1 /* Process declarations and variables for C compiler.
2 Copyright (C) 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
3 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011
4 Free Software Foundation, Inc.
6 This file is part of GCC.
8 GCC is free software; you can redistribute it and/or modify it under
9 the terms of the GNU General Public License as published by the Free
10 Software Foundation; either version 3, or (at your option) any later
13 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
14 WARRANTY; without even the implied warranty of MERCHANTABILITY or
15 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING3. If not see
20 <http://www.gnu.org/licenses/>. */
22 /* Process declarations and symbol lookup for C front end.
23 Also constructs types; the standard scalar types at initialization,
24 and structure, union, array and enum types when they are declared. */
26 /* ??? not all decl nodes are given the most useful possible
27 line numbers. For example, the CONST_DECLs for enum values. */
31 #include "coretypes.h"
36 #include "tree-inline.h"
48 #include "c-family/c-common.h"
49 #include "c-family/c-objc.h"
50 #include "c-family/c-pragma.h"
52 #include "langhooks.h"
53 #include "tree-mudflap.h"
54 #include "tree-iterator.h"
55 #include "diagnostic-core.h"
56 #include "tree-dump.h"
59 #include "langhooks-def.h"
60 #include "pointer-set.h"
62 #include "c-family/c-ada-spec.h"
64 /* In grokdeclarator, distinguish syntactic contexts of declarators. */
66 { NORMAL, /* Ordinary declaration */
67 FUNCDEF, /* Function definition */
68 PARM, /* Declaration of parm before function body */
69 FIELD, /* Declaration inside struct or union */
70 TYPENAME}; /* Typename (inside cast or sizeof) */
72 /* States indicating how grokdeclarator() should handle declspecs marked
73 with __attribute__((deprecated)). An object declared as
74 __attribute__((deprecated)) suppresses warnings of uses of other
77 enum deprecated_states {
83 /* Nonzero if we have seen an invalid cross reference
84 to a struct, union, or enum, but not yet printed the message. */
85 tree pending_invalid_xref;
87 /* File and line to appear in the eventual error message. */
88 location_t pending_invalid_xref_location;
90 /* The file and line that the prototype came from if this is an
91 old-style definition; used for diagnostics in
92 store_parm_decls_oldstyle. */
94 static location_t current_function_prototype_locus;
96 /* Whether this prototype was built-in. */
98 static bool current_function_prototype_built_in;
100 /* The argument type information of this prototype. */
102 static tree current_function_prototype_arg_types;
104 /* The argument information structure for the function currently being
107 static struct c_arg_info *current_function_arg_info;
109 /* The obstack on which parser and related data structures, which are
110 not live beyond their top-level declaration or definition, are
112 struct obstack parser_obstack;
114 /* The current statement tree. */
116 static GTY(()) struct stmt_tree_s c_stmt_tree;
118 /* State saving variables. */
122 /* A list of decls to be made automatically visible in each file scope. */
123 static GTY(()) tree visible_builtins;
125 /* Set to 0 at beginning of a function definition, set to 1 if
126 a return statement that specifies a return value is seen. */
128 int current_function_returns_value;
130 /* Set to 0 at beginning of a function definition, set to 1 if
131 a return statement with no argument is seen. */
133 int current_function_returns_null;
135 /* Set to 0 at beginning of a function definition, set to 1 if
136 a call to a noreturn function is seen. */
138 int current_function_returns_abnormally;
140 /* Set to nonzero by `grokdeclarator' for a function
141 whose return type is defaulted, if warnings for this are desired. */
143 static int warn_about_return_type;
145 /* Nonzero when the current toplevel function contains a declaration
146 of a nested function which is never defined. */
148 static bool undef_nested_function;
150 /* True means global_bindings_p should return false even if the scope stack
151 says we are in file scope. */
152 bool c_override_global_bindings_to_false;
155 /* Each c_binding structure describes one binding of an identifier to
156 a decl. All the decls in a scope - irrespective of namespace - are
157 chained together by the ->prev field, which (as the name implies)
158 runs in reverse order. All the decls in a given namespace bound to
159 a given identifier are chained by the ->shadowed field, which runs
160 from inner to outer scopes.
162 The ->decl field usually points to a DECL node, but there are two
163 exceptions. In the namespace of type tags, the bound entity is a
164 RECORD_TYPE, UNION_TYPE, or ENUMERAL_TYPE node. If an undeclared
165 identifier is encountered, it is bound to error_mark_node to
166 suppress further errors about that identifier in the current
169 The ->u.type field stores the type of the declaration in this scope;
170 if NULL, the type is the type of the ->decl field. This is only of
171 relevance for objects with external or internal linkage which may
172 be redeclared in inner scopes, forming composite types that only
173 persist for the duration of those scopes. In the external scope,
174 this stores the composite of all the types declared for this
175 object, visible or not. The ->inner_comp field (used only at file
176 scope) stores whether an incomplete array type at file scope was
177 completed at an inner scope to an array size other than 1.
179 The ->u.label field is used for labels. It points to a structure
180 which stores additional information used for warnings.
182 The depth field is copied from the scope structure that holds this
183 decl. It is used to preserve the proper ordering of the ->shadowed
184 field (see bind()) and also for a handful of special-case checks.
185 Finally, the invisible bit is true for a decl which should be
186 ignored for purposes of normal name lookup, and the nested bit is
187 true for a decl that's been bound a second time in an inner scope;
188 in all such cases, the binding in the outer scope will have its
189 invisible bit true. */
191 struct GTY((chain_next ("%h.prev"))) c_binding {
192 union GTY(()) { /* first so GTY desc can use decl */
193 tree GTY((tag ("0"))) type; /* the type in this scope */
194 struct c_label_vars * GTY((tag ("1"))) label; /* for warnings */
195 } GTY((desc ("TREE_CODE (%0.decl) == LABEL_DECL"))) u;
196 tree decl; /* the decl bound */
197 tree id; /* the identifier it's bound to */
198 struct c_binding *prev; /* the previous decl in this scope */
199 struct c_binding *shadowed; /* the innermost decl shadowed by this one */
200 unsigned int depth : 28; /* depth of this scope */
201 BOOL_BITFIELD invisible : 1; /* normal lookup should ignore this binding */
202 BOOL_BITFIELD nested : 1; /* do not set DECL_CONTEXT when popping */
203 BOOL_BITFIELD inner_comp : 1; /* incomplete array completed in inner scope */
204 BOOL_BITFIELD in_struct : 1; /* currently defined as struct field */
205 location_t locus; /* location for nested bindings */
207 #define B_IN_SCOPE(b1, b2) ((b1)->depth == (b2)->depth)
208 #define B_IN_CURRENT_SCOPE(b) ((b)->depth == current_scope->depth)
209 #define B_IN_FILE_SCOPE(b) ((b)->depth == 1 /*file_scope->depth*/)
210 #define B_IN_EXTERNAL_SCOPE(b) ((b)->depth == 0 /*external_scope->depth*/)
212 #define I_SYMBOL_BINDING(node) \
213 (((struct lang_identifier *) IDENTIFIER_NODE_CHECK(node))->symbol_binding)
214 #define I_SYMBOL_DECL(node) \
215 (I_SYMBOL_BINDING(node) ? I_SYMBOL_BINDING(node)->decl : 0)
217 #define I_TAG_BINDING(node) \
218 (((struct lang_identifier *) IDENTIFIER_NODE_CHECK(node))->tag_binding)
219 #define I_TAG_DECL(node) \
220 (I_TAG_BINDING(node) ? I_TAG_BINDING(node)->decl : 0)
222 #define I_LABEL_BINDING(node) \
223 (((struct lang_identifier *) IDENTIFIER_NODE_CHECK(node))->label_binding)
224 #define I_LABEL_DECL(node) \
225 (I_LABEL_BINDING(node) ? I_LABEL_BINDING(node)->decl : 0)
227 /* Each C symbol points to three linked lists of c_binding structures.
228 These describe the values of the identifier in the three different
229 namespaces defined by the language. */
231 struct GTY(()) lang_identifier {
232 struct c_common_identifier common_id;
233 struct c_binding *symbol_binding; /* vars, funcs, constants, typedefs */
234 struct c_binding *tag_binding; /* struct/union/enum tags */
235 struct c_binding *label_binding; /* labels */
238 /* Validate c-lang.c's assumptions. */
239 extern char C_SIZEOF_STRUCT_LANG_IDENTIFIER_isnt_accurate
240 [(sizeof(struct lang_identifier) == C_SIZEOF_STRUCT_LANG_IDENTIFIER) ? 1 : -1];
242 /* The resulting tree type. */
244 union GTY((desc ("TREE_CODE (&%h.generic) == IDENTIFIER_NODE"),
245 chain_next ("TREE_CODE (&%h.generic) == INTEGER_TYPE ? (union lang_tree_node *) TYPE_NEXT_VARIANT (&%h.generic) : ((union lang_tree_node *) TREE_CHAIN (&%h.generic))"))) lang_tree_node
247 union tree_node GTY ((tag ("0"),
248 desc ("tree_node_structure (&%h)")))
250 struct lang_identifier GTY ((tag ("1"))) identifier;
253 /* Track bindings and other things that matter for goto warnings. For
254 efficiency, we do not gather all the decls at the point of
255 definition. Instead, we point into the bindings structure. As
256 scopes are popped, we update these structures and gather the decls
257 that matter at that time. */
259 struct GTY(()) c_spot_bindings {
260 /* The currently open scope which holds bindings defined when the
261 label was defined or the goto statement was found. */
262 struct c_scope *scope;
263 /* The bindings in the scope field which were defined at the point
264 of the label or goto. This lets us look at older or newer
265 bindings in the scope, as appropriate. */
266 struct c_binding *bindings_in_scope;
267 /* The number of statement expressions that have started since this
268 label or goto statement was defined. This is zero if we are at
269 the same statement expression level. It is positive if we are in
270 a statement expression started since this spot. It is negative
271 if this spot was in a statement expression and we have left
274 /* Whether we started in a statement expression but are no longer in
275 it. This is set to true if stmt_exprs ever goes negative. */
279 /* This structure is used to keep track of bindings seen when a goto
280 statement is defined. This is only used if we see the goto
281 statement before we see the label. */
283 struct GTY(()) c_goto_bindings {
284 /* The location of the goto statement. */
286 /* The bindings of the goto statement. */
287 struct c_spot_bindings goto_bindings;
290 typedef struct c_goto_bindings *c_goto_bindings_p;
291 DEF_VEC_P(c_goto_bindings_p);
292 DEF_VEC_ALLOC_P(c_goto_bindings_p,gc);
294 /* The additional information we keep track of for a label binding.
295 These fields are updated as scopes are popped. */
297 struct GTY(()) c_label_vars {
298 /* The shadowed c_label_vars, when one label shadows another (which
299 can only happen using a __label__ declaration). */
300 struct c_label_vars *shadowed;
301 /* The bindings when the label was defined. */
302 struct c_spot_bindings label_bindings;
303 /* A list of decls that we care about: decls about which we should
304 warn if a goto branches to this label from later in the function.
305 Decls are added to this list as scopes are popped. We only add
306 the decls that matter. */
307 VEC(tree,gc) *decls_in_scope;
308 /* A list of goto statements to this label. This is only used for
309 goto statements seen before the label was defined, so that we can
310 issue appropriate warnings for them. */
311 VEC(c_goto_bindings_p,gc) *gotos;
314 /* Each c_scope structure describes the complete contents of one
315 scope. Four scopes are distinguished specially: the innermost or
316 current scope, the innermost function scope, the file scope (always
317 the second to outermost) and the outermost or external scope.
319 Most declarations are recorded in the current scope.
321 All normal label declarations are recorded in the innermost
322 function scope, as are bindings of undeclared identifiers to
323 error_mark_node. (GCC permits nested functions as an extension,
324 hence the 'innermost' qualifier.) Explicitly declared labels
325 (using the __label__ extension) appear in the current scope.
327 Being in the file scope (current_scope == file_scope) causes
328 special behavior in several places below. Also, under some
329 conditions the Objective-C front end records declarations in the
330 file scope even though that isn't the current scope.
332 All declarations with external linkage are recorded in the external
333 scope, even if they aren't visible there; this models the fact that
334 such declarations are visible to the entire program, and (with a
335 bit of cleverness, see pushdecl) allows diagnosis of some violations
336 of C99 6.2.2p7 and 6.2.7p2:
338 If, within the same translation unit, the same identifier appears
339 with both internal and external linkage, the behavior is
342 All declarations that refer to the same object or function shall
343 have compatible type; otherwise, the behavior is undefined.
345 Initially only the built-in declarations, which describe compiler
346 intrinsic functions plus a subset of the standard library, are in
349 The order of the blocks list matters, and it is frequently appended
350 to. To avoid having to walk all the way to the end of the list on
351 each insertion, or reverse the list later, we maintain a pointer to
352 the last list entry. (FIXME: It should be feasible to use a reversed
355 The bindings list is strictly in reverse order of declarations;
356 pop_scope relies on this. */
359 struct GTY((chain_next ("%h.outer"))) c_scope {
360 /* The scope containing this one. */
361 struct c_scope *outer;
363 /* The next outermost function scope. */
364 struct c_scope *outer_function;
366 /* All bindings in this scope. */
367 struct c_binding *bindings;
369 /* For each scope (except the global one), a chain of BLOCK nodes
370 for all the scopes that were entered and exited one level down. */
374 /* The depth of this scope. Used to keep the ->shadowed chain of
375 bindings sorted innermost to outermost. */
376 unsigned int depth : 28;
378 /* True if we are currently filling this scope with parameter
380 BOOL_BITFIELD parm_flag : 1;
382 /* True if we saw [*] in this scope. Used to give an error messages
383 if these appears in a function definition. */
384 BOOL_BITFIELD had_vla_unspec : 1;
386 /* True if we already complained about forward parameter decls
387 in this scope. This prevents double warnings on
388 foo (int a; int b; ...) */
389 BOOL_BITFIELD warned_forward_parm_decls : 1;
391 /* True if this is the outermost block scope of a function body.
392 This scope contains the parameters, the local variables declared
393 in the outermost block, and all the labels (except those in
394 nested functions, or declared at block scope with __label__). */
395 BOOL_BITFIELD function_body : 1;
397 /* True means make a BLOCK for this scope no matter what. */
398 BOOL_BITFIELD keep : 1;
400 /* True means that an unsuffixed float constant is _Decimal64. */
401 BOOL_BITFIELD float_const_decimal64 : 1;
403 /* True if this scope has any label bindings. This is used to speed
404 up searching for labels when popping scopes, particularly since
405 labels are normally only found at function scope. */
406 BOOL_BITFIELD has_label_bindings : 1;
408 /* True if we should issue a warning if a goto statement crosses any
409 of the bindings. We still need to check the list of bindings to
410 find the specific ones we need to warn about. This is true if
411 decl_jump_unsafe would return true for any of the bindings. This
412 is used to avoid looping over all the bindings unnecessarily. */
413 BOOL_BITFIELD has_jump_unsafe_decl : 1;
416 /* The scope currently in effect. */
418 static GTY(()) struct c_scope *current_scope;
420 /* The innermost function scope. Ordinary (not explicitly declared)
421 labels, bindings to error_mark_node, and the lazily-created
422 bindings of __func__ and its friends get this scope. */
424 static GTY(()) struct c_scope *current_function_scope;
426 /* The C file scope. This is reset for each input translation unit. */
428 static GTY(()) struct c_scope *file_scope;
430 /* The outermost scope. This is used for all declarations with
431 external linkage, and only these, hence the name. */
433 static GTY(()) struct c_scope *external_scope;
435 /* A chain of c_scope structures awaiting reuse. */
437 static GTY((deletable)) struct c_scope *scope_freelist;
439 /* A chain of c_binding structures awaiting reuse. */
441 static GTY((deletable)) struct c_binding *binding_freelist;
443 /* Append VAR to LIST in scope SCOPE. */
444 #define SCOPE_LIST_APPEND(scope, list, decl) do { \
445 struct c_scope *s_ = (scope); \
447 if (s_->list##_last) \
448 BLOCK_CHAIN (s_->list##_last) = d_; \
451 s_->list##_last = d_; \
454 /* Concatenate FROM in scope FSCOPE onto TO in scope TSCOPE. */
455 #define SCOPE_LIST_CONCAT(tscope, to, fscope, from) do { \
456 struct c_scope *t_ = (tscope); \
457 struct c_scope *f_ = (fscope); \
459 BLOCK_CHAIN (t_->to##_last) = f_->from; \
462 t_->to##_last = f_->from##_last; \
465 /* A c_inline_static structure stores details of a static identifier
466 referenced in a definition of a function that may be an inline
467 definition if no subsequent declaration of that function uses
468 "extern" or does not use "inline". */
470 struct GTY((chain_next ("%h.next"))) c_inline_static {
471 /* The location for a diagnostic. */
474 /* The function that may be an inline definition. */
477 /* The object or function referenced. */
480 /* What sort of reference this is. */
481 enum c_inline_static_type type;
483 /* The next such structure or NULL. */
484 struct c_inline_static *next;
487 /* List of static identifiers used or referenced in functions that may
488 be inline definitions. */
489 static GTY(()) struct c_inline_static *c_inline_statics;
491 /* True means unconditionally make a BLOCK for the next scope pushed. */
493 static bool keep_next_level_flag;
495 /* True means the next call to push_scope will be the outermost scope
496 of a function body, so do not push a new scope, merely cease
497 expecting parameter decls. */
499 static bool next_is_function_body;
501 /* A VEC of pointers to c_binding structures. */
503 typedef struct c_binding *c_binding_ptr;
504 DEF_VEC_P(c_binding_ptr);
505 DEF_VEC_ALLOC_P(c_binding_ptr,heap);
507 /* Information that we keep for a struct or union while it is being
510 struct c_struct_parse_info
512 /* If warn_cxx_compat, a list of types defined within this
514 VEC(tree,heap) *struct_types;
515 /* If warn_cxx_compat, a list of field names which have bindings,
516 and which are defined in this struct, but which are not defined
517 in any enclosing struct. This is used to clear the in_struct
518 field of the c_bindings structure. */
519 VEC(c_binding_ptr,heap) *fields;
520 /* If warn_cxx_compat, a list of typedef names used when defining
521 fields in this struct. */
522 VEC(tree,heap) *typedefs_seen;
525 /* Information for the struct or union currently being parsed, or
526 NULL if not parsing a struct or union. */
527 static struct c_struct_parse_info *struct_parse_info;
529 /* Forward declarations. */
530 static tree lookup_name_in_scope (tree, struct c_scope *);
531 static tree c_make_fname_decl (location_t, tree, int);
532 static tree grokdeclarator (const struct c_declarator *,
533 struct c_declspecs *,
534 enum decl_context, bool, tree *, tree *, tree *,
535 bool *, enum deprecated_states);
536 static tree grokparms (struct c_arg_info *, bool);
537 static void layout_array_type (tree);
539 /* T is a statement. Add it to the statement-tree. This is the
540 C/ObjC version--C++ has a slightly different version of this
546 enum tree_code code = TREE_CODE (t);
548 if (CAN_HAVE_LOCATION_P (t) && code != LABEL_EXPR)
550 if (!EXPR_HAS_LOCATION (t))
551 SET_EXPR_LOCATION (t, input_location);
554 if (code == LABEL_EXPR || code == CASE_LABEL_EXPR)
555 STATEMENT_LIST_HAS_LABEL (cur_stmt_list) = 1;
557 /* Add T to the statement-tree. Non-side-effect statements need to be
558 recorded during statement expressions. */
559 append_to_statement_list_force (t, &cur_stmt_list);
564 /* Return true if we will want to say something if a goto statement
568 decl_jump_unsafe (tree decl)
570 if (decl == error_mark_node || TREE_TYPE (decl) == error_mark_node)
573 /* Always warn about crossing variably modified types. */
574 if ((TREE_CODE (decl) == VAR_DECL || TREE_CODE (decl) == TYPE_DECL)
575 && variably_modified_type_p (TREE_TYPE (decl), NULL_TREE))
578 /* Otherwise, only warn if -Wgoto-misses-init and this is an
579 initialized automatic decl. */
580 if (warn_jump_misses_init
581 && TREE_CODE (decl) == VAR_DECL
582 && !TREE_STATIC (decl)
583 && DECL_INITIAL (decl) != NULL_TREE)
591 c_print_identifier (FILE *file, tree node, int indent)
593 print_node (file, "symbol", I_SYMBOL_DECL (node), indent + 4);
594 print_node (file, "tag", I_TAG_DECL (node), indent + 4);
595 print_node (file, "label", I_LABEL_DECL (node), indent + 4);
596 if (C_IS_RESERVED_WORD (node) && C_RID_CODE (node) != RID_CXX_COMPAT_WARN)
598 tree rid = ridpointers[C_RID_CODE (node)];
599 indent_to (file, indent + 4);
600 fprintf (file, "rid " HOST_PTR_PRINTF " \"%s\"",
601 (void *) rid, IDENTIFIER_POINTER (rid));
605 /* Establish a binding between NAME, an IDENTIFIER_NODE, and DECL,
606 which may be any of several kinds of DECL or TYPE or error_mark_node,
607 in the scope SCOPE. */
609 bind (tree name, tree decl, struct c_scope *scope, bool invisible,
610 bool nested, location_t locus)
612 struct c_binding *b, **here;
614 if (binding_freelist)
616 b = binding_freelist;
617 binding_freelist = b->prev;
620 b = ggc_alloc_c_binding ();
625 b->depth = scope->depth;
626 b->invisible = invisible;
634 b->prev = scope->bindings;
637 if (decl_jump_unsafe (decl))
638 scope->has_jump_unsafe_decl = 1;
643 switch (TREE_CODE (decl))
645 case LABEL_DECL: here = &I_LABEL_BINDING (name); break;
648 case RECORD_TYPE: here = &I_TAG_BINDING (name); break;
654 case ERROR_MARK: here = &I_SYMBOL_BINDING (name); break;
660 /* Locate the appropriate place in the chain of shadowed decls
661 to insert this binding. Normally, scope == current_scope and
662 this does nothing. */
663 while (*here && (*here)->depth > scope->depth)
664 here = &(*here)->shadowed;
670 /* Clear the binding structure B, stick it on the binding_freelist,
671 and return the former value of b->prev. This is used by pop_scope
672 and get_parm_info to iterate destructively over all the bindings
673 from a given scope. */
674 static struct c_binding *
675 free_binding_and_advance (struct c_binding *b)
677 struct c_binding *prev = b->prev;
679 memset (b, 0, sizeof (struct c_binding));
680 b->prev = binding_freelist;
681 binding_freelist = b;
686 /* Bind a label. Like bind, but skip fields which aren't used for
687 labels, and add the LABEL_VARS value. */
689 bind_label (tree name, tree label, struct c_scope *scope,
690 struct c_label_vars *label_vars)
694 bind (name, label, scope, /*invisible=*/false, /*nested=*/false,
697 scope->has_label_bindings = true;
700 gcc_assert (b->decl == label);
701 label_vars->shadowed = b->u.label;
702 b->u.label = label_vars;
705 /* Hook called at end of compilation to assume 1 elt
706 for a file-scope tentative array defn that wasn't complete before. */
709 c_finish_incomplete_decl (tree decl)
711 if (TREE_CODE (decl) == VAR_DECL)
713 tree type = TREE_TYPE (decl);
714 if (type != error_mark_node
715 && TREE_CODE (type) == ARRAY_TYPE
716 && !DECL_EXTERNAL (decl)
717 && TYPE_DOMAIN (type) == 0)
719 warning_at (DECL_SOURCE_LOCATION (decl),
720 0, "array %q+D assumed to have one element", decl);
722 complete_array_type (&TREE_TYPE (decl), NULL_TREE, true);
724 relayout_decl (decl);
729 /* Record that inline function FUNC contains a reference (location
730 LOC) to static DECL (file-scope or function-local according to
734 record_inline_static (location_t loc, tree func, tree decl,
735 enum c_inline_static_type type)
737 struct c_inline_static *csi = ggc_alloc_c_inline_static ();
739 csi->function = func;
740 csi->static_decl = decl;
742 csi->next = c_inline_statics;
743 c_inline_statics = csi;
746 /* Check for references to static declarations in inline functions at
747 the end of the translation unit and diagnose them if the functions
748 are still inline definitions. */
751 check_inline_statics (void)
753 struct c_inline_static *csi;
754 for (csi = c_inline_statics; csi; csi = csi->next)
756 if (DECL_EXTERNAL (csi->function))
760 pedwarn (csi->location, 0,
761 "%qD is static but used in inline function %qD "
762 "which is not static", csi->static_decl, csi->function);
765 pedwarn (csi->location, 0,
766 "%q+D is static but declared in inline function %qD "
767 "which is not static", csi->static_decl, csi->function);
773 c_inline_statics = NULL;
776 /* Fill in a c_spot_bindings structure. If DEFINING is true, set it
777 for the current state, otherwise set it to uninitialized. */
780 set_spot_bindings (struct c_spot_bindings *p, bool defining)
784 p->scope = current_scope;
785 p->bindings_in_scope = current_scope->bindings;
790 p->bindings_in_scope = NULL;
793 p->left_stmt_expr = false;
796 /* Update spot bindings P as we pop out of SCOPE. Return true if we
797 should push decls for a label. */
800 update_spot_bindings (struct c_scope *scope, struct c_spot_bindings *p)
802 if (p->scope != scope)
804 /* This label or goto is defined in some other scope, or it is a
805 label which is not yet defined. There is nothing to
810 /* Adjust the spot bindings to refer to the bindings already defined
811 in the enclosing scope. */
812 p->scope = scope->outer;
813 p->bindings_in_scope = p->scope->bindings;
818 /* The Objective-C front-end often needs to determine the current scope. */
821 objc_get_current_scope (void)
823 return current_scope;
826 /* The following function is used only by Objective-C. It needs to live here
827 because it accesses the innards of c_scope. */
830 objc_mark_locals_volatile (void *enclosing_blk)
832 struct c_scope *scope;
835 for (scope = current_scope;
836 scope && scope != enclosing_blk;
837 scope = scope->outer)
839 for (b = scope->bindings; b; b = b->prev)
840 objc_volatilize_decl (b->decl);
842 /* Do not climb up past the current function. */
843 if (scope->function_body)
848 /* Nonzero if we are currently in file scope. */
851 global_bindings_p (void)
853 return (current_scope == file_scope && !c_override_global_bindings_to_false
859 keep_next_level (void)
861 keep_next_level_flag = true;
864 /* Set the flag for the FLOAT_CONST_DECIMAL64 pragma being ON. */
867 set_float_const_decimal64 (void)
869 current_scope->float_const_decimal64 = true;
872 /* Clear the flag for the FLOAT_CONST_DECIMAL64 pragma. */
875 clear_float_const_decimal64 (void)
877 current_scope->float_const_decimal64 = false;
880 /* Return nonzero if an unsuffixed float constant is _Decimal64. */
883 float_const_decimal64_p (void)
885 return current_scope->float_const_decimal64;
888 /* Identify this scope as currently being filled with parameters. */
891 declare_parm_level (void)
893 current_scope->parm_flag = true;
899 if (next_is_function_body)
901 /* This is the transition from the parameters to the top level
902 of the function body. These are the same scope
903 (C99 6.2.1p4,6) so we do not push another scope structure.
904 next_is_function_body is set only by store_parm_decls, which
905 in turn is called when and only when we are about to
906 encounter the opening curly brace for the function body.
908 The outermost block of a function always gets a BLOCK node,
909 because the debugging output routines expect that each
910 function has at least one BLOCK. */
911 current_scope->parm_flag = false;
912 current_scope->function_body = true;
913 current_scope->keep = true;
914 current_scope->outer_function = current_function_scope;
915 current_function_scope = current_scope;
917 keep_next_level_flag = false;
918 next_is_function_body = false;
920 /* The FLOAT_CONST_DECIMAL64 pragma applies to nested scopes. */
921 if (current_scope->outer)
922 current_scope->float_const_decimal64
923 = current_scope->outer->float_const_decimal64;
925 current_scope->float_const_decimal64 = false;
929 struct c_scope *scope;
932 scope = scope_freelist;
933 scope_freelist = scope->outer;
936 scope = ggc_alloc_cleared_c_scope ();
938 /* The FLOAT_CONST_DECIMAL64 pragma applies to nested scopes. */
940 scope->float_const_decimal64 = current_scope->float_const_decimal64;
942 scope->float_const_decimal64 = false;
944 scope->keep = keep_next_level_flag;
945 scope->outer = current_scope;
946 scope->depth = current_scope ? (current_scope->depth + 1) : 0;
948 /* Check for scope depth overflow. Unlikely (2^28 == 268,435,456) but
950 if (current_scope && scope->depth == 0)
953 sorry ("GCC supports only %u nested scopes", scope->depth);
956 current_scope = scope;
957 keep_next_level_flag = false;
961 /* This is called when we are leaving SCOPE. For each label defined
962 in SCOPE, add any appropriate decls to its decls_in_scope fields.
963 These are the decls whose initialization will be skipped by a goto
964 later in the function. */
967 update_label_decls (struct c_scope *scope)
974 if (s->has_label_bindings)
978 for (b = s->bindings; b != NULL; b = b->prev)
980 struct c_label_vars *label_vars;
981 struct c_binding *b1;
984 struct c_goto_bindings *g;
986 if (TREE_CODE (b->decl) != LABEL_DECL)
988 label_vars = b->u.label;
990 b1 = label_vars->label_bindings.bindings_in_scope;
991 if (label_vars->label_bindings.scope == NULL)
994 hjud = label_vars->label_bindings.scope->has_jump_unsafe_decl;
995 if (update_spot_bindings (scope, &label_vars->label_bindings))
997 /* This label is defined in this scope. */
1000 for (; b1 != NULL; b1 = b1->prev)
1002 /* A goto from later in the function to this
1003 label will never see the initialization
1004 of B1, if any. Save it to issue a
1005 warning if needed. */
1006 if (decl_jump_unsafe (b1->decl))
1007 VEC_safe_push (tree, gc,
1008 label_vars->decls_in_scope,
1014 /* Update the bindings of any goto statements associated
1016 FOR_EACH_VEC_ELT (c_goto_bindings_p, label_vars->gotos, ix, g)
1017 update_spot_bindings (scope, &g->goto_bindings);
1021 /* Don't search beyond the current function. */
1022 if (s == current_function_scope)
1029 /* Set the TYPE_CONTEXT of all of TYPE's variants to CONTEXT. */
1032 set_type_context (tree type, tree context)
1034 for (type = TYPE_MAIN_VARIANT (type); type;
1035 type = TYPE_NEXT_VARIANT (type))
1036 TYPE_CONTEXT (type) = context;
1039 /* Exit a scope. Restore the state of the identifier-decl mappings
1040 that were in effect when this scope was entered. Return a BLOCK
1041 node containing all the DECLs in this scope that are of interest
1042 to debug info generation. */
1047 struct c_scope *scope = current_scope;
1048 tree block, context, p;
1049 struct c_binding *b;
1051 bool functionbody = scope->function_body;
1052 bool keep = functionbody || scope->keep || scope->bindings;
1054 update_label_decls (scope);
1056 /* If appropriate, create a BLOCK to record the decls for the life
1057 of this function. */
1061 block = make_node (BLOCK);
1062 BLOCK_SUBBLOCKS (block) = scope->blocks;
1063 TREE_USED (block) = 1;
1065 /* In each subblock, record that this is its superior. */
1066 for (p = scope->blocks; p; p = BLOCK_CHAIN (p))
1067 BLOCK_SUPERCONTEXT (p) = block;
1069 BLOCK_VARS (block) = 0;
1072 /* The TYPE_CONTEXTs for all of the tagged types belonging to this
1073 scope must be set so that they point to the appropriate
1074 construct, i.e. either to the current FUNCTION_DECL node, or
1075 else to the BLOCK node we just constructed.
1077 Note that for tagged types whose scope is just the formal
1078 parameter list for some function type specification, we can't
1079 properly set their TYPE_CONTEXTs here, because we don't have a
1080 pointer to the appropriate FUNCTION_TYPE node readily available
1081 to us. For those cases, the TYPE_CONTEXTs of the relevant tagged
1082 type nodes get set in `grokdeclarator' as soon as we have created
1083 the FUNCTION_TYPE node which will represent the "scope" for these
1084 "parameter list local" tagged types. */
1085 if (scope->function_body)
1086 context = current_function_decl;
1087 else if (scope == file_scope)
1089 tree file_decl = build_translation_unit_decl (NULL_TREE);
1090 context = file_decl;
1095 /* Clear all bindings in this scope. */
1096 for (b = scope->bindings; b; b = free_binding_and_advance (b))
1099 switch (TREE_CODE (p))
1102 /* Warnings for unused labels, errors for undefined labels. */
1103 if (TREE_USED (p) && !DECL_INITIAL (p))
1105 error ("label %q+D used but not defined", p);
1106 DECL_INITIAL (p) = error_mark_node;
1109 warn_for_unused_label (p);
1111 /* Labels go in BLOCK_VARS. */
1112 DECL_CHAIN (p) = BLOCK_VARS (block);
1113 BLOCK_VARS (block) = p;
1114 gcc_assert (I_LABEL_BINDING (b->id) == b);
1115 I_LABEL_BINDING (b->id) = b->shadowed;
1117 /* Also pop back to the shadowed label_vars. */
1118 release_tree_vector (b->u.label->decls_in_scope);
1119 b->u.label = b->u.label->shadowed;
1125 set_type_context (p, context);
1127 /* Types may not have tag-names, in which case the type
1128 appears in the bindings list with b->id NULL. */
1131 gcc_assert (I_TAG_BINDING (b->id) == b);
1132 I_TAG_BINDING (b->id) = b->shadowed;
1137 /* Propagate TREE_ADDRESSABLE from nested functions to their
1138 containing functions. */
1139 if (!TREE_ASM_WRITTEN (p)
1140 && DECL_INITIAL (p) != 0
1141 && TREE_ADDRESSABLE (p)
1142 && DECL_ABSTRACT_ORIGIN (p) != 0
1143 && DECL_ABSTRACT_ORIGIN (p) != p)
1144 TREE_ADDRESSABLE (DECL_ABSTRACT_ORIGIN (p)) = 1;
1145 if (!DECL_EXTERNAL (p)
1146 && !DECL_INITIAL (p)
1147 && scope != file_scope
1148 && scope != external_scope)
1150 error ("nested function %q+D declared but never defined", p);
1151 undef_nested_function = true;
1153 else if (DECL_DECLARED_INLINE_P (p)
1155 && !DECL_INITIAL (p))
1157 /* C99 6.7.4p6: "a function with external linkage... declared
1158 with an inline function specifier ... shall also be defined
1159 in the same translation unit." */
1160 if (!flag_gnu89_inline)
1161 pedwarn (input_location, 0,
1162 "inline function %q+D declared but never defined", p);
1163 DECL_EXTERNAL (p) = 1;
1169 /* Warnings for unused variables. */
1170 if ((!TREE_USED (p) || !DECL_READ_P (p))
1171 && !TREE_NO_WARNING (p)
1172 && !DECL_IN_SYSTEM_HEADER (p)
1174 && !DECL_ARTIFICIAL (p)
1175 && scope != file_scope
1176 && scope != external_scope)
1179 warning (OPT_Wunused_variable, "unused variable %q+D", p);
1180 else if (DECL_CONTEXT (p) == current_function_decl)
1181 warning_at (DECL_SOURCE_LOCATION (p),
1182 OPT_Wunused_but_set_variable,
1183 "variable %qD set but not used", p);
1188 error ("type of array %q+D completed incompatibly with"
1189 " implicit initialization", p);
1196 /* All of these go in BLOCK_VARS, but only if this is the
1197 binding in the home scope. */
1200 DECL_CHAIN (p) = BLOCK_VARS (block);
1201 BLOCK_VARS (block) = p;
1203 else if (VAR_OR_FUNCTION_DECL_P (p) && scope != file_scope)
1205 /* For block local externs add a special
1206 DECL_EXTERNAL decl for debug info generation. */
1207 tree extp = copy_node (p);
1209 DECL_EXTERNAL (extp) = 1;
1210 TREE_STATIC (extp) = 0;
1211 TREE_PUBLIC (extp) = 1;
1212 DECL_INITIAL (extp) = NULL_TREE;
1213 DECL_LANG_SPECIFIC (extp) = NULL;
1214 DECL_CONTEXT (extp) = current_function_decl;
1215 if (TREE_CODE (p) == FUNCTION_DECL)
1217 DECL_RESULT (extp) = NULL_TREE;
1218 DECL_SAVED_TREE (extp) = NULL_TREE;
1219 DECL_STRUCT_FUNCTION (extp) = NULL;
1221 if (b->locus != UNKNOWN_LOCATION)
1222 DECL_SOURCE_LOCATION (extp) = b->locus;
1223 DECL_CHAIN (extp) = BLOCK_VARS (block);
1224 BLOCK_VARS (block) = extp;
1226 /* If this is the file scope set DECL_CONTEXT of each decl to
1227 the TRANSLATION_UNIT_DECL. This makes same_translation_unit_p
1229 if (scope == file_scope)
1231 DECL_CONTEXT (p) = context;
1232 if (TREE_CODE (p) == TYPE_DECL
1233 && TREE_TYPE (p) != error_mark_node)
1234 set_type_context (TREE_TYPE (p), context);
1238 /* Parameters go in DECL_ARGUMENTS, not BLOCK_VARS, and have
1239 already been put there by store_parm_decls. Unused-
1240 parameter warnings are handled by function.c.
1241 error_mark_node obviously does not go in BLOCK_VARS and
1242 does not get unused-variable warnings. */
1245 /* It is possible for a decl not to have a name. We get
1246 here with b->id NULL in this case. */
1249 gcc_assert (I_SYMBOL_BINDING (b->id) == b);
1250 I_SYMBOL_BINDING (b->id) = b->shadowed;
1251 if (b->shadowed && b->shadowed->u.type)
1252 TREE_TYPE (b->shadowed->decl) = b->shadowed->u.type;
1262 /* Dispose of the block that we just made inside some higher level. */
1263 if ((scope->function_body || scope == file_scope) && context)
1265 DECL_INITIAL (context) = block;
1266 BLOCK_SUPERCONTEXT (block) = context;
1268 else if (scope->outer)
1271 SCOPE_LIST_APPEND (scope->outer, blocks, block);
1272 /* If we did not make a block for the scope just exited, any
1273 blocks made for inner scopes must be carried forward so they
1274 will later become subblocks of something else. */
1275 else if (scope->blocks)
1276 SCOPE_LIST_CONCAT (scope->outer, blocks, scope, blocks);
1279 /* Pop the current scope, and free the structure for reuse. */
1280 current_scope = scope->outer;
1281 if (scope->function_body)
1282 current_function_scope = scope->outer_function;
1284 memset (scope, 0, sizeof (struct c_scope));
1285 scope->outer = scope_freelist;
1286 scope_freelist = scope;
1292 push_file_scope (void)
1300 file_scope = current_scope;
1302 start_fname_decls ();
1304 for (decl = visible_builtins; decl; decl = DECL_CHAIN (decl))
1305 bind (DECL_NAME (decl), decl, file_scope,
1306 /*invisible=*/false, /*nested=*/true, DECL_SOURCE_LOCATION (decl));
1310 pop_file_scope (void)
1312 /* In case there were missing closebraces, get us back to the global
1314 while (current_scope != file_scope)
1317 /* __FUNCTION__ is defined at file scope (""). This
1318 call may not be necessary as my tests indicate it
1319 still works without it. */
1320 finish_fname_decls ();
1322 check_inline_statics ();
1324 /* This is the point to write out a PCH if we're doing that.
1325 In that case we do not want to do anything else. */
1328 c_common_write_pch ();
1332 /* Pop off the file scope and close this translation unit. */
1336 maybe_apply_pending_pragma_weaks ();
1339 /* Adjust the bindings for the start of a statement expression. */
1342 c_bindings_start_stmt_expr (struct c_spot_bindings* switch_bindings)
1344 struct c_scope *scope;
1346 for (scope = current_scope; scope != NULL; scope = scope->outer)
1348 struct c_binding *b;
1350 if (!scope->has_label_bindings)
1353 for (b = scope->bindings; b != NULL; b = b->prev)
1355 struct c_label_vars *label_vars;
1357 struct c_goto_bindings *g;
1359 if (TREE_CODE (b->decl) != LABEL_DECL)
1361 label_vars = b->u.label;
1362 ++label_vars->label_bindings.stmt_exprs;
1363 FOR_EACH_VEC_ELT (c_goto_bindings_p, label_vars->gotos, ix, g)
1364 ++g->goto_bindings.stmt_exprs;
1368 if (switch_bindings != NULL)
1369 ++switch_bindings->stmt_exprs;
1372 /* Adjust the bindings for the end of a statement expression. */
1375 c_bindings_end_stmt_expr (struct c_spot_bindings *switch_bindings)
1377 struct c_scope *scope;
1379 for (scope = current_scope; scope != NULL; scope = scope->outer)
1381 struct c_binding *b;
1383 if (!scope->has_label_bindings)
1386 for (b = scope->bindings; b != NULL; b = b->prev)
1388 struct c_label_vars *label_vars;
1390 struct c_goto_bindings *g;
1392 if (TREE_CODE (b->decl) != LABEL_DECL)
1394 label_vars = b->u.label;
1395 --label_vars->label_bindings.stmt_exprs;
1396 if (label_vars->label_bindings.stmt_exprs < 0)
1398 label_vars->label_bindings.left_stmt_expr = true;
1399 label_vars->label_bindings.stmt_exprs = 0;
1401 FOR_EACH_VEC_ELT (c_goto_bindings_p, label_vars->gotos, ix, g)
1403 --g->goto_bindings.stmt_exprs;
1404 if (g->goto_bindings.stmt_exprs < 0)
1406 g->goto_bindings.left_stmt_expr = true;
1407 g->goto_bindings.stmt_exprs = 0;
1413 if (switch_bindings != NULL)
1415 --switch_bindings->stmt_exprs;
1416 gcc_assert (switch_bindings->stmt_exprs >= 0);
1420 /* Push a definition or a declaration of struct, union or enum tag "name".
1421 "type" should be the type node.
1422 We assume that the tag "name" is not already defined, and has a location
1425 Note that the definition may really be just a forward reference.
1426 In that case, the TYPE_SIZE will be zero. */
1429 pushtag (location_t loc, tree name, tree type)
1431 /* Record the identifier as the type's name if it has none. */
1432 if (name && !TYPE_NAME (type))
1433 TYPE_NAME (type) = name;
1434 bind (name, type, current_scope, /*invisible=*/false, /*nested=*/false, loc);
1436 /* Create a fake NULL-named TYPE_DECL node whose TREE_TYPE will be the
1437 tagged type we just added to the current scope. This fake
1438 NULL-named TYPE_DECL node helps dwarfout.c to know when it needs
1439 to output a representation of a tagged type, and it also gives
1440 us a convenient place to record the "scope start" address for the
1443 TYPE_STUB_DECL (type) = pushdecl (build_decl (loc,
1444 TYPE_DECL, NULL_TREE, type));
1446 /* An approximation for now, so we can tell this is a function-scope tag.
1447 This will be updated in pop_scope. */
1448 TYPE_CONTEXT (type) = DECL_CONTEXT (TYPE_STUB_DECL (type));
1450 if (warn_cxx_compat && name != NULL_TREE)
1452 struct c_binding *b = I_SYMBOL_BINDING (name);
1455 && b->decl != NULL_TREE
1456 && TREE_CODE (b->decl) == TYPE_DECL
1457 && (B_IN_CURRENT_SCOPE (b)
1458 || (current_scope == file_scope && B_IN_EXTERNAL_SCOPE (b)))
1459 && (TYPE_MAIN_VARIANT (TREE_TYPE (b->decl))
1460 != TYPE_MAIN_VARIANT (type)))
1462 warning_at (loc, OPT_Wc___compat,
1463 ("using %qD as both a typedef and a tag is "
1466 if (b->locus != UNKNOWN_LOCATION)
1467 inform (b->locus, "originally defined here");
1472 /* Subroutine of compare_decls. Allow harmless mismatches in return
1473 and argument types provided that the type modes match. This function
1474 return a unified type given a suitable match, and 0 otherwise. */
1477 match_builtin_function_types (tree newtype, tree oldtype)
1479 tree newrettype, oldrettype;
1480 tree newargs, oldargs;
1481 tree trytype, tryargs;
1483 /* Accept the return type of the new declaration if same modes. */
1484 oldrettype = TREE_TYPE (oldtype);
1485 newrettype = TREE_TYPE (newtype);
1487 if (TYPE_MODE (oldrettype) != TYPE_MODE (newrettype))
1490 oldargs = TYPE_ARG_TYPES (oldtype);
1491 newargs = TYPE_ARG_TYPES (newtype);
1494 while (oldargs || newargs)
1498 || !TREE_VALUE (oldargs)
1499 || !TREE_VALUE (newargs)
1500 || TYPE_MODE (TREE_VALUE (oldargs))
1501 != TYPE_MODE (TREE_VALUE (newargs)))
1504 oldargs = TREE_CHAIN (oldargs);
1505 newargs = TREE_CHAIN (newargs);
1508 trytype = build_function_type (newrettype, tryargs);
1509 return build_type_attribute_variant (trytype, TYPE_ATTRIBUTES (oldtype));
1512 /* Subroutine of diagnose_mismatched_decls. Check for function type
1513 mismatch involving an empty arglist vs a nonempty one and give clearer
1516 diagnose_arglist_conflict (tree newdecl, tree olddecl,
1517 tree newtype, tree oldtype)
1521 if (TREE_CODE (olddecl) != FUNCTION_DECL
1522 || !comptypes (TREE_TYPE (oldtype), TREE_TYPE (newtype))
1523 || !((!prototype_p (oldtype) && DECL_INITIAL (olddecl) == 0)
1524 || (!prototype_p (newtype) && DECL_INITIAL (newdecl) == 0)))
1527 t = TYPE_ARG_TYPES (oldtype);
1529 t = TYPE_ARG_TYPES (newtype);
1530 for (; t; t = TREE_CHAIN (t))
1532 tree type = TREE_VALUE (t);
1534 if (TREE_CHAIN (t) == 0
1535 && TYPE_MAIN_VARIANT (type) != void_type_node)
1537 inform (input_location, "a parameter list with an ellipsis can%'t match "
1538 "an empty parameter name list declaration");
1542 if (c_type_promotes_to (type) != type)
1544 inform (input_location, "an argument type that has a default promotion can%'t match "
1545 "an empty parameter name list declaration");
1551 /* Another subroutine of diagnose_mismatched_decls. OLDDECL is an
1552 old-style function definition, NEWDECL is a prototype declaration.
1553 Diagnose inconsistencies in the argument list. Returns TRUE if
1554 the prototype is compatible, FALSE if not. */
1556 validate_proto_after_old_defn (tree newdecl, tree newtype, tree oldtype)
1558 tree newargs, oldargs;
1561 #define END_OF_ARGLIST(t) ((t) == void_type_node)
1563 oldargs = TYPE_ACTUAL_ARG_TYPES (oldtype);
1564 newargs = TYPE_ARG_TYPES (newtype);
1569 tree oldargtype = TREE_VALUE (oldargs);
1570 tree newargtype = TREE_VALUE (newargs);
1572 if (oldargtype == error_mark_node || newargtype == error_mark_node)
1575 oldargtype = TYPE_MAIN_VARIANT (oldargtype);
1576 newargtype = TYPE_MAIN_VARIANT (newargtype);
1578 if (END_OF_ARGLIST (oldargtype) && END_OF_ARGLIST (newargtype))
1581 /* Reaching the end of just one list means the two decls don't
1582 agree on the number of arguments. */
1583 if (END_OF_ARGLIST (oldargtype))
1585 error ("prototype for %q+D declares more arguments "
1586 "than previous old-style definition", newdecl);
1589 else if (END_OF_ARGLIST (newargtype))
1591 error ("prototype for %q+D declares fewer arguments "
1592 "than previous old-style definition", newdecl);
1596 /* Type for passing arg must be consistent with that declared
1598 else if (!comptypes (oldargtype, newargtype))
1600 error ("prototype for %q+D declares argument %d"
1601 " with incompatible type",
1606 oldargs = TREE_CHAIN (oldargs);
1607 newargs = TREE_CHAIN (newargs);
1611 /* If we get here, no errors were found, but do issue a warning
1612 for this poor-style construct. */
1613 warning (0, "prototype for %q+D follows non-prototype definition",
1616 #undef END_OF_ARGLIST
1619 /* Subroutine of diagnose_mismatched_decls. Report the location of DECL,
1620 first in a pair of mismatched declarations, using the diagnostic
1623 locate_old_decl (tree decl)
1625 if (TREE_CODE (decl) == FUNCTION_DECL && DECL_BUILT_IN (decl))
1627 else if (DECL_INITIAL (decl))
1628 inform (input_location, "previous definition of %q+D was here", decl);
1629 else if (C_DECL_IMPLICIT (decl))
1630 inform (input_location, "previous implicit declaration of %q+D was here", decl);
1632 inform (input_location, "previous declaration of %q+D was here", decl);
1635 /* Subroutine of duplicate_decls. Compare NEWDECL to OLDDECL.
1636 Returns true if the caller should proceed to merge the two, false
1637 if OLDDECL should simply be discarded. As a side effect, issues
1638 all necessary diagnostics for invalid or poor-style combinations.
1639 If it returns true, writes the types of NEWDECL and OLDDECL to
1640 *NEWTYPEP and *OLDTYPEP - these may have been adjusted from
1641 TREE_TYPE (NEWDECL, OLDDECL) respectively. */
1644 diagnose_mismatched_decls (tree newdecl, tree olddecl,
1645 tree *newtypep, tree *oldtypep)
1647 tree newtype, oldtype;
1648 bool pedwarned = false;
1649 bool warned = false;
1652 #define DECL_EXTERN_INLINE(DECL) (DECL_DECLARED_INLINE_P (DECL) \
1653 && DECL_EXTERNAL (DECL))
1655 /* If we have error_mark_node for either decl or type, just discard
1656 the previous decl - we're in an error cascade already. */
1657 if (olddecl == error_mark_node || newdecl == error_mark_node)
1659 *oldtypep = oldtype = TREE_TYPE (olddecl);
1660 *newtypep = newtype = TREE_TYPE (newdecl);
1661 if (oldtype == error_mark_node || newtype == error_mark_node)
1664 /* Two different categories of symbol altogether. This is an error
1665 unless OLDDECL is a builtin. OLDDECL will be discarded in any case. */
1666 if (TREE_CODE (olddecl) != TREE_CODE (newdecl))
1668 if (!(TREE_CODE (olddecl) == FUNCTION_DECL
1669 && DECL_BUILT_IN (olddecl)
1670 && !C_DECL_DECLARED_BUILTIN (olddecl)))
1672 error ("%q+D redeclared as different kind of symbol", newdecl);
1673 locate_old_decl (olddecl);
1675 else if (TREE_PUBLIC (newdecl))
1676 warning (0, "built-in function %q+D declared as non-function",
1679 warning (OPT_Wshadow, "declaration of %q+D shadows "
1680 "a built-in function", newdecl);
1684 /* Enumerators have no linkage, so may only be declared once in a
1686 if (TREE_CODE (olddecl) == CONST_DECL)
1688 error ("redeclaration of enumerator %q+D", newdecl);
1689 locate_old_decl (olddecl);
1693 if (!comptypes (oldtype, newtype))
1695 if (TREE_CODE (olddecl) == FUNCTION_DECL
1696 && DECL_BUILT_IN (olddecl) && !C_DECL_DECLARED_BUILTIN (olddecl))
1698 /* Accept harmless mismatch in function types.
1699 This is for the ffs and fprintf builtins. */
1700 tree trytype = match_builtin_function_types (newtype, oldtype);
1702 if (trytype && comptypes (newtype, trytype))
1703 *oldtypep = oldtype = trytype;
1706 /* If types don't match for a built-in, throw away the
1707 built-in. No point in calling locate_old_decl here, it
1708 won't print anything. */
1709 warning (0, "conflicting types for built-in function %q+D",
1714 else if (TREE_CODE (olddecl) == FUNCTION_DECL
1715 && DECL_IS_BUILTIN (olddecl))
1717 /* A conflicting function declaration for a predeclared
1718 function that isn't actually built in. Objective C uses
1719 these. The new declaration silently overrides everything
1720 but the volatility (i.e. noreturn) indication. See also
1721 below. FIXME: Make Objective C use normal builtins. */
1722 TREE_THIS_VOLATILE (newdecl) |= TREE_THIS_VOLATILE (olddecl);
1725 /* Permit void foo (...) to match int foo (...) if the latter is
1726 the definition and implicit int was used. See
1727 c-torture/compile/920625-2.c. */
1728 else if (TREE_CODE (newdecl) == FUNCTION_DECL && DECL_INITIAL (newdecl)
1729 && TYPE_MAIN_VARIANT (TREE_TYPE (oldtype)) == void_type_node
1730 && TYPE_MAIN_VARIANT (TREE_TYPE (newtype)) == integer_type_node
1731 && C_FUNCTION_IMPLICIT_INT (newdecl) && !DECL_INITIAL (olddecl))
1733 pedwarned = pedwarn (input_location, 0,
1734 "conflicting types for %q+D", newdecl);
1735 /* Make sure we keep void as the return type. */
1736 TREE_TYPE (newdecl) = *newtypep = newtype = oldtype;
1737 C_FUNCTION_IMPLICIT_INT (newdecl) = 0;
1739 /* Permit void foo (...) to match an earlier call to foo (...) with
1740 no declared type (thus, implicitly int). */
1741 else if (TREE_CODE (newdecl) == FUNCTION_DECL
1742 && TYPE_MAIN_VARIANT (TREE_TYPE (newtype)) == void_type_node
1743 && TYPE_MAIN_VARIANT (TREE_TYPE (oldtype)) == integer_type_node
1744 && C_DECL_IMPLICIT (olddecl) && !DECL_INITIAL (olddecl))
1746 pedwarned = pedwarn (input_location, 0,
1747 "conflicting types for %q+D", newdecl);
1748 /* Make sure we keep void as the return type. */
1749 TREE_TYPE (olddecl) = *oldtypep = oldtype = newtype;
1753 int new_quals = TYPE_QUALS (newtype);
1754 int old_quals = TYPE_QUALS (oldtype);
1756 if (new_quals != old_quals)
1758 addr_space_t new_addr = DECODE_QUAL_ADDR_SPACE (new_quals);
1759 addr_space_t old_addr = DECODE_QUAL_ADDR_SPACE (old_quals);
1760 if (new_addr != old_addr)
1762 if (ADDR_SPACE_GENERIC_P (new_addr))
1763 error ("conflicting named address spaces (generic vs %s) "
1765 c_addr_space_name (old_addr), newdecl);
1766 else if (ADDR_SPACE_GENERIC_P (old_addr))
1767 error ("conflicting named address spaces (%s vs generic) "
1769 c_addr_space_name (new_addr), newdecl);
1771 error ("conflicting named address spaces (%s vs %s) "
1773 c_addr_space_name (new_addr),
1774 c_addr_space_name (old_addr),
1778 if (CLEAR_QUAL_ADDR_SPACE (new_quals)
1779 != CLEAR_QUAL_ADDR_SPACE (old_quals))
1780 error ("conflicting type qualifiers for %q+D", newdecl);
1783 error ("conflicting types for %q+D", newdecl);
1784 diagnose_arglist_conflict (newdecl, olddecl, newtype, oldtype);
1785 locate_old_decl (olddecl);
1790 /* Redeclaration of a type is a constraint violation (6.7.2.3p1),
1791 but silently ignore the redeclaration if either is in a system
1792 header. (Conflicting redeclarations were handled above.) This
1793 is allowed for C1X if the types are the same, not just
1795 if (TREE_CODE (newdecl) == TYPE_DECL)
1797 bool types_different = false;
1798 int comptypes_result;
1801 = comptypes_check_different_types (oldtype, newtype, &types_different);
1803 if (comptypes_result != 1 || types_different)
1805 error ("redefinition of typedef %q+D with different type", newdecl);
1806 locate_old_decl (olddecl);
1810 if (DECL_IN_SYSTEM_HEADER (newdecl)
1811 || DECL_IN_SYSTEM_HEADER (olddecl)
1812 || TREE_NO_WARNING (newdecl)
1813 || TREE_NO_WARNING (olddecl))
1814 return true; /* Allow OLDDECL to continue in use. */
1816 if (variably_modified_type_p (newtype, NULL))
1818 error ("redefinition of typedef %q+D with variably modified type",
1820 locate_old_decl (olddecl);
1822 else if (pedantic && !flag_isoc1x)
1824 pedwarn (input_location, OPT_pedantic,
1825 "redefinition of typedef %q+D", newdecl);
1826 locate_old_decl (olddecl);
1832 /* Function declarations can either be 'static' or 'extern' (no
1833 qualifier is equivalent to 'extern' - C99 6.2.2p5) and therefore
1834 can never conflict with each other on account of linkage
1835 (6.2.2p4). Multiple definitions are not allowed (6.9p3,5) but
1836 gnu89 mode permits two definitions if one is 'extern inline' and
1837 one is not. The non- extern-inline definition supersedes the
1838 extern-inline definition. */
1840 else if (TREE_CODE (newdecl) == FUNCTION_DECL)
1842 /* If you declare a built-in function name as static, or
1843 define the built-in with an old-style definition (so we
1844 can't validate the argument list) the built-in definition is
1845 overridden, but optionally warn this was a bad choice of name. */
1846 if (DECL_BUILT_IN (olddecl)
1847 && !C_DECL_DECLARED_BUILTIN (olddecl)
1848 && (!TREE_PUBLIC (newdecl)
1849 || (DECL_INITIAL (newdecl)
1850 && !prototype_p (TREE_TYPE (newdecl)))))
1852 warning (OPT_Wshadow, "declaration of %q+D shadows "
1853 "a built-in function", newdecl);
1854 /* Discard the old built-in function. */
1858 if (DECL_INITIAL (newdecl))
1860 if (DECL_INITIAL (olddecl))
1862 /* If both decls are in the same TU and the new declaration
1863 isn't overriding an extern inline reject the new decl.
1864 In c99, no overriding is allowed in the same translation
1866 if ((!DECL_EXTERN_INLINE (olddecl)
1867 || DECL_EXTERN_INLINE (newdecl)
1868 || (!flag_gnu89_inline
1869 && (!DECL_DECLARED_INLINE_P (olddecl)
1870 || !lookup_attribute ("gnu_inline",
1871 DECL_ATTRIBUTES (olddecl)))
1872 && (!DECL_DECLARED_INLINE_P (newdecl)
1873 || !lookup_attribute ("gnu_inline",
1874 DECL_ATTRIBUTES (newdecl))))
1876 && same_translation_unit_p (newdecl, olddecl))
1878 error ("redefinition of %q+D", newdecl);
1879 locate_old_decl (olddecl);
1884 /* If we have a prototype after an old-style function definition,
1885 the argument types must be checked specially. */
1886 else if (DECL_INITIAL (olddecl)
1887 && !prototype_p (oldtype) && prototype_p (newtype)
1888 && TYPE_ACTUAL_ARG_TYPES (oldtype)
1889 && !validate_proto_after_old_defn (newdecl, newtype, oldtype))
1891 locate_old_decl (olddecl);
1894 /* A non-static declaration (even an "extern") followed by a
1895 static declaration is undefined behavior per C99 6.2.2p3-5,7.
1896 The same is true for a static forward declaration at block
1897 scope followed by a non-static declaration/definition at file
1898 scope. Static followed by non-static at the same scope is
1899 not undefined behavior, and is the most convenient way to get
1900 some effects (see e.g. what unwind-dw2-fde-glibc.c does to
1901 the definition of _Unwind_Find_FDE in unwind-dw2-fde.c), but
1902 we do diagnose it if -Wtraditional. */
1903 if (TREE_PUBLIC (olddecl) && !TREE_PUBLIC (newdecl))
1905 /* Two exceptions to the rule. If olddecl is an extern
1906 inline, or a predeclared function that isn't actually
1907 built in, newdecl silently overrides olddecl. The latter
1908 occur only in Objective C; see also above. (FIXME: Make
1909 Objective C use normal builtins.) */
1910 if (!DECL_IS_BUILTIN (olddecl)
1911 && !DECL_EXTERN_INLINE (olddecl))
1913 error ("static declaration of %q+D follows "
1914 "non-static declaration", newdecl);
1915 locate_old_decl (olddecl);
1919 else if (TREE_PUBLIC (newdecl) && !TREE_PUBLIC (olddecl))
1921 if (DECL_CONTEXT (olddecl))
1923 error ("non-static declaration of %q+D follows "
1924 "static declaration", newdecl);
1925 locate_old_decl (olddecl);
1928 else if (warn_traditional)
1930 warned |= warning (OPT_Wtraditional,
1931 "non-static declaration of %q+D "
1932 "follows static declaration", newdecl);
1936 /* Make sure gnu_inline attribute is either not present, or
1937 present on all inline decls. */
1938 if (DECL_DECLARED_INLINE_P (olddecl)
1939 && DECL_DECLARED_INLINE_P (newdecl))
1941 bool newa = lookup_attribute ("gnu_inline",
1942 DECL_ATTRIBUTES (newdecl)) != NULL;
1943 bool olda = lookup_attribute ("gnu_inline",
1944 DECL_ATTRIBUTES (olddecl)) != NULL;
1947 error_at (input_location, "%<gnu_inline%> attribute present on %q+D",
1948 newa ? newdecl : olddecl);
1949 error_at (DECL_SOURCE_LOCATION (newa ? olddecl : newdecl),
1954 else if (TREE_CODE (newdecl) == VAR_DECL)
1956 /* Only variables can be thread-local, and all declarations must
1957 agree on this property. */
1958 if (C_DECL_THREADPRIVATE_P (olddecl) && !DECL_THREAD_LOCAL_P (newdecl))
1960 /* Nothing to check. Since OLDDECL is marked threadprivate
1961 and NEWDECL does not have a thread-local attribute, we
1962 will merge the threadprivate attribute into NEWDECL. */
1965 else if (DECL_THREAD_LOCAL_P (newdecl) != DECL_THREAD_LOCAL_P (olddecl))
1967 if (DECL_THREAD_LOCAL_P (newdecl))
1968 error ("thread-local declaration of %q+D follows "
1969 "non-thread-local declaration", newdecl);
1971 error ("non-thread-local declaration of %q+D follows "
1972 "thread-local declaration", newdecl);
1974 locate_old_decl (olddecl);
1978 /* Multiple initialized definitions are not allowed (6.9p3,5). */
1979 if (DECL_INITIAL (newdecl) && DECL_INITIAL (olddecl))
1981 error ("redefinition of %q+D", newdecl);
1982 locate_old_decl (olddecl);
1986 /* Objects declared at file scope: if the first declaration had
1987 external linkage (even if it was an external reference) the
1988 second must have external linkage as well, or the behavior is
1989 undefined. If the first declaration had internal linkage, then
1990 the second must too, or else be an external reference (in which
1991 case the composite declaration still has internal linkage).
1992 As for function declarations, we warn about the static-then-
1993 extern case only for -Wtraditional. See generally 6.2.2p3-5,7. */
1994 if (DECL_FILE_SCOPE_P (newdecl)
1995 && TREE_PUBLIC (newdecl) != TREE_PUBLIC (olddecl))
1997 if (DECL_EXTERNAL (newdecl))
1999 if (!DECL_FILE_SCOPE_P (olddecl))
2001 error ("extern declaration of %q+D follows "
2002 "declaration with no linkage", newdecl);
2003 locate_old_decl (olddecl);
2006 else if (warn_traditional)
2008 warned |= warning (OPT_Wtraditional,
2009 "non-static declaration of %q+D "
2010 "follows static declaration", newdecl);
2015 if (TREE_PUBLIC (newdecl))
2016 error ("non-static declaration of %q+D follows "
2017 "static declaration", newdecl);
2019 error ("static declaration of %q+D follows "
2020 "non-static declaration", newdecl);
2022 locate_old_decl (olddecl);
2026 /* Two objects with the same name declared at the same block
2027 scope must both be external references (6.7p3). */
2028 else if (!DECL_FILE_SCOPE_P (newdecl))
2030 if (DECL_EXTERNAL (newdecl))
2032 /* Extern with initializer at block scope, which will
2033 already have received an error. */
2035 else if (DECL_EXTERNAL (olddecl))
2037 error ("declaration of %q+D with no linkage follows "
2038 "extern declaration", newdecl);
2039 locate_old_decl (olddecl);
2043 error ("redeclaration of %q+D with no linkage", newdecl);
2044 locate_old_decl (olddecl);
2050 /* C++ does not permit a decl to appear multiple times at file
2053 && DECL_FILE_SCOPE_P (newdecl)
2054 && !DECL_EXTERNAL (newdecl)
2055 && !DECL_EXTERNAL (olddecl))
2056 warned |= warning_at (DECL_SOURCE_LOCATION (newdecl),
2058 ("duplicate declaration of %qD is "
2064 /* All decls must agree on a visibility. */
2065 if (CODE_CONTAINS_STRUCT (TREE_CODE (newdecl), TS_DECL_WITH_VIS)
2066 && DECL_VISIBILITY_SPECIFIED (newdecl) && DECL_VISIBILITY_SPECIFIED (olddecl)
2067 && DECL_VISIBILITY (newdecl) != DECL_VISIBILITY (olddecl))
2069 warned |= warning (0, "redeclaration of %q+D with different visibility "
2070 "(old visibility preserved)", newdecl);
2073 if (TREE_CODE (newdecl) == FUNCTION_DECL)
2075 /* Diagnose inline __attribute__ ((noinline)) which is silly. */
2076 if (DECL_DECLARED_INLINE_P (newdecl)
2077 && lookup_attribute ("noinline", DECL_ATTRIBUTES (olddecl)))
2079 warned |= warning (OPT_Wattributes,
2080 "inline declaration of %qD follows "
2081 "declaration with attribute noinline", newdecl);
2083 else if (DECL_DECLARED_INLINE_P (olddecl)
2084 && lookup_attribute ("noinline", DECL_ATTRIBUTES (newdecl)))
2086 warned |= warning (OPT_Wattributes,
2087 "declaration of %q+D with attribute "
2088 "noinline follows inline declaration ", newdecl);
2091 else /* PARM_DECL, VAR_DECL */
2093 /* Redeclaration of a parameter is a constraint violation (this is
2094 not explicitly stated, but follows from C99 6.7p3 [no more than
2095 one declaration of the same identifier with no linkage in the
2096 same scope, except type tags] and 6.2.2p6 [parameters have no
2097 linkage]). We must check for a forward parameter declaration,
2098 indicated by TREE_ASM_WRITTEN on the old declaration - this is
2099 an extension, the mandatory diagnostic for which is handled by
2100 mark_forward_parm_decls. */
2102 if (TREE_CODE (newdecl) == PARM_DECL
2103 && (!TREE_ASM_WRITTEN (olddecl) || TREE_ASM_WRITTEN (newdecl)))
2105 error ("redefinition of parameter %q+D", newdecl);
2106 locate_old_decl (olddecl);
2111 /* Optional warning for completely redundant decls. */
2112 if (!warned && !pedwarned
2113 && warn_redundant_decls
2114 /* Don't warn about a function declaration followed by a
2116 && !(TREE_CODE (newdecl) == FUNCTION_DECL
2117 && DECL_INITIAL (newdecl) && !DECL_INITIAL (olddecl))
2118 /* Don't warn about redundant redeclarations of builtins. */
2119 && !(TREE_CODE (newdecl) == FUNCTION_DECL
2120 && !DECL_BUILT_IN (newdecl)
2121 && DECL_BUILT_IN (olddecl)
2122 && !C_DECL_DECLARED_BUILTIN (olddecl))
2123 /* Don't warn about an extern followed by a definition. */
2124 && !(DECL_EXTERNAL (olddecl) && !DECL_EXTERNAL (newdecl))
2125 /* Don't warn about forward parameter decls. */
2126 && !(TREE_CODE (newdecl) == PARM_DECL
2127 && TREE_ASM_WRITTEN (olddecl) && !TREE_ASM_WRITTEN (newdecl))
2128 /* Don't warn about a variable definition following a declaration. */
2129 && !(TREE_CODE (newdecl) == VAR_DECL
2130 && DECL_INITIAL (newdecl) && !DECL_INITIAL (olddecl)))
2132 warned = warning (OPT_Wredundant_decls, "redundant redeclaration of %q+D",
2136 /* Report location of previous decl/defn. */
2137 if (warned || pedwarned)
2138 locate_old_decl (olddecl);
2140 #undef DECL_EXTERN_INLINE
2145 /* Subroutine of duplicate_decls. NEWDECL has been found to be
2146 consistent with OLDDECL, but carries new information. Merge the
2147 new information into OLDDECL. This function issues no
2151 merge_decls (tree newdecl, tree olddecl, tree newtype, tree oldtype)
2153 bool new_is_definition = (TREE_CODE (newdecl) == FUNCTION_DECL
2154 && DECL_INITIAL (newdecl) != 0);
2155 bool new_is_prototype = (TREE_CODE (newdecl) == FUNCTION_DECL
2156 && prototype_p (TREE_TYPE (newdecl)));
2157 bool old_is_prototype = (TREE_CODE (olddecl) == FUNCTION_DECL
2158 && prototype_p (TREE_TYPE (olddecl)));
2159 bool extern_changed = false;
2161 /* For real parm decl following a forward decl, rechain the old decl
2162 in its new location and clear TREE_ASM_WRITTEN (it's not a
2163 forward decl anymore). */
2164 if (TREE_CODE (newdecl) == PARM_DECL
2165 && TREE_ASM_WRITTEN (olddecl) && !TREE_ASM_WRITTEN (newdecl))
2167 struct c_binding *b, **here;
2169 for (here = ¤t_scope->bindings; *here; here = &(*here)->prev)
2170 if ((*here)->decl == olddecl)
2177 b->prev = current_scope->bindings;
2178 current_scope->bindings = b;
2180 TREE_ASM_WRITTEN (olddecl) = 0;
2183 DECL_ATTRIBUTES (newdecl)
2184 = targetm.merge_decl_attributes (olddecl, newdecl);
2186 /* Merge the data types specified in the two decls. */
2188 = TREE_TYPE (olddecl)
2189 = composite_type (newtype, oldtype);
2191 /* Lay the type out, unless already done. */
2192 if (!comptypes (oldtype, TREE_TYPE (newdecl)))
2194 if (TREE_TYPE (newdecl) != error_mark_node)
2195 layout_type (TREE_TYPE (newdecl));
2196 if (TREE_CODE (newdecl) != FUNCTION_DECL
2197 && TREE_CODE (newdecl) != TYPE_DECL
2198 && TREE_CODE (newdecl) != CONST_DECL)
2199 layout_decl (newdecl, 0);
2203 /* Since the type is OLDDECL's, make OLDDECL's size go with. */
2204 DECL_SIZE (newdecl) = DECL_SIZE (olddecl);
2205 DECL_SIZE_UNIT (newdecl) = DECL_SIZE_UNIT (olddecl);
2206 DECL_MODE (newdecl) = DECL_MODE (olddecl);
2207 if (DECL_ALIGN (olddecl) > DECL_ALIGN (newdecl))
2209 DECL_ALIGN (newdecl) = DECL_ALIGN (olddecl);
2210 DECL_USER_ALIGN (newdecl) |= DECL_USER_ALIGN (olddecl);
2214 /* Keep the old rtl since we can safely use it. */
2215 if (HAS_RTL_P (olddecl))
2216 COPY_DECL_RTL (olddecl, newdecl);
2218 /* Merge the type qualifiers. */
2219 if (TREE_READONLY (newdecl))
2220 TREE_READONLY (olddecl) = 1;
2222 if (TREE_THIS_VOLATILE (newdecl))
2223 TREE_THIS_VOLATILE (olddecl) = 1;
2225 /* Merge deprecatedness. */
2226 if (TREE_DEPRECATED (newdecl))
2227 TREE_DEPRECATED (olddecl) = 1;
2229 /* If a decl is in a system header and the other isn't, keep the one on the
2230 system header. Otherwise, keep source location of definition rather than
2231 declaration and of prototype rather than non-prototype unless that
2232 prototype is built-in. */
2233 if (CODE_CONTAINS_STRUCT (TREE_CODE (olddecl), TS_DECL_WITH_VIS)
2234 && DECL_IN_SYSTEM_HEADER (olddecl)
2235 && !DECL_IN_SYSTEM_HEADER (newdecl) )
2236 DECL_SOURCE_LOCATION (newdecl) = DECL_SOURCE_LOCATION (olddecl);
2237 else if (CODE_CONTAINS_STRUCT (TREE_CODE (olddecl), TS_DECL_WITH_VIS)
2238 && DECL_IN_SYSTEM_HEADER (newdecl)
2239 && !DECL_IN_SYSTEM_HEADER (olddecl))
2240 DECL_SOURCE_LOCATION (olddecl) = DECL_SOURCE_LOCATION (newdecl);
2241 else if ((DECL_INITIAL (newdecl) == 0 && DECL_INITIAL (olddecl) != 0)
2242 || (old_is_prototype && !new_is_prototype
2243 && !C_DECL_BUILTIN_PROTOTYPE (olddecl)))
2244 DECL_SOURCE_LOCATION (newdecl) = DECL_SOURCE_LOCATION (olddecl);
2246 /* Merge the initialization information. */
2247 if (DECL_INITIAL (newdecl) == 0)
2248 DECL_INITIAL (newdecl) = DECL_INITIAL (olddecl);
2250 /* Merge the threadprivate attribute. */
2251 if (TREE_CODE (olddecl) == VAR_DECL && C_DECL_THREADPRIVATE_P (olddecl))
2253 DECL_TLS_MODEL (newdecl) = DECL_TLS_MODEL (olddecl);
2254 C_DECL_THREADPRIVATE_P (newdecl) = 1;
2257 if (CODE_CONTAINS_STRUCT (TREE_CODE (olddecl), TS_DECL_WITH_VIS))
2259 /* Merge the section attribute.
2260 We want to issue an error if the sections conflict but that
2261 must be done later in decl_attributes since we are called
2262 before attributes are assigned. */
2263 if (DECL_SECTION_NAME (newdecl) == NULL_TREE)
2264 DECL_SECTION_NAME (newdecl) = DECL_SECTION_NAME (olddecl);
2266 /* Copy the assembler name.
2267 Currently, it can only be defined in the prototype. */
2268 COPY_DECL_ASSEMBLER_NAME (olddecl, newdecl);
2270 /* Use visibility of whichever declaration had it specified */
2271 if (DECL_VISIBILITY_SPECIFIED (olddecl))
2273 DECL_VISIBILITY (newdecl) = DECL_VISIBILITY (olddecl);
2274 DECL_VISIBILITY_SPECIFIED (newdecl) = 1;
2277 if (TREE_CODE (newdecl) == FUNCTION_DECL)
2279 DECL_STATIC_CONSTRUCTOR(newdecl) |= DECL_STATIC_CONSTRUCTOR(olddecl);
2280 DECL_STATIC_DESTRUCTOR (newdecl) |= DECL_STATIC_DESTRUCTOR (olddecl);
2281 DECL_NO_LIMIT_STACK (newdecl) |= DECL_NO_LIMIT_STACK (olddecl);
2282 DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (newdecl)
2283 |= DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (olddecl);
2284 TREE_THIS_VOLATILE (newdecl) |= TREE_THIS_VOLATILE (olddecl);
2285 DECL_IS_MALLOC (newdecl) |= DECL_IS_MALLOC (olddecl);
2286 DECL_IS_OPERATOR_NEW (newdecl) |= DECL_IS_OPERATOR_NEW (olddecl);
2287 TREE_READONLY (newdecl) |= TREE_READONLY (olddecl);
2288 DECL_PURE_P (newdecl) |= DECL_PURE_P (olddecl);
2289 DECL_IS_NOVOPS (newdecl) |= DECL_IS_NOVOPS (olddecl);
2292 /* Merge the storage class information. */
2293 merge_weak (newdecl, olddecl);
2295 /* For functions, static overrides non-static. */
2296 if (TREE_CODE (newdecl) == FUNCTION_DECL)
2298 TREE_PUBLIC (newdecl) &= TREE_PUBLIC (olddecl);
2299 /* This is since we don't automatically
2300 copy the attributes of NEWDECL into OLDDECL. */
2301 TREE_PUBLIC (olddecl) = TREE_PUBLIC (newdecl);
2302 /* If this clears `static', clear it in the identifier too. */
2303 if (!TREE_PUBLIC (olddecl))
2304 TREE_PUBLIC (DECL_NAME (olddecl)) = 0;
2308 /* In c99, 'extern' declaration before (or after) 'inline' means this
2309 function is not DECL_EXTERNAL, unless 'gnu_inline' attribute
2311 if (TREE_CODE (newdecl) == FUNCTION_DECL
2312 && !flag_gnu89_inline
2313 && (DECL_DECLARED_INLINE_P (newdecl)
2314 || DECL_DECLARED_INLINE_P (olddecl))
2315 && (!DECL_DECLARED_INLINE_P (newdecl)
2316 || !DECL_DECLARED_INLINE_P (olddecl)
2317 || !DECL_EXTERNAL (olddecl))
2318 && DECL_EXTERNAL (newdecl)
2319 && !lookup_attribute ("gnu_inline", DECL_ATTRIBUTES (newdecl))
2320 && !current_function_decl)
2321 DECL_EXTERNAL (newdecl) = 0;
2323 if (DECL_EXTERNAL (newdecl))
2325 TREE_STATIC (newdecl) = TREE_STATIC (olddecl);
2326 DECL_EXTERNAL (newdecl) = DECL_EXTERNAL (olddecl);
2328 /* An extern decl does not override previous storage class. */
2329 TREE_PUBLIC (newdecl) = TREE_PUBLIC (olddecl);
2330 if (!DECL_EXTERNAL (newdecl))
2332 DECL_CONTEXT (newdecl) = DECL_CONTEXT (olddecl);
2333 DECL_COMMON (newdecl) = DECL_COMMON (olddecl);
2338 TREE_STATIC (olddecl) = TREE_STATIC (newdecl);
2339 TREE_PUBLIC (olddecl) = TREE_PUBLIC (newdecl);
2342 if (TREE_CODE (newdecl) == FUNCTION_DECL)
2344 /* If we're redefining a function previously defined as extern
2345 inline, make sure we emit debug info for the inline before we
2346 throw it away, in case it was inlined into a function that
2347 hasn't been written out yet. */
2348 if (new_is_definition && DECL_INITIAL (olddecl))
2349 /* The new defn must not be inline. */
2350 DECL_UNINLINABLE (newdecl) = 1;
2353 /* If either decl says `inline', this fn is inline, unless
2354 its definition was passed already. */
2355 if (DECL_DECLARED_INLINE_P (newdecl)
2356 || DECL_DECLARED_INLINE_P (olddecl))
2357 DECL_DECLARED_INLINE_P (newdecl) = 1;
2359 DECL_UNINLINABLE (newdecl) = DECL_UNINLINABLE (olddecl)
2360 = (DECL_UNINLINABLE (newdecl) || DECL_UNINLINABLE (olddecl));
2362 DECL_DISREGARD_INLINE_LIMITS (newdecl)
2363 = DECL_DISREGARD_INLINE_LIMITS (olddecl)
2364 = (DECL_DISREGARD_INLINE_LIMITS (newdecl)
2365 || DECL_DISREGARD_INLINE_LIMITS (olddecl));
2368 if (DECL_BUILT_IN (olddecl))
2370 /* If redeclaring a builtin function, it stays built in.
2371 But it gets tagged as having been declared. */
2372 DECL_BUILT_IN_CLASS (newdecl) = DECL_BUILT_IN_CLASS (olddecl);
2373 DECL_FUNCTION_CODE (newdecl) = DECL_FUNCTION_CODE (olddecl);
2374 C_DECL_DECLARED_BUILTIN (newdecl) = 1;
2375 if (new_is_prototype)
2376 C_DECL_BUILTIN_PROTOTYPE (newdecl) = 0;
2378 C_DECL_BUILTIN_PROTOTYPE (newdecl)
2379 = C_DECL_BUILTIN_PROTOTYPE (olddecl);
2382 /* Preserve function specific target and optimization options */
2383 if (DECL_FUNCTION_SPECIFIC_TARGET (olddecl)
2384 && !DECL_FUNCTION_SPECIFIC_TARGET (newdecl))
2385 DECL_FUNCTION_SPECIFIC_TARGET (newdecl)
2386 = DECL_FUNCTION_SPECIFIC_TARGET (olddecl);
2388 if (DECL_FUNCTION_SPECIFIC_OPTIMIZATION (olddecl)
2389 && !DECL_FUNCTION_SPECIFIC_OPTIMIZATION (newdecl))
2390 DECL_FUNCTION_SPECIFIC_OPTIMIZATION (newdecl)
2391 = DECL_FUNCTION_SPECIFIC_OPTIMIZATION (olddecl);
2393 /* Also preserve various other info from the definition. */
2394 if (!new_is_definition)
2397 DECL_RESULT (newdecl) = DECL_RESULT (olddecl);
2398 DECL_INITIAL (newdecl) = DECL_INITIAL (olddecl);
2399 DECL_STRUCT_FUNCTION (newdecl) = DECL_STRUCT_FUNCTION (olddecl);
2400 DECL_SAVED_TREE (newdecl) = DECL_SAVED_TREE (olddecl);
2401 DECL_ARGUMENTS (newdecl) = copy_list (DECL_ARGUMENTS (olddecl));
2402 for (t = DECL_ARGUMENTS (newdecl); t ; t = DECL_CHAIN (t))
2403 DECL_CONTEXT (t) = newdecl;
2405 /* See if we've got a function to instantiate from. */
2406 if (DECL_SAVED_TREE (olddecl))
2407 DECL_ABSTRACT_ORIGIN (newdecl)
2408 = DECL_ABSTRACT_ORIGIN (olddecl);
2412 extern_changed = DECL_EXTERNAL (olddecl) && !DECL_EXTERNAL (newdecl);
2414 /* Merge the USED information. */
2415 if (TREE_USED (olddecl))
2416 TREE_USED (newdecl) = 1;
2417 else if (TREE_USED (newdecl))
2418 TREE_USED (olddecl) = 1;
2419 if (TREE_CODE (olddecl) == VAR_DECL || TREE_CODE (olddecl) == PARM_DECL)
2420 DECL_READ_P (newdecl) |= DECL_READ_P (olddecl);
2421 if (DECL_PRESERVE_P (olddecl))
2422 DECL_PRESERVE_P (newdecl) = 1;
2423 else if (DECL_PRESERVE_P (newdecl))
2424 DECL_PRESERVE_P (olddecl) = 1;
2426 /* Copy most of the decl-specific fields of NEWDECL into OLDDECL.
2427 But preserve OLDDECL's DECL_UID, DECL_CONTEXT and
2428 DECL_ARGUMENTS (if appropriate). */
2430 unsigned olddecl_uid = DECL_UID (olddecl);
2431 tree olddecl_context = DECL_CONTEXT (olddecl);
2432 tree olddecl_arguments = NULL;
2433 if (TREE_CODE (olddecl) == FUNCTION_DECL)
2434 olddecl_arguments = DECL_ARGUMENTS (olddecl);
2436 memcpy ((char *) olddecl + sizeof (struct tree_common),
2437 (char *) newdecl + sizeof (struct tree_common),
2438 sizeof (struct tree_decl_common) - sizeof (struct tree_common));
2439 DECL_USER_ALIGN (olddecl) = DECL_USER_ALIGN (newdecl);
2440 switch (TREE_CODE (olddecl))
2450 memcpy ((char *) olddecl + sizeof (struct tree_decl_common),
2451 (char *) newdecl + sizeof (struct tree_decl_common),
2452 tree_code_size (TREE_CODE (olddecl)) - sizeof (struct tree_decl_common));
2457 memcpy ((char *) olddecl + sizeof (struct tree_decl_common),
2458 (char *) newdecl + sizeof (struct tree_decl_common),
2459 sizeof (struct tree_decl_non_common) - sizeof (struct tree_decl_common));
2461 DECL_UID (olddecl) = olddecl_uid;
2462 DECL_CONTEXT (olddecl) = olddecl_context;
2463 if (TREE_CODE (olddecl) == FUNCTION_DECL)
2464 DECL_ARGUMENTS (olddecl) = olddecl_arguments;
2467 /* If OLDDECL had its DECL_RTL instantiated, re-invoke make_decl_rtl
2468 so that encode_section_info has a chance to look at the new decl
2469 flags and attributes. */
2470 if (DECL_RTL_SET_P (olddecl)
2471 && (TREE_CODE (olddecl) == FUNCTION_DECL
2472 || (TREE_CODE (olddecl) == VAR_DECL
2473 && TREE_STATIC (olddecl))))
2474 make_decl_rtl (olddecl);
2476 /* If we changed a function from DECL_EXTERNAL to !DECL_EXTERNAL,
2477 and the definition is coming from the old version, cgraph needs
2478 to be called again. */
2479 if (extern_changed && !new_is_definition
2480 && TREE_CODE (olddecl) == FUNCTION_DECL && DECL_INITIAL (olddecl))
2481 cgraph_mark_if_needed (olddecl);
2484 /* Handle when a new declaration NEWDECL has the same name as an old
2485 one OLDDECL in the same binding contour. Prints an error message
2488 If safely possible, alter OLDDECL to look like NEWDECL, and return
2489 true. Otherwise, return false. */
2492 duplicate_decls (tree newdecl, tree olddecl)
2494 tree newtype = NULL, oldtype = NULL;
2496 if (!diagnose_mismatched_decls (newdecl, olddecl, &newtype, &oldtype))
2498 /* Avoid `unused variable' and other warnings for OLDDECL. */
2499 TREE_NO_WARNING (olddecl) = 1;
2503 merge_decls (newdecl, olddecl, newtype, oldtype);
2508 /* Check whether decl-node NEW_DECL shadows an existing declaration. */
2510 warn_if_shadowing (tree new_decl)
2512 struct c_binding *b;
2514 /* Shadow warnings wanted? */
2516 /* No shadow warnings for internally generated vars. */
2517 || DECL_IS_BUILTIN (new_decl)
2518 /* No shadow warnings for vars made for inlining. */
2519 || DECL_FROM_INLINE (new_decl))
2522 /* Is anything being shadowed? Invisible decls do not count. */
2523 for (b = I_SYMBOL_BINDING (DECL_NAME (new_decl)); b; b = b->shadowed)
2524 if (b->decl && b->decl != new_decl && !b->invisible)
2526 tree old_decl = b->decl;
2528 if (old_decl == error_mark_node)
2530 warning (OPT_Wshadow, "declaration of %q+D shadows previous "
2531 "non-variable", new_decl);
2534 else if (TREE_CODE (old_decl) == PARM_DECL)
2535 warning (OPT_Wshadow, "declaration of %q+D shadows a parameter",
2537 else if (DECL_FILE_SCOPE_P (old_decl))
2538 warning (OPT_Wshadow, "declaration of %q+D shadows a global "
2539 "declaration", new_decl);
2540 else if (TREE_CODE (old_decl) == FUNCTION_DECL
2541 && DECL_BUILT_IN (old_decl))
2543 warning (OPT_Wshadow, "declaration of %q+D shadows "
2544 "a built-in function", new_decl);
2548 warning (OPT_Wshadow, "declaration of %q+D shadows a previous local",
2551 warning_at (DECL_SOURCE_LOCATION (old_decl), OPT_Wshadow,
2552 "shadowed declaration is here");
2558 /* Record a decl-node X as belonging to the current lexical scope.
2559 Check for errors (such as an incompatible declaration for the same
2560 name already seen in the same scope).
2562 Returns either X or an old decl for the same name.
2563 If an old decl is returned, it may have been smashed
2564 to agree with what X says. */
2569 tree name = DECL_NAME (x);
2570 struct c_scope *scope = current_scope;
2571 struct c_binding *b;
2572 bool nested = false;
2573 location_t locus = DECL_SOURCE_LOCATION (x);
2575 /* Must set DECL_CONTEXT for everything not at file scope or
2576 DECL_FILE_SCOPE_P won't work. Local externs don't count
2577 unless they have initializers (which generate code). */
2578 if (current_function_decl
2579 && ((TREE_CODE (x) != FUNCTION_DECL && TREE_CODE (x) != VAR_DECL)
2580 || DECL_INITIAL (x) || !DECL_EXTERNAL (x)))
2581 DECL_CONTEXT (x) = current_function_decl;
2583 /* Anonymous decls are just inserted in the scope. */
2586 bind (name, x, scope, /*invisible=*/false, /*nested=*/false,
2591 /* First, see if there is another declaration with the same name in
2592 the current scope. If there is, duplicate_decls may do all the
2593 work for us. If duplicate_decls returns false, that indicates
2594 two incompatible decls in the same scope; we are to silently
2595 replace the old one (duplicate_decls has issued all appropriate
2596 diagnostics). In particular, we should not consider possible
2597 duplicates in the external scope, or shadowing. */
2598 b = I_SYMBOL_BINDING (name);
2599 if (b && B_IN_SCOPE (b, scope))
2601 struct c_binding *b_ext, *b_use;
2602 tree type = TREE_TYPE (x);
2603 tree visdecl = b->decl;
2604 tree vistype = TREE_TYPE (visdecl);
2605 if (TREE_CODE (TREE_TYPE (x)) == ARRAY_TYPE
2606 && COMPLETE_TYPE_P (TREE_TYPE (x)))
2607 b->inner_comp = false;
2610 /* If this is an external linkage declaration, we should check
2611 for compatibility with the type in the external scope before
2612 setting the type at this scope based on the visible
2613 information only. */
2614 if (TREE_PUBLIC (x) && TREE_PUBLIC (visdecl))
2616 while (b_ext && !B_IN_EXTERNAL_SCOPE (b_ext))
2617 b_ext = b_ext->shadowed;
2622 TREE_TYPE (b_use->decl) = b_use->u.type;
2625 if (duplicate_decls (x, b_use->decl))
2629 /* Save the updated type in the external scope and
2630 restore the proper type for this scope. */
2632 if (comptypes (vistype, type))
2633 thistype = composite_type (vistype, type);
2635 thistype = TREE_TYPE (b_use->decl);
2636 b_use->u.type = TREE_TYPE (b_use->decl);
2637 if (TREE_CODE (b_use->decl) == FUNCTION_DECL
2638 && DECL_BUILT_IN (b_use->decl))
2640 = build_type_attribute_variant (thistype,
2643 TREE_TYPE (b_use->decl) = thistype;
2648 goto skip_external_and_shadow_checks;
2651 /* All declarations with external linkage, and all external
2652 references, go in the external scope, no matter what scope is
2653 current. However, the binding in that scope is ignored for
2654 purposes of normal name lookup. A separate binding structure is
2655 created in the requested scope; this governs the normal
2656 visibility of the symbol.
2658 The binding in the externals scope is used exclusively for
2659 detecting duplicate declarations of the same object, no matter
2660 what scope they are in; this is what we do here. (C99 6.2.7p2:
2661 All declarations that refer to the same object or function shall
2662 have compatible type; otherwise, the behavior is undefined.) */
2663 if (DECL_EXTERNAL (x) || scope == file_scope)
2665 tree type = TREE_TYPE (x);
2668 bool type_saved = false;
2669 if (b && !B_IN_EXTERNAL_SCOPE (b)
2670 && (TREE_CODE (b->decl) == FUNCTION_DECL
2671 || TREE_CODE (b->decl) == VAR_DECL)
2672 && DECL_FILE_SCOPE_P (b->decl))
2675 vistype = TREE_TYPE (visdecl);
2677 if (scope != file_scope
2678 && !DECL_IN_SYSTEM_HEADER (x))
2679 warning (OPT_Wnested_externs, "nested extern declaration of %qD", x);
2681 while (b && !B_IN_EXTERNAL_SCOPE (b))
2683 /* If this decl might be modified, save its type. This is
2684 done here rather than when the decl is first bound
2685 because the type may change after first binding, through
2686 being completed or through attributes being added. If we
2687 encounter multiple such decls, only the first should have
2688 its type saved; the others will already have had their
2689 proper types saved and the types will not have changed as
2690 their scopes will not have been re-entered. */
2691 if (DECL_P (b->decl) && DECL_FILE_SCOPE_P (b->decl) && !type_saved)
2693 b->u.type = TREE_TYPE (b->decl);
2696 if (B_IN_FILE_SCOPE (b)
2697 && TREE_CODE (b->decl) == VAR_DECL
2698 && TREE_STATIC (b->decl)
2699 && TREE_CODE (TREE_TYPE (b->decl)) == ARRAY_TYPE
2700 && !TYPE_DOMAIN (TREE_TYPE (b->decl))
2701 && TREE_CODE (type) == ARRAY_TYPE
2702 && TYPE_DOMAIN (type)
2703 && TYPE_MAX_VALUE (TYPE_DOMAIN (type))
2704 && !integer_zerop (TYPE_MAX_VALUE (TYPE_DOMAIN (type))))
2706 /* Array type completed in inner scope, which should be
2707 diagnosed if the completion does not have size 1 and
2708 it does not get completed in the file scope. */
2709 b->inner_comp = true;
2714 /* If a matching external declaration has been found, set its
2715 type to the composite of all the types of that declaration.
2716 After the consistency checks, it will be reset to the
2717 composite of the visible types only. */
2718 if (b && (TREE_PUBLIC (x) || same_translation_unit_p (x, b->decl))
2720 TREE_TYPE (b->decl) = b->u.type;
2722 /* The point of the same_translation_unit_p check here is,
2723 we want to detect a duplicate decl for a construct like
2724 foo() { extern bar(); } ... static bar(); but not if
2725 they are in different translation units. In any case,
2726 the static does not go in the externals scope. */
2728 && (TREE_PUBLIC (x) || same_translation_unit_p (x, b->decl))
2729 && duplicate_decls (x, b->decl))
2734 if (comptypes (vistype, type))
2735 thistype = composite_type (vistype, type);
2737 thistype = TREE_TYPE (b->decl);
2741 b->u.type = TREE_TYPE (b->decl);
2742 if (TREE_CODE (b->decl) == FUNCTION_DECL && DECL_BUILT_IN (b->decl))
2744 = build_type_attribute_variant (thistype,
2745 TYPE_ATTRIBUTES (b->u.type));
2746 TREE_TYPE (b->decl) = thistype;
2747 bind (name, b->decl, scope, /*invisible=*/false, /*nested=*/true,
2751 else if (TREE_PUBLIC (x))
2753 if (visdecl && !b && duplicate_decls (x, visdecl))
2755 /* An external declaration at block scope referring to a
2756 visible entity with internal linkage. The composite
2757 type will already be correct for this scope, so we
2758 just need to fall through to make the declaration in
2765 bind (name, x, external_scope, /*invisible=*/true,
2766 /*nested=*/false, locus);
2772 if (TREE_CODE (x) != PARM_DECL)
2773 warn_if_shadowing (x);
2775 skip_external_and_shadow_checks:
2776 if (TREE_CODE (x) == TYPE_DECL)
2777 set_underlying_type (x);
2779 bind (name, x, scope, /*invisible=*/false, nested, locus);
2781 /* If x's type is incomplete because it's based on a
2782 structure or union which has not yet been fully declared,
2783 attach it to that structure or union type, so we can go
2784 back and complete the variable declaration later, if the
2785 structure or union gets fully declared.
2787 If the input is erroneous, we can have error_mark in the type
2788 slot (e.g. "f(void a, ...)") - that doesn't count as an
2790 if (TREE_TYPE (x) != error_mark_node
2791 && !COMPLETE_TYPE_P (TREE_TYPE (x)))
2793 tree element = TREE_TYPE (x);
2795 while (TREE_CODE (element) == ARRAY_TYPE)
2796 element = TREE_TYPE (element);
2797 element = TYPE_MAIN_VARIANT (element);
2799 if ((TREE_CODE (element) == RECORD_TYPE
2800 || TREE_CODE (element) == UNION_TYPE)
2801 && (TREE_CODE (x) != TYPE_DECL
2802 || TREE_CODE (TREE_TYPE (x)) == ARRAY_TYPE)
2803 && !COMPLETE_TYPE_P (element))
2804 C_TYPE_INCOMPLETE_VARS (element)
2805 = tree_cons (NULL_TREE, x, C_TYPE_INCOMPLETE_VARS (element));
2810 /* Record X as belonging to file scope.
2811 This is used only internally by the Objective-C front end,
2812 and is limited to its needs. duplicate_decls is not called;
2813 if there is any preexisting decl for this identifier, it is an ICE. */
2816 pushdecl_top_level (tree x)
2819 bool nested = false;
2820 gcc_assert (TREE_CODE (x) == VAR_DECL || TREE_CODE (x) == CONST_DECL);
2822 name = DECL_NAME (x);
2824 gcc_assert (TREE_CODE (x) == CONST_DECL || !I_SYMBOL_BINDING (name));
2826 if (TREE_PUBLIC (x))
2828 bind (name, x, external_scope, /*invisible=*/true, /*nested=*/false,
2833 bind (name, x, file_scope, /*invisible=*/false, nested, UNKNOWN_LOCATION);
2839 implicit_decl_warning (tree id, tree olddecl)
2841 if (warn_implicit_function_declaration)
2846 warned = pedwarn (input_location, OPT_Wimplicit_function_declaration,
2847 "implicit declaration of function %qE", id);
2849 warned = warning (OPT_Wimplicit_function_declaration,
2850 G_("implicit declaration of function %qE"), id);
2851 if (olddecl && warned)
2852 locate_old_decl (olddecl);
2856 /* Generate an implicit declaration for identifier FUNCTIONID at LOC as a
2857 function of type int (). */
2860 implicitly_declare (location_t loc, tree functionid)
2862 struct c_binding *b;
2866 for (b = I_SYMBOL_BINDING (functionid); b; b = b->shadowed)
2868 if (B_IN_SCOPE (b, external_scope))
2877 if (decl == error_mark_node)
2880 /* FIXME: Objective-C has weird not-really-builtin functions
2881 which are supposed to be visible automatically. They wind up
2882 in the external scope because they're pushed before the file
2883 scope gets created. Catch this here and rebind them into the
2885 if (!DECL_BUILT_IN (decl) && DECL_IS_BUILTIN (decl))
2887 bind (functionid, decl, file_scope,
2888 /*invisible=*/false, /*nested=*/true,
2889 DECL_SOURCE_LOCATION (decl));
2894 tree newtype = default_function_type;
2896 TREE_TYPE (decl) = b->u.type;
2897 /* Implicit declaration of a function already declared
2898 (somehow) in a different scope, or as a built-in.
2899 If this is the first time this has happened, warn;
2900 then recycle the old declaration but with the new type. */
2901 if (!C_DECL_IMPLICIT (decl))
2903 implicit_decl_warning (functionid, decl);
2904 C_DECL_IMPLICIT (decl) = 1;
2906 if (DECL_BUILT_IN (decl))
2908 newtype = build_type_attribute_variant (newtype,
2910 (TREE_TYPE (decl)));
2911 if (!comptypes (newtype, TREE_TYPE (decl)))
2913 warning_at (loc, 0, "incompatible implicit declaration of "
2914 "built-in function %qD", decl);
2915 newtype = TREE_TYPE (decl);
2920 if (!comptypes (newtype, TREE_TYPE (decl)))
2922 error_at (loc, "incompatible implicit declaration of function %qD", decl);
2923 locate_old_decl (decl);
2926 b->u.type = TREE_TYPE (decl);
2927 TREE_TYPE (decl) = newtype;
2928 bind (functionid, decl, current_scope,
2929 /*invisible=*/false, /*nested=*/true,
2930 DECL_SOURCE_LOCATION (decl));
2935 /* Not seen before. */
2936 decl = build_decl (loc, FUNCTION_DECL, functionid, default_function_type);
2937 DECL_EXTERNAL (decl) = 1;
2938 TREE_PUBLIC (decl) = 1;
2939 C_DECL_IMPLICIT (decl) = 1;
2940 implicit_decl_warning (functionid, 0);
2941 asmspec_tree = maybe_apply_renaming_pragma (decl, /*asmname=*/NULL);
2943 set_user_assembler_name (decl, TREE_STRING_POINTER (asmspec_tree));
2945 /* C89 says implicit declarations are in the innermost block.
2946 So we record the decl in the standard fashion. */
2947 decl = pushdecl (decl);
2949 /* No need to call objc_check_decl here - it's a function type. */
2950 rest_of_decl_compilation (decl, 0, 0);
2952 /* Write a record describing this implicit function declaration
2953 to the prototypes file (if requested). */
2954 gen_aux_info_record (decl, 0, 1, 0);
2956 /* Possibly apply some default attributes to this implicit declaration. */
2957 decl_attributes (&decl, NULL_TREE, 0);
2962 /* Issue an error message for a reference to an undeclared variable
2963 ID, including a reference to a builtin outside of function-call
2964 context. Establish a binding of the identifier to error_mark_node
2965 in an appropriate scope, which will suppress further errors for the
2966 same identifier. The error message should be given location LOC. */
2968 undeclared_variable (location_t loc, tree id)
2970 static bool already = false;
2971 struct c_scope *scope;
2973 if (current_function_decl == 0)
2975 error_at (loc, "%qE undeclared here (not in a function)", id);
2976 scope = current_scope;
2980 if (!objc_diagnose_private_ivar (id))
2981 error_at (loc, "%qE undeclared (first use in this function)", id);
2984 inform (loc, "each undeclared identifier is reported only"
2985 " once for each function it appears in");
2989 /* If we are parsing old-style parameter decls, current_function_decl
2990 will be nonnull but current_function_scope will be null. */
2991 scope = current_function_scope ? current_function_scope : current_scope;
2993 bind (id, error_mark_node, scope, /*invisible=*/false, /*nested=*/false,
2997 /* Subroutine of lookup_label, declare_label, define_label: construct a
2998 LABEL_DECL with all the proper frills. Also create a struct
2999 c_label_vars initialized for the current scope. */
3002 make_label (location_t location, tree name, bool defining,
3003 struct c_label_vars **p_label_vars)
3005 tree label = build_decl (location, LABEL_DECL, name, void_type_node);
3006 struct c_label_vars *label_vars;
3008 DECL_CONTEXT (label) = current_function_decl;
3009 DECL_MODE (label) = VOIDmode;
3011 label_vars = ggc_alloc_c_label_vars ();
3012 label_vars->shadowed = NULL;
3013 set_spot_bindings (&label_vars->label_bindings, defining);
3014 label_vars->decls_in_scope = make_tree_vector ();
3015 label_vars->gotos = VEC_alloc (c_goto_bindings_p, gc, 0);
3016 *p_label_vars = label_vars;
3021 /* Get the LABEL_DECL corresponding to identifier NAME as a label.
3022 Create one if none exists so far for the current function.
3023 This is called when a label is used in a goto expression or
3024 has its address taken. */
3027 lookup_label (tree name)
3030 struct c_label_vars *label_vars;
3032 if (current_function_scope == 0)
3034 error ("label %qE referenced outside of any function", name);
3038 /* Use a label already defined or ref'd with this name, but not if
3039 it is inherited from a containing function and wasn't declared
3041 label = I_LABEL_DECL (name);
3042 if (label && (DECL_CONTEXT (label) == current_function_decl
3043 || C_DECLARED_LABEL_FLAG (label)))
3045 /* If the label has only been declared, update its apparent
3046 location to point here, for better diagnostics if it
3047 turns out not to have been defined. */
3048 if (DECL_INITIAL (label) == NULL_TREE)
3049 DECL_SOURCE_LOCATION (label) = input_location;
3053 /* No label binding for that identifier; make one. */
3054 label = make_label (input_location, name, false, &label_vars);
3056 /* Ordinary labels go in the current function scope. */
3057 bind_label (name, label, current_function_scope, label_vars);
3062 /* Issue a warning about DECL for a goto statement at GOTO_LOC going
3066 warn_about_goto (location_t goto_loc, tree label, tree decl)
3068 if (variably_modified_type_p (TREE_TYPE (decl), NULL_TREE))
3070 "jump into scope of identifier with variably modified type");
3072 warning_at (goto_loc, OPT_Wjump_misses_init,
3073 "jump skips variable initialization");
3074 inform (DECL_SOURCE_LOCATION (label), "label %qD defined here", label);
3075 inform (DECL_SOURCE_LOCATION (decl), "%qD declared here", decl);
3078 /* Look up a label because of a goto statement. This is like
3079 lookup_label, but also issues any appropriate warnings. */
3082 lookup_label_for_goto (location_t loc, tree name)
3085 struct c_label_vars *label_vars;
3089 label = lookup_label (name);
3090 if (label == NULL_TREE)
3093 /* If we are jumping to a different function, we can't issue any
3095 if (DECL_CONTEXT (label) != current_function_decl)
3097 gcc_assert (C_DECLARED_LABEL_FLAG (label));
3101 label_vars = I_LABEL_BINDING (name)->u.label;
3103 /* If the label has not yet been defined, then push this goto on a
3104 list for possible later warnings. */
3105 if (label_vars->label_bindings.scope == NULL)
3107 struct c_goto_bindings *g;
3109 g = ggc_alloc_c_goto_bindings ();
3111 set_spot_bindings (&g->goto_bindings, true);
3112 VEC_safe_push (c_goto_bindings_p, gc, label_vars->gotos, g);
3116 /* If there are any decls in label_vars->decls_in_scope, then this
3117 goto has missed the declaration of the decl. This happens for a
3123 Issue a warning or error. */
3124 FOR_EACH_VEC_ELT (tree, label_vars->decls_in_scope, ix, decl)
3125 warn_about_goto (loc, label, decl);
3127 if (label_vars->label_bindings.left_stmt_expr)
3129 error_at (loc, "jump into statement expression");
3130 inform (DECL_SOURCE_LOCATION (label), "label %qD defined here", label);
3136 /* Make a label named NAME in the current function, shadowing silently
3137 any that may be inherited from containing functions or containing
3138 scopes. This is called for __label__ declarations. */
3141 declare_label (tree name)
3143 struct c_binding *b = I_LABEL_BINDING (name);
3145 struct c_label_vars *label_vars;
3147 /* Check to make sure that the label hasn't already been declared
3149 if (b && B_IN_CURRENT_SCOPE (b))
3151 error ("duplicate label declaration %qE", name);
3152 locate_old_decl (b->decl);
3154 /* Just use the previous declaration. */
3158 label = make_label (input_location, name, false, &label_vars);
3159 C_DECLARED_LABEL_FLAG (label) = 1;
3161 /* Declared labels go in the current scope. */
3162 bind_label (name, label, current_scope, label_vars);
3167 /* When we define a label, issue any appropriate warnings if there are
3168 any gotos earlier in the function which jump to this label. */
3171 check_earlier_gotos (tree label, struct c_label_vars* label_vars)
3174 struct c_goto_bindings *g;
3176 FOR_EACH_VEC_ELT (c_goto_bindings_p, label_vars->gotos, ix, g)
3178 struct c_binding *b;
3179 struct c_scope *scope;
3181 /* We have a goto to this label. The goto is going forward. In
3182 g->scope, the goto is going to skip any binding which was
3183 defined after g->bindings_in_scope. */
3184 if (g->goto_bindings.scope->has_jump_unsafe_decl)
3186 for (b = g->goto_bindings.scope->bindings;
3187 b != g->goto_bindings.bindings_in_scope;
3190 if (decl_jump_unsafe (b->decl))
3191 warn_about_goto (g->loc, label, b->decl);
3195 /* We also need to warn about decls defined in any scopes
3196 between the scope of the label and the scope of the goto. */
3197 for (scope = label_vars->label_bindings.scope;
3198 scope != g->goto_bindings.scope;
3199 scope = scope->outer)
3201 gcc_assert (scope != NULL);
3202 if (scope->has_jump_unsafe_decl)
3204 if (scope == label_vars->label_bindings.scope)
3205 b = label_vars->label_bindings.bindings_in_scope;
3207 b = scope->bindings;
3208 for (; b != NULL; b = b->prev)
3210 if (decl_jump_unsafe (b->decl))
3211 warn_about_goto (g->loc, label, b->decl);
3216 if (g->goto_bindings.stmt_exprs > 0)
3218 error_at (g->loc, "jump into statement expression");
3219 inform (DECL_SOURCE_LOCATION (label), "label %qD defined here",
3224 /* Now that the label is defined, we will issue warnings about
3225 subsequent gotos to this label when we see them. */
3226 VEC_truncate (c_goto_bindings_p, label_vars->gotos, 0);
3227 label_vars->gotos = NULL;
3230 /* Define a label, specifying the location in the source file.
3231 Return the LABEL_DECL node for the label, if the definition is valid.
3232 Otherwise return 0. */
3235 define_label (location_t location, tree name)
3237 /* Find any preexisting label with this name. It is an error
3238 if that label has already been defined in this function, or
3239 if there is a containing function with a declared label with
3241 tree label = I_LABEL_DECL (name);
3244 && ((DECL_CONTEXT (label) == current_function_decl
3245 && DECL_INITIAL (label) != 0)
3246 || (DECL_CONTEXT (label) != current_function_decl
3247 && C_DECLARED_LABEL_FLAG (label))))
3249 error_at (location, "duplicate label %qD", label);
3250 locate_old_decl (label);
3253 else if (label && DECL_CONTEXT (label) == current_function_decl)
3255 struct c_label_vars *label_vars = I_LABEL_BINDING (name)->u.label;
3257 /* The label has been used or declared already in this function,
3258 but not defined. Update its location to point to this
3260 DECL_SOURCE_LOCATION (label) = location;
3261 set_spot_bindings (&label_vars->label_bindings, true);
3263 /* Issue warnings as required about any goto statements from
3264 earlier in the function. */
3265 check_earlier_gotos (label, label_vars);
3269 struct c_label_vars *label_vars;
3271 /* No label binding for that identifier; make one. */
3272 label = make_label (location, name, true, &label_vars);
3274 /* Ordinary labels go in the current function scope. */
3275 bind_label (name, label, current_function_scope, label_vars);
3278 if (!in_system_header && lookup_name (name))
3279 warning_at (location, OPT_Wtraditional,
3280 "traditional C lacks a separate namespace "
3281 "for labels, identifier %qE conflicts", name);
3283 /* Mark label as having been defined. */
3284 DECL_INITIAL (label) = error_mark_node;
3288 /* Get the bindings for a new switch statement. This is used to issue
3289 warnings as appropriate for jumps from the switch to case or
3292 struct c_spot_bindings *
3293 c_get_switch_bindings (void)
3295 struct c_spot_bindings *switch_bindings;
3297 switch_bindings = XNEW (struct c_spot_bindings);
3298 set_spot_bindings (switch_bindings, true);
3299 return switch_bindings;
3303 c_release_switch_bindings (struct c_spot_bindings *bindings)
3305 gcc_assert (bindings->stmt_exprs == 0 && !bindings->left_stmt_expr);
3309 /* This is called at the point of a case or default label to issue
3310 warnings about decls as needed. It returns true if it found an
3311 error, not just a warning. */
3314 c_check_switch_jump_warnings (struct c_spot_bindings *switch_bindings,
3315 location_t switch_loc, location_t case_loc)
3318 struct c_scope *scope;
3321 for (scope = current_scope;
3322 scope != switch_bindings->scope;
3323 scope = scope->outer)
3325 struct c_binding *b;
3327 gcc_assert (scope != NULL);
3329 if (!scope->has_jump_unsafe_decl)
3332 for (b = scope->bindings; b != NULL; b = b->prev)
3334 if (decl_jump_unsafe (b->decl))
3336 if (variably_modified_type_p (TREE_TYPE (b->decl), NULL_TREE))
3340 ("switch jumps into scope of identifier with "
3341 "variably modified type"));
3344 warning_at (case_loc, OPT_Wjump_misses_init,
3345 "switch jumps over variable initialization");
3346 inform (switch_loc, "switch starts here");
3347 inform (DECL_SOURCE_LOCATION (b->decl), "%qD declared here",
3353 if (switch_bindings->stmt_exprs > 0)
3356 error_at (case_loc, "switch jumps into statement expression");
3357 inform (switch_loc, "switch starts here");
3363 /* Given NAME, an IDENTIFIER_NODE,
3364 return the structure (or union or enum) definition for that name.
3365 If THISLEVEL_ONLY is nonzero, searches only the current_scope.
3366 CODE says which kind of type the caller wants;
3367 it is RECORD_TYPE or UNION_TYPE or ENUMERAL_TYPE.
3368 If PLOC is not NULL and this returns non-null, it sets *PLOC to the
3369 location where the tag was defined.
3370 If the wrong kind of type is found, an error is reported. */
3373 lookup_tag (enum tree_code code, tree name, int thislevel_only,
3376 struct c_binding *b = I_TAG_BINDING (name);
3382 /* We only care about whether it's in this level if
3383 thislevel_only was set or it might be a type clash. */
3384 if (thislevel_only || TREE_CODE (b->decl) != code)
3386 /* For our purposes, a tag in the external scope is the same as
3387 a tag in the file scope. (Primarily relevant to Objective-C
3388 and its builtin structure tags, which get pushed before the
3389 file scope is created.) */
3390 if (B_IN_CURRENT_SCOPE (b)
3391 || (current_scope == file_scope && B_IN_EXTERNAL_SCOPE (b)))
3395 if (thislevel_only && !thislevel)
3398 if (TREE_CODE (b->decl) != code)
3400 /* Definition isn't the kind we were looking for. */
3401 pending_invalid_xref = name;
3402 pending_invalid_xref_location = input_location;
3404 /* If in the same binding level as a declaration as a tag
3405 of a different type, this must not be allowed to
3406 shadow that tag, so give the error immediately.
3407 (For example, "struct foo; union foo;" is invalid.) */
3409 pending_xref_error ();
3418 /* Print an error message now
3419 for a recent invalid struct, union or enum cross reference.
3420 We don't print them immediately because they are not invalid
3421 when used in the `struct foo;' construct for shadowing. */
3424 pending_xref_error (void)
3426 if (pending_invalid_xref != 0)
3427 error_at (pending_invalid_xref_location, "%qE defined as wrong kind of tag",
3428 pending_invalid_xref);
3429 pending_invalid_xref = 0;
3433 /* Look up NAME in the current scope and its superiors
3434 in the namespace of variables, functions and typedefs.
3435 Return a ..._DECL node of some kind representing its definition,
3436 or return 0 if it is undefined. */
3439 lookup_name (tree name)
3441 struct c_binding *b = I_SYMBOL_BINDING (name);
3442 if (b && !b->invisible)
3447 /* Similar to `lookup_name' but look only at the indicated scope. */
3450 lookup_name_in_scope (tree name, struct c_scope *scope)
3452 struct c_binding *b;
3454 for (b = I_SYMBOL_BINDING (name); b; b = b->shadowed)
3455 if (B_IN_SCOPE (b, scope))
3460 /* Create the predefined scalar types of C,
3461 and some nodes representing standard constants (0, 1, (void *) 0).
3462 Initialize the global scope.
3463 Make definitions for built-in primitive functions. */
3466 c_init_decl_processing (void)
3468 location_t save_loc = input_location;
3470 /* Initialize reserved words for parser. */
3473 current_function_decl = 0;
3475 gcc_obstack_init (&parser_obstack);
3477 /* Make the externals scope. */
3479 external_scope = current_scope;
3481 /* Declarations from c_common_nodes_and_builtins must not be associated
3482 with this input file, lest we get differences between using and not
3483 using preprocessed headers. */
3484 input_location = BUILTINS_LOCATION;
3486 build_common_tree_nodes (flag_signed_char);
3488 c_common_nodes_and_builtins ();
3490 /* In C, comparisons and TRUTH_* expressions have type int. */
3491 truthvalue_type_node = integer_type_node;
3492 truthvalue_true_node = integer_one_node;
3493 truthvalue_false_node = integer_zero_node;
3495 /* Even in C99, which has a real boolean type. */
3496 pushdecl (build_decl (UNKNOWN_LOCATION, TYPE_DECL, get_identifier ("_Bool"),
3497 boolean_type_node));
3499 input_location = save_loc;
3501 pedantic_lvalues = true;
3503 make_fname_decl = c_make_fname_decl;
3504 start_fname_decls ();
3507 /* Create the VAR_DECL at LOC for __FUNCTION__ etc. ID is the name to
3508 give the decl, NAME is the initialization string and TYPE_DEP
3509 indicates whether NAME depended on the type of the function. As we
3510 don't yet implement delayed emission of static data, we mark the
3511 decl as emitted so it is not placed in the output. Anything using
3512 it must therefore pull out the STRING_CST initializer directly.
3516 c_make_fname_decl (location_t loc, tree id, int type_dep)
3518 const char *name = fname_as_string (type_dep);
3519 tree decl, type, init;
3520 size_t length = strlen (name);
3522 type = build_array_type (char_type_node,
3523 build_index_type (size_int (length)));
3524 type = c_build_qualified_type (type, TYPE_QUAL_CONST);
3526 decl = build_decl (loc, VAR_DECL, id, type);
3528 TREE_STATIC (decl) = 1;
3529 TREE_READONLY (decl) = 1;
3530 DECL_ARTIFICIAL (decl) = 1;
3532 init = build_string (length + 1, name);
3533 free (CONST_CAST (char *, name));
3534 TREE_TYPE (init) = type;
3535 DECL_INITIAL (decl) = init;
3537 TREE_USED (decl) = 1;
3539 if (current_function_decl
3540 /* For invalid programs like this:
3543 const char* p = __FUNCTION__;
3545 the __FUNCTION__ is believed to appear in K&R style function
3546 parameter declarator. In that case we still don't have
3548 && (!seen_error () || current_function_scope))
3550 DECL_CONTEXT (decl) = current_function_decl;
3551 bind (id, decl, current_function_scope,
3552 /*invisible=*/false, /*nested=*/false, UNKNOWN_LOCATION);
3555 finish_decl (decl, loc, init, NULL_TREE, NULL_TREE);
3561 c_builtin_function (tree decl)
3563 tree type = TREE_TYPE (decl);
3564 tree id = DECL_NAME (decl);
3566 const char *name = IDENTIFIER_POINTER (id);
3567 C_DECL_BUILTIN_PROTOTYPE (decl) = prototype_p (type);
3569 /* Should never be called on a symbol with a preexisting meaning. */
3570 gcc_assert (!I_SYMBOL_BINDING (id));
3572 bind (id, decl, external_scope, /*invisible=*/true, /*nested=*/false,
3575 /* Builtins in the implementation namespace are made visible without
3576 needing to be explicitly declared. See push_file_scope. */
3577 if (name[0] == '_' && (name[1] == '_' || ISUPPER (name[1])))
3579 DECL_CHAIN (decl) = visible_builtins;
3580 visible_builtins = decl;
3587 c_builtin_function_ext_scope (tree decl)
3589 tree type = TREE_TYPE (decl);
3590 tree id = DECL_NAME (decl);
3592 const char *name = IDENTIFIER_POINTER (id);
3593 C_DECL_BUILTIN_PROTOTYPE (decl) = prototype_p (type);
3595 /* Should never be called on a symbol with a preexisting meaning. */
3596 gcc_assert (!I_SYMBOL_BINDING (id));
3598 bind (id, decl, external_scope, /*invisible=*/false, /*nested=*/false,
3601 /* Builtins in the implementation namespace are made visible without
3602 needing to be explicitly declared. See push_file_scope. */
3603 if (name[0] == '_' && (name[1] == '_' || ISUPPER (name[1])))
3605 DECL_CHAIN (decl) = visible_builtins;
3606 visible_builtins = decl;
3612 /* Called when a declaration is seen that contains no names to declare.
3613 If its type is a reference to a structure, union or enum inherited
3614 from a containing scope, shadow that tag name for the current scope
3615 with a forward reference.
3616 If its type defines a new named structure or union
3617 or defines an enum, it is valid but we need not do anything here.
3618 Otherwise, it is an error. */
3621 shadow_tag (const struct c_declspecs *declspecs)
3623 shadow_tag_warned (declspecs, 0);
3626 /* WARNED is 1 if we have done a pedwarn, 2 if we have done a warning,
3629 shadow_tag_warned (const struct c_declspecs *declspecs, int warned)
3631 bool found_tag = false;
3633 if (declspecs->type && !declspecs->default_int_p && !declspecs->typedef_p)
3635 tree value = declspecs->type;
3636 enum tree_code code = TREE_CODE (value);
3638 if (code == RECORD_TYPE || code == UNION_TYPE || code == ENUMERAL_TYPE)
3639 /* Used to test also that TYPE_SIZE (value) != 0.
3640 That caused warning for `struct foo;' at top level in the file. */
3642 tree name = TYPE_NAME (value);
3647 if (declspecs->restrict_p)
3649 error ("invalid use of %<restrict%>");
3655 if (warned != 1 && code != ENUMERAL_TYPE)
3656 /* Empty unnamed enum OK */
3658 pedwarn (input_location, 0,
3659 "unnamed struct/union that defines no instances");
3663 else if (declspecs->typespec_kind != ctsk_tagdef
3664 && declspecs->typespec_kind != ctsk_tagfirstref
3665 && declspecs->storage_class != csc_none)
3668 pedwarn (input_location, 0,
3669 "empty declaration with storage class specifier "
3670 "does not redeclare tag");
3672 pending_xref_error ();
3674 else if (declspecs->typespec_kind != ctsk_tagdef
3675 && declspecs->typespec_kind != ctsk_tagfirstref
3676 && (declspecs->const_p
3677 || declspecs->volatile_p
3678 || declspecs->restrict_p
3679 || declspecs->address_space))
3682 pedwarn (input_location, 0,
3683 "empty declaration with type qualifier "
3684 "does not redeclare tag");
3686 pending_xref_error ();
3690 pending_invalid_xref = 0;
3691 t = lookup_tag (code, name, 1, NULL);
3695 t = make_node (code);
3696 pushtag (input_location, name, t);
3702 if (warned != 1 && !in_system_header)
3704 pedwarn (input_location, 0,
3705 "useless type name in empty declaration");
3710 else if (warned != 1 && !in_system_header && declspecs->typedef_p)
3712 pedwarn (input_location, 0, "useless type name in empty declaration");
3716 pending_invalid_xref = 0;
3718 if (declspecs->inline_p)
3720 error ("%<inline%> in empty declaration");
3724 if (current_scope == file_scope && declspecs->storage_class == csc_auto)
3726 error ("%<auto%> in file-scope empty declaration");
3730 if (current_scope == file_scope && declspecs->storage_class == csc_register)
3732 error ("%<register%> in file-scope empty declaration");
3736 if (!warned && !in_system_header && declspecs->storage_class != csc_none)
3738 warning (0, "useless storage class specifier in empty declaration");
3742 if (!warned && !in_system_header && declspecs->thread_p)
3744 warning (0, "useless %<__thread%> in empty declaration");
3748 if (!warned && !in_system_header && (declspecs->const_p
3749 || declspecs->volatile_p
3750 || declspecs->restrict_p
3751 || declspecs->address_space))
3753 warning (0, "useless type qualifier in empty declaration");
3760 pedwarn (input_location, 0, "empty declaration");
3765 /* Return the qualifiers from SPECS as a bitwise OR of TYPE_QUAL_*
3766 bits. SPECS represents declaration specifiers that the grammar
3767 only permits to contain type qualifiers and attributes. */
3770 quals_from_declspecs (const struct c_declspecs *specs)
3772 int quals = ((specs->const_p ? TYPE_QUAL_CONST : 0)
3773 | (specs->volatile_p ? TYPE_QUAL_VOLATILE : 0)
3774 | (specs->restrict_p ? TYPE_QUAL_RESTRICT : 0)
3775 | (ENCODE_QUAL_ADDR_SPACE (specs->address_space)));
3776 gcc_assert (!specs->type
3777 && !specs->decl_attr
3778 && specs->typespec_word == cts_none
3779 && specs->storage_class == csc_none
3780 && !specs->typedef_p
3781 && !specs->explicit_signed_p
3782 && !specs->deprecated_p
3784 && !specs->long_long_p
3787 && !specs->unsigned_p
3788 && !specs->complex_p
3790 && !specs->thread_p);
3794 /* Construct an array declarator. LOC is the location of the
3795 beginning of the array (usually the opening brace). EXPR is the
3796 expression inside [], or NULL_TREE. QUALS are the type qualifiers
3797 inside the [] (to be applied to the pointer to which a parameter
3798 array is converted). STATIC_P is true if "static" is inside the
3799 [], false otherwise. VLA_UNSPEC_P is true if the array is [*], a
3800 VLA of unspecified length which is nevertheless a complete type,
3801 false otherwise. The field for the contained declarator is left to
3802 be filled in by set_array_declarator_inner. */
3804 struct c_declarator *
3805 build_array_declarator (location_t loc,
3806 tree expr, struct c_declspecs *quals, bool static_p,
3809 struct c_declarator *declarator = XOBNEW (&parser_obstack,
3810 struct c_declarator);
3811 declarator->id_loc = loc;
3812 declarator->kind = cdk_array;
3813 declarator->declarator = 0;
3814 declarator->u.array.dimen = expr;
3817 declarator->u.array.attrs = quals->attrs;
3818 declarator->u.array.quals = quals_from_declspecs (quals);
3822 declarator->u.array.attrs = NULL_TREE;
3823 declarator->u.array.quals = 0;
3825 declarator->u.array.static_p = static_p;
3826 declarator->u.array.vla_unspec_p = vla_unspec_p;
3829 if (static_p || quals != NULL)
3830 pedwarn (loc, OPT_pedantic,
3831 "ISO C90 does not support %<static%> or type "
3832 "qualifiers in parameter array declarators");
3834 pedwarn (loc, OPT_pedantic,
3835 "ISO C90 does not support %<[*]%> array declarators");
3839 if (!current_scope->parm_flag)
3842 error_at (loc, "%<[*]%> not allowed in other than "
3843 "function prototype scope");
3844 declarator->u.array.vla_unspec_p = false;
3847 current_scope->had_vla_unspec = true;
3852 /* Set the contained declarator of an array declarator. DECL is the
3853 declarator, as constructed by build_array_declarator; INNER is what
3854 appears on the left of the []. */
3856 struct c_declarator *
3857 set_array_declarator_inner (struct c_declarator *decl,
3858 struct c_declarator *inner)
3860 decl->declarator = inner;
3864 /* INIT is a constructor that forms DECL's initializer. If the final
3865 element initializes a flexible array field, add the size of that
3866 initializer to DECL's size. */
3869 add_flexible_array_elts_to_size (tree decl, tree init)
3873 if (VEC_empty (constructor_elt, CONSTRUCTOR_ELTS (init)))
3876 elt = VEC_last (constructor_elt, CONSTRUCTOR_ELTS (init))->value;
3877 type = TREE_TYPE (elt);
3878 if (TREE_CODE (type) == ARRAY_TYPE
3879 && TYPE_SIZE (type) == NULL_TREE
3880 && TYPE_DOMAIN (type) != NULL_TREE
3881 && TYPE_MAX_VALUE (TYPE_DOMAIN (type)) == NULL_TREE)
3883 complete_array_type (&type, elt, false);
3885 = size_binop (PLUS_EXPR, DECL_SIZE (decl), TYPE_SIZE (type));
3886 DECL_SIZE_UNIT (decl)
3887 = size_binop (PLUS_EXPR, DECL_SIZE_UNIT (decl), TYPE_SIZE_UNIT (type));
3891 /* Decode a "typename", such as "int **", returning a ..._TYPE node.
3892 Set *EXPR, if EXPR not NULL, to any expression to be evaluated
3893 before the type name, and set *EXPR_CONST_OPERANDS, if
3894 EXPR_CONST_OPERANDS not NULL, to indicate whether the type name may
3895 appear in a constant expression. */
3898 groktypename (struct c_type_name *type_name, tree *expr,
3899 bool *expr_const_operands)
3902 tree attrs = type_name->specs->attrs;
3904 type_name->specs->attrs = NULL_TREE;
3906 type = grokdeclarator (type_name->declarator, type_name->specs, TYPENAME,
3907 false, NULL, &attrs, expr, expr_const_operands,
3910 /* Apply attributes. */
3911 decl_attributes (&type, attrs, 0);
3916 /* Decode a declarator in an ordinary declaration or data definition.
3917 This is called as soon as the type information and variable name
3918 have been parsed, before parsing the initializer if any.
3919 Here we create the ..._DECL node, fill in its type,
3920 and put it on the list of decls for the current context.
3921 The ..._DECL node is returned as the value.
3923 Exception: for arrays where the length is not specified,
3924 the type is left null, to be filled in by `finish_decl'.
3926 Function definitions do not come here; they go to start_function
3927 instead. However, external and forward declarations of functions
3928 do go through here. Structure field declarations are done by
3929 grokfield and not through here. */
3932 start_decl (struct c_declarator *declarator, struct c_declspecs *declspecs,
3933 bool initialized, tree attributes)
3937 tree expr = NULL_TREE;
3938 enum deprecated_states deprecated_state = DEPRECATED_NORMAL;
3940 /* An object declared as __attribute__((deprecated)) suppresses
3941 warnings of uses of other deprecated items. */
3942 if (lookup_attribute ("deprecated", attributes))
3943 deprecated_state = DEPRECATED_SUPPRESS;
3945 decl = grokdeclarator (declarator, declspecs,
3946 NORMAL, initialized, NULL, &attributes, &expr, NULL,
3952 add_stmt (fold_convert (void_type_node, expr));
3954 if (TREE_CODE (decl) != FUNCTION_DECL && MAIN_NAME_P (DECL_NAME (decl)))
3955 warning (OPT_Wmain, "%q+D is usually a function", decl);
3958 /* Is it valid for this decl to have an initializer at all?
3959 If not, set INITIALIZED to zero, which will indirectly
3960 tell 'finish_decl' to ignore the initializer once it is parsed. */
3961 switch (TREE_CODE (decl))
3964 error ("typedef %qD is initialized (use __typeof__ instead)", decl);
3969 error ("function %qD is initialized like a variable", decl);
3974 /* DECL_INITIAL in a PARM_DECL is really DECL_ARG_TYPE. */
3975 error ("parameter %qD is initialized", decl);
3980 /* Don't allow initializations for incomplete types except for
3981 arrays which might be completed by the initialization. */
3983 /* This can happen if the array size is an undefined macro.
3984 We already gave a warning, so we don't need another one. */
3985 if (TREE_TYPE (decl) == error_mark_node)
3987 else if (COMPLETE_TYPE_P (TREE_TYPE (decl)))
3989 /* A complete type is ok if size is fixed. */
3991 if (TREE_CODE (TYPE_SIZE (TREE_TYPE (decl))) != INTEGER_CST
3992 || C_DECL_VARIABLE_SIZE (decl))
3994 error ("variable-sized object may not be initialized");
3998 else if (TREE_CODE (TREE_TYPE (decl)) != ARRAY_TYPE)
4000 error ("variable %qD has initializer but incomplete type", decl);
4003 else if (C_DECL_VARIABLE_SIZE (decl))
4005 /* Although C99 is unclear about whether incomplete arrays
4006 of VLAs themselves count as VLAs, it does not make
4007 sense to permit them to be initialized given that
4008 ordinary VLAs may not be initialized. */
4009 error ("variable-sized object may not be initialized");
4016 if (current_scope == file_scope)
4017 TREE_STATIC (decl) = 1;
4019 /* Tell 'pushdecl' this is an initialized decl
4020 even though we don't yet have the initializer expression.
4021 Also tell 'finish_decl' it may store the real initializer. */
4022 DECL_INITIAL (decl) = error_mark_node;
4025 /* If this is a function declaration, write a record describing it to the
4026 prototypes file (if requested). */
4028 if (TREE_CODE (decl) == FUNCTION_DECL)
4029 gen_aux_info_record (decl, 0, 0, prototype_p (TREE_TYPE (decl)));
4031 /* ANSI specifies that a tentative definition which is not merged with
4032 a non-tentative definition behaves exactly like a definition with an
4033 initializer equal to zero. (Section 3.7.2)
4035 -fno-common gives strict ANSI behavior, though this tends to break
4036 a large body of code that grew up without this rule.
4038 Thread-local variables are never common, since there's no entrenched
4039 body of code to break, and it allows more efficient variable references
4040 in the presence of dynamic linking. */
4042 if (TREE_CODE (decl) == VAR_DECL
4044 && TREE_PUBLIC (decl)
4045 && !DECL_THREAD_LOCAL_P (decl)
4047 DECL_COMMON (decl) = 1;
4049 /* Set attributes here so if duplicate decl, will have proper attributes. */
4050 decl_attributes (&decl, attributes, 0);
4052 /* Handle gnu_inline attribute. */
4053 if (declspecs->inline_p
4054 && !flag_gnu89_inline
4055 && TREE_CODE (decl) == FUNCTION_DECL
4056 && (lookup_attribute ("gnu_inline", DECL_ATTRIBUTES (decl))
4057 || current_function_decl))
4059 if (declspecs->storage_class == csc_auto && current_scope != file_scope)
4061 else if (declspecs->storage_class != csc_static)
4062 DECL_EXTERNAL (decl) = !DECL_EXTERNAL (decl);
4065 if (TREE_CODE (decl) == FUNCTION_DECL
4066 && targetm.calls.promote_prototypes (TREE_TYPE (decl)))
4068 struct c_declarator *ce = declarator;
4070 if (ce->kind == cdk_pointer)
4071 ce = declarator->declarator;
4072 if (ce->kind == cdk_function)
4074 tree args = ce->u.arg_info->parms;
4075 for (; args; args = DECL_CHAIN (args))
4077 tree type = TREE_TYPE (args);
4078 if (type && INTEGRAL_TYPE_P (type)
4079 && TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node))
4080 DECL_ARG_TYPE (args) = integer_type_node;
4085 if (TREE_CODE (decl) == FUNCTION_DECL
4086 && DECL_DECLARED_INLINE_P (decl)
4087 && DECL_UNINLINABLE (decl)
4088 && lookup_attribute ("noinline", DECL_ATTRIBUTES (decl)))
4089 warning (OPT_Wattributes, "inline function %q+D given attribute noinline",
4092 /* C99 6.7.4p3: An inline definition of a function with external
4093 linkage shall not contain a definition of a modifiable object
4094 with static storage duration... */
4095 if (TREE_CODE (decl) == VAR_DECL
4096 && current_scope != file_scope
4097 && TREE_STATIC (decl)
4098 && !TREE_READONLY (decl)
4099 && DECL_DECLARED_INLINE_P (current_function_decl)
4100 && DECL_EXTERNAL (current_function_decl))
4101 record_inline_static (input_location, current_function_decl,
4102 decl, csi_modifiable);
4104 if (c_dialect_objc ()
4105 && (TREE_CODE (decl) == VAR_DECL
4106 || TREE_CODE (decl) == FUNCTION_DECL))
4107 objc_check_global_decl (decl);
4109 /* Add this decl to the current scope.
4110 TEM may equal DECL or it may be a previous decl of the same name. */
4111 tem = pushdecl (decl);
4113 if (initialized && DECL_EXTERNAL (tem))
4115 DECL_EXTERNAL (tem) = 0;
4116 TREE_STATIC (tem) = 1;
4122 /* Subroutine of finish_decl. TYPE is the type of an uninitialized object
4123 DECL or the non-array element type if DECL is an uninitialized array.
4124 If that type has a const member, diagnose this. */
4127 diagnose_uninitialized_cst_member (tree decl, tree type)
4130 for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
4133 if (TREE_CODE (field) != FIELD_DECL)
4135 field_type = strip_array_types (TREE_TYPE (field));
4137 if (TYPE_QUALS (field_type) & TYPE_QUAL_CONST)
4139 warning_at (DECL_SOURCE_LOCATION (decl), OPT_Wc___compat,
4140 "uninitialized const member in %qT is invalid in C++",
4141 strip_array_types (TREE_TYPE (decl)));
4142 inform (DECL_SOURCE_LOCATION (field), "%qD should be initialized", field);
4145 if (TREE_CODE (field_type) == RECORD_TYPE
4146 || TREE_CODE (field_type) == UNION_TYPE)
4147 diagnose_uninitialized_cst_member (decl, field_type);
4151 /* Finish processing of a declaration;
4152 install its initial value.
4153 If ORIGTYPE is not NULL_TREE, it is the original type of INIT.
4154 If the length of an array type is not known before,
4155 it must be determined now, from the initial value, or it is an error.
4157 INIT_LOC is the location of the initial value. */
4160 finish_decl (tree decl, location_t init_loc, tree init,
4161 tree origtype, tree asmspec_tree)
4164 bool was_incomplete = (DECL_SIZE (decl) == 0);
4165 const char *asmspec = 0;
4167 /* If a name was specified, get the string. */
4168 if ((TREE_CODE (decl) == FUNCTION_DECL || TREE_CODE (decl) == VAR_DECL)
4169 && DECL_FILE_SCOPE_P (decl))
4170 asmspec_tree = maybe_apply_renaming_pragma (decl, asmspec_tree);
4172 asmspec = TREE_STRING_POINTER (asmspec_tree);
4174 if (TREE_CODE (decl) == VAR_DECL
4175 && TREE_STATIC (decl)
4176 && global_bindings_p ())
4177 /* So decl is a global variable. Record the types it uses
4178 so that we can decide later to emit debug info for them. */
4179 record_types_used_by_current_var_decl (decl);
4181 /* If `start_decl' didn't like having an initialization, ignore it now. */
4182 if (init != 0 && DECL_INITIAL (decl) == 0)
4185 /* Don't crash if parm is initialized. */
4186 if (TREE_CODE (decl) == PARM_DECL)
4190 store_init_value (init_loc, decl, init, origtype);
4192 if (c_dialect_objc () && (TREE_CODE (decl) == VAR_DECL
4193 || TREE_CODE (decl) == FUNCTION_DECL
4194 || TREE_CODE (decl) == FIELD_DECL))
4195 objc_check_decl (decl);
4197 type = TREE_TYPE (decl);
4199 /* Deduce size of array from initialization, if not already known. */
4200 if (TREE_CODE (type) == ARRAY_TYPE
4201 && TYPE_DOMAIN (type) == 0
4202 && TREE_CODE (decl) != TYPE_DECL)
4205 = (TREE_STATIC (decl)
4206 /* Even if pedantic, an external linkage array
4207 may have incomplete type at first. */
4208 ? pedantic && !TREE_PUBLIC (decl)
4209 : !DECL_EXTERNAL (decl));
4211 = complete_array_type (&TREE_TYPE (decl), DECL_INITIAL (decl),
4214 /* Get the completed type made by complete_array_type. */
4215 type = TREE_TYPE (decl);
4220 error ("initializer fails to determine size of %q+D", decl);
4225 error ("array size missing in %q+D", decl);
4226 /* If a `static' var's size isn't known,
4227 make it extern as well as static, so it does not get
4229 If it is not `static', then do not mark extern;
4230 finish_incomplete_decl will give it a default size
4231 and it will get allocated. */
4232 else if (!pedantic && TREE_STATIC (decl) && !TREE_PUBLIC (decl))
4233 DECL_EXTERNAL (decl) = 1;
4237 error ("zero or negative size array %q+D", decl);
4241 /* For global variables, update the copy of the type that
4242 exists in the binding. */
4243 if (TREE_PUBLIC (decl))
4245 struct c_binding *b_ext = I_SYMBOL_BINDING (DECL_NAME (decl));
4246 while (b_ext && !B_IN_EXTERNAL_SCOPE (b_ext))
4247 b_ext = b_ext->shadowed;
4251 b_ext->u.type = composite_type (b_ext->u.type, type);
4253 b_ext->u.type = type;
4262 if (DECL_INITIAL (decl))
4263 TREE_TYPE (DECL_INITIAL (decl)) = type;
4265 relayout_decl (decl);
4268 if (TREE_CODE (decl) == VAR_DECL)
4270 if (init && TREE_CODE (init) == CONSTRUCTOR)
4271 add_flexible_array_elts_to_size (decl, init);
4273 if (DECL_SIZE (decl) == 0 && TREE_TYPE (decl) != error_mark_node
4274 && COMPLETE_TYPE_P (TREE_TYPE (decl)))
4275 layout_decl (decl, 0);
4277 if (DECL_SIZE (decl) == 0
4278 /* Don't give an error if we already gave one earlier. */
4279 && TREE_TYPE (decl) != error_mark_node
4280 && (TREE_STATIC (decl)
4281 /* A static variable with an incomplete type
4282 is an error if it is initialized.
4283 Also if it is not file scope.
4284 Otherwise, let it through, but if it is not `extern'
4285 then it may cause an error message later. */
4286 ? (DECL_INITIAL (decl) != 0
4287 || !DECL_FILE_SCOPE_P (decl))
4288 /* An automatic variable with an incomplete type
4290 : !DECL_EXTERNAL (decl)))
4292 error ("storage size of %q+D isn%'t known", decl);
4293 TREE_TYPE (decl) = error_mark_node;
4296 if ((DECL_EXTERNAL (decl) || TREE_STATIC (decl))
4297 && DECL_SIZE (decl) != 0)
4299 if (TREE_CODE (DECL_SIZE (decl)) == INTEGER_CST)
4300 constant_expression_warning (DECL_SIZE (decl));
4303 error ("storage size of %q+D isn%'t constant", decl);
4304 TREE_TYPE (decl) = error_mark_node;
4308 if (TREE_USED (type))
4310 TREE_USED (decl) = 1;
4311 DECL_READ_P (decl) = 1;
4315 /* If this is a function and an assembler name is specified, reset DECL_RTL
4316 so we can give it its new name. Also, update built_in_decls if it
4317 was a normal built-in. */
4318 if (TREE_CODE (decl) == FUNCTION_DECL && asmspec)
4320 if (DECL_BUILT_IN_CLASS (decl) == BUILT_IN_NORMAL)
4321 set_builtin_user_assembler_name (decl, asmspec);
4322 set_user_assembler_name (decl, asmspec);
4325 /* If #pragma weak was used, mark the decl weak now. */
4326 maybe_apply_pragma_weak (decl);
4328 /* Output the assembler code and/or RTL code for variables and functions,
4329 unless the type is an undefined structure or union.
4330 If not, it will get done when the type is completed. */
4332 if (TREE_CODE (decl) == VAR_DECL || TREE_CODE (decl) == FUNCTION_DECL)
4334 /* Determine the ELF visibility. */
4335 if (TREE_PUBLIC (decl))
4336 c_determine_visibility (decl);
4338 /* This is a no-op in c-lang.c or something real in objc-act.c. */
4339 if (c_dialect_objc ())
4340 objc_check_decl (decl);
4344 /* If this is not a static variable, issue a warning.
4345 It doesn't make any sense to give an ASMSPEC for an
4346 ordinary, non-register local variable. Historically,
4347 GCC has accepted -- but ignored -- the ASMSPEC in
4349 if (!DECL_FILE_SCOPE_P (decl)
4350 && TREE_CODE (decl) == VAR_DECL
4351 && !C_DECL_REGISTER (decl)
4352 && !TREE_STATIC (decl))
4353 warning (0, "ignoring asm-specifier for non-static local "
4354 "variable %q+D", decl);
4356 set_user_assembler_name (decl, asmspec);
4359 if (DECL_FILE_SCOPE_P (decl))
4361 if (DECL_INITIAL (decl) == NULL_TREE
4362 || DECL_INITIAL (decl) == error_mark_node)
4363 /* Don't output anything
4364 when a tentative file-scope definition is seen.
4365 But at end of compilation, do output code for them. */
4366 DECL_DEFER_OUTPUT (decl) = 1;
4367 rest_of_decl_compilation (decl, true, 0);
4371 /* In conjunction with an ASMSPEC, the `register'
4372 keyword indicates that we should place the variable
4373 in a particular register. */
4374 if (asmspec && C_DECL_REGISTER (decl))
4376 DECL_HARD_REGISTER (decl) = 1;
4377 /* This cannot be done for a structure with volatile
4378 fields, on which DECL_REGISTER will have been
4380 if (!DECL_REGISTER (decl))
4381 error ("cannot put object with volatile field into register");
4384 if (TREE_CODE (decl) != FUNCTION_DECL)
4386 /* If we're building a variable sized type, and we might be
4387 reachable other than via the top of the current binding
4388 level, then create a new BIND_EXPR so that we deallocate
4389 the object at the right time. */
4390 /* Note that DECL_SIZE can be null due to errors. */
4391 if (DECL_SIZE (decl)
4392 && !TREE_CONSTANT (DECL_SIZE (decl))
4393 && STATEMENT_LIST_HAS_LABEL (cur_stmt_list))
4396 bind = build3 (BIND_EXPR, void_type_node, NULL, NULL, NULL);
4397 TREE_SIDE_EFFECTS (bind) = 1;
4399 BIND_EXPR_BODY (bind) = push_stmt_list ();
4401 add_stmt (build_stmt (DECL_SOURCE_LOCATION (decl),
4407 if (!DECL_FILE_SCOPE_P (decl))
4409 /* Recompute the RTL of a local array now
4410 if it used to be an incomplete type. */
4412 && !TREE_STATIC (decl) && !DECL_EXTERNAL (decl))
4414 /* If we used it already as memory, it must stay in memory. */
4415 TREE_ADDRESSABLE (decl) = TREE_USED (decl);
4416 /* If it's still incomplete now, no init will save it. */
4417 if (DECL_SIZE (decl) == 0)
4418 DECL_INITIAL (decl) = 0;
4423 if (TREE_CODE (decl) == TYPE_DECL)
4425 if (!DECL_FILE_SCOPE_P (decl)
4426 && variably_modified_type_p (TREE_TYPE (decl), NULL_TREE))
4427 add_stmt (build_stmt (DECL_SOURCE_LOCATION (decl), DECL_EXPR, decl));
4429 rest_of_decl_compilation (decl, DECL_FILE_SCOPE_P (decl), 0);
4432 /* At the end of a declaration, throw away any variable type sizes
4433 of types defined inside that declaration. There is no use
4434 computing them in the following function definition. */
4435 if (current_scope == file_scope)
4436 get_pending_sizes ();
4438 /* Install a cleanup (aka destructor) if one was given. */
4439 if (TREE_CODE (decl) == VAR_DECL && !TREE_STATIC (decl))
4441 tree attr = lookup_attribute ("cleanup", DECL_ATTRIBUTES (decl));
4444 tree cleanup_id = TREE_VALUE (TREE_VALUE (attr));
4445 tree cleanup_decl = lookup_name (cleanup_id);
4449 /* Build "cleanup(&decl)" for the destructor. */
4450 cleanup = build_unary_op (input_location, ADDR_EXPR, decl, 0);
4451 vec = VEC_alloc (tree, gc, 1);
4452 VEC_quick_push (tree, vec, cleanup);
4453 cleanup = build_function_call_vec (DECL_SOURCE_LOCATION (decl),
4454 cleanup_decl, vec, NULL);
4455 VEC_free (tree, gc, vec);
4457 /* Don't warn about decl unused; the cleanup uses it. */
4458 TREE_USED (decl) = 1;
4459 TREE_USED (cleanup_decl) = 1;
4460 DECL_READ_P (decl) = 1;
4462 push_cleanup (decl, cleanup, false);
4467 && TREE_CODE (decl) == VAR_DECL
4468 && !DECL_EXTERNAL (decl)
4469 && DECL_INITIAL (decl) == NULL_TREE)
4471 type = strip_array_types (type);
4472 if (TREE_READONLY (decl))
4473 warning_at (DECL_SOURCE_LOCATION (decl), OPT_Wc___compat,
4474 "uninitialized const %qD is invalid in C++", decl);
4475 else if ((TREE_CODE (type) == RECORD_TYPE
4476 || TREE_CODE (type) == UNION_TYPE)
4477 && C_TYPE_FIELDS_READONLY (type))
4478 diagnose_uninitialized_cst_member (decl, type);
4482 /* Given a parsed parameter declaration, decode it into a PARM_DECL. */
4485 grokparm (const struct c_parm *parm)
4487 tree attrs = parm->attrs;
4488 tree decl = grokdeclarator (parm->declarator, parm->specs, PARM, false,
4489 NULL, &attrs, NULL, NULL, DEPRECATED_NORMAL);
4491 decl_attributes (&decl, attrs, 0);
4496 /* Given a parsed parameter declaration, decode it into a PARM_DECL
4497 and push that on the current scope. */
4500 push_parm_decl (const struct c_parm *parm)
4502 tree attrs = parm->attrs;
4505 decl = grokdeclarator (parm->declarator, parm->specs, PARM, false, NULL,
4506 &attrs, NULL, NULL, DEPRECATED_NORMAL);
4507 decl_attributes (&decl, attrs, 0);
4509 decl = pushdecl (decl);
4511 finish_decl (decl, input_location, NULL_TREE, NULL_TREE, NULL_TREE);
4514 /* Mark all the parameter declarations to date as forward decls.
4515 Also diagnose use of this extension. */
4518 mark_forward_parm_decls (void)
4520 struct c_binding *b;
4522 if (pedantic && !current_scope->warned_forward_parm_decls)
4524 pedwarn (input_location, OPT_pedantic,
4525 "ISO C forbids forward parameter declarations");
4526 current_scope->warned_forward_parm_decls = true;
4529 for (b = current_scope->bindings; b; b = b->prev)
4530 if (TREE_CODE (b->decl) == PARM_DECL)
4531 TREE_ASM_WRITTEN (b->decl) = 1;
4534 /* Build a COMPOUND_LITERAL_EXPR. TYPE is the type given in the compound
4535 literal, which may be an incomplete array type completed by the
4536 initializer; INIT is a CONSTRUCTOR at LOC that initializes the compound
4537 literal. NON_CONST is true if the initializers contain something
4538 that cannot occur in a constant expression. */
4541 build_compound_literal (location_t loc, tree type, tree init, bool non_const)
4543 /* We do not use start_decl here because we have a type, not a declarator;
4544 and do not use finish_decl because the decl should be stored inside
4545 the COMPOUND_LITERAL_EXPR rather than added elsewhere as a DECL_EXPR. */
4550 if (type == error_mark_node
4551 || init == error_mark_node)
4552 return error_mark_node;
4554 decl = build_decl (loc, VAR_DECL, NULL_TREE, type);
4555 DECL_EXTERNAL (decl) = 0;
4556 TREE_PUBLIC (decl) = 0;
4557 TREE_STATIC (decl) = (current_scope == file_scope);
4558 DECL_CONTEXT (decl) = current_function_decl;
4559 TREE_USED (decl) = 1;
4560 DECL_READ_P (decl) = 1;
4561 TREE_TYPE (decl) = type;
4562 TREE_READONLY (decl) = TYPE_READONLY (type);
4563 store_init_value (loc, decl, init, NULL_TREE);
4565 if (TREE_CODE (type) == ARRAY_TYPE && !COMPLETE_TYPE_P (type))
4567 int failure = complete_array_type (&TREE_TYPE (decl),
4568 DECL_INITIAL (decl), true);
4569 gcc_assert (!failure);
4571 type = TREE_TYPE (decl);
4572 TREE_TYPE (DECL_INITIAL (decl)) = type;
4575 if (type == error_mark_node || !COMPLETE_TYPE_P (type))
4576 return error_mark_node;
4578 stmt = build_stmt (DECL_SOURCE_LOCATION (decl), DECL_EXPR, decl);
4579 complit = build1 (COMPOUND_LITERAL_EXPR, type, stmt);
4580 TREE_SIDE_EFFECTS (complit) = 1;
4582 layout_decl (decl, 0);
4584 if (TREE_STATIC (decl))
4586 /* This decl needs a name for the assembler output. */
4587 set_compound_literal_name (decl);
4588 DECL_DEFER_OUTPUT (decl) = 1;
4589 DECL_COMDAT (decl) = 1;
4590 DECL_ARTIFICIAL (decl) = 1;
4591 DECL_IGNORED_P (decl) = 1;
4593 rest_of_decl_compilation (decl, 1, 0);
4598 complit = build2 (C_MAYBE_CONST_EXPR, type, NULL, complit);
4599 C_MAYBE_CONST_EXPR_NON_CONST (complit) = 1;
4605 /* Check the type of a compound literal. Here we just check that it
4606 is valid for C++. */
4609 check_compound_literal_type (location_t loc, struct c_type_name *type_name)
4612 && (type_name->specs->typespec_kind == ctsk_tagdef
4613 || type_name->specs->typespec_kind == ctsk_tagfirstref))
4614 warning_at (loc, OPT_Wc___compat,
4615 "defining a type in a compound literal is invalid in C++");
4618 /* Determine whether TYPE is a structure with a flexible array member,
4619 or a union containing such a structure (possibly recursively). */
4622 flexible_array_type_p (tree type)
4625 switch (TREE_CODE (type))
4628 x = TYPE_FIELDS (type);
4631 while (DECL_CHAIN (x) != NULL_TREE)
4633 if (TREE_CODE (TREE_TYPE (x)) == ARRAY_TYPE
4634 && TYPE_SIZE (TREE_TYPE (x)) == NULL_TREE
4635 && TYPE_DOMAIN (TREE_TYPE (x)) != NULL_TREE
4636 && TYPE_MAX_VALUE (TYPE_DOMAIN (TREE_TYPE (x))) == NULL_TREE)
4640 for (x = TYPE_FIELDS (type); x != NULL_TREE; x = DECL_CHAIN (x))
4642 if (flexible_array_type_p (TREE_TYPE (x)))
4651 /* Performs sanity checks on the TYPE and WIDTH of the bit-field NAME,
4652 replacing with appropriate values if they are invalid. */
4654 check_bitfield_type_and_width (tree *type, tree *width, tree orig_name)
4657 unsigned int max_width;
4658 unsigned HOST_WIDE_INT w;
4659 const char *name = (orig_name
4660 ? identifier_to_locale (IDENTIFIER_POINTER (orig_name))
4661 : _("<anonymous>"));
4663 /* Detect and ignore out of range field width and process valid
4665 if (!INTEGRAL_TYPE_P (TREE_TYPE (*width)))
4667 error ("bit-field %qs width not an integer constant", name);
4668 *width = integer_one_node;
4672 if (TREE_CODE (*width) != INTEGER_CST)
4674 *width = c_fully_fold (*width, false, NULL);
4675 if (TREE_CODE (*width) == INTEGER_CST)
4676 pedwarn (input_location, OPT_pedantic,
4677 "bit-field %qs width not an integer constant expression",
4680 if (TREE_CODE (*width) != INTEGER_CST)
4682 error ("bit-field %qs width not an integer constant", name);
4683 *width = integer_one_node;
4685 constant_expression_warning (*width);
4686 if (tree_int_cst_sgn (*width) < 0)
4688 error ("negative width in bit-field %qs", name);
4689 *width = integer_one_node;
4691 else if (integer_zerop (*width) && orig_name)
4693 error ("zero width for bit-field %qs", name);
4694 *width = integer_one_node;
4698 /* Detect invalid bit-field type. */
4699 if (TREE_CODE (*type) != INTEGER_TYPE
4700 && TREE_CODE (*type) != BOOLEAN_TYPE
4701 && TREE_CODE (*type) != ENUMERAL_TYPE)
4703 error ("bit-field %qs has invalid type", name);
4704 *type = unsigned_type_node;
4707 type_mv = TYPE_MAIN_VARIANT (*type);
4708 if (!in_system_header
4709 && type_mv != integer_type_node
4710 && type_mv != unsigned_type_node
4711 && type_mv != boolean_type_node)
4712 pedwarn (input_location, OPT_pedantic,
4713 "type of bit-field %qs is a GCC extension", name);
4715 max_width = TYPE_PRECISION (*type);
4717 if (0 < compare_tree_int (*width, max_width))
4719 error ("width of %qs exceeds its type", name);
4721 *width = build_int_cst (NULL_TREE, w);
4724 w = tree_low_cst (*width, 1);
4726 if (TREE_CODE (*type) == ENUMERAL_TYPE)
4728 struct lang_type *lt = TYPE_LANG_SPECIFIC (*type);
4730 || w < tree_int_cst_min_precision (lt->enum_min, TYPE_UNSIGNED (*type))
4731 || w < tree_int_cst_min_precision (lt->enum_max, TYPE_UNSIGNED (*type)))
4732 warning (0, "%qs is narrower than values of its type", name);
4738 /* Print warning about variable length array if necessary. */
4741 warn_variable_length_array (tree name, tree size)
4743 int const_size = TREE_CONSTANT (size);
4745 if (!flag_isoc99 && pedantic && warn_vla != 0)
4750 pedwarn (input_location, OPT_Wvla,
4751 "ISO C90 forbids array %qE whose size "
4752 "can%'t be evaluated",
4755 pedwarn (input_location, OPT_Wvla, "ISO C90 forbids array whose size "
4756 "can%'t be evaluated");
4761 pedwarn (input_location, OPT_Wvla,
4762 "ISO C90 forbids variable length array %qE",
4765 pedwarn (input_location, OPT_Wvla, "ISO C90 forbids variable length array");
4768 else if (warn_vla > 0)
4774 "the size of array %qE can"
4775 "%'t be evaluated", name);
4778 "the size of array can %'t be evaluated");
4784 "variable length array %qE is used",
4788 "variable length array is used");
4793 /* Given a size SIZE that may not be a constant, return a SAVE_EXPR to
4794 serve as the actual size-expression for a type or decl. This is
4795 like variable_size in stor-layout.c, but we make global_bindings_p
4796 return negative to avoid calls to that function from outside the
4797 front end resulting in errors at file scope, then call this version
4798 instead from front-end code. */
4801 c_variable_size (tree size)
4805 if (TREE_CONSTANT (size))
4808 size = save_expr (size);
4810 save = skip_simple_arithmetic (size);
4812 if (cfun && cfun->dont_save_pending_sizes_p)
4815 if (!global_bindings_p ())
4816 put_pending_size (save);
4821 /* Given declspecs and a declarator,
4822 determine the name and type of the object declared
4823 and construct a ..._DECL node for it.
4824 (In one case we can return a ..._TYPE node instead.
4825 For invalid input we sometimes return 0.)
4827 DECLSPECS is a c_declspecs structure for the declaration specifiers.
4829 DECL_CONTEXT says which syntactic context this declaration is in:
4830 NORMAL for most contexts. Make a VAR_DECL or FUNCTION_DECL or TYPE_DECL.
4831 FUNCDEF for a function definition. Like NORMAL but a few different
4832 error messages in each case. Return value may be zero meaning
4833 this definition is too screwy to try to parse.
4834 PARM for a parameter declaration (either within a function prototype
4835 or before a function body). Make a PARM_DECL, or return void_type_node.
4836 TYPENAME if for a typename (in a cast or sizeof).
4837 Don't make a DECL node; just return the ..._TYPE node.
4838 FIELD for a struct or union field; make a FIELD_DECL.
4839 INITIALIZED is true if the decl has an initializer.
4840 WIDTH is non-NULL for bit-fields, and is a pointer to an INTEGER_CST node
4841 representing the width of the bit-field.
4842 DECL_ATTRS points to the list of attributes that should be added to this
4843 decl. Any nested attributes that belong on the decl itself will be
4845 If EXPR is not NULL, any expressions that need to be evaluated as
4846 part of evaluating variably modified types will be stored in *EXPR.
4847 If EXPR_CONST_OPERANDS is not NULL, *EXPR_CONST_OPERANDS will be
4848 set to indicate whether operands in *EXPR can be used in constant
4850 DEPRECATED_STATE is a deprecated_states value indicating whether
4851 deprecation warnings should be suppressed.
4853 In the TYPENAME case, DECLARATOR is really an absolute declarator.
4854 It may also be so in the PARM case, for a prototype where the
4855 argument type is specified but not the name.
4857 This function is where the complicated C meanings of `static'
4858 and `extern' are interpreted. */
4861 grokdeclarator (const struct c_declarator *declarator,
4862 struct c_declspecs *declspecs,
4863 enum decl_context decl_context, bool initialized, tree *width,
4864 tree *decl_attrs, tree *expr, bool *expr_const_operands,
4865 enum deprecated_states deprecated_state)
4867 tree type = declspecs->type;
4868 bool threadp = declspecs->thread_p;
4869 enum c_storage_class storage_class = declspecs->storage_class;
4873 int type_quals = TYPE_UNQUALIFIED;
4874 tree name = NULL_TREE;
4875 bool funcdef_flag = false;
4876 bool funcdef_syntax = false;
4877 bool size_varies = false;
4878 tree decl_attr = declspecs->decl_attr;
4879 int array_ptr_quals = TYPE_UNQUALIFIED;
4880 tree array_ptr_attrs = NULL_TREE;
4881 int array_parm_static = 0;
4882 bool array_parm_vla_unspec_p = false;
4883 tree returned_attrs = NULL_TREE;
4884 bool bitfield = width != NULL;
4886 struct c_arg_info *arg_info = 0;
4887 addr_space_t as1, as2, address_space;
4888 location_t loc = UNKNOWN_LOCATION;
4891 bool expr_const_operands_dummy;
4893 if (TREE_CODE (type) == ERROR_MARK)
4894 return error_mark_node;
4897 if (expr_const_operands == NULL)
4898 expr_const_operands = &expr_const_operands_dummy;
4900 *expr = declspecs->expr;
4901 *expr_const_operands = declspecs->expr_const_operands;
4903 if (decl_context == FUNCDEF)
4904 funcdef_flag = true, decl_context = NORMAL;
4906 /* Look inside a declarator for the name being declared
4907 and get it as an IDENTIFIER_NODE, for an error message. */
4909 const struct c_declarator *decl = declarator;
4920 funcdef_syntax = (decl->kind == cdk_function);
4921 decl = decl->declarator;
4925 decl = decl->declarator;
4940 gcc_assert (decl_context == PARM
4941 || decl_context == TYPENAME
4942 || (decl_context == FIELD
4943 && declarator->kind == cdk_id));
4944 gcc_assert (!initialized);
4948 /* A function definition's declarator must have the form of
4949 a function declarator. */
4951 if (funcdef_flag && !funcdef_syntax)
4954 /* If this looks like a function definition, make it one,
4955 even if it occurs where parms are expected.
4956 Then store_parm_decls will reject it and not use it as a parm. */
4957 if (decl_context == NORMAL && !funcdef_flag && current_scope->parm_flag)
4958 decl_context = PARM;
4960 if (declspecs->deprecated_p && deprecated_state != DEPRECATED_SUPPRESS)
4961 warn_deprecated_use (declspecs->type, declspecs->decl_attr);
4963 if ((decl_context == NORMAL || decl_context == FIELD)
4964 && current_scope == file_scope
4965 && variably_modified_type_p (type, NULL_TREE))
4968 error_at (loc, "variably modified %qE at file scope", name);
4970 error_at (loc, "variably modified field at file scope");
4971 type = integer_type_node;
4974 size_varies = C_TYPE_VARIABLE_SIZE (type) != 0;
4976 /* Diagnose defaulting to "int". */
4978 if (declspecs->default_int_p && !in_system_header)
4980 /* Issue a warning if this is an ISO C 99 program or if
4981 -Wreturn-type and this is a function, or if -Wimplicit;
4982 prefer the former warning since it is more explicit. */
4983 if ((warn_implicit_int || warn_return_type || flag_isoc99)
4985 warn_about_return_type = 1;
4989 pedwarn_c99 (loc, flag_isoc99 ? 0 : OPT_Wimplicit_int,
4990 "type defaults to %<int%> in declaration of %qE",
4993 pedwarn_c99 (input_location, flag_isoc99 ? 0 : OPT_Wimplicit_int,
4994 "type defaults to %<int%> in type name");
4998 /* Adjust the type if a bit-field is being declared,
4999 -funsigned-bitfields applied and the type is not explicitly
5001 if (bitfield && !flag_signed_bitfields && !declspecs->explicit_signed_p
5002 && TREE_CODE (type) == INTEGER_TYPE)
5003 type = unsigned_type_for (type);
5005 /* Figure out the type qualifiers for the declaration. There are
5006 two ways a declaration can become qualified. One is something
5007 like `const int i' where the `const' is explicit. Another is
5008 something like `typedef const int CI; CI i' where the type of the
5009 declaration contains the `const'. A third possibility is that
5010 there is a type qualifier on the element type of a typedefed
5011 array type, in which case we should extract that qualifier so
5012 that c_apply_type_quals_to_decl receives the full list of
5013 qualifiers to work with (C90 is not entirely clear about whether
5014 duplicate qualifiers should be diagnosed in this case, but it
5015 seems most appropriate to do so). */
5016 element_type = strip_array_types (type);
5017 constp = declspecs->const_p + TYPE_READONLY (element_type);
5018 restrictp = declspecs->restrict_p + TYPE_RESTRICT (element_type);
5019 volatilep = declspecs->volatile_p + TYPE_VOLATILE (element_type);
5020 as1 = declspecs->address_space;
5021 as2 = TYPE_ADDR_SPACE (element_type);
5022 address_space = ADDR_SPACE_GENERIC_P (as1)? as2 : as1;
5024 if (pedantic && !flag_isoc99)
5027 pedwarn (loc, OPT_pedantic, "duplicate %<const%>");
5029 pedwarn (loc, OPT_pedantic, "duplicate %<restrict%>");
5031 pedwarn (loc, OPT_pedantic, "duplicate %<volatile%>");
5034 if (!ADDR_SPACE_GENERIC_P (as1) && !ADDR_SPACE_GENERIC_P (as2) && as1 != as2)
5035 error_at (loc, "conflicting named address spaces (%s vs %s)",
5036 c_addr_space_name (as1), c_addr_space_name (as2));
5038 if (!flag_gen_aux_info && (TYPE_QUALS (element_type)))
5039 type = TYPE_MAIN_VARIANT (type);
5040 type_quals = ((constp ? TYPE_QUAL_CONST : 0)
5041 | (restrictp ? TYPE_QUAL_RESTRICT : 0)
5042 | (volatilep ? TYPE_QUAL_VOLATILE : 0)
5043 | ENCODE_QUAL_ADDR_SPACE (address_space));
5045 /* Warn about storage classes that are invalid for certain
5046 kinds of declarations (parameters, typenames, etc.). */
5050 || storage_class == csc_auto
5051 || storage_class == csc_register
5052 || storage_class == csc_typedef))
5054 if (storage_class == csc_auto)
5056 (current_scope == file_scope) ? 0 : OPT_pedantic,
5057 "function definition declared %<auto%>");
5058 if (storage_class == csc_register)
5059 error_at (loc, "function definition declared %<register%>");
5060 if (storage_class == csc_typedef)
5061 error_at (loc, "function definition declared %<typedef%>");
5063 error_at (loc, "function definition declared %<__thread%>");
5065 if (storage_class == csc_auto
5066 || storage_class == csc_register
5067 || storage_class == csc_typedef)
5068 storage_class = csc_none;
5070 else if (decl_context != NORMAL && (storage_class != csc_none || threadp))
5072 if (decl_context == PARM && storage_class == csc_register)
5076 switch (decl_context)
5080 error_at (loc, "storage class specified for structure "
5083 error_at (loc, "storage class specified for structure field");
5087 error_at (loc, "storage class specified for parameter %qE",
5090 error_at (loc, "storage class specified for unnamed parameter");
5093 error_at (loc, "storage class specified for typename");
5096 storage_class = csc_none;
5100 else if (storage_class == csc_extern
5104 /* 'extern' with initialization is invalid if not at file scope. */
5105 if (current_scope == file_scope)
5107 /* It is fine to have 'extern const' when compiling at C
5108 and C++ intersection. */
5109 if (!(warn_cxx_compat && constp))
5110 warning_at (loc, 0, "%qE initialized and declared %<extern%>",
5114 error_at (loc, "%qE has both %<extern%> and initializer", name);
5116 else if (current_scope == file_scope)
5118 if (storage_class == csc_auto)
5119 error_at (loc, "file-scope declaration of %qE specifies %<auto%>",
5121 if (pedantic && storage_class == csc_register)
5122 pedwarn (input_location, OPT_pedantic,
5123 "file-scope declaration of %qE specifies %<register%>", name);
5127 if (storage_class == csc_extern && funcdef_flag)
5128 error_at (loc, "nested function %qE declared %<extern%>", name);
5129 else if (threadp && storage_class == csc_none)
5131 error_at (loc, "function-scope %qE implicitly auto and declared "
5138 /* Now figure out the structure of the declarator proper.
5139 Descend through it, creating more complex types, until we reach
5140 the declared identifier (or NULL_TREE, in an absolute declarator).
5141 At each stage we maintain an unqualified version of the type
5142 together with any qualifiers that should be applied to it with
5143 c_build_qualified_type; this way, array types including
5144 multidimensional array types are first built up in unqualified
5145 form and then the qualified form is created with
5146 TYPE_MAIN_VARIANT pointing to the unqualified form. */
5148 while (declarator && declarator->kind != cdk_id)
5150 if (type == error_mark_node)
5152 declarator = declarator->declarator;
5156 /* Each level of DECLARATOR is either a cdk_array (for ...[..]),
5157 a cdk_pointer (for *...),
5158 a cdk_function (for ...(...)),
5159 a cdk_attrs (for nested attributes),
5160 or a cdk_id (for the name being declared
5161 or the place in an absolute declarator
5162 where the name was omitted).
5163 For the last case, we have just exited the loop.
5165 At this point, TYPE is the type of elements of an array,
5166 or for a function to return, or for a pointer to point to.
5167 After this sequence of ifs, TYPE is the type of the
5168 array or function or pointer, and DECLARATOR has had its
5169 outermost layer removed. */
5171 if (array_ptr_quals != TYPE_UNQUALIFIED
5172 || array_ptr_attrs != NULL_TREE
5173 || array_parm_static)
5175 /* Only the innermost declarator (making a parameter be of
5176 array type which is converted to pointer type)
5177 may have static or type qualifiers. */
5178 error_at (loc, "static or type qualifiers in non-parameter array declarator");
5179 array_ptr_quals = TYPE_UNQUALIFIED;
5180 array_ptr_attrs = NULL_TREE;
5181 array_parm_static = 0;
5184 switch (declarator->kind)
5188 /* A declarator with embedded attributes. */
5189 tree attrs = declarator->u.attrs;
5190 const struct c_declarator *inner_decl;
5192 declarator = declarator->declarator;
5193 inner_decl = declarator;
5194 while (inner_decl->kind == cdk_attrs)
5195 inner_decl = inner_decl->declarator;
5196 if (inner_decl->kind == cdk_id)
5197 attr_flags |= (int) ATTR_FLAG_DECL_NEXT;
5198 else if (inner_decl->kind == cdk_function)
5199 attr_flags |= (int) ATTR_FLAG_FUNCTION_NEXT;
5200 else if (inner_decl->kind == cdk_array)
5201 attr_flags |= (int) ATTR_FLAG_ARRAY_NEXT;
5202 returned_attrs = decl_attributes (&type,
5203 chainon (returned_attrs, attrs),
5209 tree itype = NULL_TREE;
5210 tree size = declarator->u.array.dimen;
5211 /* The index is a signed object `sizetype' bits wide. */
5212 tree index_type = c_common_signed_type (sizetype);
5214 array_ptr_quals = declarator->u.array.quals;
5215 array_ptr_attrs = declarator->u.array.attrs;
5216 array_parm_static = declarator->u.array.static_p;
5217 array_parm_vla_unspec_p = declarator->u.array.vla_unspec_p;
5219 declarator = declarator->declarator;
5221 /* Check for some types that there cannot be arrays of. */
5223 if (VOID_TYPE_P (type))
5226 error_at (loc, "declaration of %qE as array of voids", name);
5228 error_at (loc, "declaration of type name as array of voids");
5229 type = error_mark_node;
5232 if (TREE_CODE (type) == FUNCTION_TYPE)
5235 error_at (loc, "declaration of %qE as array of functions",
5238 error_at (loc, "declaration of type name as array of "
5240 type = error_mark_node;
5243 if (pedantic && !in_system_header && flexible_array_type_p (type))
5244 pedwarn (loc, OPT_pedantic,
5245 "invalid use of structure with flexible array member");
5247 if (size == error_mark_node)
5248 type = error_mark_node;
5250 if (type == error_mark_node)
5253 /* If size was specified, set ITYPE to a range-type for
5254 that size. Otherwise, ITYPE remains null. finish_decl
5255 may figure it out from an initial value. */
5259 bool size_maybe_const = true;
5260 bool size_int_const = (TREE_CODE (size) == INTEGER_CST
5261 && !TREE_OVERFLOW (size));
5262 bool this_size_varies = false;
5264 /* Strip NON_LVALUE_EXPRs since we aren't using as an
5266 STRIP_TYPE_NOPS (size);
5268 if (!INTEGRAL_TYPE_P (TREE_TYPE (size)))
5271 error_at (loc, "size of array %qE has non-integer type",
5275 "size of unnamed array has non-integer type");
5276 size = integer_one_node;
5279 size = c_fully_fold (size, false, &size_maybe_const);
5281 if (pedantic && size_maybe_const && integer_zerop (size))
5284 pedwarn (loc, OPT_pedantic,
5285 "ISO C forbids zero-size array %qE", name);
5287 pedwarn (loc, OPT_pedantic,
5288 "ISO C forbids zero-size array");
5291 if (TREE_CODE (size) == INTEGER_CST && size_maybe_const)
5293 constant_expression_warning (size);
5294 if (tree_int_cst_sgn (size) < 0)
5297 error_at (loc, "size of array %qE is negative", name);
5299 error_at (loc, "size of unnamed array is negative");
5300 size = integer_one_node;
5302 /* Handle a size folded to an integer constant but
5303 not an integer constant expression. */
5304 if (!size_int_const)
5306 /* If this is a file scope declaration of an
5307 ordinary identifier, this is invalid code;
5308 diagnosing it here and not subsequently
5309 treating the type as variable-length avoids
5310 more confusing diagnostics later. */
5311 if ((decl_context == NORMAL || decl_context == FIELD)
5312 && current_scope == file_scope)
5313 pedwarn (input_location, 0,
5314 "variably modified %qE at file scope",
5317 this_size_varies = size_varies = true;
5318 warn_variable_length_array (name, size);
5321 else if ((decl_context == NORMAL || decl_context == FIELD)
5322 && current_scope == file_scope)
5324 error_at (loc, "variably modified %qE at file scope", name);
5325 size = integer_one_node;
5329 /* Make sure the array size remains visibly
5330 nonconstant even if it is (eg) a const variable
5331 with known value. */
5332 this_size_varies = size_varies = true;
5333 warn_variable_length_array (name, size);
5336 if (integer_zerop (size) && !this_size_varies)
5338 /* A zero-length array cannot be represented with
5339 an unsigned index type, which is what we'll
5340 get with build_index_type. Create an
5341 open-ended range instead. */
5342 itype = build_range_type (sizetype, size, NULL_TREE);
5346 /* Arrange for the SAVE_EXPR on the inside of the
5347 MINUS_EXPR, which allows the -1 to get folded
5348 with the +1 that happens when building TYPE_SIZE. */
5350 size = c_variable_size (size);
5351 if (this_size_varies && TREE_CODE (size) == INTEGER_CST)
5352 size = build2 (COMPOUND_EXPR, TREE_TYPE (size),
5353 integer_zero_node, size);
5355 /* Compute the maximum valid index, that is, size
5356 - 1. Do the calculation in index_type, so that
5357 if it is a variable the computations will be
5358 done in the proper mode. */
5359 itype = fold_build2_loc (loc, MINUS_EXPR, index_type,
5360 convert (index_type, size),
5361 convert (index_type,
5364 /* If that overflowed, the array is too big. ???
5365 While a size of INT_MAX+1 technically shouldn't
5366 cause an overflow (because we subtract 1), the
5367 overflow is recorded during the conversion to
5368 index_type, before the subtraction. Handling
5369 this case seems like an unnecessary
5371 if (TREE_CODE (itype) == INTEGER_CST
5372 && TREE_OVERFLOW (itype))
5375 error_at (loc, "size of array %qE is too large",
5378 error_at (loc, "size of unnamed array is too large");
5379 type = error_mark_node;
5383 itype = build_index_type (itype);
5385 if (this_size_varies)
5388 *expr = build2 (COMPOUND_EXPR, TREE_TYPE (size),
5392 *expr_const_operands &= size_maybe_const;
5395 else if (decl_context == FIELD)
5397 bool flexible_array_member = false;
5398 if (array_parm_vla_unspec_p)
5399 /* Field names can in fact have function prototype
5400 scope so [*] is disallowed here through making
5401 the field variably modified, not through being
5402 something other than a declaration with function
5407 const struct c_declarator *t = declarator;
5408 while (t->kind == cdk_attrs)
5410 flexible_array_member = (t->kind == cdk_id);
5412 if (flexible_array_member
5413 && pedantic && !flag_isoc99 && !in_system_header)
5414 pedwarn (loc, OPT_pedantic,
5415 "ISO C90 does not support flexible array members");
5417 /* ISO C99 Flexible array members are effectively
5418 identical to GCC's zero-length array extension. */
5419 if (flexible_array_member || array_parm_vla_unspec_p)
5420 itype = build_range_type (sizetype, size_zero_node,
5423 else if (decl_context == PARM)
5425 if (array_parm_vla_unspec_p)
5427 itype = build_range_type (sizetype, size_zero_node, NULL_TREE);
5431 else if (decl_context == TYPENAME)
5433 if (array_parm_vla_unspec_p)
5436 warning (0, "%<[*]%> not in a declaration");
5437 /* We use this to avoid messing up with incomplete
5438 array types of the same type, that would
5439 otherwise be modified below. */
5440 itype = build_range_type (sizetype, size_zero_node,
5446 /* Complain about arrays of incomplete types. */
5447 if (!COMPLETE_TYPE_P (type))
5449 error_at (loc, "array type has incomplete element type");
5450 type = error_mark_node;
5453 /* When itype is NULL, a shared incomplete array type is
5454 returned for all array of a given type. Elsewhere we
5455 make sure we don't complete that type before copying
5456 it, but here we want to make sure we don't ever
5457 modify the shared type, so we gcc_assert (itype)
5460 addr_space_t as = DECODE_QUAL_ADDR_SPACE (type_quals);
5461 if (!ADDR_SPACE_GENERIC_P (as) && as != TYPE_ADDR_SPACE (type))
5462 type = build_qualified_type (type,
5463 ENCODE_QUAL_ADDR_SPACE (as));
5465 type = build_array_type (type, itype);
5468 if (type != error_mark_node)
5472 /* It is ok to modify type here even if itype is
5473 NULL: if size_varies, we're in a
5474 multi-dimensional array and the inner type has
5475 variable size, so the enclosing shared array type
5477 if (size && TREE_CODE (size) == INTEGER_CST)
5479 = build_distinct_type_copy (TYPE_MAIN_VARIANT (type));
5480 C_TYPE_VARIABLE_SIZE (type) = 1;
5483 /* The GCC extension for zero-length arrays differs from
5484 ISO flexible array members in that sizeof yields
5486 if (size && integer_zerop (size))
5489 type = build_distinct_type_copy (TYPE_MAIN_VARIANT (type));
5490 TYPE_SIZE (type) = bitsize_zero_node;
5491 TYPE_SIZE_UNIT (type) = size_zero_node;
5492 SET_TYPE_STRUCTURAL_EQUALITY (type);
5494 if (array_parm_vla_unspec_p)
5497 /* The type is complete. C99 6.7.5.2p4 */
5498 type = build_distinct_type_copy (TYPE_MAIN_VARIANT (type));
5499 TYPE_SIZE (type) = bitsize_zero_node;
5500 TYPE_SIZE_UNIT (type) = size_zero_node;
5501 SET_TYPE_STRUCTURAL_EQUALITY (type);
5505 if (decl_context != PARM
5506 && (array_ptr_quals != TYPE_UNQUALIFIED
5507 || array_ptr_attrs != NULL_TREE
5508 || array_parm_static))
5510 error_at (loc, "static or type qualifiers in non-parameter array declarator");
5511 array_ptr_quals = TYPE_UNQUALIFIED;
5512 array_ptr_attrs = NULL_TREE;
5513 array_parm_static = 0;
5519 /* Say it's a definition only for the declarator closest
5520 to the identifier, apart possibly from some
5522 bool really_funcdef = false;
5526 const struct c_declarator *t = declarator->declarator;
5527 while (t->kind == cdk_attrs)
5529 really_funcdef = (t->kind == cdk_id);
5532 /* Declaring a function type. Make sure we have a valid
5533 type for the function to return. */
5534 if (type == error_mark_node)
5537 size_varies = false;
5539 /* Warn about some types functions can't return. */
5540 if (TREE_CODE (type) == FUNCTION_TYPE)
5543 error_at (loc, "%qE declared as function returning a "
5546 error_at (loc, "type name declared as function "
5547 "returning a function");
5548 type = integer_type_node;
5550 if (TREE_CODE (type) == ARRAY_TYPE)
5553 error_at (loc, "%qE declared as function returning an array",
5556 error_at (loc, "type name declared as function returning "
5558 type = integer_type_node;
5560 errmsg = targetm.invalid_return_type (type);
5564 type = integer_type_node;
5567 /* Construct the function type and go to the next
5568 inner layer of declarator. */
5569 arg_info = declarator->u.arg_info;
5570 arg_types = grokparms (arg_info, really_funcdef);
5572 put_pending_sizes (arg_info->pending_sizes);
5574 /* Type qualifiers before the return type of the function
5575 qualify the return type, not the function type. */
5578 /* Type qualifiers on a function return type are
5579 normally permitted by the standard but have no
5580 effect, so give a warning at -Wreturn-type.
5581 Qualifiers on a void return type are banned on
5582 function definitions in ISO C; GCC used to used
5583 them for noreturn functions. */
5584 if (VOID_TYPE_P (type) && really_funcdef)
5586 "function definition has qualified void return type");
5588 warning_at (loc, OPT_Wignored_qualifiers,
5589 "type qualifiers ignored on function return type");
5591 type = c_build_qualified_type (type, type_quals);
5593 type_quals = TYPE_UNQUALIFIED;
5595 type = build_function_type (type, arg_types);
5596 declarator = declarator->declarator;
5598 /* Set the TYPE_CONTEXTs for each tagged type which is local to
5599 the formal parameter list of this FUNCTION_TYPE to point to
5600 the FUNCTION_TYPE node itself. */
5605 FOR_EACH_VEC_ELT_REVERSE (c_arg_tag, arg_info->tags, ix, tag)
5606 TYPE_CONTEXT (tag->type) = type;
5612 /* Merge any constancy or volatility into the target type
5615 if (pedantic && TREE_CODE (type) == FUNCTION_TYPE
5617 pedwarn (loc, OPT_pedantic,
5618 "ISO C forbids qualified function types");
5620 type = c_build_qualified_type (type, type_quals);
5621 size_varies = false;
5623 /* When the pointed-to type involves components of variable size,
5624 care must be taken to ensure that the size evaluation code is
5625 emitted early enough to dominate all the possible later uses
5626 and late enough for the variables on which it depends to have
5629 This is expected to happen automatically when the pointed-to
5630 type has a name/declaration of it's own, but special attention
5631 is required if the type is anonymous.
5633 We handle the NORMAL and FIELD contexts here by attaching an
5634 artificial TYPE_DECL to such pointed-to type. This forces the
5635 sizes evaluation at a safe point and ensures it is not deferred
5636 until e.g. within a deeper conditional context.
5638 We expect nothing to be needed here for PARM or TYPENAME.
5639 Pushing a TYPE_DECL at this point for TYPENAME would actually
5640 be incorrect, as we might be in the middle of an expression
5641 with side effects on the pointed-to type size "arguments" prior
5642 to the pointer declaration point and the fake TYPE_DECL in the
5643 enclosing context would force the size evaluation prior to the
5646 if (!TYPE_NAME (type)
5647 && (decl_context == NORMAL || decl_context == FIELD)
5648 && variably_modified_type_p (type, NULL_TREE))
5650 tree decl = build_decl (loc, TYPE_DECL, NULL_TREE, type);
5651 DECL_ARTIFICIAL (decl) = 1;
5653 finish_decl (decl, loc, NULL_TREE, NULL_TREE, NULL_TREE);
5654 TYPE_NAME (type) = decl;
5657 type = build_pointer_type (type);
5659 /* Process type qualifiers (such as const or volatile)
5660 that were given inside the `*'. */
5661 type_quals = declarator->u.pointer_quals;
5663 declarator = declarator->declarator;
5670 *decl_attrs = chainon (returned_attrs, *decl_attrs);
5672 /* Now TYPE has the actual type, apart from any qualifiers in
5675 /* Warn about address space used for things other than static memory or
5677 address_space = DECODE_QUAL_ADDR_SPACE (type_quals);
5678 if (!ADDR_SPACE_GENERIC_P (address_space))
5680 if (decl_context == NORMAL)
5682 switch (storage_class)
5685 error ("%qs combined with %<auto%> qualifier for %qE",
5686 c_addr_space_name (address_space), name);
5689 error ("%qs combined with %<register%> qualifier for %qE",
5690 c_addr_space_name (address_space), name);
5693 if (current_function_scope)
5695 error ("%qs specified for auto variable %qE",
5696 c_addr_space_name (address_space), name);
5708 else if (decl_context == PARM && TREE_CODE (type) != ARRAY_TYPE)
5711 error ("%qs specified for parameter %qE",
5712 c_addr_space_name (address_space), name);
5714 error ("%qs specified for unnamed parameter",
5715 c_addr_space_name (address_space));
5717 else if (decl_context == FIELD)
5720 error ("%qs specified for structure field %qE",
5721 c_addr_space_name (address_space), name);
5723 error ("%qs specified for structure field",
5724 c_addr_space_name (address_space));
5728 /* Check the type and width of a bit-field. */
5730 check_bitfield_type_and_width (&type, width, name);
5732 /* Did array size calculations overflow? */
5734 if (TREE_CODE (type) == ARRAY_TYPE
5735 && COMPLETE_TYPE_P (type)
5736 && TREE_CODE (TYPE_SIZE_UNIT (type)) == INTEGER_CST
5737 && TREE_OVERFLOW (TYPE_SIZE_UNIT (type)))
5740 error_at (loc, "size of array %qE is too large", name);
5742 error_at (loc, "size of unnamed array is too large");
5743 /* If we proceed with the array type as it is, we'll eventually
5744 crash in tree_low_cst(). */
5745 type = error_mark_node;
5748 /* If this is declaring a typedef name, return a TYPE_DECL. */
5750 if (storage_class == csc_typedef)
5753 if (pedantic && TREE_CODE (type) == FUNCTION_TYPE
5755 pedwarn (loc, OPT_pedantic,
5756 "ISO C forbids qualified function types");
5758 type = c_build_qualified_type (type, type_quals);
5759 decl = build_decl (declarator->id_loc,
5760 TYPE_DECL, declarator->u.id, type);
5761 if (declspecs->explicit_signed_p)
5762 C_TYPEDEF_EXPLICITLY_SIGNED (decl) = 1;
5763 if (declspecs->inline_p)
5764 pedwarn (loc, 0,"typedef %q+D declared %<inline%>", decl);
5766 if (warn_cxx_compat && declarator->u.id != NULL_TREE)
5768 struct c_binding *b = I_TAG_BINDING (declarator->u.id);
5771 && b->decl != NULL_TREE
5772 && (B_IN_CURRENT_SCOPE (b)
5773 || (current_scope == file_scope && B_IN_EXTERNAL_SCOPE (b)))
5774 && TYPE_MAIN_VARIANT (b->decl) != TYPE_MAIN_VARIANT (type))
5776 warning_at (declarator->id_loc, OPT_Wc___compat,
5777 ("using %qD as both a typedef and a tag is "
5780 if (b->locus != UNKNOWN_LOCATION)
5781 inform (b->locus, "originally defined here");
5788 /* If this is a type name (such as, in a cast or sizeof),
5789 compute the type and return it now. */
5791 if (decl_context == TYPENAME)
5793 /* Note that the grammar rejects storage classes in typenames
5795 gcc_assert (storage_class == csc_none && !threadp
5796 && !declspecs->inline_p);
5797 if (pedantic && TREE_CODE (type) == FUNCTION_TYPE
5799 pedwarn (loc, OPT_pedantic,
5800 "ISO C forbids const or volatile function types");
5802 type = c_build_qualified_type (type, type_quals);
5806 if (pedantic && decl_context == FIELD
5807 && variably_modified_type_p (type, NULL_TREE))
5810 pedwarn (loc, OPT_pedantic, "a member of a structure or union cannot "
5811 "have a variably modified type");
5814 /* Aside from typedefs and type names (handle above),
5815 `void' at top level (not within pointer)
5816 is allowed only in public variables.
5817 We don't complain about parms either, but that is because
5818 a better error message can be made later. */
5820 if (VOID_TYPE_P (type) && decl_context != PARM
5821 && !((decl_context != FIELD && TREE_CODE (type) != FUNCTION_TYPE)
5822 && (storage_class == csc_extern
5823 || (current_scope == file_scope
5824 && !(storage_class == csc_static
5825 || storage_class == csc_register)))))
5827 error_at (loc, "variable or field %qE declared void", name);
5828 type = integer_type_node;
5831 /* Now create the decl, which may be a VAR_DECL, a PARM_DECL
5832 or a FUNCTION_DECL, depending on DECL_CONTEXT and TYPE. */
5837 if (decl_context == PARM)
5841 /* A parameter declared as an array of T is really a pointer to T.
5842 One declared as a function is really a pointer to a function. */
5844 if (TREE_CODE (type) == ARRAY_TYPE)
5846 /* Transfer const-ness of array into that of type pointed to. */
5847 type = TREE_TYPE (type);
5849 type = c_build_qualified_type (type, type_quals);
5850 type = build_pointer_type (type);
5851 type_quals = array_ptr_quals;
5853 type = c_build_qualified_type (type, type_quals);
5855 /* We don't yet implement attributes in this context. */
5856 if (array_ptr_attrs != NULL_TREE)
5857 warning_at (loc, OPT_Wattributes,
5858 "attributes in parameter array declarator ignored");
5860 size_varies = false;
5862 else if (TREE_CODE (type) == FUNCTION_TYPE)
5865 pedwarn (loc, OPT_pedantic,
5866 "ISO C forbids qualified function types");
5868 type = c_build_qualified_type (type, type_quals);
5869 type = build_pointer_type (type);
5870 type_quals = TYPE_UNQUALIFIED;
5872 else if (type_quals)
5873 type = c_build_qualified_type (type, type_quals);
5875 decl = build_decl (declarator->id_loc,
5876 PARM_DECL, declarator->u.id, type);
5878 C_DECL_VARIABLE_SIZE (decl) = 1;
5880 /* Compute the type actually passed in the parmlist,
5881 for the case where there is no prototype.
5882 (For example, shorts and chars are passed as ints.)
5883 When there is a prototype, this is overridden later. */
5885 if (type == error_mark_node)
5886 promoted_type = type;
5888 promoted_type = c_type_promotes_to (type);
5890 DECL_ARG_TYPE (decl) = promoted_type;
5891 if (declspecs->inline_p)
5892 pedwarn (loc, 0, "parameter %q+D declared %<inline%>", decl);
5894 else if (decl_context == FIELD)
5896 /* Note that the grammar rejects storage classes in typenames
5898 gcc_assert (storage_class == csc_none && !threadp
5899 && !declspecs->inline_p);
5901 /* Structure field. It may not be a function. */
5903 if (TREE_CODE (type) == FUNCTION_TYPE)
5905 error_at (loc, "field %qE declared as a function", name);
5906 type = build_pointer_type (type);
5908 else if (TREE_CODE (type) != ERROR_MARK
5909 && !COMPLETE_OR_UNBOUND_ARRAY_TYPE_P (type))
5912 error_at (loc, "field %qE has incomplete type", name);
5914 error_at (loc, "unnamed field has incomplete type");
5915 type = error_mark_node;
5917 type = c_build_qualified_type (type, type_quals);
5918 decl = build_decl (declarator->id_loc,
5919 FIELD_DECL, declarator->u.id, type);
5920 DECL_NONADDRESSABLE_P (decl) = bitfield;
5921 if (bitfield && !declarator->u.id)
5922 TREE_NO_WARNING (decl) = 1;
5925 C_DECL_VARIABLE_SIZE (decl) = 1;
5927 else if (TREE_CODE (type) == FUNCTION_TYPE)
5929 if (storage_class == csc_register || threadp)
5931 error_at (loc, "invalid storage class for function %qE", name);
5933 else if (current_scope != file_scope)
5935 /* Function declaration not at file scope. Storage
5936 classes other than `extern' are not allowed, C99
5937 6.7.1p5, and `extern' makes no difference. However,
5938 GCC allows 'auto', perhaps with 'inline', to support
5939 nested functions. */
5940 if (storage_class == csc_auto)
5941 pedwarn (loc, OPT_pedantic,
5942 "invalid storage class for function %qE", name);
5943 else if (storage_class == csc_static)
5945 error_at (loc, "invalid storage class for function %qE", name);
5947 storage_class = declspecs->storage_class = csc_none;
5953 decl = build_decl (declarator->id_loc,
5954 FUNCTION_DECL, declarator->u.id, type);
5955 decl = build_decl_attribute_variant (decl, decl_attr);
5957 if (pedantic && type_quals && !DECL_IN_SYSTEM_HEADER (decl))
5958 pedwarn (loc, OPT_pedantic,
5959 "ISO C forbids qualified function types");
5961 /* Every function declaration is an external reference
5962 (DECL_EXTERNAL) except for those which are not at file
5963 scope and are explicitly declared "auto". This is
5964 forbidden by standard C (C99 6.7.1p5) and is interpreted by
5965 GCC to signify a forward declaration of a nested function. */
5966 if (storage_class == csc_auto && current_scope != file_scope)
5967 DECL_EXTERNAL (decl) = 0;
5968 /* In C99, a function which is declared 'inline' with 'extern'
5969 is not an external reference (which is confusing). It
5970 means that the later definition of the function must be output
5971 in this file, C99 6.7.4p6. In GNU C89, a function declared
5972 'extern inline' is an external reference. */
5973 else if (declspecs->inline_p && storage_class != csc_static)
5974 DECL_EXTERNAL (decl) = ((storage_class == csc_extern)
5975 == flag_gnu89_inline);
5977 DECL_EXTERNAL (decl) = !initialized;
5979 /* Record absence of global scope for `static' or `auto'. */
5981 = !(storage_class == csc_static || storage_class == csc_auto);
5983 /* For a function definition, record the argument information
5984 block where store_parm_decls will look for it. */
5986 current_function_arg_info = arg_info;
5988 if (declspecs->default_int_p)
5989 C_FUNCTION_IMPLICIT_INT (decl) = 1;
5991 /* Record presence of `inline', if it is reasonable. */
5992 if (flag_hosted && MAIN_NAME_P (declarator->u.id))
5994 if (declspecs->inline_p)
5995 pedwarn (loc, 0, "cannot inline function %<main%>");
5997 else if (declspecs->inline_p)
5998 /* Record that the function is declared `inline'. */
5999 DECL_DECLARED_INLINE_P (decl) = 1;
6003 /* It's a variable. */
6004 /* An uninitialized decl with `extern' is a reference. */
6005 int extern_ref = !initialized && storage_class == csc_extern;
6007 type = c_build_qualified_type (type, type_quals);
6009 /* C99 6.2.2p7: It is invalid (compile-time undefined
6010 behavior) to create an 'extern' declaration for a
6011 variable if there is a global declaration that is
6012 'static' and the global declaration is not visible.
6013 (If the static declaration _is_ currently visible,
6014 the 'extern' declaration is taken to refer to that decl.) */
6015 if (extern_ref && current_scope != file_scope)
6017 tree global_decl = identifier_global_value (declarator->u.id);
6018 tree visible_decl = lookup_name (declarator->u.id);
6021 && global_decl != visible_decl
6022 && TREE_CODE (global_decl) == VAR_DECL
6023 && !TREE_PUBLIC (global_decl))
6024 error_at (loc, "variable previously declared %<static%> "
6025 "redeclared %<extern%>");
6028 decl = build_decl (declarator->id_loc,
6029 VAR_DECL, declarator->u.id, type);
6031 C_DECL_VARIABLE_SIZE (decl) = 1;
6033 if (declspecs->inline_p)
6034 pedwarn (loc, 0, "variable %q+D declared %<inline%>", decl);
6036 /* At file scope, an initialized extern declaration may follow
6037 a static declaration. In that case, DECL_EXTERNAL will be
6038 reset later in start_decl. */
6039 DECL_EXTERNAL (decl) = (storage_class == csc_extern);
6041 /* At file scope, the presence of a `static' or `register' storage
6042 class specifier, or the absence of all storage class specifiers
6043 makes this declaration a definition (perhaps tentative). Also,
6044 the absence of `static' makes it public. */
6045 if (current_scope == file_scope)
6047 TREE_PUBLIC (decl) = storage_class != csc_static;
6048 TREE_STATIC (decl) = !extern_ref;
6050 /* Not at file scope, only `static' makes a static definition. */
6053 TREE_STATIC (decl) = (storage_class == csc_static);
6054 TREE_PUBLIC (decl) = extern_ref;
6058 DECL_TLS_MODEL (decl) = decl_default_tls_model (decl);
6061 if ((storage_class == csc_extern
6062 || (storage_class == csc_none
6063 && TREE_CODE (type) == FUNCTION_TYPE
6065 && variably_modified_type_p (type, NULL_TREE))
6068 if (TREE_CODE (type) == FUNCTION_TYPE)
6069 error_at (loc, "non-nested function with variably modified type");
6071 error_at (loc, "object with variably modified type must have "
6075 /* Record `register' declaration for warnings on &
6076 and in case doing stupid register allocation. */
6078 if (storage_class == csc_register)
6080 C_DECL_REGISTER (decl) = 1;
6081 DECL_REGISTER (decl) = 1;
6084 /* Record constancy and volatility. */
6085 c_apply_type_quals_to_decl (type_quals, decl);
6087 /* If a type has volatile components, it should be stored in memory.
6088 Otherwise, the fact that those components are volatile
6089 will be ignored, and would even crash the compiler.
6090 Of course, this only makes sense on VAR,PARM, and RESULT decl's. */
6091 if (C_TYPE_FIELDS_VOLATILE (TREE_TYPE (decl))
6092 && (TREE_CODE (decl) == VAR_DECL || TREE_CODE (decl) == PARM_DECL
6093 || TREE_CODE (decl) == RESULT_DECL))
6095 /* It is not an error for a structure with volatile fields to
6096 be declared register, but reset DECL_REGISTER since it
6097 cannot actually go in a register. */
6098 int was_reg = C_DECL_REGISTER (decl);
6099 C_DECL_REGISTER (decl) = 0;
6100 DECL_REGISTER (decl) = 0;
6101 c_mark_addressable (decl);
6102 C_DECL_REGISTER (decl) = was_reg;
6105 /* This is the earliest point at which we might know the assembler
6106 name of a variable. Thus, if it's known before this, die horribly. */
6107 gcc_assert (!DECL_ASSEMBLER_NAME_SET_P (decl));
6110 && TREE_CODE (decl) == VAR_DECL
6111 && TREE_PUBLIC (decl)
6112 && TREE_STATIC (decl)
6113 && (TREE_CODE (TREE_TYPE (decl)) == RECORD_TYPE
6114 || TREE_CODE (TREE_TYPE (decl)) == UNION_TYPE
6115 || TREE_CODE (TREE_TYPE (decl)) == ENUMERAL_TYPE)
6116 && TYPE_NAME (TREE_TYPE (decl)) == NULL_TREE)
6117 warning_at (DECL_SOURCE_LOCATION (decl), OPT_Wc___compat,
6118 ("non-local variable %qD with anonymous type is "
6119 "questionable in C++"),
6126 /* Decode the parameter-list info for a function type or function definition.
6127 The argument is the value returned by `get_parm_info' (or made in c-parse.c
6128 if there is an identifier list instead of a parameter decl list).
6129 These two functions are separate because when a function returns
6130 or receives functions then each is called multiple times but the order
6131 of calls is different. The last call to `grokparms' is always the one
6132 that contains the formal parameter names of a function definition.
6134 Return a list of arg types to use in the FUNCTION_TYPE for this function.
6136 FUNCDEF_FLAG is true for a function definition, false for
6137 a mere declaration. A nonempty identifier-list gets an error message
6138 when FUNCDEF_FLAG is false. */
6141 grokparms (struct c_arg_info *arg_info, bool funcdef_flag)
6143 tree arg_types = arg_info->types;
6145 if (funcdef_flag && arg_info->had_vla_unspec)
6147 /* A function definition isn't function prototype scope C99 6.2.1p4. */
6149 error ("%<[*]%> not allowed in other than function prototype scope");
6152 if (arg_types == 0 && !funcdef_flag && !in_system_header)
6153 warning (OPT_Wstrict_prototypes,
6154 "function declaration isn%'t a prototype");
6156 if (arg_types == error_mark_node)
6157 return 0; /* don't set TYPE_ARG_TYPES in this case */
6159 else if (arg_types && TREE_CODE (TREE_VALUE (arg_types)) == IDENTIFIER_NODE)
6163 pedwarn (input_location, 0, "parameter names (without types) in function declaration");
6164 arg_info->parms = NULL_TREE;
6167 arg_info->parms = arg_info->types;
6169 arg_info->types = 0;
6174 tree parm, type, typelt;
6175 unsigned int parmno;
6178 /* If there is a parameter of incomplete type in a definition,
6179 this is an error. In a declaration this is valid, and a
6180 struct or union type may be completed later, before any calls
6181 or definition of the function. In the case where the tag was
6182 first declared within the parameter list, a warning has
6183 already been given. If a parameter has void type, then
6184 however the function cannot be defined or called, so
6187 for (parm = arg_info->parms, typelt = arg_types, parmno = 1;
6189 parm = DECL_CHAIN (parm), typelt = TREE_CHAIN (typelt), parmno++)
6191 type = TREE_VALUE (typelt);
6192 if (type == error_mark_node)
6195 if (!COMPLETE_TYPE_P (type))
6199 if (DECL_NAME (parm))
6200 error_at (input_location,
6201 "parameter %u (%q+D) has incomplete type",
6204 error_at (DECL_SOURCE_LOCATION (parm),
6205 "parameter %u has incomplete type",
6208 TREE_VALUE (typelt) = error_mark_node;
6209 TREE_TYPE (parm) = error_mark_node;
6210 arg_types = NULL_TREE;
6212 else if (VOID_TYPE_P (type))
6214 if (DECL_NAME (parm))
6215 warning_at (input_location, 0,
6216 "parameter %u (%q+D) has void type",
6219 warning_at (DECL_SOURCE_LOCATION (parm), 0,
6220 "parameter %u has void type",
6225 errmsg = targetm.invalid_parameter_type (type);
6229 TREE_VALUE (typelt) = error_mark_node;
6230 TREE_TYPE (parm) = error_mark_node;
6231 arg_types = NULL_TREE;
6234 if (DECL_NAME (parm) && TREE_USED (parm))
6235 warn_if_shadowing (parm);
6241 /* Allocate and initialize a c_arg_info structure from the parser's
6245 build_arg_info (void)
6247 struct c_arg_info *ret = XOBNEW (&parser_obstack, struct c_arg_info);
6248 ret->parms = NULL_TREE;
6250 ret->types = NULL_TREE;
6251 ret->others = NULL_TREE;
6252 ret->pending_sizes = NULL;
6253 ret->had_vla_unspec = 0;
6257 /* Take apart the current scope and return a c_arg_info structure with
6258 info on a parameter list just parsed.
6260 This structure is later fed to 'grokparms' and 'store_parm_decls'.
6262 ELLIPSIS being true means the argument list ended in '...' so don't
6263 append a sentinel (void_list_node) to the end of the type-list. */
6266 get_parm_info (bool ellipsis)
6268 struct c_binding *b = current_scope->bindings;
6269 struct c_arg_info *arg_info = build_arg_info ();
6272 VEC(c_arg_tag,gc) *tags = NULL;
6276 static bool explained_incomplete_types = false;
6277 bool gave_void_only_once_err = false;
6279 arg_info->had_vla_unspec = current_scope->had_vla_unspec;
6281 /* The bindings in this scope must not get put into a block.
6282 We will take care of deleting the binding nodes. */
6283 current_scope->bindings = 0;
6285 /* This function is only called if there was *something* on the
6289 /* A parameter list consisting solely of 'void' indicates that the
6290 function takes no arguments. But if the 'void' is qualified
6291 (by 'const' or 'volatile'), or has a storage class specifier
6292 ('register'), then the behavior is undefined; issue an error.
6293 Typedefs for 'void' are OK (see DR#157). */
6294 if (b->prev == 0 /* one binding */
6295 && TREE_CODE (b->decl) == PARM_DECL /* which is a parameter */
6296 && !DECL_NAME (b->decl) /* anonymous */
6297 && VOID_TYPE_P (TREE_TYPE (b->decl))) /* of void type */
6299 if (TREE_THIS_VOLATILE (b->decl)
6300 || TREE_READONLY (b->decl)
6301 || C_DECL_REGISTER (b->decl))
6302 error ("%<void%> as only parameter may not be qualified");
6304 /* There cannot be an ellipsis. */
6306 error ("%<void%> must be the only parameter");
6308 arg_info->types = void_list_node;
6313 types = void_list_node;
6315 /* Break up the bindings list into parms, tags, types, and others;
6316 apply sanity checks; purge the name-to-decl bindings. */
6319 tree decl = b->decl;
6320 tree type = TREE_TYPE (decl);
6322 const char *keyword;
6324 switch (TREE_CODE (decl))
6329 gcc_assert (I_SYMBOL_BINDING (b->id) == b);
6330 I_SYMBOL_BINDING (b->id) = b->shadowed;
6333 /* Check for forward decls that never got their actual decl. */
6334 if (TREE_ASM_WRITTEN (decl))
6335 error ("parameter %q+D has just a forward declaration", decl);
6336 /* Check for (..., void, ...) and issue an error. */
6337 else if (VOID_TYPE_P (type) && !DECL_NAME (decl))
6339 if (!gave_void_only_once_err)
6341 error ("%<void%> must be the only parameter");
6342 gave_void_only_once_err = true;
6347 /* Valid parameter, add it to the list. */
6348 DECL_CHAIN (decl) = parms;
6351 /* Since there is a prototype, args are passed in their
6352 declared types. The back end may override this later. */
6353 DECL_ARG_TYPE (decl) = type;
6354 types = tree_cons (0, type, types);
6358 case ENUMERAL_TYPE: keyword = "enum"; goto tag;
6359 case UNION_TYPE: keyword = "union"; goto tag;
6360 case RECORD_TYPE: keyword = "struct"; goto tag;
6362 /* Types may not have tag-names, in which case the type
6363 appears in the bindings list with b->id NULL. */
6366 gcc_assert (I_TAG_BINDING (b->id) == b);
6367 I_TAG_BINDING (b->id) = b->shadowed;
6370 /* Warn about any struct, union or enum tags defined in a
6371 parameter list. The scope of such types is limited to
6372 the parameter list, which is rarely if ever desirable
6373 (it's impossible to call such a function with type-
6374 correct arguments). An anonymous union parm type is
6375 meaningful as a GNU extension, so don't warn for that. */
6376 if (TREE_CODE (decl) != UNION_TYPE || b->id != 0)
6379 /* The %s will be one of 'struct', 'union', or 'enum'. */
6380 warning (0, "%<%s %E%> declared inside parameter list",
6383 /* The %s will be one of 'struct', 'union', or 'enum'. */
6384 warning (0, "anonymous %s declared inside parameter list",
6387 if (!explained_incomplete_types)
6389 warning (0, "its scope is only this definition or declaration,"
6390 " which is probably not what you want");
6391 explained_incomplete_types = true;
6395 tag = VEC_safe_push (c_arg_tag, gc, tags, NULL);
6403 /* CONST_DECLs appear here when we have an embedded enum,
6404 and TYPE_DECLs appear here when we have an embedded struct
6405 or union. No warnings for this - we already warned about the
6406 type itself. FUNCTION_DECLs appear when there is an implicit
6407 function declaration in the parameter list. */
6409 /* When we reinsert this decl in the function body, we need
6410 to reconstruct whether it was marked as nested. */
6411 gcc_assert (TREE_CODE (decl) == FUNCTION_DECL
6414 DECL_CHAIN (decl) = others;
6419 /* error_mark_node appears here when we have an undeclared
6420 variable. Just throw it away. */
6423 gcc_assert (I_SYMBOL_BINDING (b->id) == b);
6424 I_SYMBOL_BINDING (b->id) = b->shadowed;
6428 /* Other things that might be encountered. */
6435 b = free_binding_and_advance (b);
6438 arg_info->parms = parms;
6439 arg_info->tags = tags;
6440 arg_info->types = types;
6441 arg_info->others = others;
6442 arg_info->pending_sizes = get_pending_sizes ();
6446 /* Get the struct, enum or union (CODE says which) with tag NAME.
6447 Define the tag as a forward-reference with location LOC if it is
6448 not defined. Return a c_typespec structure for the type
6452 parser_xref_tag (location_t loc, enum tree_code code, tree name)
6454 struct c_typespec ret;
6458 ret.expr = NULL_TREE;
6459 ret.expr_const_operands = true;
6461 /* If a cross reference is requested, look up the type
6462 already defined for this tag and return it. */
6464 ref = lookup_tag (code, name, 0, &refloc);
6465 /* If this is the right type of tag, return what we found.
6466 (This reference will be shadowed by shadow_tag later if appropriate.)
6467 If this is the wrong type of tag, do not return it. If it was the
6468 wrong type in the same scope, we will have had an error
6469 message already; if in a different scope and declaring
6470 a name, pending_xref_error will give an error message; but if in a
6471 different scope and not declaring a name, this tag should
6472 shadow the previous declaration of a different type of tag, and
6473 this would not work properly if we return the reference found.
6474 (For example, with "struct foo" in an outer scope, "union foo;"
6475 must shadow that tag with a new one of union type.) */
6476 ret.kind = (ref ? ctsk_tagref : ctsk_tagfirstref);
6477 if (ref && TREE_CODE (ref) == code)
6479 if (C_TYPE_DEFINED_IN_STRUCT (ref)
6480 && loc != UNKNOWN_LOCATION
6486 warning_at (loc, OPT_Wc___compat,
6487 ("enum type defined in struct or union "
6488 "is not visible in C++"));
6489 inform (refloc, "enum type defined here");
6492 warning_at (loc, OPT_Wc___compat,
6493 ("struct defined in struct or union "
6494 "is not visible in C++"));
6495 inform (refloc, "struct defined here");
6498 warning_at (loc, OPT_Wc___compat,
6499 ("union defined in struct or union "
6500 "is not visible in C++"));
6501 inform (refloc, "union defined here");
6512 /* If no such tag is yet defined, create a forward-reference node
6513 and record it as the "definition".
6514 When a real declaration of this type is found,
6515 the forward-reference will be altered into a real type. */
6517 ref = make_node (code);
6518 if (code == ENUMERAL_TYPE)
6520 /* Give the type a default layout like unsigned int
6521 to avoid crashing if it does not get defined. */
6522 SET_TYPE_MODE (ref, TYPE_MODE (unsigned_type_node));
6523 TYPE_ALIGN (ref) = TYPE_ALIGN (unsigned_type_node);
6524 TYPE_USER_ALIGN (ref) = 0;
6525 TYPE_UNSIGNED (ref) = 1;
6526 TYPE_PRECISION (ref) = TYPE_PRECISION (unsigned_type_node);
6527 TYPE_MIN_VALUE (ref) = TYPE_MIN_VALUE (unsigned_type_node);
6528 TYPE_MAX_VALUE (ref) = TYPE_MAX_VALUE (unsigned_type_node);
6531 pushtag (loc, name, ref);
6537 /* Get the struct, enum or union (CODE says which) with tag NAME.
6538 Define the tag as a forward-reference if it is not defined.
6539 Return a tree for the type. */
6542 xref_tag (enum tree_code code, tree name)
6544 return parser_xref_tag (input_location, code, name).spec;
6547 /* Make sure that the tag NAME is defined *in the current scope*
6548 at least as a forward reference.
6549 LOC is the location of the struct's definition.
6550 CODE says which kind of tag NAME ought to be.
6552 This stores the current value of the file static STRUCT_PARSE_INFO
6553 in *ENCLOSING_STRUCT_PARSE_INFO, and points STRUCT_PARSE_INFO at a
6554 new c_struct_parse_info structure. The old value of
6555 STRUCT_PARSE_INFO is restored in finish_struct. */
6558 start_struct (location_t loc, enum tree_code code, tree name,
6559 struct c_struct_parse_info **enclosing_struct_parse_info)
6561 /* If there is already a tag defined at this scope
6562 (as a forward reference), just return it. */
6564 tree ref = NULL_TREE;
6565 location_t refloc = UNKNOWN_LOCATION;
6567 if (name != NULL_TREE)
6568 ref = lookup_tag (code, name, 1, &refloc);
6569 if (ref && TREE_CODE (ref) == code)
6571 if (TYPE_SIZE (ref))
6573 if (code == UNION_TYPE)
6574 error_at (loc, "redefinition of %<union %E%>", name);
6576 error_at (loc, "redefinition of %<struct %E%>", name);
6577 if (refloc != UNKNOWN_LOCATION)
6578 inform (refloc, "originally defined here");
6579 /* Don't create structures using a name already in use. */
6582 else if (C_TYPE_BEING_DEFINED (ref))
6584 if (code == UNION_TYPE)
6585 error_at (loc, "nested redefinition of %<union %E%>", name);
6587 error_at (loc, "nested redefinition of %<struct %E%>", name);
6588 /* Don't bother to report "originally defined here" for a
6589 nested redefinition; the original definition should be
6591 /* Don't create structures that contain themselves. */
6596 /* Otherwise create a forward-reference just so the tag is in scope. */
6598 if (ref == NULL_TREE || TREE_CODE (ref) != code)
6600 ref = make_node (code);
6601 pushtag (loc, name, ref);
6604 C_TYPE_BEING_DEFINED (ref) = 1;
6605 TYPE_PACKED (ref) = flag_pack_struct;
6607 *enclosing_struct_parse_info = struct_parse_info;
6608 struct_parse_info = XNEW (struct c_struct_parse_info);
6609 struct_parse_info->struct_types = VEC_alloc (tree, heap, 0);
6610 struct_parse_info->fields = VEC_alloc (c_binding_ptr, heap, 0);
6611 struct_parse_info->typedefs_seen = VEC_alloc (tree, heap, 0);
6613 /* FIXME: This will issue a warning for a use of a type defined
6614 within a statement expr used within sizeof, et. al. This is not
6615 terribly serious as C++ doesn't permit statement exprs within
6617 if (warn_cxx_compat && (in_sizeof || in_typeof || in_alignof))
6618 warning_at (loc, OPT_Wc___compat,
6619 "defining type in %qs expression is invalid in C++",
6622 : (in_typeof ? "typeof" : "alignof")));
6627 /* Process the specs, declarator and width (NULL if omitted)
6628 of a structure component, returning a FIELD_DECL node.
6629 WIDTH is non-NULL for bit-fields only, and is an INTEGER_CST node.
6630 DECL_ATTRS is as for grokdeclarator.
6632 LOC is the location of the structure component.
6634 This is done during the parsing of the struct declaration.
6635 The FIELD_DECL nodes are chained together and the lot of them
6636 are ultimately passed to `build_struct' to make the RECORD_TYPE node. */
6639 grokfield (location_t loc,
6640 struct c_declarator *declarator, struct c_declspecs *declspecs,
6641 tree width, tree *decl_attrs)
6645 if (declarator->kind == cdk_id && declarator->u.id == NULL_TREE
6646 && width == NULL_TREE)
6648 /* This is an unnamed decl.
6650 If we have something of the form "union { list } ;" then this
6651 is the anonymous union extension. Similarly for struct.
6653 If this is something of the form "struct foo;", then
6654 If MS or Plan 9 extensions are enabled, this is handled as
6655 an anonymous struct.
6656 Otherwise this is a forward declaration of a structure tag.
6658 If this is something of the form "foo;" and foo is a TYPE_DECL, then
6659 If foo names a structure or union without a tag, then this
6660 is an anonymous struct (this is permitted by C1X).
6661 If MS or Plan 9 extensions are enabled and foo names a
6662 structure, then again this is an anonymous struct.
6663 Otherwise this is an error.
6665 Oh what a horrid tangled web we weave. I wonder if MS consciously
6666 took this from Plan 9 or if it was an accident of implementation
6667 that took root before someone noticed the bug... */
6669 tree type = declspecs->type;
6670 bool type_ok = (TREE_CODE (type) == RECORD_TYPE
6671 || TREE_CODE (type) == UNION_TYPE);
6675 && (flag_ms_extensions
6676 || flag_plan9_extensions
6677 || !declspecs->typedef_p))
6679 if (flag_ms_extensions || flag_plan9_extensions)
6681 else if (TYPE_NAME (type) == NULL)
6688 pedwarn (loc, 0, "declaration does not declare anything");
6694 pedwarn (loc, OPT_pedantic,
6695 "ISO C99 doesn%'t support unnamed structs/unions");
6697 pedwarn (loc, OPT_pedantic,
6698 "ISO C90 doesn%'t support unnamed structs/unions");
6702 value = grokdeclarator (declarator, declspecs, FIELD, false,
6703 width ? &width : NULL, decl_attrs, NULL, NULL,
6706 finish_decl (value, loc, NULL_TREE, NULL_TREE, NULL_TREE);
6707 DECL_INITIAL (value) = width;
6709 if (warn_cxx_compat && DECL_NAME (value) != NULL_TREE)
6711 /* If we currently have a binding for this field, set the
6712 in_struct field in the binding, so that we warn about lookups
6714 struct c_binding *b = I_SYMBOL_BINDING (DECL_NAME (value));
6717 /* If the in_struct field is not yet set, push it on a list
6718 to be cleared when this struct is finished. */
6721 VEC_safe_push (c_binding_ptr, heap,
6722 struct_parse_info->fields, b);
6731 /* Subroutine of detect_field_duplicates: return whether X and Y,
6732 which are both fields in the same struct, have duplicate field
6736 is_duplicate_field (tree x, tree y)
6738 if (DECL_NAME (x) != NULL_TREE && DECL_NAME (x) == DECL_NAME (y))
6741 /* When using -fplan9-extensions, an anonymous field whose name is a
6742 typedef can duplicate a field name. */
6743 if (flag_plan9_extensions
6744 && (DECL_NAME (x) == NULL_TREE || DECL_NAME (y) == NULL_TREE))
6746 tree xt, xn, yt, yn;
6749 if (DECL_NAME (x) != NULL_TREE)
6751 else if ((TREE_CODE (xt) == RECORD_TYPE || TREE_CODE (xt) == UNION_TYPE)
6752 && TYPE_NAME (xt) != NULL_TREE
6753 && TREE_CODE (TYPE_NAME (xt)) == TYPE_DECL)
6754 xn = DECL_NAME (TYPE_NAME (xt));
6759 if (DECL_NAME (y) != NULL_TREE)
6761 else if ((TREE_CODE (yt) == RECORD_TYPE || TREE_CODE (yt) == UNION_TYPE)
6762 && TYPE_NAME (yt) != NULL_TREE
6763 && TREE_CODE (TYPE_NAME (yt)) == TYPE_DECL)
6764 yn = DECL_NAME (TYPE_NAME (yt));
6768 if (xn != NULL_TREE && xn == yn)
6775 /* Subroutine of detect_field_duplicates: add the fields of FIELDLIST
6776 to HTAB, giving errors for any duplicates. */
6779 detect_field_duplicates_hash (tree fieldlist, htab_t htab)
6784 for (x = fieldlist; x ; x = DECL_CHAIN (x))
6785 if ((y = DECL_NAME (x)) != 0)
6787 slot = htab_find_slot (htab, y, INSERT);
6790 error ("duplicate member %q+D", x);
6791 DECL_NAME (x) = NULL_TREE;
6795 else if (TREE_CODE (TREE_TYPE (x)) == RECORD_TYPE
6796 || TREE_CODE (TREE_TYPE (x)) == UNION_TYPE)
6798 detect_field_duplicates_hash (TYPE_FIELDS (TREE_TYPE (x)), htab);
6800 /* When using -fplan9-extensions, an anonymous field whose
6801 name is a typedef can duplicate a field name. */
6802 if (flag_plan9_extensions
6803 && TYPE_NAME (TREE_TYPE (x)) != NULL_TREE
6804 && TREE_CODE (TYPE_NAME (TREE_TYPE (x))) == TYPE_DECL)
6806 tree xn = DECL_NAME (TYPE_NAME (TREE_TYPE (x)));
6807 slot = htab_find_slot (htab, xn, INSERT);
6809 error ("duplicate member %q+D", TYPE_NAME (TREE_TYPE (x)));
6815 /* Generate an error for any duplicate field names in FIELDLIST. Munge
6816 the list such that this does not present a problem later. */
6819 detect_field_duplicates (tree fieldlist)
6824 /* If the struct is the list of instance variables of an Objective-C
6825 class, then we need to add all the instance variables of
6826 superclasses before checking for duplicates (since you can't have
6827 an instance variable in a subclass with the same name as an
6828 instance variable in a superclass). objc_get_interface_ivars()
6829 leaves fieldlist unchanged if we are not in this case, so in that
6830 case nothing changes compared to C.
6832 if (c_dialect_objc ())
6833 fieldlist = objc_get_interface_ivars (fieldlist);
6835 /* First, see if there are more than "a few" fields.
6836 This is trivially true if there are zero or one fields. */
6837 if (!fieldlist || !DECL_CHAIN (fieldlist))
6842 if (DECL_NAME (x) == NULL_TREE
6843 && (TREE_CODE (TREE_TYPE (x)) == RECORD_TYPE
6844 || TREE_CODE (TREE_TYPE (x)) == UNION_TYPE))
6847 } while (timeout > 0 && x);
6849 /* If there were "few" fields and no anonymous structures or unions,
6850 avoid the overhead of allocating a hash table. Instead just do
6851 the nested traversal thing. */
6854 for (x = DECL_CHAIN (fieldlist); x; x = DECL_CHAIN (x))
6855 /* When using -fplan9-extensions, we can have duplicates
6856 between typedef names and fields. */
6858 || (flag_plan9_extensions
6859 && DECL_NAME (x) == NULL_TREE
6860 && (TREE_CODE (TREE_TYPE (x)) == RECORD_TYPE
6861 || TREE_CODE (TREE_TYPE (x)) == UNION_TYPE)
6862 && TYPE_NAME (TREE_TYPE (x)) != NULL_TREE
6863 && TREE_CODE (TYPE_NAME (TREE_TYPE (x))) == TYPE_DECL))
6865 for (y = fieldlist; y != x; y = TREE_CHAIN (y))
6866 if (is_duplicate_field (y, x))
6868 error ("duplicate member %q+D", x);
6869 DECL_NAME (x) = NULL_TREE;
6875 htab_t htab = htab_create (37, htab_hash_pointer, htab_eq_pointer, NULL);
6877 detect_field_duplicates_hash (fieldlist, htab);
6882 /* Finish up struct info used by -Wc++-compat. */
6885 warn_cxx_compat_finish_struct (tree fieldlist)
6889 struct c_binding *b;
6891 /* Set the C_TYPE_DEFINED_IN_STRUCT flag for each type defined in
6892 the current struct. We do this now at the end of the struct
6893 because the flag is used to issue visibility warnings, and we
6894 only want to issue those warnings if the type is referenced
6895 outside of the struct declaration. */
6896 FOR_EACH_VEC_ELT (tree, struct_parse_info->struct_types, ix, x)
6897 C_TYPE_DEFINED_IN_STRUCT (x) = 1;
6899 /* The TYPEDEFS_SEEN field of STRUCT_PARSE_INFO is a list of
6900 typedefs used when declaring fields in this struct. If the name
6901 of any of the fields is also a typedef name then the struct would
6902 not parse in C++, because the C++ lookup rules say that the
6903 typedef name would be looked up in the context of the struct, and
6904 would thus be the field rather than the typedef. */
6905 if (!VEC_empty (tree, struct_parse_info->typedefs_seen)
6906 && fieldlist != NULL_TREE)
6908 /* Use a pointer_set using the name of the typedef. We can use
6909 a pointer_set because identifiers are interned. */
6910 struct pointer_set_t *tset = pointer_set_create ();
6912 FOR_EACH_VEC_ELT (tree, struct_parse_info->typedefs_seen, ix, x)
6913 pointer_set_insert (tset, DECL_NAME (x));
6915 for (x = fieldlist; x != NULL_TREE; x = DECL_CHAIN (x))
6917 if (DECL_NAME (x) != NULL_TREE
6918 && pointer_set_contains (tset, DECL_NAME (x)))
6920 warning_at (DECL_SOURCE_LOCATION (x), OPT_Wc___compat,
6921 ("using %qD as both field and typedef name is "
6924 /* FIXME: It would be nice to report the location where
6925 the typedef name is used. */
6929 pointer_set_destroy (tset);
6932 /* For each field which has a binding and which was not defined in
6933 an enclosing struct, clear the in_struct field. */
6934 FOR_EACH_VEC_ELT (c_binding_ptr, struct_parse_info->fields, ix, b)
6938 /* Fill in the fields of a RECORD_TYPE or UNION_TYPE node, T.
6939 LOC is the location of the RECORD_TYPE or UNION_TYPE's definition.
6940 FIELDLIST is a chain of FIELD_DECL nodes for the fields.
6941 ATTRIBUTES are attributes to be applied to the structure.
6943 ENCLOSING_STRUCT_PARSE_INFO is the value of STRUCT_PARSE_INFO when
6944 the struct was started. */
6947 finish_struct (location_t loc, tree t, tree fieldlist, tree attributes,
6948 struct c_struct_parse_info *enclosing_struct_parse_info)
6951 bool toplevel = file_scope == current_scope;
6952 int saw_named_field;
6954 /* If this type was previously laid out as a forward reference,
6955 make sure we lay it out again. */
6959 decl_attributes (&t, attributes, (int) ATTR_FLAG_TYPE_IN_PLACE);
6963 for (x = fieldlist; x; x = DECL_CHAIN (x))
6965 if (DECL_NAME (x) != 0)
6968 && (TREE_CODE (TREE_TYPE (x)) == RECORD_TYPE
6969 || TREE_CODE (TREE_TYPE (x)) == UNION_TYPE))
6975 if (TREE_CODE (t) == UNION_TYPE)
6978 pedwarn (loc, OPT_pedantic, "union has no named members");
6980 pedwarn (loc, OPT_pedantic, "union has no members");
6985 pedwarn (loc, OPT_pedantic, "struct has no named members");
6987 pedwarn (loc, OPT_pedantic, "struct has no members");
6992 /* Install struct as DECL_CONTEXT of each field decl.
6993 Also process specified field sizes, found in the DECL_INITIAL,
6994 storing 0 there after the type has been changed to precision equal
6995 to its width, rather than the precision of the specified standard
6996 type. (Correct layout requires the original type to have been preserved
6999 saw_named_field = 0;
7000 for (x = fieldlist; x; x = DECL_CHAIN (x))
7002 if (TREE_TYPE (x) == error_mark_node)
7005 DECL_CONTEXT (x) = t;
7007 /* If any field is const, the structure type is pseudo-const. */
7008 if (TREE_READONLY (x))
7009 C_TYPE_FIELDS_READONLY (t) = 1;
7012 /* A field that is pseudo-const makes the structure likewise. */
7013 tree t1 = strip_array_types (TREE_TYPE (x));
7014 if ((TREE_CODE (t1) == RECORD_TYPE || TREE_CODE (t1) == UNION_TYPE)
7015 && C_TYPE_FIELDS_READONLY (t1))
7016 C_TYPE_FIELDS_READONLY (t) = 1;
7019 /* Any field that is volatile means variables of this type must be
7020 treated in some ways as volatile. */
7021 if (TREE_THIS_VOLATILE (x))
7022 C_TYPE_FIELDS_VOLATILE (t) = 1;
7024 /* Any field of nominal variable size implies structure is too. */
7025 if (C_DECL_VARIABLE_SIZE (x))
7026 C_TYPE_VARIABLE_SIZE (t) = 1;
7028 if (DECL_INITIAL (x))
7030 unsigned HOST_WIDE_INT width = tree_low_cst (DECL_INITIAL (x), 1);
7031 DECL_SIZE (x) = bitsize_int (width);
7032 DECL_BIT_FIELD (x) = 1;
7033 SET_DECL_C_BIT_FIELD (x);
7037 && (DECL_BIT_FIELD (x)
7038 || TYPE_ALIGN (TREE_TYPE (x)) > BITS_PER_UNIT))
7039 DECL_PACKED (x) = 1;
7041 /* Detect flexible array member in an invalid context. */
7042 if (TREE_CODE (TREE_TYPE (x)) == ARRAY_TYPE
7043 && TYPE_SIZE (TREE_TYPE (x)) == NULL_TREE
7044 && TYPE_DOMAIN (TREE_TYPE (x)) != NULL_TREE
7045 && TYPE_MAX_VALUE (TYPE_DOMAIN (TREE_TYPE (x))) == NULL_TREE)
7047 if (TREE_CODE (t) == UNION_TYPE)
7049 error_at (DECL_SOURCE_LOCATION (x),
7050 "flexible array member in union");
7051 TREE_TYPE (x) = error_mark_node;
7053 else if (DECL_CHAIN (x) != NULL_TREE)
7055 error_at (DECL_SOURCE_LOCATION (x),
7056 "flexible array member not at end of struct");
7057 TREE_TYPE (x) = error_mark_node;
7059 else if (!saw_named_field)
7061 error_at (DECL_SOURCE_LOCATION (x),
7062 "flexible array member in otherwise empty struct");
7063 TREE_TYPE (x) = error_mark_node;
7067 if (pedantic && TREE_CODE (t) == RECORD_TYPE
7068 && flexible_array_type_p (TREE_TYPE (x)))
7069 pedwarn (DECL_SOURCE_LOCATION (x), OPT_pedantic,
7070 "invalid use of structure with flexible array member");
7073 || TREE_CODE (TREE_TYPE (x)) == RECORD_TYPE
7074 || TREE_CODE (TREE_TYPE (x)) == UNION_TYPE)
7075 saw_named_field = 1;
7078 detect_field_duplicates (fieldlist);
7080 /* Now we have the nearly final fieldlist. Record it,
7081 then lay out the structure or union (including the fields). */
7083 TYPE_FIELDS (t) = fieldlist;
7087 /* Give bit-fields their proper types. */
7089 tree *fieldlistp = &fieldlist;
7091 if (TREE_CODE (*fieldlistp) == FIELD_DECL && DECL_INITIAL (*fieldlistp)
7092 && TREE_TYPE (*fieldlistp) != error_mark_node)
7094 unsigned HOST_WIDE_INT width
7095 = tree_low_cst (DECL_INITIAL (*fieldlistp), 1);
7096 tree type = TREE_TYPE (*fieldlistp);
7097 if (width != TYPE_PRECISION (type))
7099 TREE_TYPE (*fieldlistp)
7100 = c_build_bitfield_integer_type (width, TYPE_UNSIGNED (type));
7101 DECL_MODE (*fieldlistp) = TYPE_MODE (TREE_TYPE (*fieldlistp));
7103 DECL_INITIAL (*fieldlistp) = 0;
7106 fieldlistp = &DECL_CHAIN (*fieldlistp);
7109 /* Now we have the truly final field list.
7110 Store it in this type and in the variants. */
7112 TYPE_FIELDS (t) = fieldlist;
7114 /* If there are lots of fields, sort so we can look through them fast.
7115 We arbitrarily consider 16 or more elts to be "a lot". */
7120 for (x = fieldlist; x; x = DECL_CHAIN (x))
7122 if (len > 15 || DECL_NAME (x) == NULL)
7130 struct lang_type *space;
7131 struct sorted_fields_type *space2;
7133 len += list_length (x);
7135 /* Use the same allocation policy here that make_node uses, to
7136 ensure that this lives as long as the rest of the struct decl.
7137 All decls in an inline function need to be saved. */
7139 space = ggc_alloc_cleared_lang_type (sizeof (struct lang_type));
7140 space2 = ggc_alloc_sorted_fields_type
7141 (sizeof (struct sorted_fields_type) + len * sizeof (tree));
7145 field_array = &space2->elts[0];
7146 for (x = fieldlist; x; x = DECL_CHAIN (x))
7148 field_array[len++] = x;
7150 /* If there is anonymous struct or union, break out of the loop. */
7151 if (DECL_NAME (x) == NULL)
7154 /* Found no anonymous struct/union. Add the TYPE_LANG_SPECIFIC. */
7157 TYPE_LANG_SPECIFIC (t) = space;
7158 TYPE_LANG_SPECIFIC (t)->s->len = len;
7159 field_array = TYPE_LANG_SPECIFIC (t)->s->elts;
7160 qsort (field_array, len, sizeof (tree), field_decl_cmp);
7165 for (x = TYPE_MAIN_VARIANT (t); x; x = TYPE_NEXT_VARIANT (x))
7167 TYPE_FIELDS (x) = TYPE_FIELDS (t);
7168 TYPE_LANG_SPECIFIC (x) = TYPE_LANG_SPECIFIC (t);
7169 C_TYPE_FIELDS_READONLY (x) = C_TYPE_FIELDS_READONLY (t);
7170 C_TYPE_FIELDS_VOLATILE (x) = C_TYPE_FIELDS_VOLATILE (t);
7171 C_TYPE_VARIABLE_SIZE (x) = C_TYPE_VARIABLE_SIZE (t);
7174 /* If this was supposed to be a transparent union, but we can't
7175 make it one, warn and turn off the flag. */
7176 if (TREE_CODE (t) == UNION_TYPE
7177 && TYPE_TRANSPARENT_AGGR (t)
7178 && (!TYPE_FIELDS (t) || TYPE_MODE (t) != DECL_MODE (TYPE_FIELDS (t))))
7180 TYPE_TRANSPARENT_AGGR (t) = 0;
7181 warning_at (loc, 0, "union cannot be made transparent");
7184 /* If this structure or union completes the type of any previous
7185 variable declaration, lay it out and output its rtl. */
7186 for (x = C_TYPE_INCOMPLETE_VARS (TYPE_MAIN_VARIANT (t));
7190 tree decl = TREE_VALUE (x);
7191 if (TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE)
7192 layout_array_type (TREE_TYPE (decl));
7193 if (TREE_CODE (decl) != TYPE_DECL)
7195 layout_decl (decl, 0);
7196 if (c_dialect_objc ())
7197 objc_check_decl (decl);
7198 rest_of_decl_compilation (decl, toplevel, 0);
7203 C_TYPE_INCOMPLETE_VARS (TYPE_MAIN_VARIANT (t)) = 0;
7205 /* Update type location to the one of the definition, instead of e.g.
7206 a forward declaration. */
7207 if (TYPE_STUB_DECL (t))
7208 DECL_SOURCE_LOCATION (TYPE_STUB_DECL (t)) = loc;
7210 /* Finish debugging output for this type. */
7211 rest_of_type_compilation (t, toplevel);
7213 /* If we're inside a function proper, i.e. not file-scope and not still
7214 parsing parameters, then arrange for the size of a variable sized type
7216 if (cur_stmt_list && variably_modified_type_p (t, NULL_TREE))
7217 add_stmt (build_stmt (loc,
7218 DECL_EXPR, build_decl (loc, TYPE_DECL, NULL, t)));
7220 if (warn_cxx_compat)
7221 warn_cxx_compat_finish_struct (fieldlist);
7223 VEC_free (tree, heap, struct_parse_info->struct_types);
7224 VEC_free (c_binding_ptr, heap, struct_parse_info->fields);
7225 VEC_free (tree, heap, struct_parse_info->typedefs_seen);
7226 XDELETE (struct_parse_info);
7228 struct_parse_info = enclosing_struct_parse_info;
7230 /* If this struct is defined inside a struct, add it to
7233 && struct_parse_info != NULL
7234 && !in_sizeof && !in_typeof && !in_alignof)
7235 VEC_safe_push (tree, heap, struct_parse_info->struct_types, t);
7240 /* Lay out the type T, and its element type, and so on. */
7243 layout_array_type (tree t)
7245 if (TREE_CODE (TREE_TYPE (t)) == ARRAY_TYPE)
7246 layout_array_type (TREE_TYPE (t));
7250 /* Begin compiling the definition of an enumeration type.
7251 NAME is its name (or null if anonymous).
7252 LOC is the enum's location.
7253 Returns the type object, as yet incomplete.
7254 Also records info about it so that build_enumerator
7255 may be used to declare the individual values as they are read. */
7258 start_enum (location_t loc, struct c_enum_contents *the_enum, tree name)
7260 tree enumtype = NULL_TREE;
7261 location_t enumloc = UNKNOWN_LOCATION;
7263 /* If this is the real definition for a previous forward reference,
7264 fill in the contents in the same object that used to be the
7265 forward reference. */
7267 if (name != NULL_TREE)
7268 enumtype = lookup_tag (ENUMERAL_TYPE, name, 1, &enumloc);
7270 if (enumtype == 0 || TREE_CODE (enumtype) != ENUMERAL_TYPE)
7272 enumtype = make_node (ENUMERAL_TYPE);
7273 pushtag (loc, name, enumtype);
7276 if (C_TYPE_BEING_DEFINED (enumtype))
7277 error_at (loc, "nested redefinition of %<enum %E%>", name);
7279 C_TYPE_BEING_DEFINED (enumtype) = 1;
7281 if (TYPE_VALUES (enumtype) != 0)
7283 /* This enum is a named one that has been declared already. */
7284 error_at (loc, "redeclaration of %<enum %E%>", name);
7285 if (enumloc != UNKNOWN_LOCATION)
7286 inform (enumloc, "originally defined here");
7288 /* Completely replace its old definition.
7289 The old enumerators remain defined, however. */
7290 TYPE_VALUES (enumtype) = 0;
7293 the_enum->enum_next_value = integer_zero_node;
7294 the_enum->enum_overflow = 0;
7296 if (flag_short_enums)
7297 TYPE_PACKED (enumtype) = 1;
7299 /* FIXME: This will issue a warning for a use of a type defined
7300 within sizeof in a statement expr. This is not terribly serious
7301 as C++ doesn't permit statement exprs within sizeof anyhow. */
7302 if (warn_cxx_compat && (in_sizeof || in_typeof || in_alignof))
7303 warning_at (loc, OPT_Wc___compat,
7304 "defining type in %qs expression is invalid in C++",
7307 : (in_typeof ? "typeof" : "alignof")));
7312 /* After processing and defining all the values of an enumeration type,
7313 install their decls in the enumeration type and finish it off.
7314 ENUMTYPE is the type object, VALUES a list of decl-value pairs,
7315 and ATTRIBUTES are the specified attributes.
7316 Returns ENUMTYPE. */
7319 finish_enum (tree enumtype, tree values, tree attributes)
7322 tree minnode = 0, maxnode = 0;
7323 int precision, unsign;
7324 bool toplevel = (file_scope == current_scope);
7325 struct lang_type *lt;
7327 decl_attributes (&enumtype, attributes, (int) ATTR_FLAG_TYPE_IN_PLACE);
7329 /* Calculate the maximum value of any enumerator in this type. */
7331 if (values == error_mark_node)
7332 minnode = maxnode = integer_zero_node;
7335 minnode = maxnode = TREE_VALUE (values);
7336 for (pair = TREE_CHAIN (values); pair; pair = TREE_CHAIN (pair))
7338 tree value = TREE_VALUE (pair);
7339 if (tree_int_cst_lt (maxnode, value))
7341 if (tree_int_cst_lt (value, minnode))
7346 /* Construct the final type of this enumeration. It is the same
7347 as one of the integral types - the narrowest one that fits, except
7348 that normally we only go as narrow as int - and signed iff any of
7349 the values are negative. */
7350 unsign = (tree_int_cst_sgn (minnode) >= 0);
7351 precision = MAX (tree_int_cst_min_precision (minnode, unsign),
7352 tree_int_cst_min_precision (maxnode, unsign));
7354 if (TYPE_PACKED (enumtype) || precision > TYPE_PRECISION (integer_type_node))
7356 tem = c_common_type_for_size (precision, unsign);
7359 warning (0, "enumeration values exceed range of largest integer");
7360 tem = long_long_integer_type_node;
7364 tem = unsign ? unsigned_type_node : integer_type_node;
7366 TYPE_MIN_VALUE (enumtype) = TYPE_MIN_VALUE (tem);
7367 TYPE_MAX_VALUE (enumtype) = TYPE_MAX_VALUE (tem);
7368 TYPE_UNSIGNED (enumtype) = TYPE_UNSIGNED (tem);
7369 TYPE_SIZE (enumtype) = 0;
7371 /* If the precision of the type was specific with an attribute and it
7372 was too small, give an error. Otherwise, use it. */
7373 if (TYPE_PRECISION (enumtype))
7375 if (precision > TYPE_PRECISION (enumtype))
7376 error ("specified mode too small for enumeral values");
7379 TYPE_PRECISION (enumtype) = TYPE_PRECISION (tem);
7381 layout_type (enumtype);
7383 if (values != error_mark_node)
7385 /* Change the type of the enumerators to be the enum type. We
7386 need to do this irrespective of the size of the enum, for
7387 proper type checking. Replace the DECL_INITIALs of the
7388 enumerators, and the value slots of the list, with copies
7389 that have the enum type; they cannot be modified in place
7390 because they may be shared (e.g. integer_zero_node) Finally,
7391 change the purpose slots to point to the names of the decls. */
7392 for (pair = values; pair; pair = TREE_CHAIN (pair))
7394 tree enu = TREE_PURPOSE (pair);
7395 tree ini = DECL_INITIAL (enu);
7397 TREE_TYPE (enu) = enumtype;
7399 /* The ISO C Standard mandates enumerators to have type int,
7400 even though the underlying type of an enum type is
7401 unspecified. However, GCC allows enumerators of any
7402 integer type as an extensions. build_enumerator()
7403 converts any enumerators that fit in an int to type int,
7404 to avoid promotions to unsigned types when comparing
7405 integers with enumerators that fit in the int range.
7406 When -pedantic is given, build_enumerator() would have
7407 already warned about those that don't fit. Here we
7408 convert the rest to the enumerator type. */
7409 if (TREE_TYPE (ini) != integer_type_node)
7410 ini = convert (enumtype, ini);
7412 DECL_INITIAL (enu) = ini;
7413 TREE_PURPOSE (pair) = DECL_NAME (enu);
7414 TREE_VALUE (pair) = ini;
7417 TYPE_VALUES (enumtype) = values;
7420 /* Record the min/max values so that we can warn about bit-field
7421 enumerations that are too small for the values. */
7422 lt = ggc_alloc_cleared_lang_type (sizeof (struct lang_type));
7423 lt->enum_min = minnode;
7424 lt->enum_max = maxnode;
7425 TYPE_LANG_SPECIFIC (enumtype) = lt;
7427 /* Fix up all variant types of this enum type. */
7428 for (tem = TYPE_MAIN_VARIANT (enumtype); tem; tem = TYPE_NEXT_VARIANT (tem))
7430 if (tem == enumtype)
7432 TYPE_VALUES (tem) = TYPE_VALUES (enumtype);
7433 TYPE_MIN_VALUE (tem) = TYPE_MIN_VALUE (enumtype);
7434 TYPE_MAX_VALUE (tem) = TYPE_MAX_VALUE (enumtype);
7435 TYPE_SIZE (tem) = TYPE_SIZE (enumtype);
7436 TYPE_SIZE_UNIT (tem) = TYPE_SIZE_UNIT (enumtype);
7437 SET_TYPE_MODE (tem, TYPE_MODE (enumtype));
7438 TYPE_PRECISION (tem) = TYPE_PRECISION (enumtype);
7439 TYPE_ALIGN (tem) = TYPE_ALIGN (enumtype);
7440 TYPE_USER_ALIGN (tem) = TYPE_USER_ALIGN (enumtype);
7441 TYPE_UNSIGNED (tem) = TYPE_UNSIGNED (enumtype);
7442 TYPE_LANG_SPECIFIC (tem) = TYPE_LANG_SPECIFIC (enumtype);
7445 /* Finish debugging output for this type. */
7446 rest_of_type_compilation (enumtype, toplevel);
7448 /* If this enum is defined inside a struct, add it to
7451 && struct_parse_info != NULL
7452 && !in_sizeof && !in_typeof && !in_alignof)
7453 VEC_safe_push (tree, heap, struct_parse_info->struct_types, enumtype);
7458 /* Build and install a CONST_DECL for one value of the
7459 current enumeration type (one that was begun with start_enum).
7460 DECL_LOC is the location of the enumerator.
7461 LOC is the location of the '=' operator if any, DECL_LOC otherwise.
7462 Return a tree-list containing the CONST_DECL and its value.
7463 Assignment of sequential values by default is handled here. */
7466 build_enumerator (location_t decl_loc, location_t loc,
7467 struct c_enum_contents *the_enum, tree name, tree value)
7471 /* Validate and default VALUE. */
7475 /* Don't issue more errors for error_mark_node (i.e. an
7476 undeclared identifier) - just ignore the value expression. */
7477 if (value == error_mark_node)
7479 else if (!INTEGRAL_TYPE_P (TREE_TYPE (value)))
7481 error_at (loc, "enumerator value for %qE is not an integer constant",
7487 if (TREE_CODE (value) != INTEGER_CST)
7489 value = c_fully_fold (value, false, NULL);
7490 if (TREE_CODE (value) == INTEGER_CST)
7491 pedwarn (loc, OPT_pedantic,
7492 "enumerator value for %qE is not an integer "
7493 "constant expression", name);
7495 if (TREE_CODE (value) != INTEGER_CST)
7497 error ("enumerator value for %qE is not an integer constant",
7503 value = default_conversion (value);
7504 constant_expression_warning (value);
7509 /* Default based on previous value. */
7510 /* It should no longer be possible to have NON_LVALUE_EXPR
7514 value = the_enum->enum_next_value;
7515 if (the_enum->enum_overflow)
7516 error_at (loc, "overflow in enumeration values");
7518 /* Even though the underlying type of an enum is unspecified, the
7519 type of enumeration constants is explicitly defined as int
7520 (6.4.4.3/2 in the C99 Standard). GCC allows any integer type as
7522 else if (!int_fits_type_p (value, integer_type_node))
7523 pedwarn (loc, OPT_pedantic,
7524 "ISO C restricts enumerator values to range of %<int%>");
7526 /* The ISO C Standard mandates enumerators to have type int, even
7527 though the underlying type of an enum type is unspecified.
7528 However, GCC allows enumerators of any integer type as an
7529 extensions. Here we convert any enumerators that fit in an int
7530 to type int, to avoid promotions to unsigned types when comparing
7531 integers with enumerators that fit in the int range. When
7532 -pedantic is given, we would have already warned about those that
7533 don't fit. We have to do this here rather than in finish_enum
7534 because this value may be used to define more enumerators. */
7535 if (int_fits_type_p (value, integer_type_node))
7536 value = convert (integer_type_node, value);
7538 /* Set basis for default for next value. */
7539 the_enum->enum_next_value
7540 = build_binary_op (EXPR_LOC_OR_HERE (value),
7541 PLUS_EXPR, value, integer_one_node, 0);
7542 the_enum->enum_overflow = tree_int_cst_lt (the_enum->enum_next_value, value);
7544 /* Now create a declaration for the enum value name. */
7546 type = TREE_TYPE (value);
7547 type = c_common_type_for_size (MAX (TYPE_PRECISION (type),
7548 TYPE_PRECISION (integer_type_node)),
7549 (TYPE_PRECISION (type)
7550 >= TYPE_PRECISION (integer_type_node)
7551 && TYPE_UNSIGNED (type)));
7553 decl = build_decl (decl_loc, CONST_DECL, name, type);
7554 DECL_INITIAL (decl) = convert (type, value);
7557 return tree_cons (decl, value, NULL_TREE);
7561 /* Create the FUNCTION_DECL for a function definition.
7562 DECLSPECS, DECLARATOR and ATTRIBUTES are the parts of
7563 the declaration; they describe the function's name and the type it returns,
7564 but twisted together in a fashion that parallels the syntax of C.
7566 This function creates a binding context for the function body
7567 as well as setting up the FUNCTION_DECL in current_function_decl.
7569 Returns 1 on success. If the DECLARATOR is not suitable for a function
7570 (it defines a datum instead), we return 0, which tells
7571 yyparse to report a parse error. */
7574 start_function (struct c_declspecs *declspecs, struct c_declarator *declarator,
7577 tree decl1, old_decl;
7578 tree restype, resdecl;
7581 current_function_returns_value = 0; /* Assume, until we see it does. */
7582 current_function_returns_null = 0;
7583 current_function_returns_abnormally = 0;
7584 warn_about_return_type = 0;
7585 c_switch_stack = NULL;
7587 /* Indicate no valid break/continue context by setting these variables
7588 to some non-null, non-label value. We'll notice and emit the proper
7589 error message in c_finish_bc_stmt. */
7590 c_break_label = c_cont_label = size_zero_node;
7592 decl1 = grokdeclarator (declarator, declspecs, FUNCDEF, true, NULL,
7593 &attributes, NULL, NULL, DEPRECATED_NORMAL);
7595 /* If the declarator is not suitable for a function definition,
7596 cause a syntax error. */
7598 || TREE_CODE (decl1) != FUNCTION_DECL)
7601 loc = DECL_SOURCE_LOCATION (decl1);
7603 decl_attributes (&decl1, attributes, 0);
7605 if (DECL_DECLARED_INLINE_P (decl1)
7606 && DECL_UNINLINABLE (decl1)
7607 && lookup_attribute ("noinline", DECL_ATTRIBUTES (decl1)))
7608 warning_at (loc, OPT_Wattributes,
7609 "inline function %qD given attribute noinline",
7612 /* Handle gnu_inline attribute. */
7613 if (declspecs->inline_p
7614 && !flag_gnu89_inline
7615 && TREE_CODE (decl1) == FUNCTION_DECL
7616 && (lookup_attribute ("gnu_inline", DECL_ATTRIBUTES (decl1))
7617 || current_function_decl))
7619 if (declspecs->storage_class != csc_static)
7620 DECL_EXTERNAL (decl1) = !DECL_EXTERNAL (decl1);
7623 announce_function (decl1);
7625 if (!COMPLETE_OR_VOID_TYPE_P (TREE_TYPE (TREE_TYPE (decl1))))
7627 error_at (loc, "return type is an incomplete type");
7628 /* Make it return void instead. */
7630 = build_function_type (void_type_node,
7631 TYPE_ARG_TYPES (TREE_TYPE (decl1)));
7634 if (warn_about_return_type)
7635 pedwarn_c99 (loc, flag_isoc99 ? 0
7636 : (warn_return_type ? OPT_Wreturn_type : OPT_Wimplicit_int),
7637 "return type defaults to %<int%>");
7639 /* Make the init_value nonzero so pushdecl knows this is not tentative.
7640 error_mark_node is replaced below (in pop_scope) with the BLOCK. */
7641 DECL_INITIAL (decl1) = error_mark_node;
7643 /* A nested function is not global. */
7644 if (current_function_decl != 0)
7645 TREE_PUBLIC (decl1) = 0;
7647 /* If this definition isn't a prototype and we had a prototype declaration
7648 before, copy the arg type info from that prototype. */
7649 old_decl = lookup_name_in_scope (DECL_NAME (decl1), current_scope);
7650 if (old_decl && TREE_CODE (old_decl) != FUNCTION_DECL)
7652 current_function_prototype_locus = UNKNOWN_LOCATION;
7653 current_function_prototype_built_in = false;
7654 current_function_prototype_arg_types = NULL_TREE;
7655 if (!prototype_p (TREE_TYPE (decl1)))
7657 if (old_decl != 0 && TREE_CODE (TREE_TYPE (old_decl)) == FUNCTION_TYPE
7658 && comptypes (TREE_TYPE (TREE_TYPE (decl1)),
7659 TREE_TYPE (TREE_TYPE (old_decl))))
7661 TREE_TYPE (decl1) = composite_type (TREE_TYPE (old_decl),
7663 current_function_prototype_locus = DECL_SOURCE_LOCATION (old_decl);
7664 current_function_prototype_built_in
7665 = C_DECL_BUILTIN_PROTOTYPE (old_decl);
7666 current_function_prototype_arg_types
7667 = TYPE_ARG_TYPES (TREE_TYPE (decl1));
7669 if (TREE_PUBLIC (decl1))
7671 /* If there is an external prototype declaration of this
7672 function, record its location but do not copy information
7673 to this decl. This may be an invisible declaration
7674 (built-in or in a scope which has finished) or simply
7675 have more refined argument types than any declaration
7677 struct c_binding *b;
7678 for (b = I_SYMBOL_BINDING (DECL_NAME (decl1)); b; b = b->shadowed)
7679 if (B_IN_SCOPE (b, external_scope))
7683 tree ext_decl, ext_type;
7685 ext_type = b->u.type ? b->u.type : TREE_TYPE (ext_decl);
7686 if (TREE_CODE (ext_type) == FUNCTION_TYPE
7687 && comptypes (TREE_TYPE (TREE_TYPE (decl1)),
7688 TREE_TYPE (ext_type)))
7690 current_function_prototype_locus
7691 = DECL_SOURCE_LOCATION (ext_decl);
7692 current_function_prototype_built_in
7693 = C_DECL_BUILTIN_PROTOTYPE (ext_decl);
7694 current_function_prototype_arg_types
7695 = TYPE_ARG_TYPES (ext_type);
7701 /* Optionally warn of old-fashioned def with no previous prototype. */
7702 if (warn_strict_prototypes
7703 && old_decl != error_mark_node
7704 && !prototype_p (TREE_TYPE (decl1))
7705 && C_DECL_ISNT_PROTOTYPE (old_decl))
7706 warning_at (loc, OPT_Wstrict_prototypes,
7707 "function declaration isn%'t a prototype");
7708 /* Optionally warn of any global def with no previous prototype. */
7709 else if (warn_missing_prototypes
7710 && old_decl != error_mark_node
7711 && TREE_PUBLIC (decl1)
7712 && !MAIN_NAME_P (DECL_NAME (decl1))
7713 && C_DECL_ISNT_PROTOTYPE (old_decl))
7714 warning_at (loc, OPT_Wmissing_prototypes,
7715 "no previous prototype for %qD", decl1);
7716 /* Optionally warn of any def with no previous prototype
7717 if the function has already been used. */
7718 else if (warn_missing_prototypes
7720 && old_decl != error_mark_node
7721 && TREE_USED (old_decl)
7722 && !prototype_p (TREE_TYPE (old_decl)))
7723 warning_at (loc, OPT_Wmissing_prototypes,
7724 "%qD was used with no prototype before its definition", decl1);
7725 /* Optionally warn of any global def with no previous declaration. */
7726 else if (warn_missing_declarations
7727 && TREE_PUBLIC (decl1)
7729 && !MAIN_NAME_P (DECL_NAME (decl1)))
7730 warning_at (loc, OPT_Wmissing_declarations,
7731 "no previous declaration for %qD",
7733 /* Optionally warn of any def with no previous declaration
7734 if the function has already been used. */
7735 else if (warn_missing_declarations
7737 && old_decl != error_mark_node
7738 && TREE_USED (old_decl)
7739 && C_DECL_IMPLICIT (old_decl))
7740 warning_at (loc, OPT_Wmissing_declarations,
7741 "%qD was used with no declaration before its definition", decl1);
7743 /* This function exists in static storage.
7744 (This does not mean `static' in the C sense!) */
7745 TREE_STATIC (decl1) = 1;
7747 /* This is the earliest point at which we might know the assembler
7748 name of the function. Thus, if it's set before this, die horribly. */
7749 gcc_assert (!DECL_ASSEMBLER_NAME_SET_P (decl1));
7751 /* If #pragma weak was used, mark the decl weak now. */
7752 if (current_scope == file_scope)
7753 maybe_apply_pragma_weak (decl1);
7755 /* Warn for unlikely, improbable, or stupid declarations of `main'. */
7756 if (warn_main && MAIN_NAME_P (DECL_NAME (decl1)))
7758 if (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (decl1)))
7759 != integer_type_node)
7760 pedwarn (loc, OPT_Wmain, "return type of %qD is not %<int%>", decl1);
7762 check_main_parameter_types (decl1);
7764 if (!TREE_PUBLIC (decl1))
7765 pedwarn (loc, OPT_Wmain,
7766 "%qD is normally a non-static function", decl1);
7769 /* Record the decl so that the function name is defined.
7770 If we already have a decl for this name, and it is a FUNCTION_DECL,
7771 use the old decl. */
7773 current_function_decl = pushdecl (decl1);
7776 declare_parm_level ();
7778 restype = TREE_TYPE (TREE_TYPE (current_function_decl));
7779 resdecl = build_decl (loc, RESULT_DECL, NULL_TREE, restype);
7780 DECL_ARTIFICIAL (resdecl) = 1;
7781 DECL_IGNORED_P (resdecl) = 1;
7782 DECL_RESULT (current_function_decl) = resdecl;
7784 start_fname_decls ();
7789 /* Subroutine of store_parm_decls which handles new-style function
7790 definitions (prototype format). The parms already have decls, so we
7791 need only record them as in effect and complain if any redundant
7792 old-style parm decls were written. */
7794 store_parm_decls_newstyle (tree fndecl, const struct c_arg_info *arg_info)
7800 if (current_scope->bindings)
7802 error_at (DECL_SOURCE_LOCATION (fndecl),
7803 "old-style parameter declarations in prototyped "
7804 "function definition");
7806 /* Get rid of the old-style declarations. */
7810 /* Don't issue this warning for nested functions, and don't issue this
7811 warning if we got here because ARG_INFO_TYPES was error_mark_node
7812 (this happens when a function definition has just an ellipsis in
7813 its parameter list). */
7814 else if (!in_system_header && !current_function_scope
7815 && arg_info->types != error_mark_node)
7816 warning_at (DECL_SOURCE_LOCATION (fndecl), OPT_Wtraditional,
7817 "traditional C rejects ISO C style function definitions");
7819 /* Now make all the parameter declarations visible in the function body.
7820 We can bypass most of the grunt work of pushdecl. */
7821 for (decl = arg_info->parms; decl; decl = DECL_CHAIN (decl))
7823 DECL_CONTEXT (decl) = current_function_decl;
7824 if (DECL_NAME (decl))
7826 bind (DECL_NAME (decl), decl, current_scope,
7827 /*invisible=*/false, /*nested=*/false,
7829 if (!TREE_USED (decl))
7830 warn_if_shadowing (decl);
7833 error_at (DECL_SOURCE_LOCATION (decl), "parameter name omitted");
7836 /* Record the parameter list in the function declaration. */
7837 DECL_ARGUMENTS (fndecl) = arg_info->parms;
7839 /* Now make all the ancillary declarations visible, likewise. */
7840 for (decl = arg_info->others; decl; decl = DECL_CHAIN (decl))
7842 DECL_CONTEXT (decl) = current_function_decl;
7843 if (DECL_NAME (decl))
7844 bind (DECL_NAME (decl), decl, current_scope,
7845 /*invisible=*/false,
7846 /*nested=*/(TREE_CODE (decl) == FUNCTION_DECL),
7850 /* And all the tag declarations. */
7851 FOR_EACH_VEC_ELT_REVERSE (c_arg_tag, arg_info->tags, ix, tag)
7853 bind (tag->id, tag->type, current_scope,
7854 /*invisible=*/false, /*nested=*/false, UNKNOWN_LOCATION);
7857 /* Subroutine of store_parm_decls which handles old-style function
7858 definitions (separate parameter list and declarations). */
7861 store_parm_decls_oldstyle (tree fndecl, const struct c_arg_info *arg_info)
7863 struct c_binding *b;
7864 tree parm, decl, last;
7865 tree parmids = arg_info->parms;
7866 struct pointer_set_t *seen_args = pointer_set_create ();
7868 if (!in_system_header)
7869 warning_at (DECL_SOURCE_LOCATION (fndecl),
7870 OPT_Wold_style_definition, "old-style function definition");
7872 /* Match each formal parameter name with its declaration. Save each
7873 decl in the appropriate TREE_PURPOSE slot of the parmids chain. */
7874 for (parm = parmids; parm; parm = TREE_CHAIN (parm))
7876 if (TREE_VALUE (parm) == 0)
7878 error_at (DECL_SOURCE_LOCATION (fndecl),
7879 "parameter name missing from parameter list");
7880 TREE_PURPOSE (parm) = 0;
7884 b = I_SYMBOL_BINDING (TREE_VALUE (parm));
7885 if (b && B_IN_CURRENT_SCOPE (b))
7888 /* Skip erroneous parameters. */
7889 if (decl == error_mark_node)
7891 /* If we got something other than a PARM_DECL it is an error. */
7892 if (TREE_CODE (decl) != PARM_DECL)
7893 error_at (DECL_SOURCE_LOCATION (decl),
7894 "%qD declared as a non-parameter", decl);
7895 /* If the declaration is already marked, we have a duplicate
7896 name. Complain and ignore the duplicate. */
7897 else if (pointer_set_contains (seen_args, decl))
7899 error_at (DECL_SOURCE_LOCATION (decl),
7900 "multiple parameters named %qD", decl);
7901 TREE_PURPOSE (parm) = 0;
7904 /* If the declaration says "void", complain and turn it into
7906 else if (VOID_TYPE_P (TREE_TYPE (decl)))
7908 error_at (DECL_SOURCE_LOCATION (decl),
7909 "parameter %qD declared with void type", decl);
7910 TREE_TYPE (decl) = integer_type_node;
7911 DECL_ARG_TYPE (decl) = integer_type_node;
7912 layout_decl (decl, 0);
7914 warn_if_shadowing (decl);
7916 /* If no declaration found, default to int. */
7919 /* FIXME diagnostics: This should be the location of the argument,
7920 not the FNDECL. E.g., for an old-style declaration
7922 int f10(v) { blah; }
7924 We should use the location of the V, not the F10.
7925 Unfortunately, the V is an IDENTIFIER_NODE which has no
7926 location. In the future we need locations for c_arg_info
7929 See gcc.dg/Wshadow-3.c for an example of this problem. */
7930 decl = build_decl (DECL_SOURCE_LOCATION (fndecl),
7931 PARM_DECL, TREE_VALUE (parm), integer_type_node);
7932 DECL_ARG_TYPE (decl) = TREE_TYPE (decl);
7934 warn_if_shadowing (decl);
7937 pedwarn (DECL_SOURCE_LOCATION (decl),
7938 0, "type of %qD defaults to %<int%>", decl);
7940 warning_at (DECL_SOURCE_LOCATION (decl),
7941 OPT_Wmissing_parameter_type,
7942 "type of %qD defaults to %<int%>", decl);
7945 TREE_PURPOSE (parm) = decl;
7946 pointer_set_insert (seen_args, decl);
7949 /* Now examine the parms chain for incomplete declarations
7950 and declarations with no corresponding names. */
7952 for (b = current_scope->bindings; b; b = b->prev)
7955 if (TREE_CODE (parm) != PARM_DECL)
7958 if (TREE_TYPE (parm) != error_mark_node
7959 && !COMPLETE_TYPE_P (TREE_TYPE (parm)))
7961 error_at (DECL_SOURCE_LOCATION (parm),
7962 "parameter %qD has incomplete type", parm);
7963 TREE_TYPE (parm) = error_mark_node;
7966 if (!pointer_set_contains (seen_args, parm))
7968 error_at (DECL_SOURCE_LOCATION (parm),
7969 "declaration for parameter %qD but no such parameter",
7972 /* Pretend the parameter was not missing.
7973 This gets us to a standard state and minimizes
7974 further error messages. */
7975 parmids = chainon (parmids, tree_cons (parm, 0, 0));
7979 /* Chain the declarations together in the order of the list of
7980 names. Store that chain in the function decl, replacing the
7981 list of names. Update the current scope to match. */
7982 DECL_ARGUMENTS (fndecl) = 0;
7984 for (parm = parmids; parm; parm = TREE_CHAIN (parm))
7985 if (TREE_PURPOSE (parm))
7987 if (parm && TREE_PURPOSE (parm))
7989 last = TREE_PURPOSE (parm);
7990 DECL_ARGUMENTS (fndecl) = last;
7992 for (parm = TREE_CHAIN (parm); parm; parm = TREE_CHAIN (parm))
7993 if (TREE_PURPOSE (parm))
7995 DECL_CHAIN (last) = TREE_PURPOSE (parm);
7996 last = TREE_PURPOSE (parm);
7998 DECL_CHAIN (last) = 0;
8001 pointer_set_destroy (seen_args);
8003 /* If there was a previous prototype,
8004 set the DECL_ARG_TYPE of each argument according to
8005 the type previously specified, and report any mismatches. */
8007 if (current_function_prototype_arg_types)
8010 for (parm = DECL_ARGUMENTS (fndecl),
8011 type = current_function_prototype_arg_types;
8012 parm || (type && TREE_VALUE (type) != error_mark_node
8013 && (TYPE_MAIN_VARIANT (TREE_VALUE (type)) != void_type_node));
8014 parm = DECL_CHAIN (parm), type = TREE_CHAIN (type))
8016 if (parm == 0 || type == 0
8017 || TYPE_MAIN_VARIANT (TREE_VALUE (type)) == void_type_node)
8019 if (current_function_prototype_built_in)
8020 warning_at (DECL_SOURCE_LOCATION (fndecl),
8021 0, "number of arguments doesn%'t match "
8022 "built-in prototype");
8025 /* FIXME diagnostics: This should be the location of
8026 FNDECL, but there is bug when a prototype is
8027 declared inside function context, but defined
8028 outside of it (e.g., gcc.dg/pr15698-2.c). In
8029 which case FNDECL gets the location of the
8030 prototype, not the definition. */
8031 error_at (input_location,
8032 "number of arguments doesn%'t match prototype");
8034 error_at (current_function_prototype_locus,
8035 "prototype declaration");
8039 /* Type for passing arg must be consistent with that
8040 declared for the arg. ISO C says we take the unqualified
8041 type for parameters declared with qualified type. */
8042 if (TREE_TYPE (parm) != error_mark_node
8043 && TREE_TYPE (type) != error_mark_node
8044 && !comptypes (TYPE_MAIN_VARIANT (DECL_ARG_TYPE (parm)),
8045 TYPE_MAIN_VARIANT (TREE_VALUE (type))))
8047 if (TYPE_MAIN_VARIANT (TREE_TYPE (parm))
8048 == TYPE_MAIN_VARIANT (TREE_VALUE (type)))
8050 /* Adjust argument to match prototype. E.g. a previous
8051 `int foo(float);' prototype causes
8052 `int foo(x) float x; {...}' to be treated like
8053 `int foo(float x) {...}'. This is particularly
8054 useful for argument types like uid_t. */
8055 DECL_ARG_TYPE (parm) = TREE_TYPE (parm);
8057 if (targetm.calls.promote_prototypes (TREE_TYPE (current_function_decl))
8058 && INTEGRAL_TYPE_P (TREE_TYPE (parm))
8059 && TYPE_PRECISION (TREE_TYPE (parm))
8060 < TYPE_PRECISION (integer_type_node))
8061 DECL_ARG_TYPE (parm) = integer_type_node;
8063 /* ??? Is it possible to get here with a
8064 built-in prototype or will it always have
8065 been diagnosed as conflicting with an
8066 old-style definition and discarded? */
8067 if (current_function_prototype_built_in)
8068 warning_at (DECL_SOURCE_LOCATION (parm),
8069 OPT_pedantic, "promoted argument %qD "
8070 "doesn%'t match built-in prototype", parm);
8073 pedwarn (DECL_SOURCE_LOCATION (parm),
8074 OPT_pedantic, "promoted argument %qD "
8075 "doesn%'t match prototype", parm);
8076 pedwarn (current_function_prototype_locus, OPT_pedantic,
8077 "prototype declaration");
8082 if (current_function_prototype_built_in)
8083 warning_at (DECL_SOURCE_LOCATION (parm),
8084 0, "argument %qD doesn%'t match "
8085 "built-in prototype", parm);
8088 error_at (DECL_SOURCE_LOCATION (parm),
8089 "argument %qD doesn%'t match prototype", parm);
8090 error_at (current_function_prototype_locus,
8091 "prototype declaration");
8096 TYPE_ACTUAL_ARG_TYPES (TREE_TYPE (fndecl)) = 0;
8099 /* Otherwise, create a prototype that would match. */
8103 tree actual = 0, last = 0, type;
8105 for (parm = DECL_ARGUMENTS (fndecl); parm; parm = DECL_CHAIN (parm))
8107 type = tree_cons (NULL_TREE, DECL_ARG_TYPE (parm), NULL_TREE);
8109 TREE_CHAIN (last) = type;
8114 type = tree_cons (NULL_TREE, void_type_node, NULL_TREE);
8116 TREE_CHAIN (last) = type;
8120 /* We are going to assign a new value for the TYPE_ACTUAL_ARG_TYPES
8121 of the type of this function, but we need to avoid having this
8122 affect the types of other similarly-typed functions, so we must
8123 first force the generation of an identical (but separate) type
8124 node for the relevant function type. The new node we create
8125 will be a variant of the main variant of the original function
8128 TREE_TYPE (fndecl) = build_variant_type_copy (TREE_TYPE (fndecl));
8130 TYPE_ACTUAL_ARG_TYPES (TREE_TYPE (fndecl)) = actual;
8134 /* Store parameter declarations passed in ARG_INFO into the current
8135 function declaration. */
8138 store_parm_decls_from (struct c_arg_info *arg_info)
8140 current_function_arg_info = arg_info;
8141 store_parm_decls ();
8144 /* Store the parameter declarations into the current function declaration.
8145 This is called after parsing the parameter declarations, before
8146 digesting the body of the function.
8148 For an old-style definition, construct a prototype out of the old-style
8149 parameter declarations and inject it into the function's type. */
8152 store_parm_decls (void)
8154 tree fndecl = current_function_decl;
8157 /* The argument information block for FNDECL. */
8158 struct c_arg_info *arg_info = current_function_arg_info;
8159 current_function_arg_info = 0;
8161 /* True if this definition is written with a prototype. Note:
8162 despite C99 6.7.5.3p14, we can *not* treat an empty argument
8163 list in a function definition as equivalent to (void) -- an
8164 empty argument list specifies the function has no parameters,
8165 but only (void) sets up a prototype for future calls. */
8166 proto = arg_info->types != 0;
8169 store_parm_decls_newstyle (fndecl, arg_info);
8171 store_parm_decls_oldstyle (fndecl, arg_info);
8173 /* The next call to push_scope will be a function body. */
8175 next_is_function_body = true;
8177 /* Write a record describing this function definition to the prototypes
8178 file (if requested). */
8180 gen_aux_info_record (fndecl, 1, 0, proto);
8182 /* Initialize the RTL code for the function. */
8183 allocate_struct_function (fndecl, false);
8185 /* Begin the statement tree for this function. */
8186 DECL_SAVED_TREE (fndecl) = push_stmt_list ();
8188 /* ??? Insert the contents of the pending sizes list into the function
8189 to be evaluated. The only reason left to have this is
8190 void foo(int n, int array[n++])
8191 because we throw away the array type in favor of a pointer type, and
8192 thus won't naturally see the SAVE_EXPR containing the increment. All
8193 other pending sizes would be handled by gimplify_parameters. */
8195 VEC(tree,gc) *pending_sizes = get_pending_sizes ();
8199 FOR_EACH_VEC_ELT (tree, pending_sizes, i, t)
8203 /* Even though we're inside a function body, we still don't want to
8204 call expand_expr to calculate the size of a variable-sized array.
8205 We haven't necessarily assigned RTL to all variables yet, so it's
8206 not safe to try to expand expressions involving them. */
8207 cfun->dont_save_pending_sizes_p = 1;
8211 /* Finish up a function declaration and compile that function
8212 all the way to assembler language output. Then free the storage
8213 for the function definition.
8215 This is called after parsing the body of the function definition. */
8218 finish_function (void)
8220 tree fndecl = current_function_decl;
8222 if (c_dialect_objc ())
8223 objc_finish_function ();
8225 if (TREE_CODE (fndecl) == FUNCTION_DECL
8226 && targetm.calls.promote_prototypes (TREE_TYPE (fndecl)))
8228 tree args = DECL_ARGUMENTS (fndecl);
8229 for (; args; args = DECL_CHAIN (args))
8231 tree type = TREE_TYPE (args);
8232 if (INTEGRAL_TYPE_P (type)
8233 && TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node))
8234 DECL_ARG_TYPE (args) = integer_type_node;
8238 if (DECL_INITIAL (fndecl) && DECL_INITIAL (fndecl) != error_mark_node)
8239 BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl)) = fndecl;
8241 /* Must mark the RESULT_DECL as being in this function. */
8243 if (DECL_RESULT (fndecl) && DECL_RESULT (fndecl) != error_mark_node)
8244 DECL_CONTEXT (DECL_RESULT (fndecl)) = fndecl;
8246 if (MAIN_NAME_P (DECL_NAME (fndecl)) && flag_hosted
8247 && TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (fndecl)))
8248 == integer_type_node && flag_isoc99)
8250 /* Hack. We don't want the middle-end to warn that this return
8251 is unreachable, so we mark its location as special. Using
8252 UNKNOWN_LOCATION has the problem that it gets clobbered in
8253 annotate_one_with_locus. A cleaner solution might be to
8254 ensure ! should_carry_locus_p (stmt), but that needs a flag.
8256 c_finish_return (BUILTINS_LOCATION, integer_zero_node, NULL_TREE);
8259 /* Tie off the statement tree for this function. */
8260 DECL_SAVED_TREE (fndecl) = pop_stmt_list (DECL_SAVED_TREE (fndecl));
8262 finish_fname_decls ();
8264 /* Complain if there's just no return statement. */
8265 if (warn_return_type
8266 && TREE_CODE (TREE_TYPE (TREE_TYPE (fndecl))) != VOID_TYPE
8267 && !current_function_returns_value && !current_function_returns_null
8268 /* Don't complain if we are no-return. */
8269 && !current_function_returns_abnormally
8270 /* Don't complain if we are declared noreturn. */
8271 && !TREE_THIS_VOLATILE (fndecl)
8272 /* Don't warn for main(). */
8273 && !MAIN_NAME_P (DECL_NAME (fndecl))
8274 /* Or if they didn't actually specify a return type. */
8275 && !C_FUNCTION_IMPLICIT_INT (fndecl)
8276 /* Normally, with -Wreturn-type, flow will complain, but we might
8277 optimize out static functions. */
8278 && !TREE_PUBLIC (fndecl))
8280 warning (OPT_Wreturn_type,
8281 "no return statement in function returning non-void");
8282 TREE_NO_WARNING (fndecl) = 1;
8285 /* Complain about parameters that are only set, but never otherwise used. */
8286 if (warn_unused_but_set_parameter)
8290 for (decl = DECL_ARGUMENTS (fndecl);
8292 decl = DECL_CHAIN (decl))
8293 if (TREE_USED (decl)
8294 && TREE_CODE (decl) == PARM_DECL
8295 && !DECL_READ_P (decl)
8297 && !DECL_ARTIFICIAL (decl)
8298 && !TREE_NO_WARNING (decl))
8299 warning_at (DECL_SOURCE_LOCATION (decl),
8300 OPT_Wunused_but_set_parameter,
8301 "parameter %qD set but not used", decl);
8304 /* Store the end of the function, so that we get good line number
8305 info for the epilogue. */
8306 cfun->function_end_locus = input_location;
8308 /* Finalize the ELF visibility for the function. */
8309 c_determine_visibility (fndecl);
8311 /* For GNU C extern inline functions disregard inline limits. */
8312 if (DECL_EXTERNAL (fndecl)
8313 && DECL_DECLARED_INLINE_P (fndecl))
8314 DECL_DISREGARD_INLINE_LIMITS (fndecl) = 1;
8316 /* Genericize before inlining. Delay genericizing nested functions
8317 until their parent function is genericized. Since finalizing
8318 requires GENERIC, delay that as well. */
8320 if (DECL_INITIAL (fndecl) && DECL_INITIAL (fndecl) != error_mark_node
8321 && !undef_nested_function)
8323 if (!decl_function_context (fndecl))
8325 invoke_plugin_callbacks (PLUGIN_PRE_GENERICIZE, fndecl);
8326 c_genericize (fndecl);
8328 /* ??? Objc emits functions after finalizing the compilation unit.
8329 This should be cleaned up later and this conditional removed. */
8330 if (cgraph_global_info_ready)
8332 cgraph_add_new_function (fndecl, false);
8335 cgraph_finalize_function (fndecl, false);
8339 /* Register this function with cgraph just far enough to get it
8340 added to our parent's nested function list. Handy, since the
8341 C front end doesn't have such a list. */
8342 (void) cgraph_node (fndecl);
8346 if (!decl_function_context (fndecl))
8347 undef_nested_function = false;
8349 /* We're leaving the context of this function, so zap cfun.
8350 It's still in DECL_STRUCT_FUNCTION, and we'll restore it in
8351 tree_rest_of_compilation. */
8353 current_function_decl = NULL;
8356 /* Check the declarations given in a for-loop for satisfying the C99
8357 constraints. If exactly one such decl is found, return it. LOC is
8358 the location of the opening parenthesis of the for loop. The last
8359 parameter allows you to control the "for loop initial declarations
8360 are only allowed in C99 mode". Normally, you should pass
8361 flag_isoc99 as that parameter. But in some cases (Objective-C
8362 foreach loop, for example) we want to run the checks in this
8363 function even if not in C99 mode, so we allow the caller to turn
8364 off the error about not being in C99 mode.
8368 check_for_loop_decls (location_t loc, bool turn_off_iso_c99_error)
8370 struct c_binding *b;
8371 tree one_decl = NULL_TREE;
8374 if (!turn_off_iso_c99_error)
8376 static bool hint = true;
8377 /* If we get here, declarations have been used in a for loop without
8378 the C99 for loop scope. This doesn't make much sense, so don't
8380 error_at (loc, "%<for%> loop initial declarations "
8381 "are only allowed in C99 mode");
8385 "use option -std=c99 or -std=gnu99 to compile your code");
8390 /* C99 subclause 6.8.5 paragraph 3:
8392 [#3] The declaration part of a for statement shall only
8393 declare identifiers for objects having storage class auto or
8396 It isn't clear whether, in this sentence, "identifiers" binds to
8397 "shall only declare" or to "objects" - that is, whether all identifiers
8398 declared must be identifiers for objects, or whether the restriction
8399 only applies to those that are. (A question on this in comp.std.c
8400 in November 2000 received no answer.) We implement the strictest
8401 interpretation, to avoid creating an extension which later causes
8404 for (b = current_scope->bindings; b; b = b->prev)
8407 tree decl = b->decl;
8412 switch (TREE_CODE (decl))
8416 location_t decl_loc = DECL_SOURCE_LOCATION (decl);
8417 if (TREE_STATIC (decl))
8419 "declaration of static variable %qD in %<for%> loop "
8420 "initial declaration", decl);
8421 else if (DECL_EXTERNAL (decl))
8423 "declaration of %<extern%> variable %qD in %<for%> loop "
8424 "initial declaration", decl);
8430 "%<struct %E%> declared in %<for%> loop initial "
8435 "%<union %E%> declared in %<for%> loop initial declaration",
8439 error_at (loc, "%<enum %E%> declared in %<for%> loop "
8440 "initial declaration", id);
8443 error_at (loc, "declaration of non-variable "
8444 "%qD in %<for%> loop initial declaration", decl);
8451 return n_decls == 1 ? one_decl : NULL_TREE;
8454 /* Save and reinitialize the variables
8455 used during compilation of a C function. */
8458 c_push_function_context (void)
8460 struct language_function *p;
8461 p = ggc_alloc_language_function ();
8464 p->base.x_stmt_tree = c_stmt_tree;
8465 p->x_break_label = c_break_label;
8466 p->x_cont_label = c_cont_label;
8467 p->x_switch_stack = c_switch_stack;
8468 p->arg_info = current_function_arg_info;
8469 p->returns_value = current_function_returns_value;
8470 p->returns_null = current_function_returns_null;
8471 p->returns_abnormally = current_function_returns_abnormally;
8472 p->warn_about_return_type = warn_about_return_type;
8474 push_function_context ();
8477 /* Restore the variables used during compilation of a C function. */
8480 c_pop_function_context (void)
8482 struct language_function *p;
8484 pop_function_context ();
8486 cfun->language = NULL;
8488 if (DECL_STRUCT_FUNCTION (current_function_decl) == 0
8489 && DECL_SAVED_TREE (current_function_decl) == NULL_TREE)
8491 /* Stop pointing to the local nodes about to be freed. */
8492 /* But DECL_INITIAL must remain nonzero so we know this
8493 was an actual function definition. */
8494 DECL_INITIAL (current_function_decl) = error_mark_node;
8495 DECL_ARGUMENTS (current_function_decl) = 0;
8498 c_stmt_tree = p->base.x_stmt_tree;
8499 c_break_label = p->x_break_label;
8500 c_cont_label = p->x_cont_label;
8501 c_switch_stack = p->x_switch_stack;
8502 current_function_arg_info = p->arg_info;
8503 current_function_returns_value = p->returns_value;
8504 current_function_returns_null = p->returns_null;
8505 current_function_returns_abnormally = p->returns_abnormally;
8506 warn_about_return_type = p->warn_about_return_type;
8509 /* The functions below are required for functionality of doing
8510 function at once processing in the C front end. Currently these
8511 functions are not called from anywhere in the C front end, but as
8512 these changes continue, that will change. */
8514 /* Returns the stmt_tree (if any) to which statements are currently
8515 being added. If there is no active statement-tree, NULL is
8519 current_stmt_tree (void)
8521 return &c_stmt_tree;
8524 /* Return the global value of T as a symbol. */
8527 identifier_global_value (tree t)
8529 struct c_binding *b;
8531 for (b = I_SYMBOL_BINDING (t); b; b = b->shadowed)
8532 if (B_IN_FILE_SCOPE (b) || B_IN_EXTERNAL_SCOPE (b))
8538 /* Record a builtin type for C. If NAME is non-NULL, it is the name used;
8539 otherwise the name is found in ridpointers from RID_INDEX. */
8542 record_builtin_type (enum rid rid_index, const char *name, tree type)
8546 id = ridpointers[(int) rid_index];
8548 id = get_identifier (name);
8549 decl = build_decl (UNKNOWN_LOCATION, TYPE_DECL, id, type);
8551 if (debug_hooks->type_decl)
8552 debug_hooks->type_decl (decl, false);
8555 /* Build the void_list_node (void_type_node having been created). */
8557 build_void_list_node (void)
8559 tree t = build_tree_list (NULL_TREE, void_type_node);
8563 /* Return a c_parm structure with the given SPECS, ATTRS and DECLARATOR. */
8566 build_c_parm (struct c_declspecs *specs, tree attrs,
8567 struct c_declarator *declarator)
8569 struct c_parm *ret = XOBNEW (&parser_obstack, struct c_parm);
8572 ret->declarator = declarator;
8576 /* Return a declarator with nested attributes. TARGET is the inner
8577 declarator to which these attributes apply. ATTRS are the
8580 struct c_declarator *
8581 build_attrs_declarator (tree attrs, struct c_declarator *target)
8583 struct c_declarator *ret = XOBNEW (&parser_obstack, struct c_declarator);
8584 ret->kind = cdk_attrs;
8585 ret->declarator = target;
8586 ret->u.attrs = attrs;
8590 /* Return a declarator for a function with arguments specified by ARGS
8591 and return type specified by TARGET. */
8593 struct c_declarator *
8594 build_function_declarator (struct c_arg_info *args,
8595 struct c_declarator *target)
8597 struct c_declarator *ret = XOBNEW (&parser_obstack, struct c_declarator);
8598 ret->kind = cdk_function;
8599 ret->declarator = target;
8600 ret->u.arg_info = args;
8604 /* Return a declarator for the identifier IDENT (which may be
8605 NULL_TREE for an abstract declarator). */
8607 struct c_declarator *
8608 build_id_declarator (tree ident)
8610 struct c_declarator *ret = XOBNEW (&parser_obstack, struct c_declarator);
8612 ret->declarator = 0;
8614 /* Default value - may get reset to a more precise location. */
8615 ret->id_loc = input_location;
8619 /* Return something to represent absolute declarators containing a *.
8620 TARGET is the absolute declarator that the * contains.
8621 TYPE_QUALS_ATTRS is a structure for type qualifiers and attributes
8622 to apply to the pointer type. */
8624 struct c_declarator *
8625 make_pointer_declarator (struct c_declspecs *type_quals_attrs,
8626 struct c_declarator *target)
8630 struct c_declarator *itarget = target;
8631 struct c_declarator *ret = XOBNEW (&parser_obstack, struct c_declarator);
8632 if (type_quals_attrs)
8634 attrs = type_quals_attrs->attrs;
8635 quals = quals_from_declspecs (type_quals_attrs);
8636 if (attrs != NULL_TREE)
8637 itarget = build_attrs_declarator (attrs, target);
8639 ret->kind = cdk_pointer;
8640 ret->declarator = itarget;
8641 ret->u.pointer_quals = quals;
8645 /* Return a pointer to a structure for an empty list of declaration
8648 struct c_declspecs *
8649 build_null_declspecs (void)
8651 struct c_declspecs *ret = XOBNEW (&parser_obstack, struct c_declspecs);
8656 ret->typespec_word = cts_none;
8657 ret->storage_class = csc_none;
8658 ret->expr_const_operands = true;
8659 ret->declspecs_seen_p = false;
8660 ret->typespec_kind = ctsk_none;
8661 ret->non_sc_seen_p = false;
8662 ret->typedef_p = false;
8663 ret->explicit_signed_p = false;
8664 ret->deprecated_p = false;
8665 ret->default_int_p = false;
8666 ret->long_p = false;
8667 ret->long_long_p = false;
8668 ret->short_p = false;
8669 ret->signed_p = false;
8670 ret->unsigned_p = false;
8671 ret->complex_p = false;
8672 ret->inline_p = false;
8673 ret->thread_p = false;
8674 ret->const_p = false;
8675 ret->volatile_p = false;
8676 ret->restrict_p = false;
8677 ret->saturating_p = false;
8678 ret->address_space = ADDR_SPACE_GENERIC;
8682 /* Add the address space ADDRSPACE to the declaration specifiers
8683 SPECS, returning SPECS. */
8685 struct c_declspecs *
8686 declspecs_add_addrspace (struct c_declspecs *specs, addr_space_t as)
8688 specs->non_sc_seen_p = true;
8689 specs->declspecs_seen_p = true;
8691 if (!ADDR_SPACE_GENERIC_P (specs->address_space)
8692 && specs->address_space != as)
8693 error ("incompatible address space qualifiers %qs and %qs",
8694 c_addr_space_name (as),
8695 c_addr_space_name (specs->address_space));
8697 specs->address_space = as;
8701 /* Add the type qualifier QUAL to the declaration specifiers SPECS,
8704 struct c_declspecs *
8705 declspecs_add_qual (struct c_declspecs *specs, tree qual)
8709 specs->non_sc_seen_p = true;
8710 specs->declspecs_seen_p = true;
8711 gcc_assert (TREE_CODE (qual) == IDENTIFIER_NODE
8712 && C_IS_RESERVED_WORD (qual));
8713 i = C_RID_CODE (qual);
8717 dupe = specs->const_p;
8718 specs->const_p = true;
8721 dupe = specs->volatile_p;
8722 specs->volatile_p = true;
8725 dupe = specs->restrict_p;
8726 specs->restrict_p = true;
8731 if (dupe && !flag_isoc99)
8732 pedwarn (input_location, OPT_pedantic, "duplicate %qE", qual);
8736 /* Add the type specifier TYPE to the declaration specifiers SPECS,
8739 struct c_declspecs *
8740 declspecs_add_type (location_t loc, struct c_declspecs *specs,
8741 struct c_typespec spec)
8743 tree type = spec.spec;
8744 specs->non_sc_seen_p = true;
8745 specs->declspecs_seen_p = true;
8746 specs->typespec_kind = spec.kind;
8747 if (TREE_DEPRECATED (type))
8748 specs->deprecated_p = true;
8750 /* Handle type specifier keywords. */
8751 if (TREE_CODE (type) == IDENTIFIER_NODE
8752 && C_IS_RESERVED_WORD (type)
8753 && C_RID_CODE (type) != RID_CXX_COMPAT_WARN)
8755 enum rid i = C_RID_CODE (type);
8758 error_at (loc, "two or more data types in declaration specifiers");
8761 if ((int) i <= (int) RID_LAST_MODIFIER)
8763 /* "long", "short", "signed", "unsigned", "_Complex" or "_Sat". */
8768 if (specs->long_long_p)
8770 error_at (loc, "%<long long long%> is too long for GCC");
8775 if (specs->typespec_word == cts_double)
8778 ("both %<long long%> and %<double%> in "
8779 "declaration specifiers"));
8782 pedwarn_c90 (loc, OPT_Wlong_long,
8783 "ISO C90 does not support %<long long%>");
8784 specs->long_long_p = 1;
8789 ("both %<long%> and %<short%> in "
8790 "declaration specifiers"));
8791 else if (specs->typespec_word == cts_void)
8793 ("both %<long%> and %<void%> in "
8794 "declaration specifiers"));
8795 else if (specs->typespec_word == cts_int128)
8797 ("both %<long%> and %<__int128%> in "
8798 "declaration specifiers"));
8799 else if (specs->typespec_word == cts_bool)
8801 ("both %<long%> and %<_Bool%> in "
8802 "declaration specifiers"));
8803 else if (specs->typespec_word == cts_char)
8805 ("both %<long%> and %<char%> in "
8806 "declaration specifiers"));
8807 else if (specs->typespec_word == cts_float)
8809 ("both %<long%> and %<float%> in "
8810 "declaration specifiers"));
8811 else if (specs->typespec_word == cts_dfloat32)
8813 ("both %<long%> and %<_Decimal32%> in "
8814 "declaration specifiers"));
8815 else if (specs->typespec_word == cts_dfloat64)
8817 ("both %<long%> and %<_Decimal64%> in "
8818 "declaration specifiers"));
8819 else if (specs->typespec_word == cts_dfloat128)
8821 ("both %<long%> and %<_Decimal128%> in "
8822 "declaration specifiers"));
8824 specs->long_p = true;
8827 dupe = specs->short_p;
8830 ("both %<long%> and %<short%> in "
8831 "declaration specifiers"));
8832 else if (specs->typespec_word == cts_void)
8834 ("both %<short%> and %<void%> in "
8835 "declaration specifiers"));
8836 else if (specs->typespec_word == cts_int128)
8838 ("both %<short%> and %<__int128%> in "
8839 "declaration specifiers"));
8840 else if (specs->typespec_word == cts_bool)
8842 ("both %<short%> and %<_Bool%> in "
8843 "declaration specifiers"));
8844 else if (specs->typespec_word == cts_char)
8846 ("both %<short%> and %<char%> in "
8847 "declaration specifiers"));
8848 else if (specs->typespec_word == cts_float)
8850 ("both %<short%> and %<float%> in "
8851 "declaration specifiers"));
8852 else if (specs->typespec_word == cts_double)
8854 ("both %<short%> and %<double%> in "
8855 "declaration specifiers"));
8856 else if (specs->typespec_word == cts_dfloat32)
8858 ("both %<short%> and %<_Decimal32%> in "
8859 "declaration specifiers"));
8860 else if (specs->typespec_word == cts_dfloat64)
8862 ("both %<short%> and %<_Decimal64%> in "
8863 "declaration specifiers"));
8864 else if (specs->typespec_word == cts_dfloat128)
8866 ("both %<short%> and %<_Decimal128%> in "
8867 "declaration specifiers"));
8869 specs->short_p = true;
8872 dupe = specs->signed_p;
8873 if (specs->unsigned_p)
8875 ("both %<signed%> and %<unsigned%> in "
8876 "declaration specifiers"));
8877 else if (specs->typespec_word == cts_void)
8879 ("both %<signed%> and %<void%> in "
8880 "declaration specifiers"));
8881 else if (specs->typespec_word == cts_bool)
8883 ("both %<signed%> and %<_Bool%> in "
8884 "declaration specifiers"));
8885 else if (specs->typespec_word == cts_float)
8887 ("both %<signed%> and %<float%> in "
8888 "declaration specifiers"));
8889 else if (specs->typespec_word == cts_double)
8891 ("both %<signed%> and %<double%> in "
8892 "declaration specifiers"));
8893 else if (specs->typespec_word == cts_dfloat32)
8895 ("both %<signed%> and %<_Decimal32%> in "
8896 "declaration specifiers"));
8897 else if (specs->typespec_word == cts_dfloat64)
8899 ("both %<signed%> and %<_Decimal64%> in "
8900 "declaration specifiers"));
8901 else if (specs->typespec_word == cts_dfloat128)
8903 ("both %<signed%> and %<_Decimal128%> in "
8904 "declaration specifiers"));
8906 specs->signed_p = true;
8909 dupe = specs->unsigned_p;
8910 if (specs->signed_p)
8912 ("both %<signed%> and %<unsigned%> in "
8913 "declaration specifiers"));
8914 else if (specs->typespec_word == cts_void)
8916 ("both %<unsigned%> and %<void%> in "
8917 "declaration specifiers"));
8918 else if (specs->typespec_word == cts_bool)
8920 ("both %<unsigned%> and %<_Bool%> in "
8921 "declaration specifiers"));
8922 else if (specs->typespec_word == cts_float)
8924 ("both %<unsigned%> and %<float%> in "
8925 "declaration specifiers"));
8926 else if (specs->typespec_word == cts_double)
8928 ("both %<unsigned%> and %<double%> in "
8929 "declaration specifiers"));
8930 else if (specs->typespec_word == cts_dfloat32)
8932 ("both %<unsigned%> and %<_Decimal32%> in "
8933 "declaration specifiers"));
8934 else if (specs->typespec_word == cts_dfloat64)
8936 ("both %<unsigned%> and %<_Decimal64%> in "
8937 "declaration specifiers"));
8938 else if (specs->typespec_word == cts_dfloat128)
8940 ("both %<unsigned%> and %<_Decimal128%> in "
8941 "declaration specifiers"));
8943 specs->unsigned_p = true;
8946 dupe = specs->complex_p;
8947 if (!flag_isoc99 && !in_system_header)
8948 pedwarn (loc, OPT_pedantic,
8949 "ISO C90 does not support complex types");
8950 if (specs->typespec_word == cts_void)
8952 ("both %<complex%> and %<void%> in "
8953 "declaration specifiers"));
8954 else if (specs->typespec_word == cts_bool)
8956 ("both %<complex%> and %<_Bool%> in "
8957 "declaration specifiers"));
8958 else if (specs->typespec_word == cts_dfloat32)
8960 ("both %<complex%> and %<_Decimal32%> in "
8961 "declaration specifiers"));
8962 else if (specs->typespec_word == cts_dfloat64)
8964 ("both %<complex%> and %<_Decimal64%> in "
8965 "declaration specifiers"));
8966 else if (specs->typespec_word == cts_dfloat128)
8968 ("both %<complex%> and %<_Decimal128%> in "
8969 "declaration specifiers"));
8970 else if (specs->typespec_word == cts_fract)
8972 ("both %<complex%> and %<_Fract%> in "
8973 "declaration specifiers"));
8974 else if (specs->typespec_word == cts_accum)
8976 ("both %<complex%> and %<_Accum%> in "
8977 "declaration specifiers"));
8978 else if (specs->saturating_p)
8980 ("both %<complex%> and %<_Sat%> in "
8981 "declaration specifiers"));
8983 specs->complex_p = true;
8986 dupe = specs->saturating_p;
8987 pedwarn (loc, OPT_pedantic,
8988 "ISO C does not support saturating types");
8989 if (specs->typespec_word == cts_int128)
8992 ("both %<_Sat%> and %<__int128%> in "
8993 "declaration specifiers"));
8995 else if (specs->typespec_word == cts_void)
8997 ("both %<_Sat%> and %<void%> in "
8998 "declaration specifiers"));
8999 else if (specs->typespec_word == cts_bool)
9001 ("both %<_Sat%> and %<_Bool%> in "
9002 "declaration specifiers"));
9003 else if (specs->typespec_word == cts_char)
9005 ("both %<_Sat%> and %<char%> in "
9006 "declaration specifiers"));
9007 else if (specs->typespec_word == cts_int)
9009 ("both %<_Sat%> and %<int%> in "
9010 "declaration specifiers"));
9011 else if (specs->typespec_word == cts_float)
9013 ("both %<_Sat%> and %<float%> in "
9014 "declaration specifiers"));
9015 else if (specs->typespec_word == cts_double)
9017 ("both %<_Sat%> and %<double%> in "
9018 "declaration specifiers"));
9019 else if (specs->typespec_word == cts_dfloat32)
9021 ("both %<_Sat%> and %<_Decimal32%> in "
9022 "declaration specifiers"));
9023 else if (specs->typespec_word == cts_dfloat64)
9025 ("both %<_Sat%> and %<_Decimal64%> in "
9026 "declaration specifiers"));
9027 else if (specs->typespec_word == cts_dfloat128)
9029 ("both %<_Sat%> and %<_Decimal128%> in "
9030 "declaration specifiers"));
9031 else if (specs->complex_p)
9033 ("both %<_Sat%> and %<complex%> in "
9034 "declaration specifiers"));
9036 specs->saturating_p = true;
9043 error_at (loc, "duplicate %qE", type);
9049 /* "void", "_Bool", "char", "int", "float", "double", "_Decimal32",
9050 "__int128", "_Decimal64", "_Decimal128", "_Fract" or "_Accum". */
9051 if (specs->typespec_word != cts_none)
9054 "two or more data types in declaration specifiers");
9060 if (int128_integer_type_node == NULL_TREE)
9062 error_at (loc, "%<__int128%> is not supported for this target");
9065 if (!in_system_header)
9066 pedwarn (loc, OPT_pedantic,
9067 "ISO C does not support %<__int128%> type");
9071 ("both %<__int128%> and %<long%> in "
9072 "declaration specifiers"));
9073 else if (specs->saturating_p)
9075 ("both %<_Sat%> and %<__int128%> in "
9076 "declaration specifiers"));
9077 else if (specs->short_p)
9079 ("both %<__int128%> and %<short%> in "
9080 "declaration specifiers"));
9082 specs->typespec_word = cts_int128;
9087 ("both %<long%> and %<void%> in "
9088 "declaration specifiers"));
9089 else if (specs->short_p)
9091 ("both %<short%> and %<void%> in "
9092 "declaration specifiers"));
9093 else if (specs->signed_p)
9095 ("both %<signed%> and %<void%> in "
9096 "declaration specifiers"));
9097 else if (specs->unsigned_p)
9099 ("both %<unsigned%> and %<void%> in "
9100 "declaration specifiers"));
9101 else if (specs->complex_p)
9103 ("both %<complex%> and %<void%> in "
9104 "declaration specifiers"));
9105 else if (specs->saturating_p)
9107 ("both %<_Sat%> and %<void%> in "
9108 "declaration specifiers"));
9110 specs->typespec_word = cts_void;
9115 ("both %<long%> and %<_Bool%> in "
9116 "declaration specifiers"));
9117 else if (specs->short_p)
9119 ("both %<short%> and %<_Bool%> in "
9120 "declaration specifiers"));
9121 else if (specs->signed_p)
9123 ("both %<signed%> and %<_Bool%> in "
9124 "declaration specifiers"));
9125 else if (specs->unsigned_p)
9127 ("both %<unsigned%> and %<_Bool%> in "
9128 "declaration specifiers"));
9129 else if (specs->complex_p)
9131 ("both %<complex%> and %<_Bool%> in "
9132 "declaration specifiers"));
9133 else if (specs->saturating_p)
9135 ("both %<_Sat%> and %<_Bool%> in "
9136 "declaration specifiers"));
9138 specs->typespec_word = cts_bool;
9143 ("both %<long%> and %<char%> in "
9144 "declaration specifiers"));
9145 else if (specs->short_p)
9147 ("both %<short%> and %<char%> in "
9148 "declaration specifiers"));
9149 else if (specs->saturating_p)
9151 ("both %<_Sat%> and %<char%> in "
9152 "declaration specifiers"));
9154 specs->typespec_word = cts_char;
9157 if (specs->saturating_p)
9159 ("both %<_Sat%> and %<int%> in "
9160 "declaration specifiers"));
9162 specs->typespec_word = cts_int;
9167 ("both %<long%> and %<float%> in "
9168 "declaration specifiers"));
9169 else if (specs->short_p)
9171 ("both %<short%> and %<float%> in "
9172 "declaration specifiers"));
9173 else if (specs->signed_p)
9175 ("both %<signed%> and %<float%> in "
9176 "declaration specifiers"));
9177 else if (specs->unsigned_p)
9179 ("both %<unsigned%> and %<float%> in "
9180 "declaration specifiers"));
9181 else if (specs->saturating_p)
9183 ("both %<_Sat%> and %<float%> in "
9184 "declaration specifiers"));
9186 specs->typespec_word = cts_float;
9189 if (specs->long_long_p)
9191 ("both %<long long%> and %<double%> in "
9192 "declaration specifiers"));
9193 else if (specs->short_p)
9195 ("both %<short%> and %<double%> in "
9196 "declaration specifiers"));
9197 else if (specs->signed_p)
9199 ("both %<signed%> and %<double%> in "
9200 "declaration specifiers"));
9201 else if (specs->unsigned_p)
9203 ("both %<unsigned%> and %<double%> in "
9204 "declaration specifiers"));
9205 else if (specs->saturating_p)
9207 ("both %<_Sat%> and %<double%> in "
9208 "declaration specifiers"));
9210 specs->typespec_word = cts_double;
9217 if (i == RID_DFLOAT32)
9219 else if (i == RID_DFLOAT64)
9222 str = "_Decimal128";
9223 if (specs->long_long_p)
9225 ("both %<long long%> and %<%s%> in "
9226 "declaration specifiers"),
9230 ("both %<long%> and %<%s%> in "
9231 "declaration specifiers"),
9233 else if (specs->short_p)
9235 ("both %<short%> and %<%s%> in "
9236 "declaration specifiers"),
9238 else if (specs->signed_p)
9240 ("both %<signed%> and %<%s%> in "
9241 "declaration specifiers"),
9243 else if (specs->unsigned_p)
9245 ("both %<unsigned%> and %<%s%> in "
9246 "declaration specifiers"),
9248 else if (specs->complex_p)
9250 ("both %<complex%> and %<%s%> in "
9251 "declaration specifiers"),
9253 else if (specs->saturating_p)
9255 ("both %<_Sat%> and %<%s%> in "
9256 "declaration specifiers"),
9258 else if (i == RID_DFLOAT32)
9259 specs->typespec_word = cts_dfloat32;
9260 else if (i == RID_DFLOAT64)
9261 specs->typespec_word = cts_dfloat64;
9263 specs->typespec_word = cts_dfloat128;
9265 if (!targetm.decimal_float_supported_p ())
9267 ("decimal floating point not supported "
9268 "for this target"));
9269 pedwarn (loc, OPT_pedantic,
9270 "ISO C does not support decimal floating point");
9280 if (specs->complex_p)
9282 ("both %<complex%> and %<%s%> in "
9283 "declaration specifiers"),
9285 else if (i == RID_FRACT)
9286 specs->typespec_word = cts_fract;
9288 specs->typespec_word = cts_accum;
9290 if (!targetm.fixed_point_supported_p ())
9292 "fixed-point types not supported for this target");
9293 pedwarn (loc, OPT_pedantic,
9294 "ISO C does not support fixed-point types");
9297 /* ObjC reserved word "id", handled below. */
9303 /* Now we have a typedef (a TYPE_DECL node), an identifier (some
9304 form of ObjC type, cases such as "int" and "long" being handled
9305 above), a TYPE (struct, union, enum and typeof specifiers) or an
9306 ERROR_MARK. In none of these cases may there have previously
9307 been any type specifiers. */
9308 if (specs->type || specs->typespec_word != cts_none
9309 || specs->long_p || specs->short_p || specs->signed_p
9310 || specs->unsigned_p || specs->complex_p)
9311 error_at (loc, "two or more data types in declaration specifiers");
9312 else if (TREE_CODE (type) == TYPE_DECL)
9314 if (TREE_TYPE (type) == error_mark_node)
9315 ; /* Allow the type to default to int to avoid cascading errors. */
9318 specs->type = TREE_TYPE (type);
9319 specs->decl_attr = DECL_ATTRIBUTES (type);
9320 specs->typedef_p = true;
9321 specs->explicit_signed_p = C_TYPEDEF_EXPLICITLY_SIGNED (type);
9323 /* If this typedef name is defined in a struct, then a C++
9324 lookup would return a different value. */
9326 && I_SYMBOL_BINDING (DECL_NAME (type))->in_struct)
9327 warning_at (loc, OPT_Wc___compat,
9328 "C++ lookup of %qD would return a field, not a type",
9331 /* If we are parsing a struct, record that a struct field
9333 if (warn_cxx_compat && struct_parse_info != NULL)
9334 VEC_safe_push (tree, heap, struct_parse_info->typedefs_seen, type);
9337 else if (TREE_CODE (type) == IDENTIFIER_NODE)
9339 tree t = lookup_name (type);
9340 if (!t || TREE_CODE (t) != TYPE_DECL)
9341 error_at (loc, "%qE fails to be a typedef or built in type", type);
9342 else if (TREE_TYPE (t) == error_mark_node)
9345 specs->type = TREE_TYPE (t);
9349 if (TREE_CODE (type) != ERROR_MARK && spec.kind == ctsk_typeof)
9351 specs->typedef_p = true;
9355 specs->expr = build2 (COMPOUND_EXPR, TREE_TYPE (spec.expr),
9356 specs->expr, spec.expr);
9358 specs->expr = spec.expr;
9359 specs->expr_const_operands &= spec.expr_const_operands;
9368 /* Add the storage class specifier or function specifier SCSPEC to the
9369 declaration specifiers SPECS, returning SPECS. */
9371 struct c_declspecs *
9372 declspecs_add_scspec (struct c_declspecs *specs, tree scspec)
9375 enum c_storage_class n = csc_none;
9377 specs->declspecs_seen_p = true;
9378 gcc_assert (TREE_CODE (scspec) == IDENTIFIER_NODE
9379 && C_IS_RESERVED_WORD (scspec));
9380 i = C_RID_CODE (scspec);
9381 if (specs->non_sc_seen_p)
9382 warning (OPT_Wold_style_declaration,
9383 "%qE is not at beginning of declaration", scspec);
9387 /* C99 permits duplicate inline. Although of doubtful utility,
9388 it seems simplest to permit it in gnu89 mode as well, as
9389 there is also little utility in maintaining this as a
9390 difference between gnu89 and C99 inline. */
9392 specs->inline_p = true;
9395 dupe = specs->thread_p;
9396 if (specs->storage_class == csc_auto)
9397 error ("%<__thread%> used with %<auto%>");
9398 else if (specs->storage_class == csc_register)
9399 error ("%<__thread%> used with %<register%>");
9400 else if (specs->storage_class == csc_typedef)
9401 error ("%<__thread%> used with %<typedef%>");
9403 specs->thread_p = true;
9410 /* Diagnose "__thread extern". */
9411 if (specs->thread_p)
9412 error ("%<__thread%> before %<extern%>");
9419 /* Diagnose "__thread static". */
9420 if (specs->thread_p)
9421 error ("%<__thread%> before %<static%>");
9429 if (n != csc_none && n == specs->storage_class)
9432 error ("duplicate %qE", scspec);
9435 if (specs->storage_class != csc_none && n != specs->storage_class)
9437 error ("multiple storage classes in declaration specifiers");
9441 specs->storage_class = n;
9442 if (n != csc_extern && n != csc_static && specs->thread_p)
9444 error ("%<__thread%> used with %qE", scspec);
9445 specs->thread_p = false;
9452 /* Add the attributes ATTRS to the declaration specifiers SPECS,
9455 struct c_declspecs *
9456 declspecs_add_attrs (struct c_declspecs *specs, tree attrs)
9458 specs->attrs = chainon (attrs, specs->attrs);
9459 specs->declspecs_seen_p = true;
9463 /* Combine "long", "short", "signed", "unsigned" and "_Complex" type
9464 specifiers with any other type specifier to determine the resulting
9465 type. This is where ISO C checks on complex types are made, since
9466 "_Complex long" is a prefix of the valid ISO C type "_Complex long
9469 struct c_declspecs *
9470 finish_declspecs (struct c_declspecs *specs)
9472 /* If a type was specified as a whole, we have no modifiers and are
9474 if (specs->type != NULL_TREE)
9476 gcc_assert (!specs->long_p && !specs->long_long_p && !specs->short_p
9477 && !specs->signed_p && !specs->unsigned_p
9478 && !specs->complex_p);
9480 /* Set a dummy type. */
9481 if (TREE_CODE (specs->type) == ERROR_MARK)
9482 specs->type = integer_type_node;
9486 /* If none of "void", "_Bool", "char", "int", "float" or "double"
9487 has been specified, treat it as "int" unless "_Complex" is
9488 present and there are no other specifiers. If we just have
9489 "_Complex", it is equivalent to "_Complex double", but e.g.
9490 "_Complex short" is equivalent to "_Complex short int". */
9491 if (specs->typespec_word == cts_none)
9493 if (specs->saturating_p)
9495 error ("%<_Sat%> is used without %<_Fract%> or %<_Accum%>");
9496 if (!targetm.fixed_point_supported_p ())
9497 error ("fixed-point types not supported for this target");
9498 specs->typespec_word = cts_fract;
9500 else if (specs->long_p || specs->short_p
9501 || specs->signed_p || specs->unsigned_p)
9503 specs->typespec_word = cts_int;
9505 else if (specs->complex_p)
9507 specs->typespec_word = cts_double;
9508 pedwarn (input_location, OPT_pedantic,
9509 "ISO C does not support plain %<complex%> meaning "
9510 "%<double complex%>");
9514 specs->typespec_word = cts_int;
9515 specs->default_int_p = true;
9516 /* We don't diagnose this here because grokdeclarator will
9517 give more specific diagnostics according to whether it is
9518 a function definition. */
9522 /* If "signed" was specified, record this to distinguish "int" and
9523 "signed int" in the case of a bit-field with
9524 -funsigned-bitfields. */
9525 specs->explicit_signed_p = specs->signed_p;
9527 /* Now compute the actual type. */
9528 switch (specs->typespec_word)
9531 gcc_assert (!specs->long_p && !specs->short_p
9532 && !specs->signed_p && !specs->unsigned_p
9533 && !specs->complex_p);
9534 specs->type = void_type_node;
9537 gcc_assert (!specs->long_p && !specs->short_p
9538 && !specs->signed_p && !specs->unsigned_p
9539 && !specs->complex_p);
9540 specs->type = boolean_type_node;
9543 gcc_assert (!specs->long_p && !specs->short_p);
9544 gcc_assert (!(specs->signed_p && specs->unsigned_p));
9545 if (specs->signed_p)
9546 specs->type = signed_char_type_node;
9547 else if (specs->unsigned_p)
9548 specs->type = unsigned_char_type_node;
9550 specs->type = char_type_node;
9551 if (specs->complex_p)
9553 pedwarn (input_location, OPT_pedantic,
9554 "ISO C does not support complex integer types");
9555 specs->type = build_complex_type (specs->type);
9559 gcc_assert (!specs->long_p && !specs->short_p && !specs->long_long_p);
9560 gcc_assert (!(specs->signed_p && specs->unsigned_p));
9561 specs->type = (specs->unsigned_p
9562 ? int128_unsigned_type_node
9563 : int128_integer_type_node);
9564 if (specs->complex_p)
9566 pedwarn (input_location, OPT_pedantic,
9567 "ISO C does not support complex integer types");
9568 specs->type = build_complex_type (specs->type);
9572 gcc_assert (!(specs->long_p && specs->short_p));
9573 gcc_assert (!(specs->signed_p && specs->unsigned_p));
9574 if (specs->long_long_p)
9575 specs->type = (specs->unsigned_p
9576 ? long_long_unsigned_type_node
9577 : long_long_integer_type_node);
9578 else if (specs->long_p)
9579 specs->type = (specs->unsigned_p
9580 ? long_unsigned_type_node
9581 : long_integer_type_node);
9582 else if (specs->short_p)
9583 specs->type = (specs->unsigned_p
9584 ? short_unsigned_type_node
9585 : short_integer_type_node);
9587 specs->type = (specs->unsigned_p
9588 ? unsigned_type_node
9589 : integer_type_node);
9590 if (specs->complex_p)
9592 pedwarn (input_location, OPT_pedantic,
9593 "ISO C does not support complex integer types");
9594 specs->type = build_complex_type (specs->type);
9598 gcc_assert (!specs->long_p && !specs->short_p
9599 && !specs->signed_p && !specs->unsigned_p);
9600 specs->type = (specs->complex_p
9601 ? complex_float_type_node
9605 gcc_assert (!specs->long_long_p && !specs->short_p
9606 && !specs->signed_p && !specs->unsigned_p);
9609 specs->type = (specs->complex_p
9610 ? complex_long_double_type_node
9611 : long_double_type_node);
9615 specs->type = (specs->complex_p
9616 ? complex_double_type_node
9617 : double_type_node);
9623 gcc_assert (!specs->long_p && !specs->long_long_p && !specs->short_p
9624 && !specs->signed_p && !specs->unsigned_p && !specs->complex_p);
9625 if (specs->typespec_word == cts_dfloat32)
9626 specs->type = dfloat32_type_node;
9627 else if (specs->typespec_word == cts_dfloat64)
9628 specs->type = dfloat64_type_node;
9630 specs->type = dfloat128_type_node;
9633 gcc_assert (!specs->complex_p);
9634 if (!targetm.fixed_point_supported_p ())
9635 specs->type = integer_type_node;
9636 else if (specs->saturating_p)
9638 if (specs->long_long_p)
9639 specs->type = specs->unsigned_p
9640 ? sat_unsigned_long_long_fract_type_node
9641 : sat_long_long_fract_type_node;
9642 else if (specs->long_p)
9643 specs->type = specs->unsigned_p
9644 ? sat_unsigned_long_fract_type_node
9645 : sat_long_fract_type_node;
9646 else if (specs->short_p)
9647 specs->type = specs->unsigned_p
9648 ? sat_unsigned_short_fract_type_node
9649 : sat_short_fract_type_node;
9651 specs->type = specs->unsigned_p
9652 ? sat_unsigned_fract_type_node
9653 : sat_fract_type_node;
9657 if (specs->long_long_p)
9658 specs->type = specs->unsigned_p
9659 ? unsigned_long_long_fract_type_node
9660 : long_long_fract_type_node;
9661 else if (specs->long_p)
9662 specs->type = specs->unsigned_p
9663 ? unsigned_long_fract_type_node
9664 : long_fract_type_node;
9665 else if (specs->short_p)
9666 specs->type = specs->unsigned_p
9667 ? unsigned_short_fract_type_node
9668 : short_fract_type_node;
9670 specs->type = specs->unsigned_p
9671 ? unsigned_fract_type_node
9676 gcc_assert (!specs->complex_p);
9677 if (!targetm.fixed_point_supported_p ())
9678 specs->type = integer_type_node;
9679 else if (specs->saturating_p)
9681 if (specs->long_long_p)
9682 specs->type = specs->unsigned_p
9683 ? sat_unsigned_long_long_accum_type_node
9684 : sat_long_long_accum_type_node;
9685 else if (specs->long_p)
9686 specs->type = specs->unsigned_p
9687 ? sat_unsigned_long_accum_type_node
9688 : sat_long_accum_type_node;
9689 else if (specs->short_p)
9690 specs->type = specs->unsigned_p
9691 ? sat_unsigned_short_accum_type_node
9692 : sat_short_accum_type_node;
9694 specs->type = specs->unsigned_p
9695 ? sat_unsigned_accum_type_node
9696 : sat_accum_type_node;
9700 if (specs->long_long_p)
9701 specs->type = specs->unsigned_p
9702 ? unsigned_long_long_accum_type_node
9703 : long_long_accum_type_node;
9704 else if (specs->long_p)
9705 specs->type = specs->unsigned_p
9706 ? unsigned_long_accum_type_node
9707 : long_accum_type_node;
9708 else if (specs->short_p)
9709 specs->type = specs->unsigned_p
9710 ? unsigned_short_accum_type_node
9711 : short_accum_type_node;
9713 specs->type = specs->unsigned_p
9714 ? unsigned_accum_type_node
9725 /* A subroutine of c_write_global_declarations. Perform final processing
9726 on one file scope's declarations (or the external scope's declarations),
9730 c_write_global_declarations_1 (tree globals)
9735 /* Process the decls in the order they were written. */
9736 for (decl = globals; decl; decl = DECL_CHAIN (decl))
9738 /* Check for used but undefined static functions using the C
9739 standard's definition of "used", and set TREE_NO_WARNING so
9740 that check_global_declarations doesn't repeat the check. */
9741 if (TREE_CODE (decl) == FUNCTION_DECL
9742 && DECL_INITIAL (decl) == 0
9743 && DECL_EXTERNAL (decl)
9744 && !TREE_PUBLIC (decl)
9745 && C_DECL_USED (decl))
9747 pedwarn (input_location, 0, "%q+F used but never defined", decl);
9748 TREE_NO_WARNING (decl) = 1;
9751 wrapup_global_declaration_1 (decl);
9757 for (decl = globals; decl; decl = DECL_CHAIN (decl))
9758 reconsider |= wrapup_global_declaration_2 (decl);
9762 for (decl = globals; decl; decl = DECL_CHAIN (decl))
9763 check_global_declaration_1 (decl);
9766 /* A subroutine of c_write_global_declarations Emit debug information for each
9767 of the declarations in GLOBALS. */
9770 c_write_global_declarations_2 (tree globals)
9774 for (decl = globals; decl ; decl = DECL_CHAIN (decl))
9775 debug_hooks->global_decl (decl);
9778 /* Callback to collect a source_ref from a DECL. */
9781 collect_source_ref_cb (tree decl)
9783 if (!DECL_IS_BUILTIN (decl))
9784 collect_source_ref (LOCATION_FILE (decl_sloc (decl, false)));
9787 /* Preserve the external declarations scope across a garbage collect. */
9788 static GTY(()) tree ext_block;
9790 /* Collect all references relevant to SOURCE_FILE. */
9793 collect_all_refs (const char *source_file)
9798 FOR_EACH_VEC_ELT (tree, all_translation_units, i, t)
9799 collect_ada_nodes (BLOCK_VARS (DECL_INITIAL (t)), source_file);
9801 collect_ada_nodes (BLOCK_VARS (ext_block), source_file);
9804 /* Iterate over all global declarations and call CALLBACK. */
9807 for_each_global_decl (void (*callback) (tree decl))
9814 FOR_EACH_VEC_ELT (tree, all_translation_units, i, t)
9816 decls = DECL_INITIAL (t);
9817 for (decl = BLOCK_VARS (decls); decl; decl = TREE_CHAIN (decl))
9821 for (decl = BLOCK_VARS (ext_block); decl; decl = TREE_CHAIN (decl))
9826 c_write_global_declarations (void)
9831 /* We don't want to do this if generating a PCH. */
9835 /* Do the Objective-C stuff. This is where all the Objective-C
9836 module stuff gets generated (symtab, class/protocol/selector
9838 if (c_dialect_objc ())
9839 objc_write_global_declarations ();
9841 /* Close the external scope. */
9842 ext_block = pop_scope ();
9844 gcc_assert (!current_scope);
9846 /* Handle -fdump-ada-spec[-slim]. */
9847 if (dump_enabled_p (TDI_ada))
9849 /* Build a table of files to generate specs for */
9850 if (get_dump_file_info (TDI_ada)->flags & TDF_SLIM)
9851 collect_source_ref (main_input_filename);
9853 for_each_global_decl (collect_source_ref_cb);
9855 dump_ada_specs (collect_all_refs, NULL);
9860 tree tmp = BLOCK_VARS (ext_block);
9862 FILE * stream = dump_begin (TDI_tu, &flags);
9865 dump_node (tmp, flags & ~TDF_SLIM, stream);
9866 dump_end (TDI_tu, stream);
9870 /* Process all file scopes in this compilation, and the external_scope,
9871 through wrapup_global_declarations and check_global_declarations. */
9872 FOR_EACH_VEC_ELT (tree, all_translation_units, i, t)
9873 c_write_global_declarations_1 (BLOCK_VARS (DECL_INITIAL (t)));
9874 c_write_global_declarations_1 (BLOCK_VARS (ext_block));
9876 /* We're done parsing; proceed to optimize and emit assembly.
9877 FIXME: shouldn't be the front end's responsibility to call this. */
9878 cgraph_finalize_compilation_unit ();
9880 /* After cgraph has had a chance to emit everything that's going to
9881 be emitted, output debug information for globals. */
9884 timevar_push (TV_SYMOUT);
9885 FOR_EACH_VEC_ELT (tree, all_translation_units, i, t)
9886 c_write_global_declarations_2 (BLOCK_VARS (DECL_INITIAL (t)));
9887 c_write_global_declarations_2 (BLOCK_VARS (ext_block));
9888 timevar_pop (TV_SYMOUT);
9894 /* Register reserved keyword WORD as qualifier for address space AS. */
9897 c_register_addr_space (const char *word, addr_space_t as)
9899 int rid = RID_FIRST_ADDR_SPACE + as;
9902 /* Address space qualifiers are only supported
9903 in C with GNU extensions enabled. */
9904 if (c_dialect_objc () || flag_no_asm)
9907 id = get_identifier (word);
9908 C_SET_RID_CODE (id, rid);
9909 C_IS_RESERVED_WORD (id) = 1;
9910 ridpointers [rid] = id;
9913 #include "gt-c-decl.h"