diff options
| author | Dan Albert <danalbert@google.com> | 2016-02-24 13:48:45 -0800 |
|---|---|---|
| committer | Dan Albert <danalbert@google.com> | 2016-02-24 13:51:18 -0800 |
| commit | b9de1157289455b0ca26daff519d4a0ddcd1fa13 (patch) | |
| tree | 4c56cc0a34b91f17033a40a455f26652304f7b8d /gcc-4.8.1/gcc/c/c-decl.c | |
| parent | 098157a754787181cfa10e71325832448ddcea98 (diff) | |
| download | toolchain_gcc-b9de1157289455b0ca26daff519d4a0ddcd1fa13.tar.gz toolchain_gcc-b9de1157289455b0ca26daff519d4a0ddcd1fa13.tar.bz2 toolchain_gcc-b9de1157289455b0ca26daff519d4a0ddcd1fa13.zip | |
Update 4.8.1 to 4.8.3.
My previous drop was the wrong version. The platform mingw is
currently using 4.8.3, not 4.8.1 (not sure how I got that wrong).
From ftp://ftp.gnu.org/gnu/gcc/gcc-4.8.3/gcc-4.8.3.tar.bz2.
Bug: http://b/26523949
Change-Id: Id85f1bdcbbaf78c7d0b5a69e74c798a08f341c35
Diffstat (limited to 'gcc-4.8.1/gcc/c/c-decl.c')
| -rw-r--r-- | gcc-4.8.1/gcc/c/c-decl.c | 10157 |
1 files changed, 0 insertions, 10157 deletions
diff --git a/gcc-4.8.1/gcc/c/c-decl.c b/gcc-4.8.1/gcc/c/c-decl.c deleted file mode 100644 index d9bbf5c25..000000000 --- a/gcc-4.8.1/gcc/c/c-decl.c +++ /dev/null @@ -1,10157 +0,0 @@ -/* Process declarations and variables for C compiler. - Copyright (C) 1988-2013 Free Software Foundation, Inc. - -This file is part of GCC. - -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 -Software Foundation; either version 3, or (at your option) any later -version. - -GCC is distributed in the hope that it will be useful, but WITHOUT ANY -WARRANTY; without even the implied warranty of MERCHANTABILITY or -FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License -for more details. - -You should have received a copy of the GNU General Public License -along with GCC; see the file COPYING3. If not see -<http://www.gnu.org/licenses/>. */ - -/* Process declarations and symbol lookup for C front end. - Also constructs types; the standard scalar types at initialization, - and structure, union, array and enum types when they are declared. */ - -/* ??? not all decl nodes are given the most useful possible - line numbers. For example, the CONST_DECLs for enum values. */ - -#include "config.h" -#include "system.h" -#include "coretypes.h" -#include "input.h" -#include "tm.h" -#include "intl.h" -#include "tree.h" -#include "tree-inline.h" -#include "flags.h" -#include "function.h" -#include "c-tree.h" -#include "toplev.h" -#include "tm_p.h" -#include "cpplib.h" -#include "target.h" -#include "debug.h" -#include "opts.h" -#include "timevar.h" -#include "c-family/c-common.h" -#include "c-family/c-objc.h" -#include "c-family/c-pragma.h" -#include "c-lang.h" -#include "langhooks.h" -#include "tree-iterator.h" -#include "diagnostic-core.h" -#include "dumpfile.h" -#include "cgraph.h" -#include "hash-table.h" -#include "langhooks-def.h" -#include "pointer-set.h" -#include "plugin.h" -#include "c-family/c-ada-spec.h" - -/* In grokdeclarator, distinguish syntactic contexts of declarators. */ -enum decl_context -{ NORMAL, /* Ordinary declaration */ - FUNCDEF, /* Function definition */ - PARM, /* Declaration of parm before function body */ - FIELD, /* Declaration inside struct or union */ - TYPENAME}; /* Typename (inside cast or sizeof) */ - -/* States indicating how grokdeclarator() should handle declspecs marked - with __attribute__((deprecated)). An object declared as - __attribute__((deprecated)) suppresses warnings of uses of other - deprecated items. */ - -enum deprecated_states { - DEPRECATED_NORMAL, - DEPRECATED_SUPPRESS -}; - - -/* Nonzero if we have seen an invalid cross reference - to a struct, union, or enum, but not yet printed the message. */ -tree pending_invalid_xref; - -/* File and line to appear in the eventual error message. */ -location_t pending_invalid_xref_location; - -/* The file and line that the prototype came from if this is an - old-style definition; used for diagnostics in - store_parm_decls_oldstyle. */ - -static location_t current_function_prototype_locus; - -/* Whether this prototype was built-in. */ - -static bool current_function_prototype_built_in; - -/* The argument type information of this prototype. */ - -static tree current_function_prototype_arg_types; - -/* The argument information structure for the function currently being - defined. */ - -static struct c_arg_info *current_function_arg_info; - -/* The obstack on which parser and related data structures, which are - not live beyond their top-level declaration or definition, are - allocated. */ -struct obstack parser_obstack; - -/* The current statement tree. */ - -static GTY(()) struct stmt_tree_s c_stmt_tree; - -/* State saving variables. */ -tree c_break_label; -tree c_cont_label; - -/* A list of decls to be made automatically visible in each file scope. */ -static GTY(()) tree visible_builtins; - -/* Set to 0 at beginning of a function definition, set to 1 if - a return statement that specifies a return value is seen. */ - -int current_function_returns_value; - -/* Set to 0 at beginning of a function definition, set to 1 if - a return statement with no argument is seen. */ - -int current_function_returns_null; - -/* Set to 0 at beginning of a function definition, set to 1 if - a call to a noreturn function is seen. */ - -int current_function_returns_abnormally; - -/* Set to nonzero by `grokdeclarator' for a function - whose return type is defaulted, if warnings for this are desired. */ - -static int warn_about_return_type; - -/* Nonzero when the current toplevel function contains a declaration - of a nested function which is never defined. */ - -static bool undef_nested_function; - -/* Mode used to build pointers (VOIDmode means ptr_mode). */ - -enum machine_mode c_default_pointer_mode = VOIDmode; - - -/* Each c_binding structure describes one binding of an identifier to - a decl. All the decls in a scope - irrespective of namespace - are - chained together by the ->prev field, which (as the name implies) - runs in reverse order. All the decls in a given namespace bound to - a given identifier are chained by the ->shadowed field, which runs - from inner to outer scopes. - - 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 - RECORD_TYPE, UNION_TYPE, or ENUMERAL_TYPE node. If an undeclared - identifier is encountered, it is bound to error_mark_node to - suppress further errors about that identifier in the current - function. - - 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 - relevance for objects with external or internal linkage which may - be redeclared in inner scopes, forming composite types that only - persist for the duration of those scopes. In the external scope, - this stores the composite of all the types declared for this - object, visible or not. The ->inner_comp field (used only at file - scope) stores whether an incomplete array type at file scope was - 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 - which stores additional information used for warnings. - - The depth field is copied from the scope structure that holds this - decl. It is used to preserve the proper ordering of the ->shadowed - field (see bind()) and also for a handful of special-case checks. - Finally, the invisible bit is true for a decl which should be - 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; - in all such cases, the binding in the outer scope will have its - invisible bit true. */ - -struct GTY((chain_next ("%h.prev"))) c_binding { - union GTY(()) { /* first so GTY desc can use decl */ - tree GTY((tag ("0"))) type; /* the type in this scope */ - struct c_label_vars * GTY((tag ("1"))) label; /* for warnings */ - } GTY((desc ("TREE_CODE (%0.decl) == LABEL_DECL"))) u; - tree decl; /* the decl bound */ - tree id; /* the identifier it's bound to */ - struct c_binding *prev; /* the previous decl in this scope */ - struct c_binding *shadowed; /* the innermost decl shadowed by this one */ - unsigned int depth : 28; /* depth of this scope */ - BOOL_BITFIELD invisible : 1; /* normal lookup should ignore this binding */ - BOOL_BITFIELD nested : 1; /* do not set DECL_CONTEXT when popping */ - BOOL_BITFIELD inner_comp : 1; /* incomplete array completed in inner scope */ - BOOL_BITFIELD in_struct : 1; /* currently defined as struct field */ - location_t locus; /* location for nested bindings */ -}; -#define B_IN_SCOPE(b1, b2) ((b1)->depth == (b2)->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_EXTERNAL_SCOPE(b) ((b)->depth == 0 /*external_scope->depth*/) - -#define I_SYMBOL_BINDING(node) \ - (((struct lang_identifier *) IDENTIFIER_NODE_CHECK(node))->symbol_binding) -#define I_SYMBOL_DECL(node) \ - (I_SYMBOL_BINDING(node) ? I_SYMBOL_BINDING(node)->decl : 0) - -#define I_TAG_BINDING(node) \ - (((struct lang_identifier *) IDENTIFIER_NODE_CHECK(node))->tag_binding) -#define I_TAG_DECL(node) \ - (I_TAG_BINDING(node) ? I_TAG_BINDING(node)->decl : 0) - -#define I_LABEL_BINDING(node) \ - (((struct lang_identifier *) IDENTIFIER_NODE_CHECK(node))->label_binding) -#define I_LABEL_DECL(node) \ - (I_LABEL_BINDING(node) ? I_LABEL_BINDING(node)->decl : 0) - -/* Each C symbol points to three linked lists of c_binding structures. - These describe the values of the identifier in the three different - namespaces defined by the language. */ - -struct GTY(()) lang_identifier { - struct c_common_identifier common_id; - struct c_binding *symbol_binding; /* vars, funcs, constants, typedefs */ - struct c_binding *tag_binding; /* struct/union/enum tags */ - struct c_binding *label_binding; /* labels */ -}; - -/* Validate c-lang.c's assumptions. */ -extern char C_SIZEOF_STRUCT_LANG_IDENTIFIER_isnt_accurate -[(sizeof(struct lang_identifier) == C_SIZEOF_STRUCT_LANG_IDENTIFIER) ? 1 : -1]; - -/* The resulting tree type. */ - -union GTY((desc ("TREE_CODE (&%h.generic) == IDENTIFIER_NODE"), - chain_next ("(union lang_tree_node *) c_tree_chain_next (&%h.generic)"))) lang_tree_node - { - union tree_node GTY ((tag ("0"), - desc ("tree_node_structure (&%h)"))) - generic; - struct lang_identifier GTY ((tag ("1"))) identifier; -}; - -/* Track bindings and other things that matter for goto warnings. For - efficiency, we do not gather all the decls at the point of - definition. Instead, we point into the bindings structure. As - scopes are popped, we update these structures and gather the decls - that matter at that time. */ - -struct GTY(()) c_spot_bindings { - /* The currently open scope which holds bindings defined when the - label was defined or the goto statement was found. */ - struct c_scope *scope; - /* 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 - bindings in the scope, as appropriate. */ - struct c_binding *bindings_in_scope; - /* The number of statement expressions that have started since this - 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 - a statement expression started since this spot. It is negative - if this spot was in a statement expression and we have left - it. */ - int stmt_exprs; - /* Whether we started in a statement expression but are no longer in - it. This is set to true if stmt_exprs ever goes negative. */ - bool left_stmt_expr; -}; - -/* 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 before we see the label. */ - -struct GTY(()) c_goto_bindings { - /* The location of the goto statement. */ - location_t loc; - /* The bindings of the goto statement. */ - struct c_spot_bindings goto_bindings; -}; - -typedef struct c_goto_bindings *c_goto_bindings_p; - -/* The additional information we keep track of for a label binding. - These fields are updated as scopes are popped. */ - -struct GTY(()) c_label_vars { - /* The shadowed c_label_vars, when one label shadows another (which - can only happen using a __label__ declaration). */ - struct c_label_vars *shadowed; - /* The bindings when the label was defined. */ - struct c_spot_bindings label_bindings; - /* 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. - Decls are added to this list as scopes are popped. We only add - the decls that matter. */ - vec<tree, va_gc> *decls_in_scope; - /* 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 - issue appropriate warnings for them. */ - vec<c_goto_bindings_p, va_gc> *gotos; -}; - -/* Each c_scope structure describes the complete contents of one - scope. Four scopes are distinguished specially: the innermost or - current scope, the innermost function scope, the file scope (always - the second to outermost) and the outermost or external scope. - - Most declarations are recorded in the current scope. - - All normal label declarations are recorded in the innermost - function scope, as are bindings of undeclared identifiers to - error_mark_node. (GCC permits nested functions as an extension, - hence the 'innermost' qualifier.) Explicitly declared labels - (using the __label__ extension) appear in the current scope. - - Being in the file scope (current_scope == file_scope) causes - special behavior in several places below. Also, under some - conditions the Objective-C front end records declarations in the - file scope even though that isn't the current scope. - - All declarations with external linkage are recorded in the external - scope, even if they aren't visible there; this models the fact that - such declarations are visible to the entire program, and (with a - bit of cleverness, see pushdecl) allows diagnosis of some violations - of C99 6.2.2p7 and 6.2.7p2: - - If, within the same translation unit, the same identifier appears - with both internal and external linkage, the behavior is - undefined. - - All declarations that refer to the same object or function shall - have compatible type; otherwise, the behavior is undefined. - - Initially only the built-in declarations, which describe compiler - intrinsic functions plus a subset of the standard library, are in - this scope. - - 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 - 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 - list here.) - - The bindings list is strictly in reverse order of declarations; - pop_scope relies on this. */ - - -struct GTY((chain_next ("%h.outer"))) c_scope { - /* The scope containing this one. */ - struct c_scope *outer; - - /* The next outermost function scope. */ - struct c_scope *outer_function; - - /* All bindings in this scope. */ - struct c_binding *bindings; - - /* For each scope (except the global one), a chain of BLOCK nodes - for all the scopes that were entered and exited one level down. */ - tree blocks; - tree blocks_last; - - /* The depth of this scope. Used to keep the ->shadowed chain of - bindings sorted innermost to outermost. */ - unsigned int depth : 28; - - /* True if we are currently filling this scope with parameter - declarations. */ - BOOL_BITFIELD parm_flag : 1; - - /* True if we saw [*] in this scope. Used to give an error messages - if these appears in a function definition. */ - BOOL_BITFIELD had_vla_unspec : 1; - - /* True if we already complained about forward parameter decls - in this scope. This prevents double warnings on - foo (int a; int b; ...) */ - BOOL_BITFIELD warned_forward_parm_decls : 1; - - /* True if this is the outermost block scope of a function body. - This scope contains the parameters, the local variables declared - in the outermost block, and all the labels (except those in - nested functions, or declared at block scope with __label__). */ - BOOL_BITFIELD function_body : 1; - - /* True means make a BLOCK for this scope no matter what. */ - BOOL_BITFIELD keep : 1; - - /* True means that an unsuffixed float constant is _Decimal64. */ - BOOL_BITFIELD float_const_decimal64 : 1; - - /* True if this scope has any label bindings. This is used to speed - up searching for labels when popping scopes, particularly since - labels are normally only found at function scope. */ - BOOL_BITFIELD has_label_bindings : 1; - - /* True if we should issue a warning if a goto statement crosses any - of the bindings. We still need to check the list of bindings to - find the specific ones we need to warn about. This is true if - decl_jump_unsafe would return true for any of the bindings. This - is used to avoid looping over all the bindings unnecessarily. */ - BOOL_BITFIELD has_jump_unsafe_decl : 1; -}; - -/* The scope currently in effect. */ - -static GTY(()) struct c_scope *current_scope; - -/* The innermost function scope. Ordinary (not explicitly declared) - labels, bindings to error_mark_node, and the lazily-created - bindings of __func__ and its friends get this scope. */ - -static GTY(()) struct c_scope *current_function_scope; - -/* The C file scope. This is reset for each input translation unit. */ - -static GTY(()) struct c_scope *file_scope; - -/* The outermost scope. This is used for all declarations with - external linkage, and only these, hence the name. */ - -static GTY(()) struct c_scope *external_scope; - -/* A chain of c_scope structures awaiting reuse. */ - -static GTY((deletable)) struct c_scope *scope_freelist; - -/* A chain of c_binding structures awaiting reuse. */ - -static GTY((deletable)) struct c_binding *binding_freelist; - -/* Append VAR to LIST in scope SCOPE. */ -#define SCOPE_LIST_APPEND(scope, list, decl) do { \ - struct c_scope *s_ = (scope); \ - tree d_ = (decl); \ - if (s_->list##_last) \ - BLOCK_CHAIN (s_->list##_last) = d_; \ - else \ - s_->list = d_; \ - s_->list##_last = d_; \ -} while (0) - -/* Concatenate FROM in scope FSCOPE onto TO in scope TSCOPE. */ -#define SCOPE_LIST_CONCAT(tscope, to, fscope, from) do { \ - struct c_scope *t_ = (tscope); \ - struct c_scope *f_ = (fscope); \ - if (t_->to##_last) \ - BLOCK_CHAIN (t_->to##_last) = f_->from; \ - else \ - t_->to = f_->from; \ - t_->to##_last = f_->from##_last; \ -} while (0) - -/* A c_inline_static structure stores details of a static identifier - referenced in a definition of a function that may be an inline - definition if no subsequent declaration of that function uses - "extern" or does not use "inline". */ - -struct GTY((chain_next ("%h.next"))) c_inline_static { - /* The location for a diagnostic. */ - location_t location; - - /* The function that may be an inline definition. */ - tree function; - - /* The object or function referenced. */ - tree static_decl; - - /* What sort of reference this is. */ - enum c_inline_static_type type; - - /* The next such structure or NULL. */ - struct c_inline_static *next; -}; - -/* List of static identifiers used or referenced in functions that may - be inline definitions. */ -static GTY(()) struct c_inline_static *c_inline_statics; - -/* True means unconditionally make a BLOCK for the next scope pushed. */ - -static bool keep_next_level_flag; - -/* 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 - expecting parameter decls. */ - -static bool next_is_function_body; - -/* A vector of pointers to c_binding structures. */ - -typedef struct c_binding *c_binding_ptr; - -/* Information that we keep for a struct or union while it is being - parsed. */ - -struct c_struct_parse_info -{ - /* If warn_cxx_compat, a list of types defined within this - struct. */ - vec<tree> struct_types; - /* If warn_cxx_compat, a list of field names which have bindings, - and which are defined in this struct, but which are not defined - in any enclosing struct. This is used to clear the in_struct - field of the c_bindings structure. */ - vec<c_binding_ptr> fields; - /* If warn_cxx_compat, a list of typedef names used when defining - fields in this struct. */ - vec<tree> typedefs_seen; -}; - -/* Information for the struct or union currently being parsed, or - NULL if not parsing a struct or union. */ -static struct c_struct_parse_info *struct_parse_info; - -/* Forward declarations. */ -static tree lookup_name_in_scope (tree, struct c_scope *); -static tree c_make_fname_decl (location_t, tree, int); -static tree grokdeclarator (const struct c_declarator *, - struct c_declspecs *, - enum decl_context, bool, tree *, tree *, tree *, - bool *, enum deprecated_states); -static tree grokparms (struct c_arg_info *, bool); -static void layout_array_type (tree); - -/* T is a statement. Add it to the statement-tree. This is the - C/ObjC version--C++ has a slightly different version of this - function. */ - -tree -add_stmt (tree t) -{ - enum tree_code code = TREE_CODE (t); - - if (CAN_HAVE_LOCATION_P (t) && code != LABEL_EXPR) - { - if (!EXPR_HAS_LOCATION (t)) - SET_EXPR_LOCATION (t, input_location); - } - - if (code == LABEL_EXPR || code == CASE_LABEL_EXPR) - STATEMENT_LIST_HAS_LABEL (cur_stmt_list) = 1; - - /* Add T to the statement-tree. Non-side-effect statements need to be - recorded during statement expressions. */ - if (!building_stmt_list_p ()) - push_stmt_list (); - append_to_statement_list_force (t, &cur_stmt_list); - - return t; -} - -/* Build a pointer type using the default pointer mode. */ - -static tree -c_build_pointer_type (tree to_type) -{ - addr_space_t as = to_type == error_mark_node? ADDR_SPACE_GENERIC - : TYPE_ADDR_SPACE (to_type); - enum machine_mode pointer_mode; - - if (as != ADDR_SPACE_GENERIC || c_default_pointer_mode == VOIDmode) - pointer_mode = targetm.addr_space.pointer_mode (as); - else - pointer_mode = c_default_pointer_mode; - return build_pointer_type_for_mode (to_type, pointer_mode, false); -} - - -/* Return true if we will want to say something if a goto statement - crosses DECL. */ - -static bool -decl_jump_unsafe (tree decl) -{ - if (error_operand_p (decl)) - return false; - - /* Always warn about crossing variably modified types. */ - if ((TREE_CODE (decl) == VAR_DECL || TREE_CODE (decl) == TYPE_DECL) - && variably_modified_type_p (TREE_TYPE (decl), NULL_TREE)) - return true; - - /* Otherwise, only warn if -Wgoto-misses-init and this is an - initialized automatic decl. */ - if (warn_jump_misses_init - && TREE_CODE (decl) == VAR_DECL - && !TREE_STATIC (decl) - && DECL_INITIAL (decl) != NULL_TREE) - return true; - - return false; -} - - -void -c_print_identifier (FILE *file, tree node, int indent) -{ - print_node (file, "symbol", I_SYMBOL_DECL (node), indent + 4); - print_node (file, "tag", I_TAG_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) - { - tree rid = ridpointers[C_RID_CODE (node)]; - indent_to (file, indent + 4); - fprintf (file, "rid " HOST_PTR_PRINTF " \"%s\"", - (void *) rid, IDENTIFIER_POINTER (rid)); - } -} - -/* 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, - in the scope SCOPE. */ -static void -bind (tree name, tree decl, struct c_scope *scope, bool invisible, - bool nested, location_t locus) -{ - struct c_binding *b, **here; - - if (binding_freelist) - { - b = binding_freelist; - binding_freelist = b->prev; - } - else - b = ggc_alloc_c_binding (); - - b->shadowed = 0; - b->decl = decl; - b->id = name; - b->depth = scope->depth; - b->invisible = invisible; - b->nested = nested; - b->inner_comp = 0; - b->in_struct = 0; - b->locus = locus; - - b->u.type = NULL; - - b->prev = scope->bindings; - scope->bindings = b; - - if (decl_jump_unsafe (decl)) - scope->has_jump_unsafe_decl = 1; - - if (!name) - return; - - switch (TREE_CODE (decl)) - { - case LABEL_DECL: here = &I_LABEL_BINDING (name); break; - case ENUMERAL_TYPE: - case UNION_TYPE: - case RECORD_TYPE: here = &I_TAG_BINDING (name); break; - case VAR_DECL: - case FUNCTION_DECL: - case TYPE_DECL: - case CONST_DECL: - case PARM_DECL: - case ERROR_MARK: here = &I_SYMBOL_BINDING (name); break; - - default: - gcc_unreachable (); - } - - /* Locate the appropriate place in the chain of shadowed decls - to insert this binding. Normally, scope == current_scope and - this does nothing. */ - while (*here && (*here)->depth > scope->depth) - here = &(*here)->shadowed; - - b->shadowed = *here; - *here = b; -} - -/* 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 get_parm_info to iterate destructively over all the bindings - from a given scope. */ -static struct c_binding * -free_binding_and_advance (struct c_binding *b) -{ - struct c_binding *prev = b->prev; - - memset (b, 0, sizeof (struct c_binding)); - b->prev = binding_freelist; - binding_freelist = b; - - return prev; -} - -/* Bind a label. Like bind, but skip fields which aren't used for - labels, and add the LABEL_VARS value. */ -static void -bind_label (tree name, tree label, struct c_scope *scope, - struct c_label_vars *label_vars) -{ - struct c_binding *b; - - bind (name, label, scope, /*invisible=*/false, /*nested=*/false, - UNKNOWN_LOCATION); - - scope->has_label_bindings = true; - - b = scope->bindings; - gcc_assert (b->decl == label); - label_vars->shadowed = b->u.label; - b->u.label = label_vars; -} - -/* Hook called at end of compilation to assume 1 elt - for a file-scope tentative array defn that wasn't complete before. */ - -void -c_finish_incomplete_decl (tree decl) -{ - if (TREE_CODE (decl) == VAR_DECL) - { - tree type = TREE_TYPE (decl); - if (type != error_mark_node - && TREE_CODE (type) == ARRAY_TYPE - && !DECL_EXTERNAL (decl) - && TYPE_DOMAIN (type) == 0) - { - warning_at (DECL_SOURCE_LOCATION (decl), - 0, "array %q+D assumed to have one element", decl); - - complete_array_type (&TREE_TYPE (decl), NULL_TREE, true); - - relayout_decl (decl); - } - } -} - -/* Record that inline function FUNC contains a reference (location - LOC) to static DECL (file-scope or function-local according to - TYPE). */ - -void -record_inline_static (location_t loc, tree func, tree decl, - enum c_inline_static_type type) -{ - struct c_inline_static *csi = ggc_alloc_c_inline_static (); - csi->location = loc; - csi->function = func; - csi->static_decl = decl; - csi->type = type; - csi->next = c_inline_statics; - c_inline_statics = csi; -} - -/* Check for references to static declarations in inline functions at - the end of the translation unit and diagnose them if the functions - are still inline definitions. */ - -static void -check_inline_statics (void) -{ - struct c_inline_static *csi; - for (csi = c_inline_statics; csi; csi = csi->next) - { - if (DECL_EXTERNAL (csi->function)) - switch (csi->type) - { - case csi_internal: - pedwarn (csi->location, 0, - "%qD is static but used in inline function %qD " - "which is not static", csi->static_decl, csi->function); - break; - case csi_modifiable: - pedwarn (csi->location, 0, - "%q+D is static but declared in inline function %qD " - "which is not static", csi->static_decl, csi->function); - break; - default: - gcc_unreachable (); - } - } - c_inline_statics = NULL; -} - -/* Fill in a c_spot_bindings structure. If DEFINING is true, set it - for the current state, otherwise set it to uninitialized. */ - -static void -set_spot_bindings (struct c_spot_bindings *p, bool defining) -{ - if (defining) - { - p->scope = current_scope; - p->bindings_in_scope = current_scope->bindings; - } - else - { - p->scope = NULL; - p->bindings_in_scope = NULL; - } - p->stmt_exprs = 0; - p->left_stmt_expr = false; -} - -/* Update spot bindings P as we pop out of SCOPE. Return true if we - should push decls for a label. */ - -static bool -update_spot_bindings (struct c_scope *scope, struct c_spot_bindings *p) -{ - if (p->scope != scope) - { - /* This label or goto is defined in some other scope, or it is a - label which is not yet defined. There is nothing to - update. */ - return false; - } - - /* Adjust the spot bindings to refer to the bindings already defined - in the enclosing scope. */ - p->scope = scope->outer; - p->bindings_in_scope = p->scope->bindings; - - return true; -} - -/* The Objective-C front-end often needs to determine the current scope. */ - -void * -objc_get_current_scope (void) -{ - return current_scope; -} - -/* The following function is used only by Objective-C. It needs to live here - because it accesses the innards of c_scope. */ - -void -objc_mark_locals_volatile (void *enclosing_blk) -{ - struct c_scope *scope; - struct c_binding *b; - - for (scope = current_scope; - scope && scope != enclosing_blk; - scope = scope->outer) - { - for (b = scope->bindings; b; b = b->prev) - objc_volatilize_decl (b->decl); - - /* Do not climb up past the current function. */ - if (scope->function_body) - break; - } -} - -/* Return true if we are in the global binding level. */ - -bool -global_bindings_p (void) -{ - return current_scope == file_scope; -} - -void -keep_next_level (void) -{ - keep_next_level_flag = true; -} - -/* Set the flag for the FLOAT_CONST_DECIMAL64 pragma being ON. */ - -void -set_float_const_decimal64 (void) -{ - current_scope->float_const_decimal64 = true; -} - -/* Clear the flag for the FLOAT_CONST_DECIMAL64 pragma. */ - -void -clear_float_const_decimal64 (void) -{ - current_scope->float_const_decimal64 = false; -} - -/* Return nonzero if an unsuffixed float constant is _Decimal64. */ - -bool -float_const_decimal64_p (void) -{ - return current_scope->float_const_decimal64; -} - -/* Identify this scope as currently being filled with parameters. */ - -void -declare_parm_level (void) -{ - current_scope->parm_flag = true; -} - -void -push_scope (void) -{ - if (next_is_function_body) - { - /* This is the transition from the parameters to the top level - of the function body. These are the same scope - (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 - in turn is called when and only when we are about to - encounter the opening curly brace for the function body. - - The outermost block of a function always gets a BLOCK node, - because the debugging output routines expect that each - function has at least one BLOCK. */ - current_scope->parm_flag = false; - current_scope->function_body = true; - current_scope->keep = true; - current_scope->outer_function = current_function_scope; - current_function_scope = current_scope; - - keep_next_level_flag = false; - next_is_function_body = false; - - /* The FLOAT_CONST_DECIMAL64 pragma applies to nested scopes. */ - if (current_scope->outer) - current_scope->float_const_decimal64 - = current_scope->outer->float_const_decimal64; - else - current_scope->float_const_decimal64 = false; - } - else - { - struct c_scope *scope; - if (scope_freelist) - { - scope = scope_freelist; - scope_freelist = scope->outer; - } - else - scope = ggc_alloc_cleared_c_scope (); - - /* The FLOAT_CONST_DECIMAL64 pragma applies to nested scopes. */ - if (current_scope) - scope->float_const_decimal64 = current_scope->float_const_decimal64; - else - scope->float_const_decimal64 = false; - - scope->keep = keep_next_level_flag; - scope->outer = current_scope; - scope->depth = current_scope ? (current_scope->depth + 1) : 0; - - /* Check for scope depth overflow. Unlikely (2^28 == 268,435,456) but - possible. */ - if (current_scope && scope->depth == 0) - { - scope->depth--; - sorry ("GCC supports only %u nested scopes", scope->depth); - } - - current_scope = scope; - keep_next_level_flag = false; - } -} - -/* This is called when we are leaving SCOPE. For each label defined - in SCOPE, add any appropriate decls to its decls_in_scope fields. - These are the decls whose initialization will be skipped by a goto - later in the function. */ - -static void -update_label_decls (struct c_scope *scope) -{ - struct c_scope *s; - - s = scope; - while (s != NULL) - { - if (s->has_label_bindings) - { - struct c_binding *b; - - for (b = s->bindings; b != NULL; b = b->prev) - { - struct c_label_vars *label_vars; - struct c_binding *b1; - bool hjud; - unsigned int ix; - struct c_goto_bindings *g; - - if (TREE_CODE (b->decl) != LABEL_DECL) - continue; - label_vars = b->u.label; - - b1 = label_vars->label_bindings.bindings_in_scope; - if (label_vars->label_bindings.scope == NULL) - hjud = false; - else - hjud = label_vars->label_bindings.scope->has_jump_unsafe_decl; - if (update_spot_bindings (scope, &label_vars->label_bindings)) - { - /* This label is defined in this scope. */ - if (hjud) - { - for (; b1 != NULL; b1 = b1->prev) - { - /* A goto from later in the function to this - label will never see the initialization - of B1, if any. Save it to issue a - warning if needed. */ - if (decl_jump_unsafe (b1->decl)) - vec_safe_push(label_vars->decls_in_scope, b1->decl); - } - } - } - - /* Update the bindings of any goto statements associated - with this label. */ - FOR_EACH_VEC_SAFE_ELT (label_vars->gotos, ix, g) - update_spot_bindings (scope, &g->goto_bindings); - } - } - - /* Don't search beyond the current function. */ - if (s == current_function_scope) - break; - - s = s->outer; - } -} - -/* Set the TYPE_CONTEXT of all of TYPE's variants to CONTEXT. */ - -static void -set_type_context (tree type, tree context) -{ - for (type = TYPE_MAIN_VARIANT (type); type; - type = TYPE_NEXT_VARIANT (type)) - TYPE_CONTEXT (type) = context; -} - -/* Exit a scope. Restore the state of the identifier-decl mappings - that were in effect when this scope was entered. Return a BLOCK - node containing all the DECLs in this scope that are of interest - to debug info generation. */ - -tree -pop_scope (void) -{ - struct c_scope *scope = current_scope; - tree block, context, p; - struct c_binding *b; - - bool functionbody = scope->function_body; - bool keep = functionbody || scope->keep || scope->bindings; - - update_label_decls (scope); - - /* If appropriate, create a BLOCK to record the decls for the life - of this function. */ - block = 0; - if (keep) - { - block = make_node (BLOCK); - BLOCK_SUBBLOCKS (block) = scope->blocks; - TREE_USED (block) = 1; - - /* In each subblock, record that this is its superior. */ - for (p = scope->blocks; p; p = BLOCK_CHAIN (p)) - BLOCK_SUPERCONTEXT (p) = block; - - BLOCK_VARS (block) = 0; - } - - /* The TYPE_CONTEXTs for all of the tagged types belonging to this - scope must be set so that they point to the appropriate - construct, i.e. either to the current FUNCTION_DECL node, or - else to the BLOCK node we just constructed. - - Note that for tagged types whose scope is just the formal - parameter list for some function type specification, we can't - properly set their TYPE_CONTEXTs here, because we don't have a - pointer to the appropriate FUNCTION_TYPE node readily available - to us. For those cases, the TYPE_CONTEXTs of the relevant tagged - type nodes get set in `grokdeclarator' as soon as we have created - the FUNCTION_TYPE node which will represent the "scope" for these - "parameter list local" tagged types. */ - if (scope->function_body) - context = current_function_decl; - else if (scope == file_scope) - { - tree file_decl = build_translation_unit_decl (NULL_TREE); - context = file_decl; - } - else - context = block; - - /* Clear all bindings in this scope. */ - for (b = scope->bindings; b; b = free_binding_and_advance (b)) - { - p = b->decl; - switch (TREE_CODE (p)) - { - case LABEL_DECL: - /* Warnings for unused labels, errors for undefined labels. */ - if (TREE_USED (p) && !DECL_INITIAL (p)) - { - error ("label %q+D used but not defined", p); - DECL_INITIAL (p) = error_mark_node; - } - else - warn_for_unused_label (p); - - /* Labels go in BLOCK_VARS. */ - DECL_CHAIN (p) = BLOCK_VARS (block); - BLOCK_VARS (block) = p; - gcc_assert (I_LABEL_BINDING (b->id) == b); - I_LABEL_BINDING (b->id) = b->shadowed; - - /* Also pop back to the shadowed label_vars. */ - release_tree_vector (b->u.label->decls_in_scope); - b->u.label = b->u.label->shadowed; - break; - - case ENUMERAL_TYPE: - case UNION_TYPE: - case RECORD_TYPE: - set_type_context (p, context); - - /* Types may not have tag-names, in which case the type - appears in the bindings list with b->id NULL. */ - if (b->id) - { - gcc_assert (I_TAG_BINDING (b->id) == b); - I_TAG_BINDING (b->id) = b->shadowed; - } - break; - - case FUNCTION_DECL: - /* Propagate TREE_ADDRESSABLE from nested functions to their - containing functions. */ - if (!TREE_ASM_WRITTEN (p) - && DECL_INITIAL (p) != 0 - && TREE_ADDRESSABLE (p) - && DECL_ABSTRACT_ORIGIN (p) != 0 - && DECL_ABSTRACT_ORIGIN (p) != p) - TREE_ADDRESSABLE (DECL_ABSTRACT_ORIGIN (p)) = 1; - if (!DECL_EXTERNAL (p) - && !DECL_INITIAL (p) - && scope != file_scope - && scope != external_scope) - { - error ("nested function %q+D declared but never defined", p); - undef_nested_function = true; - } - else if (DECL_DECLARED_INLINE_P (p) - && TREE_PUBLIC (p) - && !DECL_INITIAL (p)) - { - /* C99 6.7.4p6: "a function with external linkage... declared - with an inline function specifier ... shall also be defined - in the same translation unit." */ - if (!flag_gnu89_inline) - pedwarn (input_location, 0, - "inline function %q+D declared but never defined", p); - DECL_EXTERNAL (p) = 1; - } - - goto common_symbol; - - case VAR_DECL: - /* Warnings for unused variables. */ - if ((!TREE_USED (p) || !DECL_READ_P (p)) - && !TREE_NO_WARNING (p) - && !DECL_IN_SYSTEM_HEADER (p) - && DECL_NAME (p) - && !DECL_ARTIFICIAL (p) - && scope != file_scope - && scope != external_scope) - { - if (!TREE_USED (p)) - warning (OPT_Wunused_variable, "unused variable %q+D", p); - else if (DECL_CONTEXT (p) == current_function_decl) - warning_at (DECL_SOURCE_LOCATION (p), - OPT_Wunused_but_set_variable, - "variable %qD set but not used", p); - } - - if (b->inner_comp) - { - error ("type of array %q+D completed incompatibly with" - " implicit initialization", p); - } - - /* Fall through. */ - case TYPE_DECL: - case CONST_DECL: - common_symbol: - /* All of these go in BLOCK_VARS, but only if this is the - binding in the home scope. */ - if (!b->nested) - { - DECL_CHAIN (p) = BLOCK_VARS (block); - BLOCK_VARS (block) = p; - } - else if (VAR_OR_FUNCTION_DECL_P (p) && scope != file_scope) - { - /* For block local externs add a special - DECL_EXTERNAL decl for debug info generation. */ - tree extp = copy_node (p); - - DECL_EXTERNAL (extp) = 1; - TREE_STATIC (extp) = 0; - TREE_PUBLIC (extp) = 1; - DECL_INITIAL (extp) = NULL_TREE; - DECL_LANG_SPECIFIC (extp) = NULL; - DECL_CONTEXT (extp) = current_function_decl; - if (TREE_CODE (p) == FUNCTION_DECL) - { - DECL_RESULT (extp) = NULL_TREE; - DECL_SAVED_TREE (extp) = NULL_TREE; - DECL_STRUCT_FUNCTION (extp) = NULL; - } - if (b->locus != UNKNOWN_LOCATION) - DECL_SOURCE_LOCATION (extp) = b->locus; - DECL_CHAIN (extp) = BLOCK_VARS (block); - BLOCK_VARS (block) = extp; - } - /* If this is the file scope set DECL_CONTEXT of each decl to - the TRANSLATION_UNIT_DECL. This makes same_translation_unit_p - work. */ - if (scope == file_scope) - { - DECL_CONTEXT (p) = context; - if (TREE_CODE (p) == TYPE_DECL - && TREE_TYPE (p) != error_mark_node) - set_type_context (TREE_TYPE (p), context); - } - - /* Fall through. */ - /* Parameters go in DECL_ARGUMENTS, not BLOCK_VARS, and have - already been put there by store_parm_decls. Unused- - parameter warnings are handled by function.c. - error_mark_node obviously does not go in BLOCK_VARS and - does not get unused-variable warnings. */ - case PARM_DECL: - case ERROR_MARK: - /* It is possible for a decl not to have a name. We get - here with b->id NULL in this case. */ - if (b->id) - { - gcc_assert (I_SYMBOL_BINDING (b->id) == b); - I_SYMBOL_BINDING (b->id) = b->shadowed; - if (b->shadowed && b->shadowed->u.type) - TREE_TYPE (b->shadowed->decl) = b->shadowed->u.type; - } - break; - - default: - gcc_unreachable (); - } - } - - - /* Dispose of the block that we just made inside some higher level. */ - if ((scope->function_body || scope == file_scope) && context) - { - DECL_INITIAL (context) = block; - BLOCK_SUPERCONTEXT (block) = context; - } - else if (scope->outer) - { - if (block) - SCOPE_LIST_APPEND (scope->outer, blocks, block); - /* If we did not make a block for the scope just exited, any - blocks made for inner scopes must be carried forward so they - will later become subblocks of something else. */ - else if (scope->blocks) - SCOPE_LIST_CONCAT (scope->outer, blocks, scope, blocks); - } - - /* Pop the current scope, and free the structure for reuse. */ - current_scope = scope->outer; - if (scope->function_body) - current_function_scope = scope->outer_function; - - memset (scope, 0, sizeof (struct c_scope)); - scope->outer = scope_freelist; - scope_freelist = scope; - - return block; -} - -void -push_file_scope (void) -{ - tree decl; - - if (file_scope) - return; - - push_scope (); - file_scope = current_scope; - - start_fname_decls (); - - for (decl = visible_builtins; decl; decl = DECL_CHAIN (decl)) - bind (DECL_NAME (decl), decl, file_scope, - /*invisible=*/false, /*nested=*/true, DECL_SOURCE_LOCATION (decl)); -} - -void -pop_file_scope (void) -{ - /* In case there were missing closebraces, get us back to the global - binding level. */ - while (current_scope != file_scope) - pop_scope (); - - /* __FUNCTION__ is defined at file scope (""). This - call may not be necessary as my tests indicate it - still works without it. */ - finish_fname_decls (); - - check_inline_statics (); - - /* 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. */ - if (pch_file) - { - c_common_write_pch (); - return; - } - - /* Pop off the file scope and close this translation unit. */ - pop_scope (); - file_scope = 0; - - maybe_apply_pending_pragma_weaks (); -} - -/* Adjust the bindings for the start of a statement expression. */ - -void -c_bindings_start_stmt_expr (struct c_spot_bindings* switch_bindings) -{ - struct c_scope *scope; - - for (scope = current_scope; scope != NULL; scope = scope->outer) - { - struct c_binding *b; - - if (!scope->has_label_bindings) - continue; - - for (b = scope->bindings; b != NULL; b = b->prev) - { - struct c_label_vars *label_vars; - unsigned int ix; - struct c_goto_bindings *g; - - if (TREE_CODE (b->decl) != LABEL_DECL) - continue; - label_vars = b->u.label; - ++label_vars->label_bindings.stmt_exprs; - FOR_EACH_VEC_SAFE_ELT (label_vars->gotos, ix, g) - ++g->goto_bindings.stmt_exprs; - } - } - - if (switch_bindings != NULL) - ++switch_bindings->stmt_exprs; -} - -/* Adjust the bindings for the end of a statement expression. */ - -void -c_bindings_end_stmt_expr (struct c_spot_bindings *switch_bindings) -{ - struct c_scope *scope; - - for (scope = current_scope; scope != NULL; scope = scope->outer) - { - struct c_binding *b; - - if (!scope->has_label_bindings) - continue; - - for (b = scope->bindings; b != NULL; b = b->prev) - { - struct c_label_vars *label_vars; - unsigned int ix; - struct c_goto_bindings *g; - - if (TREE_CODE (b->decl) != LABEL_DECL) - continue; - label_vars = b->u.label; - --label_vars->label_bindings.stmt_exprs; - if (label_vars->label_bindings.stmt_exprs < 0) - { - label_vars->label_bindings.left_stmt_expr = true; - label_vars->label_bindings.stmt_exprs = 0; - } - FOR_EACH_VEC_SAFE_ELT (label_vars->gotos, ix, g) - { - --g->goto_bindings.stmt_exprs; - if (g->goto_bindings.stmt_exprs < 0) - { - g->goto_bindings.left_stmt_expr = true; - g->goto_bindings.stmt_exprs = 0; - } - } - } - } - - if (switch_bindings != NULL) - { - --switch_bindings->stmt_exprs; - gcc_assert (switch_bindings->stmt_exprs >= 0); - } -} - -/* Push a definition or a declaration of struct, union or enum tag "name". - "type" should be the type node. - We assume that the tag "name" is not already defined, and has a location - of LOC. - - Note that the definition may really be just a forward reference. - In that case, the TYPE_SIZE will be zero. */ - -static void -pushtag (location_t loc, tree name, tree type) -{ - /* Record the identifier as the type's name if it has none. */ - if (name && !TYPE_NAME (type)) - TYPE_NAME (type) = name; - bind (name, type, current_scope, /*invisible=*/false, /*nested=*/false, loc); - - /* 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 - 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 - us a convenient place to record the "scope start" address for the - tagged type. */ - - TYPE_STUB_DECL (type) = pushdecl (build_decl (loc, - TYPE_DECL, NULL_TREE, type)); - - /* An approximation for now, so we can tell this is a function-scope tag. - This will be updated in pop_scope. */ - TYPE_CONTEXT (type) = DECL_CONTEXT (TYPE_STUB_DECL (type)); - - if (warn_cxx_compat && name != NULL_TREE) - { - struct c_binding *b = I_SYMBOL_BINDING (name); - - if (b != NULL - && b->decl != NULL_TREE - && TREE_CODE (b->decl) == TYPE_DECL - && (B_IN_CURRENT_SCOPE (b) - || (current_scope == file_scope && B_IN_EXTERNAL_SCOPE (b))) - && (TYPE_MAIN_VARIANT (TREE_TYPE (b->decl)) - != TYPE_MAIN_VARIANT (type))) - { - warning_at (loc, OPT_Wc___compat, - ("using %qD as both a typedef and a tag is " - "invalid in C++"), - b->decl); - if (b->locus != UNKNOWN_LOCATION) - inform (b->locus, "originally defined here"); - } - } -} - -/* Subroutine of compare_decls. Allow harmless mismatches in return - and argument types provided that the type modes match. This function - return a unified type given a suitable match, and 0 otherwise. */ - -static tree -match_builtin_function_types (tree newtype, tree oldtype) -{ - tree newrettype, oldrettype; - tree newargs, oldargs; - tree trytype, tryargs; - - /* Accept the return type of the new declaration if same modes. */ - oldrettype = TREE_TYPE (oldtype); - newrettype = TREE_TYPE (newtype); - - if (TYPE_MODE (oldrettype) != TYPE_MODE (newrettype)) - return 0; - - oldargs = TYPE_ARG_TYPES (oldtype); - newargs = TYPE_ARG_TYPES (newtype); - tryargs = newargs; - - while (oldargs || newargs) - { - if (!oldargs - || !newargs - || !TREE_VALUE (oldargs) - || !TREE_VALUE (newargs) - || TYPE_MODE (TREE_VALUE (oldargs)) - != TYPE_MODE (TREE_VALUE (newargs))) - return 0; - - oldargs = TREE_CHAIN (oldargs); - newargs = TREE_CHAIN (newargs); - } - - trytype = build_function_type (newrettype, tryargs); - return build_type_attribute_variant (trytype, TYPE_ATTRIBUTES (oldtype)); -} - -/* Subroutine of diagnose_mismatched_decls. Check for function type - mismatch involving an empty arglist vs a nonempty one and give clearer - diagnostics. */ -static void -diagnose_arglist_conflict (tree newdecl, tree olddecl, - tree newtype, tree oldtype) -{ - tree t; - - if (TREE_CODE (olddecl) != FUNCTION_DECL - || !comptypes (TREE_TYPE (oldtype), TREE_TYPE (newtype)) - || !((!prototype_p (oldtype) && DECL_INITIAL (olddecl) == 0) - || (!prototype_p (newtype) && DECL_INITIAL (newdecl) == 0))) - return; - - t = TYPE_ARG_TYPES (oldtype); - if (t == 0) - t = TYPE_ARG_TYPES (newtype); - for (; t; t = TREE_CHAIN (t)) - { - tree type = TREE_VALUE (t); - - if (TREE_CHAIN (t) == 0 - && TYPE_MAIN_VARIANT (type) != void_type_node) - { - inform (input_location, "a parameter list with an ellipsis can%'t match " - "an empty parameter name list declaration"); - break; - } - - if (c_type_promotes_to (type) != type) - { - inform (input_location, "an argument type that has a default promotion can%'t match " - "an empty parameter name list declaration"); - break; - } - } -} - -/* Another subroutine of diagnose_mismatched_decls. OLDDECL is an - old-style function definition, NEWDECL is a prototype declaration. - Diagnose inconsistencies in the argument list. Returns TRUE if - the prototype is compatible, FALSE if not. */ -static bool -validate_proto_after_old_defn (tree newdecl, tree newtype, tree oldtype) -{ - tree newargs, oldargs; - int i; - -#define END_OF_ARGLIST(t) ((t) == void_type_node) - - oldargs = TYPE_ACTUAL_ARG_TYPES (oldtype); - newargs = TYPE_ARG_TYPES (newtype); - i = 1; - - for (;;) - { - tree oldargtype = TREE_VALUE (oldargs); - tree newargtype = TREE_VALUE (newargs); - - if (oldargtype == error_mark_node || newargtype == error_mark_node) - return false; - - oldargtype = TYPE_MAIN_VARIANT (oldargtype); - newargtype = TYPE_MAIN_VARIANT (newargtype); - - if (END_OF_ARGLIST (oldargtype) && END_OF_ARGLIST (newargtype)) - break; - - /* Reaching the end of just one list means the two decls don't - agree on the number of arguments. */ - if (END_OF_ARGLIST (oldargtype)) - { - error ("prototype for %q+D declares more arguments " - "than previous old-style definition", newdecl); - return false; - } - else if (END_OF_ARGLIST (newargtype)) - { - error ("prototype for %q+D declares fewer arguments " - "than previous old-style definition", newdecl); - return false; - } - - /* Type for passing arg must be consistent with that declared - for the arg. */ - else if (!comptypes (oldargtype, newargtype)) - { - error ("prototype for %q+D declares argument %d" - " with incompatible type", - newdecl, i); - return false; - } - - oldargs = TREE_CHAIN (oldargs); - newargs = TREE_CHAIN (newargs); - i++; - } - - /* If we get here, no errors were found, but do issue a warning - for this poor-style construct. */ - warning (0, "prototype for %q+D follows non-prototype definition", - newdecl); - return true; -#undef END_OF_ARGLIST -} - -/* Subroutine of diagnose_mismatched_decls. Report the location of DECL, - first in a pair of mismatched declarations, using the diagnostic - function DIAG. */ -static void -locate_old_decl (tree decl) -{ - if (TREE_CODE (decl) == FUNCTION_DECL && DECL_BUILT_IN (decl)) - ; - else if (DECL_INITIAL (decl)) - inform (input_location, "previous definition of %q+D was here", decl); - else if (C_DECL_IMPLICIT (decl)) - inform (input_location, "previous implicit declaration of %q+D was here", decl); - else - inform (input_location, "previous declaration of %q+D was here", decl); -} - -/* Subroutine of duplicate_decls. Compare NEWDECL to OLDDECL. - Returns true if the caller should proceed to merge the two, false - if OLDDECL should simply be discarded. As a side effect, issues - all necessary diagnostics for invalid or poor-style combinations. - If it returns true, writes the types of NEWDECL and OLDDECL to - *NEWTYPEP and *OLDTYPEP - these may have been adjusted from - TREE_TYPE (NEWDECL, OLDDECL) respectively. */ - -static bool -diagnose_mismatched_decls (tree newdecl, tree olddecl, - tree *newtypep, tree *oldtypep) -{ - tree newtype, oldtype; - bool pedwarned = false; - bool warned = false; - bool retval = true; - -#define DECL_EXTERN_INLINE(DECL) (DECL_DECLARED_INLINE_P (DECL) \ - && DECL_EXTERNAL (DECL)) - - /* If we have error_mark_node for either decl or type, just discard - the previous decl - we're in an error cascade already. */ - if (olddecl == error_mark_node || newdecl == error_mark_node) - return false; - *oldtypep = oldtype = TREE_TYPE (olddecl); - *newtypep = newtype = TREE_TYPE (newdecl); - if (oldtype == error_mark_node || newtype == error_mark_node) - return false; - - /* Two different categories of symbol altogether. This is an error - unless OLDDECL is a builtin. OLDDECL will be discarded in any case. */ - if (TREE_CODE (olddecl) != TREE_CODE (newdecl)) - { - if (!(TREE_CODE (olddecl) == FUNCTION_DECL - && DECL_BUILT_IN (olddecl) - && !C_DECL_DECLARED_BUILTIN (olddecl))) - { - error ("%q+D redeclared as different kind of symbol", newdecl); - locate_old_decl (olddecl); - } - else if (TREE_PUBLIC (newdecl)) - warning (0, "built-in function %q+D declared as non-function", - newdecl); - else - warning (OPT_Wshadow, "declaration of %q+D shadows " - "a built-in function", newdecl); - return false; - } - - /* Enumerators have no linkage, so may only be declared once in a - given scope. */ - if (TREE_CODE (olddecl) == CONST_DECL) - { - error ("redeclaration of enumerator %q+D", newdecl); - locate_old_decl (olddecl); - return false; - } - - if (!comptypes (oldtype, newtype)) - { - if (TREE_CODE (olddecl) == FUNCTION_DECL - && DECL_BUILT_IN (olddecl) && !C_DECL_DECLARED_BUILTIN (olddecl)) - { - /* Accept harmless mismatch in function types. - This is for the ffs and fprintf builtins. */ - tree trytype = match_builtin_function_types (newtype, oldtype); - - if (trytype && comptypes (newtype, trytype)) - *oldtypep = oldtype = trytype; - else - { - /* If types don't match for a built-in, throw away the - built-in. No point in calling locate_old_decl here, it - won't print anything. */ - warning (0, "conflicting types for built-in function %q+D", - newdecl); - return false; - } - } - else if (TREE_CODE (olddecl) == FUNCTION_DECL - && DECL_IS_BUILTIN (olddecl)) - { - /* A conflicting function declaration for a predeclared - function that isn't actually built in. Objective C uses - these. The new declaration silently overrides everything - but the volatility (i.e. noreturn) indication. See also - below. FIXME: Make Objective C use normal builtins. */ - TREE_THIS_VOLATILE (newdecl) |= TREE_THIS_VOLATILE (olddecl); - return false; - } - /* Permit void foo (...) to match int foo (...) if the latter is - the definition and implicit int was used. See - c-torture/compile/920625-2.c. */ - else if (TREE_CODE (newdecl) == FUNCTION_DECL && DECL_INITIAL (newdecl) - && TYPE_MAIN_VARIANT (TREE_TYPE (oldtype)) == void_type_node - && TYPE_MAIN_VARIANT (TREE_TYPE (newtype)) == integer_type_node - && C_FUNCTION_IMPLICIT_INT (newdecl) && !DECL_INITIAL (olddecl)) - { - pedwarned = pedwarn (input_location, 0, - "conflicting types for %q+D", newdecl); - /* Make sure we keep void as the return type. */ - TREE_TYPE (newdecl) = *newtypep = newtype = oldtype; - C_FUNCTION_IMPLICIT_INT (newdecl) = 0; - } - /* Permit void foo (...) to match an earlier call to foo (...) with - no declared type (thus, implicitly int). */ - else if (TREE_CODE (newdecl) == FUNCTION_DECL - && TYPE_MAIN_VARIANT (TREE_TYPE (newtype)) == void_type_node - && TYPE_MAIN_VARIANT (TREE_TYPE (oldtype)) == integer_type_node - && C_DECL_IMPLICIT (olddecl) && !DECL_INITIAL (olddecl)) - { - pedwarned = pedwarn (input_location, 0, - "conflicting types for %q+D", newdecl); - /* Make sure we keep void as the return type. */ - TREE_TYPE (olddecl) = *oldtypep = oldtype = newtype; - } - else - { - int new_quals = TYPE_QUALS (newtype); - int old_quals = TYPE_QUALS (oldtype); - - if (new_quals != old_quals) - { - addr_space_t new_addr = DECODE_QUAL_ADDR_SPACE (new_quals); - addr_space_t old_addr = DECODE_QUAL_ADDR_SPACE (old_quals); - if (new_addr != old_addr) - { - if (ADDR_SPACE_GENERIC_P (new_addr)) - error ("conflicting named address spaces (generic vs %s) " - "for %q+D", - c_addr_space_name (old_addr), newdecl); - else if (ADDR_SPACE_GENERIC_P (old_addr)) - error ("conflicting named address spaces (%s vs generic) " - "for %q+D", - c_addr_space_name (new_addr), newdecl); - else - error ("conflicting named address spaces (%s vs %s) " - "for %q+D", - c_addr_space_name (new_addr), - c_addr_space_name (old_addr), - newdecl); - } - - if (CLEAR_QUAL_ADDR_SPACE (new_quals) - != CLEAR_QUAL_ADDR_SPACE (old_quals)) - error ("conflicting type qualifiers for %q+D", newdecl); - } - else - error ("conflicting types for %q+D", newdecl); - diagnose_arglist_conflict (newdecl, olddecl, newtype, oldtype); - locate_old_decl (olddecl); - return false; - } - } - - /* Redeclaration of a type is a constraint violation (6.7.2.3p1), - but silently ignore the redeclaration if either is in a system - header. (Conflicting redeclarations were handled above.) This - is allowed for C11 if the types are the same, not just - compatible. */ - if (TREE_CODE (newdecl) == TYPE_DECL) - { - bool types_different = false; - int comptypes_result; - - comptypes_result - = comptypes_check_different_types (oldtype, newtype, &types_different); - - if (comptypes_result != 1 || types_different) - { - error ("redefinition of typedef %q+D with different type", newdecl); - locate_old_decl (olddecl); - return false; - } - - if (DECL_IN_SYSTEM_HEADER (newdecl) - || DECL_IN_SYSTEM_HEADER (olddecl) - || TREE_NO_WARNING (newdecl) - || TREE_NO_WARNING (olddecl)) - return true; /* Allow OLDDECL to continue in use. */ - - if (variably_modified_type_p (newtype, NULL)) - { - error ("redefinition of typedef %q+D with variably modified type", - newdecl); - locate_old_decl (olddecl); - } - else if (pedantic && !flag_isoc11) - { - pedwarn (input_location, OPT_Wpedantic, - "redefinition of typedef %q+D", newdecl); - locate_old_decl (olddecl); - } - - return true; - } - - /* Function declarations can either be 'static' or 'extern' (no - qualifier is equivalent to 'extern' - C99 6.2.2p5) and therefore - can never conflict with each other on account of linkage - (6.2.2p4). Multiple definitions are not allowed (6.9p3,5) but - gnu89 mode permits two definitions if one is 'extern inline' and - one is not. The non- extern-inline definition supersedes the - extern-inline definition. */ - - else if (TREE_CODE (newdecl) == FUNCTION_DECL) - { - /* If you declare a built-in function name as static, or - define the built-in with an old-style definition (so we - can't validate the argument list) the built-in definition is - overridden, but optionally warn this was a bad choice of name. */ - if (DECL_BUILT_IN (olddecl) - && !C_DECL_DECLARED_BUILTIN (olddecl) - && (!TREE_PUBLIC (newdecl) - || (DECL_INITIAL (newdecl) - && !prototype_p (TREE_TYPE (newdecl))))) - { - warning (OPT_Wshadow, "declaration of %q+D shadows " - "a built-in function", newdecl); - /* Discard the old built-in function. */ - return false; - } - - if (DECL_INITIAL (newdecl)) - { - if (DECL_INITIAL (olddecl)) - { - /* If both decls are in the same TU and the new declaration - isn't overriding an extern inline reject the new decl. - In c99, no overriding is allowed in the same translation - unit. */ - if ((!DECL_EXTERN_INLINE (olddecl) - || DECL_EXTERN_INLINE (newdecl) - || (!flag_gnu89_inline - && (!DECL_DECLARED_INLINE_P (olddecl) - || !lookup_attribute ("gnu_inline", - DECL_ATTRIBUTES (olddecl))) - && (!DECL_DECLARED_INLINE_P (newdecl) - || !lookup_attribute ("gnu_inline", - DECL_ATTRIBUTES (newdecl)))) - ) - && same_translation_unit_p (newdecl, olddecl)) - { - error ("redefinition of %q+D", newdecl); - locate_old_decl (olddecl); - return false; - } - } - } - /* If we have a prototype after an old-style function definition, - the argument types must be checked specially. */ - else if (DECL_INITIAL (olddecl) - && !prototype_p (oldtype) && prototype_p (newtype) - && TYPE_ACTUAL_ARG_TYPES (oldtype) - && !validate_proto_after_old_defn (newdecl, newtype, oldtype)) - { - locate_old_decl (olddecl); - return false; - } - /* A non-static declaration (even an "extern") followed by a - static declaration is undefined behavior per C99 6.2.2p3-5,7. - The same is true for a static forward declaration at block - scope followed by a non-static declaration/definition at file - scope. Static followed by non-static at the same scope is - not undefined behavior, and is the most convenient way to get - 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 - we do diagnose it if -Wtraditional. */ - if (TREE_PUBLIC (olddecl) && !TREE_PUBLIC (newdecl)) - { - /* Two exceptions to the rule. If olddecl is an extern - inline, or a predeclared function that isn't actually - built in, newdecl silently overrides olddecl. The latter - occur only in Objective C; see also above. (FIXME: Make - Objective C use normal builtins.) */ - if (!DECL_IS_BUILTIN (olddecl) - && !DECL_EXTERN_INLINE (olddecl)) - { - error ("static declaration of %q+D follows " - "non-static declaration", newdecl); - locate_old_decl (olddecl); - } - return false; - } - else if (TREE_PUBLIC (newdecl) && !TREE_PUBLIC (olddecl)) - { - if (DECL_CONTEXT (olddecl)) - { - error ("non-static declaration of %q+D follows " - "static declaration", newdecl); - locate_old_decl (olddecl); - return false; - } - else if (warn_traditional) - { - warned |= warning (OPT_Wtraditional, - "non-static declaration of %q+D " - "follows static declaration", newdecl); - } - } - - /* Make sure gnu_inline attribute is either not present, or - present on all inline decls. */ - if (DECL_DECLARED_INLINE_P (olddecl) - && DECL_DECLARED_INLINE_P (newdecl)) - { - bool newa = lookup_attribute ("gnu_inline", - DECL_ATTRIBUTES (newdecl)) != NULL; - bool olda = lookup_attribute ("gnu_inline", - DECL_ATTRIBUTES (olddecl)) != NULL; - if (newa != olda) - { - error_at (input_location, "%<gnu_inline%> attribute present on %q+D", - newa ? newdecl : olddecl); - error_at (DECL_SOURCE_LOCATION (newa ? olddecl : newdecl), - "but not here"); - } - } - } - else if (TREE_CODE (newdecl) == VAR_DECL) - { - /* Only variables can be thread-local, and all declarations must - agree on this property. */ - if (C_DECL_THREADPRIVATE_P (olddecl) && !DECL_THREAD_LOCAL_P (newdecl)) - { - /* Nothing to check. Since OLDDECL is marked threadprivate - and NEWDECL does not have a thread-local attribute, we - will merge the threadprivate attribute into NEWDECL. */ - ; - } - else if (DECL_THREAD_LOCAL_P (newdecl) != DECL_THREAD_LOCAL_P (olddecl)) - { - if (DECL_THREAD_LOCAL_P (newdecl)) - error ("thread-local declaration of %q+D follows " - "non-thread-local declaration", newdecl); - else - error ("non-thread-local declaration of %q+D follows " - "thread-local declaration", newdecl); - - locate_old_decl (olddecl); - return false; - } - - /* Multiple initialized definitions are not allowed (6.9p3,5). */ - if (DECL_INITIAL (newdecl) && DECL_INITIAL (olddecl)) - { - error ("redefinition of %q+D", newdecl); - locate_old_decl (olddecl); - return false; - } - - /* Objects declared at file scope: if the first declaration had - external linkage (even if it was an external reference) the - second must have external linkage as well, or the behavior is - undefined. If the first declaration had internal linkage, then - the second must too, or else be an external reference (in which - case the composite declaration still has internal linkage). - As for function declarations, we warn about the static-then- - extern case only for -Wtraditional. See generally 6.2.2p3-5,7. */ - if (DECL_FILE_SCOPE_P (newdecl) - && TREE_PUBLIC (newdecl) != TREE_PUBLIC (olddecl)) - { - if (DECL_EXTERNAL (newdecl)) - { - if (!DECL_FILE_SCOPE_P (olddecl)) - { - error ("extern declaration of %q+D follows " - "declaration with no linkage", newdecl); - locate_old_decl (olddecl); - return false; - } - else if (warn_traditional) - { - warned |= warning (OPT_Wtraditional, - "non-static declaration of %q+D " - "follows static declaration", newdecl); - } - } - else - { - if (TREE_PUBLIC (newdecl)) - error ("non-static declaration of %q+D follows " - "static declaration", newdecl); - else - error ("static declaration of %q+D follows " - "non-static declaration", newdecl); - - locate_old_decl (olddecl); - return false; - } - } - /* Two objects with the same name declared at the same block - scope must both be external references (6.7p3). */ - else if (!DECL_FILE_SCOPE_P (newdecl)) - { - if (DECL_EXTERNAL (newdecl)) - { - /* Extern with initializer at block scope, which will - already have received an error. */ - } - else if (DECL_EXTERNAL (olddecl)) - { - error ("declaration of %q+D with no linkage follows " - "extern declaration", newdecl); - locate_old_decl (olddecl); - } - else - { - error ("redeclaration of %q+D with no linkage", newdecl); - locate_old_decl (olddecl); - } - - return false; - } - - /* C++ does not permit a decl to appear multiple times at file - scope. */ - if (warn_cxx_compat - && DECL_FILE_SCOPE_P (newdecl) - && !DECL_EXTERNAL (newdecl) - && !DECL_EXTERNAL (olddecl)) - warned |= warning_at (DECL_SOURCE_LOCATION (newdecl), - OPT_Wc___compat, - ("duplicate declaration of %qD is " - "invalid in C++"), - newdecl); - } - - /* warnings */ - /* All decls must agree on a visibility. */ - if (CODE_CONTAINS_STRUCT (TREE_CODE (newdecl), TS_DECL_WITH_VIS) - && DECL_VISIBILITY_SPECIFIED (newdecl) && DECL_VISIBILITY_SPECIFIED (olddecl) - && DECL_VISIBILITY (newdecl) != DECL_VISIBILITY (olddecl)) - { - warned |= warning (0, "redeclaration of %q+D with different visibility " - "(old visibility preserved)", newdecl); - } - - if (TREE_CODE (newdecl) == FUNCTION_DECL) - { - /* Diagnose inline __attribute__ ((noinline)) which is silly. */ - if (DECL_DECLARED_INLINE_P (newdecl) - && lookup_attribute ("noinline", DECL_ATTRIBUTES (olddecl))) - { - warned |= warning (OPT_Wattributes, - "inline declaration of %qD follows " - "declaration with attribute noinline", newdecl); - } - else if (DECL_DECLARED_INLINE_P (olddecl) - && lookup_attribute ("noinline", DECL_ATTRIBUTES (newdecl))) - { - warned |= warning (OPT_Wattributes, - "declaration of %q+D with attribute " - "noinline follows inline declaration ", newdecl); - } - } - else /* PARM_DECL, VAR_DECL */ - { - /* Redeclaration of a parameter is a constraint violation (this is - not explicitly stated, but follows from C99 6.7p3 [no more than - one declaration of the same identifier with no linkage in the - same scope, except type tags] and 6.2.2p6 [parameters have no - linkage]). We must check for a forward parameter declaration, - indicated by TREE_ASM_WRITTEN on the old declaration - this is - an extension, the mandatory diagnostic for which is handled by - mark_forward_parm_decls. */ - - if (TREE_CODE (newdecl) == PARM_DECL - && (!TREE_ASM_WRITTEN (olddecl) || TREE_ASM_WRITTEN (newdecl))) - { - error ("redefinition of parameter %q+D", newdecl); - locate_old_decl (olddecl); - return false; - } - } - - /* Optional warning for completely redundant decls. */ - if (!warned && !pedwarned - && warn_redundant_decls - /* Don't warn about a function declaration followed by a - definition. */ - && !(TREE_CODE (newdecl) == FUNCTION_DECL - && DECL_INITIAL (newdecl) && !DECL_INITIAL (olddecl)) - /* Don't warn about redundant redeclarations of builtins. */ - && !(TREE_CODE (newdecl) == FUNCTION_DECL - && !DECL_BUILT_IN (newdecl) - && DECL_BUILT_IN (olddecl) - && !C_DECL_DECLARED_BUILTIN (olddecl)) - /* Don't warn about an extern followed by a definition. */ - && !(DECL_EXTERNAL (olddecl) && !DECL_EXTERNAL (newdecl)) - /* Don't warn about forward parameter decls. */ - && !(TREE_CODE (newdecl) == PARM_DECL - && TREE_ASM_WRITTEN (olddecl) && !TREE_ASM_WRITTEN (newdecl)) - /* Don't warn about a variable definition following a declaration. */ - && !(TREE_CODE (newdecl) == VAR_DECL - && DECL_INITIAL (newdecl) && !DECL_INITIAL (olddecl))) - { - warned = warning (OPT_Wredundant_decls, "redundant redeclaration of %q+D", - newdecl); - } - - /* Report location of previous decl/defn. */ - if (warned || pedwarned) - locate_old_decl (olddecl); - -#undef DECL_EXTERN_INLINE - - return retval; -} - -/* Subroutine of duplicate_decls. NEWDECL has been found to be - consistent with OLDDECL, but carries new information. Merge the - new information into OLDDECL. This function issues no - diagnostics. */ - -static void -merge_decls (tree newdecl, tree olddecl, tree newtype, tree oldtype) -{ - bool new_is_definition = (TREE_CODE (newdecl) == FUNCTION_DECL - && DECL_INITIAL (newdecl) != 0); - bool new_is_prototype = (TREE_CODE (newdecl) == FUNCTION_DECL - && prototype_p (TREE_TYPE (newdecl))); - bool old_is_prototype = (TREE_CODE (olddecl) == FUNCTION_DECL - && prototype_p (TREE_TYPE (olddecl))); - - /* 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 - forward decl anymore). */ - if (TREE_CODE (newdecl) == PARM_DECL - && TREE_ASM_WRITTEN (olddecl) && !TREE_ASM_WRITTEN (newdecl)) - { - struct c_binding *b, **here; - - for (here = ¤t_scope->bindings; *here; here = &(*here)->prev) - if ((*here)->decl == olddecl) - goto found; - gcc_unreachable (); - - found: - b = *here; - *here = b->prev; - b->prev = current_scope->bindings; - current_scope->bindings = b; - - TREE_ASM_WRITTEN (olddecl) = 0; - } - - DECL_ATTRIBUTES (newdecl) - = targetm.merge_decl_attributes (olddecl, newdecl); - - /* Merge the data types specified in the two decls. */ - TREE_TYPE (newdecl) - = TREE_TYPE (olddecl) - = composite_type (newtype, oldtype); - - /* Lay the type out, unless already done. */ - if (!comptypes (oldtype, TREE_TYPE (newdecl))) - { - if (TREE_TYPE (newdecl) != error_mark_node) - layout_type (TREE_TYPE (newdecl)); - if (TREE_CODE (newdecl) != FUNCTION_DECL - && TREE_CODE (newdecl) != TYPE_DECL - && TREE_CODE (newdecl) != CONST_DECL) - layout_decl (newdecl, 0); - } - else - { - /* Since the type is OLDDECL's, make OLDDECL's size go with. */ - DECL_SIZE (newdecl) = DECL_SIZE (olddecl); - DECL_SIZE_UNIT (newdecl) = DECL_SIZE_UNIT (olddecl); - DECL_MODE (newdecl) = DECL_MODE (olddecl); - if (DECL_ALIGN (olddecl) > DECL_ALIGN (newdecl)) - { - DECL_ALIGN (newdecl) = DECL_ALIGN (olddecl); - DECL_USER_ALIGN (newdecl) |= DECL_USER_ALIGN (olddecl); - } - } - - /* Keep the old rtl since we can safely use it. */ - if (HAS_RTL_P (olddecl)) - COPY_DECL_RTL (olddecl, newdecl); - - /* Merge the type qualifiers. */ - if (TREE_READONLY (newdecl)) - TREE_READONLY (olddecl) = 1; - - if (TREE_THIS_VOLATILE (newdecl)) - TREE_THIS_VOLATILE (olddecl) = 1; - - /* Merge deprecatedness. */ - if (TREE_DEPRECATED (newdecl)) - TREE_DEPRECATED (olddecl) = 1; - - /* 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 - declaration and of prototype rather than non-prototype unless that - prototype is built-in. */ - if (CODE_CONTAINS_STRUCT (TREE_CODE (olddecl), TS_DECL_WITH_VIS) - && DECL_IN_SYSTEM_HEADER (olddecl) - && !DECL_IN_SYSTEM_HEADER (newdecl) ) - DECL_SOURCE_LOCATION (newdecl) = DECL_SOURCE_LOCATION (olddecl); - else if (CODE_CONTAINS_STRUCT (TREE_CODE (olddecl), TS_DECL_WITH_VIS) - && DECL_IN_SYSTEM_HEADER (newdecl) - && !DECL_IN_SYSTEM_HEADER (olddecl)) - DECL_SOURCE_LOCATION (olddecl) = DECL_SOURCE_LOCATION (newdecl); - else if ((DECL_INITIAL (newdecl) == 0 && DECL_INITIAL (olddecl) != 0) - || (old_is_prototype && !new_is_prototype - && !C_DECL_BUILTIN_PROTOTYPE (olddecl))) - DECL_SOURCE_LOCATION (newdecl) = DECL_SOURCE_LOCATION (olddecl); - - /* Merge the initialization information. */ - if (DECL_INITIAL (newdecl) == 0) - DECL_INITIAL (newdecl) = DECL_INITIAL (olddecl); - - /* Merge the threadprivate attribute. */ - if (TREE_CODE (olddecl) == VAR_DECL && C_DECL_THREADPRIVATE_P (olddecl)) - { - DECL_TLS_MODEL (newdecl) = DECL_TLS_MODEL (olddecl); - C_DECL_THREADPRIVATE_P (newdecl) = 1; - } - - if (CODE_CONTAINS_STRUCT (TREE_CODE (olddecl), TS_DECL_WITH_VIS)) - { - /* Merge the section attribute. - We want to issue an error if the sections conflict but that - must be done later in decl_attributes since we are called - before attributes are assigned. */ - if (DECL_SECTION_NAME (newdecl) == NULL_TREE) - DECL_SECTION_NAME (newdecl) = DECL_SECTION_NAME (olddecl); - - /* Copy the assembler name. - Currently, it can only be defined in the prototype. */ - COPY_DECL_ASSEMBLER_NAME (olddecl, newdecl); - - /* Use visibility of whichever declaration had it specified */ - if (DECL_VISIBILITY_SPECIFIED (olddecl)) - { - DECL_VISIBILITY (newdecl) = DECL_VISIBILITY (olddecl); - DECL_VISIBILITY_SPECIFIED (newdecl) = 1; - } - - if (TREE_CODE (newdecl) == FUNCTION_DECL) - { - DECL_STATIC_CONSTRUCTOR(newdecl) |= DECL_STATIC_CONSTRUCTOR(olddecl); - DECL_STATIC_DESTRUCTOR (newdecl) |= DECL_STATIC_DESTRUCTOR (olddecl); - DECL_NO_LIMIT_STACK (newdecl) |= DECL_NO_LIMIT_STACK (olddecl); - DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (newdecl) - |= DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (olddecl); - TREE_THIS_VOLATILE (newdecl) |= TREE_THIS_VOLATILE (olddecl); - DECL_IS_MALLOC (newdecl) |= DECL_IS_MALLOC (olddecl); - DECL_IS_OPERATOR_NEW (newdecl) |= DECL_IS_OPERATOR_NEW (olddecl); - TREE_READONLY (newdecl) |= TREE_READONLY (olddecl); - DECL_PURE_P (newdecl) |= DECL_PURE_P (olddecl); - DECL_IS_NOVOPS (newdecl) |= DECL_IS_NOVOPS (olddecl); - } - - /* Merge the storage class information. */ - merge_weak (newdecl, olddecl); - - /* For functions, static overrides non-static. */ - if (TREE_CODE (newdecl) == FUNCTION_DECL) - { - TREE_PUBLIC (newdecl) &= TREE_PUBLIC (olddecl); - /* This is since we don't automatically - copy the attributes of NEWDECL into OLDDECL. */ - TREE_PUBLIC (olddecl) = TREE_PUBLIC (newdecl); - /* If this clears `static', clear it in the identifier too. */ - if (!TREE_PUBLIC (olddecl)) - TREE_PUBLIC (DECL_NAME (olddecl)) = 0; - } - } - - /* In c99, 'extern' declaration before (or after) 'inline' means this - function is not DECL_EXTERNAL, unless 'gnu_inline' attribute - is present. */ - if (TREE_CODE (newdecl) == FUNCTION_DECL - && !flag_gnu89_inline - && (DECL_DECLARED_INLINE_P (newdecl) - || DECL_DECLARED_INLINE_P (olddecl)) - && (!DECL_DECLARED_INLINE_P (newdecl) - || !DECL_DECLARED_INLINE_P (olddecl) - || !DECL_EXTERNAL (olddecl)) - && DECL_EXTERNAL (newdecl) - && !lookup_attribute ("gnu_inline", DECL_ATTRIBUTES (newdecl)) - && !current_function_decl) - DECL_EXTERNAL (newdecl) = 0; - - if (DECL_EXTERNAL (newdecl)) - { - TREE_STATIC (newdecl) = TREE_STATIC (olddecl); - DECL_EXTERNAL (newdecl) = DECL_EXTERNAL (olddecl); - - /* An extern decl does not override previous storage class. */ - TREE_PUBLIC (newdecl) = TREE_PUBLIC (olddecl); - if (!DECL_EXTERNAL (newdecl)) - { - DECL_CONTEXT (newdecl) = DECL_CONTEXT (olddecl); - DECL_COMMON (newdecl) = DECL_COMMON (olddecl); - } - } - else - { - TREE_STATIC (olddecl) = TREE_STATIC (newdecl); - TREE_PUBLIC (olddecl) = TREE_PUBLIC (newdecl); - } - - if (TREE_CODE (newdecl) == FUNCTION_DECL) - { - /* If we're redefining a function previously defined as extern - inline, make sure we emit debug info for the inline before we - throw it away, in case it was inlined into a function that - hasn't been written out yet. */ - if (new_is_definition && DECL_INITIAL (olddecl)) - /* The new defn must not be inline. */ - DECL_UNINLINABLE (newdecl) = 1; - else - { - /* If either decl says `inline', this fn is inline, unless - its definition was passed already. */ - if (DECL_DECLARED_INLINE_P (newdecl) - || DECL_DECLARED_INLINE_P (olddecl)) - DECL_DECLARED_INLINE_P (newdecl) = 1; - - DECL_UNINLINABLE (newdecl) = DECL_UNINLINABLE (olddecl) - = (DECL_UNINLINABLE (newdecl) || DECL_UNINLINABLE (olddecl)); - - DECL_DISREGARD_INLINE_LIMITS (newdecl) - = DECL_DISREGARD_INLINE_LIMITS (olddecl) - = (DECL_DISREGARD_INLINE_LIMITS (newdecl) - || DECL_DISREGARD_INLINE_LIMITS (olddecl)); - } - - if (DECL_BUILT_IN (olddecl)) - { - /* If redeclaring a builtin function, it stays built in. - But it gets tagged as having been declared. */ - DECL_BUILT_IN_CLASS (newdecl) = DECL_BUILT_IN_CLASS (olddecl); - DECL_FUNCTION_CODE (newdecl) = DECL_FUNCTION_CODE (olddecl); - C_DECL_DECLARED_BUILTIN (newdecl) = 1; - if (new_is_prototype) - { - C_DECL_BUILTIN_PROTOTYPE (newdecl) = 0; - if (DECL_BUILT_IN_CLASS (newdecl) == BUILT_IN_NORMAL) - { - enum built_in_function fncode = DECL_FUNCTION_CODE (newdecl); - switch (fncode) - { - /* If a compatible prototype of these builtin functions - is seen, assume the runtime implements it with the - expected semantics. */ - case BUILT_IN_STPCPY: - if (builtin_decl_explicit_p (fncode)) - set_builtin_decl_implicit_p (fncode, true); - break; - default: - break; - } - } - } - else - C_DECL_BUILTIN_PROTOTYPE (newdecl) - = C_DECL_BUILTIN_PROTOTYPE (olddecl); - } - - /* Preserve function specific target and optimization options */ - if (DECL_FUNCTION_SPECIFIC_TARGET (olddecl) - && !DECL_FUNCTION_SPECIFIC_TARGET (newdecl)) - DECL_FUNCTION_SPECIFIC_TARGET (newdecl) - = DECL_FUNCTION_SPECIFIC_TARGET (olddecl); - - if (DECL_FUNCTION_SPECIFIC_OPTIMIZATION (olddecl) - && !DECL_FUNCTION_SPECIFIC_OPTIMIZATION (newdecl)) - DECL_FUNCTION_SPECIFIC_OPTIMIZATION (newdecl) - = DECL_FUNCTION_SPECIFIC_OPTIMIZATION (olddecl); - - /* Also preserve various other info from the definition. */ - if (!new_is_definition) - { - tree t; - DECL_RESULT (newdecl) = DECL_RESULT (olddecl); - DECL_INITIAL (newdecl) = DECL_INITIAL (olddecl); - DECL_STRUCT_FUNCTION (newdecl) = DECL_STRUCT_FUNCTION (olddecl); - DECL_SAVED_TREE (newdecl) = DECL_SAVED_TREE (olddecl); - DECL_ARGUMENTS (newdecl) = copy_list (DECL_ARGUMENTS (olddecl)); - for (t = DECL_ARGUMENTS (newdecl); t ; t = DECL_CHAIN (t)) - DECL_CONTEXT (t) = newdecl; - - /* See if we've got a function to instantiate from. */ - if (DECL_SAVED_TREE (olddecl)) - DECL_ABSTRACT_ORIGIN (newdecl) - = DECL_ABSTRACT_ORIGIN (olddecl); - } - } - - /* Merge the USED information. */ - if (TREE_USED (olddecl)) - TREE_USED (newdecl) = 1; - else if (TREE_USED (newdecl)) - TREE_USED (olddecl) = 1; - if (TREE_CODE (olddecl) == VAR_DECL || TREE_CODE (olddecl) == PARM_DECL) - DECL_READ_P (newdecl) |= DECL_READ_P (olddecl); - if (DECL_PRESERVE_P (olddecl)) - DECL_PRESERVE_P (newdecl) = 1; - else if (DECL_PRESERVE_P (newdecl)) - DECL_PRESERVE_P (olddecl) = 1; - - /* Copy most of the decl-specific fields of NEWDECL into OLDDECL. - But preserve OLDDECL's DECL_UID, DECL_CONTEXT and - DECL_ARGUMENTS (if appropriate). */ - { - unsigned olddecl_uid = DECL_UID (olddecl); - tree olddecl_context = DECL_CONTEXT (olddecl); - tree olddecl_arguments = NULL; - if (TREE_CODE (olddecl) == FUNCTION_DECL) - olddecl_arguments = DECL_ARGUMENTS (olddecl); - - memcpy ((char *) olddecl + sizeof (struct tree_common), - (char *) newdecl + sizeof (struct tree_common), - sizeof (struct tree_decl_common) - sizeof (struct tree_common)); - DECL_USER_ALIGN (olddecl) = DECL_USER_ALIGN (newdecl); - switch (TREE_CODE (olddecl)) - { - case FUNCTION_DECL: - case FIELD_DECL: - case VAR_DECL: - case PARM_DECL: - case LABEL_DECL: - case RESULT_DECL: - case CONST_DECL: - case TYPE_DECL: - memcpy ((char *) olddecl + sizeof (struct tree_decl_common), - (char *) newdecl + sizeof (struct tree_decl_common), - tree_code_size (TREE_CODE (olddecl)) - sizeof (struct tree_decl_common)); - break; - - default: - - memcpy ((char *) olddecl + sizeof (struct tree_decl_common), - (char *) newdecl + sizeof (struct tree_decl_common), - sizeof (struct tree_decl_non_common) - sizeof (struct tree_decl_common)); - } - DECL_UID (olddecl) = olddecl_uid; - DECL_CONTEXT (olddecl) = olddecl_context; - if (TREE_CODE (olddecl) == FUNCTION_DECL) - DECL_ARGUMENTS (olddecl) = olddecl_arguments; - } - - /* 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 - flags and attributes. */ - if (DECL_RTL_SET_P (olddecl) - && (TREE_CODE (olddecl) == FUNCTION_DECL - || (TREE_CODE (olddecl) == VAR_DECL - && TREE_STATIC (olddecl)))) - make_decl_rtl (olddecl); -} - -/* Handle when a new declaration NEWDECL has the same name as an old - one OLDDECL in the same binding contour. Prints an error message - if appropriate. - - If safely possible, alter OLDDECL to look like NEWDECL, and return - true. Otherwise, return false. */ - -static bool -duplicate_decls (tree newdecl, tree olddecl) -{ - tree newtype = NULL, oldtype = NULL; - - if (!diagnose_mismatched_decls (newdecl, olddecl, &newtype, &oldtype)) - { - /* Avoid `unused variable' and other warnings for OLDDECL. */ - TREE_NO_WARNING (olddecl) = 1; - return false; - } - - merge_decls (newdecl, olddecl, newtype, oldtype); - return true; -} - - -/* Check whether decl-node NEW_DECL shadows an existing declaration. */ -static void -warn_if_shadowing (tree new_decl) -{ - struct c_binding *b; - - /* Shadow warnings wanted? */ - if (!warn_shadow - /* No shadow warnings for internally generated vars. */ - || DECL_IS_BUILTIN (new_decl) - /* No shadow warnings for vars made for inlining. */ - || DECL_FROM_INLINE (new_decl)) - return; - - /* Is anything being shadowed? Invisible decls do not count. */ - for (b = I_SYMBOL_BINDING (DECL_NAME (new_decl)); b; b = b->shadowed) - if (b->decl && b->decl != new_decl && !b->invisible - && (b->decl == error_mark_node - || diagnostic_report_warnings_p (global_dc, - DECL_SOURCE_LOCATION (b->decl)))) - { - tree old_decl = b->decl; - - if (old_decl == error_mark_node) - { - warning (OPT_Wshadow, "declaration of %q+D shadows previous " - "non-variable", new_decl); - break; - } - else if (TREE_CODE (old_decl) == PARM_DECL) - warning (OPT_Wshadow, "declaration of %q+D shadows a parameter", - new_decl); - else if (DECL_FILE_SCOPE_P (old_decl)) - { - /* Do not warn if a variable shadows a function, unless - the variable is a function or a pointer-to-function. */ - if (TREE_CODE (old_decl) == FUNCTION_DECL - && TREE_CODE (new_decl) != FUNCTION_DECL - && !FUNCTION_POINTER_TYPE_P (TREE_TYPE (new_decl))) - continue; - - warning_at (DECL_SOURCE_LOCATION (new_decl), OPT_Wshadow, - "declaration of %qD shadows a global declaration", - new_decl); - } - else if (TREE_CODE (old_decl) == FUNCTION_DECL - && DECL_BUILT_IN (old_decl)) - { - warning (OPT_Wshadow, "declaration of %q+D shadows " - "a built-in function", new_decl); - break; - } - else - warning (OPT_Wshadow, "declaration of %q+D shadows a previous local", - new_decl); - - warning_at (DECL_SOURCE_LOCATION (old_decl), OPT_Wshadow, - "shadowed declaration is here"); - - break; - } -} - -/* Record a decl-node X as belonging to the current lexical scope. - Check for errors (such as an incompatible declaration for the same - name already seen in the same scope). - - Returns either X or an old decl for the same name. - If an old decl is returned, it may have been smashed - to agree with what X says. */ - -tree -pushdecl (tree x) -{ - tree name = DECL_NAME (x); - struct c_scope *scope = current_scope; - struct c_binding *b; - bool nested = false; - location_t locus = DECL_SOURCE_LOCATION (x); - - /* Must set DECL_CONTEXT for everything not at file scope or - DECL_FILE_SCOPE_P won't work. Local externs don't count - unless they have initializers (which generate code). */ - if (current_function_decl - && ((TREE_CODE (x) != FUNCTION_DECL && TREE_CODE (x) != VAR_DECL) - || DECL_INITIAL (x) || !DECL_EXTERNAL (x))) - DECL_CONTEXT (x) = current_function_decl; - - /* Anonymous decls are just inserted in the scope. */ - if (!name) - { - bind (name, x, scope, /*invisible=*/false, /*nested=*/false, - locus); - return x; - } - - /* First, see if there is another declaration with the same name in - the current scope. If there is, duplicate_decls may do all the - work for us. If duplicate_decls returns false, that indicates - two incompatible decls in the same scope; we are to silently - replace the old one (duplicate_decls has issued all appropriate - diagnostics). In particular, we should not consider possible - duplicates in the external scope, or shadowing. */ - b = I_SYMBOL_BINDING (name); - if (b && B_IN_SCOPE (b, scope)) - { - struct c_binding *b_ext, *b_use; - tree type = TREE_TYPE (x); - tree visdecl = b->decl; - tree vistype = TREE_TYPE (visdecl); - if (TREE_CODE (TREE_TYPE (x)) == ARRAY_TYPE - && COMPLETE_TYPE_P (TREE_TYPE (x))) - b->inner_comp = false; - b_use = b; - b_ext = b; - /* If this is an external linkage declaration, we should check - for compatibility with the type in the external scope before - setting the type at this scope based on the visible - information only. */ - if (TREE_PUBLIC (x) && TREE_PUBLIC (visdecl)) - { - while (b_ext && !B_IN_EXTERNAL_SCOPE (b_ext)) - b_ext = b_ext->shadowed; - if (b_ext) - { - b_use = b_ext; - if (b_use->u.type) - TREE_TYPE (b_use->decl) = b_use->u.type; - } - } - if (duplicate_decls (x, b_use->decl)) - { - if (b_use != b) - { - /* Save the updated type in the external scope and - restore the proper type for this scope. */ - tree thistype; - if (comptypes (vistype, type)) - thistype = composite_type (vistype, type); - else - thistype = TREE_TYPE (b_use->decl); - b_use->u.type = TREE_TYPE (b_use->decl); - if (TREE_CODE (b_use->decl) == FUNCTION_DECL - && DECL_BUILT_IN (b_use->decl)) - thistype - = build_type_attribute_variant (thistype, - TYPE_ATTRIBUTES - (b_use->u.type)); - TREE_TYPE (b_use->decl) = thistype; - } - return b_use->decl; - } - else - goto skip_external_and_shadow_checks; - } - - /* All declarations with external linkage, and all external - references, go in the external scope, no matter what scope is - current. However, the binding in that scope is ignored for - purposes of normal name lookup. A separate binding structure is - created in the requested scope; this governs the normal - visibility of the symbol. - - The binding in the externals scope is used exclusively for - detecting duplicate declarations of the same object, no matter - 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 - have compatible type; otherwise, the behavior is undefined.) */ - if (DECL_EXTERNAL (x) || scope == file_scope) - { - tree type = TREE_TYPE (x); - tree vistype = 0; - tree visdecl = 0; - bool type_saved = false; - if (b && !B_IN_EXTERNAL_SCOPE (b) - && (TREE_CODE (b->decl) == FUNCTION_DECL - || TREE_CODE (b->decl) == VAR_DECL) - && DECL_FILE_SCOPE_P (b->decl)) - { - visdecl = b->decl; - vistype = TREE_TYPE (visdecl); - } - if (scope != file_scope - && !DECL_IN_SYSTEM_HEADER (x)) - warning (OPT_Wnested_externs, "nested extern declaration of %qD", x); - - while (b && !B_IN_EXTERNAL_SCOPE (b)) - { - /* If this decl might be modified, save its type. This is - done here rather than when the decl is first bound - because the type may change after first binding, through - being completed or through attributes being added. If we - encounter multiple such decls, only the first should have - its type saved; the others will already have had their - proper types saved and the types will not have changed as - their scopes will not have been re-entered. */ - if (DECL_P (b->decl) && DECL_FILE_SCOPE_P (b->decl) && !type_saved) - { - b->u.type = TREE_TYPE (b->decl); - type_saved = true; - } - if (B_IN_FILE_SCOPE (b) - && TREE_CODE (b->decl) == VAR_DECL - && TREE_STATIC (b->decl) - && TREE_CODE (TREE_TYPE (b->decl)) == ARRAY_TYPE - && !TYPE_DOMAIN (TREE_TYPE (b->decl)) - && TREE_CODE (type) == ARRAY_TYPE - && TYPE_DOMAIN (type) - && TYPE_MAX_VALUE (TYPE_DOMAIN (type)) - && !integer_zerop (TYPE_MAX_VALUE (TYPE_DOMAIN (type)))) - { - /* Array type completed in inner scope, which should be - diagnosed if the completion does not have size 1 and - it does not get completed in the file scope. */ - b->inner_comp = true; - } - b = b->shadowed; - } - - /* If a matching external declaration has been found, set its - type to the composite of all the types of that declaration. - After the consistency checks, it will be reset to the - composite of the visible types only. */ - if (b && (TREE_PUBLIC (x) || same_translation_unit_p (x, b->decl)) - && b->u.type) - TREE_TYPE (b->decl) = b->u.type; - - /* The point of the same_translation_unit_p check here is, - we want to detect a duplicate decl for a construct like - foo() { extern bar(); } ... static bar(); but not if - they are in different translation units. In any case, - the static does not go in the externals scope. */ - if (b - && (TREE_PUBLIC (x) || same_translation_unit_p (x, b->decl)) - && duplicate_decls (x, b->decl)) - { - tree thistype; - if (vistype) - { - if (comptypes (vistype, type)) - thistype = composite_type (vistype, type); - else - thistype = TREE_TYPE (b->decl); - } - else - thistype = type; - b->u.type = TREE_TYPE (b->decl); - if (TREE_CODE (b->decl) == FUNCTION_DECL && DECL_BUILT_IN (b->decl)) - thistype - = build_type_attribute_variant (thistype, - TYPE_ATTRIBUTES (b->u.type)); - TREE_TYPE (b->decl) = thistype; - bind (name, b->decl, scope, /*invisible=*/false, /*nested=*/true, - locus); - return b->decl; - } - else if (TREE_PUBLIC (x)) - { - if (visdecl && !b && duplicate_decls (x, visdecl)) - { - /* An external declaration at block scope referring to a - visible entity with internal linkage. The composite - type will already be correct for this scope, so we - just need to fall through to make the declaration in - this scope. */ - nested = true; - x = visdecl; - } - else - { - bind (name, x, external_scope, /*invisible=*/true, - /*nested=*/false, locus); - nested = true; - } - } - } - - if (TREE_CODE (x) != PARM_DECL) - warn_if_shadowing (x); - - skip_external_and_shadow_checks: - if (TREE_CODE (x) == TYPE_DECL) - { - /* So this is a typedef, set its underlying type. */ - set_underlying_type (x); - - /* If X is a typedef defined in the current function, record it - for the purpose of implementing the -Wunused-local-typedefs - warning. */ - record_locally_defined_typedef (x); - } - - bind (name, x, scope, /*invisible=*/false, nested, locus); - - /* If x's type is incomplete because it's based on a - structure or union which has not yet been fully declared, - attach it to that structure or union type, so we can go - back and complete the variable declaration later, if the - structure or union gets fully declared. - - 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 - incomplete type. */ - if (TREE_TYPE (x) != error_mark_node - && !COMPLETE_TYPE_P (TREE_TYPE (x))) - { - tree element = TREE_TYPE (x); - - while (TREE_CODE (element) == ARRAY_TYPE) - element = TREE_TYPE (element); - element = TYPE_MAIN_VARIANT (element); - - if ((TREE_CODE (element) == RECORD_TYPE - || TREE_CODE (element) == UNION_TYPE) - && (TREE_CODE (x) != TYPE_DECL - || TREE_CODE (TREE_TYPE (x)) == ARRAY_TYPE) - && !COMPLETE_TYPE_P (element)) - C_TYPE_INCOMPLETE_VARS (element) - = tree_cons (NULL_TREE, x, C_TYPE_INCOMPLETE_VARS (element)); - } - return x; -} - -/* Record X as belonging to file scope. - This is used only internally by the Objective-C front end, - and is limited to its needs. duplicate_decls is not called; - if there is any preexisting decl for this identifier, it is an ICE. */ - -tree -pushdecl_top_level (tree x) -{ - tree name; - bool nested = false; - gcc_assert (TREE_CODE (x) == VAR_DECL || TREE_CODE (x) == CONST_DECL); - - name = DECL_NAME (x); - - gcc_assert (TREE_CODE (x) == CONST_DECL || !I_SYMBOL_BINDING (name)); - - if (TREE_PUBLIC (x)) - { - bind (name, x, external_scope, /*invisible=*/true, /*nested=*/false, - UNKNOWN_LOCATION); - nested = true; - } - if (file_scope) - bind (name, x, file_scope, /*invisible=*/false, nested, UNKNOWN_LOCATION); - - return x; -} - -static void -implicit_decl_warning (tree id, tree olddecl) -{ - if (warn_implicit_function_declaration) - { - bool warned; - - if (flag_isoc99) - warned = pedwarn (input_location, OPT_Wimplicit_function_declaration, - "implicit declaration of function %qE", id); - else - warned = warning (OPT_Wimplicit_function_declaration, - G_("implicit declaration of function %qE"), id); - if (olddecl && warned) - locate_old_decl (olddecl); - } -} - -/* Generate an implicit declaration for identifier FUNCTIONID at LOC as a - function of type int (). */ - -tree -implicitly_declare (location_t loc, tree functionid) -{ - struct c_binding *b; - tree decl = 0; - tree asmspec_tree; - - for (b = I_SYMBOL_BINDING (functionid); b; b = b->shadowed) - { - if (B_IN_SCOPE (b, external_scope)) - { - decl = b->decl; - break; - } - } - - if (decl) - { - if (decl == error_mark_node) - return decl; - - /* FIXME: Objective-C has weird not-really-builtin functions - which are supposed to be visible automatically. They wind up - in the external scope because they're pushed before the file - scope gets created. Catch this here and rebind them into the - file scope. */ - if (!DECL_BUILT_IN (decl) && DECL_IS_BUILTIN (decl)) - { - bind (functionid, decl, file_scope, - /*invisible=*/false, /*nested=*/true, - DECL_SOURCE_LOCATION (decl)); - return decl; - } - else - { - tree newtype = default_function_type; - if (b->u.type) - TREE_TYPE (decl) = b->u.type; - /* Implicit declaration of a function already declared - (somehow) in a different scope, or as a built-in. - If this is the first time this has happened, warn; - then recycle the old declaration but with the new type. */ - if (!C_DECL_IMPLICIT (decl)) - { - implicit_decl_warning (functionid, decl); - C_DECL_IMPLICIT (decl) = 1; - } - if (DECL_BUILT_IN (decl)) - { - newtype = build_type_attribute_variant (newtype, - TYPE_ATTRIBUTES - (TREE_TYPE (decl))); - if (!comptypes (newtype, TREE_TYPE (decl))) - { - warning_at (loc, 0, "incompatible implicit declaration of " - "built-in function %qD", decl); - newtype = TREE_TYPE (decl); - } - } - else - { - if (!comptypes (newtype, TREE_TYPE (decl))) - { - error_at (loc, "incompatible implicit declaration of function %qD", decl); - locate_old_decl (decl); - } - } - b->u.type = TREE_TYPE (decl); - TREE_TYPE (decl) = newtype; - bind (functionid, decl, current_scope, - /*invisible=*/false, /*nested=*/true, - DECL_SOURCE_LOCATION (decl)); - return decl; - } - } - - /* Not seen before. */ - decl = build_decl (loc, FUNCTION_DECL, functionid, default_function_type); - DECL_EXTERNAL (decl) = 1; - TREE_PUBLIC (decl) = 1; - C_DECL_IMPLICIT (decl) = 1; - implicit_decl_warning (functionid, 0); - asmspec_tree = maybe_apply_renaming_pragma (decl, /*asmname=*/NULL); - if (asmspec_tree) - set_user_assembler_name (decl, TREE_STRING_POINTER (asmspec_tree)); - - /* C89 says implicit declarations are in the innermost block. - So we record the decl in the standard fashion. */ - decl = pushdecl (decl); - - /* No need to call objc_check_decl here - it's a function type. */ - rest_of_decl_compilation (decl, 0, 0); - - /* Write a record describing this implicit function declaration - to the prototypes file (if requested). */ - gen_aux_info_record (decl, 0, 1, 0); - - /* Possibly apply some default attributes to this implicit declaration. */ - decl_attributes (&decl, NULL_TREE, 0); - - return decl; -} - -/* Issue an error message for a reference to an undeclared variable - ID, including a reference to a builtin outside of function-call - context. Establish a binding of the identifier to error_mark_node - in an appropriate scope, which will suppress further errors for the - same identifier. The error message should be given location LOC. */ -void -undeclared_variable (location_t loc, tree id) -{ - static bool already = false; - struct c_scope *scope; - - if (current_function_decl == 0) - { - error_at (loc, "%qE undeclared here (not in a function)", id); - scope = current_scope; - } - else - { - if (!objc_diagnose_private_ivar (id)) - error_at (loc, "%qE undeclared (first use in this function)", id); - if (!already) - { - inform (loc, "each undeclared identifier is reported only" - " once for each function it appears in"); - already = true; - } - - /* If we are parsing old-style parameter decls, current_function_decl - will be nonnull but current_function_scope will be null. */ - scope = current_function_scope ? current_function_scope : current_scope; - } - bind (id, error_mark_node, scope, /*invisible=*/false, /*nested=*/false, - UNKNOWN_LOCATION); -} - -/* Subroutine of lookup_label, declare_label, define_label: construct a - LABEL_DECL with all the proper frills. Also create a struct - c_label_vars initialized for the current scope. */ - -static tree -make_label (location_t location, tree name, bool defining, - struct c_label_vars **p_label_vars) -{ - tree label = build_decl (location, LABEL_DECL, name, void_type_node); - struct c_label_vars *label_vars; - - DECL_CONTEXT (label) = current_function_decl; - DECL_MODE (label) = VOIDmode; - - label_vars = ggc_alloc_c_label_vars (); - label_vars->shadowed = NULL; - set_spot_bindings (&label_vars->label_bindings, defining); - label_vars->decls_in_scope = make_tree_vector (); - label_vars->gotos = NULL; - *p_label_vars = label_vars; - - return label; -} - -/* Get the LABEL_DECL corresponding to identifier NAME as a label. - Create one if none exists so far for the current function. - This is called when a label is used in a goto expression or - has its address taken. */ - -tree -lookup_label (tree name) -{ - tree label; - struct c_label_vars *label_vars; - - if (current_function_scope == 0) - { - error ("label %qE referenced outside of any function", name); - return 0; - } - - /* 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 - using __label__. */ - label = I_LABEL_DECL (name); - if (label && (DECL_CONTEXT (label) == current_function_decl - || C_DECLARED_LABEL_FLAG (label))) - { - /* If the label has only been declared, update its apparent - location to point here, for better diagnostics if it - turns out not to have been defined. */ - if (DECL_INITIAL (label) == NULL_TREE) - DECL_SOURCE_LOCATION (label) = input_location; - return label; - } - - /* No label binding for that identifier; make one. */ - label = make_label (input_location, name, false, &label_vars); - - /* Ordinary labels go in the current function scope. */ - bind_label (name, label, current_function_scope, label_vars); - - return label; -} - -/* Issue a warning about DECL for a goto statement at GOTO_LOC going - to LABEL. */ - -static void -warn_about_goto (location_t goto_loc, tree label, tree decl) -{ - if (variably_modified_type_p (TREE_TYPE (decl), NULL_TREE)) - error_at (goto_loc, - "jump into scope of identifier with variably modified type"); - else - warning_at (goto_loc, OPT_Wjump_misses_init, - "jump skips variable initialization"); - inform (DECL_SOURCE_LOCATION (label), "label %qD defined here", label); - inform (DECL_SOURCE_LOCATION (decl), "%qD declared here", decl); -} - -/* Look up a label because of a goto statement. This is like - lookup_label, but also issues any appropriate warnings. */ - -tree -lookup_label_for_goto (location_t loc, tree name) -{ - tree label; - struct c_label_vars *label_vars; - unsigned int ix; - tree decl; - - label = lookup_label (name); - if (label == NULL_TREE) - return NULL_TREE; - - /* If we are jumping to a different function, we can't issue any - useful warnings. */ - if (DECL_CONTEXT (label) != current_function_decl) - { - gcc_assert (C_DECLARED_LABEL_FLAG (label)); - return label; - } - - label_vars = I_LABEL_BINDING (name)->u.label; - - /* If the label has not yet been defined, then push this goto on a - list for possible later warnings. */ - if (label_vars->label_bindings.scope == NULL) - { - struct c_goto_bindings *g; - - g = ggc_alloc_c_goto_bindings (); - g->loc = loc; - set_spot_bindings (&g->goto_bindings, true); - vec_safe_push (label_vars->gotos, g); - return label; - } - - /* 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 - case like - int i = 1; - lab: - ... - goto lab; - Issue a warning or error. */ - FOR_EACH_VEC_SAFE_ELT (label_vars->decls_in_scope, ix, decl) - warn_about_goto (loc, label, decl); - - if (label_vars->label_bindings.left_stmt_expr) - { - error_at (loc, "jump into statement expression"); - inform (DECL_SOURCE_LOCATION (label), "label %qD defined here", label); - } - - return label; -} - -/* Make a label named NAME in the current function, shadowing silently - any that may be inherited from containing functions or containing - scopes. This is called for __label__ declarations. */ - -tree -declare_label (tree name) -{ - struct c_binding *b = I_LABEL_BINDING (name); - tree label; - struct c_label_vars *label_vars; - - /* Check to make sure that the label hasn't already been declared - at this scope */ - if (b && B_IN_CURRENT_SCOPE (b)) - { - error ("duplicate label declaration %qE", name); - locate_old_decl (b->decl); - - /* Just use the previous declaration. */ - return b->decl; - } - - label = make_label (input_location, name, false, &label_vars); - C_DECLARED_LABEL_FLAG (label) = 1; - - /* Declared labels go in the current scope. */ - bind_label (name, label, current_scope, label_vars); - - return label; -} - -/* When we define a label, issue any appropriate warnings if there are - any gotos earlier in the function which jump to this label. */ - -static void -check_earlier_gotos (tree label, struct c_label_vars* label_vars) -{ - unsigned int ix; - struct c_goto_bindings *g; - - FOR_EACH_VEC_SAFE_ELT (label_vars->gotos, ix, g) - { - struct c_binding *b; - struct c_scope *scope; - - /* 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 - defined after g->bindings_in_scope. */ - if (g->goto_bindings.scope->has_jump_unsafe_decl) - { - for (b = g->goto_bindings.scope->bindings; - b != g->goto_bindings.bindings_in_scope; - b = b->prev) - { - if (decl_jump_unsafe (b->decl)) - warn_about_goto (g->loc, label, b->decl); - } - } - - /* We also need to warn about decls defined in any scopes - between the scope of the label and the scope of the goto. */ - for (scope = label_vars->label_bindings.scope; - scope != g->goto_bindings.scope; - scope = scope->outer) - { - gcc_assert (scope != NULL); - if (scope->has_jump_unsafe_decl) - { - if (scope == label_vars->label_bindings.scope) - b = label_vars->label_bindings.bindings_in_scope; - else - b = scope->bindings; - for (; b != NULL; b = b->prev) - { - if (decl_jump_unsafe (b->decl)) - warn_about_goto (g->loc, label, b->decl); - } - } - } - - if (g->goto_bindings.stmt_exprs > 0) - { - error_at (g->loc, "jump into statement expression"); - inform (DECL_SOURCE_LOCATION (label), "label %qD defined here", - label); - } - } - - /* Now that the label is defined, we will issue warnings about - subsequent gotos to this label when we see them. */ - vec_safe_truncate (label_vars->gotos, 0); - label_vars->gotos = NULL; -} - -/* Define a label, specifying the location in the source file. - Return the LABEL_DECL node for the label, if the definition is valid. - Otherwise return 0. */ - -tree -define_label (location_t location, tree name) -{ - /* Find any preexisting label with this name. It is an error - if that label has already been defined in this function, or - if there is a containing function with a declared label with - the same name. */ - tree label = I_LABEL_DECL (name); - - if (label - && ((DECL_CONTEXT (label) == current_function_decl - && DECL_INITIAL (label) != 0) - || (DECL_CONTEXT (label) != current_function_decl - && C_DECLARED_LABEL_FLAG (label)))) - { - error_at (location, "duplicate label %qD", label); - locate_old_decl (label); - return 0; - } - else if (label && DECL_CONTEXT (label) == current_function_decl) - { - struct c_label_vars *label_vars = I_LABEL_BINDING (name)->u.label; - - /* The label has been used or declared already in this function, - but not defined. Update its location to point to this - definition. */ - DECL_SOURCE_LOCATION (label) = location; - set_spot_bindings (&label_vars->label_bindings, true); - - /* Issue warnings as required about any goto statements from - earlier in the function. */ - check_earlier_gotos (label, label_vars); - } - else - { - struct c_label_vars *label_vars; - - /* No label binding for that identifier; make one. */ - label = make_label (location, name, true, &label_vars); - - /* Ordinary labels go in the current function scope. */ - bind_label (name, label, current_function_scope, label_vars); - } - - if (!in_system_header && lookup_name (name)) - warning_at (location, OPT_Wtraditional, - "traditional C lacks a separate namespace " - "for labels, identifier %qE conflicts", name); - - /* Mark label as having been defined. */ - DECL_INITIAL (label) = error_mark_node; - return label; -} - -/* Get the bindings for a new switch statement. This is used to issue - warnings as appropriate for jumps from the switch to case or - default labels. */ - -struct c_spot_bindings * -c_get_switch_bindings (void) -{ - struct c_spot_bindings *switch_bindings; - - switch_bindings = XNEW (struct c_spot_bindings); - set_spot_bindings (switch_bindings, true); - return switch_bindings; -} - -void -c_release_switch_bindings (struct c_spot_bindings *bindings) -{ - gcc_assert (bindings->stmt_exprs == 0 && !bindings->left_stmt_expr); - XDELETE (bindings); -} - -/* 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 - error, not just a warning. */ - -bool -c_check_switch_jump_warnings (struct c_spot_bindings *switch_bindings, - location_t switch_loc, location_t case_loc) -{ - bool saw_error; - struct c_scope *scope; - - saw_error = false; - for (scope = current_scope; - scope != switch_bindings->scope; - scope = scope->outer) - { - struct c_binding *b; - - gcc_assert (scope != NULL); - - if (!scope->has_jump_unsafe_decl) - continue; - - for (b = scope->bindings; b != NULL; b = b->prev) - { - if (decl_jump_unsafe (b->decl)) - { - if (variably_modified_type_p (TREE_TYPE (b->decl), NULL_TREE)) - { - saw_error = true; - error_at (case_loc, - ("switch jumps into scope of identifier with " - "variably modified type")); - } - else - warning_at (case_loc, OPT_Wjump_misses_init, - "switch jumps over variable initialization"); - inform (switch_loc, "switch starts here"); - inform (DECL_SOURCE_LOCATION (b->decl), "%qD declared here", - b->decl); - } - } - } - - if (switch_bindings->stmt_exprs > 0) - { - saw_error = true; - error_at (case_loc, "switch jumps into statement expression"); - inform (switch_loc, "switch starts here"); - } - - return saw_error; -} - -/* Given NAME, an IDENTIFIER_NODE, - return the structure (or union or enum) definition for that name. - If THISLEVEL_ONLY is nonzero, searches only the current_scope. - CODE says which kind of type the caller wants; - 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 - location where the tag was defined. - If the wrong kind of type is found, an error is reported. */ - -static tree -lookup_tag (enum tree_code code, tree name, int thislevel_only, - location_t *ploc) -{ - struct c_binding *b = I_TAG_BINDING (name); - int thislevel = 0; - - if (!b || !b->decl) - return 0; - - /* We only care about whether it's in this level if - thislevel_only was set or it might be a type clash. */ - if (thislevel_only || TREE_CODE (b->decl) != code) - { - /* For our purposes, a tag in the external scope is the same as - a tag in the file scope. (Primarily relevant to Objective-C - and its builtin structure tags, which get pushed before the - file scope is created.) */ - if (B_IN_CURRENT_SCOPE (b) - || (current_scope == file_scope && B_IN_EXTERNAL_SCOPE (b))) - thislevel = 1; - } - - if (thislevel_only && !thislevel) - return 0; - - if (TREE_CODE (b->decl) != code) - { - /* Definition isn't the kind we were looking for. */ - pending_invalid_xref = name; - pending_invalid_xref_location = input_location; - - /* If in the same binding level as a declaration as a tag - of a different type, this must not be allowed to - shadow that tag, so give the error immediately. - (For example, "struct foo; union foo;" is invalid.) */ - if (thislevel) - pending_xref_error (); - } - - if (ploc != NULL) - *ploc = b->locus; - - return b->decl; -} - -/* Print an error message now - for a recent invalid struct, union or enum cross reference. - We don't print them immediately because they are not invalid - when used in the `struct foo;' construct for shadowing. */ - -void -pending_xref_error (void) -{ - if (pending_invalid_xref != 0) - error_at (pending_invalid_xref_location, "%qE defined as wrong kind of tag", - pending_invalid_xref); - pending_invalid_xref = 0; -} - - -/* Look up NAME in the current scope and its superiors - in the namespace of variables, functions and typedefs. - Return a ..._DECL node of some kind representing its definition, - or return 0 if it is undefined. */ - -tree -lookup_name (tree name) -{ - struct c_binding *b = I_SYMBOL_BINDING (name); - if (b && !b->invisible) - { - maybe_record_typedef_use (b->decl); - return b->decl; - } - return 0; -} - -/* Similar to `lookup_name' but look only at the indicated scope. */ - -static tree -lookup_name_in_scope (tree name, struct c_scope *scope) -{ - struct c_binding *b; - - for (b = I_SYMBOL_BINDING (name); b; b = b->shadowed) - if (B_IN_SCOPE (b, scope)) - return b->decl; - return 0; -} - -/* Create the predefined scalar types of C, - and some nodes representing standard constants (0, 1, (void *) 0). - Initialize the global scope. - Make definitions for built-in primitive functions. */ - -void -c_init_decl_processing (void) -{ - location_t save_loc = input_location; - - /* Initialize reserved words for parser. */ - c_parse_init (); - - current_function_decl = 0; - - gcc_obstack_init (&parser_obstack); - - /* Make the externals scope. */ - push_scope (); - external_scope = current_scope; - - /* Declarations from c_common_nodes_and_builtins must not be associated - with this input file, lest we get differences between using and not - using preprocessed headers. */ - input_location = BUILTINS_LOCATION; - - c_common_nodes_and_builtins (); - - /* In C, comparisons and TRUTH_* expressions have type int. */ - truthvalue_type_node = integer_type_node; - truthvalue_true_node = integer_one_node; - truthvalue_false_node = integer_zero_node; - - /* Even in C99, which has a real boolean type. */ - pushdecl (build_decl (UNKNOWN_LOCATION, TYPE_DECL, get_identifier ("_Bool"), - boolean_type_node)); - - input_location = save_loc; - - pedantic_lvalues = true; - - make_fname_decl = c_make_fname_decl; - start_fname_decls (); -} - -/* 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 - indicates whether NAME depended on the type of the function. As we - 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 - it must therefore pull out the STRING_CST initializer directly. - FIXME. */ - -static tree -c_make_fname_decl (location_t loc, tree id, int type_dep) -{ - const char *name = fname_as_string (type_dep); - tree decl, type, init; - size_t length = strlen (name); - - type = build_array_type (char_type_node, - build_index_type (size_int (length))); - type = c_build_qualified_type (type, TYPE_QUAL_CONST); - - decl = build_decl (loc, VAR_DECL, id, type); - - TREE_STATIC (decl) = 1; - TREE_READONLY (decl) = 1; - DECL_ARTIFICIAL (decl) = 1; - - init = build_string (length + 1, name); - free (CONST_CAST (char *, name)); - TREE_TYPE (init) = type; - DECL_INITIAL (decl) = init; - - TREE_USED (decl) = 1; - - if (current_function_decl - /* For invalid programs like this: - - void foo() - const char* p = __FUNCTION__; - - the __FUNCTION__ is believed to appear in K&R style function - parameter declarator. In that case we still don't have - function_scope. */ - && (!seen_error () || current_function_scope)) - { - DECL_CONTEXT (decl) = current_function_decl; - bind (id, decl, current_function_scope, - /*invisible=*/false, /*nested=*/false, UNKNOWN_LOCATION); - } - - finish_decl (decl, loc, init, NULL_TREE, NULL_TREE); - - return decl; -} - -tree -c_builtin_function (tree decl) -{ - tree type = TREE_TYPE (decl); - tree id = DECL_NAME (decl); - - const char *name = IDENTIFIER_POINTER (id); - C_DECL_BUILTIN_PROTOTYPE (decl) = prototype_p (type); - - /* Should never be called on a symbol with a preexisting meaning. */ - gcc_assert (!I_SYMBOL_BINDING (id)); - - bind (id, decl, external_scope, /*invisible=*/true, /*nested=*/false, - UNKNOWN_LOCATION); - - /* Builtins in the implementation namespace are made visible without - needing to be explicitly declared. See push_file_scope. */ - if (name[0] == '_' && (name[1] == '_' || ISUPPER (name[1]))) - { - DECL_CHAIN (decl) = visible_builtins; - visible_builtins = decl; - } - - return decl; -} - -tree -c_builtin_function_ext_scope (tree decl) -{ - tree type = TREE_TYPE (decl); - tree id = DECL_NAME (decl); - - const char *name = IDENTIFIER_POINTER (id); - C_DECL_BUILTIN_PROTOTYPE (decl) = prototype_p (type); - - /* Should never be called on a symbol with a preexisting meaning. */ - gcc_assert (!I_SYMBOL_BINDING (id)); - - bind (id, decl, external_scope, /*invisible=*/false, /*nested=*/false, - UNKNOWN_LOCATION); - - /* Builtins in the implementation namespace are made visible without - needing to be explicitly declared. See push_file_scope. */ - if (name[0] == '_' && (name[1] == '_' || ISUPPER (name[1]))) - { - DECL_CHAIN (decl) = visible_builtins; - visible_builtins = decl; - } - - return decl; -} - -/* 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 - from a containing scope, shadow that tag name for the current scope - with a forward reference. - If its type defines a new named structure or union - or defines an enum, it is valid but we need not do anything here. - Otherwise, it is an error. */ - -void -shadow_tag (const struct c_declspecs *declspecs) -{ - shadow_tag_warned (declspecs, 0); -} - -/* WARNED is 1 if we have done a pedwarn, 2 if we have done a warning, - but no pedwarn. */ -void -shadow_tag_warned (const struct c_declspecs *declspecs, int warned) -{ - bool found_tag = false; - - if (declspecs->type && !declspecs->default_int_p && !declspecs->typedef_p) - { - tree value = declspecs->type; - enum tree_code code = TREE_CODE (value); - - if (code == RECORD_TYPE || code == UNION_TYPE || code == ENUMERAL_TYPE) - /* Used to test also that TYPE_SIZE (value) != 0. - That caused warning for `struct foo;' at top level in the file. */ - { - tree name = TYPE_NAME (value); - tree t; - - found_tag = true; - - if (declspecs->restrict_p) - { - error ("invalid use of %<restrict%>"); - warned = 1; - } - - if (name == 0) - { - if (warned != 1 && code != ENUMERAL_TYPE) - /* Empty unnamed enum OK */ - { - pedwarn (input_location, 0, - "unnamed struct/union that defines no instances"); - warned = 1; - } - } - else if (declspecs->typespec_kind != ctsk_tagdef - && declspecs->typespec_kind != ctsk_tagfirstref - && declspecs->storage_class != csc_none) - { - if (warned != 1) - pedwarn (input_location, 0, - "empty declaration with storage class specifier " - "does not redeclare tag"); - warned = 1; - pending_xref_error (); - } - else if (declspecs->typespec_kind != ctsk_tagdef - && declspecs->typespec_kind != ctsk_tagfirstref - && (declspecs->const_p - || declspecs->volatile_p - || declspecs->restrict_p - || declspecs->address_space)) - { - if (warned != 1) - pedwarn (input_location, 0, - "empty declaration with type qualifier " - "does not redeclare tag"); - warned = 1; - pending_xref_error (); - } - else if (declspecs->typespec_kind != ctsk_tagdef - && declspecs->typespec_kind != ctsk_tagfirstref - && declspecs->alignas_p) - { - if (warned != 1) - pedwarn (input_location, 0, - "empty declaration with %<_Alignas%> " - "does not redeclare tag"); - warned = 1; - pending_xref_error (); - } - else - { - pending_invalid_xref = 0; - t = lookup_tag (code, name, 1, NULL); - - if (t == 0) - { - t = make_node (code); - pushtag (input_location, name, t); - } - } - } - else - { - if (warned != 1 && !in_system_header) - { - pedwarn (input_location, 0, - "useless type name in empty declaration"); - warned = 1; - } - } - } - else if (warned != 1 && !in_system_header && declspecs->typedef_p) - { - pedwarn (input_location, 0, "useless type name in empty declaration"); - warned = 1; - } - - pending_invalid_xref = 0; - - if (declspecs->inline_p) - { - error ("%<inline%> in empty declaration"); - warned = 1; - } - - if (declspecs->noreturn_p) - { - error ("%<_Noreturn%> in empty declaration"); - warned = 1; - } - - if (current_scope == file_scope && declspecs->storage_class == csc_auto) - { - error ("%<auto%> in file-scope empty declaration"); - warned = 1; - } - - if (current_scope == file_scope && declspecs->storage_class == csc_register) - { - error ("%<register%> in file-scope empty declaration"); - warned = 1; - } - - if (!warned && !in_system_header && declspecs->storage_class != csc_none) - { - warning (0, "useless storage class specifier in empty declaration"); - warned = 2; - } - - if (!warned && !in_system_header && declspecs->thread_p) - { - warning (0, "useless %<__thread%> in empty declaration"); - warned = 2; - } - - if (!warned && !in_system_header && (declspecs->const_p - || declspecs->volatile_p - || declspecs->restrict_p - || declspecs->address_space)) - { - warning (0, "useless type qualifier in empty declaration"); - warned = 2; - } - - if (!warned && !in_system_header && declspecs->alignas_p) - { - warning (0, "useless %<_Alignas%> in empty declaration"); - warned = 2; - } - - if (warned != 1) - { - if (!found_tag) - pedwarn (input_location, 0, "empty declaration"); - } -} - - -/* Return the qualifiers from SPECS as a bitwise OR of TYPE_QUAL_* - bits. SPECS represents declaration specifiers that the grammar - only permits to contain type qualifiers and attributes. */ - -int -quals_from_declspecs (const struct c_declspecs *specs) -{ - int quals = ((specs->const_p ? TYPE_QUAL_CONST : 0) - | (specs->volatile_p ? TYPE_QUAL_VOLATILE : 0) - | (specs->restrict_p ? TYPE_QUAL_RESTRICT : 0) - | (ENCODE_QUAL_ADDR_SPACE (specs->address_space))); - gcc_assert (!specs->type - && !specs->decl_attr - && specs->typespec_word == cts_none - && specs->storage_class == csc_none - && !specs->typedef_p - && !specs->explicit_signed_p - && !specs->deprecated_p - && !specs->long_p - && !specs->long_long_p - && !specs->short_p - && !specs->signed_p - && !specs->unsigned_p - && !specs->complex_p - && !specs->inline_p - && !specs->noreturn_p - && !specs->thread_p); - return quals; -} - -/* Construct an array declarator. LOC is the location of the - beginning of the array (usually the opening brace). EXPR is the - expression inside [], or NULL_TREE. QUALS are the type qualifiers - inside the [] (to be applied to the pointer to which a parameter - array is converted). STATIC_P is true if "static" is inside the - [], false otherwise. VLA_UNSPEC_P is true if the array is [*], a - VLA of unspecified length which is nevertheless a complete type, - false otherwise. The field for the contained declarator is left to - be filled in by set_array_declarator_inner. */ - -struct c_declarator * -build_array_declarator (location_t loc, - tree expr, struct c_declspecs *quals, bool static_p, - bool vla_unspec_p) -{ - struct c_declarator *declarator = XOBNEW (&parser_obstack, - struct c_declarator); - declarator->id_loc = loc; - declarator->kind = cdk_array; - declarator->declarator = 0; - declarator->u.array.dimen = expr; - if (quals) - { - declarator->u.array.attrs = quals->attrs; - declarator->u.array.quals = quals_from_declspecs (quals); - } - else - { - declarator->u.array.attrs = NULL_TREE; - declarator->u.array.quals = 0; - } - declarator->u.array.static_p = static_p; - declarator->u.array.vla_unspec_p = vla_unspec_p; - if (!flag_isoc99) - { - if (static_p || quals != NULL) - pedwarn (loc, OPT_Wpedantic, - "ISO C90 does not support %<static%> or type " - "qualifiers in parameter array declarators"); - if (vla_unspec_p) - pedwarn (loc, OPT_Wpedantic, - "ISO C90 does not support %<[*]%> array declarators"); - } - if (vla_unspec_p) - { - if (!current_scope->parm_flag) - { - /* C99 6.7.5.2p4 */ - error_at (loc, "%<[*]%> not allowed in other than " - "function prototype scope"); - declarator->u.array.vla_unspec_p = false; - return NULL; - } - current_scope->had_vla_unspec = true; - } - return declarator; -} - -/* Set the contained declarator of an array declarator. DECL is the - declarator, as constructed by build_array_declarator; INNER is what - appears on the left of the []. */ - -struct c_declarator * -set_array_declarator_inner (struct c_declarator *decl, - struct c_declarator *inner) -{ - decl->declarator = inner; - return decl; -} - -/* INIT is a constructor that forms DECL's initializer. If the final - element initializes a flexible array field, add the size of that - initializer to DECL's size. */ - -static void -add_flexible_array_elts_to_size (tree decl, tree init) -{ - tree elt, type; - - if (vec_safe_is_empty (CONSTRUCTOR_ELTS (init))) - return; - - elt = CONSTRUCTOR_ELTS (init)->last ().value; - type = TREE_TYPE (elt); - if (TREE_CODE (type) == ARRAY_TYPE - && TYPE_SIZE (type) == NULL_TREE - && TYPE_DOMAIN (type) != NULL_TREE - && TYPE_MAX_VALUE (TYPE_DOMAIN (type)) == NULL_TREE) - { - complete_array_type (&type, elt, false); - DECL_SIZE (decl) - = size_binop (PLUS_EXPR, DECL_SIZE (decl), TYPE_SIZE (type)); - DECL_SIZE_UNIT (decl) - = size_binop (PLUS_EXPR, DECL_SIZE_UNIT (decl), TYPE_SIZE_UNIT (type)); - } -} - -/* Decode a "typename", such as "int **", returning a ..._TYPE node. - Set *EXPR, if EXPR not NULL, to any expression to be evaluated - before the type name, and set *EXPR_CONST_OPERANDS, if - EXPR_CONST_OPERANDS not NULL, to indicate whether the type name may - appear in a constant expression. */ - -tree -groktypename (struct c_type_name *type_name, tree *expr, - bool *expr_const_operands) -{ - tree type; - tree attrs = type_name->specs->attrs; - - type_name->specs->attrs = NULL_TREE; - - type = grokdeclarator (type_name->declarator, type_name->specs, TYPENAME, - false, NULL, &attrs, expr, expr_const_operands, - DEPRECATED_NORMAL); - - /* Apply attributes. */ - decl_attributes (&type, attrs, 0); - - return type; -} - -/* Decode a declarator in an ordinary declaration or data definition. - This is called as soon as the type information and variable name - have been parsed, before parsing the initializer if any. - Here we create the ..._DECL node, fill in its type, - and put it on the list of decls for the current context. - The ..._DECL node is returned as the value. - - Exception: for arrays where the length is not specified, - the type is left null, to be filled in by `finish_decl'. - - Function definitions do not come here; they go to start_function - instead. However, external and forward declarations of functions - do go through here. Structure field declarations are done by - grokfield and not through here. */ - -tree -start_decl (struct c_declarator *declarator, struct c_declspecs *declspecs, - bool initialized, tree attributes) -{ - tree decl; - tree tem; - tree expr = NULL_TREE; - enum deprecated_states deprecated_state = DEPRECATED_NORMAL; - - /* An object declared as __attribute__((deprecated)) suppresses - warnings of uses of other deprecated items. */ - if (lookup_attribute ("deprecated", attributes)) - deprecated_state = DEPRECATED_SUPPRESS; - - decl = grokdeclarator (declarator, declspecs, - NORMAL, initialized, NULL, &attributes, &expr, NULL, - deprecated_state); - if (!decl) - return 0; - - if (expr) - add_stmt (fold_convert (void_type_node, expr)); - - if (TREE_CODE (decl) != FUNCTION_DECL && MAIN_NAME_P (DECL_NAME (decl))) - warning (OPT_Wmain, "%q+D is usually a function", decl); - - if (initialized) - /* Is it valid for this decl to have an initializer at all? - If not, set INITIALIZED to zero, which will indirectly - tell 'finish_decl' to ignore the initializer once it is parsed. */ - switch (TREE_CODE (decl)) - { - case TYPE_DECL: - error ("typedef %qD is initialized (use __typeof__ instead)", decl); - initialized = 0; - break; - - case FUNCTION_DECL: - error ("function %qD is initialized like a variable", decl); - initialized = 0; - break; - - case PARM_DECL: - /* DECL_INITIAL in a PARM_DECL is really DECL_ARG_TYPE. */ - error ("parameter %qD is initialized", decl); - initialized = 0; - break; - - default: - /* Don't allow initializations for incomplete types except for - arrays which might be completed by the initialization. */ - - /* This can happen if the array size is an undefined macro. - We already gave a warning, so we don't need another one. */ - if (TREE_TYPE (decl) == error_mark_node) - initialized = 0; - else if (COMPLETE_TYPE_P (TREE_TYPE (decl))) - { - /* A complete type is ok if size is fixed. */ - - if (TREE_CODE (TYPE_SIZE (TREE_TYPE (decl))) != INTEGER_CST - || C_DECL_VARIABLE_SIZE (decl)) - { - error ("variable-sized object may not be initialized"); - initialized = 0; - } - } - else if (TREE_CODE (TREE_TYPE (decl)) != ARRAY_TYPE) - { - error ("variable %qD has initializer but incomplete type", decl); - initialized = 0; - } - else if (C_DECL_VARIABLE_SIZE (decl)) - { - /* Although C99 is unclear about whether incomplete arrays - of VLAs themselves count as VLAs, it does not make - sense to permit them to be initialized given that - ordinary VLAs may not be initialized. */ - error ("variable-sized object may not be initialized"); - initialized = 0; - } - } - - if (initialized) - { - if (current_scope == file_scope) - TREE_STATIC (decl) = 1; - - /* Tell 'pushdecl' this is an initialized decl - even though we don't yet have the initializer expression. - Also tell 'finish_decl' it may store the real initializer. */ - DECL_INITIAL (decl) = error_mark_node; - } - - /* If this is a function declaration, write a record describing it to the - prototypes file (if requested). */ - - if (TREE_CODE (decl) == FUNCTION_DECL) - gen_aux_info_record (decl, 0, 0, prototype_p (TREE_TYPE (decl))); - - /* ANSI specifies that a tentative definition which is not merged with - a non-tentative definition behaves exactly like a definition with an - initializer equal to zero. (Section 3.7.2) - - -fno-common gives strict ANSI behavior, though this tends to break - a large body of code that grew up without this rule. - - Thread-local variables are never common, since there's no entrenched - body of code to break, and it allows more efficient variable references - in the presence of dynamic linking. */ - - if (TREE_CODE (decl) == VAR_DECL - && !initialized - && TREE_PUBLIC (decl) - && !DECL_THREAD_LOCAL_P (decl) - && !flag_no_common) - DECL_COMMON (decl) = 1; - - /* Set attributes here so if duplicate decl, will have proper attributes. */ - decl_attributes (&decl, attributes, 0); - - /* Handle gnu_inline attribute. */ - if (declspecs->inline_p - && !flag_gnu89_inline - && TREE_CODE (decl) == FUNCTION_DECL - && (lookup_attribute ("gnu_inline", DECL_ATTRIBUTES (decl)) - || current_function_decl)) - { - if (declspecs->storage_class == csc_auto && current_scope != file_scope) - ; - else if (declspecs->storage_class != csc_static) - DECL_EXTERNAL (decl) = !DECL_EXTERNAL (decl); - } - - if (TREE_CODE (decl) == FUNCTION_DECL - && targetm.calls.promote_prototypes (TREE_TYPE (decl))) - { - struct c_declarator *ce = declarator; - - if (ce->kind == cdk_pointer) - ce = declarator->declarator; - if (ce->kind == cdk_function) - { - tree args = ce->u.arg_info->parms; - for (; args; args = DECL_CHAIN (args)) - { - tree type = TREE_TYPE (args); - if (type && INTEGRAL_TYPE_P (type) - && TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node)) - DECL_ARG_TYPE (args) = integer_type_node; - } - } - } - - if (TREE_CODE (decl) == FUNCTION_DECL - && DECL_DECLARED_INLINE_P (decl) - && DECL_UNINLINABLE (decl) - && lookup_attribute ("noinline", DECL_ATTRIBUTES (decl))) - warning (OPT_Wattributes, "inline function %q+D given attribute noinline", - decl); - - /* C99 6.7.4p3: An inline definition of a function with external - linkage shall not contain a definition of a modifiable object - with static storage duration... */ - if (TREE_CODE (decl) == VAR_DECL - && current_scope != file_scope - && TREE_STATIC (decl) - && !TREE_READONLY (decl) - && DECL_DECLARED_INLINE_P (current_function_decl) - && DECL_EXTERNAL (current_function_decl)) - record_inline_static (input_location, current_function_decl, - decl, csi_modifiable); - - if (c_dialect_objc () - && (TREE_CODE (decl) == VAR_DECL - || TREE_CODE (decl) == FUNCTION_DECL)) - objc_check_global_decl (decl); - - /* Add this decl to the current scope. - TEM may equal DECL or it may be a previous decl of the same name. */ - tem = pushdecl (decl); - - if (initialized && DECL_EXTERNAL (tem)) - { - DECL_EXTERNAL (tem) = 0; - TREE_STATIC (tem) = 1; - } - - return tem; -} - -/* Subroutine of finish_decl. TYPE is the type of an uninitialized object - DECL or the non-array element type if DECL is an uninitialized array. - If that type has a const member, diagnose this. */ - -static void -diagnose_uninitialized_cst_member (tree decl, tree type) -{ - tree field; - for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field)) - { - tree field_type; - if (TREE_CODE (field) != FIELD_DECL) - continue; - field_type = strip_array_types (TREE_TYPE (field)); - - if (TYPE_QUALS (field_type) & TYPE_QUAL_CONST) - { - warning_at (DECL_SOURCE_LOCATION (decl), OPT_Wc___compat, - "uninitialized const member in %qT is invalid in C++", - strip_array_types (TREE_TYPE (decl))); - inform (DECL_SOURCE_LOCATION (field), "%qD should be initialized", field); - } - - if (TREE_CODE (field_type) == RECORD_TYPE - || TREE_CODE (field_type) == UNION_TYPE) - diagnose_uninitialized_cst_member (decl, field_type); - } -} - -/* Finish processing of a declaration; - install its initial value. - If ORIGTYPE is not NULL_TREE, it is the original type of INIT. - 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. - - INIT_LOC is the location of the initial value. */ - -void -finish_decl (tree decl, location_t init_loc, tree init, - tree origtype, tree asmspec_tree) -{ - tree type; - bool was_incomplete = (DECL_SIZE (decl) == 0); - const char *asmspec = 0; - - /* If a name was specified, get the string. */ - if ((TREE_CODE (decl) == FUNCTION_DECL || TREE_CODE (decl) == VAR_DECL) - && DECL_FILE_SCOPE_P (decl)) - asmspec_tree = maybe_apply_renaming_pragma (decl, asmspec_tree); - if (asmspec_tree) - asmspec = TREE_STRING_POINTER (asmspec_tree); - - if (TREE_CODE (decl) == VAR_DECL - && TREE_STATIC (decl) - && global_bindings_p ()) - /* So decl is a global variable. Record the types it uses - so that we can decide later to emit debug info for them. */ - record_types_used_by_current_var_decl (decl); - - /* If `start_decl' didn't like having an initialization, ignore it now. */ - if (init != 0 && DECL_INITIAL (decl) == 0) - init = 0; - - /* Don't crash if parm is initialized. */ - if (TREE_CODE (decl) == PARM_DECL) - init = 0; - - if (init) - store_init_value (init_loc, decl, init, origtype); - - if (c_dialect_objc () && (TREE_CODE (decl) == VAR_DECL - || TREE_CODE (decl) == FUNCTION_DECL - || TREE_CODE (decl) == FIELD_DECL)) - objc_check_decl (decl); - - type = TREE_TYPE (decl); - - /* Deduce size of array from initialization, if not already known. */ - if (TREE_CODE (type) == ARRAY_TYPE - && TYPE_DOMAIN (type) == 0 - && TREE_CODE (decl) != TYPE_DECL) - { - bool do_default - = (TREE_STATIC (decl) - /* Even if pedantic, an external linkage array - may have incomplete type at first. */ - ? pedantic && !TREE_PUBLIC (decl) - : !DECL_EXTERNAL (decl)); - int failure - = complete_array_type (&TREE_TYPE (decl), DECL_INITIAL (decl), - do_default); - - /* Get the completed type made by complete_array_type. */ - type = TREE_TYPE (decl); - - switch (failure) - { - case 1: - error ("initializer fails to determine size of %q+D", decl); - break; - - case 2: - if (do_default) - error ("array size missing in %q+D", decl); - /* If a `static' var's size isn't known, - make it extern as well as static, so it does not get - allocated. - If it is not `static', then do not mark extern; - finish_incomplete_decl will give it a default size - and it will get allocated. */ - else if (!pedantic && TREE_STATIC (decl) && !TREE_PUBLIC (decl)) - DECL_EXTERNAL (decl) = 1; - break; - - case 3: - error ("zero or negative size array %q+D", decl); - break; - - case 0: - /* For global variables, update the copy of the type that - exists in the binding. */ - if (TREE_PUBLIC (decl)) - { - struct c_binding *b_ext = I_SYMBOL_BINDING (DECL_NAME (decl)); - while (b_ext && !B_IN_EXTERNAL_SCOPE (b_ext)) - b_ext = b_ext->shadowed; - if (b_ext) - { - if (b_ext->u.type && comptypes (b_ext->u.type, type)) - b_ext->u.type = composite_type (b_ext->u.type, type); - else - b_ext->u.type = type; - } - } - break; - - default: - gcc_unreachable (); - } - - if (DECL_INITIAL (decl)) - TREE_TYPE (DECL_INITIAL (decl)) = type; - - relayout_decl (decl); - } - - if (TREE_CODE (decl) == VAR_DECL) - { - if (init && TREE_CODE (init) == CONSTRUCTOR) - add_flexible_array_elts_to_size (decl, init); - - if (DECL_SIZE (decl) == 0 && TREE_TYPE (decl) != error_mark_node - && COMPLETE_TYPE_P (TREE_TYPE (decl))) - layout_decl (decl, 0); - - if (DECL_SIZE (decl) == 0 - /* Don't give an error if we already gave one earlier. */ - && TREE_TYPE (decl) != error_mark_node - && (TREE_STATIC (decl) - /* A static variable with an incomplete type - is an error if it is initialized. - Also if it is not file scope. - Otherwise, let it through, but if it is not `extern' - then it may cause an error message later. */ - ? (DECL_INITIAL (decl) != 0 - || !DECL_FILE_SCOPE_P (decl)) - /* An automatic variable with an incomplete type - is an error. */ - : !DECL_EXTERNAL (decl))) - { - error ("storage size of %q+D isn%'t known", decl); - TREE_TYPE (decl) = error_mark_node; - } - - if ((DECL_EXTERNAL (decl) || TREE_STATIC (decl)) - && DECL_SIZE (decl) != 0) - { - if (TREE_CODE (DECL_SIZE (decl)) == INTEGER_CST) - constant_expression_warning (DECL_SIZE (decl)); - else - { - error ("storage size of %q+D isn%'t constant", decl); - TREE_TYPE (decl) = error_mark_node; - } - } - - if (TREE_USED (type)) - { - TREE_USED (decl) = 1; - DECL_READ_P (decl) = 1; - } - } - - /* If this is a function and an assembler name is specified, reset DECL_RTL - so we can give it its new name. Also, update builtin_decl if it - was a normal built-in. */ - if (TREE_CODE (decl) == FUNCTION_DECL && asmspec) - { - if (DECL_BUILT_IN_CLASS (decl) == BUILT_IN_NORMAL) - set_builtin_user_assembler_name (decl, asmspec); - set_user_assembler_name (decl, asmspec); - } - - /* If #pragma weak was used, mark the decl weak now. */ - maybe_apply_pragma_weak (decl); - - /* Output the assembler code and/or RTL code for variables and functions, - unless the type is an undefined structure or union. - If not, it will get done when the type is completed. */ - - if (TREE_CODE (decl) == VAR_DECL || TREE_CODE (decl) == FUNCTION_DECL) - { - /* Determine the ELF visibility. */ - if (TREE_PUBLIC (decl)) - c_determine_visibility (decl); - - /* This is a no-op in c-lang.c or something real in objc-act.c. */ - if (c_dialect_objc ()) - objc_check_decl (decl); - - if (asmspec) - { - /* If this is not a static variable, issue a warning. - It doesn't make any sense to give an ASMSPEC for an - ordinary, non-register local variable. Historically, - GCC has accepted -- but ignored -- the ASMSPEC in - this case. */ - if (!DECL_FILE_SCOPE_P (decl) - && TREE_CODE (decl) == VAR_DECL - && !C_DECL_REGISTER (decl) - && !TREE_STATIC (decl)) - warning (0, "ignoring asm-specifier for non-static local " - "variable %q+D", decl); - else - set_user_assembler_name (decl, asmspec); - } - - if (DECL_FILE_SCOPE_P (decl)) - { - if (DECL_INITIAL (decl) == NULL_TREE - || DECL_INITIAL (decl) == error_mark_node) - /* Don't output anything - when a tentative file-scope definition is seen. - But at end of compilation, do output code for them. */ - DECL_DEFER_OUTPUT (decl) = 1; - if (asmspec && C_DECL_REGISTER (decl)) - DECL_HARD_REGISTER (decl) = 1; - rest_of_decl_compilation (decl, true, 0); - } - else - { - /* In conjunction with an ASMSPEC, the `register' - keyword indicates that we should place the variable - in a particular register. */ - if (asmspec && C_DECL_REGISTER (decl)) - { - DECL_HARD_REGISTER (decl) = 1; - /* This cannot be done for a structure with volatile - fields, on which DECL_REGISTER will have been - reset. */ - if (!DECL_REGISTER (decl)) - error ("cannot put object with volatile field into register"); - } - - if (TREE_CODE (decl) != FUNCTION_DECL) - { - /* If we're building a variable sized type, and we might be - reachable other than via the top of the current binding - level, then create a new BIND_EXPR so that we deallocate - the object at the right time. */ - /* Note that DECL_SIZE can be null due to errors. */ - if (DECL_SIZE (decl) - && !TREE_CONSTANT (DECL_SIZE (decl)) - && STATEMENT_LIST_HAS_LABEL (cur_stmt_list)) - { - tree bind; - bind = build3 (BIND_EXPR, void_type_node, NULL, NULL, NULL); - TREE_SIDE_EFFECTS (bind) = 1; - add_stmt (bind); - BIND_EXPR_BODY (bind) = push_stmt_list (); - } - add_stmt (build_stmt (DECL_SOURCE_LOCATION (decl), - DECL_EXPR, decl)); - } - } - - - if (!DECL_FILE_SCOPE_P (decl)) - { - /* Recompute the RTL of a local array now - if it used to be an incomplete type. */ - if (was_incomplete - && !TREE_STATIC (decl) && !DECL_EXTERNAL (decl)) - { - /* If we used it already as memory, it must stay in memory. */ - TREE_ADDRESSABLE (decl) = TREE_USED (decl); - /* If it's still incomplete now, no init will save it. */ - if (DECL_SIZE (decl) == 0) - DECL_INITIAL (decl) = 0; - } - } - } - - if (TREE_CODE (decl) == TYPE_DECL) - { - if (!DECL_FILE_SCOPE_P (decl) - && variably_modified_type_p (TREE_TYPE (decl), NULL_TREE)) - add_stmt (build_stmt (DECL_SOURCE_LOCATION (decl), DECL_EXPR, decl)); - - rest_of_decl_compilation (decl, DECL_FILE_SCOPE_P (decl), 0); - } - - /* Install a cleanup (aka destructor) if one was given. */ - if (TREE_CODE (decl) == VAR_DECL && !TREE_STATIC (decl)) - { - tree attr = lookup_attribute ("cleanup", DECL_ATTRIBUTES (decl)); - if (attr) - { - tree cleanup_id = TREE_VALUE (TREE_VALUE (attr)); - tree cleanup_decl = lookup_name (cleanup_id); - tree cleanup; - vec<tree, va_gc> *v; - - /* Build "cleanup(&decl)" for the destructor. */ - cleanup = build_unary_op (input_location, ADDR_EXPR, decl, 0); - vec_alloc (v, 1); - v->quick_push (cleanup); - cleanup = build_function_call_vec (DECL_SOURCE_LOCATION (decl), - cleanup_decl, v, NULL); - vec_free (v); - - /* Don't warn about decl unused; the cleanup uses it. */ - TREE_USED (decl) = 1; - TREE_USED (cleanup_decl) = 1; - DECL_READ_P (decl) = 1; - - push_cleanup (decl, cleanup, false); - } - } - - if (warn_cxx_compat - && TREE_CODE (decl) == VAR_DECL - && !DECL_EXTERNAL (decl) - && DECL_INITIAL (decl) == NULL_TREE) - { - type = strip_array_types (type); - if (TREE_READONLY (decl)) - warning_at (DECL_SOURCE_LOCATION (decl), OPT_Wc___compat, - "uninitialized const %qD is invalid in C++", decl); - else if ((TREE_CODE (type) == RECORD_TYPE - || TREE_CODE (type) == UNION_TYPE) - && C_TYPE_FIELDS_READONLY (type)) - diagnose_uninitialized_cst_member (decl, type); - } - - invoke_plugin_callbacks (PLUGIN_FINISH_DECL, decl); -} - -/* Given a parsed parameter declaration, decode it into a PARM_DECL. - EXPR is NULL or a pointer to an expression that needs to be - evaluated for the side effects of array size expressions in the - parameters. */ - -tree -grokparm (const struct c_parm *parm, tree *expr) -{ - tree attrs = parm->attrs; - tree decl = grokdeclarator (parm->declarator, parm->specs, PARM, false, - NULL, &attrs, expr, NULL, DEPRECATED_NORMAL); - - decl_attributes (&decl, attrs, 0); - - return decl; -} - -/* Given a parsed parameter declaration, decode it into a PARM_DECL - and push that on the current scope. EXPR is a pointer to an - expression that needs to be evaluated for the side effects of array - size expressions in the parameters. */ - -void -push_parm_decl (const struct c_parm *parm, tree *expr) -{ - tree attrs = parm->attrs; - tree decl; - - decl = grokdeclarator (parm->declarator, parm->specs, PARM, false, NULL, - &attrs, expr, NULL, DEPRECATED_NORMAL); - decl_attributes (&decl, attrs, 0); - - decl = pushdecl (decl); - - finish_decl (decl, input_location, NULL_TREE, NULL_TREE, NULL_TREE); -} - -/* Mark all the parameter declarations to date as forward decls. - Also diagnose use of this extension. */ - -void -mark_forward_parm_decls (void) -{ - struct c_binding *b; - - if (pedantic && !current_scope->warned_forward_parm_decls) - { - pedwarn (input_location, OPT_Wpedantic, - "ISO C forbids forward parameter declarations"); - current_scope->warned_forward_parm_decls = true; - } - - for (b = current_scope->bindings; b; b = b->prev) - if (TREE_CODE (b->decl) == PARM_DECL) - TREE_ASM_WRITTEN (b->decl) = 1; -} - -/* Build a COMPOUND_LITERAL_EXPR. TYPE is the type given in the compound - literal, which may be an incomplete array type completed by the - initializer; INIT is a CONSTRUCTOR at LOC that initializes the compound - literal. NON_CONST is true if the initializers contain something - that cannot occur in a constant expression. */ - -tree -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; - 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. */ - tree decl; - tree complit; - tree stmt; - - if (type == error_mark_node - || init == error_mark_node) - return error_mark_node; - - decl = build_decl (loc, VAR_DECL, NULL_TREE, type); - DECL_EXTERNAL (decl) = 0; - TREE_PUBLIC (decl) = 0; - TREE_STATIC (decl) = (current_scope == file_scope); - DECL_CONTEXT (decl) = current_function_decl; - TREE_USED (decl) = 1; - DECL_READ_P (decl) = 1; - TREE_TYPE (decl) = type; - TREE_READONLY (decl) = (TYPE_READONLY (type) - || (TREE_CODE (type) == ARRAY_TYPE - && TYPE_READONLY (TREE_TYPE (type)))); - store_init_value (loc, decl, init, NULL_TREE); - - if (TREE_CODE (type) == ARRAY_TYPE && !COMPLETE_TYPE_P (type)) - { - int failure = complete_array_type (&TREE_TYPE (decl), - DECL_INITIAL (decl), true); - gcc_assert (!failure); - - type = TREE_TYPE (decl); - TREE_TYPE (DECL_INITIAL (decl)) = type; - } - - if (type == error_mark_node || !COMPLETE_TYPE_P (type)) - { - c_incomplete_type_error (NULL_TREE, type); - return error_mark_node; - } - - stmt = build_stmt (DECL_SOURCE_LOCATION (decl), DECL_EXPR, decl); - complit = build1 (COMPOUND_LITERAL_EXPR, type, stmt); - TREE_SIDE_EFFECTS (complit) = 1; - - layout_decl (decl, 0); - - if (TREE_STATIC (decl)) - { - /* This decl needs a name for the assembler output. */ - set_compound_literal_name (decl); - DECL_DEFER_OUTPUT (decl) = 1; - DECL_COMDAT (decl) = 1; - DECL_ARTIFICIAL (decl) = 1; - DECL_IGNORED_P (decl) = 1; - pushdecl (decl); - rest_of_decl_compilation (decl, 1, 0); - } - - if (non_const) - { - complit = build2 (C_MAYBE_CONST_EXPR, type, NULL, complit); - C_MAYBE_CONST_EXPR_NON_CONST (complit) = 1; - } - - return complit; -} - -/* Check the type of a compound literal. Here we just check that it - is valid for C++. */ - -void -check_compound_literal_type (location_t loc, struct c_type_name *type_name) -{ - if (warn_cxx_compat - && (type_name->specs->typespec_kind == ctsk_tagdef - || type_name->specs->typespec_kind == ctsk_tagfirstref)) - warning_at (loc, OPT_Wc___compat, - "defining a type in a compound literal is invalid in C++"); -} - -/* Determine whether TYPE is a structure with a flexible array member, - or a union containing such a structure (possibly recursively). */ - -static bool -flexible_array_type_p (tree type) -{ - tree x; - switch (TREE_CODE (type)) - { - case RECORD_TYPE: - x = TYPE_FIELDS (type); - if (x == NULL_TREE) - return false; - while (DECL_CHAIN (x) != NULL_TREE) - x = DECL_CHAIN (x); - if (TREE_CODE (TREE_TYPE (x)) == ARRAY_TYPE - && TYPE_SIZE (TREE_TYPE (x)) == NULL_TREE - && TYPE_DOMAIN (TREE_TYPE (x)) != NULL_TREE - && TYPE_MAX_VALUE (TYPE_DOMAIN (TREE_TYPE (x))) == NULL_TREE) - return true; - return false; - case UNION_TYPE: - for (x = TYPE_FIELDS (type); x != NULL_TREE; x = DECL_CHAIN (x)) - { - if (flexible_array_type_p (TREE_TYPE (x))) - return true; - } - return false; - default: - return false; - } -} - -/* Performs sanity checks on the TYPE and WIDTH of the bit-field NAME, - replacing with appropriate values if they are invalid. */ -static void -check_bitfield_type_and_width (tree *type, tree *width, tree orig_name) -{ - tree type_mv; - unsigned int max_width; - unsigned HOST_WIDE_INT w; - const char *name = (orig_name - ? identifier_to_locale (IDENTIFIER_POINTER (orig_name)) - : _("<anonymous>")); - - /* Detect and ignore out of range field width and process valid - field widths. */ - if (!INTEGRAL_TYPE_P (TREE_TYPE (*width))) - { - error ("bit-field %qs width not an integer constant", name); - *width = integer_one_node; - } - else - { - if (TREE_CODE (*width) != INTEGER_CST) - { - *width = c_fully_fold (*width, false, NULL); - if (TREE_CODE (*width) == INTEGER_CST) - pedwarn (input_location, OPT_Wpedantic, - "bit-field %qs width not an integer constant expression", - name); - } - if (TREE_CODE (*width) != INTEGER_CST) - { - error ("bit-field %qs width not an integer constant", name); - *width = integer_one_node; - } - constant_expression_warning (*width); - if (tree_int_cst_sgn (*width) < 0) - { - error ("negative width in bit-field %qs", name); - *width = integer_one_node; - } - else if (integer_zerop (*width) && orig_name) - { - error ("zero width for bit-field %qs", name); - *width = integer_one_node; - } - } - - /* Detect invalid bit-field type. */ - if (TREE_CODE (*type) != INTEGER_TYPE - && TREE_CODE (*type) != BOOLEAN_TYPE - && TREE_CODE (*type) != ENUMERAL_TYPE) - { - error ("bit-field %qs has invalid type", name); - *type = unsigned_type_node; - } - - type_mv = TYPE_MAIN_VARIANT (*type); - if (!in_system_header - && type_mv != integer_type_node - && type_mv != unsigned_type_node - && type_mv != boolean_type_node) - pedwarn (input_location, OPT_Wpedantic, - "type of bit-field %qs is a GCC extension", name); - - max_width = TYPE_PRECISION (*type); - - if (0 < compare_tree_int (*width, max_width)) - { - error ("width of %qs exceeds its type", name); - w = max_width; - *width = build_int_cst (integer_type_node, w); - } - else - w = tree_low_cst (*width, 1); - - if (TREE_CODE (*type) == ENUMERAL_TYPE) - { - struct lang_type *lt = TYPE_LANG_SPECIFIC (*type); - if (!lt - || w < tree_int_cst_min_precision (lt->enum_min, 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); - } -} - - - -/* Print warning about variable length array if necessary. */ - -static void -warn_variable_length_array (tree name, tree size) -{ - int const_size = TREE_CONSTANT (size); - - if (!flag_isoc99 && pedantic && warn_vla != 0) - { - if (const_size) - { - if (name) - pedwarn (input_location, OPT_Wvla, - "ISO C90 forbids array %qE whose size " - "can%'t be evaluated", - name); - else - pedwarn (input_location, OPT_Wvla, "ISO C90 forbids array whose size " - "can%'t be evaluated"); - } - else - { - if (name) - pedwarn (input_location, OPT_Wvla, - "ISO C90 forbids variable length array %qE", - name); - else - pedwarn (input_location, OPT_Wvla, "ISO C90 forbids variable length array"); - } - } - else if (warn_vla > 0) - { - if (const_size) - { - if (name) - warning (OPT_Wvla, - "the size of array %qE can" - "%'t be evaluated", name); - else - warning (OPT_Wvla, - "the size of array can %'t be evaluated"); - } - else - { - if (name) - warning (OPT_Wvla, - "variable length array %qE is used", - name); - else - warning (OPT_Wvla, - "variable length array is used"); - } - } -} - -/* Given declspecs and a declarator, - determine the name and type of the object declared - and construct a ..._DECL node for it. - (In one case we can return a ..._TYPE node instead. - For invalid input we sometimes return 0.) - - DECLSPECS is a c_declspecs structure for the declaration specifiers. - - DECL_CONTEXT says which syntactic context this declaration is in: - 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 - error messages in each case. Return value may be zero meaning - this definition is too screwy to try to parse. - PARM for a parameter declaration (either within a function prototype - or before a function body). Make a PARM_DECL, or return void_type_node. - TYPENAME if for a typename (in a cast or sizeof). - Don't make a DECL node; just return the ..._TYPE node. - FIELD for a struct or union field; make a FIELD_DECL. - 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 - representing the width of the bit-field. - 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 - added to this list. - If EXPR is not NULL, any expressions that need to be evaluated as - part of evaluating variably modified types will be stored in *EXPR. - If EXPR_CONST_OPERANDS is not NULL, *EXPR_CONST_OPERANDS will be - set to indicate whether operands in *EXPR can be used in constant - expressions. - DEPRECATED_STATE is a deprecated_states value indicating whether - deprecation warnings should be suppressed. - - In the TYPENAME case, DECLARATOR is really an absolute declarator. - It may also be so in the PARM case, for a prototype where the - argument type is specified but not the name. - - This function is where the complicated C meanings of `static' - and `extern' are interpreted. */ - -static tree -grokdeclarator (const struct c_declarator *declarator, - struct c_declspecs *declspecs, - enum decl_context decl_context, bool initialized, tree *width, - tree *decl_attrs, tree *expr, bool *expr_const_operands, - enum deprecated_states deprecated_state) -{ - tree type = declspecs->type; - bool threadp = declspecs->thread_p; - enum c_storage_class storage_class = declspecs->storage_class; - int constp; - int restrictp; - int volatilep; - int type_quals = TYPE_UNQUALIFIED; - tree name = NULL_TREE; - bool funcdef_flag = false; - bool funcdef_syntax = false; - bool size_varies = false; - tree decl_attr = declspecs->decl_attr; - int array_ptr_quals = TYPE_UNQUALIFIED; - tree array_ptr_attrs = NULL_TREE; - int array_parm_static = 0; - bool array_parm_vla_unspec_p = false; - tree returned_attrs = NULL_TREE; - bool bitfield = width != NULL; - tree element_type; - struct c_arg_info *arg_info = 0; - addr_space_t as1, as2, address_space; - location_t loc = UNKNOWN_LOCATION; - const char *errmsg; - tree expr_dummy; - bool expr_const_operands_dummy; - enum c_declarator_kind first_non_attr_kind; - unsigned int alignas_align = 0; - - if (TREE_CODE (type) == ERROR_MARK) - return error_mark_node; - if (expr == NULL) - expr = &expr_dummy; - if (expr_const_operands == NULL) - expr_const_operands = &expr_const_operands_dummy; - - *expr = declspecs->expr; - *expr_const_operands = declspecs->expr_const_operands; - - if (decl_context == FUNCDEF) - funcdef_flag = true, decl_context = NORMAL; - - /* Look inside a declarator for the name being declared - and get it as an IDENTIFIER_NODE, for an error message. */ - { - const struct c_declarator *decl = declarator; - - first_non_attr_kind = cdk_attrs; - while (decl) - switch (decl->kind) - { - case cdk_array: - loc = decl->id_loc; - /* FALL THRU. */ - - case cdk_function: - case cdk_pointer: - funcdef_syntax = (decl->kind == cdk_function); - decl = decl->declarator; - if (first_non_attr_kind == cdk_attrs) - first_non_attr_kind = decl->kind; - break; - - case cdk_attrs: - decl = decl->declarator; - break; - - case cdk_id: - loc = decl->id_loc; - if (decl->u.id) - name = decl->u.id; - if (first_non_attr_kind == cdk_attrs) - first_non_attr_kind = decl->kind; - decl = 0; - break; - - default: - gcc_unreachable (); - } - if (name == 0) - { - gcc_assert (decl_context == PARM - || decl_context == TYPENAME - || (decl_context == FIELD - && declarator->kind == cdk_id)); - gcc_assert (!initialized); - } - } - - /* A function definition's declarator must have the form of - a function declarator. */ - - if (funcdef_flag && !funcdef_syntax) - return 0; - - /* If this looks like a function definition, make it one, - even if it occurs where parms are expected. - Then store_parm_decls will reject it and not use it as a parm. */ - if (decl_context == NORMAL && !funcdef_flag && current_scope->parm_flag) - decl_context = PARM; - - if (declspecs->deprecated_p && deprecated_state != DEPRECATED_SUPPRESS) - warn_deprecated_use (declspecs->type, declspecs->decl_attr); - - if ((decl_context == NORMAL || decl_context == FIELD) - && current_scope == file_scope - && variably_modified_type_p (type, NULL_TREE)) - { - if (name) - error_at (loc, "variably modified %qE at file scope", name); - else - error_at (loc, "variably modified field at file scope"); - type = integer_type_node; - } - - size_varies = C_TYPE_VARIABLE_SIZE (type) != 0; - - /* Diagnose defaulting to "int". */ - - if (declspecs->default_int_p && !in_system_header) - { - /* Issue a warning if this is an ISO C 99 program or if - -Wreturn-type and this is a function, or if -Wimplicit; - prefer the former warning since it is more explicit. */ - if ((warn_implicit_int || warn_return_type || flag_isoc99) - && funcdef_flag) - warn_about_return_type = 1; - else - { - if (name) - pedwarn_c99 (loc, flag_isoc99 ? 0 : OPT_Wimplicit_int, - "type defaults to %<int%> in declaration of %qE", - name); - else - pedwarn_c99 (input_location, flag_isoc99 ? 0 : OPT_Wimplicit_int, - "type defaults to %<int%> in type name"); - } - } - - /* Adjust the type if a bit-field is being declared, - -funsigned-bitfields applied and the type is not explicitly - "signed". */ - if (bitfield && !flag_signed_bitfields && !declspecs->explicit_signed_p - && TREE_CODE (type) == INTEGER_TYPE) - type = unsigned_type_for (type); - - /* Figure out the type qualifiers for the declaration. There are - two ways a declaration can become qualified. One is something - like `const int i' where the `const' is explicit. Another is - something like `typedef const int CI; CI i' where the type of the - declaration contains the `const'. A third possibility is that - there is a type qualifier on the element type of a typedefed - array type, in which case we should extract that qualifier so - that c_apply_type_quals_to_decl receives the full list of - qualifiers to work with (C90 is not entirely clear about whether - duplicate qualifiers should be diagnosed in this case, but it - seems most appropriate to do so). */ - element_type = strip_array_types (type); - constp = declspecs->const_p + TYPE_READONLY (element_type); - restrictp = declspecs->restrict_p + TYPE_RESTRICT (element_type); - volatilep = declspecs->volatile_p + TYPE_VOLATILE (element_type); - as1 = declspecs->address_space; - as2 = TYPE_ADDR_SPACE (element_type); - address_space = ADDR_SPACE_GENERIC_P (as1)? as2 : as1; - - if (pedantic && !flag_isoc99) - { - if (constp > 1) - pedwarn (loc, OPT_Wpedantic, "duplicate %<const%>"); - if (restrictp > 1) - pedwarn (loc, OPT_Wpedantic, "duplicate %<restrict%>"); - if (volatilep > 1) - pedwarn (loc, OPT_Wpedantic, "duplicate %<volatile%>"); - } - - if (!ADDR_SPACE_GENERIC_P (as1) && !ADDR_SPACE_GENERIC_P (as2) && as1 != as2) - error_at (loc, "conflicting named address spaces (%s vs %s)", - c_addr_space_name (as1), c_addr_space_name (as2)); - - if ((TREE_CODE (type) == ARRAY_TYPE - || first_non_attr_kind == cdk_array) - && TYPE_QUALS (element_type)) - type = TYPE_MAIN_VARIANT (type); - type_quals = ((constp ? TYPE_QUAL_CONST : 0) - | (restrictp ? TYPE_QUAL_RESTRICT : 0) - | (volatilep ? TYPE_QUAL_VOLATILE : 0) - | ENCODE_QUAL_ADDR_SPACE (address_space)); - - /* Warn about storage classes that are invalid for certain - kinds of declarations (parameters, typenames, etc.). */ - - if (funcdef_flag - && (threadp - || storage_class == csc_auto - || storage_class == csc_register - || storage_class == csc_typedef)) - { - if (storage_class == csc_auto) - pedwarn (loc, - (current_scope == file_scope) ? 0 : OPT_Wpedantic, - "function definition declared %<auto%>"); - if (storage_class == csc_register) - error_at (loc, "function definition declared %<register%>"); - if (storage_class == csc_typedef) - error_at (loc, "function definition declared %<typedef%>"); - if (threadp) - error_at (loc, "function definition declared %<__thread%>"); - threadp = false; - if (storage_class == csc_auto - || storage_class == csc_register - || storage_class == csc_typedef) - storage_class = csc_none; - } - else if (decl_context != NORMAL && (storage_class != csc_none || threadp)) - { - if (decl_context == PARM && storage_class == csc_register) - ; - else - { - switch (decl_context) - { - case FIELD: - if (name) - error_at (loc, "storage class specified for structure " - "field %qE", name); - else - error_at (loc, "storage class specified for structure field"); - break; - case PARM: - if (name) - error_at (loc, "storage class specified for parameter %qE", - name); - else - error_at (loc, "storage class specified for unnamed parameter"); - break; - default: - error_at (loc, "storage class specified for typename"); - break; - } - storage_class = csc_none; - threadp = false; - } - } - else if (storage_class == csc_extern - && initialized - && !funcdef_flag) - { - /* 'extern' with initialization is invalid if not at file scope. */ - if (current_scope == file_scope) - { - /* It is fine to have 'extern const' when compiling at C - and C++ intersection. */ - if (!(warn_cxx_compat && constp)) - warning_at (loc, 0, "%qE initialized and declared %<extern%>", - name); - } - else - error_at (loc, "%qE has both %<extern%> and initializer", name); - } - else if (current_scope == file_scope) - { - if (storage_class == csc_auto) - error_at (loc, "file-scope declaration of %qE specifies %<auto%>", - name); - if (pedantic && storage_class == csc_register) - pedwarn (input_location, OPT_Wpedantic, - "file-scope declaration of %qE specifies %<register%>", name); - } - else - { - if (storage_class == csc_extern && funcdef_flag) - error_at (loc, "nested function %qE declared %<extern%>", name); - else if (threadp && storage_class == csc_none) - { - error_at (loc, "function-scope %qE implicitly auto and declared " - "%<__thread%>", - name); - threadp = false; - } - } - - /* Now figure out the structure of the declarator proper. - Descend through it, creating more complex types, until we reach - the declared identifier (or NULL_TREE, in an absolute declarator). - At each stage we maintain an unqualified version of the type - together with any qualifiers that should be applied to it with - c_build_qualified_type; this way, array types including - multidimensional array types are first built up in unqualified - form and then the qualified form is created with - TYPE_MAIN_VARIANT pointing to the unqualified form. */ - - while (declarator && declarator->kind != cdk_id) - { - if (type == error_mark_node) - { - declarator = declarator->declarator; - continue; - } - - /* Each level of DECLARATOR is either a cdk_array (for ...[..]), - a cdk_pointer (for *...), - a cdk_function (for ...(...)), - a cdk_attrs (for nested attributes), - or a cdk_id (for the name being declared - or the place in an absolute declarator - where the name was omitted). - For the last case, we have just exited the loop. - - 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. - After this sequence of ifs, TYPE is the type of the - array or function or pointer, and DECLARATOR has had its - outermost layer removed. */ - - if (array_ptr_quals != TYPE_UNQUALIFIED - || array_ptr_attrs != NULL_TREE - || array_parm_static) - { - /* Only the innermost declarator (making a parameter be of - array type which is converted to pointer type) - may have static or type qualifiers. */ - error_at (loc, "static or type qualifiers in non-parameter array declarator"); - array_ptr_quals = TYPE_UNQUALIFIED; - array_ptr_attrs = NULL_TREE; - array_parm_static = 0; - } - - switch (declarator->kind) - { - case cdk_attrs: - { - /* A declarator with embedded attributes. */ - tree attrs = declarator->u.attrs; - const struct c_declarator *inner_decl; - int attr_flags = 0; - declarator = declarator->declarator; - inner_decl = declarator; - while (inner_decl->kind == cdk_attrs) - inner_decl = inner_decl->declarator; - if (inner_decl->kind == cdk_id) - attr_flags |= (int) ATTR_FLAG_DECL_NEXT; - else if (inner_decl->kind == cdk_function) - attr_flags |= (int) ATTR_FLAG_FUNCTION_NEXT; - else if (inner_decl->kind == cdk_array) - attr_flags |= (int) ATTR_FLAG_ARRAY_NEXT; - returned_attrs = decl_attributes (&type, - chainon (returned_attrs, attrs), - attr_flags); - break; - } - case cdk_array: - { - tree itype = NULL_TREE; - tree size = declarator->u.array.dimen; - /* The index is a signed object `sizetype' bits wide. */ - tree index_type = c_common_signed_type (sizetype); - - array_ptr_quals = declarator->u.array.quals; - array_ptr_attrs = declarator->u.array.attrs; - array_parm_static = declarator->u.array.static_p; - array_parm_vla_unspec_p = declarator->u.array.vla_unspec_p; - - declarator = declarator->declarator; - - /* Check for some types that there cannot be arrays of. */ - - if (VOID_TYPE_P (type)) - { - if (name) - error_at (loc, "declaration of %qE as array of voids", name); - else - error_at (loc, "declaration of type name as array of voids"); - type = error_mark_node; - } - - if (TREE_CODE (type) == FUNCTION_TYPE) - { - if (name) - error_at (loc, "declaration of %qE as array of functions", - name); - else - error_at (loc, "declaration of type name as array of " - "functions"); - type = error_mark_node; - } - - if (pedantic && !in_system_header && flexible_array_type_p (type)) - pedwarn (loc, OPT_Wpedantic, - "invalid use of structure with flexible array member"); - - if (size == error_mark_node) - type = error_mark_node; - - if (type == error_mark_node) - continue; - - /* If size was specified, set ITYPE to a range-type for - that size. Otherwise, ITYPE remains null. finish_decl - may figure it out from an initial value. */ - - if (size) - { - bool size_maybe_const = true; - bool size_int_const = (TREE_CODE (size) == INTEGER_CST - && !TREE_OVERFLOW (size)); - bool this_size_varies = false; - - /* Strip NON_LVALUE_EXPRs since we aren't using as an - lvalue. */ - STRIP_TYPE_NOPS (size); - - if (!INTEGRAL_TYPE_P (TREE_TYPE (size))) - { - if (name) - error_at (loc, "size of array %qE has non-integer type", - name); - else - error_at (loc, - "size of unnamed array has non-integer type"); - size = integer_one_node; - } - - size = c_fully_fold (size, false, &size_maybe_const); - - if (pedantic && size_maybe_const && integer_zerop (size)) - { - if (name) - pedwarn (loc, OPT_Wpedantic, - "ISO C forbids zero-size array %qE", name); - else - pedwarn (loc, OPT_Wpedantic, - "ISO C forbids zero-size array"); - } - - if (TREE_CODE (size) == INTEGER_CST && size_maybe_const) - { - constant_expression_warning (size); - if (tree_int_cst_sgn (size) < 0) - { - if (name) - error_at (loc, "size of array %qE is negative", name); - else - error_at (loc, "size of unnamed array is negative"); - size = integer_one_node; - } - /* Handle a size folded to an integer constant but - not an integer constant expression. */ - if (!size_int_const) - { - /* If this is a file scope declaration of an - ordinary identifier, this is invalid code; - diagnosing it here and not subsequently - treating the type as variable-length avoids - more confusing diagnostics later. */ - if ((decl_context == NORMAL || decl_context == FIELD) - && current_scope == file_scope) - pedwarn (input_location, 0, - "variably modified %qE at file scope", - name); - else - this_size_varies = size_varies = true; - warn_variable_length_array (name, size); - } - } - else if ((decl_context == NORMAL || decl_context == FIELD) - && current_scope == file_scope) - { - error_at (loc, "variably modified %qE at file scope", name); - size = integer_one_node; - } - else - { - /* Make sure the array size remains visibly - nonconstant even if it is (eg) a const variable - with known value. */ - this_size_varies = size_varies = true; - warn_variable_length_array (name, size); - } - - if (integer_zerop (size) && !this_size_varies) - { - /* A zero-length array cannot be represented with - an unsigned index type, which is what we'll - get with build_index_type. Create an - open-ended range instead. */ - itype = build_range_type (sizetype, size, NULL_TREE); - } - else - { - /* Arrange for the SAVE_EXPR on the inside of the - MINUS_EXPR, which allows the -1 to get folded - with the +1 that happens when building TYPE_SIZE. */ - if (size_varies) - size = save_expr (size); - if (this_size_varies && TREE_CODE (size) == INTEGER_CST) - size = build2 (COMPOUND_EXPR, TREE_TYPE (size), - integer_zero_node, size); - - /* Compute the maximum valid index, that is, size - - 1. Do the calculation in index_type, so that - if it is a variable the computations will be - done in the proper mode. */ - itype = fold_build2_loc (loc, MINUS_EXPR, index_type, - convert (index_type, size), - convert (index_type, - size_one_node)); - - /* The above overflows when size does not fit - in index_type. - ??? While a size of INT_MAX+1 technically shouldn't - cause an overflow (because we subtract 1), handling - this case seems like an unnecessary complication. */ - if (TREE_CODE (size) == INTEGER_CST - && !int_fits_type_p (size, index_type)) - { - if (name) - error_at (loc, "size of array %qE is too large", - name); - else - error_at (loc, "size of unnamed array is too large"); - type = error_mark_node; - continue; - } - - itype = build_index_type (itype); - } - if (this_size_varies) - { - if (*expr) - *expr = build2 (COMPOUND_EXPR, TREE_TYPE (size), - *expr, size); - else - *expr = size; - *expr_const_operands &= size_maybe_const; - } - } - else if (decl_context == FIELD) - { - bool flexible_array_member = false; - if (array_parm_vla_unspec_p) - /* Field names can in fact have function prototype - scope so [*] is disallowed here through making - the field variably modified, not through being - something other than a declaration with function - prototype scope. */ - size_varies = true; - else - { - const struct c_declarator *t = declarator; - while (t->kind == cdk_attrs) - t = t->declarator; - flexible_array_member = (t->kind == cdk_id); - } - if (flexible_array_member - && pedantic && !flag_isoc99 && !in_system_header) - pedwarn (loc, OPT_Wpedantic, - "ISO C90 does not support flexible array members"); - - /* ISO C99 Flexible array members are effectively - identical to GCC's zero-length array extension. */ - if (flexible_array_member || array_parm_vla_unspec_p) - itype = build_range_type (sizetype, size_zero_node, - NULL_TREE); - } - else if (decl_context == PARM) - { - if (array_parm_vla_unspec_p) - { - itype = build_range_type (sizetype, size_zero_node, NULL_TREE); - size_varies = true; - } - } - else if (decl_context == TYPENAME) - { - if (array_parm_vla_unspec_p) - { - /* C99 6.7.5.2p4 */ - warning (0, "%<[*]%> not in a declaration"); - /* We use this to avoid messing up with incomplete - array types of the same type, that would - otherwise be modified below. */ - itype = build_range_type (sizetype, size_zero_node, - NULL_TREE); - size_varies = true; - } - } - - /* Complain about arrays of incomplete types. */ - if (!COMPLETE_TYPE_P (type)) - { - error_at (loc, "array type has incomplete element type"); - type = error_mark_node; - } - else - /* When itype is NULL, a shared incomplete array type is - returned for all array of a given type. Elsewhere we - make sure we don't complete that type before copying - it, but here we want to make sure we don't ever - modify the shared type, so we gcc_assert (itype) - below. */ - { - addr_space_t as = DECODE_QUAL_ADDR_SPACE (type_quals); - if (!ADDR_SPACE_GENERIC_P (as) && as != TYPE_ADDR_SPACE (type)) - type = build_qualified_type (type, - ENCODE_QUAL_ADDR_SPACE (as)); - - type = build_array_type (type, itype); - } - - if (type != error_mark_node) - { - if (size_varies) - { - /* It is ok to modify type here even if itype is - NULL: if size_varies, we're in a - multi-dimensional array and the inner type has - variable size, so the enclosing shared array type - must too. */ - if (size && TREE_CODE (size) == INTEGER_CST) - type - = build_distinct_type_copy (TYPE_MAIN_VARIANT (type)); - C_TYPE_VARIABLE_SIZE (type) = 1; - } - - /* The GCC extension for zero-length arrays differs from - ISO flexible array members in that sizeof yields - zero. */ - if (size && integer_zerop (size)) - { - gcc_assert (itype); - type = build_distinct_type_copy (TYPE_MAIN_VARIANT (type)); - TYPE_SIZE (type) = bitsize_zero_node; - TYPE_SIZE_UNIT (type) = size_zero_node; - SET_TYPE_STRUCTURAL_EQUALITY (type); - } - if (array_parm_vla_unspec_p) - { - gcc_assert (itype); - /* The type is complete. C99 6.7.5.2p4 */ - type = build_distinct_type_copy (TYPE_MAIN_VARIANT (type)); - TYPE_SIZE (type) = bitsize_zero_node; - TYPE_SIZE_UNIT (type) = size_zero_node; - SET_TYPE_STRUCTURAL_EQUALITY (type); - } - } - - if (decl_context != PARM - && (array_ptr_quals != TYPE_UNQUALIFIED - || array_ptr_attrs != NULL_TREE - || array_parm_static)) - { - error_at (loc, "static or type qualifiers in non-parameter array declarator"); - array_ptr_quals = TYPE_UNQUALIFIED; - array_ptr_attrs = NULL_TREE; - array_parm_static = 0; - } - break; - } - case cdk_function: - { - /* Say it's a definition only for the declarator closest - to the identifier, apart possibly from some - attributes. */ - bool really_funcdef = false; - tree arg_types; - if (funcdef_flag) - { - const struct c_declarator *t = declarator->declarator; - while (t->kind == cdk_attrs) - t = t->declarator; - really_funcdef = (t->kind == cdk_id); - } - - /* Declaring a function type. Make sure we have a valid - type for the function to return. */ - if (type == error_mark_node) - continue; - - size_varies = false; - - /* Warn about some types functions can't return. */ - if (TREE_CODE (type) == FUNCTION_TYPE) - { - if (name) - error_at (loc, "%qE declared as function returning a " - "function", name); - else - error_at (loc, "type name declared as function " - "returning a function"); - type = integer_type_node; - } - if (TREE_CODE (type) == ARRAY_TYPE) - { - if (name) - error_at (loc, "%qE declared as function returning an array", - name); - else - error_at (loc, "type name declared as function returning " - "an array"); - type = integer_type_node; - } - errmsg = targetm.invalid_return_type (type); - if (errmsg) - { - error (errmsg); - type = integer_type_node; - } - - /* Construct the function type and go to the next - inner layer of declarator. */ - arg_info = declarator->u.arg_info; - arg_types = grokparms (arg_info, really_funcdef); - - /* Type qualifiers before the return type of the function - qualify the return type, not the function type. */ - if (type_quals) - { - /* Type qualifiers on a function return type are - normally permitted by the standard but have no - effect, so give a warning at -Wreturn-type. - Qualifiers on a void return type are banned on - function definitions in ISO C; GCC used to used - them for noreturn functions. */ - if (VOID_TYPE_P (type) && really_funcdef) - pedwarn (loc, 0, - "function definition has qualified void return type"); - else - warning_at (loc, OPT_Wignored_qualifiers, - "type qualifiers ignored on function return type"); - - type = c_build_qualified_type (type, type_quals); - } - type_quals = TYPE_UNQUALIFIED; - - type = build_function_type (type, arg_types); - declarator = declarator->declarator; - - /* Set the TYPE_CONTEXTs for each tagged type which is local to - the formal parameter list of this FUNCTION_TYPE to point to - the FUNCTION_TYPE node itself. */ - { - c_arg_tag *tag; - unsigned ix; - - FOR_EACH_VEC_SAFE_ELT_REVERSE (arg_info->tags, ix, tag) - TYPE_CONTEXT (tag->type) = type; - } - break; - } - case cdk_pointer: - { - /* Merge any constancy or volatility into the target type - for the pointer. */ - - if (pedantic && TREE_CODE (type) == FUNCTION_TYPE - && type_quals) - pedwarn (loc, OPT_Wpedantic, - "ISO C forbids qualified function types"); - if (type_quals) - type = c_build_qualified_type (type, type_quals); - size_varies = false; - - /* When the pointed-to type involves components of variable size, - care must be taken to ensure that the size evaluation code is - emitted early enough to dominate all the possible later uses - and late enough for the variables on which it depends to have - been assigned. - - This is expected to happen automatically when the pointed-to - type has a name/declaration of it's own, but special attention - is required if the type is anonymous. - - We handle the NORMAL and FIELD contexts here by attaching an - artificial TYPE_DECL to such pointed-to type. This forces the - sizes evaluation at a safe point and ensures it is not deferred - until e.g. within a deeper conditional context. - - We expect nothing to be needed here for PARM or TYPENAME. - Pushing a TYPE_DECL at this point for TYPENAME would actually - be incorrect, as we might be in the middle of an expression - with side effects on the pointed-to type size "arguments" prior - to the pointer declaration point and the fake TYPE_DECL in the - enclosing context would force the size evaluation prior to the - side effects. */ - - if (!TYPE_NAME (type) - && (decl_context == NORMAL || decl_context == FIELD) - && variably_modified_type_p (type, NULL_TREE)) - { - tree decl = build_decl (loc, TYPE_DECL, NULL_TREE, type); - DECL_ARTIFICIAL (decl) = 1; - pushdecl (decl); - finish_decl (decl, loc, NULL_TREE, NULL_TREE, NULL_TREE); - TYPE_NAME (type) = decl; - } - - type = c_build_pointer_type (type); - - /* Process type qualifiers (such as const or volatile) - that were given inside the `*'. */ - type_quals = declarator->u.pointer_quals; - - declarator = declarator->declarator; - break; - } - default: - gcc_unreachable (); - } - } - *decl_attrs = chainon (returned_attrs, *decl_attrs); - - /* Now TYPE has the actual type, apart from any qualifiers in - TYPE_QUALS. */ - - /* Warn about address space used for things other than static memory or - pointers. */ - address_space = DECODE_QUAL_ADDR_SPACE (type_quals); - if (!ADDR_SPACE_GENERIC_P (address_space)) - { - if (decl_context == NORMAL) - { - switch (storage_class) - { - case csc_auto: - error ("%qs combined with %<auto%> qualifier for %qE", - c_addr_space_name (address_space), name); - break; - case csc_register: - error ("%qs combined with %<register%> qualifier for %qE", - c_addr_space_name (address_space), name); - break; - case csc_none: - if (current_function_scope) - { - error ("%qs specified for auto variable %qE", - c_addr_space_name (address_space), name); - break; - } - break; - case csc_static: - case csc_extern: - case csc_typedef: - break; - default: - gcc_unreachable (); - } - } - else if (decl_context == PARM && TREE_CODE (type) != ARRAY_TYPE) - { - if (name) - error ("%qs specified for parameter %qE", - c_addr_space_name (address_space), name); - else - error ("%qs specified for unnamed parameter", - c_addr_space_name (address_space)); - } - else if (decl_context == FIELD) - { - if (name) - error ("%qs specified for structure field %qE", - c_addr_space_name (address_space), name); - else - error ("%qs specified for structure field", - c_addr_space_name (address_space)); - } - } - - /* Check the type and width of a bit-field. */ - if (bitfield) - check_bitfield_type_and_width (&type, width, name); - - /* Reject invalid uses of _Alignas. */ - if (declspecs->alignas_p) - { - if (storage_class == csc_typedef) - error_at (loc, "alignment specified for typedef %qE", name); - else if (storage_class == csc_register) - error_at (loc, "alignment specified for %<register%> object %qE", - name); - else if (decl_context == PARM) - { - if (name) - error_at (loc, "alignment specified for parameter %qE", name); - else - error_at (loc, "alignment specified for unnamed parameter"); - } - else if (bitfield) - { - if (name) - error_at (loc, "alignment specified for bit-field %qE", name); - else - error_at (loc, "alignment specified for unnamed bit-field"); - } - else if (TREE_CODE (type) == FUNCTION_TYPE) - error_at (loc, "alignment specified for function %qE", name); - else if (declspecs->align_log != -1) - { - alignas_align = 1U << declspecs->align_log; - if (alignas_align < TYPE_ALIGN_UNIT (type)) - { - if (name) - error_at (loc, "%<_Alignas%> specifiers cannot reduce " - "alignment of %qE", name); - else - error_at (loc, "%<_Alignas%> specifiers cannot reduce " - "alignment of unnamed field"); - alignas_align = 0; - } - } - } - - /* Did array size calculations overflow or does the array cover more - than half of the address-space? */ - if (TREE_CODE (type) == ARRAY_TYPE - && COMPLETE_TYPE_P (type) - && TREE_CODE (TYPE_SIZE_UNIT (type)) == INTEGER_CST - && ! valid_constant_size_p (TYPE_SIZE_UNIT (type))) - { - if (name) - error_at (loc, "size of array %qE is too large", name); - else - error_at (loc, "size of unnamed array is too large"); - /* If we proceed with the array type as it is, we'll eventually - crash in tree_low_cst(). */ - type = error_mark_node; - } - - /* If this is declaring a typedef name, return a TYPE_DECL. */ - - if (storage_class == csc_typedef) - { - tree decl; - if (pedantic && TREE_CODE (type) == FUNCTION_TYPE - && type_quals) - pedwarn (loc, OPT_Wpedantic, - "ISO C forbids qualified function types"); - if (type_quals) - type = c_build_qualified_type (type, type_quals); - decl = build_decl (declarator->id_loc, - TYPE_DECL, declarator->u.id, type); - if (declspecs->explicit_signed_p) - C_TYPEDEF_EXPLICITLY_SIGNED (decl) = 1; - if (declspecs->inline_p) - pedwarn (loc, 0,"typedef %q+D declared %<inline%>", decl); - if (declspecs->noreturn_p) - pedwarn (loc, 0,"typedef %q+D declared %<_Noreturn%>", decl); - - if (warn_cxx_compat && declarator->u.id != NULL_TREE) - { - struct c_binding *b = I_TAG_BINDING (declarator->u.id); - - if (b != NULL - && b->decl != NULL_TREE - && (B_IN_CURRENT_SCOPE (b) - || (current_scope == file_scope && B_IN_EXTERNAL_SCOPE (b))) - && TYPE_MAIN_VARIANT (b->decl) != TYPE_MAIN_VARIANT (type)) - { - warning_at (declarator->id_loc, OPT_Wc___compat, - ("using %qD as both a typedef and a tag is " - "invalid in C++"), - decl); - if (b->locus != UNKNOWN_LOCATION) - inform (b->locus, "originally defined here"); - } - } - - return decl; - } - - /* If this is a type name (such as, in a cast or sizeof), - compute the type and return it now. */ - - if (decl_context == TYPENAME) - { - /* Note that the grammar rejects storage classes in typenames - and fields. */ - gcc_assert (storage_class == csc_none && !threadp - && !declspecs->inline_p && !declspecs->noreturn_p); - if (pedantic && TREE_CODE (type) == FUNCTION_TYPE - && type_quals) - pedwarn (loc, OPT_Wpedantic, - "ISO C forbids const or volatile function types"); - if (type_quals) - type = c_build_qualified_type (type, type_quals); - return type; - } - - if (pedantic && decl_context == FIELD - && variably_modified_type_p (type, NULL_TREE)) - { - /* C99 6.7.2.1p8 */ - pedwarn (loc, OPT_Wpedantic, "a member of a structure or union cannot " - "have a variably modified type"); - } - - /* Aside from typedefs and type names (handle above), - `void' at top level (not within pointer) - is allowed only in public variables. - We don't complain about parms either, but that is because - a better error message can be made later. */ - - if (VOID_TYPE_P (type) && decl_context != PARM - && !((decl_context != FIELD && TREE_CODE (type) != FUNCTION_TYPE) - && (storage_class == csc_extern - || (current_scope == file_scope - && !(storage_class == csc_static - || storage_class == csc_register))))) - { - error_at (loc, "variable or field %qE declared void", name); - type = integer_type_node; - } - - /* Now create the decl, which may be a VAR_DECL, a PARM_DECL - or a FUNCTION_DECL, depending on DECL_CONTEXT and TYPE. */ - - { - tree decl; - - if (decl_context == PARM) - { - tree promoted_type; - - /* 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. */ - - if (TREE_CODE (type) == ARRAY_TYPE) - { - /* Transfer const-ness of array into that of type pointed to. */ - type = TREE_TYPE (type); - if (type_quals) - type = c_build_qualified_type (type, type_quals); - type = c_build_pointer_type (type); - type_quals = array_ptr_quals; - if (type_quals) - type = c_build_qualified_type (type, type_quals); - - /* We don't yet implement attributes in this context. */ - if (array_ptr_attrs != NULL_TREE) - warning_at (loc, OPT_Wattributes, - "attributes in parameter array declarator ignored"); - - size_varies = false; - } - else if (TREE_CODE (type) == FUNCTION_TYPE) - { - if (type_quals) - pedwarn (loc, OPT_Wpedantic, - "ISO C forbids qualified function types"); - if (type_quals) - type = c_build_qualified_type (type, type_quals); - type = c_build_pointer_type (type); - type_quals = TYPE_UNQUALIFIED; - } - else if (type_quals) - type = c_build_qualified_type (type, type_quals); - - decl = build_decl (declarator->id_loc, - PARM_DECL, declarator->u.id, type); - if (size_varies) - C_DECL_VARIABLE_SIZE (decl) = 1; - - /* Compute the type actually passed in the parmlist, - for the case where there is no prototype. - (For example, shorts and chars are passed as ints.) - When there is a prototype, this is overridden later. */ - - if (type == error_mark_node) - promoted_type = type; - else - promoted_type = c_type_promotes_to (type); - - DECL_ARG_TYPE (decl) = promoted_type; - if (declspecs->inline_p) - pedwarn (loc, 0, "parameter %q+D declared %<inline%>", decl); - if (declspecs->noreturn_p) - pedwarn (loc, 0, "parameter %q+D declared %<_Noreturn%>", decl); - } - else if (decl_context == FIELD) - { - /* Note that the grammar rejects storage classes in typenames - and fields. */ - gcc_assert (storage_class == csc_none && !threadp - && !declspecs->inline_p && !declspecs->noreturn_p); - - /* Structure field. It may not be a function. */ - - if (TREE_CODE (type) == FUNCTION_TYPE) - { - error_at (loc, "field %qE declared as a function", name); - type = build_pointer_type (type); - } - else if (TREE_CODE (type) != ERROR_MARK - && !COMPLETE_OR_UNBOUND_ARRAY_TYPE_P (type)) - { - if (name) - error_at (loc, "field %qE has incomplete type", name); - else - error_at (loc, "unnamed field has incomplete type"); - type = error_mark_node; - } - type = c_build_qualified_type (type, type_quals); - decl = build_decl (declarator->id_loc, - FIELD_DECL, declarator->u.id, type); - DECL_NONADDRESSABLE_P (decl) = bitfield; - if (bitfield && !declarator->u.id) - TREE_NO_WARNING (decl) = 1; - - if (size_varies) - C_DECL_VARIABLE_SIZE (decl) = 1; - } - else if (TREE_CODE (type) == FUNCTION_TYPE) - { - if (storage_class == csc_register || threadp) - { - error_at (loc, "invalid storage class for function %qE", name); - } - else if (current_scope != file_scope) - { - /* Function declaration not at file scope. Storage - classes other than `extern' are not allowed, C99 - 6.7.1p5, and `extern' makes no difference. However, - GCC allows 'auto', perhaps with 'inline', to support - nested functions. */ - if (storage_class == csc_auto) - pedwarn (loc, OPT_Wpedantic, - "invalid storage class for function %qE", name); - else if (storage_class == csc_static) - { - error_at (loc, "invalid storage class for function %qE", name); - if (funcdef_flag) - storage_class = declspecs->storage_class = csc_none; - else - return 0; - } - } - - decl = build_decl (declarator->id_loc, - FUNCTION_DECL, declarator->u.id, type); - decl = build_decl_attribute_variant (decl, decl_attr); - - if (pedantic && type_quals && !DECL_IN_SYSTEM_HEADER (decl)) - pedwarn (loc, OPT_Wpedantic, - "ISO C forbids qualified function types"); - - /* Every function declaration is an external reference - (DECL_EXTERNAL) except for those which are not at file - scope and are explicitly declared "auto". This is - forbidden by standard C (C99 6.7.1p5) and is interpreted by - GCC to signify a forward declaration of a nested function. */ - if (storage_class == csc_auto && current_scope != file_scope) - DECL_EXTERNAL (decl) = 0; - /* In C99, a function which is declared 'inline' with 'extern' - is not an external reference (which is confusing). It - means that the later definition of the function must be output - in this file, C99 6.7.4p6. In GNU C89, a function declared - 'extern inline' is an external reference. */ - else if (declspecs->inline_p && storage_class != csc_static) - DECL_EXTERNAL (decl) = ((storage_class == csc_extern) - == flag_gnu89_inline); - else - DECL_EXTERNAL (decl) = !initialized; - - /* Record absence of global scope for `static' or `auto'. */ - TREE_PUBLIC (decl) - = !(storage_class == csc_static || storage_class == csc_auto); - - /* For a function definition, record the argument information - block where store_parm_decls will look for it. */ - if (funcdef_flag) - current_function_arg_info = arg_info; - - if (declspecs->default_int_p) - C_FUNCTION_IMPLICIT_INT (decl) = 1; - - /* Record presence of `inline' and `_Noreturn', if it is - reasonable. */ - if (flag_hosted && MAIN_NAME_P (declarator->u.id)) - { - if (declspecs->inline_p) - pedwarn (loc, 0, "cannot inline function %<main%>"); - if (declspecs->noreturn_p) - pedwarn (loc, 0, "%<main%> declared %<_Noreturn%>"); - } - else - { - if (declspecs->inline_p) - /* Record that the function is declared `inline'. */ - DECL_DECLARED_INLINE_P (decl) = 1; - if (declspecs->noreturn_p) - { - if (!flag_isoc11) - { - if (flag_isoc99) - pedwarn (loc, OPT_Wpedantic, - "ISO C99 does not support %<_Noreturn%>"); - else - pedwarn (loc, OPT_Wpedantic, - "ISO C90 does not support %<_Noreturn%>"); - } - TREE_THIS_VOLATILE (decl) = 1; - } - } - } - else - { - /* It's a variable. */ - /* An uninitialized decl with `extern' is a reference. */ - int extern_ref = !initialized && storage_class == csc_extern; - - type = c_build_qualified_type (type, type_quals); - - /* C99 6.2.2p7: It is invalid (compile-time undefined - behavior) to create an 'extern' declaration for a - variable if there is a global declaration that is - 'static' and the global declaration is not visible. - (If the static declaration _is_ currently visible, - the 'extern' declaration is taken to refer to that decl.) */ - if (extern_ref && current_scope != file_scope) - { - tree global_decl = identifier_global_value (declarator->u.id); - tree visible_decl = lookup_name (declarator->u.id); - - if (global_decl - && global_decl != visible_decl - && TREE_CODE (global_decl) == VAR_DECL - && !TREE_PUBLIC (global_decl)) - error_at (loc, "variable previously declared %<static%> " - "redeclared %<extern%>"); - } - - decl = build_decl (declarator->id_loc, - VAR_DECL, declarator->u.id, type); - if (size_varies) - C_DECL_VARIABLE_SIZE (decl) = 1; - - if (declspecs->inline_p) - pedwarn (loc, 0, "variable %q+D declared %<inline%>", decl); - if (declspecs->noreturn_p) - pedwarn (loc, 0, "variable %q+D declared %<_Noreturn%>", decl); - - /* At file scope, an initialized extern declaration may follow - a static declaration. In that case, DECL_EXTERNAL will be - reset later in start_decl. */ - DECL_EXTERNAL (decl) = (storage_class == csc_extern); - - /* At file scope, the presence of a `static' or `register' storage - class specifier, or the absence of all storage class specifiers - makes this declaration a definition (perhaps tentative). Also, - the absence of `static' makes it public. */ - if (current_scope == file_scope) - { - TREE_PUBLIC (decl) = storage_class != csc_static; - TREE_STATIC (decl) = !extern_ref; - } - /* Not at file scope, only `static' makes a static definition. */ - else - { - TREE_STATIC (decl) = (storage_class == csc_static); - TREE_PUBLIC (decl) = extern_ref; - } - - if (threadp) - DECL_TLS_MODEL (decl) = decl_default_tls_model (decl); - } - - if ((storage_class == csc_extern - || (storage_class == csc_none - && TREE_CODE (type) == FUNCTION_TYPE - && !funcdef_flag)) - && variably_modified_type_p (type, NULL_TREE)) - { - /* C99 6.7.5.2p2 */ - if (TREE_CODE (type) == FUNCTION_TYPE) - error_at (loc, "non-nested function with variably modified type"); - else - error_at (loc, "object with variably modified type must have " - "no linkage"); - } - - /* Record `register' declaration for warnings on & - and in case doing stupid register allocation. */ - - if (storage_class == csc_register) - { - C_DECL_REGISTER (decl) = 1; - DECL_REGISTER (decl) = 1; - } - - /* Record constancy and volatility. */ - c_apply_type_quals_to_decl (type_quals, decl); - - /* Apply _Alignas specifiers. */ - if (alignas_align) - { - DECL_ALIGN (decl) = alignas_align * BITS_PER_UNIT; - DECL_USER_ALIGN (decl) = 1; - } - - /* If a type has volatile components, it should be stored in memory. - Otherwise, the fact that those components are volatile - will be ignored, and would even crash the compiler. - Of course, this only makes sense on VAR,PARM, and RESULT decl's. */ - if (C_TYPE_FIELDS_VOLATILE (TREE_TYPE (decl)) - && (TREE_CODE (decl) == VAR_DECL || TREE_CODE (decl) == PARM_DECL - || TREE_CODE (decl) == RESULT_DECL)) - { - /* It is not an error for a structure with volatile fields to - be declared register, but reset DECL_REGISTER since it - cannot actually go in a register. */ - int was_reg = C_DECL_REGISTER (decl); - C_DECL_REGISTER (decl) = 0; - DECL_REGISTER (decl) = 0; - c_mark_addressable (decl); - C_DECL_REGISTER (decl) = was_reg; - } - - /* 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. */ - gcc_assert (!DECL_ASSEMBLER_NAME_SET_P (decl)); - - if (warn_cxx_compat - && TREE_CODE (decl) == VAR_DECL - && TREE_PUBLIC (decl) - && TREE_STATIC (decl) - && (TREE_CODE (TREE_TYPE (decl)) == RECORD_TYPE - || TREE_CODE (TREE_TYPE (decl)) == UNION_TYPE - || TREE_CODE (TREE_TYPE (decl)) == ENUMERAL_TYPE) - && TYPE_NAME (TREE_TYPE (decl)) == NULL_TREE) - warning_at (DECL_SOURCE_LOCATION (decl), OPT_Wc___compat, - ("non-local variable %qD with anonymous type is " - "questionable in C++"), - decl); - - return decl; - } -} - -/* 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 - if there is an identifier list instead of a parameter decl list). - These two functions are separate because when a function returns - 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 - 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. - - FUNCDEF_FLAG is true for a function definition, false for - a mere declaration. A nonempty identifier-list gets an error message - when FUNCDEF_FLAG is false. */ - -static tree -grokparms (struct c_arg_info *arg_info, bool funcdef_flag) -{ - tree arg_types = arg_info->types; - - if (funcdef_flag && arg_info->had_vla_unspec) - { - /* A function definition isn't function prototype scope C99 6.2.1p4. */ - /* C99 6.7.5.2p4 */ - error ("%<[*]%> not allowed in other than function prototype scope"); - } - - if (arg_types == 0 && !funcdef_flag && !in_system_header) - warning (OPT_Wstrict_prototypes, - "function declaration isn%'t a prototype"); - - if (arg_types == error_mark_node) - return 0; /* don't set TYPE_ARG_TYPES in this case */ - - else if (arg_types && TREE_CODE (TREE_VALUE (arg_types)) == IDENTIFIER_NODE) - { - if (!funcdef_flag) - { - pedwarn (input_location, 0, "parameter names (without types) in function declaration"); - arg_info->parms = NULL_TREE; - } - else - arg_info->parms = arg_info->types; - - arg_info->types = 0; - return 0; - } - else - { - tree parm, type, typelt; - unsigned int parmno; - const char *errmsg; - - /* If there is a parameter of incomplete type in a definition, - this is an error. In a declaration this is valid, and a - struct or union type may be completed later, before any calls - or definition of the function. In the case where the tag was - first declared within the parameter list, a warning has - already been given. If a parameter has void type, then - however the function cannot be defined or called, so - warn. */ - - for (parm = arg_info->parms, typelt = arg_types, parmno = 1; - parm; - parm = DECL_CHAIN (parm), typelt = TREE_CHAIN (typelt), parmno++) - { - type = TREE_VALUE (typelt); - if (type == error_mark_node) - continue; - - if (!COMPLETE_TYPE_P (type)) - { - if (funcdef_flag) - { - if (DECL_NAME (parm)) - error_at (input_location, - "parameter %u (%q+D) has incomplete type", - parmno, parm); - else - error_at (DECL_SOURCE_LOCATION (parm), - "parameter %u has incomplete type", - parmno); - - TREE_VALUE (typelt) = error_mark_node; - TREE_TYPE (parm) = error_mark_node; - arg_types = NULL_TREE; - } - else if (VOID_TYPE_P (type)) - { - if (DECL_NAME (parm)) - warning_at (input_location, 0, - "parameter %u (%q+D) has void type", - parmno, parm); - else - warning_at (DECL_SOURCE_LOCATION (parm), 0, - "parameter %u has void type", - parmno); - } - } - - errmsg = targetm.invalid_parameter_type (type); - if (errmsg) - { - error (errmsg); - TREE_VALUE (typelt) = error_mark_node; - TREE_TYPE (parm) = error_mark_node; - arg_types = NULL_TREE; - } - - if (DECL_NAME (parm) && TREE_USED (parm)) - warn_if_shadowing (parm); - } - return arg_types; - } -} - -/* Allocate and initialize a c_arg_info structure from the parser's - obstack. */ - -struct c_arg_info * -build_arg_info (void) -{ - struct c_arg_info *ret = XOBNEW (&parser_obstack, struct c_arg_info); - ret->parms = NULL_TREE; - ret->tags = NULL; - ret->types = NULL_TREE; - ret->others = NULL_TREE; - ret->pending_sizes = NULL; - ret->had_vla_unspec = 0; - return ret; -} - -/* Take apart the current scope and return a c_arg_info structure with - info on a parameter list just parsed. - - This structure is later fed to 'grokparms' and 'store_parm_decls'. - - 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. - - EXPR is NULL or an expression that needs to be evaluated for the - side effects of array size expressions in the parameters. */ - -struct c_arg_info * -get_parm_info (bool ellipsis, tree expr) -{ - struct c_binding *b = current_scope->bindings; - struct c_arg_info *arg_info = build_arg_info (); - - tree parms = 0; - vec<c_arg_tag, va_gc> *tags = NULL; - tree types = 0; - tree others = 0; - - static bool explained_incomplete_types = false; - bool gave_void_only_once_err = false; - - arg_info->had_vla_unspec = current_scope->had_vla_unspec; - - /* The bindings in this scope must not get put into a block. - We will take care of deleting the binding nodes. */ - current_scope->bindings = 0; - - /* This function is only called if there was *something* on the - parameter list. */ - gcc_assert (b); - - /* A parameter list consisting solely of 'void' indicates that the - function takes no arguments. But if the 'void' is qualified - (by 'const' or 'volatile'), or has a storage class specifier - ('register'), then the behavior is undefined; issue an error. - Typedefs for 'void' are OK (see DR#157). */ - if (b->prev == 0 /* one binding */ - && TREE_CODE (b->decl) == PARM_DECL /* which is a parameter */ - && !DECL_NAME (b->decl) /* anonymous */ - && VOID_TYPE_P (TREE_TYPE (b->decl))) /* of void type */ - { - if (TREE_THIS_VOLATILE (b->decl) - || TREE_READONLY (b->decl) - || C_DECL_REGISTER (b->decl)) - error ("%<void%> as only parameter may not be qualified"); - - /* There cannot be an ellipsis. */ - if (ellipsis) - error ("%<void%> must be the only parameter"); - - arg_info->types = void_list_node; - return arg_info; - } - - if (!ellipsis) - types = void_list_node; - - /* Break up the bindings list into parms, tags, types, and others; - apply sanity checks; purge the name-to-decl bindings. */ - while (b) - { - tree decl = b->decl; - tree type = TREE_TYPE (decl); - c_arg_tag tag; - const char *keyword; - - switch (TREE_CODE (decl)) - { - case PARM_DECL: - if (b->id) - { - gcc_assert (I_SYMBOL_BINDING (b->id) == b); - I_SYMBOL_BINDING (b->id) = b->shadowed; - } - - /* Check for forward decls that never got their actual decl. */ - if (TREE_ASM_WRITTEN (decl)) - error ("parameter %q+D has just a forward declaration", decl); - /* Check for (..., void, ...) and issue an error. */ - else if (VOID_TYPE_P (type) && !DECL_NAME (decl)) - { - if (!gave_void_only_once_err) - { - error ("%<void%> must be the only parameter"); - gave_void_only_once_err = true; - } - } - else - { - /* Valid parameter, add it to the list. */ - DECL_CHAIN (decl) = parms; - parms = decl; - - /* Since there is a prototype, args are passed in their - declared types. The back end may override this later. */ - DECL_ARG_TYPE (decl) = type; - types = tree_cons (0, type, types); - } - break; - - case ENUMERAL_TYPE: keyword = "enum"; goto tag; - case UNION_TYPE: keyword = "union"; goto tag; - case RECORD_TYPE: keyword = "struct"; goto tag; - tag: - /* Types may not have tag-names, in which case the type - appears in the bindings list with b->id NULL. */ - if (b->id) - { - gcc_assert (I_TAG_BINDING (b->id) == b); - I_TAG_BINDING (b->id) = b->shadowed; - } - - /* Warn about any struct, union or enum tags defined in a - parameter list. The scope of such types is limited to - the parameter list, which is rarely if ever desirable - (it's impossible to call such a function with type- - correct arguments). An anonymous union parm type is - meaningful as a GNU extension, so don't warn for that. */ - if (TREE_CODE (decl) != UNION_TYPE || b->id != 0) - { - if (b->id) - /* The %s will be one of 'struct', 'union', or 'enum'. */ - warning (0, "%<%s %E%> declared inside parameter list", - keyword, b->id); - else - /* The %s will be one of 'struct', 'union', or 'enum'. */ - warning (0, "anonymous %s declared inside parameter list", - keyword); - - if (!explained_incomplete_types) - { - warning (0, "its scope is only this definition or declaration," - " which is probably not what you want"); - explained_incomplete_types = true; - } - } - - tag.id = b->id; - tag.type = decl; - vec_safe_push (tags, tag); - break; - - case CONST_DECL: - case TYPE_DECL: - case FUNCTION_DECL: - /* CONST_DECLs appear here when we have an embedded enum, - and TYPE_DECLs appear here when we have an embedded struct - or union. No warnings for this - we already warned about the - type itself. FUNCTION_DECLs appear when there is an implicit - function declaration in the parameter list. */ - - /* When we reinsert this decl in the function body, we need - to reconstruct whether it was marked as nested. */ - gcc_assert (TREE_CODE (decl) == FUNCTION_DECL - ? b->nested - : !b->nested); - DECL_CHAIN (decl) = others; - others = decl; - /* fall through */ - - case ERROR_MARK: - /* error_mark_node appears here when we have an undeclared - variable. Just throw it away. */ - if (b->id) - { - gcc_assert (I_SYMBOL_BINDING (b->id) == b); - I_SYMBOL_BINDING (b->id) = b->shadowed; - } - break; - - /* Other things that might be encountered. */ - case LABEL_DECL: - case VAR_DECL: - default: - gcc_unreachable (); - } - - b = free_binding_and_advance (b); - } - - arg_info->parms = parms; - arg_info->tags = tags; - arg_info->types = types; - arg_info->others = others; - arg_info->pending_sizes = expr; - return arg_info; -} - -/* 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 - not defined. Return a c_typespec structure for the type - specifier. */ - -struct c_typespec -parser_xref_tag (location_t loc, enum tree_code code, tree name) -{ - struct c_typespec ret; - tree ref; - location_t refloc; - - ret.expr = NULL_TREE; - ret.expr_const_operands = true; - - /* If a cross reference is requested, look up the type - already defined for this tag and return it. */ - - ref = lookup_tag (code, name, 0, &refloc); - /* If this is the right type of tag, return what we found. - (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 - wrong type in the same scope, we will have had an error - message already; if in a different scope and declaring - a name, pending_xref_error will give an error message; but if in a - different scope and not declaring a name, this tag should - shadow the previous declaration of a different type of tag, and - this would not work properly if we return the reference found. - (For example, with "struct foo" in an outer scope, "union foo;" - must shadow that tag with a new one of union type.) */ - ret.kind = (ref ? ctsk_tagref : ctsk_tagfirstref); - if (ref && TREE_CODE (ref) == code) - { - if (C_TYPE_DEFINED_IN_STRUCT (ref) - && loc != UNKNOWN_LOCATION - && warn_cxx_compat) - { - switch (code) - { - case ENUMERAL_TYPE: - warning_at (loc, OPT_Wc___compat, - ("enum type defined in struct or union " - "is not visible in C++")); - inform (refloc, "enum type defined here"); - break; - case RECORD_TYPE: - warning_at (loc, OPT_Wc___compat, - ("struct defined in struct or union " - "is not visible in C++")); - inform (refloc, "struct defined here"); - break; - case UNION_TYPE: - warning_at (loc, OPT_Wc___compat, - ("union defined in struct or union " - "is not visible in C++")); - inform (refloc, "union defined here"); - break; - default: - gcc_unreachable(); - } - } - - ret.spec = ref; - return ret; - } - - /* If no such tag is yet defined, create a forward-reference node - and record it as the "definition". - When a real declaration of this type is found, - the forward-reference will be altered into a real type. */ - - ref = make_node (code); - if (code == ENUMERAL_TYPE) - { - /* Give the type a default layout like unsigned int - to avoid crashing if it does not get defined. */ - SET_TYPE_MODE (ref, TYPE_MODE (unsigned_type_node)); - TYPE_ALIGN (ref) = TYPE_ALIGN (unsigned_type_node); - TYPE_USER_ALIGN (ref) = 0; - TYPE_UNSIGNED (ref) = 1; - TYPE_PRECISION (ref) = TYPE_PRECISION (unsigned_type_node); - TYPE_MIN_VALUE (ref) = TYPE_MIN_VALUE (unsigned_type_node); - TYPE_MAX_VALUE (ref) = TYPE_MAX_VALUE (unsigned_type_node); - } - - pushtag (loc, name, ref); - - ret.spec = ref; - return ret; -} - -/* Get the struct, enum or union (CODE says which) with tag NAME. - Define the tag as a forward-reference if it is not defined. - Return a tree for the type. */ - -tree -xref_tag (enum tree_code code, tree name) -{ - return parser_xref_tag (input_location, code, name).spec; -} - -/* Make sure that the tag NAME is defined *in the current scope* - at least as a forward reference. - LOC is the location of the struct's definition. - CODE says which kind of tag NAME ought to be. - - This stores the current value of the file static STRUCT_PARSE_INFO - in *ENCLOSING_STRUCT_PARSE_INFO, and points STRUCT_PARSE_INFO at a - new c_struct_parse_info structure. The old value of - STRUCT_PARSE_INFO is restored in finish_struct. */ - -tree -start_struct (location_t loc, enum tree_code code, tree name, - struct c_struct_parse_info **enclosing_struct_parse_info) -{ - /* If there is already a tag defined at this scope - (as a forward reference), just return it. */ - - tree ref = NULL_TREE; - location_t refloc = UNKNOWN_LOCATION; - - if (name != NULL_TREE) - ref = lookup_tag (code, name, 1, &refloc); - if (ref && TREE_CODE (ref) == code) - { - if (TYPE_SIZE (ref)) - { - if (code == UNION_TYPE) - error_at (loc, "redefinition of %<union %E%>", name); - else - error_at (loc, "redefinition of %<struct %E%>", name); - if (refloc != UNKNOWN_LOCATION) - inform (refloc, "originally defined here"); - /* Don't create structures using a name already in use. */ - ref = NULL_TREE; - } - else if (C_TYPE_BEING_DEFINED (ref)) - { - if (code == UNION_TYPE) - error_at (loc, "nested redefinition of %<union %E%>", name); - else - error_at (loc, "nested redefinition of %<struct %E%>", name); - /* Don't bother to report "originally defined here" for a - nested redefinition; the original definition should be - obvious. */ - /* Don't create structures that contain themselves. */ - ref = NULL_TREE; - } - } - - /* Otherwise create a forward-reference just so the tag is in scope. */ - - if (ref == NULL_TREE || TREE_CODE (ref) != code) - { - ref = make_node (code); - pushtag (loc, name, ref); - } - - C_TYPE_BEING_DEFINED (ref) = 1; - TYPE_PACKED (ref) = flag_pack_struct; - - *enclosing_struct_parse_info = struct_parse_info; - struct_parse_info = XNEW (struct c_struct_parse_info); - struct_parse_info->struct_types.create (0); - struct_parse_info->fields.create (0); - struct_parse_info->typedefs_seen.create (0); - - /* 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 - terribly serious as C++ doesn't permit statement exprs within - sizeof anyhow. */ - if (warn_cxx_compat && (in_sizeof || in_typeof || in_alignof)) - warning_at (loc, OPT_Wc___compat, - "defining type in %qs expression is invalid in C++", - (in_sizeof - ? "sizeof" - : (in_typeof ? "typeof" : "alignof"))); - - return ref; -} - -/* Process the specs, declarator and width (NULL if omitted) - of a structure component, returning a FIELD_DECL node. - WIDTH is non-NULL for bit-fields only, and is an INTEGER_CST node. - DECL_ATTRS is as for grokdeclarator. - - LOC is the location of the structure component. - - This is done during the parsing of the struct declaration. - The FIELD_DECL nodes are chained together and the lot of them - are ultimately passed to `build_struct' to make the RECORD_TYPE node. */ - -tree -grokfield (location_t loc, - struct c_declarator *declarator, struct c_declspecs *declspecs, - tree width, tree *decl_attrs) -{ - tree value; - - if (declarator->kind == cdk_id && declarator->u.id == NULL_TREE - && width == NULL_TREE) - { - /* This is an unnamed decl. - - If we have something of the form "union { list } ;" then this - is the anonymous union extension. Similarly for struct. - - If this is something of the form "struct foo;", then - If MS or Plan 9 extensions are enabled, this is handled as - an anonymous struct. - 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 foo names a structure or union without a tag, then this - is an anonymous struct (this is permitted by C11). - If MS or Plan 9 extensions are enabled and foo names a - structure, then again this is an anonymous struct. - Otherwise this is an error. - - 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 - that took root before someone noticed the bug... */ - - tree type = declspecs->type; - bool type_ok = (TREE_CODE (type) == RECORD_TYPE - || TREE_CODE (type) == UNION_TYPE); - bool ok = false; - - if (type_ok - && (flag_ms_extensions - || flag_plan9_extensions - || !declspecs->typedef_p)) - { - if (flag_ms_extensions || flag_plan9_extensions) - ok = true; - else if (TYPE_NAME (type) == NULL) - ok = true; - else - ok = false; - } - if (!ok) - { - pedwarn (loc, 0, "declaration does not declare anything"); - return NULL_TREE; - } - if (!flag_isoc11) - { - if (flag_isoc99) - pedwarn (loc, OPT_Wpedantic, - "ISO C99 doesn%'t support unnamed structs/unions"); - else - pedwarn (loc, OPT_Wpedantic, - "ISO C90 doesn%'t support unnamed structs/unions"); - } - } - - value = grokdeclarator (declarator, declspecs, FIELD, false, - width ? &width : NULL, decl_attrs, NULL, NULL, - DEPRECATED_NORMAL); - - finish_decl (value, loc, NULL_TREE, NULL_TREE, NULL_TREE); - DECL_INITIAL (value) = width; - - if (warn_cxx_compat && DECL_NAME (value) != NULL_TREE) - { - /* If we currently have a binding for this field, set the - in_struct field in the binding, so that we warn about lookups - which find it. */ - struct c_binding *b = I_SYMBOL_BINDING (DECL_NAME (value)); - if (b != NULL) - { - /* If the in_struct field is not yet set, push it on a list - to be cleared when this struct is finished. */ - if (!b->in_struct) - { - struct_parse_info->fields.safe_push (b); - b->in_struct = 1; - } - } - } - - return value; -} - -/* Subroutine of detect_field_duplicates: return whether X and Y, - which are both fields in the same struct, have duplicate field - names. */ - -static bool -is_duplicate_field (tree x, tree y) -{ - if (DECL_NAME (x) != NULL_TREE && DECL_NAME (x) == DECL_NAME (y)) - return true; - - /* When using -fplan9-extensions, an anonymous field whose name is a - typedef can duplicate a field name. */ - if (flag_plan9_extensions - && (DECL_NAME (x) == NULL_TREE || DECL_NAME (y) == NULL_TREE)) - { - tree xt, xn, yt, yn; - - xt = TREE_TYPE (x); - if (DECL_NAME (x) != NULL_TREE) - xn = DECL_NAME (x); - else if ((TREE_CODE (xt) == RECORD_TYPE || TREE_CODE (xt) == UNION_TYPE) - && TYPE_NAME (xt) != NULL_TREE - && TREE_CODE (TYPE_NAME (xt)) == TYPE_DECL) - xn = DECL_NAME (TYPE_NAME (xt)); - else - xn = NULL_TREE; - - yt = TREE_TYPE (y); - if (DECL_NAME (y) != NULL_TREE) - yn = DECL_NAME (y); - else if ((TREE_CODE (yt) == RECORD_TYPE || TREE_CODE (yt) == UNION_TYPE) - && TYPE_NAME (yt) != NULL_TREE - && TREE_CODE (TYPE_NAME (yt)) == TYPE_DECL) - yn = DECL_NAME (TYPE_NAME (yt)); - else - yn = NULL_TREE; - - if (xn != NULL_TREE && xn == yn) - return true; - } - - return false; -} - -/* Subroutine of detect_field_duplicates: add the fields of FIELDLIST - to HTAB, giving errors for any duplicates. */ - -static void -detect_field_duplicates_hash (tree fieldlist, - hash_table <pointer_hash <tree_node> > htab) -{ - tree x, y; - tree_node **slot; - - for (x = fieldlist; x ; x = DECL_CHAIN (x)) - if ((y = DECL_NAME (x)) != 0) - { - slot = htab.find_slot (y, INSERT); - if (*slot) - { - error ("duplicate member %q+D", x); - DECL_NAME (x) = NULL_TREE; - } - *slot = y; - } - else if (TREE_CODE (TREE_TYPE (x)) == RECORD_TYPE - || TREE_CODE (TREE_TYPE (x)) == UNION_TYPE) - { - detect_field_duplicates_hash (TYPE_FIELDS (TREE_TYPE (x)), htab); - - /* When using -fplan9-extensions, an anonymous field whose - name is a typedef can duplicate a field name. */ - if (flag_plan9_extensions - && TYPE_NAME (TREE_TYPE (x)) != NULL_TREE - && TREE_CODE (TYPE_NAME (TREE_TYPE (x))) == TYPE_DECL) - { - tree xn = DECL_NAME (TYPE_NAME (TREE_TYPE (x))); - slot = htab.find_slot (xn, INSERT); - if (*slot) - error ("duplicate member %q+D", TYPE_NAME (TREE_TYPE (x))); - *slot = xn; - } - } -} - -/* Generate an error for any duplicate field names in FIELDLIST. Munge - the list such that this does not present a problem later. */ - -static void -detect_field_duplicates (tree fieldlist) -{ - tree x, y; - int timeout = 10; - - /* If the struct is the list of instance variables of an Objective-C - class, then we need to check all the instance variables of - superclasses when checking for duplicates (since you can't have - an instance variable in a subclass with the same name as an - instance variable in a superclass). We pass on this job to the - Objective-C compiler. objc_detect_field_duplicates() will return - false if we are not checking the list of instance variables and - the C frontend should proceed with the standard field duplicate - checks. If we are checking the list of instance variables, the - ObjC frontend will do the check, emit the errors if needed, and - then return true. */ - if (c_dialect_objc ()) - if (objc_detect_field_duplicates (false)) - return; - - /* First, see if there are more than "a few" fields. - This is trivially true if there are zero or one fields. */ - if (!fieldlist || !DECL_CHAIN (fieldlist)) - return; - x = fieldlist; - do { - timeout--; - if (DECL_NAME (x) == NULL_TREE - && (TREE_CODE (TREE_TYPE (x)) == RECORD_TYPE - || TREE_CODE (TREE_TYPE (x)) == UNION_TYPE)) - timeout = 0; - x = DECL_CHAIN (x); - } while (timeout > 0 && x); - - /* If there were "few" fields and no anonymous structures or unions, - avoid the overhead of allocating a hash table. Instead just do - the nested traversal thing. */ - if (timeout > 0) - { - for (x = DECL_CHAIN (fieldlist); x; x = DECL_CHAIN (x)) - /* When using -fplan9-extensions, we can have duplicates - between typedef names and fields. */ - if (DECL_NAME (x) - || (flag_plan9_extensions - && DECL_NAME (x) == NULL_TREE - && (TREE_CODE (TREE_TYPE (x)) == RECORD_TYPE - || TREE_CODE (TREE_TYPE (x)) == UNION_TYPE) - && TYPE_NAME (TREE_TYPE (x)) != NULL_TREE - && TREE_CODE (TYPE_NAME (TREE_TYPE (x))) == TYPE_DECL)) - { - for (y = fieldlist; y != x; y = TREE_CHAIN (y)) - if (is_duplicate_field (y, x)) - { - error ("duplicate member %q+D", x); - DECL_NAME (x) = NULL_TREE; - } - } - } - else - { - hash_table <pointer_hash <tree_node> > htab; - htab.create (37); - - detect_field_duplicates_hash (fieldlist, htab); - htab.dispose (); - } -} - -/* Finish up struct info used by -Wc++-compat. */ - -static void -warn_cxx_compat_finish_struct (tree fieldlist) -{ - unsigned int ix; - tree x; - struct c_binding *b; - - /* 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 - because the flag is used to issue visibility warnings, and we - only want to issue those warnings if the type is referenced - outside of the struct declaration. */ - FOR_EACH_VEC_ELT (struct_parse_info->struct_types, ix, x) - C_TYPE_DEFINED_IN_STRUCT (x) = 1; - - /* The TYPEDEFS_SEEN field of STRUCT_PARSE_INFO is a list of - 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 - 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 - would thus be the field rather than the typedef. */ - if (!struct_parse_info->typedefs_seen.is_empty () - && fieldlist != NULL_TREE) - { - /* Use a pointer_set using the name of the typedef. We can use - a pointer_set because identifiers are interned. */ - struct pointer_set_t *tset = pointer_set_create (); - - FOR_EACH_VEC_ELT (struct_parse_info->typedefs_seen, ix, x) - pointer_set_insert (tset, DECL_NAME (x)); - - for (x = fieldlist; x != NULL_TREE; x = DECL_CHAIN (x)) - { - if (DECL_NAME (x) != NULL_TREE - && pointer_set_contains (tset, DECL_NAME (x))) - { - warning_at (DECL_SOURCE_LOCATION (x), OPT_Wc___compat, - ("using %qD as both field and typedef name is " - "invalid in C++"), - x); - /* FIXME: It would be nice to report the location where - the typedef name is used. */ - } - } - - pointer_set_destroy (tset); - } - - /* For each field which has a binding and which was not defined in - an enclosing struct, clear the in_struct field. */ - FOR_EACH_VEC_ELT (struct_parse_info->fields, ix, b) - b->in_struct = 0; -} - -/* 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. - FIELDLIST is a chain of FIELD_DECL nodes for the fields. - ATTRIBUTES are attributes to be applied to the structure. - - ENCLOSING_STRUCT_PARSE_INFO is the value of STRUCT_PARSE_INFO when - the struct was started. */ - -tree -finish_struct (location_t loc, tree t, tree fieldlist, tree attributes, - struct c_struct_parse_info *enclosing_struct_parse_info) -{ - tree x; - bool toplevel = file_scope == current_scope; - int saw_named_field; - - /* If this type was previously laid out as a forward reference, - make sure we lay it out again. */ - - TYPE_SIZE (t) = 0; - - decl_attributes (&t, attributes, (int) ATTR_FLAG_TYPE_IN_PLACE); - - if (pedantic) - { - for (x = fieldlist; x; x = DECL_CHAIN (x)) - { - if (DECL_NAME (x) != 0) - break; - if (flag_isoc11 - && (TREE_CODE (TREE_TYPE (x)) == RECORD_TYPE - || TREE_CODE (TREE_TYPE (x)) == UNION_TYPE)) - break; - } - - if (x == 0) - { - if (TREE_CODE (t) == UNION_TYPE) - { - if (fieldlist) - pedwarn (loc, OPT_Wpedantic, "union has no named members"); - else - pedwarn (loc, OPT_Wpedantic, "union has no members"); - } - else - { - if (fieldlist) - pedwarn (loc, OPT_Wpedantic, "struct has no named members"); - else - pedwarn (loc, OPT_Wpedantic, "struct has no members"); - } - } - } - - /* Install struct as DECL_CONTEXT of each field decl. - Also process specified field sizes, found in the DECL_INITIAL, - storing 0 there after the type has been changed to precision equal - to its width, rather than the precision of the specified standard - type. (Correct layout requires the original type to have been preserved - until now.) */ - - saw_named_field = 0; - for (x = fieldlist; x; x = DECL_CHAIN (x)) - { - if (TREE_TYPE (x) == error_mark_node) - continue; - - DECL_CONTEXT (x) = t; - - /* If any field is const, the structure type is pseudo-const. */ - if (TREE_READONLY (x)) - C_TYPE_FIELDS_READONLY (t) = 1; - else - { - /* A field that is pseudo-const makes the structure likewise. */ - tree t1 = strip_array_types (TREE_TYPE (x)); - if ((TREE_CODE (t1) == RECORD_TYPE || TREE_CODE (t1) == UNION_TYPE) - && C_TYPE_FIELDS_READONLY (t1)) - C_TYPE_FIELDS_READONLY (t) = 1; - } - - /* Any field that is volatile means variables of this type must be - treated in some ways as volatile. */ - if (TREE_THIS_VOLATILE (x)) - C_TYPE_FIELDS_VOLATILE (t) = 1; - - /* Any field of nominal variable size implies structure is too. */ - if (C_DECL_VARIABLE_SIZE (x)) - C_TYPE_VARIABLE_SIZE (t) = 1; - - if (DECL_INITIAL (x)) - { - unsigned HOST_WIDE_INT width = tree_low_cst (DECL_INITIAL (x), 1); - DECL_SIZE (x) = bitsize_int (width); - DECL_BIT_FIELD (x) = 1; - SET_DECL_C_BIT_FIELD (x); - } - - if (TYPE_PACKED (t) - && (DECL_BIT_FIELD (x) - || TYPE_ALIGN (TREE_TYPE (x)) > BITS_PER_UNIT)) - DECL_PACKED (x) = 1; - - /* Detect flexible array member in an invalid context. */ - if (TREE_CODE (TREE_TYPE (x)) == ARRAY_TYPE - && TYPE_SIZE (TREE_TYPE (x)) == NULL_TREE - && TYPE_DOMAIN (TREE_TYPE (x)) != NULL_TREE - && TYPE_MAX_VALUE (TYPE_DOMAIN (TREE_TYPE (x))) == NULL_TREE) - { - if (TREE_CODE (t) == UNION_TYPE) - { - error_at (DECL_SOURCE_LOCATION (x), - "flexible array member in union"); - TREE_TYPE (x) = error_mark_node; - } - else if (DECL_CHAIN (x) != NULL_TREE) - { - error_at (DECL_SOURCE_LOCATION (x), - "flexible array member not at end of struct"); - TREE_TYPE (x) = error_mark_node; - } - else if (!saw_named_field) - { - error_at (DECL_SOURCE_LOCATION (x), - "flexible array member in otherwise empty struct"); - TREE_TYPE (x) = error_mark_node; - } - } - - if (pedantic && TREE_CODE (t) == RECORD_TYPE - && flexible_array_type_p (TREE_TYPE (x))) - pedwarn (DECL_SOURCE_LOCATION (x), OPT_Wpedantic, - "invalid use of structure with flexible array member"); - - if (DECL_NAME (x) - || TREE_CODE (TREE_TYPE (x)) == RECORD_TYPE - || TREE_CODE (TREE_TYPE (x)) == UNION_TYPE) - saw_named_field = 1; - } - - detect_field_duplicates (fieldlist); - - /* Now we have the nearly final fieldlist. Record it, - then lay out the structure or union (including the fields). */ - - TYPE_FIELDS (t) = fieldlist; - - layout_type (t); - - /* Give bit-fields their proper types. */ - { - tree *fieldlistp = &fieldlist; - while (*fieldlistp) - if (TREE_CODE (*fieldlistp) == FIELD_DECL && DECL_INITIAL (*fieldlistp) - && TREE_TYPE (*fieldlistp) != error_mark_node) - { - unsigned HOST_WIDE_INT width - = tree_low_cst (DECL_INITIAL (*fieldlistp), 1); - tree type = TREE_TYPE (*fieldlistp); - if (width != TYPE_PRECISION (type)) - { - TREE_TYPE (*fieldlistp) - = c_build_bitfield_integer_type (width, TYPE_UNSIGNED (type)); - DECL_MODE (*fieldlistp) = TYPE_MODE (TREE_TYPE (*fieldlistp)); - } - DECL_INITIAL (*fieldlistp) = 0; - } - else - fieldlistp = &DECL_CHAIN (*fieldlistp); - } - - /* Now we have the truly final field list. - Store it in this type and in the variants. */ - - TYPE_FIELDS (t) = fieldlist; - - /* 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". */ - - { - int len = 0; - - for (x = fieldlist; x; x = DECL_CHAIN (x)) - { - if (len > 15 || DECL_NAME (x) == NULL) - break; - len += 1; - } - - if (len > 15) - { - tree *field_array; - struct lang_type *space; - struct sorted_fields_type *space2; - - len += list_length (x); - - /* Use the same allocation policy here that make_node uses, to - ensure that this lives as long as the rest of the struct decl. - All decls in an inline function need to be saved. */ - - space = ggc_alloc_cleared_lang_type (sizeof (struct lang_type)); - space2 = ggc_alloc_sorted_fields_type - (sizeof (struct sorted_fields_type) + len * sizeof (tree)); - - len = 0; - space->s = space2; - field_array = &space2->elts[0]; - for (x = fieldlist; x; x = DECL_CHAIN (x)) - { - field_array[len++] = x; - - /* If there is anonymous struct or union, break out of the loop. */ - if (DECL_NAME (x) == NULL) - break; - } - /* Found no anonymous struct/union. Add the TYPE_LANG_SPECIFIC. */ - if (x == NULL) - { - TYPE_LANG_SPECIFIC (t) = space; - TYPE_LANG_SPECIFIC (t)->s->len = len; - field_array = TYPE_LANG_SPECIFIC (t)->s->elts; - qsort (field_array, len, sizeof (tree), field_decl_cmp); - } - } - } - - for (x = TYPE_MAIN_VARIANT (t); x; x = TYPE_NEXT_VARIANT (x)) - { - TYPE_FIELDS (x) = TYPE_FIELDS (t); - TYPE_LANG_SPECIFIC (x) = TYPE_LANG_SPECIFIC (t); - C_TYPE_FIELDS_READONLY (x) = C_TYPE_FIELDS_READONLY (t); - C_TYPE_FIELDS_VOLATILE (x) = C_TYPE_FIELDS_VOLATILE (t); - C_TYPE_VARIABLE_SIZE (x) = C_TYPE_VARIABLE_SIZE (t); - } - - /* If this was supposed to be a transparent union, but we can't - make it one, warn and turn off the flag. */ - if (TREE_CODE (t) == UNION_TYPE - && TYPE_TRANSPARENT_AGGR (t) - && (!TYPE_FIELDS (t) || TYPE_MODE (t) != DECL_MODE (TYPE_FIELDS (t)))) - { - TYPE_TRANSPARENT_AGGR (t) = 0; - warning_at (loc, 0, "union cannot be made transparent"); - } - - /* If this structure or union completes the type of any previous - variable declaration, lay it out and output its rtl. */ - for (x = C_TYPE_INCOMPLETE_VARS (TYPE_MAIN_VARIANT (t)); - x; - x = TREE_CHAIN (x)) - { - tree decl = TREE_VALUE (x); - if (TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE) - layout_array_type (TREE_TYPE (decl)); - if (TREE_CODE (decl) != TYPE_DECL) - { - layout_decl (decl, 0); - if (c_dialect_objc ()) - objc_check_decl (decl); - rest_of_decl_compilation (decl, toplevel, 0); - } - } - C_TYPE_INCOMPLETE_VARS (TYPE_MAIN_VARIANT (t)) = 0; - - /* Update type location to the one of the definition, instead of e.g. - a forward declaration. */ - if (TYPE_STUB_DECL (t)) - DECL_SOURCE_LOCATION (TYPE_STUB_DECL (t)) = loc; - - /* Finish debugging output for this type. */ - rest_of_type_compilation (t, toplevel); - - /* 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 - to be bound now. */ - if (building_stmt_list_p () && variably_modified_type_p (t, NULL_TREE)) - add_stmt (build_stmt (loc, - DECL_EXPR, build_decl (loc, TYPE_DECL, NULL, t))); - - if (warn_cxx_compat) - warn_cxx_compat_finish_struct (fieldlist); - - struct_parse_info->struct_types.release (); - struct_parse_info->fields.release (); - struct_parse_info->typedefs_seen.release (); - XDELETE (struct_parse_info); - - struct_parse_info = enclosing_struct_parse_info; - - /* If this struct is defined inside a struct, add it to - struct_types. */ - if (warn_cxx_compat - && struct_parse_info != NULL - && !in_sizeof && !in_typeof && !in_alignof) - struct_parse_info->struct_types.safe_push (t); - - return t; -} - -/* Lay out the type T, and its element type, and so on. */ - -static void -layout_array_type (tree t) -{ - if (TREE_CODE (TREE_TYPE (t)) == ARRAY_TYPE) - layout_array_type (TREE_TYPE (t)); - layout_type (t); -} - -/* Begin compiling the definition of an enumeration type. - NAME is its name (or null if anonymous). - LOC is the enum's location. - Returns the type object, as yet incomplete. - Also records info about it so that build_enumerator - may be used to declare the individual values as they are read. */ - -tree -start_enum (location_t loc, struct c_enum_contents *the_enum, tree name) -{ - tree enumtype = NULL_TREE; - location_t enumloc = UNKNOWN_LOCATION; - - /* If this is the real definition for a previous forward reference, - fill in the contents in the same object that used to be the - forward reference. */ - - if (name != NULL_TREE) - enumtype = lookup_tag (ENUMERAL_TYPE, name, 1, &enumloc); - - if (enumtype == 0 || TREE_CODE (enumtype) != ENUMERAL_TYPE) - { - enumtype = make_node (ENUMERAL_TYPE); - pushtag (loc, name, enumtype); - } - - if (C_TYPE_BEING_DEFINED (enumtype)) - error_at (loc, "nested redefinition of %<enum %E%>", name); - - C_TYPE_BEING_DEFINED (enumtype) = 1; - - if (TYPE_VALUES (enumtype) != 0) - { - /* This enum is a named one that has been declared already. */ - error_at (loc, "redeclaration of %<enum %E%>", name); - if (enumloc != UNKNOWN_LOCATION) - inform (enumloc, "originally defined here"); - - /* Completely replace its old definition. - The old enumerators remain defined, however. */ - TYPE_VALUES (enumtype) = 0; - } - - the_enum->enum_next_value = integer_zero_node; - the_enum->enum_overflow = 0; - - if (flag_short_enums) - TYPE_PACKED (enumtype) = 1; - - /* FIXME: This will issue a warning for a use of a type defined - within sizeof in a statement expr. This is not terribly serious - as C++ doesn't permit statement exprs within sizeof anyhow. */ - if (warn_cxx_compat && (in_sizeof || in_typeof || in_alignof)) - warning_at (loc, OPT_Wc___compat, - "defining type in %qs expression is invalid in C++", - (in_sizeof - ? "sizeof" - : (in_typeof ? "typeof" : "alignof"))); - - return enumtype; -} - -/* After processing and defining all the values of an enumeration type, - install their decls in the enumeration type and finish it off. - ENUMTYPE is the type object, VALUES a list of decl-value pairs, - and ATTRIBUTES are the specified attributes. - Returns ENUMTYPE. */ - -tree -finish_enum (tree enumtype, tree values, tree attributes) -{ - tree pair, tem; - tree minnode = 0, maxnode = 0; - int precision, unsign; - bool toplevel = (file_scope == current_scope); - struct lang_type *lt; - - decl_attributes (&enumtype, attributes, (int) ATTR_FLAG_TYPE_IN_PLACE); - - /* Calculate the maximum value of any enumerator in this type. */ - - if (values == error_mark_node) - minnode = maxnode = integer_zero_node; - else - { - minnode = maxnode = TREE_VALUE (values); - for (pair = TREE_CHAIN (values); pair; pair = TREE_CHAIN (pair)) - { - tree value = TREE_VALUE (pair); - if (tree_int_cst_lt (maxnode, value)) - maxnode = value; - if (tree_int_cst_lt (value, minnode)) - minnode = value; - } - } - - /* Construct the final type of this enumeration. It is the same - 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 - the values are negative. */ - unsign = (tree_int_cst_sgn (minnode) >= 0); - precision = MAX (tree_int_cst_min_precision (minnode, unsign), - tree_int_cst_min_precision (maxnode, unsign)); - - if (TYPE_PACKED (enumtype) || precision > TYPE_PRECISION (integer_type_node)) - { - tem = c_common_type_for_size (precision, unsign); - if (tem == NULL) - { - warning (0, "enumeration values exceed range of largest integer"); - tem = long_long_integer_type_node; - } - } - else - tem = unsign ? unsigned_type_node : integer_type_node; - - TYPE_MIN_VALUE (enumtype) = TYPE_MIN_VALUE (tem); - TYPE_MAX_VALUE (enumtype) = TYPE_MAX_VALUE (tem); - TYPE_UNSIGNED (enumtype) = TYPE_UNSIGNED (tem); - TYPE_SIZE (enumtype) = 0; - - /* If the precision of the type was specific with an attribute and it - was too small, give an error. Otherwise, use it. */ - if (TYPE_PRECISION (enumtype)) - { - if (precision > TYPE_PRECISION (enumtype)) - error ("specified mode too small for enumeral values"); - } - else - TYPE_PRECISION (enumtype) = TYPE_PRECISION (tem); - - layout_type (enumtype); - - if (values != error_mark_node) - { - /* Change the type of the enumerators to be the enum type. We - need to do this irrespective of the size of the enum, for - proper type checking. Replace the DECL_INITIALs of the - enumerators, and the value slots of the list, with copies - that have the enum type; they cannot be modified in place - because they may be shared (e.g. integer_zero_node) Finally, - change the purpose slots to point to the names of the decls. */ - for (pair = values; pair; pair = TREE_CHAIN (pair)) - { - tree enu = TREE_PURPOSE (pair); - tree ini = DECL_INITIAL (enu); - - TREE_TYPE (enu) = enumtype; - - /* The ISO C Standard mandates enumerators to have type int, - even though the underlying type of an enum type is - unspecified. However, GCC allows enumerators of any - integer type as an extensions. build_enumerator() - converts any enumerators that fit in an int to type int, - to avoid promotions to unsigned types when comparing - integers with enumerators that fit in the int range. - When -pedantic is given, build_enumerator() would have - already warned about those that don't fit. Here we - convert the rest to the enumerator type. */ - if (TREE_TYPE (ini) != integer_type_node) - ini = convert (enumtype, ini); - - DECL_INITIAL (enu) = ini; - TREE_PURPOSE (pair) = DECL_NAME (enu); - TREE_VALUE (pair) = ini; - } - - TYPE_VALUES (enumtype) = values; - } - - /* Record the min/max values so that we can warn about bit-field - enumerations that are too small for the values. */ - lt = ggc_alloc_cleared_lang_type (sizeof (struct lang_type)); - lt->enum_min = minnode; - lt->enum_max = maxnode; - TYPE_LANG_SPECIFIC (enumtype) = lt; - - /* Fix up all variant types of this enum type. */ - for (tem = TYPE_MAIN_VARIANT (enumtype); tem; tem = TYPE_NEXT_VARIANT (tem)) - { - if (tem == enumtype) - continue; - TYPE_VALUES (tem) = TYPE_VALUES (enumtype); - TYPE_MIN_VALUE (tem) = TYPE_MIN_VALUE (enumtype); - TYPE_MAX_VALUE (tem) = TYPE_MAX_VALUE (enumtype); - TYPE_SIZE (tem) = TYPE_SIZE (enumtype); - TYPE_SIZE_UNIT (tem) = TYPE_SIZE_UNIT (enumtype); - SET_TYPE_MODE (tem, TYPE_MODE (enumtype)); - TYPE_PRECISION (tem) = TYPE_PRECISION (enumtype); - TYPE_ALIGN (tem) = TYPE_ALIGN (enumtype); - TYPE_USER_ALIGN (tem) = TYPE_USER_ALIGN (enumtype); - TYPE_UNSIGNED (tem) = TYPE_UNSIGNED (enumtype); - TYPE_LANG_SPECIFIC (tem) = TYPE_LANG_SPECIFIC (enumtype); - } - - /* Finish debugging output for this type. */ - rest_of_type_compilation (enumtype, toplevel); - - /* If this enum is defined inside a struct, add it to - struct_types. */ - if (warn_cxx_compat - && struct_parse_info != NULL - && !in_sizeof && !in_typeof && !in_alignof) - struct_parse_info->struct_types.safe_push (enumtype); - - return enumtype; -} - -/* Build and install a CONST_DECL for one value of the - current enumeration type (one that was begun with start_enum). - DECL_LOC is the location of the enumerator. - LOC is the location of the '=' operator if any, DECL_LOC otherwise. - Return a tree-list containing the CONST_DECL and its value. - Assignment of sequential values by default is handled here. */ - -tree -build_enumerator (location_t decl_loc, location_t loc, - struct c_enum_contents *the_enum, tree name, tree value) -{ - tree decl, type; - - /* Validate and default VALUE. */ - - if (value != 0) - { - /* Don't issue more errors for error_mark_node (i.e. an - undeclared identifier) - just ignore the value expression. */ - if (value == error_mark_node) - value = 0; - else if (!INTEGRAL_TYPE_P (TREE_TYPE (value))) - { - error_at (loc, "enumerator value for %qE is not an integer constant", - name); - value = 0; - } - else - { - if (TREE_CODE (value) != INTEGER_CST) - { - value = c_fully_fold (value, false, NULL); - if (TREE_CODE (value) == INTEGER_CST) - pedwarn (loc, OPT_Wpedantic, - "enumerator value for %qE is not an integer " - "constant expression", name); - } - if (TREE_CODE (value) != INTEGER_CST) - { - error ("enumerator value for %qE is not an integer constant", - name); - value = 0; - } - else - { - value = default_conversion (value); - constant_expression_warning (value); - } - } - } - - /* Default based on previous value. */ - /* It should no longer be possible to have NON_LVALUE_EXPR - in the default. */ - if (value == 0) - { - value = the_enum->enum_next_value; - if (the_enum->enum_overflow) - error_at (loc, "overflow in enumeration values"); - } - /* Even though the underlying type of an enum is unspecified, the - type of enumeration constants is explicitly defined as int - (6.4.4.3/2 in the C99 Standard). GCC allows any integer type as - an extension. */ - else if (!int_fits_type_p (value, integer_type_node)) - pedwarn (loc, OPT_Wpedantic, - "ISO C restricts enumerator values to range of %<int%>"); - - /* The ISO C Standard mandates enumerators to have type int, even - though the underlying type of an enum type is unspecified. - However, GCC allows enumerators of any integer type as an - extensions. Here we convert any enumerators that fit in an int - to type int, to avoid promotions to unsigned types when comparing - integers with enumerators that fit in the int range. When - -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 - because this value may be used to define more enumerators. */ - if (int_fits_type_p (value, integer_type_node)) - value = convert (integer_type_node, value); - - /* Set basis for default for next value. */ - the_enum->enum_next_value - = build_binary_op (EXPR_LOC_OR_HERE (value), - PLUS_EXPR, value, integer_one_node, 0); - the_enum->enum_overflow = tree_int_cst_lt (the_enum->enum_next_value, value); - - /* Now create a declaration for the enum value name. */ - - type = TREE_TYPE (value); - type = c_common_type_for_size (MAX (TYPE_PRECISION (type), - TYPE_PRECISION (integer_type_node)), - (TYPE_PRECISION (type) - >= TYPE_PRECISION (integer_type_node) - && TYPE_UNSIGNED (type))); - - decl = build_decl (decl_loc, CONST_DECL, name, type); - DECL_INITIAL (decl) = convert (type, value); - pushdecl (decl); - - return tree_cons (decl, value, NULL_TREE); -} - - -/* Create the FUNCTION_DECL for a function definition. - DECLSPECS, DECLARATOR and ATTRIBUTES are the parts of - 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. - - This function creates a binding context for the function body - 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 - (it defines a datum instead), we return 0, which tells - yyparse to report a parse error. */ - -int -start_function (struct c_declspecs *declspecs, struct c_declarator *declarator, - tree attributes) -{ - tree decl1, old_decl; - tree restype, resdecl; - location_t loc; - - current_function_returns_value = 0; /* Assume, until we see it does. */ - current_function_returns_null = 0; - current_function_returns_abnormally = 0; - warn_about_return_type = 0; - c_switch_stack = NULL; - - /* Indicate no valid break/continue context by setting these variables - to some non-null, non-label value. We'll notice and emit the proper - error message in c_finish_bc_stmt. */ - c_break_label = c_cont_label = size_zero_node; - - decl1 = grokdeclarator (declarator, declspecs, FUNCDEF, true, NULL, - &attributes, NULL, NULL, DEPRECATED_NORMAL); - - /* If the declarator is not suitable for a function definition, - cause a syntax error. */ - if (decl1 == 0 - || TREE_CODE (decl1) != FUNCTION_DECL) - return 0; - - loc = DECL_SOURCE_LOCATION (decl1); - - decl_attributes (&decl1, attributes, 0); - - if (DECL_DECLARED_INLINE_P (decl1) - && DECL_UNINLINABLE (decl1) - && lookup_attribute ("noinline", DECL_ATTRIBUTES (decl1))) - warning_at (loc, OPT_Wattributes, - "inline function %qD given attribute noinline", - decl1); - - /* Handle gnu_inline attribute. */ - if (declspecs->inline_p - && !flag_gnu89_inline - && TREE_CODE (decl1) == FUNCTION_DECL - && (lookup_attribute ("gnu_inline", DECL_ATTRIBUTES (decl1)) - || current_function_decl)) - { - if (declspecs->storage_class != csc_static) - DECL_EXTERNAL (decl1) = !DECL_EXTERNAL (decl1); - } - - announce_function (decl1); - - if (!COMPLETE_OR_VOID_TYPE_P (TREE_TYPE (TREE_TYPE (decl1)))) - { - error_at (loc, "return type is an incomplete type"); - /* Make it return void instead. */ - TREE_TYPE (decl1) - = build_function_type (void_type_node, - TYPE_ARG_TYPES (TREE_TYPE (decl1))); - } - - if (warn_about_return_type) - pedwarn_c99 (loc, flag_isoc99 ? 0 - : (warn_return_type ? OPT_Wreturn_type : OPT_Wimplicit_int), - "return type defaults to %<int%>"); - - /* Make the init_value nonzero so pushdecl knows this is not tentative. - error_mark_node is replaced below (in pop_scope) with the BLOCK. */ - DECL_INITIAL (decl1) = error_mark_node; - - /* A nested function is not global. */ - if (current_function_decl != 0) - TREE_PUBLIC (decl1) = 0; - - /* If this definition isn't a prototype and we had a prototype declaration - before, copy the arg type info from that prototype. */ - old_decl = lookup_name_in_scope (DECL_NAME (decl1), current_scope); - if (old_decl && TREE_CODE (old_decl) != FUNCTION_DECL) - old_decl = 0; - current_function_prototype_locus = UNKNOWN_LOCATION; - current_function_prototype_built_in = false; - current_function_prototype_arg_types = NULL_TREE; - if (!prototype_p (TREE_TYPE (decl1))) - { - if (old_decl != 0 && TREE_CODE (TREE_TYPE (old_decl)) == FUNCTION_TYPE - && comptypes (TREE_TYPE (TREE_TYPE (decl1)), - TREE_TYPE (TREE_TYPE (old_decl)))) - { - TREE_TYPE (decl1) = composite_type (TREE_TYPE (old_decl), - TREE_TYPE (decl1)); - current_function_prototype_locus = DECL_SOURCE_LOCATION (old_decl); - current_function_prototype_built_in - = C_DECL_BUILTIN_PROTOTYPE (old_decl); - current_function_prototype_arg_types - = TYPE_ARG_TYPES (TREE_TYPE (decl1)); - } - if (TREE_PUBLIC (decl1)) - { - /* If there is an external prototype declaration of this - function, record its location but do not copy information - to this decl. This may be an invisible declaration - (built-in or in a scope which has finished) or simply - have more refined argument types than any declaration - found above. */ - struct c_binding *b; - for (b = I_SYMBOL_BINDING (DECL_NAME (decl1)); b; b = b->shadowed) - if (B_IN_SCOPE (b, external_scope)) - break; - if (b) - { - tree ext_decl, ext_type; - ext_decl = b->decl; - ext_type = b->u.type ? b->u.type : TREE_TYPE (ext_decl); - if (TREE_CODE (ext_type) == FUNCTION_TYPE - && comptypes (TREE_TYPE (TREE_TYPE (decl1)), - TREE_TYPE (ext_type))) - { - current_function_prototype_locus - = DECL_SOURCE_LOCATION (ext_decl); - current_function_prototype_built_in - = C_DECL_BUILTIN_PROTOTYPE (ext_decl); - current_function_prototype_arg_types - = TYPE_ARG_TYPES (ext_type); - } - } - } - } - - /* Optionally warn of old-fashioned def with no previous prototype. */ - if (warn_strict_prototypes - && old_decl != error_mark_node - && !prototype_p (TREE_TYPE (decl1)) - && C_DECL_ISNT_PROTOTYPE (old_decl)) - warning_at (loc, OPT_Wstrict_prototypes, - "function declaration isn%'t a prototype"); - /* Optionally warn of any global def with no previous prototype. */ - else if (warn_missing_prototypes - && old_decl != error_mark_node - && TREE_PUBLIC (decl1) - && !MAIN_NAME_P (DECL_NAME (decl1)) - && C_DECL_ISNT_PROTOTYPE (old_decl)) - warning_at (loc, OPT_Wmissing_prototypes, - "no previous prototype for %qD", decl1); - /* Optionally warn of any def with no previous prototype - if the function has already been used. */ - else if (warn_missing_prototypes - && old_decl != 0 - && old_decl != error_mark_node - && TREE_USED (old_decl) - && !prototype_p (TREE_TYPE (old_decl))) - warning_at (loc, OPT_Wmissing_prototypes, - "%qD was used with no prototype before its definition", decl1); - /* Optionally warn of any global def with no previous declaration. */ - else if (warn_missing_declarations - && TREE_PUBLIC (decl1) - && old_decl == 0 - && !MAIN_NAME_P (DECL_NAME (decl1))) - warning_at (loc, OPT_Wmissing_declarations, - "no previous declaration for %qD", - decl1); - /* Optionally warn of any def with no previous declaration - if the function has already been used. */ - else if (warn_missing_declarations - && old_decl != 0 - && old_decl != error_mark_node - && TREE_USED (old_decl) - && C_DECL_IMPLICIT (old_decl)) - warning_at (loc, OPT_Wmissing_declarations, - "%qD was used with no declaration before its definition", decl1); - - /* This function exists in static storage. - (This does not mean `static' in the C sense!) */ - TREE_STATIC (decl1) = 1; - - /* 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. */ - gcc_assert (!DECL_ASSEMBLER_NAME_SET_P (decl1)); - - /* If #pragma weak was used, mark the decl weak now. */ - if (current_scope == file_scope) - maybe_apply_pragma_weak (decl1); - - /* Warn for unlikely, improbable, or stupid declarations of `main'. */ - if (warn_main && MAIN_NAME_P (DECL_NAME (decl1))) - { - if (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (decl1))) - != integer_type_node) - pedwarn (loc, OPT_Wmain, "return type of %qD is not %<int%>", decl1); - - check_main_parameter_types (decl1); - - if (!TREE_PUBLIC (decl1)) - pedwarn (loc, OPT_Wmain, - "%qD is normally a non-static function", decl1); - } - - /* 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, - use the old decl. */ - - current_function_decl = pushdecl (decl1); - - push_scope (); - declare_parm_level (); - - restype = TREE_TYPE (TREE_TYPE (current_function_decl)); - resdecl = build_decl (loc, RESULT_DECL, NULL_TREE, restype); - DECL_ARTIFICIAL (resdecl) = 1; - DECL_IGNORED_P (resdecl) = 1; - DECL_RESULT (current_function_decl) = resdecl; - - start_fname_decls (); - - return 1; -} - -/* Subroutine of store_parm_decls which handles new-style function - definitions (prototype format). The parms already have decls, so we - need only record them as in effect and complain if any redundant - old-style parm decls were written. */ -static void -store_parm_decls_newstyle (tree fndecl, const struct c_arg_info *arg_info) -{ - tree decl; - c_arg_tag *tag; - unsigned ix; - - if (current_scope->bindings) - { - error_at (DECL_SOURCE_LOCATION (fndecl), - "old-style parameter declarations in prototyped " - "function definition"); - - /* Get rid of the old-style declarations. */ - pop_scope (); - push_scope (); - } - /* 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 - (this happens when a function definition has just an ellipsis in - its parameter list). */ - else if (!in_system_header && !current_function_scope - && arg_info->types != error_mark_node) - warning_at (DECL_SOURCE_LOCATION (fndecl), OPT_Wtraditional, - "traditional C rejects ISO C style function definitions"); - - /* Now make all the parameter declarations visible in the function body. - We can bypass most of the grunt work of pushdecl. */ - for (decl = arg_info->parms; decl; decl = DECL_CHAIN (decl)) - { - DECL_CONTEXT (decl) = current_function_decl; - if (DECL_NAME (decl)) - { - bind (DECL_NAME (decl), decl, current_scope, - /*invisible=*/false, /*nested=*/false, - UNKNOWN_LOCATION); - if (!TREE_USED (decl)) - warn_if_shadowing (decl); - } - else - error_at (DECL_SOURCE_LOCATION (decl), "parameter name omitted"); - } - - /* Record the parameter list in the function declaration. */ - DECL_ARGUMENTS (fndecl) = arg_info->parms; - - /* Now make all the ancillary declarations visible, likewise. */ - for (decl = arg_info->others; decl; decl = DECL_CHAIN (decl)) - { - DECL_CONTEXT (decl) = current_function_decl; - if (DECL_NAME (decl)) - bind (DECL_NAME (decl), decl, current_scope, - /*invisible=*/false, - /*nested=*/(TREE_CODE (decl) == FUNCTION_DECL), - UNKNOWN_LOCATION); - } - - /* And all the tag declarations. */ - FOR_EACH_VEC_SAFE_ELT_REVERSE (arg_info->tags, ix, tag) - if (tag->id) - bind (tag->id, tag->type, current_scope, - /*invisible=*/false, /*nested=*/false, UNKNOWN_LOCATION); -} - -/* Subroutine of store_parm_decls which handles old-style function - definitions (separate parameter list and declarations). */ - -static void -store_parm_decls_oldstyle (tree fndecl, const struct c_arg_info *arg_info) -{ - struct c_binding *b; - tree parm, decl, last; - tree parmids = arg_info->parms; - struct pointer_set_t *seen_args = pointer_set_create (); - - if (!in_system_header) - warning_at (DECL_SOURCE_LOCATION (fndecl), - OPT_Wold_style_definition, "old-style function definition"); - - /* Match each formal parameter name with its declaration. Save each - decl in the appropriate TREE_PURPOSE slot of the parmids chain. */ - for (parm = parmids; parm; parm = TREE_CHAIN (parm)) - { - if (TREE_VALUE (parm) == 0) - { - error_at (DECL_SOURCE_LOCATION (fndecl), - "parameter name missing from parameter list"); - TREE_PURPOSE (parm) = 0; - continue; - } - - b = I_SYMBOL_BINDING (TREE_VALUE (parm)); - if (b && B_IN_CURRENT_SCOPE (b)) - { - decl = b->decl; - /* Skip erroneous parameters. */ - if (decl == error_mark_node) - continue; - /* If we got something other than a PARM_DECL it is an error. */ - if (TREE_CODE (decl) != PARM_DECL) - error_at (DECL_SOURCE_LOCATION (decl), - "%qD declared as a non-parameter", decl); - /* If the declaration is already marked, we have a duplicate - name. Complain and ignore the duplicate. */ - else if (pointer_set_contains (seen_args, decl)) - { - error_at (DECL_SOURCE_LOCATION (decl), - "multiple parameters named %qD", decl); - TREE_PURPOSE (parm) = 0; - continue; - } - /* If the declaration says "void", complain and turn it into - an int. */ - else if (VOID_TYPE_P (TREE_TYPE (decl))) - { - error_at (DECL_SOURCE_LOCATION (decl), - "parameter %qD declared with void type", decl); - TREE_TYPE (decl) = integer_type_node; - DECL_ARG_TYPE (decl) = integer_type_node; - layout_decl (decl, 0); - } - warn_if_shadowing (decl); - } - /* If no declaration found, default to int. */ - else - { - /* FIXME diagnostics: This should be the location of the argument, - not the FNDECL. E.g., for an old-style declaration - - int f10(v) { blah; } - - We should use the location of the V, not the F10. - Unfortunately, the V is an IDENTIFIER_NODE which has no - location. In the future we need locations for c_arg_info - entries. - - See gcc.dg/Wshadow-3.c for an example of this problem. */ - decl = build_decl (DECL_SOURCE_LOCATION (fndecl), - PARM_DECL, TREE_VALUE (parm), integer_type_node); - DECL_ARG_TYPE (decl) = TREE_TYPE (decl); - pushdecl (decl); - warn_if_shadowing (decl); - - if (flag_isoc99) - pedwarn (DECL_SOURCE_LOCATION (decl), - 0, "type of %qD defaults to %<int%>", decl); - else - warning_at (DECL_SOURCE_LOCATION (decl), - OPT_Wmissing_parameter_type, - "type of %qD defaults to %<int%>", decl); - } - - TREE_PURPOSE (parm) = decl; - pointer_set_insert (seen_args, decl); - } - - /* Now examine the parms chain for incomplete declarations - and declarations with no corresponding names. */ - - for (b = current_scope->bindings; b; b = b->prev) - { - parm = b->decl; - if (TREE_CODE (parm) != PARM_DECL) - continue; - - if (TREE_TYPE (parm) != error_mark_node - && !COMPLETE_TYPE_P (TREE_TYPE (parm))) - { - error_at (DECL_SOURCE_LOCATION (parm), - "parameter %qD has incomplete type", parm); - TREE_TYPE (parm) = error_mark_node; - } - - if (!pointer_set_contains (seen_args, parm)) - { - error_at (DECL_SOURCE_LOCATION (parm), - "declaration for parameter %qD but no such parameter", - parm); - - /* Pretend the parameter was not missing. - This gets us to a standard state and minimizes - further error messages. */ - parmids = chainon (parmids, tree_cons (parm, 0, 0)); - } - } - - /* Chain the declarations together in the order of the list of - names. Store that chain in the function decl, replacing the - list of names. Update the current scope to match. */ - DECL_ARGUMENTS (fndecl) = 0; - - for (parm = parmids; parm; parm = TREE_CHAIN (parm)) - if (TREE_PURPOSE (parm)) - break; - if (parm && TREE_PURPOSE (parm)) - { - last = TREE_PURPOSE (parm); - DECL_ARGUMENTS (fndecl) = last; - - for (parm = TREE_CHAIN (parm); parm; parm = TREE_CHAIN (parm)) - if (TREE_PURPOSE (parm)) - { - DECL_CHAIN (last) = TREE_PURPOSE (parm); - last = TREE_PURPOSE (parm); - } - DECL_CHAIN (last) = 0; - } - - pointer_set_destroy (seen_args); - - /* If there was a previous prototype, - set the DECL_ARG_TYPE of each argument according to - the type previously specified, and report any mismatches. */ - - if (current_function_prototype_arg_types) - { - tree type; - for (parm = DECL_ARGUMENTS (fndecl), - type = current_function_prototype_arg_types; - parm || (type && TREE_VALUE (type) != error_mark_node - && (TYPE_MAIN_VARIANT (TREE_VALUE (type)) != void_type_node)); - parm = DECL_CHAIN (parm), type = TREE_CHAIN (type)) - { - if (parm == 0 || type == 0 - || TYPE_MAIN_VARIANT (TREE_VALUE (type)) == void_type_node) - { - if (current_function_prototype_built_in) - warning_at (DECL_SOURCE_LOCATION (fndecl), - 0, "number of arguments doesn%'t match " - "built-in prototype"); - else - { - /* FIXME diagnostics: This should be the location of - FNDECL, but there is bug when a prototype is - declared inside function context, but defined - outside of it (e.g., gcc.dg/pr15698-2.c). In - which case FNDECL gets the location of the - prototype, not the definition. */ - error_at (input_location, - "number of arguments doesn%'t match prototype"); - - error_at (current_function_prototype_locus, - "prototype declaration"); - } - break; - } - /* Type for passing arg must be consistent with that - declared for the arg. ISO C says we take the unqualified - type for parameters declared with qualified type. */ - if (TREE_TYPE (parm) != error_mark_node - && TREE_TYPE (type) != error_mark_node - && !comptypes (TYPE_MAIN_VARIANT (DECL_ARG_TYPE (parm)), - TYPE_MAIN_VARIANT (TREE_VALUE (type)))) - { - if (TYPE_MAIN_VARIANT (TREE_TYPE (parm)) - == TYPE_MAIN_VARIANT (TREE_VALUE (type))) - { - /* Adjust argument to match prototype. E.g. a previous - `int foo(float);' prototype causes - `int foo(x) float x; {...}' to be treated like - `int foo(float x) {...}'. This is particularly - useful for argument types like uid_t. */ - DECL_ARG_TYPE (parm) = TREE_TYPE (parm); - - if (targetm.calls.promote_prototypes (TREE_TYPE (current_function_decl)) - && INTEGRAL_TYPE_P (TREE_TYPE (parm)) - && TYPE_PRECISION (TREE_TYPE (parm)) - < TYPE_PRECISION (integer_type_node)) - DECL_ARG_TYPE (parm) = integer_type_node; - - /* ??? Is it possible to get here with a - built-in prototype or will it always have - been diagnosed as conflicting with an - old-style definition and discarded? */ - if (current_function_prototype_built_in) - warning_at (DECL_SOURCE_LOCATION (parm), - OPT_Wpedantic, "promoted argument %qD " - "doesn%'t match built-in prototype", parm); - else - { - pedwarn (DECL_SOURCE_LOCATION (parm), - OPT_Wpedantic, "promoted argument %qD " - "doesn%'t match prototype", parm); - pedwarn (current_function_prototype_locus, OPT_Wpedantic, - "prototype declaration"); - } - } - else - { - if (current_function_prototype_built_in) - warning_at (DECL_SOURCE_LOCATION (parm), - 0, "argument %qD doesn%'t match " - "built-in prototype", parm); - else - { - error_at (DECL_SOURCE_LOCATION (parm), - "argument %qD doesn%'t match prototype", parm); - error_at (current_function_prototype_locus, - "prototype declaration"); - } - } - } - } - TYPE_ACTUAL_ARG_TYPES (TREE_TYPE (fndecl)) = 0; - } - - /* Otherwise, create a prototype that would match. */ - - else - { - tree actual = 0, last = 0, type; - - for (parm = DECL_ARGUMENTS (fndecl); parm; parm = DECL_CHAIN (parm)) - { - type = tree_cons (NULL_TREE, DECL_ARG_TYPE (parm), NULL_TREE); - if (last) - TREE_CHAIN (last) = type; - else - actual = type; - last = type; - } - type = tree_cons (NULL_TREE, void_type_node, NULL_TREE); - if (last) - TREE_CHAIN (last) = type; - else - actual = type; - - /* 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 - affect the types of other similarly-typed functions, so we must - first force the generation of an identical (but separate) type - node for the relevant function type. The new node we create - will be a variant of the main variant of the original function - type. */ - - TREE_TYPE (fndecl) = build_variant_type_copy (TREE_TYPE (fndecl)); - - TYPE_ACTUAL_ARG_TYPES (TREE_TYPE (fndecl)) = actual; - } -} - -/* Store parameter declarations passed in ARG_INFO into the current - function declaration. */ - -void -store_parm_decls_from (struct c_arg_info *arg_info) -{ - current_function_arg_info = arg_info; - store_parm_decls (); -} - -/* Store the parameter declarations into the current function declaration. - This is called after parsing the parameter declarations, before - digesting the body of the function. - - For an old-style definition, construct a prototype out of the old-style - parameter declarations and inject it into the function's type. */ - -void -store_parm_decls (void) -{ - tree fndecl = current_function_decl; - bool proto; - - /* The argument information block for FNDECL. */ - struct c_arg_info *arg_info = current_function_arg_info; - current_function_arg_info = 0; - - /* True if this definition is written with a prototype. Note: - despite C99 6.7.5.3p14, we can *not* treat an empty argument - list in a function definition as equivalent to (void) -- an - empty argument list specifies the function has no parameters, - but only (void) sets up a prototype for future calls. */ - proto = arg_info->types != 0; - - if (proto) - store_parm_decls_newstyle (fndecl, arg_info); - else - store_parm_decls_oldstyle (fndecl, arg_info); - - /* The next call to push_scope will be a function body. */ - - next_is_function_body = true; - - /* Write a record describing this function definition to the prototypes - file (if requested). */ - - gen_aux_info_record (fndecl, 1, 0, proto); - - /* Initialize the RTL code for the function. */ - allocate_struct_function (fndecl, false); - - if (warn_unused_local_typedefs) - cfun->language = ggc_alloc_cleared_language_function (); - - /* Begin the statement tree for this function. */ - DECL_SAVED_TREE (fndecl) = push_stmt_list (); - - /* ??? Insert the contents of the pending sizes list into the function - to be evaluated. The only reason left to have this is - void foo(int n, int array[n++]) - 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 - other pending sizes would be handled by gimplify_parameters. */ - if (arg_info->pending_sizes) - add_stmt (arg_info->pending_sizes); -} - - -/* Finish up a function declaration and compile that function - all the way to assembler language output. Then free the storage - for the function definition. - - This is called after parsing the body of the function definition. */ - -void -finish_function (void) -{ - tree fndecl = current_function_decl; - - if (c_dialect_objc ()) - objc_finish_function (); - - if (TREE_CODE (fndecl) == FUNCTION_DECL - && targetm.calls.promote_prototypes (TREE_TYPE (fndecl))) - { - tree args = DECL_ARGUMENTS (fndecl); - for (; args; args = DECL_CHAIN (args)) - { - tree type = TREE_TYPE (args); - if (INTEGRAL_TYPE_P (type) - && TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node)) - DECL_ARG_TYPE (args) = integer_type_node; - } - } - - if (DECL_INITIAL (fndecl) && DECL_INITIAL (fndecl) != error_mark_node) - BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl)) = fndecl; - - /* Must mark the RESULT_DECL as being in this function. */ - - if (DECL_RESULT (fndecl) && DECL_RESULT (fndecl) != error_mark_node) - DECL_CONTEXT (DECL_RESULT (fndecl)) = fndecl; - - if (MAIN_NAME_P (DECL_NAME (fndecl)) && flag_hosted - && TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (fndecl))) - == integer_type_node && flag_isoc99) - { - /* Hack. We don't want the middle-end to warn that this return - is unreachable, so we mark its location as special. Using - UNKNOWN_LOCATION has the problem that it gets clobbered in - annotate_one_with_locus. A cleaner solution might be to - ensure ! should_carry_locus_p (stmt), but that needs a flag. - */ - c_finish_return (BUILTINS_LOCATION, integer_zero_node, NULL_TREE); - } - - /* Tie off the statement tree for this function. */ - DECL_SAVED_TREE (fndecl) = pop_stmt_list (DECL_SAVED_TREE (fndecl)); - - finish_fname_decls (); - - /* Complain if there's just no return statement. */ - if (warn_return_type - && TREE_CODE (TREE_TYPE (TREE_TYPE (fndecl))) != VOID_TYPE - && !current_function_returns_value && !current_function_returns_null - /* Don't complain if we are no-return. */ - && !current_function_returns_abnormally - /* Don't complain if we are declared noreturn. */ - && !TREE_THIS_VOLATILE (fndecl) - /* Don't warn for main(). */ - && !MAIN_NAME_P (DECL_NAME (fndecl)) - /* Or if they didn't actually specify a return type. */ - && !C_FUNCTION_IMPLICIT_INT (fndecl) - /* Normally, with -Wreturn-type, flow will complain, but we might - optimize out static functions. */ - && !TREE_PUBLIC (fndecl)) - { - warning (OPT_Wreturn_type, - "no return statement in function returning non-void"); - TREE_NO_WARNING (fndecl) = 1; - } - - /* Complain about parameters that are only set, but never otherwise used. */ - if (warn_unused_but_set_parameter) - { - tree decl; - - for (decl = DECL_ARGUMENTS (fndecl); - decl; - decl = DECL_CHAIN (decl)) - if (TREE_USED (decl) - && TREE_CODE (decl) == PARM_DECL - && !DECL_READ_P (decl) - && DECL_NAME (decl) - && !DECL_ARTIFICIAL (decl) - && !TREE_NO_WARNING (decl)) - warning_at (DECL_SOURCE_LOCATION (decl), - OPT_Wunused_but_set_parameter, - "parameter %qD set but not used", decl); - } - - /* Complain about locally defined typedefs that are not used in this - function. */ - maybe_warn_unused_local_typedefs (); - - /* Store the end of the function, so that we get good line number - info for the epilogue. */ - cfun->function_end_locus = input_location; - - /* Finalize the ELF visibility for the function. */ - c_determine_visibility (fndecl); - - /* For GNU C extern inline functions disregard inline limits. */ - if (DECL_EXTERNAL (fndecl) - && DECL_DECLARED_INLINE_P (fndecl)) - DECL_DISREGARD_INLINE_LIMITS (fndecl) = 1; - - /* Genericize before inlining. Delay genericizing nested functions - until their parent function is genericized. Since finalizing - requires GENERIC, delay that as well. */ - - if (DECL_INITIAL (fndecl) && DECL_INITIAL (fndecl) != error_mark_node - && !undef_nested_function) - { - if (!decl_function_context (fndecl)) - { - invoke_plugin_callbacks (PLUGIN_PRE_GENERICIZE, fndecl); - c_genericize (fndecl); - - /* ??? Objc emits functions after finalizing the compilation unit. - This should be cleaned up later and this conditional removed. */ - if (cgraph_global_info_ready) - { - cgraph_add_new_function (fndecl, false); - return; - } - cgraph_finalize_function (fndecl, false); - } - else - { - /* Register this function with cgraph just far enough to get it - added to our parent's nested function list. Handy, since the - C front end doesn't have such a list. */ - (void) cgraph_get_create_node (fndecl); - } - } - - if (!decl_function_context (fndecl)) - undef_nested_function = false; - - if (cfun->language != NULL) - { - ggc_free (cfun->language); - cfun->language = NULL; - } - - /* We're leaving the context of this function, so zap cfun. - It's still in DECL_STRUCT_FUNCTION, and we'll restore it in - tree_rest_of_compilation. */ - set_cfun (NULL); - current_function_decl = NULL; -} - -/* Check the declarations given in a for-loop for satisfying the C99 - constraints. If exactly one such decl is found, return it. LOC is - the location of the opening parenthesis of the for loop. The last - parameter allows you to control the "for loop initial declarations - are only allowed in C99 mode". Normally, you should pass - flag_isoc99 as that parameter. But in some cases (Objective-C - foreach loop, for example) we want to run the checks in this - function even if not in C99 mode, so we allow the caller to turn - off the error about not being in C99 mode. -*/ - -tree -check_for_loop_decls (location_t loc, bool turn_off_iso_c99_error) -{ - struct c_binding *b; - tree one_decl = NULL_TREE; - int n_decls = 0; - - if (!turn_off_iso_c99_error) - { - static bool hint = true; - /* 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 - allow it. */ - error_at (loc, "%<for%> loop initial declarations " - "are only allowed in C99 mode"); - if (hint) - { - inform (loc, - "use option -std=c99 or -std=gnu99 to compile your code"); - hint = false; - } - return NULL_TREE; - } - /* C99 subclause 6.8.5 paragraph 3: - - [#3] The declaration part of a for statement shall only - declare identifiers for objects having storage class auto or - register. - - It isn't clear whether, in this sentence, "identifiers" binds to - "shall only declare" or to "objects" - that is, whether all identifiers - declared must be identifiers for objects, or whether the restriction - only applies to those that are. (A question on this in comp.std.c - in November 2000 received no answer.) We implement the strictest - interpretation, to avoid creating an extension which later causes - problems. */ - - for (b = current_scope->bindings; b; b = b->prev) - { - tree id = b->id; - tree decl = b->decl; - - if (!id) - continue; - - switch (TREE_CODE (decl)) - { - case VAR_DECL: - { - location_t decl_loc = DECL_SOURCE_LOCATION (decl); - if (TREE_STATIC (decl)) - error_at (decl_loc, - "declaration of static variable %qD in %<for%> loop " - "initial declaration", decl); - else if (DECL_EXTERNAL (decl)) - error_at (decl_loc, - "declaration of %<extern%> variable %qD in %<for%> loop " - "initial declaration", decl); - } - break; - - case RECORD_TYPE: - error_at (loc, - "%<struct %E%> declared in %<for%> loop initial " - "declaration", id); - break; - case UNION_TYPE: - error_at (loc, - "%<union %E%> declared in %<for%> loop initial declaration", - id); - break; - case ENUMERAL_TYPE: - error_at (loc, "%<enum %E%> declared in %<for%> loop " - "initial declaration", id); - break; - default: - error_at (loc, "declaration of non-variable " - "%qD in %<for%> loop initial declaration", decl); - } - - n_decls++; - one_decl = decl; - } - - return n_decls == 1 ? one_decl : NULL_TREE; -} - -/* Save and reinitialize the variables - used during compilation of a C function. */ - -void -c_push_function_context (void) -{ - struct language_function *p = cfun->language; - /* cfun->language might have been already allocated by the use of - -Wunused-local-typedefs. In that case, just re-use it. */ - if (p == NULL) - cfun->language = p = ggc_alloc_cleared_language_function (); - - p->base.x_stmt_tree = c_stmt_tree; - c_stmt_tree.x_cur_stmt_list = vec_safe_copy (c_stmt_tree.x_cur_stmt_list); - p->x_break_label = c_break_label; - p->x_cont_label = c_cont_label; - p->x_switch_stack = c_switch_stack; - p->arg_info = current_function_arg_info; - p->returns_value = current_function_returns_value; - p->returns_null = current_function_returns_null; - p->returns_abnormally = current_function_returns_abnormally; - p->warn_about_return_type = warn_about_return_type; - - push_function_context (); -} - -/* Restore the variables used during compilation of a C function. */ - -void -c_pop_function_context (void) -{ - struct language_function *p; - - pop_function_context (); - p = cfun->language; - - /* When -Wunused-local-typedefs is in effect, cfun->languages is - used to store data throughout the life time of the current cfun, - So don't deallocate it. */ - if (!warn_unused_local_typedefs) - cfun->language = NULL; - - if (DECL_STRUCT_FUNCTION (current_function_decl) == 0 - && DECL_SAVED_TREE (current_function_decl) == NULL_TREE) - { - /* Stop pointing to the local nodes about to be freed. */ - /* But DECL_INITIAL must remain nonzero so we know this - was an actual function definition. */ - DECL_INITIAL (current_function_decl) = error_mark_node; - DECL_ARGUMENTS (current_function_decl) = 0; - } - - c_stmt_tree = p->base.x_stmt_tree; - p->base.x_stmt_tree.x_cur_stmt_list = NULL; - c_break_label = p->x_break_label; - c_cont_label = p->x_cont_label; - c_switch_stack = p->x_switch_stack; - current_function_arg_info = p->arg_info; - current_function_returns_value = p->returns_value; - current_function_returns_null = p->returns_null; - current_function_returns_abnormally = p->returns_abnormally; - warn_about_return_type = p->warn_about_return_type; -} - -/* The functions below are required for functionality of doing - function at once processing in the C front end. Currently these - functions are not called from anywhere in the C front end, but as - these changes continue, that will change. */ - -/* Returns the stmt_tree (if any) to which statements are currently - being added. If there is no active statement-tree, NULL is - returned. */ - -stmt_tree -current_stmt_tree (void) -{ - return &c_stmt_tree; -} - -/* Return the global value of T as a symbol. */ - -tree -identifier_global_value (tree t) -{ - struct c_binding *b; - - for (b = I_SYMBOL_BINDING (t); b; b = b->shadowed) - if (B_IN_FILE_SCOPE (b) || B_IN_EXTERNAL_SCOPE (b)) - return b->decl; - - return 0; -} - -/* In C, the only C-linkage public declaration is at file scope. */ - -tree -c_linkage_bindings (tree name) -{ - return identifier_global_value (name); -} - -/* 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. */ - -void -record_builtin_type (enum rid rid_index, const char *name, tree type) -{ - tree id, decl; - if (name == 0) - id = ridpointers[(int) rid_index]; - else - id = get_identifier (name); - decl = build_decl (UNKNOWN_LOCATION, TYPE_DECL, id, type); - pushdecl (decl); - if (debug_hooks->type_decl) - debug_hooks->type_decl (decl, false); -} - -/* Build the void_list_node (void_type_node having been created). */ -tree -build_void_list_node (void) -{ - tree t = build_tree_list (NULL_TREE, void_type_node); - return t; -} - -/* Return a c_parm structure with the given SPECS, ATTRS and DECLARATOR. */ - -struct c_parm * -build_c_parm (struct c_declspecs *specs, tree attrs, - struct c_declarator *declarator) -{ - struct c_parm *ret = XOBNEW (&parser_obstack, struct c_parm); - ret->specs = specs; - ret->attrs = attrs; - ret->declarator = declarator; - return ret; -} - -/* Return a declarator with nested attributes. TARGET is the inner - declarator to which these attributes apply. ATTRS are the - attributes. */ - -struct c_declarator * -build_attrs_declarator (tree attrs, struct c_declarator *target) -{ - struct c_declarator *ret = XOBNEW (&parser_obstack, struct c_declarator); - ret->kind = cdk_attrs; - ret->declarator = target; - ret->u.attrs = attrs; - return ret; -} - -/* Return a declarator for a function with arguments specified by ARGS - and return type specified by TARGET. */ - -struct c_declarator * -build_function_declarator (struct c_arg_info *args, - struct c_declarator *target) -{ - struct c_declarator *ret = XOBNEW (&parser_obstack, struct c_declarator); - ret->kind = cdk_function; - ret->declarator = target; - ret->u.arg_info = args; - return ret; -} - -/* Return a declarator for the identifier IDENT (which may be - NULL_TREE for an abstract declarator). */ - -struct c_declarator * -build_id_declarator (tree ident) -{ - struct c_declarator *ret = XOBNEW (&parser_obstack, struct c_declarator); - ret->kind = cdk_id; - ret->declarator = 0; - ret->u.id = ident; - /* Default value - may get reset to a more precise location. */ - ret->id_loc = input_location; - return ret; -} - -/* Return something to represent absolute declarators containing a *. - TARGET is the absolute declarator that the * contains. - TYPE_QUALS_ATTRS is a structure for type qualifiers and attributes - to apply to the pointer type. */ - -struct c_declarator * -make_pointer_declarator (struct c_declspecs *type_quals_attrs, - struct c_declarator *target) -{ - tree attrs; - int quals = 0; - struct c_declarator *itarget = target; - struct c_declarator *ret = XOBNEW (&parser_obstack, struct c_declarator); - if (type_quals_attrs) - { - attrs = type_quals_attrs->attrs; - quals = quals_from_declspecs (type_quals_attrs); - if (attrs != NULL_TREE) - itarget = build_attrs_declarator (attrs, target); - } - ret->kind = cdk_pointer; - ret->declarator = itarget; - ret->u.pointer_quals = quals; - return ret; -} - -/* Return a pointer to a structure for an empty list of declaration - specifiers. */ - -struct c_declspecs * -build_null_declspecs (void) -{ - struct c_declspecs *ret = XOBNEW (&parser_obstack, struct c_declspecs); - memset (&ret->locations, 0, cdw_number_of_elements); - ret->type = 0; - ret->expr = 0; - ret->decl_attr = 0; - ret->attrs = 0; - ret->align_log = -1; - ret->typespec_word = cts_none; - ret->storage_class = csc_none; - ret->expr_const_operands = true; - ret->declspecs_seen_p = false; - ret->typespec_kind = ctsk_none; - ret->non_sc_seen_p = false; - ret->typedef_p = false; - ret->explicit_signed_p = false; - ret->deprecated_p = false; - ret->default_int_p = false; - ret->long_p = false; - ret->long_long_p = false; - ret->short_p = false; - ret->signed_p = false; - ret->unsigned_p = false; - ret->complex_p = false; - ret->inline_p = false; - ret->noreturn_p = false; - ret->thread_p = false; - ret->const_p = false; - ret->volatile_p = false; - ret->restrict_p = false; - ret->saturating_p = false; - ret->alignas_p = false; - ret->address_space = ADDR_SPACE_GENERIC; - return ret; -} - -/* Add the address space ADDRSPACE to the declaration specifiers - SPECS, returning SPECS. */ - -struct c_declspecs * -declspecs_add_addrspace (source_location location, - struct c_declspecs *specs, addr_space_t as) -{ - specs->non_sc_seen_p = true; - specs->declspecs_seen_p = true; - - if (!ADDR_SPACE_GENERIC_P (specs->address_space) - && specs->address_space != as) - error ("incompatible address space qualifiers %qs and %qs", - c_addr_space_name (as), - c_addr_space_name (specs->address_space)); - else - { - specs->address_space = as; - specs->locations[cdw_address_space] = location; - } - return specs; -} - -/* Add the type qualifier QUAL to the declaration specifiers SPECS, - returning SPECS. */ - -struct c_declspecs * -declspecs_add_qual (source_location loc, - struct c_declspecs *specs, tree qual) -{ - enum rid i; - bool dupe = false; - specs->non_sc_seen_p = true; - specs->declspecs_seen_p = true; - gcc_assert (TREE_CODE (qual) == IDENTIFIER_NODE - && C_IS_RESERVED_WORD (qual)); - i = C_RID_CODE (qual); - switch (i) - { - case RID_CONST: - dupe = specs->const_p; - specs->const_p = true; - specs->locations[cdw_const] = loc; - break; - case RID_VOLATILE: - dupe = specs->volatile_p; - specs->volatile_p = true; - specs->locations[cdw_volatile] = loc; - break; - case RID_RESTRICT: - dupe = specs->restrict_p; - specs->restrict_p = true; - specs->locations[cdw_restrict] = loc; - break; - default: - gcc_unreachable (); - } - if (dupe && !flag_isoc99) - pedwarn (loc, OPT_Wpedantic, "duplicate %qE", qual); - return specs; -} - -/* Add the type specifier TYPE to the declaration specifiers SPECS, - returning SPECS. */ - -struct c_declspecs * -declspecs_add_type (location_t loc, struct c_declspecs *specs, - struct c_typespec spec) -{ - tree type = spec.spec; - specs->non_sc_seen_p = true; - specs->declspecs_seen_p = true; - specs->typespec_kind = spec.kind; - if (TREE_DEPRECATED (type)) - specs->deprecated_p = true; - - /* Handle type specifier keywords. */ - if (TREE_CODE (type) == IDENTIFIER_NODE - && C_IS_RESERVED_WORD (type) - && C_RID_CODE (type) != RID_CXX_COMPAT_WARN) - { - enum rid i = C_RID_CODE (type); - if (specs->type) - { - error_at (loc, "two or more data types in declaration specifiers"); - return specs; - } - if ((int) i <= (int) RID_LAST_MODIFIER) - { - /* "long", "short", "signed", "unsigned", "_Complex" or "_Sat". */ - bool dupe = false; - switch (i) - { - case RID_LONG: - if (specs->long_long_p) - { - error_at (loc, "%<long long long%> is too long for GCC"); - break; - } - if (specs->long_p) - { - if (specs->typespec_word == cts_double) - { - error_at (loc, - ("both %<long long%> and %<double%> in " - "declaration specifiers")); - break; - } - pedwarn_c90 (loc, OPT_Wlong_long, - "ISO C90 does not support %<long long%>"); - specs->long_long_p = 1; - specs->locations[cdw_long_long] = loc; - break; - } - if (specs->short_p) - error_at (loc, - ("both %<long%> and %<short%> in " - "declaration specifiers")); - else if (specs->typespec_word == cts_void) - error_at (loc, - ("both %<long%> and %<void%> in " - "declaration specifiers")); - else if (specs->typespec_word == cts_int128) - error_at (loc, - ("both %<long%> and %<__int128%> in " - "declaration specifiers")); - else if (specs->typespec_word == cts_bool) - error_at (loc, - ("both %<long%> and %<_Bool%> in " - "declaration specifiers")); - else if (specs->typespec_word == cts_char) - error_at (loc, - ("both %<long%> and %<char%> in " - "declaration specifiers")); - else if (specs->typespec_word == cts_float) - error_at (loc, - ("both %<long%> and %<float%> in " - "declaration specifiers")); - else if (specs->typespec_word == cts_dfloat32) - error_at (loc, - ("both %<long%> and %<_Decimal32%> in " - "declaration specifiers")); - else if (specs->typespec_word == cts_dfloat64) - error_at (loc, - ("both %<long%> and %<_Decimal64%> in " - "declaration specifiers")); - else if (specs->typespec_word == cts_dfloat128) - error_at (loc, - ("both %<long%> and %<_Decimal128%> in " - "declaration specifiers")); - else - { - specs->long_p = true; - specs->locations[cdw_long] = loc; - } - break; - case RID_SHORT: - dupe = specs->short_p; - if (specs->long_p) - error_at (loc, - ("both %<long%> and %<short%> in " - "declaration specifiers")); - else if (specs->typespec_word == cts_void) - error_at (loc, - ("both %<short%> and %<void%> in " - "declaration specifiers")); - else if (specs->typespec_word == cts_int128) - error_at (loc, - ("both %<short%> and %<__int128%> in " - "declaration specifiers")); - else if (specs->typespec_word == cts_bool) - error_at (loc, - ("both %<short%> and %<_Bool%> in " - "declaration specifiers")); - else if (specs->typespec_word == cts_char) - error_at (loc, - ("both %<short%> and %<char%> in " - "declaration specifiers")); - else if (specs->typespec_word == cts_float) - error_at (loc, - ("both %<short%> and %<float%> in " - "declaration specifiers")); - else if (specs->typespec_word == cts_double) - error_at (loc, - ("both %<short%> and %<double%> in " - "declaration specifiers")); - else if (specs->typespec_word == cts_dfloat32) - error_at (loc, - ("both %<short%> and %<_Decimal32%> in " - "declaration specifiers")); - else if (specs->typespec_word == cts_dfloat64) - error_at (loc, - ("both %<short%> and %<_Decimal64%> in " - "declaration specifiers")); - else if (specs->typespec_word == cts_dfloat128) - error_at (loc, - ("both %<short%> and %<_Decimal128%> in " - "declaration specifiers")); - else - { - specs->short_p = true; - specs->locations[cdw_short] = loc; - } - break; - case RID_SIGNED: - dupe = specs->signed_p; - if (specs->unsigned_p) - error_at (loc, - ("both %<signed%> and %<unsigned%> in " - "declaration specifiers")); - else if (specs->typespec_word == cts_void) - error_at (loc, - ("both %<signed%> and %<void%> in " - "declaration specifiers")); - else if (specs->typespec_word == cts_bool) - error_at (loc, - ("both %<signed%> and %<_Bool%> in " - "declaration specifiers")); - else if (specs->typespec_word == cts_float) - error_at (loc, - ("both %<signed%> and %<float%> in " - "declaration specifiers")); - else if (specs->typespec_word == cts_double) - error_at (loc, - ("both %<signed%> and %<double%> in " - "declaration specifiers")); - else if (specs->typespec_word == cts_dfloat32) - error_at (loc, - ("both %<signed%> and %<_Decimal32%> in " - "declaration specifiers")); - else if (specs->typespec_word == cts_dfloat64) - error_at (loc, - ("both %<signed%> and %<_Decimal64%> in " - "declaration specifiers")); - else if (specs->typespec_word == cts_dfloat128) - error_at (loc, - ("both %<signed%> and %<_Decimal128%> in " - "declaration specifiers")); - else - { - specs->signed_p = true; - specs->locations[cdw_signed] = loc; - } - break; - case RID_UNSIGNED: - dupe = specs->unsigned_p; - if (specs->signed_p) - error_at (loc, - ("both %<signed%> and %<unsigned%> in " - "declaration specifiers")); - else if (specs->typespec_word == cts_void) - error_at (loc, - ("both %<unsigned%> and %<void%> in " - "declaration specifiers")); - else if (specs->typespec_word == cts_bool) - error_at (loc, - ("both %<unsigned%> and %<_Bool%> in " - "declaration specifiers")); - else if (specs->typespec_word == cts_float) - error_at (loc, - ("both %<unsigned%> and %<float%> in " - "declaration specifiers")); - else if (specs->typespec_word == cts_double) - error_at (loc, - ("both %<unsigned%> and %<double%> in " - "declaration specifiers")); - else if (specs->typespec_word == cts_dfloat32) - error_at (loc, - ("both %<unsigned%> and %<_Decimal32%> in " - "declaration specifiers")); - else if (specs->typespec_word == cts_dfloat64) - error_at (loc, - ("both %<unsigned%> and %<_Decimal64%> in " - "declaration specifiers")); - else if (specs->typespec_word == cts_dfloat128) - error_at (loc, - ("both %<unsigned%> and %<_Decimal128%> in " - "declaration specifiers")); - else - { - specs->unsigned_p = true; - specs->locations[cdw_unsigned] = loc; - } - break; - case RID_COMPLEX: - dupe = specs->complex_p; - if (!flag_isoc99 && !in_system_header_at (loc)) - pedwarn (loc, OPT_Wpedantic, - "ISO C90 does not support complex types"); - if (specs->typespec_word == cts_void) - error_at (loc, - ("both %<complex%> and %<void%> in " - "declaration specifiers")); - else if (specs->typespec_word == cts_bool) - error_at (loc, - ("both %<complex%> and %<_Bool%> in " - "declaration specifiers")); - else if (specs->typespec_word == cts_dfloat32) - error_at (loc, - ("both %<complex%> and %<_Decimal32%> in " - "declaration specifiers")); - else if (specs->typespec_word == cts_dfloat64) - error_at (loc, - ("both %<complex%> and %<_Decimal64%> in " - "declaration specifiers")); - else if (specs->typespec_word == cts_dfloat128) - error_at (loc, - ("both %<complex%> and %<_Decimal128%> in " - "declaration specifiers")); - else if (specs->typespec_word == cts_fract) - error_at (loc, - ("both %<complex%> and %<_Fract%> in " - "declaration specifiers")); - else if (specs->typespec_word == cts_accum) - error_at (loc, - ("both %<complex%> and %<_Accum%> in " - "declaration specifiers")); - else if (specs->saturating_p) - error_at (loc, - ("both %<complex%> and %<_Sat%> in " - "declaration specifiers")); - else - { - specs->complex_p = true; - specs->locations[cdw_complex] = loc; - } - break; - case RID_SAT: - dupe = specs->saturating_p; - pedwarn (loc, OPT_Wpedantic, - "ISO C does not support saturating types"); - if (specs->typespec_word == cts_int128) - { - error_at (loc, - ("both %<_Sat%> and %<__int128%> in " - "declaration specifiers")); - } - else if (specs->typespec_word == cts_void) - error_at (loc, - ("both %<_Sat%> and %<void%> in " - "declaration specifiers")); - else if (specs->typespec_word == cts_bool) - error_at (loc, - ("both %<_Sat%> and %<_Bool%> in " - "declaration specifiers")); - else if (specs->typespec_word == cts_char) - error_at (loc, - ("both %<_Sat%> and %<char%> in " - "declaration specifiers")); - else if (specs->typespec_word == cts_int) - error_at (loc, - ("both %<_Sat%> and %<int%> in " - "declaration specifiers")); - else if (specs->typespec_word == cts_float) - error_at (loc, - ("both %<_Sat%> and %<float%> in " - "declaration specifiers")); - else if (specs->typespec_word == cts_double) - error_at (loc, - ("both %<_Sat%> and %<double%> in " - "declaration specifiers")); - else if (specs->typespec_word == cts_dfloat32) - error_at (loc, - ("both %<_Sat%> and %<_Decimal32%> in " - "declaration specifiers")); - else if (specs->typespec_word == cts_dfloat64) - error_at (loc, - ("both %<_Sat%> and %<_Decimal64%> in " - "declaration specifiers")); - else if (specs->typespec_word == cts_dfloat128) - error_at (loc, - ("both %<_Sat%> and %<_Decimal128%> in " - "declaration specifiers")); - else if (specs->complex_p) - error_at (loc, - ("both %<_Sat%> and %<complex%> in " - "declaration specifiers")); - else - { - specs->saturating_p = true; - specs->locations[cdw_saturating] = loc; - } - break; - default: - gcc_unreachable (); - } - - if (dupe) - error_at (loc, "duplicate %qE", type); - - return specs; - } - else - { - /* "void", "_Bool", "char", "int", "float", "double", "_Decimal32", - "__int128", "_Decimal64", "_Decimal128", "_Fract" or "_Accum". */ - if (specs->typespec_word != cts_none) - { - error_at (loc, - "two or more data types in declaration specifiers"); - return specs; - } - switch (i) - { - case RID_INT128: - if (int128_integer_type_node == NULL_TREE) - { - error_at (loc, "%<__int128%> is not supported for this target"); - return specs; - } - if (!in_system_header) - pedwarn (loc, OPT_Wpedantic, - "ISO C does not support %<__int128%> type"); - - if (specs->long_p) - error_at (loc, - ("both %<__int128%> and %<long%> in " - "declaration specifiers")); - else if (specs->saturating_p) - error_at (loc, - ("both %<_Sat%> and %<__int128%> in " - "declaration specifiers")); - else if (specs->short_p) - error_at (loc, - ("both %<__int128%> and %<short%> in " - "declaration specifiers")); - else - { - specs->typespec_word = cts_int128; - specs->locations[cdw_typespec] = loc; - } - return specs; - case RID_VOID: - if (specs->long_p) - error_at (loc, - ("both %<long%> and %<void%> in " - "declaration specifiers")); - else if (specs->short_p) - error_at (loc, - ("both %<short%> and %<void%> in " - "declaration specifiers")); - else if (specs->signed_p) - error_at (loc, - ("both %<signed%> and %<void%> in " - "declaration specifiers")); - else if (specs->unsigned_p) - error_at (loc, - ("both %<unsigned%> and %<void%> in " - "declaration specifiers")); - else if (specs->complex_p) - error_at (loc, - ("both %<complex%> and %<void%> in " - "declaration specifiers")); - else if (specs->saturating_p) - error_at (loc, - ("both %<_Sat%> and %<void%> in " - "declaration specifiers")); - else - { - specs->typespec_word = cts_void; - specs->locations[cdw_typespec] = loc; - } - return specs; - case RID_BOOL: - if (specs->long_p) - error_at (loc, - ("both %<long%> and %<_Bool%> in " - "declaration specifiers")); - else if (specs->short_p) - error_at (loc, - ("both %<short%> and %<_Bool%> in " - "declaration specifiers")); - else if (specs->signed_p) - error_at (loc, - ("both %<signed%> and %<_Bool%> in " - "declaration specifiers")); - else if (specs->unsigned_p) - error_at (loc, - ("both %<unsigned%> and %<_Bool%> in " - "declaration specifiers")); - else if (specs->complex_p) - error_at (loc, - ("both %<complex%> and %<_Bool%> in " - "declaration specifiers")); - else if (specs->saturating_p) - error_at (loc, - ("both %<_Sat%> and %<_Bool%> in " - "declaration specifiers")); - else - { - specs->typespec_word = cts_bool; - specs->locations[cdw_typespec] = loc; - } - return specs; - case RID_CHAR: - if (specs->long_p) - error_at (loc, - ("both %<long%> and %<char%> in " - "declaration specifiers")); - else if (specs->short_p) - error_at (loc, - ("both %<short%> and %<char%> in " - "declaration specifiers")); - else if (specs->saturating_p) - error_at (loc, - ("both %<_Sat%> and %<char%> in " - "declaration specifiers")); - else - { - specs->typespec_word = cts_char; - specs->locations[cdw_typespec] = loc; - } - return specs; - case RID_INT: - if (specs->saturating_p) - error_at (loc, - ("both %<_Sat%> and %<int%> in " - "declaration specifiers")); - else - { - specs->typespec_word = cts_int; - specs->locations[cdw_typespec] = loc; - } - return specs; - case RID_FLOAT: - if (specs->long_p) - error_at (loc, - ("both %<long%> and %<float%> in " - "declaration specifiers")); - else if (specs->short_p) - error_at (loc, - ("both %<short%> and %<float%> in " - "declaration specifiers")); - else if (specs->signed_p) - error_at (loc, - ("both %<signed%> and %<float%> in " - "declaration specifiers")); - else if (specs->unsigned_p) - error_at (loc, - ("both %<unsigned%> and %<float%> in " - "declaration specifiers")); - else if (specs->saturating_p) - error_at (loc, - ("both %<_Sat%> and %<float%> in " - "declaration specifiers")); - else - { - specs->typespec_word = cts_float; - specs->locations[cdw_typespec] = loc; - } - return specs; - case RID_DOUBLE: - if (specs->long_long_p) - error_at (loc, - ("both %<long long%> and %<double%> in " - "declaration specifiers")); - else if (specs->short_p) - error_at (loc, - ("both %<short%> and %<double%> in " - "declaration specifiers")); - else if (specs->signed_p) - error_at (loc, - ("both %<signed%> and %<double%> in " - "declaration specifiers")); - else if (specs->unsigned_p) - error_at (loc, - ("both %<unsigned%> and %<double%> in " - "declaration specifiers")); - else if (specs->saturating_p) - error_at (loc, - ("both %<_Sat%> and %<double%> in " - "declaration specifiers")); - else - { - specs->typespec_word = cts_double; - specs->locations[cdw_typespec] = loc; - } - return specs; - case RID_DFLOAT32: - case RID_DFLOAT64: - case RID_DFLOAT128: - { - const char *str; - if (i == RID_DFLOAT32) - str = "_Decimal32"; - else if (i == RID_DFLOAT64) - str = "_Decimal64"; - else - str = "_Decimal128"; - if (specs->long_long_p) - error_at (loc, - ("both %<long long%> and %<%s%> in " - "declaration specifiers"), - str); - if (specs->long_p) - error_at (loc, - ("both %<long%> and %<%s%> in " - "declaration specifiers"), - str); - else if (specs->short_p) - error_at (loc, - ("both %<short%> and %<%s%> in " - "declaration specifiers"), - str); - else if (specs->signed_p) - error_at (loc, - ("both %<signed%> and %<%s%> in " - "declaration specifiers"), - str); - else if (specs->unsigned_p) - error_at (loc, - ("both %<unsigned%> and %<%s%> in " - "declaration specifiers"), - str); - else if (specs->complex_p) - error_at (loc, - ("both %<complex%> and %<%s%> in " - "declaration specifiers"), - str); - else if (specs->saturating_p) - error_at (loc, - ("both %<_Sat%> and %<%s%> in " - "declaration specifiers"), - str); - else if (i == RID_DFLOAT32) - specs->typespec_word = cts_dfloat32; - else if (i == RID_DFLOAT64) - specs->typespec_word = cts_dfloat64; - else - specs->typespec_word = cts_dfloat128; - specs->locations[cdw_typespec] = loc; - } - if (!targetm.decimal_float_supported_p ()) - error_at (loc, - ("decimal floating point not supported " - "for this target")); - pedwarn (loc, OPT_Wpedantic, - "ISO C does not support decimal floating point"); - return specs; - case RID_FRACT: - case RID_ACCUM: - { - const char *str; - if (i == RID_FRACT) - str = "_Fract"; - else - str = "_Accum"; - if (specs->complex_p) - error_at (loc, - ("both %<complex%> and %<%s%> in " - "declaration specifiers"), - str); - else if (i == RID_FRACT) - specs->typespec_word = cts_fract; - else - specs->typespec_word = cts_accum; - specs->locations[cdw_typespec] = loc; - } - if (!targetm.fixed_point_supported_p ()) - error_at (loc, - "fixed-point types not supported for this target"); - pedwarn (loc, OPT_Wpedantic, - "ISO C does not support fixed-point types"); - return specs; - default: - /* ObjC reserved word "id", handled below. */ - break; - } - } - } - - /* Now we have a typedef (a TYPE_DECL node), an identifier (some - form of ObjC type, cases such as "int" and "long" being handled - above), a TYPE (struct, union, enum and typeof specifiers) or an - ERROR_MARK. In none of these cases may there have previously - been any type specifiers. */ - if (specs->type || specs->typespec_word != cts_none - || specs->long_p || specs->short_p || specs->signed_p - || specs->unsigned_p || specs->complex_p) - error_at (loc, "two or more data types in declaration specifiers"); - else if (TREE_CODE (type) == TYPE_DECL) - { - if (TREE_TYPE (type) == error_mark_node) - ; /* Allow the type to default to int to avoid cascading errors. */ - else - { - specs->type = TREE_TYPE (type); - specs->decl_attr = DECL_ATTRIBUTES (type); - specs->typedef_p = true; - specs->explicit_signed_p = C_TYPEDEF_EXPLICITLY_SIGNED (type); - specs->locations[cdw_typedef] = loc; - - /* If this typedef name is defined in a struct, then a C++ - lookup would return a different value. */ - if (warn_cxx_compat - && I_SYMBOL_BINDING (DECL_NAME (type))->in_struct) - warning_at (loc, OPT_Wc___compat, - "C++ lookup of %qD would return a field, not a type", - type); - - /* If we are parsing a struct, record that a struct field - used a typedef. */ - if (warn_cxx_compat && struct_parse_info != NULL) - struct_parse_info->typedefs_seen.safe_push (type); - } - } - else if (TREE_CODE (type) == IDENTIFIER_NODE) - { - tree t = lookup_name (type); - if (!t || TREE_CODE (t) != TYPE_DECL) - error_at (loc, "%qE fails to be a typedef or built in type", type); - else if (TREE_TYPE (t) == error_mark_node) - ; - else - { - specs->type = TREE_TYPE (t); - specs->locations[cdw_typespec] = loc; - } - } - else - { - if (TREE_CODE (type) != ERROR_MARK && spec.kind == ctsk_typeof) - { - specs->typedef_p = true; - specs->locations[cdw_typedef] = loc; - if (spec.expr) - { - if (specs->expr) - specs->expr = build2 (COMPOUND_EXPR, TREE_TYPE (spec.expr), - specs->expr, spec.expr); - else - specs->expr = spec.expr; - specs->expr_const_operands &= spec.expr_const_operands; - } - } - specs->type = type; - } - - return specs; -} - -/* Add the storage class specifier or function specifier SCSPEC to the - declaration specifiers SPECS, returning SPECS. */ - -struct c_declspecs * -declspecs_add_scspec (source_location loc, - struct c_declspecs *specs, - tree scspec) -{ - enum rid i; - enum c_storage_class n = csc_none; - bool dupe = false; - specs->declspecs_seen_p = true; - gcc_assert (TREE_CODE (scspec) == IDENTIFIER_NODE - && C_IS_RESERVED_WORD (scspec)); - i = C_RID_CODE (scspec); - if (specs->non_sc_seen_p) - warning (OPT_Wold_style_declaration, - "%qE is not at beginning of declaration", scspec); - switch (i) - { - case RID_INLINE: - /* C99 permits duplicate inline. Although of doubtful utility, - it seems simplest to permit it in gnu89 mode as well, as - there is also little utility in maintaining this as a - difference between gnu89 and C99 inline. */ - dupe = false; - specs->inline_p = true; - specs->locations[cdw_inline] = loc; - break; - case RID_NORETURN: - /* Duplicate _Noreturn is permitted. */ - dupe = false; - specs->noreturn_p = true; - specs->locations[cdw_noreturn] = loc; - break; - case RID_THREAD: - dupe = specs->thread_p; - if (specs->storage_class == csc_auto) - error ("%<__thread%> used with %<auto%>"); - else if (specs->storage_class == csc_register) - error ("%<__thread%> used with %<register%>"); - else if (specs->storage_class == csc_typedef) - error ("%<__thread%> used with %<typedef%>"); - else - { - specs->thread_p = true; - specs->locations[cdw_thread] = loc; - } - break; - case RID_AUTO: - n = csc_auto; - break; - case RID_EXTERN: - n = csc_extern; - /* Diagnose "__thread extern". */ - if (specs->thread_p) - error ("%<__thread%> before %<extern%>"); - break; - case RID_REGISTER: - n = csc_register; - break; - case RID_STATIC: - n = csc_static; - /* Diagnose "__thread static". */ - if (specs->thread_p) - error ("%<__thread%> before %<static%>"); - break; - case RID_TYPEDEF: - n = csc_typedef; - break; - default: - gcc_unreachable (); - } - if (n != csc_none && n == specs->storage_class) - dupe = true; - if (dupe) - error ("duplicate %qE", scspec); - if (n != csc_none) - { - if (specs->storage_class != csc_none && n != specs->storage_class) - { - error ("multiple storage classes in declaration specifiers"); - } - else - { - specs->storage_class = n; - specs->locations[cdw_storage_class] = loc; - if (n != csc_extern && n != csc_static && specs->thread_p) - { - error ("%<__thread%> used with %qE", scspec); - specs->thread_p = false; - } - } - } - return specs; -} - -/* Add the attributes ATTRS to the declaration specifiers SPECS, - returning SPECS. */ - -struct c_declspecs * -declspecs_add_attrs (source_location loc, struct c_declspecs *specs, tree attrs) -{ - specs->attrs = chainon (attrs, specs->attrs); - specs->locations[cdw_attributes] = loc; - specs->declspecs_seen_p = true; - return specs; -} - -/* Add an _Alignas specifier (expression ALIGN, or type whose - alignment is ALIGN) to the declaration specifiers SPECS, returning - SPECS. */ -struct c_declspecs * -declspecs_add_alignas (source_location loc, - struct c_declspecs *specs, tree align) -{ - int align_log; - specs->alignas_p = true; - specs->locations[cdw_alignas] = loc; - if (align == error_mark_node) - return specs; - align_log = check_user_alignment (align, true); - if (align_log > specs->align_log) - specs->align_log = align_log; - return specs; -} - -/* Combine "long", "short", "signed", "unsigned" and "_Complex" type - specifiers with any other type specifier to determine the resulting - 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 - double". */ - -struct c_declspecs * -finish_declspecs (struct c_declspecs *specs) -{ - /* If a type was specified as a whole, we have no modifiers and are - done. */ - if (specs->type != NULL_TREE) - { - gcc_assert (!specs->long_p && !specs->long_long_p && !specs->short_p - && !specs->signed_p && !specs->unsigned_p - && !specs->complex_p); - - /* Set a dummy type. */ - if (TREE_CODE (specs->type) == ERROR_MARK) - specs->type = integer_type_node; - return specs; - } - - /* If none of "void", "_Bool", "char", "int", "float" or "double" - has been specified, treat it as "int" unless "_Complex" is - present and there are no other specifiers. If we just have - "_Complex", it is equivalent to "_Complex double", but e.g. - "_Complex short" is equivalent to "_Complex short int". */ - if (specs->typespec_word == cts_none) - { - if (specs->saturating_p) - { - error_at (specs->locations[cdw_saturating], - "%<_Sat%> is used without %<_Fract%> or %<_Accum%>"); - if (!targetm.fixed_point_supported_p ()) - error_at (specs->locations[cdw_saturating], - "fixed-point types not supported for this target"); - specs->typespec_word = cts_fract; - } - else if (specs->long_p || specs->short_p - || specs->signed_p || specs->unsigned_p) - { - specs->typespec_word = cts_int; - } - else if (specs->complex_p) - { - specs->typespec_word = cts_double; - pedwarn (specs->locations[cdw_complex], OPT_Wpedantic, - "ISO C does not support plain %<complex%> meaning " - "%<double complex%>"); - } - else - { - specs->typespec_word = cts_int; - specs->default_int_p = true; - /* We don't diagnose this here because grokdeclarator will - give more specific diagnostics according to whether it is - a function definition. */ - } - } - - /* If "signed" was specified, record this to distinguish "int" and - "signed int" in the case of a bit-field with - -funsigned-bitfields. */ - specs->explicit_signed_p = specs->signed_p; - - /* Now compute the actual type. */ - switch (specs->typespec_word) - { - case cts_void: - gcc_assert (!specs->long_p && !specs->short_p - && !specs->signed_p && !specs->unsigned_p - && !specs->complex_p); - specs->type = void_type_node; - break; - case cts_bool: - gcc_assert (!specs->long_p && !specs->short_p - && !specs->signed_p && !specs->unsigned_p - && !specs->complex_p); - specs->type = boolean_type_node; - break; - case cts_char: - gcc_assert (!specs->long_p && !specs->short_p); - gcc_assert (!(specs->signed_p && specs->unsigned_p)); - if (specs->signed_p) - specs->type = signed_char_type_node; - else if (specs->unsigned_p) - specs->type = unsigned_char_type_node; - else - specs->type = char_type_node; - if (specs->complex_p) - { - pedwarn (specs->locations[cdw_complex], OPT_Wpedantic, - "ISO C does not support complex integer types"); - specs->type = build_complex_type (specs->type); - } - break; - case cts_int128: - gcc_assert (!specs->long_p && !specs->short_p && !specs->long_long_p); - gcc_assert (!(specs->signed_p && specs->unsigned_p)); - specs->type = (specs->unsigned_p - ? int128_unsigned_type_node - : int128_integer_type_node); - if (specs->complex_p) - { - pedwarn (specs->locations[cdw_complex], OPT_Wpedantic, - "ISO C does not support complex integer types"); - specs->type = build_complex_type (specs->type); - } - break; - case cts_int: - gcc_assert (!(specs->long_p && specs->short_p)); - gcc_assert (!(specs->signed_p && specs->unsigned_p)); - if (specs->long_long_p) - specs->type = (specs->unsigned_p - ? long_long_unsigned_type_node - : long_long_integer_type_node); - else if (specs->long_p) - specs->type = (specs->unsigned_p - ? long_unsigned_type_node - : long_integer_type_node); - else if (specs->short_p) - specs->type = (specs->unsigned_p - ? short_unsigned_type_node - : short_integer_type_node); - else - specs->type = (specs->unsigned_p - ? unsigned_type_node - : integer_type_node); - if (specs->complex_p) - { - pedwarn (specs->locations[cdw_complex], OPT_Wpedantic, - "ISO C does not support complex integer types"); - specs->type = build_complex_type (specs->type); - } - break; - case cts_float: - gcc_assert (!specs->long_p && !specs->short_p - && !specs->signed_p && !specs->unsigned_p); - specs->type = (specs->complex_p - ? complex_float_type_node - : float_type_node); - break; - case cts_double: - gcc_assert (!specs->long_long_p && !specs->short_p - && !specs->signed_p && !specs->unsigned_p); - if (specs->long_p) - { - specs->type = (specs->complex_p - ? complex_long_double_type_node - : long_double_type_node); - } - else - { - specs->type = (specs->complex_p - ? complex_double_type_node - : double_type_node); - } - break; - case cts_dfloat32: - case cts_dfloat64: - case cts_dfloat128: - gcc_assert (!specs->long_p && !specs->long_long_p && !specs->short_p - && !specs->signed_p && !specs->unsigned_p && !specs->complex_p); - if (specs->typespec_word == cts_dfloat32) - specs->type = dfloat32_type_node; - else if (specs->typespec_word == cts_dfloat64) - specs->type = dfloat64_type_node; - else - specs->type = dfloat128_type_node; - break; - case cts_fract: - gcc_assert (!specs->complex_p); - if (!targetm.fixed_point_supported_p ()) - specs->type = integer_type_node; - else if (specs->saturating_p) - { - if (specs->long_long_p) - specs->type = specs->unsigned_p - ? sat_unsigned_long_long_fract_type_node - : sat_long_long_fract_type_node; - else if (specs->long_p) - specs->type = specs->unsigned_p - ? sat_unsigned_long_fract_type_node - : sat_long_fract_type_node; - else if (specs->short_p) - specs->type = specs->unsigned_p - ? sat_unsigned_short_fract_type_node - : sat_short_fract_type_node; - else - specs->type = specs->unsigned_p - ? sat_unsigned_fract_type_node - : sat_fract_type_node; - } - else - { - if (specs->long_long_p) - specs->type = specs->unsigned_p - ? unsigned_long_long_fract_type_node - : long_long_fract_type_node; - else if (specs->long_p) - specs->type = specs->unsigned_p - ? unsigned_long_fract_type_node - : long_fract_type_node; - else if (specs->short_p) - specs->type = specs->unsigned_p - ? unsigned_short_fract_type_node - : short_fract_type_node; - else - specs->type = specs->unsigned_p - ? unsigned_fract_type_node - : fract_type_node; - } - break; - case cts_accum: - gcc_assert (!specs->complex_p); - if (!targetm.fixed_point_supported_p ()) - specs->type = integer_type_node; - else if (specs->saturating_p) - { - if (specs->long_long_p) - specs->type = specs->unsigned_p - ? sat_unsigned_long_long_accum_type_node - : sat_long_long_accum_type_node; - else if (specs->long_p) - specs->type = specs->unsigned_p - ? sat_unsigned_long_accum_type_node - : sat_long_accum_type_node; - else if (specs->short_p) - specs->type = specs->unsigned_p - ? sat_unsigned_short_accum_type_node - : sat_short_accum_type_node; - else - specs->type = specs->unsigned_p - ? sat_unsigned_accum_type_node - : sat_accum_type_node; - } - else - { - if (specs->long_long_p) - specs->type = specs->unsigned_p - ? unsigned_long_long_accum_type_node - : long_long_accum_type_node; - else if (specs->long_p) - specs->type = specs->unsigned_p - ? unsigned_long_accum_type_node - : long_accum_type_node; - else if (specs->short_p) - specs->type = specs->unsigned_p - ? unsigned_short_accum_type_node - : short_accum_type_node; - else - specs->type = specs->unsigned_p - ? unsigned_accum_type_node - : accum_type_node; - } - break; - default: - gcc_unreachable (); - } - - return specs; -} - -/* A subroutine of c_write_global_declarations. Perform final processing - on one file scope's declarations (or the external scope's declarations), - GLOBALS. */ - -static void -c_write_global_declarations_1 (tree globals) -{ - tree decl; - bool reconsider; - - /* Process the decls in the order they were written. */ - for (decl = globals; decl; decl = DECL_CHAIN (decl)) - { - /* Check for used but undefined static functions using the C - standard's definition of "used", and set TREE_NO_WARNING so - that check_global_declarations doesn't repeat the check. */ - if (TREE_CODE (decl) == FUNCTION_DECL - && DECL_INITIAL (decl) == 0 - && DECL_EXTERNAL (decl) - && !TREE_PUBLIC (decl) - && C_DECL_USED (decl)) - { - pedwarn (input_location, 0, "%q+F used but never defined", decl); - TREE_NO_WARNING (decl) = 1; - } - - wrapup_global_declaration_1 (decl); - } - - do - { - reconsider = false; - for (decl = globals; decl; decl = DECL_CHAIN (decl)) - reconsider |= wrapup_global_declaration_2 (decl); - } - while (reconsider); - - for (decl = globals; decl; decl = DECL_CHAIN (decl)) - check_global_declaration_1 (decl); -} - -/* A subroutine of c_write_global_declarations Emit debug information for each - of the declarations in GLOBALS. */ - -static void -c_write_global_declarations_2 (tree globals) -{ - tree decl; - - for (decl = globals; decl ; decl = DECL_CHAIN (decl)) - debug_hooks->global_decl (decl); -} - -/* Callback to collect a source_ref from a DECL. */ - -static void -collect_source_ref_cb (tree decl) -{ - if (!DECL_IS_BUILTIN (decl)) - collect_source_ref (LOCATION_FILE (decl_sloc (decl, false))); -} - -/* Preserve the external declarations scope across a garbage collect. */ -static GTY(()) tree ext_block; - -/* Collect all references relevant to SOURCE_FILE. */ - -static void -collect_all_refs (const char *source_file) -{ - tree t; - unsigned i; - - FOR_EACH_VEC_ELT (*all_translation_units, i, t) - collect_ada_nodes (BLOCK_VARS (DECL_INITIAL (t)), source_file); - - collect_ada_nodes (BLOCK_VARS (ext_block), source_file); -} - -/* Iterate over all global declarations and call CALLBACK. */ - -static void -for_each_global_decl (void (*callback) (tree decl)) -{ - tree t; - tree decls; - tree decl; - unsigned i; - - FOR_EACH_VEC_ELT (*all_translation_units, i, t) - { - decls = DECL_INITIAL (t); - for (decl = BLOCK_VARS (decls); decl; decl = TREE_CHAIN (decl)) - callback (decl); - } - - for (decl = BLOCK_VARS (ext_block); decl; decl = TREE_CHAIN (decl)) - callback (decl); -} - -void -c_write_global_declarations (void) -{ - tree t; - unsigned i; - - /* We don't want to do this if generating a PCH. */ - if (pch_file) - return; - - timevar_start (TV_PHASE_DEFERRED); - - /* Do the Objective-C stuff. This is where all the Objective-C - module stuff gets generated (symtab, class/protocol/selector - lists etc). */ - if (c_dialect_objc ()) - objc_write_global_declarations (); - - /* Close the external scope. */ - ext_block = pop_scope (); - external_scope = 0; - gcc_assert (!current_scope); - - /* Handle -fdump-ada-spec[-slim]. */ - if (flag_dump_ada_spec || flag_dump_ada_spec_slim) - { - /* Build a table of files to generate specs for */ - if (flag_dump_ada_spec_slim) - collect_source_ref (main_input_filename); - else - for_each_global_decl (collect_source_ref_cb); - - dump_ada_specs (collect_all_refs, NULL); - } - - if (ext_block) - { - tree tmp = BLOCK_VARS (ext_block); - int flags; - FILE * stream = dump_begin (TDI_tu, &flags); - if (stream && tmp) - { - dump_node (tmp, flags & ~TDF_SLIM, stream); - dump_end (TDI_tu, stream); - } - } - - /* Process all file scopes in this compilation, and the external_scope, - through wrapup_global_declarations and check_global_declarations. */ - FOR_EACH_VEC_ELT (*all_translation_units, i, t) - c_write_global_declarations_1 (BLOCK_VARS (DECL_INITIAL (t))); - c_write_global_declarations_1 (BLOCK_VARS (ext_block)); - - timevar_stop (TV_PHASE_DEFERRED); - timevar_start (TV_PHASE_OPT_GEN); - - /* We're done parsing; proceed to optimize and emit assembly. - FIXME: shouldn't be the front end's responsibility to call this. */ - finalize_compilation_unit (); - - timevar_stop (TV_PHASE_OPT_GEN); - timevar_start (TV_PHASE_DBGINFO); - - /* After cgraph has had a chance to emit everything that's going to - be emitted, output debug information for globals. */ - if (!seen_error ()) - { - timevar_push (TV_SYMOUT); - FOR_EACH_VEC_ELT (*all_translation_units, i, t) - c_write_global_declarations_2 (BLOCK_VARS (DECL_INITIAL (t))); - c_write_global_declarations_2 (BLOCK_VARS (ext_block)); - timevar_pop (TV_SYMOUT); - } - - ext_block = NULL; - timevar_stop (TV_PHASE_DBGINFO); -} - -/* Register reserved keyword WORD as qualifier for address space AS. */ - -void -c_register_addr_space (const char *word, addr_space_t as) -{ - int rid = RID_FIRST_ADDR_SPACE + as; - tree id; - - /* Address space qualifiers are only supported - in C with GNU extensions enabled. */ - if (c_dialect_objc () || flag_no_asm) - return; - - id = get_identifier (word); - C_SET_RID_CODE (id, rid); - C_IS_RESERVED_WORD (id) = 1; - ridpointers [rid] = id; -} - -#include "gt-c-c-decl.h" |