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 switch (TREE_CODE (olddecl))
2449 memcpy ((char *) olddecl + sizeof (struct tree_decl_common),
2450 (char *) newdecl + sizeof (struct tree_decl_common),
2451 tree_code_size (TREE_CODE (olddecl)) - sizeof (struct tree_decl_common));
2456 memcpy ((char *) olddecl + sizeof (struct tree_decl_common),
2457 (char *) newdecl + sizeof (struct tree_decl_common),
2458 sizeof (struct tree_decl_non_common) - sizeof (struct tree_decl_common));
2460 DECL_UID (olddecl) = olddecl_uid;
2461 DECL_CONTEXT (olddecl) = olddecl_context;
2462 if (TREE_CODE (olddecl) == FUNCTION_DECL)
2463 DECL_ARGUMENTS (olddecl) = olddecl_arguments;
2466 /* If OLDDECL had its DECL_RTL instantiated, re-invoke make_decl_rtl
2467 so that encode_section_info has a chance to look at the new decl
2468 flags and attributes. */
2469 if (DECL_RTL_SET_P (olddecl)
2470 && (TREE_CODE (olddecl) == FUNCTION_DECL
2471 || (TREE_CODE (olddecl) == VAR_DECL
2472 && TREE_STATIC (olddecl))))
2473 make_decl_rtl (olddecl);
2475 /* If we changed a function from DECL_EXTERNAL to !DECL_EXTERNAL,
2476 and the definition is coming from the old version, cgraph needs
2477 to be called again. */
2478 if (extern_changed && !new_is_definition
2479 && TREE_CODE (olddecl) == FUNCTION_DECL && DECL_INITIAL (olddecl))
2480 cgraph_mark_if_needed (olddecl);
2483 /* Handle when a new declaration NEWDECL has the same name as an old
2484 one OLDDECL in the same binding contour. Prints an error message
2487 If safely possible, alter OLDDECL to look like NEWDECL, and return
2488 true. Otherwise, return false. */
2491 duplicate_decls (tree newdecl, tree olddecl)
2493 tree newtype = NULL, oldtype = NULL;
2495 if (!diagnose_mismatched_decls (newdecl, olddecl, &newtype, &oldtype))
2497 /* Avoid `unused variable' and other warnings for OLDDECL. */
2498 TREE_NO_WARNING (olddecl) = 1;
2502 merge_decls (newdecl, olddecl, newtype, oldtype);
2507 /* Check whether decl-node NEW_DECL shadows an existing declaration. */
2509 warn_if_shadowing (tree new_decl)
2511 struct c_binding *b;
2513 /* Shadow warnings wanted? */
2515 /* No shadow warnings for internally generated vars. */
2516 || DECL_IS_BUILTIN (new_decl)
2517 /* No shadow warnings for vars made for inlining. */
2518 || DECL_FROM_INLINE (new_decl))
2521 /* Is anything being shadowed? Invisible decls do not count. */
2522 for (b = I_SYMBOL_BINDING (DECL_NAME (new_decl)); b; b = b->shadowed)
2523 if (b->decl && b->decl != new_decl && !b->invisible)
2525 tree old_decl = b->decl;
2527 if (old_decl == error_mark_node)
2529 warning (OPT_Wshadow, "declaration of %q+D shadows previous "
2530 "non-variable", new_decl);
2533 else if (TREE_CODE (old_decl) == PARM_DECL)
2534 warning (OPT_Wshadow, "declaration of %q+D shadows a parameter",
2536 else if (DECL_FILE_SCOPE_P (old_decl))
2537 warning (OPT_Wshadow, "declaration of %q+D shadows a global "
2538 "declaration", new_decl);
2539 else if (TREE_CODE (old_decl) == FUNCTION_DECL
2540 && DECL_BUILT_IN (old_decl))
2542 warning (OPT_Wshadow, "declaration of %q+D shadows "
2543 "a built-in function", new_decl);
2547 warning (OPT_Wshadow, "declaration of %q+D shadows a previous local",
2550 warning_at (DECL_SOURCE_LOCATION (old_decl), OPT_Wshadow,
2551 "shadowed declaration is here");
2557 /* Record a decl-node X as belonging to the current lexical scope.
2558 Check for errors (such as an incompatible declaration for the same
2559 name already seen in the same scope).
2561 Returns either X or an old decl for the same name.
2562 If an old decl is returned, it may have been smashed
2563 to agree with what X says. */
2568 tree name = DECL_NAME (x);
2569 struct c_scope *scope = current_scope;
2570 struct c_binding *b;
2571 bool nested = false;
2572 location_t locus = DECL_SOURCE_LOCATION (x);
2574 /* Must set DECL_CONTEXT for everything not at file scope or
2575 DECL_FILE_SCOPE_P won't work. Local externs don't count
2576 unless they have initializers (which generate code). */
2577 if (current_function_decl
2578 && ((TREE_CODE (x) != FUNCTION_DECL && TREE_CODE (x) != VAR_DECL)
2579 || DECL_INITIAL (x) || !DECL_EXTERNAL (x)))
2580 DECL_CONTEXT (x) = current_function_decl;
2582 /* Anonymous decls are just inserted in the scope. */
2585 bind (name, x, scope, /*invisible=*/false, /*nested=*/false,
2590 /* First, see if there is another declaration with the same name in
2591 the current scope. If there is, duplicate_decls may do all the
2592 work for us. If duplicate_decls returns false, that indicates
2593 two incompatible decls in the same scope; we are to silently
2594 replace the old one (duplicate_decls has issued all appropriate
2595 diagnostics). In particular, we should not consider possible
2596 duplicates in the external scope, or shadowing. */
2597 b = I_SYMBOL_BINDING (name);
2598 if (b && B_IN_SCOPE (b, scope))
2600 struct c_binding *b_ext, *b_use;
2601 tree type = TREE_TYPE (x);
2602 tree visdecl = b->decl;
2603 tree vistype = TREE_TYPE (visdecl);
2604 if (TREE_CODE (TREE_TYPE (x)) == ARRAY_TYPE
2605 && COMPLETE_TYPE_P (TREE_TYPE (x)))
2606 b->inner_comp = false;
2609 /* If this is an external linkage declaration, we should check
2610 for compatibility with the type in the external scope before
2611 setting the type at this scope based on the visible
2612 information only. */
2613 if (TREE_PUBLIC (x) && TREE_PUBLIC (visdecl))
2615 while (b_ext && !B_IN_EXTERNAL_SCOPE (b_ext))
2616 b_ext = b_ext->shadowed;
2621 TREE_TYPE (b_use->decl) = b_use->u.type;
2624 if (duplicate_decls (x, b_use->decl))
2628 /* Save the updated type in the external scope and
2629 restore the proper type for this scope. */
2631 if (comptypes (vistype, type))
2632 thistype = composite_type (vistype, type);
2634 thistype = TREE_TYPE (b_use->decl);
2635 b_use->u.type = TREE_TYPE (b_use->decl);
2636 if (TREE_CODE (b_use->decl) == FUNCTION_DECL
2637 && DECL_BUILT_IN (b_use->decl))
2639 = build_type_attribute_variant (thistype,
2642 TREE_TYPE (b_use->decl) = thistype;
2647 goto skip_external_and_shadow_checks;
2650 /* All declarations with external linkage, and all external
2651 references, go in the external scope, no matter what scope is
2652 current. However, the binding in that scope is ignored for
2653 purposes of normal name lookup. A separate binding structure is
2654 created in the requested scope; this governs the normal
2655 visibility of the symbol.
2657 The binding in the externals scope is used exclusively for
2658 detecting duplicate declarations of the same object, no matter
2659 what scope they are in; this is what we do here. (C99 6.2.7p2:
2660 All declarations that refer to the same object or function shall
2661 have compatible type; otherwise, the behavior is undefined.) */
2662 if (DECL_EXTERNAL (x) || scope == file_scope)
2664 tree type = TREE_TYPE (x);
2667 bool type_saved = false;
2668 if (b && !B_IN_EXTERNAL_SCOPE (b)
2669 && (TREE_CODE (b->decl) == FUNCTION_DECL
2670 || TREE_CODE (b->decl) == VAR_DECL)
2671 && DECL_FILE_SCOPE_P (b->decl))
2674 vistype = TREE_TYPE (visdecl);
2676 if (scope != file_scope
2677 && !DECL_IN_SYSTEM_HEADER (x))
2678 warning (OPT_Wnested_externs, "nested extern declaration of %qD", x);
2680 while (b && !B_IN_EXTERNAL_SCOPE (b))
2682 /* If this decl might be modified, save its type. This is
2683 done here rather than when the decl is first bound
2684 because the type may change after first binding, through
2685 being completed or through attributes being added. If we
2686 encounter multiple such decls, only the first should have
2687 its type saved; the others will already have had their
2688 proper types saved and the types will not have changed as
2689 their scopes will not have been re-entered. */
2690 if (DECL_P (b->decl) && DECL_FILE_SCOPE_P (b->decl) && !type_saved)
2692 b->u.type = TREE_TYPE (b->decl);
2695 if (B_IN_FILE_SCOPE (b)
2696 && TREE_CODE (b->decl) == VAR_DECL
2697 && TREE_STATIC (b->decl)
2698 && TREE_CODE (TREE_TYPE (b->decl)) == ARRAY_TYPE
2699 && !TYPE_DOMAIN (TREE_TYPE (b->decl))
2700 && TREE_CODE (type) == ARRAY_TYPE
2701 && TYPE_DOMAIN (type)
2702 && TYPE_MAX_VALUE (TYPE_DOMAIN (type))
2703 && !integer_zerop (TYPE_MAX_VALUE (TYPE_DOMAIN (type))))
2705 /* Array type completed in inner scope, which should be
2706 diagnosed if the completion does not have size 1 and
2707 it does not get completed in the file scope. */
2708 b->inner_comp = true;
2713 /* If a matching external declaration has been found, set its
2714 type to the composite of all the types of that declaration.
2715 After the consistency checks, it will be reset to the
2716 composite of the visible types only. */
2717 if (b && (TREE_PUBLIC (x) || same_translation_unit_p (x, b->decl))
2719 TREE_TYPE (b->decl) = b->u.type;
2721 /* The point of the same_translation_unit_p check here is,
2722 we want to detect a duplicate decl for a construct like
2723 foo() { extern bar(); } ... static bar(); but not if
2724 they are in different translation units. In any case,
2725 the static does not go in the externals scope. */
2727 && (TREE_PUBLIC (x) || same_translation_unit_p (x, b->decl))
2728 && duplicate_decls (x, b->decl))
2733 if (comptypes (vistype, type))
2734 thistype = composite_type (vistype, type);
2736 thistype = TREE_TYPE (b->decl);
2740 b->u.type = TREE_TYPE (b->decl);
2741 if (TREE_CODE (b->decl) == FUNCTION_DECL && DECL_BUILT_IN (b->decl))
2743 = build_type_attribute_variant (thistype,
2744 TYPE_ATTRIBUTES (b->u.type));
2745 TREE_TYPE (b->decl) = thistype;
2746 bind (name, b->decl, scope, /*invisible=*/false, /*nested=*/true,
2750 else if (TREE_PUBLIC (x))
2752 if (visdecl && !b && duplicate_decls (x, visdecl))
2754 /* An external declaration at block scope referring to a
2755 visible entity with internal linkage. The composite
2756 type will already be correct for this scope, so we
2757 just need to fall through to make the declaration in
2764 bind (name, x, external_scope, /*invisible=*/true,
2765 /*nested=*/false, locus);
2771 if (TREE_CODE (x) != PARM_DECL)
2772 warn_if_shadowing (x);
2774 skip_external_and_shadow_checks:
2775 if (TREE_CODE (x) == TYPE_DECL)
2776 set_underlying_type (x);
2778 bind (name, x, scope, /*invisible=*/false, nested, locus);
2780 /* If x's type is incomplete because it's based on a
2781 structure or union which has not yet been fully declared,
2782 attach it to that structure or union type, so we can go
2783 back and complete the variable declaration later, if the
2784 structure or union gets fully declared.
2786 If the input is erroneous, we can have error_mark in the type
2787 slot (e.g. "f(void a, ...)") - that doesn't count as an
2789 if (TREE_TYPE (x) != error_mark_node
2790 && !COMPLETE_TYPE_P (TREE_TYPE (x)))
2792 tree element = TREE_TYPE (x);
2794 while (TREE_CODE (element) == ARRAY_TYPE)
2795 element = TREE_TYPE (element);
2796 element = TYPE_MAIN_VARIANT (element);
2798 if ((TREE_CODE (element) == RECORD_TYPE
2799 || TREE_CODE (element) == UNION_TYPE)
2800 && (TREE_CODE (x) != TYPE_DECL
2801 || TREE_CODE (TREE_TYPE (x)) == ARRAY_TYPE)
2802 && !COMPLETE_TYPE_P (element))
2803 C_TYPE_INCOMPLETE_VARS (element)
2804 = tree_cons (NULL_TREE, x, C_TYPE_INCOMPLETE_VARS (element));
2809 /* Record X as belonging to file scope.
2810 This is used only internally by the Objective-C front end,
2811 and is limited to its needs. duplicate_decls is not called;
2812 if there is any preexisting decl for this identifier, it is an ICE. */
2815 pushdecl_top_level (tree x)
2818 bool nested = false;
2819 gcc_assert (TREE_CODE (x) == VAR_DECL || TREE_CODE (x) == CONST_DECL);
2821 name = DECL_NAME (x);
2823 gcc_assert (TREE_CODE (x) == CONST_DECL || !I_SYMBOL_BINDING (name));
2825 if (TREE_PUBLIC (x))
2827 bind (name, x, external_scope, /*invisible=*/true, /*nested=*/false,
2832 bind (name, x, file_scope, /*invisible=*/false, nested, UNKNOWN_LOCATION);
2838 implicit_decl_warning (tree id, tree olddecl)
2840 if (warn_implicit_function_declaration)
2845 warned = pedwarn (input_location, OPT_Wimplicit_function_declaration,
2846 "implicit declaration of function %qE", id);
2848 warned = warning (OPT_Wimplicit_function_declaration,
2849 G_("implicit declaration of function %qE"), id);
2850 if (olddecl && warned)
2851 locate_old_decl (olddecl);
2855 /* Generate an implicit declaration for identifier FUNCTIONID at LOC as a
2856 function of type int (). */
2859 implicitly_declare (location_t loc, tree functionid)
2861 struct c_binding *b;
2865 for (b = I_SYMBOL_BINDING (functionid); b; b = b->shadowed)
2867 if (B_IN_SCOPE (b, external_scope))
2876 if (decl == error_mark_node)
2879 /* FIXME: Objective-C has weird not-really-builtin functions
2880 which are supposed to be visible automatically. They wind up
2881 in the external scope because they're pushed before the file
2882 scope gets created. Catch this here and rebind them into the
2884 if (!DECL_BUILT_IN (decl) && DECL_IS_BUILTIN (decl))
2886 bind (functionid, decl, file_scope,
2887 /*invisible=*/false, /*nested=*/true,
2888 DECL_SOURCE_LOCATION (decl));
2893 tree newtype = default_function_type;
2895 TREE_TYPE (decl) = b->u.type;
2896 /* Implicit declaration of a function already declared
2897 (somehow) in a different scope, or as a built-in.
2898 If this is the first time this has happened, warn;
2899 then recycle the old declaration but with the new type. */
2900 if (!C_DECL_IMPLICIT (decl))
2902 implicit_decl_warning (functionid, decl);
2903 C_DECL_IMPLICIT (decl) = 1;
2905 if (DECL_BUILT_IN (decl))
2907 newtype = build_type_attribute_variant (newtype,
2909 (TREE_TYPE (decl)));
2910 if (!comptypes (newtype, TREE_TYPE (decl)))
2912 warning_at (loc, 0, "incompatible implicit declaration of "
2913 "built-in function %qD", decl);
2914 newtype = TREE_TYPE (decl);
2919 if (!comptypes (newtype, TREE_TYPE (decl)))
2921 error_at (loc, "incompatible implicit declaration of function %qD", decl);
2922 locate_old_decl (decl);
2925 b->u.type = TREE_TYPE (decl);
2926 TREE_TYPE (decl) = newtype;
2927 bind (functionid, decl, current_scope,
2928 /*invisible=*/false, /*nested=*/true,
2929 DECL_SOURCE_LOCATION (decl));
2934 /* Not seen before. */
2935 decl = build_decl (loc, FUNCTION_DECL, functionid, default_function_type);
2936 DECL_EXTERNAL (decl) = 1;
2937 TREE_PUBLIC (decl) = 1;
2938 C_DECL_IMPLICIT (decl) = 1;
2939 implicit_decl_warning (functionid, 0);
2940 asmspec_tree = maybe_apply_renaming_pragma (decl, /*asmname=*/NULL);
2942 set_user_assembler_name (decl, TREE_STRING_POINTER (asmspec_tree));
2944 /* C89 says implicit declarations are in the innermost block.
2945 So we record the decl in the standard fashion. */
2946 decl = pushdecl (decl);
2948 /* No need to call objc_check_decl here - it's a function type. */
2949 rest_of_decl_compilation (decl, 0, 0);
2951 /* Write a record describing this implicit function declaration
2952 to the prototypes file (if requested). */
2953 gen_aux_info_record (decl, 0, 1, 0);
2955 /* Possibly apply some default attributes to this implicit declaration. */
2956 decl_attributes (&decl, NULL_TREE, 0);
2961 /* Issue an error message for a reference to an undeclared variable
2962 ID, including a reference to a builtin outside of function-call
2963 context. Establish a binding of the identifier to error_mark_node
2964 in an appropriate scope, which will suppress further errors for the
2965 same identifier. The error message should be given location LOC. */
2967 undeclared_variable (location_t loc, tree id)
2969 static bool already = false;
2970 struct c_scope *scope;
2972 if (current_function_decl == 0)
2974 error_at (loc, "%qE undeclared here (not in a function)", id);
2975 scope = current_scope;
2979 if (!objc_diagnose_private_ivar (id))
2980 error_at (loc, "%qE undeclared (first use in this function)", id);
2983 inform (loc, "each undeclared identifier is reported only"
2984 " once for each function it appears in");
2988 /* If we are parsing old-style parameter decls, current_function_decl
2989 will be nonnull but current_function_scope will be null. */
2990 scope = current_function_scope ? current_function_scope : current_scope;
2992 bind (id, error_mark_node, scope, /*invisible=*/false, /*nested=*/false,
2996 /* Subroutine of lookup_label, declare_label, define_label: construct a
2997 LABEL_DECL with all the proper frills. Also create a struct
2998 c_label_vars initialized for the current scope. */
3001 make_label (location_t location, tree name, bool defining,
3002 struct c_label_vars **p_label_vars)
3004 tree label = build_decl (location, LABEL_DECL, name, void_type_node);
3005 struct c_label_vars *label_vars;
3007 DECL_CONTEXT (label) = current_function_decl;
3008 DECL_MODE (label) = VOIDmode;
3010 label_vars = ggc_alloc_c_label_vars ();
3011 label_vars->shadowed = NULL;
3012 set_spot_bindings (&label_vars->label_bindings, defining);
3013 label_vars->decls_in_scope = make_tree_vector ();
3014 label_vars->gotos = VEC_alloc (c_goto_bindings_p, gc, 0);
3015 *p_label_vars = label_vars;
3020 /* Get the LABEL_DECL corresponding to identifier NAME as a label.
3021 Create one if none exists so far for the current function.
3022 This is called when a label is used in a goto expression or
3023 has its address taken. */
3026 lookup_label (tree name)
3029 struct c_label_vars *label_vars;
3031 if (current_function_scope == 0)
3033 error ("label %qE referenced outside of any function", name);
3037 /* Use a label already defined or ref'd with this name, but not if
3038 it is inherited from a containing function and wasn't declared
3040 label = I_LABEL_DECL (name);
3041 if (label && (DECL_CONTEXT (label) == current_function_decl
3042 || C_DECLARED_LABEL_FLAG (label)))
3044 /* If the label has only been declared, update its apparent
3045 location to point here, for better diagnostics if it
3046 turns out not to have been defined. */
3047 if (DECL_INITIAL (label) == NULL_TREE)
3048 DECL_SOURCE_LOCATION (label) = input_location;
3052 /* No label binding for that identifier; make one. */
3053 label = make_label (input_location, name, false, &label_vars);
3055 /* Ordinary labels go in the current function scope. */
3056 bind_label (name, label, current_function_scope, label_vars);
3061 /* Issue a warning about DECL for a goto statement at GOTO_LOC going
3065 warn_about_goto (location_t goto_loc, tree label, tree decl)
3067 if (variably_modified_type_p (TREE_TYPE (decl), NULL_TREE))
3069 "jump into scope of identifier with variably modified type");
3071 warning_at (goto_loc, OPT_Wjump_misses_init,
3072 "jump skips variable initialization");
3073 inform (DECL_SOURCE_LOCATION (label), "label %qD defined here", label);
3074 inform (DECL_SOURCE_LOCATION (decl), "%qD declared here", decl);
3077 /* Look up a label because of a goto statement. This is like
3078 lookup_label, but also issues any appropriate warnings. */
3081 lookup_label_for_goto (location_t loc, tree name)
3084 struct c_label_vars *label_vars;
3088 label = lookup_label (name);
3089 if (label == NULL_TREE)
3092 /* If we are jumping to a different function, we can't issue any
3094 if (DECL_CONTEXT (label) != current_function_decl)
3096 gcc_assert (C_DECLARED_LABEL_FLAG (label));
3100 label_vars = I_LABEL_BINDING (name)->u.label;
3102 /* If the label has not yet been defined, then push this goto on a
3103 list for possible later warnings. */
3104 if (label_vars->label_bindings.scope == NULL)
3106 struct c_goto_bindings *g;
3108 g = ggc_alloc_c_goto_bindings ();
3110 set_spot_bindings (&g->goto_bindings, true);
3111 VEC_safe_push (c_goto_bindings_p, gc, label_vars->gotos, g);
3115 /* If there are any decls in label_vars->decls_in_scope, then this
3116 goto has missed the declaration of the decl. This happens for a
3122 Issue a warning or error. */
3123 FOR_EACH_VEC_ELT (tree, label_vars->decls_in_scope, ix, decl)
3124 warn_about_goto (loc, label, decl);
3126 if (label_vars->label_bindings.left_stmt_expr)
3128 error_at (loc, "jump into statement expression");
3129 inform (DECL_SOURCE_LOCATION (label), "label %qD defined here", label);
3135 /* Make a label named NAME in the current function, shadowing silently
3136 any that may be inherited from containing functions or containing
3137 scopes. This is called for __label__ declarations. */
3140 declare_label (tree name)
3142 struct c_binding *b = I_LABEL_BINDING (name);
3144 struct c_label_vars *label_vars;
3146 /* Check to make sure that the label hasn't already been declared
3148 if (b && B_IN_CURRENT_SCOPE (b))
3150 error ("duplicate label declaration %qE", name);
3151 locate_old_decl (b->decl);
3153 /* Just use the previous declaration. */
3157 label = make_label (input_location, name, false, &label_vars);
3158 C_DECLARED_LABEL_FLAG (label) = 1;
3160 /* Declared labels go in the current scope. */
3161 bind_label (name, label, current_scope, label_vars);
3166 /* When we define a label, issue any appropriate warnings if there are
3167 any gotos earlier in the function which jump to this label. */
3170 check_earlier_gotos (tree label, struct c_label_vars* label_vars)
3173 struct c_goto_bindings *g;
3175 FOR_EACH_VEC_ELT (c_goto_bindings_p, label_vars->gotos, ix, g)
3177 struct c_binding *b;
3178 struct c_scope *scope;
3180 /* We have a goto to this label. The goto is going forward. In
3181 g->scope, the goto is going to skip any binding which was
3182 defined after g->bindings_in_scope. */
3183 if (g->goto_bindings.scope->has_jump_unsafe_decl)
3185 for (b = g->goto_bindings.scope->bindings;
3186 b != g->goto_bindings.bindings_in_scope;
3189 if (decl_jump_unsafe (b->decl))
3190 warn_about_goto (g->loc, label, b->decl);
3194 /* We also need to warn about decls defined in any scopes
3195 between the scope of the label and the scope of the goto. */
3196 for (scope = label_vars->label_bindings.scope;
3197 scope != g->goto_bindings.scope;
3198 scope = scope->outer)
3200 gcc_assert (scope != NULL);
3201 if (scope->has_jump_unsafe_decl)
3203 if (scope == label_vars->label_bindings.scope)
3204 b = label_vars->label_bindings.bindings_in_scope;
3206 b = scope->bindings;
3207 for (; b != NULL; b = b->prev)
3209 if (decl_jump_unsafe (b->decl))
3210 warn_about_goto (g->loc, label, b->decl);
3215 if (g->goto_bindings.stmt_exprs > 0)
3217 error_at (g->loc, "jump into statement expression");
3218 inform (DECL_SOURCE_LOCATION (label), "label %qD defined here",
3223 /* Now that the label is defined, we will issue warnings about
3224 subsequent gotos to this label when we see them. */
3225 VEC_truncate (c_goto_bindings_p, label_vars->gotos, 0);
3226 label_vars->gotos = NULL;
3229 /* Define a label, specifying the location in the source file.
3230 Return the LABEL_DECL node for the label, if the definition is valid.
3231 Otherwise return 0. */
3234 define_label (location_t location, tree name)
3236 /* Find any preexisting label with this name. It is an error
3237 if that label has already been defined in this function, or
3238 if there is a containing function with a declared label with
3240 tree label = I_LABEL_DECL (name);
3243 && ((DECL_CONTEXT (label) == current_function_decl
3244 && DECL_INITIAL (label) != 0)
3245 || (DECL_CONTEXT (label) != current_function_decl
3246 && C_DECLARED_LABEL_FLAG (label))))
3248 error_at (location, "duplicate label %qD", label);
3249 locate_old_decl (label);
3252 else if (label && DECL_CONTEXT (label) == current_function_decl)
3254 struct c_label_vars *label_vars = I_LABEL_BINDING (name)->u.label;
3256 /* The label has been used or declared already in this function,
3257 but not defined. Update its location to point to this
3259 DECL_SOURCE_LOCATION (label) = location;
3260 set_spot_bindings (&label_vars->label_bindings, true);
3262 /* Issue warnings as required about any goto statements from
3263 earlier in the function. */
3264 check_earlier_gotos (label, label_vars);
3268 struct c_label_vars *label_vars;
3270 /* No label binding for that identifier; make one. */
3271 label = make_label (location, name, true, &label_vars);
3273 /* Ordinary labels go in the current function scope. */
3274 bind_label (name, label, current_function_scope, label_vars);
3277 if (!in_system_header && lookup_name (name))
3278 warning_at (location, OPT_Wtraditional,
3279 "traditional C lacks a separate namespace "
3280 "for labels, identifier %qE conflicts", name);
3282 /* Mark label as having been defined. */
3283 DECL_INITIAL (label) = error_mark_node;
3287 /* Get the bindings for a new switch statement. This is used to issue
3288 warnings as appropriate for jumps from the switch to case or
3291 struct c_spot_bindings *
3292 c_get_switch_bindings (void)
3294 struct c_spot_bindings *switch_bindings;
3296 switch_bindings = XNEW (struct c_spot_bindings);
3297 set_spot_bindings (switch_bindings, true);
3298 return switch_bindings;
3302 c_release_switch_bindings (struct c_spot_bindings *bindings)
3304 gcc_assert (bindings->stmt_exprs == 0 && !bindings->left_stmt_expr);
3308 /* This is called at the point of a case or default label to issue
3309 warnings about decls as needed. It returns true if it found an
3310 error, not just a warning. */
3313 c_check_switch_jump_warnings (struct c_spot_bindings *switch_bindings,
3314 location_t switch_loc, location_t case_loc)
3317 struct c_scope *scope;
3320 for (scope = current_scope;
3321 scope != switch_bindings->scope;
3322 scope = scope->outer)
3324 struct c_binding *b;
3326 gcc_assert (scope != NULL);
3328 if (!scope->has_jump_unsafe_decl)
3331 for (b = scope->bindings; b != NULL; b = b->prev)
3333 if (decl_jump_unsafe (b->decl))
3335 if (variably_modified_type_p (TREE_TYPE (b->decl), NULL_TREE))
3339 ("switch jumps into scope of identifier with "
3340 "variably modified type"));
3343 warning_at (case_loc, OPT_Wjump_misses_init,
3344 "switch jumps over variable initialization");
3345 inform (switch_loc, "switch starts here");
3346 inform (DECL_SOURCE_LOCATION (b->decl), "%qD declared here",
3352 if (switch_bindings->stmt_exprs > 0)
3355 error_at (case_loc, "switch jumps into statement expression");
3356 inform (switch_loc, "switch starts here");
3362 /* Given NAME, an IDENTIFIER_NODE,
3363 return the structure (or union or enum) definition for that name.
3364 If THISLEVEL_ONLY is nonzero, searches only the current_scope.
3365 CODE says which kind of type the caller wants;
3366 it is RECORD_TYPE or UNION_TYPE or ENUMERAL_TYPE.
3367 If PLOC is not NULL and this returns non-null, it sets *PLOC to the
3368 location where the tag was defined.
3369 If the wrong kind of type is found, an error is reported. */
3372 lookup_tag (enum tree_code code, tree name, int thislevel_only,
3375 struct c_binding *b = I_TAG_BINDING (name);
3381 /* We only care about whether it's in this level if
3382 thislevel_only was set or it might be a type clash. */
3383 if (thislevel_only || TREE_CODE (b->decl) != code)
3385 /* For our purposes, a tag in the external scope is the same as
3386 a tag in the file scope. (Primarily relevant to Objective-C
3387 and its builtin structure tags, which get pushed before the
3388 file scope is created.) */
3389 if (B_IN_CURRENT_SCOPE (b)
3390 || (current_scope == file_scope && B_IN_EXTERNAL_SCOPE (b)))
3394 if (thislevel_only && !thislevel)
3397 if (TREE_CODE (b->decl) != code)
3399 /* Definition isn't the kind we were looking for. */
3400 pending_invalid_xref = name;
3401 pending_invalid_xref_location = input_location;
3403 /* If in the same binding level as a declaration as a tag
3404 of a different type, this must not be allowed to
3405 shadow that tag, so give the error immediately.
3406 (For example, "struct foo; union foo;" is invalid.) */
3408 pending_xref_error ();
3417 /* Print an error message now
3418 for a recent invalid struct, union or enum cross reference.
3419 We don't print them immediately because they are not invalid
3420 when used in the `struct foo;' construct for shadowing. */
3423 pending_xref_error (void)
3425 if (pending_invalid_xref != 0)
3426 error_at (pending_invalid_xref_location, "%qE defined as wrong kind of tag",
3427 pending_invalid_xref);
3428 pending_invalid_xref = 0;
3432 /* Look up NAME in the current scope and its superiors
3433 in the namespace of variables, functions and typedefs.
3434 Return a ..._DECL node of some kind representing its definition,
3435 or return 0 if it is undefined. */
3438 lookup_name (tree name)
3440 struct c_binding *b = I_SYMBOL_BINDING (name);
3441 if (b && !b->invisible)
3446 /* Similar to `lookup_name' but look only at the indicated scope. */
3449 lookup_name_in_scope (tree name, struct c_scope *scope)
3451 struct c_binding *b;
3453 for (b = I_SYMBOL_BINDING (name); b; b = b->shadowed)
3454 if (B_IN_SCOPE (b, scope))
3459 /* Create the predefined scalar types of C,
3460 and some nodes representing standard constants (0, 1, (void *) 0).
3461 Initialize the global scope.
3462 Make definitions for built-in primitive functions. */
3465 c_init_decl_processing (void)
3467 location_t save_loc = input_location;
3469 /* Initialize reserved words for parser. */
3472 current_function_decl = 0;
3474 gcc_obstack_init (&parser_obstack);
3476 /* Make the externals scope. */
3478 external_scope = current_scope;
3480 /* Declarations from c_common_nodes_and_builtins must not be associated
3481 with this input file, lest we get differences between using and not
3482 using preprocessed headers. */
3483 input_location = BUILTINS_LOCATION;
3485 build_common_tree_nodes (flag_signed_char);
3487 c_common_nodes_and_builtins ();
3489 /* In C, comparisons and TRUTH_* expressions have type int. */
3490 truthvalue_type_node = integer_type_node;
3491 truthvalue_true_node = integer_one_node;
3492 truthvalue_false_node = integer_zero_node;
3494 /* Even in C99, which has a real boolean type. */
3495 pushdecl (build_decl (UNKNOWN_LOCATION, TYPE_DECL, get_identifier ("_Bool"),
3496 boolean_type_node));
3498 input_location = save_loc;
3500 pedantic_lvalues = true;
3502 make_fname_decl = c_make_fname_decl;
3503 start_fname_decls ();
3506 /* Create the VAR_DECL at LOC for __FUNCTION__ etc. ID is the name to
3507 give the decl, NAME is the initialization string and TYPE_DEP
3508 indicates whether NAME depended on the type of the function. As we
3509 don't yet implement delayed emission of static data, we mark the
3510 decl as emitted so it is not placed in the output. Anything using
3511 it must therefore pull out the STRING_CST initializer directly.
3515 c_make_fname_decl (location_t loc, tree id, int type_dep)
3517 const char *name = fname_as_string (type_dep);
3518 tree decl, type, init;
3519 size_t length = strlen (name);
3521 type = build_array_type (char_type_node,
3522 build_index_type (size_int (length)));
3523 type = c_build_qualified_type (type, TYPE_QUAL_CONST);
3525 decl = build_decl (loc, VAR_DECL, id, type);
3527 TREE_STATIC (decl) = 1;
3528 TREE_READONLY (decl) = 1;
3529 DECL_ARTIFICIAL (decl) = 1;
3531 init = build_string (length + 1, name);
3532 free (CONST_CAST (char *, name));
3533 TREE_TYPE (init) = type;
3534 DECL_INITIAL (decl) = init;
3536 TREE_USED (decl) = 1;
3538 if (current_function_decl
3539 /* For invalid programs like this:
3542 const char* p = __FUNCTION__;
3544 the __FUNCTION__ is believed to appear in K&R style function
3545 parameter declarator. In that case we still don't have
3547 && (!seen_error () || current_function_scope))
3549 DECL_CONTEXT (decl) = current_function_decl;
3550 bind (id, decl, current_function_scope,
3551 /*invisible=*/false, /*nested=*/false, UNKNOWN_LOCATION);
3554 finish_decl (decl, loc, init, NULL_TREE, NULL_TREE);
3560 c_builtin_function (tree decl)
3562 tree type = TREE_TYPE (decl);
3563 tree id = DECL_NAME (decl);
3565 const char *name = IDENTIFIER_POINTER (id);
3566 C_DECL_BUILTIN_PROTOTYPE (decl) = prototype_p (type);
3568 /* Should never be called on a symbol with a preexisting meaning. */
3569 gcc_assert (!I_SYMBOL_BINDING (id));
3571 bind (id, decl, external_scope, /*invisible=*/true, /*nested=*/false,
3574 /* Builtins in the implementation namespace are made visible without
3575 needing to be explicitly declared. See push_file_scope. */
3576 if (name[0] == '_' && (name[1] == '_' || ISUPPER (name[1])))
3578 DECL_CHAIN (decl) = visible_builtins;
3579 visible_builtins = decl;
3586 c_builtin_function_ext_scope (tree decl)
3588 tree type = TREE_TYPE (decl);
3589 tree id = DECL_NAME (decl);
3591 const char *name = IDENTIFIER_POINTER (id);
3592 C_DECL_BUILTIN_PROTOTYPE (decl) = prototype_p (type);
3594 /* Should never be called on a symbol with a preexisting meaning. */
3595 gcc_assert (!I_SYMBOL_BINDING (id));
3597 bind (id, decl, external_scope, /*invisible=*/false, /*nested=*/false,
3600 /* Builtins in the implementation namespace are made visible without
3601 needing to be explicitly declared. See push_file_scope. */
3602 if (name[0] == '_' && (name[1] == '_' || ISUPPER (name[1])))
3604 DECL_CHAIN (decl) = visible_builtins;
3605 visible_builtins = decl;
3611 /* Called when a declaration is seen that contains no names to declare.
3612 If its type is a reference to a structure, union or enum inherited
3613 from a containing scope, shadow that tag name for the current scope
3614 with a forward reference.
3615 If its type defines a new named structure or union
3616 or defines an enum, it is valid but we need not do anything here.
3617 Otherwise, it is an error. */
3620 shadow_tag (const struct c_declspecs *declspecs)
3622 shadow_tag_warned (declspecs, 0);
3625 /* WARNED is 1 if we have done a pedwarn, 2 if we have done a warning,
3628 shadow_tag_warned (const struct c_declspecs *declspecs, int warned)
3630 bool found_tag = false;
3632 if (declspecs->type && !declspecs->default_int_p && !declspecs->typedef_p)
3634 tree value = declspecs->type;
3635 enum tree_code code = TREE_CODE (value);
3637 if (code == RECORD_TYPE || code == UNION_TYPE || code == ENUMERAL_TYPE)
3638 /* Used to test also that TYPE_SIZE (value) != 0.
3639 That caused warning for `struct foo;' at top level in the file. */
3641 tree name = TYPE_NAME (value);
3646 if (declspecs->restrict_p)
3648 error ("invalid use of %<restrict%>");
3654 if (warned != 1 && code != ENUMERAL_TYPE)
3655 /* Empty unnamed enum OK */
3657 pedwarn (input_location, 0,
3658 "unnamed struct/union that defines no instances");
3662 else if (declspecs->typespec_kind != ctsk_tagdef
3663 && declspecs->typespec_kind != ctsk_tagfirstref
3664 && declspecs->storage_class != csc_none)
3667 pedwarn (input_location, 0,
3668 "empty declaration with storage class specifier "
3669 "does not redeclare tag");
3671 pending_xref_error ();
3673 else if (declspecs->typespec_kind != ctsk_tagdef
3674 && declspecs->typespec_kind != ctsk_tagfirstref
3675 && (declspecs->const_p
3676 || declspecs->volatile_p
3677 || declspecs->restrict_p
3678 || declspecs->address_space))
3681 pedwarn (input_location, 0,
3682 "empty declaration with type qualifier "
3683 "does not redeclare tag");
3685 pending_xref_error ();
3689 pending_invalid_xref = 0;
3690 t = lookup_tag (code, name, 1, NULL);
3694 t = make_node (code);
3695 pushtag (input_location, name, t);
3701 if (warned != 1 && !in_system_header)
3703 pedwarn (input_location, 0,
3704 "useless type name in empty declaration");
3709 else if (warned != 1 && !in_system_header && declspecs->typedef_p)
3711 pedwarn (input_location, 0, "useless type name in empty declaration");
3715 pending_invalid_xref = 0;
3717 if (declspecs->inline_p)
3719 error ("%<inline%> in empty declaration");
3723 if (current_scope == file_scope && declspecs->storage_class == csc_auto)
3725 error ("%<auto%> in file-scope empty declaration");
3729 if (current_scope == file_scope && declspecs->storage_class == csc_register)
3731 error ("%<register%> in file-scope empty declaration");
3735 if (!warned && !in_system_header && declspecs->storage_class != csc_none)
3737 warning (0, "useless storage class specifier in empty declaration");
3741 if (!warned && !in_system_header && declspecs->thread_p)
3743 warning (0, "useless %<__thread%> in empty declaration");
3747 if (!warned && !in_system_header && (declspecs->const_p
3748 || declspecs->volatile_p
3749 || declspecs->restrict_p
3750 || declspecs->address_space))
3752 warning (0, "useless type qualifier in empty declaration");
3759 pedwarn (input_location, 0, "empty declaration");
3764 /* Return the qualifiers from SPECS as a bitwise OR of TYPE_QUAL_*
3765 bits. SPECS represents declaration specifiers that the grammar
3766 only permits to contain type qualifiers and attributes. */
3769 quals_from_declspecs (const struct c_declspecs *specs)
3771 int quals = ((specs->const_p ? TYPE_QUAL_CONST : 0)
3772 | (specs->volatile_p ? TYPE_QUAL_VOLATILE : 0)
3773 | (specs->restrict_p ? TYPE_QUAL_RESTRICT : 0)
3774 | (ENCODE_QUAL_ADDR_SPACE (specs->address_space)));
3775 gcc_assert (!specs->type
3776 && !specs->decl_attr
3777 && specs->typespec_word == cts_none
3778 && specs->storage_class == csc_none
3779 && !specs->typedef_p
3780 && !specs->explicit_signed_p
3781 && !specs->deprecated_p
3783 && !specs->long_long_p
3786 && !specs->unsigned_p
3787 && !specs->complex_p
3789 && !specs->thread_p);
3793 /* Construct an array declarator. LOC is the location of the
3794 beginning of the array (usually the opening brace). EXPR is the
3795 expression inside [], or NULL_TREE. QUALS are the type qualifiers
3796 inside the [] (to be applied to the pointer to which a parameter
3797 array is converted). STATIC_P is true if "static" is inside the
3798 [], false otherwise. VLA_UNSPEC_P is true if the array is [*], a
3799 VLA of unspecified length which is nevertheless a complete type,
3800 false otherwise. The field for the contained declarator is left to
3801 be filled in by set_array_declarator_inner. */
3803 struct c_declarator *
3804 build_array_declarator (location_t loc,
3805 tree expr, struct c_declspecs *quals, bool static_p,
3808 struct c_declarator *declarator = XOBNEW (&parser_obstack,
3809 struct c_declarator);
3810 declarator->id_loc = loc;
3811 declarator->kind = cdk_array;
3812 declarator->declarator = 0;
3813 declarator->u.array.dimen = expr;
3816 declarator->u.array.attrs = quals->attrs;
3817 declarator->u.array.quals = quals_from_declspecs (quals);
3821 declarator->u.array.attrs = NULL_TREE;
3822 declarator->u.array.quals = 0;
3824 declarator->u.array.static_p = static_p;
3825 declarator->u.array.vla_unspec_p = vla_unspec_p;
3828 if (static_p || quals != NULL)
3829 pedwarn (loc, OPT_pedantic,
3830 "ISO C90 does not support %<static%> or type "
3831 "qualifiers in parameter array declarators");
3833 pedwarn (loc, OPT_pedantic,
3834 "ISO C90 does not support %<[*]%> array declarators");
3838 if (!current_scope->parm_flag)
3841 error_at (loc, "%<[*]%> not allowed in other than "
3842 "function prototype scope");
3843 declarator->u.array.vla_unspec_p = false;
3846 current_scope->had_vla_unspec = true;
3851 /* Set the contained declarator of an array declarator. DECL is the
3852 declarator, as constructed by build_array_declarator; INNER is what
3853 appears on the left of the []. */
3855 struct c_declarator *
3856 set_array_declarator_inner (struct c_declarator *decl,
3857 struct c_declarator *inner)
3859 decl->declarator = inner;
3863 /* INIT is a constructor that forms DECL's initializer. If the final
3864 element initializes a flexible array field, add the size of that
3865 initializer to DECL's size. */
3868 add_flexible_array_elts_to_size (tree decl, tree init)
3872 if (VEC_empty (constructor_elt, CONSTRUCTOR_ELTS (init)))
3875 elt = VEC_last (constructor_elt, CONSTRUCTOR_ELTS (init))->value;
3876 type = TREE_TYPE (elt);
3877 if (TREE_CODE (type) == ARRAY_TYPE
3878 && TYPE_SIZE (type) == NULL_TREE
3879 && TYPE_DOMAIN (type) != NULL_TREE
3880 && TYPE_MAX_VALUE (TYPE_DOMAIN (type)) == NULL_TREE)
3882 complete_array_type (&type, elt, false);
3884 = size_binop (PLUS_EXPR, DECL_SIZE (decl), TYPE_SIZE (type));
3885 DECL_SIZE_UNIT (decl)
3886 = size_binop (PLUS_EXPR, DECL_SIZE_UNIT (decl), TYPE_SIZE_UNIT (type));
3890 /* Decode a "typename", such as "int **", returning a ..._TYPE node.
3891 Set *EXPR, if EXPR not NULL, to any expression to be evaluated
3892 before the type name, and set *EXPR_CONST_OPERANDS, if
3893 EXPR_CONST_OPERANDS not NULL, to indicate whether the type name may
3894 appear in a constant expression. */
3897 groktypename (struct c_type_name *type_name, tree *expr,
3898 bool *expr_const_operands)
3901 tree attrs = type_name->specs->attrs;
3903 type_name->specs->attrs = NULL_TREE;
3905 type = grokdeclarator (type_name->declarator, type_name->specs, TYPENAME,
3906 false, NULL, &attrs, expr, expr_const_operands,
3909 /* Apply attributes. */
3910 decl_attributes (&type, attrs, 0);
3915 /* Decode a declarator in an ordinary declaration or data definition.
3916 This is called as soon as the type information and variable name
3917 have been parsed, before parsing the initializer if any.
3918 Here we create the ..._DECL node, fill in its type,
3919 and put it on the list of decls for the current context.
3920 The ..._DECL node is returned as the value.
3922 Exception: for arrays where the length is not specified,
3923 the type is left null, to be filled in by `finish_decl'.
3925 Function definitions do not come here; they go to start_function
3926 instead. However, external and forward declarations of functions
3927 do go through here. Structure field declarations are done by
3928 grokfield and not through here. */
3931 start_decl (struct c_declarator *declarator, struct c_declspecs *declspecs,
3932 bool initialized, tree attributes)
3936 tree expr = NULL_TREE;
3937 enum deprecated_states deprecated_state = DEPRECATED_NORMAL;
3939 /* An object declared as __attribute__((deprecated)) suppresses
3940 warnings of uses of other deprecated items. */
3941 if (lookup_attribute ("deprecated", attributes))
3942 deprecated_state = DEPRECATED_SUPPRESS;
3944 decl = grokdeclarator (declarator, declspecs,
3945 NORMAL, initialized, NULL, &attributes, &expr, NULL,
3951 add_stmt (fold_convert (void_type_node, expr));
3953 if (TREE_CODE (decl) != FUNCTION_DECL && MAIN_NAME_P (DECL_NAME (decl)))
3954 warning (OPT_Wmain, "%q+D is usually a function", decl);
3957 /* Is it valid for this decl to have an initializer at all?
3958 If not, set INITIALIZED to zero, which will indirectly
3959 tell 'finish_decl' to ignore the initializer once it is parsed. */
3960 switch (TREE_CODE (decl))
3963 error ("typedef %qD is initialized (use __typeof__ instead)", decl);
3968 error ("function %qD is initialized like a variable", decl);
3973 /* DECL_INITIAL in a PARM_DECL is really DECL_ARG_TYPE. */
3974 error ("parameter %qD is initialized", decl);
3979 /* Don't allow initializations for incomplete types except for
3980 arrays which might be completed by the initialization. */
3982 /* This can happen if the array size is an undefined macro.
3983 We already gave a warning, so we don't need another one. */
3984 if (TREE_TYPE (decl) == error_mark_node)
3986 else if (COMPLETE_TYPE_P (TREE_TYPE (decl)))
3988 /* A complete type is ok if size is fixed. */
3990 if (TREE_CODE (TYPE_SIZE (TREE_TYPE (decl))) != INTEGER_CST
3991 || C_DECL_VARIABLE_SIZE (decl))
3993 error ("variable-sized object may not be initialized");
3997 else if (TREE_CODE (TREE_TYPE (decl)) != ARRAY_TYPE)
3999 error ("variable %qD has initializer but incomplete type", decl);
4002 else if (C_DECL_VARIABLE_SIZE (decl))
4004 /* Although C99 is unclear about whether incomplete arrays
4005 of VLAs themselves count as VLAs, it does not make
4006 sense to permit them to be initialized given that
4007 ordinary VLAs may not be initialized. */
4008 error ("variable-sized object may not be initialized");
4015 if (current_scope == file_scope)
4016 TREE_STATIC (decl) = 1;
4018 /* Tell 'pushdecl' this is an initialized decl
4019 even though we don't yet have the initializer expression.
4020 Also tell 'finish_decl' it may store the real initializer. */
4021 DECL_INITIAL (decl) = error_mark_node;
4024 /* If this is a function declaration, write a record describing it to the
4025 prototypes file (if requested). */
4027 if (TREE_CODE (decl) == FUNCTION_DECL)
4028 gen_aux_info_record (decl, 0, 0, prototype_p (TREE_TYPE (decl)));
4030 /* ANSI specifies that a tentative definition which is not merged with
4031 a non-tentative definition behaves exactly like a definition with an
4032 initializer equal to zero. (Section 3.7.2)
4034 -fno-common gives strict ANSI behavior, though this tends to break
4035 a large body of code that grew up without this rule.
4037 Thread-local variables are never common, since there's no entrenched
4038 body of code to break, and it allows more efficient variable references
4039 in the presence of dynamic linking. */
4041 if (TREE_CODE (decl) == VAR_DECL
4043 && TREE_PUBLIC (decl)
4044 && !DECL_THREAD_LOCAL_P (decl)
4046 DECL_COMMON (decl) = 1;
4048 /* Set attributes here so if duplicate decl, will have proper attributes. */
4049 decl_attributes (&decl, attributes, 0);
4051 /* Handle gnu_inline attribute. */
4052 if (declspecs->inline_p
4053 && !flag_gnu89_inline
4054 && TREE_CODE (decl) == FUNCTION_DECL
4055 && (lookup_attribute ("gnu_inline", DECL_ATTRIBUTES (decl))
4056 || current_function_decl))
4058 if (declspecs->storage_class == csc_auto && current_scope != file_scope)
4060 else if (declspecs->storage_class != csc_static)
4061 DECL_EXTERNAL (decl) = !DECL_EXTERNAL (decl);
4064 if (TREE_CODE (decl) == FUNCTION_DECL
4065 && targetm.calls.promote_prototypes (TREE_TYPE (decl)))
4067 struct c_declarator *ce = declarator;
4069 if (ce->kind == cdk_pointer)
4070 ce = declarator->declarator;
4071 if (ce->kind == cdk_function)
4073 tree args = ce->u.arg_info->parms;
4074 for (; args; args = DECL_CHAIN (args))
4076 tree type = TREE_TYPE (args);
4077 if (type && INTEGRAL_TYPE_P (type)
4078 && TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node))
4079 DECL_ARG_TYPE (args) = integer_type_node;
4084 if (TREE_CODE (decl) == FUNCTION_DECL
4085 && DECL_DECLARED_INLINE_P (decl)
4086 && DECL_UNINLINABLE (decl)
4087 && lookup_attribute ("noinline", DECL_ATTRIBUTES (decl)))
4088 warning (OPT_Wattributes, "inline function %q+D given attribute noinline",
4091 /* C99 6.7.4p3: An inline definition of a function with external
4092 linkage shall not contain a definition of a modifiable object
4093 with static storage duration... */
4094 if (TREE_CODE (decl) == VAR_DECL
4095 && current_scope != file_scope
4096 && TREE_STATIC (decl)
4097 && !TREE_READONLY (decl)
4098 && DECL_DECLARED_INLINE_P (current_function_decl)
4099 && DECL_EXTERNAL (current_function_decl))
4100 record_inline_static (input_location, current_function_decl,
4101 decl, csi_modifiable);
4103 if (c_dialect_objc ()
4104 && (TREE_CODE (decl) == VAR_DECL
4105 || TREE_CODE (decl) == FUNCTION_DECL))
4106 objc_check_global_decl (decl);
4108 /* Add this decl to the current scope.
4109 TEM may equal DECL or it may be a previous decl of the same name. */
4110 tem = pushdecl (decl);
4112 if (initialized && DECL_EXTERNAL (tem))
4114 DECL_EXTERNAL (tem) = 0;
4115 TREE_STATIC (tem) = 1;
4121 /* Subroutine of finish_decl. TYPE is the type of an uninitialized object
4122 DECL or the non-array element type if DECL is an uninitialized array.
4123 If that type has a const member, diagnose this. */
4126 diagnose_uninitialized_cst_member (tree decl, tree type)
4129 for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
4132 if (TREE_CODE (field) != FIELD_DECL)
4134 field_type = strip_array_types (TREE_TYPE (field));
4136 if (TYPE_QUALS (field_type) & TYPE_QUAL_CONST)
4138 warning_at (DECL_SOURCE_LOCATION (decl), OPT_Wc___compat,
4139 "uninitialized const member in %qT is invalid in C++",
4140 strip_array_types (TREE_TYPE (decl)));
4141 inform (DECL_SOURCE_LOCATION (field), "%qD should be initialized", field);
4144 if (TREE_CODE (field_type) == RECORD_TYPE
4145 || TREE_CODE (field_type) == UNION_TYPE)
4146 diagnose_uninitialized_cst_member (decl, field_type);
4150 /* Finish processing of a declaration;
4151 install its initial value.
4152 If ORIGTYPE is not NULL_TREE, it is the original type of INIT.
4153 If the length of an array type is not known before,
4154 it must be determined now, from the initial value, or it is an error.
4156 INIT_LOC is the location of the initial value. */
4159 finish_decl (tree decl, location_t init_loc, tree init,
4160 tree origtype, tree asmspec_tree)
4163 bool was_incomplete = (DECL_SIZE (decl) == 0);
4164 const char *asmspec = 0;
4166 /* If a name was specified, get the string. */
4167 if ((TREE_CODE (decl) == FUNCTION_DECL || TREE_CODE (decl) == VAR_DECL)
4168 && DECL_FILE_SCOPE_P (decl))
4169 asmspec_tree = maybe_apply_renaming_pragma (decl, asmspec_tree);
4171 asmspec = TREE_STRING_POINTER (asmspec_tree);
4173 if (TREE_CODE (decl) == VAR_DECL
4174 && TREE_STATIC (decl)
4175 && global_bindings_p ())
4176 /* So decl is a global variable. Record the types it uses
4177 so that we can decide later to emit debug info for them. */
4178 record_types_used_by_current_var_decl (decl);
4180 /* If `start_decl' didn't like having an initialization, ignore it now. */
4181 if (init != 0 && DECL_INITIAL (decl) == 0)
4184 /* Don't crash if parm is initialized. */
4185 if (TREE_CODE (decl) == PARM_DECL)
4189 store_init_value (init_loc, decl, init, origtype);
4191 if (c_dialect_objc () && (TREE_CODE (decl) == VAR_DECL
4192 || TREE_CODE (decl) == FUNCTION_DECL
4193 || TREE_CODE (decl) == FIELD_DECL))
4194 objc_check_decl (decl);
4196 type = TREE_TYPE (decl);
4198 /* Deduce size of array from initialization, if not already known. */
4199 if (TREE_CODE (type) == ARRAY_TYPE
4200 && TYPE_DOMAIN (type) == 0
4201 && TREE_CODE (decl) != TYPE_DECL)
4204 = (TREE_STATIC (decl)
4205 /* Even if pedantic, an external linkage array
4206 may have incomplete type at first. */
4207 ? pedantic && !TREE_PUBLIC (decl)
4208 : !DECL_EXTERNAL (decl));
4210 = complete_array_type (&TREE_TYPE (decl), DECL_INITIAL (decl),
4213 /* Get the completed type made by complete_array_type. */
4214 type = TREE_TYPE (decl);
4219 error ("initializer fails to determine size of %q+D", decl);
4224 error ("array size missing in %q+D", decl);
4225 /* If a `static' var's size isn't known,
4226 make it extern as well as static, so it does not get
4228 If it is not `static', then do not mark extern;
4229 finish_incomplete_decl will give it a default size
4230 and it will get allocated. */
4231 else if (!pedantic && TREE_STATIC (decl) && !TREE_PUBLIC (decl))
4232 DECL_EXTERNAL (decl) = 1;
4236 error ("zero or negative size array %q+D", decl);
4240 /* For global variables, update the copy of the type that
4241 exists in the binding. */
4242 if (TREE_PUBLIC (decl))
4244 struct c_binding *b_ext = I_SYMBOL_BINDING (DECL_NAME (decl));
4245 while (b_ext && !B_IN_EXTERNAL_SCOPE (b_ext))
4246 b_ext = b_ext->shadowed;
4250 b_ext->u.type = composite_type (b_ext->u.type, type);
4252 b_ext->u.type = type;
4261 if (DECL_INITIAL (decl))
4262 TREE_TYPE (DECL_INITIAL (decl)) = type;
4264 relayout_decl (decl);
4267 if (TREE_CODE (decl) == VAR_DECL)
4269 if (init && TREE_CODE (init) == CONSTRUCTOR)
4270 add_flexible_array_elts_to_size (decl, init);
4272 if (DECL_SIZE (decl) == 0 && TREE_TYPE (decl) != error_mark_node
4273 && COMPLETE_TYPE_P (TREE_TYPE (decl)))
4274 layout_decl (decl, 0);
4276 if (DECL_SIZE (decl) == 0
4277 /* Don't give an error if we already gave one earlier. */
4278 && TREE_TYPE (decl) != error_mark_node
4279 && (TREE_STATIC (decl)
4280 /* A static variable with an incomplete type
4281 is an error if it is initialized.
4282 Also if it is not file scope.
4283 Otherwise, let it through, but if it is not `extern'
4284 then it may cause an error message later. */
4285 ? (DECL_INITIAL (decl) != 0
4286 || !DECL_FILE_SCOPE_P (decl))
4287 /* An automatic variable with an incomplete type
4289 : !DECL_EXTERNAL (decl)))
4291 error ("storage size of %q+D isn%'t known", decl);
4292 TREE_TYPE (decl) = error_mark_node;
4295 if ((DECL_EXTERNAL (decl) || TREE_STATIC (decl))
4296 && DECL_SIZE (decl) != 0)
4298 if (TREE_CODE (DECL_SIZE (decl)) == INTEGER_CST)
4299 constant_expression_warning (DECL_SIZE (decl));
4302 error ("storage size of %q+D isn%'t constant", decl);
4303 TREE_TYPE (decl) = error_mark_node;
4307 if (TREE_USED (type))
4309 TREE_USED (decl) = 1;
4310 DECL_READ_P (decl) = 1;
4314 /* If this is a function and an assembler name is specified, reset DECL_RTL
4315 so we can give it its new name. Also, update built_in_decls if it
4316 was a normal built-in. */
4317 if (TREE_CODE (decl) == FUNCTION_DECL && asmspec)
4319 if (DECL_BUILT_IN_CLASS (decl) == BUILT_IN_NORMAL)
4320 set_builtin_user_assembler_name (decl, asmspec);
4321 set_user_assembler_name (decl, asmspec);
4324 /* If #pragma weak was used, mark the decl weak now. */
4325 maybe_apply_pragma_weak (decl);
4327 /* Output the assembler code and/or RTL code for variables and functions,
4328 unless the type is an undefined structure or union.
4329 If not, it will get done when the type is completed. */
4331 if (TREE_CODE (decl) == VAR_DECL || TREE_CODE (decl) == FUNCTION_DECL)
4333 /* Determine the ELF visibility. */
4334 if (TREE_PUBLIC (decl))
4335 c_determine_visibility (decl);
4337 /* This is a no-op in c-lang.c or something real in objc-act.c. */
4338 if (c_dialect_objc ())
4339 objc_check_decl (decl);
4343 /* If this is not a static variable, issue a warning.
4344 It doesn't make any sense to give an ASMSPEC for an
4345 ordinary, non-register local variable. Historically,
4346 GCC has accepted -- but ignored -- the ASMSPEC in
4348 if (!DECL_FILE_SCOPE_P (decl)
4349 && TREE_CODE (decl) == VAR_DECL
4350 && !C_DECL_REGISTER (decl)
4351 && !TREE_STATIC (decl))
4352 warning (0, "ignoring asm-specifier for non-static local "
4353 "variable %q+D", decl);
4355 set_user_assembler_name (decl, asmspec);
4358 if (DECL_FILE_SCOPE_P (decl))
4360 if (DECL_INITIAL (decl) == NULL_TREE
4361 || DECL_INITIAL (decl) == error_mark_node)
4362 /* Don't output anything
4363 when a tentative file-scope definition is seen.
4364 But at end of compilation, do output code for them. */
4365 DECL_DEFER_OUTPUT (decl) = 1;
4366 rest_of_decl_compilation (decl, true, 0);
4370 /* In conjunction with an ASMSPEC, the `register'
4371 keyword indicates that we should place the variable
4372 in a particular register. */
4373 if (asmspec && C_DECL_REGISTER (decl))
4375 DECL_HARD_REGISTER (decl) = 1;
4376 /* This cannot be done for a structure with volatile
4377 fields, on which DECL_REGISTER will have been
4379 if (!DECL_REGISTER (decl))
4380 error ("cannot put object with volatile field into register");
4383 if (TREE_CODE (decl) != FUNCTION_DECL)
4385 /* If we're building a variable sized type, and we might be
4386 reachable other than via the top of the current binding
4387 level, then create a new BIND_EXPR so that we deallocate
4388 the object at the right time. */
4389 /* Note that DECL_SIZE can be null due to errors. */
4390 if (DECL_SIZE (decl)
4391 && !TREE_CONSTANT (DECL_SIZE (decl))
4392 && STATEMENT_LIST_HAS_LABEL (cur_stmt_list))
4395 bind = build3 (BIND_EXPR, void_type_node, NULL, NULL, NULL);
4396 TREE_SIDE_EFFECTS (bind) = 1;
4398 BIND_EXPR_BODY (bind) = push_stmt_list ();
4400 add_stmt (build_stmt (DECL_SOURCE_LOCATION (decl),
4406 if (!DECL_FILE_SCOPE_P (decl))
4408 /* Recompute the RTL of a local array now
4409 if it used to be an incomplete type. */
4411 && !TREE_STATIC (decl) && !DECL_EXTERNAL (decl))
4413 /* If we used it already as memory, it must stay in memory. */
4414 TREE_ADDRESSABLE (decl) = TREE_USED (decl);
4415 /* If it's still incomplete now, no init will save it. */
4416 if (DECL_SIZE (decl) == 0)
4417 DECL_INITIAL (decl) = 0;
4422 if (TREE_CODE (decl) == TYPE_DECL)
4424 if (!DECL_FILE_SCOPE_P (decl)
4425 && variably_modified_type_p (TREE_TYPE (decl), NULL_TREE))
4426 add_stmt (build_stmt (DECL_SOURCE_LOCATION (decl), DECL_EXPR, decl));
4428 rest_of_decl_compilation (decl, DECL_FILE_SCOPE_P (decl), 0);
4431 /* At the end of a declaration, throw away any variable type sizes
4432 of types defined inside that declaration. There is no use
4433 computing them in the following function definition. */
4434 if (current_scope == file_scope)
4435 get_pending_sizes ();
4437 /* Install a cleanup (aka destructor) if one was given. */
4438 if (TREE_CODE (decl) == VAR_DECL && !TREE_STATIC (decl))
4440 tree attr = lookup_attribute ("cleanup", DECL_ATTRIBUTES (decl));
4443 tree cleanup_id = TREE_VALUE (TREE_VALUE (attr));
4444 tree cleanup_decl = lookup_name (cleanup_id);
4448 /* Build "cleanup(&decl)" for the destructor. */
4449 cleanup = build_unary_op (input_location, ADDR_EXPR, decl, 0);
4450 vec = VEC_alloc (tree, gc, 1);
4451 VEC_quick_push (tree, vec, cleanup);
4452 cleanup = build_function_call_vec (DECL_SOURCE_LOCATION (decl),
4453 cleanup_decl, vec, NULL);
4454 VEC_free (tree, gc, vec);
4456 /* Don't warn about decl unused; the cleanup uses it. */
4457 TREE_USED (decl) = 1;
4458 TREE_USED (cleanup_decl) = 1;
4459 DECL_READ_P (decl) = 1;
4461 push_cleanup (decl, cleanup, false);
4466 && TREE_CODE (decl) == VAR_DECL
4467 && !DECL_EXTERNAL (decl)
4468 && DECL_INITIAL (decl) == NULL_TREE)
4470 type = strip_array_types (type);
4471 if (TREE_READONLY (decl))
4472 warning_at (DECL_SOURCE_LOCATION (decl), OPT_Wc___compat,
4473 "uninitialized const %qD is invalid in C++", decl);
4474 else if ((TREE_CODE (type) == RECORD_TYPE
4475 || TREE_CODE (type) == UNION_TYPE)
4476 && C_TYPE_FIELDS_READONLY (type))
4477 diagnose_uninitialized_cst_member (decl, type);
4481 /* Given a parsed parameter declaration, decode it into a PARM_DECL. */
4484 grokparm (const struct c_parm *parm)
4486 tree attrs = parm->attrs;
4487 tree decl = grokdeclarator (parm->declarator, parm->specs, PARM, false,
4488 NULL, &attrs, NULL, NULL, DEPRECATED_NORMAL);
4490 decl_attributes (&decl, attrs, 0);
4495 /* Given a parsed parameter declaration, decode it into a PARM_DECL
4496 and push that on the current scope. */
4499 push_parm_decl (const struct c_parm *parm)
4501 tree attrs = parm->attrs;
4504 decl = grokdeclarator (parm->declarator, parm->specs, PARM, false, NULL,
4505 &attrs, NULL, NULL, DEPRECATED_NORMAL);
4506 decl_attributes (&decl, attrs, 0);
4508 decl = pushdecl (decl);
4510 finish_decl (decl, input_location, NULL_TREE, NULL_TREE, NULL_TREE);
4513 /* Mark all the parameter declarations to date as forward decls.
4514 Also diagnose use of this extension. */
4517 mark_forward_parm_decls (void)
4519 struct c_binding *b;
4521 if (pedantic && !current_scope->warned_forward_parm_decls)
4523 pedwarn (input_location, OPT_pedantic,
4524 "ISO C forbids forward parameter declarations");
4525 current_scope->warned_forward_parm_decls = true;
4528 for (b = current_scope->bindings; b; b = b->prev)
4529 if (TREE_CODE (b->decl) == PARM_DECL)
4530 TREE_ASM_WRITTEN (b->decl) = 1;
4533 /* Build a COMPOUND_LITERAL_EXPR. TYPE is the type given in the compound
4534 literal, which may be an incomplete array type completed by the
4535 initializer; INIT is a CONSTRUCTOR at LOC that initializes the compound
4536 literal. NON_CONST is true if the initializers contain something
4537 that cannot occur in a constant expression. */
4540 build_compound_literal (location_t loc, tree type, tree init, bool non_const)
4542 /* We do not use start_decl here because we have a type, not a declarator;
4543 and do not use finish_decl because the decl should be stored inside
4544 the COMPOUND_LITERAL_EXPR rather than added elsewhere as a DECL_EXPR. */
4549 if (type == error_mark_node
4550 || init == error_mark_node)
4551 return error_mark_node;
4553 decl = build_decl (loc, VAR_DECL, NULL_TREE, type);
4554 DECL_EXTERNAL (decl) = 0;
4555 TREE_PUBLIC (decl) = 0;
4556 TREE_STATIC (decl) = (current_scope == file_scope);
4557 DECL_CONTEXT (decl) = current_function_decl;
4558 TREE_USED (decl) = 1;
4559 DECL_READ_P (decl) = 1;
4560 TREE_TYPE (decl) = type;
4561 TREE_READONLY (decl) = TYPE_READONLY (type);
4562 store_init_value (loc, decl, init, NULL_TREE);
4564 if (TREE_CODE (type) == ARRAY_TYPE && !COMPLETE_TYPE_P (type))
4566 int failure = complete_array_type (&TREE_TYPE (decl),
4567 DECL_INITIAL (decl), true);
4568 gcc_assert (!failure);
4570 type = TREE_TYPE (decl);
4571 TREE_TYPE (DECL_INITIAL (decl)) = type;
4574 if (type == error_mark_node || !COMPLETE_TYPE_P (type))
4575 return error_mark_node;
4577 stmt = build_stmt (DECL_SOURCE_LOCATION (decl), DECL_EXPR, decl);
4578 complit = build1 (COMPOUND_LITERAL_EXPR, type, stmt);
4579 TREE_SIDE_EFFECTS (complit) = 1;
4581 layout_decl (decl, 0);
4583 if (TREE_STATIC (decl))
4585 /* This decl needs a name for the assembler output. */
4586 set_compound_literal_name (decl);
4587 DECL_DEFER_OUTPUT (decl) = 1;
4588 DECL_COMDAT (decl) = 1;
4589 DECL_ARTIFICIAL (decl) = 1;
4590 DECL_IGNORED_P (decl) = 1;
4592 rest_of_decl_compilation (decl, 1, 0);
4597 complit = build2 (C_MAYBE_CONST_EXPR, type, NULL, complit);
4598 C_MAYBE_CONST_EXPR_NON_CONST (complit) = 1;
4604 /* Check the type of a compound literal. Here we just check that it
4605 is valid for C++. */
4608 check_compound_literal_type (location_t loc, struct c_type_name *type_name)
4611 && (type_name->specs->typespec_kind == ctsk_tagdef
4612 || type_name->specs->typespec_kind == ctsk_tagfirstref))
4613 warning_at (loc, OPT_Wc___compat,
4614 "defining a type in a compound literal is invalid in C++");
4617 /* Determine whether TYPE is a structure with a flexible array member,
4618 or a union containing such a structure (possibly recursively). */
4621 flexible_array_type_p (tree type)
4624 switch (TREE_CODE (type))
4627 x = TYPE_FIELDS (type);
4630 while (DECL_CHAIN (x) != NULL_TREE)
4632 if (TREE_CODE (TREE_TYPE (x)) == ARRAY_TYPE
4633 && TYPE_SIZE (TREE_TYPE (x)) == NULL_TREE
4634 && TYPE_DOMAIN (TREE_TYPE (x)) != NULL_TREE
4635 && TYPE_MAX_VALUE (TYPE_DOMAIN (TREE_TYPE (x))) == NULL_TREE)
4639 for (x = TYPE_FIELDS (type); x != NULL_TREE; x = DECL_CHAIN (x))
4641 if (flexible_array_type_p (TREE_TYPE (x)))
4650 /* Performs sanity checks on the TYPE and WIDTH of the bit-field NAME,
4651 replacing with appropriate values if they are invalid. */
4653 check_bitfield_type_and_width (tree *type, tree *width, tree orig_name)
4656 unsigned int max_width;
4657 unsigned HOST_WIDE_INT w;
4658 const char *name = (orig_name
4659 ? identifier_to_locale (IDENTIFIER_POINTER (orig_name))
4660 : _("<anonymous>"));
4662 /* Detect and ignore out of range field width and process valid
4664 if (!INTEGRAL_TYPE_P (TREE_TYPE (*width)))
4666 error ("bit-field %qs width not an integer constant", name);
4667 *width = integer_one_node;
4671 if (TREE_CODE (*width) != INTEGER_CST)
4673 *width = c_fully_fold (*width, false, NULL);
4674 if (TREE_CODE (*width) == INTEGER_CST)
4675 pedwarn (input_location, OPT_pedantic,
4676 "bit-field %qs width not an integer constant expression",
4679 if (TREE_CODE (*width) != INTEGER_CST)
4681 error ("bit-field %qs width not an integer constant", name);
4682 *width = integer_one_node;
4684 constant_expression_warning (*width);
4685 if (tree_int_cst_sgn (*width) < 0)
4687 error ("negative width in bit-field %qs", name);
4688 *width = integer_one_node;
4690 else if (integer_zerop (*width) && orig_name)
4692 error ("zero width for bit-field %qs", name);
4693 *width = integer_one_node;
4697 /* Detect invalid bit-field type. */
4698 if (TREE_CODE (*type) != INTEGER_TYPE
4699 && TREE_CODE (*type) != BOOLEAN_TYPE
4700 && TREE_CODE (*type) != ENUMERAL_TYPE)
4702 error ("bit-field %qs has invalid type", name);
4703 *type = unsigned_type_node;
4706 type_mv = TYPE_MAIN_VARIANT (*type);
4707 if (!in_system_header
4708 && type_mv != integer_type_node
4709 && type_mv != unsigned_type_node
4710 && type_mv != boolean_type_node)
4711 pedwarn (input_location, OPT_pedantic,
4712 "type of bit-field %qs is a GCC extension", name);
4714 max_width = TYPE_PRECISION (*type);
4716 if (0 < compare_tree_int (*width, max_width))
4718 error ("width of %qs exceeds its type", name);
4720 *width = build_int_cst (NULL_TREE, w);
4723 w = tree_low_cst (*width, 1);
4725 if (TREE_CODE (*type) == ENUMERAL_TYPE)
4727 struct lang_type *lt = TYPE_LANG_SPECIFIC (*type);
4729 || w < tree_int_cst_min_precision (lt->enum_min, TYPE_UNSIGNED (*type))
4730 || w < tree_int_cst_min_precision (lt->enum_max, TYPE_UNSIGNED (*type)))
4731 warning (0, "%qs is narrower than values of its type", name);
4737 /* Print warning about variable length array if necessary. */
4740 warn_variable_length_array (tree name, tree size)
4742 int const_size = TREE_CONSTANT (size);
4744 if (!flag_isoc99 && pedantic && warn_vla != 0)
4749 pedwarn (input_location, OPT_Wvla,
4750 "ISO C90 forbids array %qE whose size "
4751 "can%'t be evaluated",
4754 pedwarn (input_location, OPT_Wvla, "ISO C90 forbids array whose size "
4755 "can%'t be evaluated");
4760 pedwarn (input_location, OPT_Wvla,
4761 "ISO C90 forbids variable length array %qE",
4764 pedwarn (input_location, OPT_Wvla, "ISO C90 forbids variable length array");
4767 else if (warn_vla > 0)
4773 "the size of array %qE can"
4774 "%'t be evaluated", name);
4777 "the size of array can %'t be evaluated");
4783 "variable length array %qE is used",
4787 "variable length array is used");
4792 /* Given a size SIZE that may not be a constant, return a SAVE_EXPR to
4793 serve as the actual size-expression for a type or decl. This is
4794 like variable_size in stor-layout.c, but we make global_bindings_p
4795 return negative to avoid calls to that function from outside the
4796 front end resulting in errors at file scope, then call this version
4797 instead from front-end code. */
4800 c_variable_size (tree size)
4804 if (TREE_CONSTANT (size))
4807 size = save_expr (size);
4809 save = skip_simple_arithmetic (size);
4811 if (cfun && cfun->dont_save_pending_sizes_p)
4814 if (!global_bindings_p ())
4815 put_pending_size (save);
4820 /* Given declspecs and a declarator,
4821 determine the name and type of the object declared
4822 and construct a ..._DECL node for it.
4823 (In one case we can return a ..._TYPE node instead.
4824 For invalid input we sometimes return 0.)
4826 DECLSPECS is a c_declspecs structure for the declaration specifiers.
4828 DECL_CONTEXT says which syntactic context this declaration is in:
4829 NORMAL for most contexts. Make a VAR_DECL or FUNCTION_DECL or TYPE_DECL.
4830 FUNCDEF for a function definition. Like NORMAL but a few different
4831 error messages in each case. Return value may be zero meaning
4832 this definition is too screwy to try to parse.
4833 PARM for a parameter declaration (either within a function prototype
4834 or before a function body). Make a PARM_DECL, or return void_type_node.
4835 TYPENAME if for a typename (in a cast or sizeof).
4836 Don't make a DECL node; just return the ..._TYPE node.
4837 FIELD for a struct or union field; make a FIELD_DECL.
4838 INITIALIZED is true if the decl has an initializer.
4839 WIDTH is non-NULL for bit-fields, and is a pointer to an INTEGER_CST node
4840 representing the width of the bit-field.
4841 DECL_ATTRS points to the list of attributes that should be added to this
4842 decl. Any nested attributes that belong on the decl itself will be
4844 If EXPR is not NULL, any expressions that need to be evaluated as
4845 part of evaluating variably modified types will be stored in *EXPR.
4846 If EXPR_CONST_OPERANDS is not NULL, *EXPR_CONST_OPERANDS will be
4847 set to indicate whether operands in *EXPR can be used in constant
4849 DEPRECATED_STATE is a deprecated_states value indicating whether
4850 deprecation warnings should be suppressed.
4852 In the TYPENAME case, DECLARATOR is really an absolute declarator.
4853 It may also be so in the PARM case, for a prototype where the
4854 argument type is specified but not the name.
4856 This function is where the complicated C meanings of `static'
4857 and `extern' are interpreted. */
4860 grokdeclarator (const struct c_declarator *declarator,
4861 struct c_declspecs *declspecs,
4862 enum decl_context decl_context, bool initialized, tree *width,
4863 tree *decl_attrs, tree *expr, bool *expr_const_operands,
4864 enum deprecated_states deprecated_state)
4866 tree type = declspecs->type;
4867 bool threadp = declspecs->thread_p;
4868 enum c_storage_class storage_class = declspecs->storage_class;
4872 int type_quals = TYPE_UNQUALIFIED;
4873 tree name = NULL_TREE;
4874 bool funcdef_flag = false;
4875 bool funcdef_syntax = false;
4876 bool size_varies = false;
4877 tree decl_attr = declspecs->decl_attr;
4878 int array_ptr_quals = TYPE_UNQUALIFIED;
4879 tree array_ptr_attrs = NULL_TREE;
4880 int array_parm_static = 0;
4881 bool array_parm_vla_unspec_p = false;
4882 tree returned_attrs = NULL_TREE;
4883 bool bitfield = width != NULL;
4885 struct c_arg_info *arg_info = 0;
4886 addr_space_t as1, as2, address_space;
4887 location_t loc = UNKNOWN_LOCATION;
4890 bool expr_const_operands_dummy;
4892 if (TREE_CODE (type) == ERROR_MARK)
4893 return error_mark_node;
4896 if (expr_const_operands == NULL)
4897 expr_const_operands = &expr_const_operands_dummy;
4899 *expr = declspecs->expr;
4900 *expr_const_operands = declspecs->expr_const_operands;
4902 if (decl_context == FUNCDEF)
4903 funcdef_flag = true, decl_context = NORMAL;
4905 /* Look inside a declarator for the name being declared
4906 and get it as an IDENTIFIER_NODE, for an error message. */
4908 const struct c_declarator *decl = declarator;
4919 funcdef_syntax = (decl->kind == cdk_function);
4920 decl = decl->declarator;
4924 decl = decl->declarator;
4939 gcc_assert (decl_context == PARM
4940 || decl_context == TYPENAME
4941 || (decl_context == FIELD
4942 && declarator->kind == cdk_id));
4943 gcc_assert (!initialized);
4947 /* A function definition's declarator must have the form of
4948 a function declarator. */
4950 if (funcdef_flag && !funcdef_syntax)
4953 /* If this looks like a function definition, make it one,
4954 even if it occurs where parms are expected.
4955 Then store_parm_decls will reject it and not use it as a parm. */
4956 if (decl_context == NORMAL && !funcdef_flag && current_scope->parm_flag)
4957 decl_context = PARM;
4959 if (declspecs->deprecated_p && deprecated_state != DEPRECATED_SUPPRESS)
4960 warn_deprecated_use (declspecs->type, declspecs->decl_attr);
4962 if ((decl_context == NORMAL || decl_context == FIELD)
4963 && current_scope == file_scope
4964 && variably_modified_type_p (type, NULL_TREE))
4967 error_at (loc, "variably modified %qE at file scope", name);
4969 error_at (loc, "variably modified field at file scope");
4970 type = integer_type_node;
4973 size_varies = C_TYPE_VARIABLE_SIZE (type) != 0;
4975 /* Diagnose defaulting to "int". */
4977 if (declspecs->default_int_p && !in_system_header)
4979 /* Issue a warning if this is an ISO C 99 program or if
4980 -Wreturn-type and this is a function, or if -Wimplicit;
4981 prefer the former warning since it is more explicit. */
4982 if ((warn_implicit_int || warn_return_type || flag_isoc99)
4984 warn_about_return_type = 1;
4988 pedwarn_c99 (loc, flag_isoc99 ? 0 : OPT_Wimplicit_int,
4989 "type defaults to %<int%> in declaration of %qE",
4992 pedwarn_c99 (input_location, flag_isoc99 ? 0 : OPT_Wimplicit_int,
4993 "type defaults to %<int%> in type name");
4997 /* Adjust the type if a bit-field is being declared,
4998 -funsigned-bitfields applied and the type is not explicitly
5000 if (bitfield && !flag_signed_bitfields && !declspecs->explicit_signed_p
5001 && TREE_CODE (type) == INTEGER_TYPE)
5002 type = unsigned_type_for (type);
5004 /* Figure out the type qualifiers for the declaration. There are
5005 two ways a declaration can become qualified. One is something
5006 like `const int i' where the `const' is explicit. Another is
5007 something like `typedef const int CI; CI i' where the type of the
5008 declaration contains the `const'. A third possibility is that
5009 there is a type qualifier on the element type of a typedefed
5010 array type, in which case we should extract that qualifier so
5011 that c_apply_type_quals_to_decl receives the full list of
5012 qualifiers to work with (C90 is not entirely clear about whether
5013 duplicate qualifiers should be diagnosed in this case, but it
5014 seems most appropriate to do so). */
5015 element_type = strip_array_types (type);
5016 constp = declspecs->const_p + TYPE_READONLY (element_type);
5017 restrictp = declspecs->restrict_p + TYPE_RESTRICT (element_type);
5018 volatilep = declspecs->volatile_p + TYPE_VOLATILE (element_type);
5019 as1 = declspecs->address_space;
5020 as2 = TYPE_ADDR_SPACE (element_type);
5021 address_space = ADDR_SPACE_GENERIC_P (as1)? as2 : as1;
5023 if (pedantic && !flag_isoc99)
5026 pedwarn (loc, OPT_pedantic, "duplicate %<const%>");
5028 pedwarn (loc, OPT_pedantic, "duplicate %<restrict%>");
5030 pedwarn (loc, OPT_pedantic, "duplicate %<volatile%>");
5033 if (!ADDR_SPACE_GENERIC_P (as1) && !ADDR_SPACE_GENERIC_P (as2) && as1 != as2)
5034 error_at (loc, "conflicting named address spaces (%s vs %s)",
5035 c_addr_space_name (as1), c_addr_space_name (as2));
5037 if (!flag_gen_aux_info && (TYPE_QUALS (element_type)))
5038 type = TYPE_MAIN_VARIANT (type);
5039 type_quals = ((constp ? TYPE_QUAL_CONST : 0)
5040 | (restrictp ? TYPE_QUAL_RESTRICT : 0)
5041 | (volatilep ? TYPE_QUAL_VOLATILE : 0)
5042 | ENCODE_QUAL_ADDR_SPACE (address_space));
5044 /* Warn about storage classes that are invalid for certain
5045 kinds of declarations (parameters, typenames, etc.). */
5049 || storage_class == csc_auto
5050 || storage_class == csc_register
5051 || storage_class == csc_typedef))
5053 if (storage_class == csc_auto)
5055 (current_scope == file_scope) ? 0 : OPT_pedantic,
5056 "function definition declared %<auto%>");
5057 if (storage_class == csc_register)
5058 error_at (loc, "function definition declared %<register%>");
5059 if (storage_class == csc_typedef)
5060 error_at (loc, "function definition declared %<typedef%>");
5062 error_at (loc, "function definition declared %<__thread%>");
5064 if (storage_class == csc_auto
5065 || storage_class == csc_register
5066 || storage_class == csc_typedef)
5067 storage_class = csc_none;
5069 else if (decl_context != NORMAL && (storage_class != csc_none || threadp))
5071 if (decl_context == PARM && storage_class == csc_register)
5075 switch (decl_context)
5079 error_at (loc, "storage class specified for structure "
5082 error_at (loc, "storage class specified for structure field");
5086 error_at (loc, "storage class specified for parameter %qE",
5089 error_at (loc, "storage class specified for unnamed parameter");
5092 error_at (loc, "storage class specified for typename");
5095 storage_class = csc_none;
5099 else if (storage_class == csc_extern
5103 /* 'extern' with initialization is invalid if not at file scope. */
5104 if (current_scope == file_scope)
5106 /* It is fine to have 'extern const' when compiling at C
5107 and C++ intersection. */
5108 if (!(warn_cxx_compat && constp))
5109 warning_at (loc, 0, "%qE initialized and declared %<extern%>",
5113 error_at (loc, "%qE has both %<extern%> and initializer", name);
5115 else if (current_scope == file_scope)
5117 if (storage_class == csc_auto)
5118 error_at (loc, "file-scope declaration of %qE specifies %<auto%>",
5120 if (pedantic && storage_class == csc_register)
5121 pedwarn (input_location, OPT_pedantic,
5122 "file-scope declaration of %qE specifies %<register%>", name);
5126 if (storage_class == csc_extern && funcdef_flag)
5127 error_at (loc, "nested function %qE declared %<extern%>", name);
5128 else if (threadp && storage_class == csc_none)
5130 error_at (loc, "function-scope %qE implicitly auto and declared "
5137 /* Now figure out the structure of the declarator proper.
5138 Descend through it, creating more complex types, until we reach
5139 the declared identifier (or NULL_TREE, in an absolute declarator).
5140 At each stage we maintain an unqualified version of the type
5141 together with any qualifiers that should be applied to it with
5142 c_build_qualified_type; this way, array types including
5143 multidimensional array types are first built up in unqualified
5144 form and then the qualified form is created with
5145 TYPE_MAIN_VARIANT pointing to the unqualified form. */
5147 while (declarator && declarator->kind != cdk_id)
5149 if (type == error_mark_node)
5151 declarator = declarator->declarator;
5155 /* Each level of DECLARATOR is either a cdk_array (for ...[..]),
5156 a cdk_pointer (for *...),
5157 a cdk_function (for ...(...)),
5158 a cdk_attrs (for nested attributes),
5159 or a cdk_id (for the name being declared
5160 or the place in an absolute declarator
5161 where the name was omitted).
5162 For the last case, we have just exited the loop.
5164 At this point, TYPE is the type of elements of an array,
5165 or for a function to return, or for a pointer to point to.
5166 After this sequence of ifs, TYPE is the type of the
5167 array or function or pointer, and DECLARATOR has had its
5168 outermost layer removed. */
5170 if (array_ptr_quals != TYPE_UNQUALIFIED
5171 || array_ptr_attrs != NULL_TREE
5172 || array_parm_static)
5174 /* Only the innermost declarator (making a parameter be of
5175 array type which is converted to pointer type)
5176 may have static or type qualifiers. */
5177 error_at (loc, "static or type qualifiers in non-parameter array declarator");
5178 array_ptr_quals = TYPE_UNQUALIFIED;
5179 array_ptr_attrs = NULL_TREE;
5180 array_parm_static = 0;
5183 switch (declarator->kind)
5187 /* A declarator with embedded attributes. */
5188 tree attrs = declarator->u.attrs;
5189 const struct c_declarator *inner_decl;
5191 declarator = declarator->declarator;
5192 inner_decl = declarator;
5193 while (inner_decl->kind == cdk_attrs)
5194 inner_decl = inner_decl->declarator;
5195 if (inner_decl->kind == cdk_id)
5196 attr_flags |= (int) ATTR_FLAG_DECL_NEXT;
5197 else if (inner_decl->kind == cdk_function)
5198 attr_flags |= (int) ATTR_FLAG_FUNCTION_NEXT;
5199 else if (inner_decl->kind == cdk_array)
5200 attr_flags |= (int) ATTR_FLAG_ARRAY_NEXT;
5201 returned_attrs = decl_attributes (&type,
5202 chainon (returned_attrs, attrs),
5208 tree itype = NULL_TREE;
5209 tree size = declarator->u.array.dimen;
5210 /* The index is a signed object `sizetype' bits wide. */
5211 tree index_type = c_common_signed_type (sizetype);
5213 array_ptr_quals = declarator->u.array.quals;
5214 array_ptr_attrs = declarator->u.array.attrs;
5215 array_parm_static = declarator->u.array.static_p;
5216 array_parm_vla_unspec_p = declarator->u.array.vla_unspec_p;
5218 declarator = declarator->declarator;
5220 /* Check for some types that there cannot be arrays of. */
5222 if (VOID_TYPE_P (type))
5225 error_at (loc, "declaration of %qE as array of voids", name);
5227 error_at (loc, "declaration of type name as array of voids");
5228 type = error_mark_node;
5231 if (TREE_CODE (type) == FUNCTION_TYPE)
5234 error_at (loc, "declaration of %qE as array of functions",
5237 error_at (loc, "declaration of type name as array of "
5239 type = error_mark_node;
5242 if (pedantic && !in_system_header && flexible_array_type_p (type))
5243 pedwarn (loc, OPT_pedantic,
5244 "invalid use of structure with flexible array member");
5246 if (size == error_mark_node)
5247 type = error_mark_node;
5249 if (type == error_mark_node)
5252 /* If size was specified, set ITYPE to a range-type for
5253 that size. Otherwise, ITYPE remains null. finish_decl
5254 may figure it out from an initial value. */
5258 bool size_maybe_const = true;
5259 bool size_int_const = (TREE_CODE (size) == INTEGER_CST
5260 && !TREE_OVERFLOW (size));
5261 bool this_size_varies = false;
5263 /* Strip NON_LVALUE_EXPRs since we aren't using as an
5265 STRIP_TYPE_NOPS (size);
5267 if (!INTEGRAL_TYPE_P (TREE_TYPE (size)))
5270 error_at (loc, "size of array %qE has non-integer type",
5274 "size of unnamed array has non-integer type");
5275 size = integer_one_node;
5278 size = c_fully_fold (size, false, &size_maybe_const);
5280 if (pedantic && size_maybe_const && integer_zerop (size))
5283 pedwarn (loc, OPT_pedantic,
5284 "ISO C forbids zero-size array %qE", name);
5286 pedwarn (loc, OPT_pedantic,
5287 "ISO C forbids zero-size array");
5290 if (TREE_CODE (size) == INTEGER_CST && size_maybe_const)
5292 constant_expression_warning (size);
5293 if (tree_int_cst_sgn (size) < 0)
5296 error_at (loc, "size of array %qE is negative", name);
5298 error_at (loc, "size of unnamed array is negative");
5299 size = integer_one_node;
5301 /* Handle a size folded to an integer constant but
5302 not an integer constant expression. */
5303 if (!size_int_const)
5305 /* If this is a file scope declaration of an
5306 ordinary identifier, this is invalid code;
5307 diagnosing it here and not subsequently
5308 treating the type as variable-length avoids
5309 more confusing diagnostics later. */
5310 if ((decl_context == NORMAL || decl_context == FIELD)
5311 && current_scope == file_scope)
5312 pedwarn (input_location, 0,
5313 "variably modified %qE at file scope",
5316 this_size_varies = size_varies = true;
5317 warn_variable_length_array (name, size);
5320 else if ((decl_context == NORMAL || decl_context == FIELD)
5321 && current_scope == file_scope)
5323 error_at (loc, "variably modified %qE at file scope", name);
5324 size = integer_one_node;
5328 /* Make sure the array size remains visibly
5329 nonconstant even if it is (eg) a const variable
5330 with known value. */
5331 this_size_varies = size_varies = true;
5332 warn_variable_length_array (name, size);
5335 if (integer_zerop (size) && !this_size_varies)
5337 /* A zero-length array cannot be represented with
5338 an unsigned index type, which is what we'll
5339 get with build_index_type. Create an
5340 open-ended range instead. */
5341 itype = build_range_type (sizetype, size, NULL_TREE);
5345 /* Arrange for the SAVE_EXPR on the inside of the
5346 MINUS_EXPR, which allows the -1 to get folded
5347 with the +1 that happens when building TYPE_SIZE. */
5349 size = c_variable_size (size);
5350 if (this_size_varies && TREE_CODE (size) == INTEGER_CST)
5351 size = build2 (COMPOUND_EXPR, TREE_TYPE (size),
5352 integer_zero_node, size);
5354 /* Compute the maximum valid index, that is, size
5355 - 1. Do the calculation in index_type, so that
5356 if it is a variable the computations will be
5357 done in the proper mode. */
5358 itype = fold_build2_loc (loc, MINUS_EXPR, index_type,
5359 convert (index_type, size),
5360 convert (index_type,
5363 /* If that overflowed, the array is too big. ???
5364 While a size of INT_MAX+1 technically shouldn't
5365 cause an overflow (because we subtract 1), the
5366 overflow is recorded during the conversion to
5367 index_type, before the subtraction. Handling
5368 this case seems like an unnecessary
5370 if (TREE_CODE (itype) == INTEGER_CST
5371 && TREE_OVERFLOW (itype))
5374 error_at (loc, "size of array %qE is too large",
5377 error_at (loc, "size of unnamed array is too large");
5378 type = error_mark_node;
5382 itype = build_index_type (itype);
5384 if (this_size_varies)
5387 *expr = build2 (COMPOUND_EXPR, TREE_TYPE (size),
5391 *expr_const_operands &= size_maybe_const;
5394 else if (decl_context == FIELD)
5396 bool flexible_array_member = false;
5397 if (array_parm_vla_unspec_p)
5398 /* Field names can in fact have function prototype
5399 scope so [*] is disallowed here through making
5400 the field variably modified, not through being
5401 something other than a declaration with function
5406 const struct c_declarator *t = declarator;
5407 while (t->kind == cdk_attrs)
5409 flexible_array_member = (t->kind == cdk_id);
5411 if (flexible_array_member
5412 && pedantic && !flag_isoc99 && !in_system_header)
5413 pedwarn (loc, OPT_pedantic,
5414 "ISO C90 does not support flexible array members");
5416 /* ISO C99 Flexible array members are effectively
5417 identical to GCC's zero-length array extension. */
5418 if (flexible_array_member || array_parm_vla_unspec_p)
5419 itype = build_range_type (sizetype, size_zero_node,
5422 else if (decl_context == PARM)
5424 if (array_parm_vla_unspec_p)
5426 itype = build_range_type (sizetype, size_zero_node, NULL_TREE);
5430 else if (decl_context == TYPENAME)
5432 if (array_parm_vla_unspec_p)
5435 warning (0, "%<[*]%> not in a declaration");
5436 /* We use this to avoid messing up with incomplete
5437 array types of the same type, that would
5438 otherwise be modified below. */
5439 itype = build_range_type (sizetype, size_zero_node,
5445 /* Complain about arrays of incomplete types. */
5446 if (!COMPLETE_TYPE_P (type))
5448 error_at (loc, "array type has incomplete element type");
5449 type = error_mark_node;
5452 /* When itype is NULL, a shared incomplete array type is
5453 returned for all array of a given type. Elsewhere we
5454 make sure we don't complete that type before copying
5455 it, but here we want to make sure we don't ever
5456 modify the shared type, so we gcc_assert (itype)
5459 addr_space_t as = DECODE_QUAL_ADDR_SPACE (type_quals);
5460 if (!ADDR_SPACE_GENERIC_P (as) && as != TYPE_ADDR_SPACE (type))
5461 type = build_qualified_type (type,
5462 ENCODE_QUAL_ADDR_SPACE (as));
5464 type = build_array_type (type, itype);
5467 if (type != error_mark_node)
5471 /* It is ok to modify type here even if itype is
5472 NULL: if size_varies, we're in a
5473 multi-dimensional array and the inner type has
5474 variable size, so the enclosing shared array type
5476 if (size && TREE_CODE (size) == INTEGER_CST)
5478 = build_distinct_type_copy (TYPE_MAIN_VARIANT (type));
5479 C_TYPE_VARIABLE_SIZE (type) = 1;
5482 /* The GCC extension for zero-length arrays differs from
5483 ISO flexible array members in that sizeof yields
5485 if (size && integer_zerop (size))
5488 type = build_distinct_type_copy (TYPE_MAIN_VARIANT (type));
5489 TYPE_SIZE (type) = bitsize_zero_node;
5490 TYPE_SIZE_UNIT (type) = size_zero_node;
5491 SET_TYPE_STRUCTURAL_EQUALITY (type);
5493 if (array_parm_vla_unspec_p)
5496 /* The type is complete. C99 6.7.5.2p4 */
5497 type = build_distinct_type_copy (TYPE_MAIN_VARIANT (type));
5498 TYPE_SIZE (type) = bitsize_zero_node;
5499 TYPE_SIZE_UNIT (type) = size_zero_node;
5500 SET_TYPE_STRUCTURAL_EQUALITY (type);
5504 if (decl_context != PARM
5505 && (array_ptr_quals != TYPE_UNQUALIFIED
5506 || array_ptr_attrs != NULL_TREE
5507 || array_parm_static))
5509 error_at (loc, "static or type qualifiers in non-parameter array declarator");
5510 array_ptr_quals = TYPE_UNQUALIFIED;
5511 array_ptr_attrs = NULL_TREE;
5512 array_parm_static = 0;
5518 /* Say it's a definition only for the declarator closest
5519 to the identifier, apart possibly from some
5521 bool really_funcdef = false;
5525 const struct c_declarator *t = declarator->declarator;
5526 while (t->kind == cdk_attrs)
5528 really_funcdef = (t->kind == cdk_id);
5531 /* Declaring a function type. Make sure we have a valid
5532 type for the function to return. */
5533 if (type == error_mark_node)
5536 size_varies = false;
5538 /* Warn about some types functions can't return. */
5539 if (TREE_CODE (type) == FUNCTION_TYPE)
5542 error_at (loc, "%qE declared as function returning a "
5545 error_at (loc, "type name declared as function "
5546 "returning a function");
5547 type = integer_type_node;
5549 if (TREE_CODE (type) == ARRAY_TYPE)
5552 error_at (loc, "%qE declared as function returning an array",
5555 error_at (loc, "type name declared as function returning "
5557 type = integer_type_node;
5559 errmsg = targetm.invalid_return_type (type);
5563 type = integer_type_node;
5566 /* Construct the function type and go to the next
5567 inner layer of declarator. */
5568 arg_info = declarator->u.arg_info;
5569 arg_types = grokparms (arg_info, really_funcdef);
5571 put_pending_sizes (arg_info->pending_sizes);
5573 /* Type qualifiers before the return type of the function
5574 qualify the return type, not the function type. */
5577 /* Type qualifiers on a function return type are
5578 normally permitted by the standard but have no
5579 effect, so give a warning at -Wreturn-type.
5580 Qualifiers on a void return type are banned on
5581 function definitions in ISO C; GCC used to used
5582 them for noreturn functions. */
5583 if (VOID_TYPE_P (type) && really_funcdef)
5585 "function definition has qualified void return type");
5587 warning_at (loc, OPT_Wignored_qualifiers,
5588 "type qualifiers ignored on function return type");
5590 type = c_build_qualified_type (type, type_quals);
5592 type_quals = TYPE_UNQUALIFIED;
5594 type = build_function_type (type, arg_types);
5595 declarator = declarator->declarator;
5597 /* Set the TYPE_CONTEXTs for each tagged type which is local to
5598 the formal parameter list of this FUNCTION_TYPE to point to
5599 the FUNCTION_TYPE node itself. */
5604 FOR_EACH_VEC_ELT_REVERSE (c_arg_tag, arg_info->tags, ix, tag)
5605 TYPE_CONTEXT (tag->type) = type;
5611 /* Merge any constancy or volatility into the target type
5614 if (pedantic && TREE_CODE (type) == FUNCTION_TYPE
5616 pedwarn (loc, OPT_pedantic,
5617 "ISO C forbids qualified function types");
5619 type = c_build_qualified_type (type, type_quals);
5620 size_varies = false;
5622 /* When the pointed-to type involves components of variable size,
5623 care must be taken to ensure that the size evaluation code is
5624 emitted early enough to dominate all the possible later uses
5625 and late enough for the variables on which it depends to have
5628 This is expected to happen automatically when the pointed-to
5629 type has a name/declaration of it's own, but special attention
5630 is required if the type is anonymous.
5632 We handle the NORMAL and FIELD contexts here by attaching an
5633 artificial TYPE_DECL to such pointed-to type. This forces the
5634 sizes evaluation at a safe point and ensures it is not deferred
5635 until e.g. within a deeper conditional context.
5637 We expect nothing to be needed here for PARM or TYPENAME.
5638 Pushing a TYPE_DECL at this point for TYPENAME would actually
5639 be incorrect, as we might be in the middle of an expression
5640 with side effects on the pointed-to type size "arguments" prior
5641 to the pointer declaration point and the fake TYPE_DECL in the
5642 enclosing context would force the size evaluation prior to the
5645 if (!TYPE_NAME (type)
5646 && (decl_context == NORMAL || decl_context == FIELD)
5647 && variably_modified_type_p (type, NULL_TREE))
5649 tree decl = build_decl (loc, TYPE_DECL, NULL_TREE, type);
5650 DECL_ARTIFICIAL (decl) = 1;
5652 finish_decl (decl, loc, NULL_TREE, NULL_TREE, NULL_TREE);
5653 TYPE_NAME (type) = decl;
5656 type = build_pointer_type (type);
5658 /* Process type qualifiers (such as const or volatile)
5659 that were given inside the `*'. */
5660 type_quals = declarator->u.pointer_quals;
5662 declarator = declarator->declarator;
5669 *decl_attrs = chainon (returned_attrs, *decl_attrs);
5671 /* Now TYPE has the actual type, apart from any qualifiers in
5674 /* Warn about address space used for things other than static memory or
5676 address_space = DECODE_QUAL_ADDR_SPACE (type_quals);
5677 if (!ADDR_SPACE_GENERIC_P (address_space))
5679 if (decl_context == NORMAL)
5681 switch (storage_class)
5684 error ("%qs combined with %<auto%> qualifier for %qE",
5685 c_addr_space_name (address_space), name);
5688 error ("%qs combined with %<register%> qualifier for %qE",
5689 c_addr_space_name (address_space), name);
5692 if (current_function_scope)
5694 error ("%qs specified for auto variable %qE",
5695 c_addr_space_name (address_space), name);
5707 else if (decl_context == PARM && TREE_CODE (type) != ARRAY_TYPE)
5710 error ("%qs specified for parameter %qE",
5711 c_addr_space_name (address_space), name);
5713 error ("%qs specified for unnamed parameter",
5714 c_addr_space_name (address_space));
5716 else if (decl_context == FIELD)
5719 error ("%qs specified for structure field %qE",
5720 c_addr_space_name (address_space), name);
5722 error ("%qs specified for structure field",
5723 c_addr_space_name (address_space));
5727 /* Check the type and width of a bit-field. */
5729 check_bitfield_type_and_width (&type, width, name);
5731 /* Did array size calculations overflow? */
5733 if (TREE_CODE (type) == ARRAY_TYPE
5734 && COMPLETE_TYPE_P (type)
5735 && TREE_CODE (TYPE_SIZE_UNIT (type)) == INTEGER_CST
5736 && TREE_OVERFLOW (TYPE_SIZE_UNIT (type)))
5739 error_at (loc, "size of array %qE is too large", name);
5741 error_at (loc, "size of unnamed array is too large");
5742 /* If we proceed with the array type as it is, we'll eventually
5743 crash in tree_low_cst(). */
5744 type = error_mark_node;
5747 /* If this is declaring a typedef name, return a TYPE_DECL. */
5749 if (storage_class == csc_typedef)
5752 if (pedantic && TREE_CODE (type) == FUNCTION_TYPE
5754 pedwarn (loc, OPT_pedantic,
5755 "ISO C forbids qualified function types");
5757 type = c_build_qualified_type (type, type_quals);
5758 decl = build_decl (declarator->id_loc,
5759 TYPE_DECL, declarator->u.id, type);
5760 if (declspecs->explicit_signed_p)
5761 C_TYPEDEF_EXPLICITLY_SIGNED (decl) = 1;
5762 if (declspecs->inline_p)
5763 pedwarn (loc, 0,"typedef %q+D declared %<inline%>", decl);
5765 if (warn_cxx_compat && declarator->u.id != NULL_TREE)
5767 struct c_binding *b = I_TAG_BINDING (declarator->u.id);
5770 && b->decl != NULL_TREE
5771 && (B_IN_CURRENT_SCOPE (b)
5772 || (current_scope == file_scope && B_IN_EXTERNAL_SCOPE (b)))
5773 && TYPE_MAIN_VARIANT (b->decl) != TYPE_MAIN_VARIANT (type))
5775 warning_at (declarator->id_loc, OPT_Wc___compat,
5776 ("using %qD as both a typedef and a tag is "
5779 if (b->locus != UNKNOWN_LOCATION)
5780 inform (b->locus, "originally defined here");
5787 /* If this is a type name (such as, in a cast or sizeof),
5788 compute the type and return it now. */
5790 if (decl_context == TYPENAME)
5792 /* Note that the grammar rejects storage classes in typenames
5794 gcc_assert (storage_class == csc_none && !threadp
5795 && !declspecs->inline_p);
5796 if (pedantic && TREE_CODE (type) == FUNCTION_TYPE
5798 pedwarn (loc, OPT_pedantic,
5799 "ISO C forbids const or volatile function types");
5801 type = c_build_qualified_type (type, type_quals);
5805 if (pedantic && decl_context == FIELD
5806 && variably_modified_type_p (type, NULL_TREE))
5809 pedwarn (loc, OPT_pedantic, "a member of a structure or union cannot "
5810 "have a variably modified type");
5813 /* Aside from typedefs and type names (handle above),
5814 `void' at top level (not within pointer)
5815 is allowed only in public variables.
5816 We don't complain about parms either, but that is because
5817 a better error message can be made later. */
5819 if (VOID_TYPE_P (type) && decl_context != PARM
5820 && !((decl_context != FIELD && TREE_CODE (type) != FUNCTION_TYPE)
5821 && (storage_class == csc_extern
5822 || (current_scope == file_scope
5823 && !(storage_class == csc_static
5824 || storage_class == csc_register)))))
5826 error_at (loc, "variable or field %qE declared void", name);
5827 type = integer_type_node;
5830 /* Now create the decl, which may be a VAR_DECL, a PARM_DECL
5831 or a FUNCTION_DECL, depending on DECL_CONTEXT and TYPE. */
5836 if (decl_context == PARM)
5840 /* A parameter declared as an array of T is really a pointer to T.
5841 One declared as a function is really a pointer to a function. */
5843 if (TREE_CODE (type) == ARRAY_TYPE)
5845 /* Transfer const-ness of array into that of type pointed to. */
5846 type = TREE_TYPE (type);
5848 type = c_build_qualified_type (type, type_quals);
5849 type = build_pointer_type (type);
5850 type_quals = array_ptr_quals;
5852 type = c_build_qualified_type (type, type_quals);
5854 /* We don't yet implement attributes in this context. */
5855 if (array_ptr_attrs != NULL_TREE)
5856 warning_at (loc, OPT_Wattributes,
5857 "attributes in parameter array declarator ignored");
5859 size_varies = false;
5861 else if (TREE_CODE (type) == FUNCTION_TYPE)
5864 pedwarn (loc, OPT_pedantic,
5865 "ISO C forbids qualified function types");
5867 type = c_build_qualified_type (type, type_quals);
5868 type = build_pointer_type (type);
5869 type_quals = TYPE_UNQUALIFIED;
5871 else if (type_quals)
5872 type = c_build_qualified_type (type, type_quals);
5874 decl = build_decl (declarator->id_loc,
5875 PARM_DECL, declarator->u.id, type);
5877 C_DECL_VARIABLE_SIZE (decl) = 1;
5879 /* Compute the type actually passed in the parmlist,
5880 for the case where there is no prototype.
5881 (For example, shorts and chars are passed as ints.)
5882 When there is a prototype, this is overridden later. */
5884 if (type == error_mark_node)
5885 promoted_type = type;
5887 promoted_type = c_type_promotes_to (type);
5889 DECL_ARG_TYPE (decl) = promoted_type;
5890 if (declspecs->inline_p)
5891 pedwarn (loc, 0, "parameter %q+D declared %<inline%>", decl);
5893 else if (decl_context == FIELD)
5895 /* Note that the grammar rejects storage classes in typenames
5897 gcc_assert (storage_class == csc_none && !threadp
5898 && !declspecs->inline_p);
5900 /* Structure field. It may not be a function. */
5902 if (TREE_CODE (type) == FUNCTION_TYPE)
5904 error_at (loc, "field %qE declared as a function", name);
5905 type = build_pointer_type (type);
5907 else if (TREE_CODE (type) != ERROR_MARK
5908 && !COMPLETE_OR_UNBOUND_ARRAY_TYPE_P (type))
5911 error_at (loc, "field %qE has incomplete type", name);
5913 error_at (loc, "unnamed field has incomplete type");
5914 type = error_mark_node;
5916 type = c_build_qualified_type (type, type_quals);
5917 decl = build_decl (declarator->id_loc,
5918 FIELD_DECL, declarator->u.id, type);
5919 DECL_NONADDRESSABLE_P (decl) = bitfield;
5920 if (bitfield && !declarator->u.id)
5921 TREE_NO_WARNING (decl) = 1;
5924 C_DECL_VARIABLE_SIZE (decl) = 1;
5926 else if (TREE_CODE (type) == FUNCTION_TYPE)
5928 if (storage_class == csc_register || threadp)
5930 error_at (loc, "invalid storage class for function %qE", name);
5932 else if (current_scope != file_scope)
5934 /* Function declaration not at file scope. Storage
5935 classes other than `extern' are not allowed, C99
5936 6.7.1p5, and `extern' makes no difference. However,
5937 GCC allows 'auto', perhaps with 'inline', to support
5938 nested functions. */
5939 if (storage_class == csc_auto)
5940 pedwarn (loc, OPT_pedantic,
5941 "invalid storage class for function %qE", name);
5942 else if (storage_class == csc_static)
5944 error_at (loc, "invalid storage class for function %qE", name);
5946 storage_class = declspecs->storage_class = csc_none;
5952 decl = build_decl (declarator->id_loc,
5953 FUNCTION_DECL, declarator->u.id, type);
5954 decl = build_decl_attribute_variant (decl, decl_attr);
5956 if (pedantic && type_quals && !DECL_IN_SYSTEM_HEADER (decl))
5957 pedwarn (loc, OPT_pedantic,
5958 "ISO C forbids qualified function types");
5960 /* Every function declaration is an external reference
5961 (DECL_EXTERNAL) except for those which are not at file
5962 scope and are explicitly declared "auto". This is
5963 forbidden by standard C (C99 6.7.1p5) and is interpreted by
5964 GCC to signify a forward declaration of a nested function. */
5965 if (storage_class == csc_auto && current_scope != file_scope)
5966 DECL_EXTERNAL (decl) = 0;
5967 /* In C99, a function which is declared 'inline' with 'extern'
5968 is not an external reference (which is confusing). It
5969 means that the later definition of the function must be output
5970 in this file, C99 6.7.4p6. In GNU C89, a function declared
5971 'extern inline' is an external reference. */
5972 else if (declspecs->inline_p && storage_class != csc_static)
5973 DECL_EXTERNAL (decl) = ((storage_class == csc_extern)
5974 == flag_gnu89_inline);
5976 DECL_EXTERNAL (decl) = !initialized;
5978 /* Record absence of global scope for `static' or `auto'. */
5980 = !(storage_class == csc_static || storage_class == csc_auto);
5982 /* For a function definition, record the argument information
5983 block where store_parm_decls will look for it. */
5985 current_function_arg_info = arg_info;
5987 if (declspecs->default_int_p)
5988 C_FUNCTION_IMPLICIT_INT (decl) = 1;
5990 /* Record presence of `inline', if it is reasonable. */
5991 if (flag_hosted && MAIN_NAME_P (declarator->u.id))
5993 if (declspecs->inline_p)
5994 pedwarn (loc, 0, "cannot inline function %<main%>");
5996 else if (declspecs->inline_p)
5997 /* Record that the function is declared `inline'. */
5998 DECL_DECLARED_INLINE_P (decl) = 1;
6002 /* It's a variable. */
6003 /* An uninitialized decl with `extern' is a reference. */
6004 int extern_ref = !initialized && storage_class == csc_extern;
6006 type = c_build_qualified_type (type, type_quals);
6008 /* C99 6.2.2p7: It is invalid (compile-time undefined
6009 behavior) to create an 'extern' declaration for a
6010 variable if there is a global declaration that is
6011 'static' and the global declaration is not visible.
6012 (If the static declaration _is_ currently visible,
6013 the 'extern' declaration is taken to refer to that decl.) */
6014 if (extern_ref && current_scope != file_scope)
6016 tree global_decl = identifier_global_value (declarator->u.id);
6017 tree visible_decl = lookup_name (declarator->u.id);
6020 && global_decl != visible_decl
6021 && TREE_CODE (global_decl) == VAR_DECL
6022 && !TREE_PUBLIC (global_decl))
6023 error_at (loc, "variable previously declared %<static%> "
6024 "redeclared %<extern%>");
6027 decl = build_decl (declarator->id_loc,
6028 VAR_DECL, declarator->u.id, type);
6030 C_DECL_VARIABLE_SIZE (decl) = 1;
6032 if (declspecs->inline_p)
6033 pedwarn (loc, 0, "variable %q+D declared %<inline%>", decl);
6035 /* At file scope, an initialized extern declaration may follow
6036 a static declaration. In that case, DECL_EXTERNAL will be
6037 reset later in start_decl. */
6038 DECL_EXTERNAL (decl) = (storage_class == csc_extern);
6040 /* At file scope, the presence of a `static' or `register' storage
6041 class specifier, or the absence of all storage class specifiers
6042 makes this declaration a definition (perhaps tentative). Also,
6043 the absence of `static' makes it public. */
6044 if (current_scope == file_scope)
6046 TREE_PUBLIC (decl) = storage_class != csc_static;
6047 TREE_STATIC (decl) = !extern_ref;
6049 /* Not at file scope, only `static' makes a static definition. */
6052 TREE_STATIC (decl) = (storage_class == csc_static);
6053 TREE_PUBLIC (decl) = extern_ref;
6057 DECL_TLS_MODEL (decl) = decl_default_tls_model (decl);
6060 if ((storage_class == csc_extern
6061 || (storage_class == csc_none
6062 && TREE_CODE (type) == FUNCTION_TYPE
6064 && variably_modified_type_p (type, NULL_TREE))
6067 if (TREE_CODE (type) == FUNCTION_TYPE)
6068 error_at (loc, "non-nested function with variably modified type");
6070 error_at (loc, "object with variably modified type must have "
6074 /* Record `register' declaration for warnings on &
6075 and in case doing stupid register allocation. */
6077 if (storage_class == csc_register)
6079 C_DECL_REGISTER (decl) = 1;
6080 DECL_REGISTER (decl) = 1;
6083 /* Record constancy and volatility. */
6084 c_apply_type_quals_to_decl (type_quals, decl);
6086 /* If a type has volatile components, it should be stored in memory.
6087 Otherwise, the fact that those components are volatile
6088 will be ignored, and would even crash the compiler.
6089 Of course, this only makes sense on VAR,PARM, and RESULT decl's. */
6090 if (C_TYPE_FIELDS_VOLATILE (TREE_TYPE (decl))
6091 && (TREE_CODE (decl) == VAR_DECL || TREE_CODE (decl) == PARM_DECL
6092 || TREE_CODE (decl) == RESULT_DECL))
6094 /* It is not an error for a structure with volatile fields to
6095 be declared register, but reset DECL_REGISTER since it
6096 cannot actually go in a register. */
6097 int was_reg = C_DECL_REGISTER (decl);
6098 C_DECL_REGISTER (decl) = 0;
6099 DECL_REGISTER (decl) = 0;
6100 c_mark_addressable (decl);
6101 C_DECL_REGISTER (decl) = was_reg;
6104 /* This is the earliest point at which we might know the assembler
6105 name of a variable. Thus, if it's known before this, die horribly. */
6106 gcc_assert (!DECL_ASSEMBLER_NAME_SET_P (decl));
6109 && TREE_CODE (decl) == VAR_DECL
6110 && TREE_PUBLIC (decl)
6111 && TREE_STATIC (decl)
6112 && (TREE_CODE (TREE_TYPE (decl)) == RECORD_TYPE
6113 || TREE_CODE (TREE_TYPE (decl)) == UNION_TYPE
6114 || TREE_CODE (TREE_TYPE (decl)) == ENUMERAL_TYPE)
6115 && TYPE_NAME (TREE_TYPE (decl)) == NULL_TREE)
6116 warning_at (DECL_SOURCE_LOCATION (decl), OPT_Wc___compat,
6117 ("non-local variable %qD with anonymous type is "
6118 "questionable in C++"),
6125 /* Decode the parameter-list info for a function type or function definition.
6126 The argument is the value returned by `get_parm_info' (or made in c-parse.c
6127 if there is an identifier list instead of a parameter decl list).
6128 These two functions are separate because when a function returns
6129 or receives functions then each is called multiple times but the order
6130 of calls is different. The last call to `grokparms' is always the one
6131 that contains the formal parameter names of a function definition.
6133 Return a list of arg types to use in the FUNCTION_TYPE for this function.
6135 FUNCDEF_FLAG is true for a function definition, false for
6136 a mere declaration. A nonempty identifier-list gets an error message
6137 when FUNCDEF_FLAG is false. */
6140 grokparms (struct c_arg_info *arg_info, bool funcdef_flag)
6142 tree arg_types = arg_info->types;
6144 if (funcdef_flag && arg_info->had_vla_unspec)
6146 /* A function definition isn't function prototype scope C99 6.2.1p4. */
6148 error ("%<[*]%> not allowed in other than function prototype scope");
6151 if (arg_types == 0 && !funcdef_flag && !in_system_header)
6152 warning (OPT_Wstrict_prototypes,
6153 "function declaration isn%'t a prototype");
6155 if (arg_types == error_mark_node)
6156 return 0; /* don't set TYPE_ARG_TYPES in this case */
6158 else if (arg_types && TREE_CODE (TREE_VALUE (arg_types)) == IDENTIFIER_NODE)
6162 pedwarn (input_location, 0, "parameter names (without types) in function declaration");
6163 arg_info->parms = NULL_TREE;
6166 arg_info->parms = arg_info->types;
6168 arg_info->types = 0;
6173 tree parm, type, typelt;
6174 unsigned int parmno;
6177 /* If there is a parameter of incomplete type in a definition,
6178 this is an error. In a declaration this is valid, and a
6179 struct or union type may be completed later, before any calls
6180 or definition of the function. In the case where the tag was
6181 first declared within the parameter list, a warning has
6182 already been given. If a parameter has void type, then
6183 however the function cannot be defined or called, so
6186 for (parm = arg_info->parms, typelt = arg_types, parmno = 1;
6188 parm = DECL_CHAIN (parm), typelt = TREE_CHAIN (typelt), parmno++)
6190 type = TREE_VALUE (typelt);
6191 if (type == error_mark_node)
6194 if (!COMPLETE_TYPE_P (type))
6198 if (DECL_NAME (parm))
6199 error_at (input_location,
6200 "parameter %u (%q+D) has incomplete type",
6203 error_at (DECL_SOURCE_LOCATION (parm),
6204 "parameter %u has incomplete type",
6207 TREE_VALUE (typelt) = error_mark_node;
6208 TREE_TYPE (parm) = error_mark_node;
6209 arg_types = NULL_TREE;
6211 else if (VOID_TYPE_P (type))
6213 if (DECL_NAME (parm))
6214 warning_at (input_location, 0,
6215 "parameter %u (%q+D) has void type",
6218 warning_at (DECL_SOURCE_LOCATION (parm), 0,
6219 "parameter %u has void type",
6224 errmsg = targetm.invalid_parameter_type (type);
6228 TREE_VALUE (typelt) = error_mark_node;
6229 TREE_TYPE (parm) = error_mark_node;
6230 arg_types = NULL_TREE;
6233 if (DECL_NAME (parm) && TREE_USED (parm))
6234 warn_if_shadowing (parm);
6240 /* Allocate and initialize a c_arg_info structure from the parser's
6244 build_arg_info (void)
6246 struct c_arg_info *ret = XOBNEW (&parser_obstack, struct c_arg_info);
6247 ret->parms = NULL_TREE;
6249 ret->types = NULL_TREE;
6250 ret->others = NULL_TREE;
6251 ret->pending_sizes = NULL;
6252 ret->had_vla_unspec = 0;
6256 /* Take apart the current scope and return a c_arg_info structure with
6257 info on a parameter list just parsed.
6259 This structure is later fed to 'grokparms' and 'store_parm_decls'.
6261 ELLIPSIS being true means the argument list ended in '...' so don't
6262 append a sentinel (void_list_node) to the end of the type-list. */
6265 get_parm_info (bool ellipsis)
6267 struct c_binding *b = current_scope->bindings;
6268 struct c_arg_info *arg_info = build_arg_info ();
6271 VEC(c_arg_tag,gc) *tags = NULL;
6275 static bool explained_incomplete_types = false;
6276 bool gave_void_only_once_err = false;
6278 arg_info->had_vla_unspec = current_scope->had_vla_unspec;
6280 /* The bindings in this scope must not get put into a block.
6281 We will take care of deleting the binding nodes. */
6282 current_scope->bindings = 0;
6284 /* This function is only called if there was *something* on the
6288 /* A parameter list consisting solely of 'void' indicates that the
6289 function takes no arguments. But if the 'void' is qualified
6290 (by 'const' or 'volatile'), or has a storage class specifier
6291 ('register'), then the behavior is undefined; issue an error.
6292 Typedefs for 'void' are OK (see DR#157). */
6293 if (b->prev == 0 /* one binding */
6294 && TREE_CODE (b->decl) == PARM_DECL /* which is a parameter */
6295 && !DECL_NAME (b->decl) /* anonymous */
6296 && VOID_TYPE_P (TREE_TYPE (b->decl))) /* of void type */
6298 if (TREE_THIS_VOLATILE (b->decl)
6299 || TREE_READONLY (b->decl)
6300 || C_DECL_REGISTER (b->decl))
6301 error ("%<void%> as only parameter may not be qualified");
6303 /* There cannot be an ellipsis. */
6305 error ("%<void%> must be the only parameter");
6307 arg_info->types = void_list_node;
6312 types = void_list_node;
6314 /* Break up the bindings list into parms, tags, types, and others;
6315 apply sanity checks; purge the name-to-decl bindings. */
6318 tree decl = b->decl;
6319 tree type = TREE_TYPE (decl);
6321 const char *keyword;
6323 switch (TREE_CODE (decl))
6328 gcc_assert (I_SYMBOL_BINDING (b->id) == b);
6329 I_SYMBOL_BINDING (b->id) = b->shadowed;
6332 /* Check for forward decls that never got their actual decl. */
6333 if (TREE_ASM_WRITTEN (decl))
6334 error ("parameter %q+D has just a forward declaration", decl);
6335 /* Check for (..., void, ...) and issue an error. */
6336 else if (VOID_TYPE_P (type) && !DECL_NAME (decl))
6338 if (!gave_void_only_once_err)
6340 error ("%<void%> must be the only parameter");
6341 gave_void_only_once_err = true;
6346 /* Valid parameter, add it to the list. */
6347 DECL_CHAIN (decl) = parms;
6350 /* Since there is a prototype, args are passed in their
6351 declared types. The back end may override this later. */
6352 DECL_ARG_TYPE (decl) = type;
6353 types = tree_cons (0, type, types);
6357 case ENUMERAL_TYPE: keyword = "enum"; goto tag;
6358 case UNION_TYPE: keyword = "union"; goto tag;
6359 case RECORD_TYPE: keyword = "struct"; goto tag;
6361 /* Types may not have tag-names, in which case the type
6362 appears in the bindings list with b->id NULL. */
6365 gcc_assert (I_TAG_BINDING (b->id) == b);
6366 I_TAG_BINDING (b->id) = b->shadowed;
6369 /* Warn about any struct, union or enum tags defined in a
6370 parameter list. The scope of such types is limited to
6371 the parameter list, which is rarely if ever desirable
6372 (it's impossible to call such a function with type-
6373 correct arguments). An anonymous union parm type is
6374 meaningful as a GNU extension, so don't warn for that. */
6375 if (TREE_CODE (decl) != UNION_TYPE || b->id != 0)
6378 /* The %s will be one of 'struct', 'union', or 'enum'. */
6379 warning (0, "%<%s %E%> declared inside parameter list",
6382 /* The %s will be one of 'struct', 'union', or 'enum'. */
6383 warning (0, "anonymous %s declared inside parameter list",
6386 if (!explained_incomplete_types)
6388 warning (0, "its scope is only this definition or declaration,"
6389 " which is probably not what you want");
6390 explained_incomplete_types = true;
6394 tag = VEC_safe_push (c_arg_tag, gc, tags, NULL);
6402 /* CONST_DECLs appear here when we have an embedded enum,
6403 and TYPE_DECLs appear here when we have an embedded struct
6404 or union. No warnings for this - we already warned about the
6405 type itself. FUNCTION_DECLs appear when there is an implicit
6406 function declaration in the parameter list. */
6408 /* When we reinsert this decl in the function body, we need
6409 to reconstruct whether it was marked as nested. */
6410 gcc_assert (TREE_CODE (decl) == FUNCTION_DECL
6413 DECL_CHAIN (decl) = others;
6418 /* error_mark_node appears here when we have an undeclared
6419 variable. Just throw it away. */
6422 gcc_assert (I_SYMBOL_BINDING (b->id) == b);
6423 I_SYMBOL_BINDING (b->id) = b->shadowed;
6427 /* Other things that might be encountered. */
6434 b = free_binding_and_advance (b);
6437 arg_info->parms = parms;
6438 arg_info->tags = tags;
6439 arg_info->types = types;
6440 arg_info->others = others;
6441 arg_info->pending_sizes = get_pending_sizes ();
6445 /* Get the struct, enum or union (CODE says which) with tag NAME.
6446 Define the tag as a forward-reference with location LOC if it is
6447 not defined. Return a c_typespec structure for the type
6451 parser_xref_tag (location_t loc, enum tree_code code, tree name)
6453 struct c_typespec ret;
6457 ret.expr = NULL_TREE;
6458 ret.expr_const_operands = true;
6460 /* If a cross reference is requested, look up the type
6461 already defined for this tag and return it. */
6463 ref = lookup_tag (code, name, 0, &refloc);
6464 /* If this is the right type of tag, return what we found.
6465 (This reference will be shadowed by shadow_tag later if appropriate.)
6466 If this is the wrong type of tag, do not return it. If it was the
6467 wrong type in the same scope, we will have had an error
6468 message already; if in a different scope and declaring
6469 a name, pending_xref_error will give an error message; but if in a
6470 different scope and not declaring a name, this tag should
6471 shadow the previous declaration of a different type of tag, and
6472 this would not work properly if we return the reference found.
6473 (For example, with "struct foo" in an outer scope, "union foo;"
6474 must shadow that tag with a new one of union type.) */
6475 ret.kind = (ref ? ctsk_tagref : ctsk_tagfirstref);
6476 if (ref && TREE_CODE (ref) == code)
6478 if (C_TYPE_DEFINED_IN_STRUCT (ref)
6479 && loc != UNKNOWN_LOCATION
6485 warning_at (loc, OPT_Wc___compat,
6486 ("enum type defined in struct or union "
6487 "is not visible in C++"));
6488 inform (refloc, "enum type defined here");
6491 warning_at (loc, OPT_Wc___compat,
6492 ("struct defined in struct or union "
6493 "is not visible in C++"));
6494 inform (refloc, "struct defined here");
6497 warning_at (loc, OPT_Wc___compat,
6498 ("union defined in struct or union "
6499 "is not visible in C++"));
6500 inform (refloc, "union defined here");
6511 /* If no such tag is yet defined, create a forward-reference node
6512 and record it as the "definition".
6513 When a real declaration of this type is found,
6514 the forward-reference will be altered into a real type. */
6516 ref = make_node (code);
6517 if (code == ENUMERAL_TYPE)
6519 /* Give the type a default layout like unsigned int
6520 to avoid crashing if it does not get defined. */
6521 SET_TYPE_MODE (ref, TYPE_MODE (unsigned_type_node));
6522 TYPE_ALIGN (ref) = TYPE_ALIGN (unsigned_type_node);
6523 TYPE_USER_ALIGN (ref) = 0;
6524 TYPE_UNSIGNED (ref) = 1;
6525 TYPE_PRECISION (ref) = TYPE_PRECISION (unsigned_type_node);
6526 TYPE_MIN_VALUE (ref) = TYPE_MIN_VALUE (unsigned_type_node);
6527 TYPE_MAX_VALUE (ref) = TYPE_MAX_VALUE (unsigned_type_node);
6530 pushtag (loc, name, ref);
6536 /* Get the struct, enum or union (CODE says which) with tag NAME.
6537 Define the tag as a forward-reference if it is not defined.
6538 Return a tree for the type. */
6541 xref_tag (enum tree_code code, tree name)
6543 return parser_xref_tag (input_location, code, name).spec;
6546 /* Make sure that the tag NAME is defined *in the current scope*
6547 at least as a forward reference.
6548 LOC is the location of the struct's definition.
6549 CODE says which kind of tag NAME ought to be.
6551 This stores the current value of the file static STRUCT_PARSE_INFO
6552 in *ENCLOSING_STRUCT_PARSE_INFO, and points STRUCT_PARSE_INFO at a
6553 new c_struct_parse_info structure. The old value of
6554 STRUCT_PARSE_INFO is restored in finish_struct. */
6557 start_struct (location_t loc, enum tree_code code, tree name,
6558 struct c_struct_parse_info **enclosing_struct_parse_info)
6560 /* If there is already a tag defined at this scope
6561 (as a forward reference), just return it. */
6563 tree ref = NULL_TREE;
6564 location_t refloc = UNKNOWN_LOCATION;
6566 if (name != NULL_TREE)
6567 ref = lookup_tag (code, name, 1, &refloc);
6568 if (ref && TREE_CODE (ref) == code)
6570 if (TYPE_SIZE (ref))
6572 if (code == UNION_TYPE)
6573 error_at (loc, "redefinition of %<union %E%>", name);
6575 error_at (loc, "redefinition of %<struct %E%>", name);
6576 if (refloc != UNKNOWN_LOCATION)
6577 inform (refloc, "originally defined here");
6578 /* Don't create structures using a name already in use. */
6581 else if (C_TYPE_BEING_DEFINED (ref))
6583 if (code == UNION_TYPE)
6584 error_at (loc, "nested redefinition of %<union %E%>", name);
6586 error_at (loc, "nested redefinition of %<struct %E%>", name);
6587 /* Don't bother to report "originally defined here" for a
6588 nested redefinition; the original definition should be
6590 /* Don't create structures that contain themselves. */
6595 /* Otherwise create a forward-reference just so the tag is in scope. */
6597 if (ref == NULL_TREE || TREE_CODE (ref) != code)
6599 ref = make_node (code);
6600 pushtag (loc, name, ref);
6603 C_TYPE_BEING_DEFINED (ref) = 1;
6604 TYPE_PACKED (ref) = flag_pack_struct;
6606 *enclosing_struct_parse_info = struct_parse_info;
6607 struct_parse_info = XNEW (struct c_struct_parse_info);
6608 struct_parse_info->struct_types = VEC_alloc (tree, heap, 0);
6609 struct_parse_info->fields = VEC_alloc (c_binding_ptr, heap, 0);
6610 struct_parse_info->typedefs_seen = VEC_alloc (tree, heap, 0);
6612 /* FIXME: This will issue a warning for a use of a type defined
6613 within a statement expr used within sizeof, et. al. This is not
6614 terribly serious as C++ doesn't permit statement exprs within
6616 if (warn_cxx_compat && (in_sizeof || in_typeof || in_alignof))
6617 warning_at (loc, OPT_Wc___compat,
6618 "defining type in %qs expression is invalid in C++",
6621 : (in_typeof ? "typeof" : "alignof")));
6626 /* Process the specs, declarator and width (NULL if omitted)
6627 of a structure component, returning a FIELD_DECL node.
6628 WIDTH is non-NULL for bit-fields only, and is an INTEGER_CST node.
6629 DECL_ATTRS is as for grokdeclarator.
6631 LOC is the location of the structure component.
6633 This is done during the parsing of the struct declaration.
6634 The FIELD_DECL nodes are chained together and the lot of them
6635 are ultimately passed to `build_struct' to make the RECORD_TYPE node. */
6638 grokfield (location_t loc,
6639 struct c_declarator *declarator, struct c_declspecs *declspecs,
6640 tree width, tree *decl_attrs)
6644 if (declarator->kind == cdk_id && declarator->u.id == NULL_TREE
6645 && width == NULL_TREE)
6647 /* This is an unnamed decl.
6649 If we have something of the form "union { list } ;" then this
6650 is the anonymous union extension. Similarly for struct.
6652 If this is something of the form "struct foo;", then
6653 If MS or Plan 9 extensions are enabled, this is handled as
6654 an anonymous struct.
6655 Otherwise this is a forward declaration of a structure tag.
6657 If this is something of the form "foo;" and foo is a TYPE_DECL, then
6658 If foo names a structure or union without a tag, then this
6659 is an anonymous struct (this is permitted by C1X).
6660 If MS or Plan 9 extensions are enabled and foo names a
6661 structure, then again this is an anonymous struct.
6662 Otherwise this is an error.
6664 Oh what a horrid tangled web we weave. I wonder if MS consciously
6665 took this from Plan 9 or if it was an accident of implementation
6666 that took root before someone noticed the bug... */
6668 tree type = declspecs->type;
6669 bool type_ok = (TREE_CODE (type) == RECORD_TYPE
6670 || TREE_CODE (type) == UNION_TYPE);
6674 && (flag_ms_extensions
6675 || flag_plan9_extensions
6676 || !declspecs->typedef_p))
6678 if (flag_ms_extensions || flag_plan9_extensions)
6680 else if (TYPE_NAME (type) == NULL)
6687 pedwarn (loc, 0, "declaration does not declare anything");
6693 pedwarn (loc, OPT_pedantic,
6694 "ISO C99 doesn%'t support unnamed structs/unions");
6696 pedwarn (loc, OPT_pedantic,
6697 "ISO C90 doesn%'t support unnamed structs/unions");
6701 value = grokdeclarator (declarator, declspecs, FIELD, false,
6702 width ? &width : NULL, decl_attrs, NULL, NULL,
6705 finish_decl (value, loc, NULL_TREE, NULL_TREE, NULL_TREE);
6706 DECL_INITIAL (value) = width;
6708 if (warn_cxx_compat && DECL_NAME (value) != NULL_TREE)
6710 /* If we currently have a binding for this field, set the
6711 in_struct field in the binding, so that we warn about lookups
6713 struct c_binding *b = I_SYMBOL_BINDING (DECL_NAME (value));
6716 /* If the in_struct field is not yet set, push it on a list
6717 to be cleared when this struct is finished. */
6720 VEC_safe_push (c_binding_ptr, heap,
6721 struct_parse_info->fields, b);
6730 /* Subroutine of detect_field_duplicates: return whether X and Y,
6731 which are both fields in the same struct, have duplicate field
6735 is_duplicate_field (tree x, tree y)
6737 if (DECL_NAME (x) != NULL_TREE && DECL_NAME (x) == DECL_NAME (y))
6740 /* When using -fplan9-extensions, an anonymous field whose name is a
6741 typedef can duplicate a field name. */
6742 if (flag_plan9_extensions
6743 && (DECL_NAME (x) == NULL_TREE || DECL_NAME (y) == NULL_TREE))
6745 tree xt, xn, yt, yn;
6748 if (DECL_NAME (x) != NULL_TREE)
6750 else if ((TREE_CODE (xt) == RECORD_TYPE || TREE_CODE (xt) == UNION_TYPE)
6751 && TYPE_NAME (xt) != NULL_TREE
6752 && TREE_CODE (TYPE_NAME (xt)) == TYPE_DECL)
6753 xn = DECL_NAME (TYPE_NAME (xt));
6758 if (DECL_NAME (y) != NULL_TREE)
6760 else if ((TREE_CODE (yt) == RECORD_TYPE || TREE_CODE (yt) == UNION_TYPE)
6761 && TYPE_NAME (yt) != NULL_TREE
6762 && TREE_CODE (TYPE_NAME (yt)) == TYPE_DECL)
6763 yn = DECL_NAME (TYPE_NAME (yt));
6767 if (xn != NULL_TREE && xn == yn)
6774 /* Subroutine of detect_field_duplicates: add the fields of FIELDLIST
6775 to HTAB, giving errors for any duplicates. */
6778 detect_field_duplicates_hash (tree fieldlist, htab_t htab)
6783 for (x = fieldlist; x ; x = DECL_CHAIN (x))
6784 if ((y = DECL_NAME (x)) != 0)
6786 slot = htab_find_slot (htab, y, INSERT);
6789 error ("duplicate member %q+D", x);
6790 DECL_NAME (x) = NULL_TREE;
6794 else if (TREE_CODE (TREE_TYPE (x)) == RECORD_TYPE
6795 || TREE_CODE (TREE_TYPE (x)) == UNION_TYPE)
6797 detect_field_duplicates_hash (TYPE_FIELDS (TREE_TYPE (x)), htab);
6799 /* When using -fplan9-extensions, an anonymous field whose
6800 name is a typedef can duplicate a field name. */
6801 if (flag_plan9_extensions
6802 && TYPE_NAME (TREE_TYPE (x)) != NULL_TREE
6803 && TREE_CODE (TYPE_NAME (TREE_TYPE (x))) == TYPE_DECL)
6805 tree xn = DECL_NAME (TYPE_NAME (TREE_TYPE (x)));
6806 slot = htab_find_slot (htab, xn, INSERT);
6808 error ("duplicate member %q+D", TYPE_NAME (TREE_TYPE (x)));
6814 /* Generate an error for any duplicate field names in FIELDLIST. Munge
6815 the list such that this does not present a problem later. */
6818 detect_field_duplicates (tree fieldlist)
6823 /* If the struct is the list of instance variables of an Objective-C
6824 class, then we need to add all the instance variables of
6825 superclasses before checking for duplicates (since you can't have
6826 an instance variable in a subclass with the same name as an
6827 instance variable in a superclass). objc_get_interface_ivars()
6828 leaves fieldlist unchanged if we are not in this case, so in that
6829 case nothing changes compared to C.
6831 if (c_dialect_objc ())
6832 fieldlist = objc_get_interface_ivars (fieldlist);
6834 /* First, see if there are more than "a few" fields.
6835 This is trivially true if there are zero or one fields. */
6836 if (!fieldlist || !DECL_CHAIN (fieldlist))
6841 if (DECL_NAME (x) == NULL_TREE
6842 && (TREE_CODE (TREE_TYPE (x)) == RECORD_TYPE
6843 || TREE_CODE (TREE_TYPE (x)) == UNION_TYPE))
6846 } while (timeout > 0 && x);
6848 /* If there were "few" fields and no anonymous structures or unions,
6849 avoid the overhead of allocating a hash table. Instead just do
6850 the nested traversal thing. */
6853 for (x = DECL_CHAIN (fieldlist); x; x = DECL_CHAIN (x))
6854 /* When using -fplan9-extensions, we can have duplicates
6855 between typedef names and fields. */
6857 || (flag_plan9_extensions
6858 && DECL_NAME (x) == NULL_TREE
6859 && (TREE_CODE (TREE_TYPE (x)) == RECORD_TYPE
6860 || TREE_CODE (TREE_TYPE (x)) == UNION_TYPE)
6861 && TYPE_NAME (TREE_TYPE (x)) != NULL_TREE
6862 && TREE_CODE (TYPE_NAME (TREE_TYPE (x))) == TYPE_DECL))
6864 for (y = fieldlist; y != x; y = TREE_CHAIN (y))
6865 if (is_duplicate_field (y, x))
6867 error ("duplicate member %q+D", x);
6868 DECL_NAME (x) = NULL_TREE;
6874 htab_t htab = htab_create (37, htab_hash_pointer, htab_eq_pointer, NULL);
6876 detect_field_duplicates_hash (fieldlist, htab);
6881 /* Finish up struct info used by -Wc++-compat. */
6884 warn_cxx_compat_finish_struct (tree fieldlist)
6888 struct c_binding *b;
6890 /* Set the C_TYPE_DEFINED_IN_STRUCT flag for each type defined in
6891 the current struct. We do this now at the end of the struct
6892 because the flag is used to issue visibility warnings, and we
6893 only want to issue those warnings if the type is referenced
6894 outside of the struct declaration. */
6895 FOR_EACH_VEC_ELT (tree, struct_parse_info->struct_types, ix, x)
6896 C_TYPE_DEFINED_IN_STRUCT (x) = 1;
6898 /* The TYPEDEFS_SEEN field of STRUCT_PARSE_INFO is a list of
6899 typedefs used when declaring fields in this struct. If the name
6900 of any of the fields is also a typedef name then the struct would
6901 not parse in C++, because the C++ lookup rules say that the
6902 typedef name would be looked up in the context of the struct, and
6903 would thus be the field rather than the typedef. */
6904 if (!VEC_empty (tree, struct_parse_info->typedefs_seen)
6905 && fieldlist != NULL_TREE)
6907 /* Use a pointer_set using the name of the typedef. We can use
6908 a pointer_set because identifiers are interned. */
6909 struct pointer_set_t *tset = pointer_set_create ();
6911 FOR_EACH_VEC_ELT (tree, struct_parse_info->typedefs_seen, ix, x)
6912 pointer_set_insert (tset, DECL_NAME (x));
6914 for (x = fieldlist; x != NULL_TREE; x = DECL_CHAIN (x))
6916 if (DECL_NAME (x) != NULL_TREE
6917 && pointer_set_contains (tset, DECL_NAME (x)))
6919 warning_at (DECL_SOURCE_LOCATION (x), OPT_Wc___compat,
6920 ("using %qD as both field and typedef name is "
6923 /* FIXME: It would be nice to report the location where
6924 the typedef name is used. */
6928 pointer_set_destroy (tset);
6931 /* For each field which has a binding and which was not defined in
6932 an enclosing struct, clear the in_struct field. */
6933 FOR_EACH_VEC_ELT (c_binding_ptr, struct_parse_info->fields, ix, b)
6937 /* Fill in the fields of a RECORD_TYPE or UNION_TYPE node, T.
6938 LOC is the location of the RECORD_TYPE or UNION_TYPE's definition.
6939 FIELDLIST is a chain of FIELD_DECL nodes for the fields.
6940 ATTRIBUTES are attributes to be applied to the structure.
6942 ENCLOSING_STRUCT_PARSE_INFO is the value of STRUCT_PARSE_INFO when
6943 the struct was started. */
6946 finish_struct (location_t loc, tree t, tree fieldlist, tree attributes,
6947 struct c_struct_parse_info *enclosing_struct_parse_info)
6950 bool toplevel = file_scope == current_scope;
6951 int saw_named_field;
6953 /* If this type was previously laid out as a forward reference,
6954 make sure we lay it out again. */
6958 decl_attributes (&t, attributes, (int) ATTR_FLAG_TYPE_IN_PLACE);
6962 for (x = fieldlist; x; x = DECL_CHAIN (x))
6964 if (DECL_NAME (x) != 0)
6967 && (TREE_CODE (TREE_TYPE (x)) == RECORD_TYPE
6968 || TREE_CODE (TREE_TYPE (x)) == UNION_TYPE))
6974 if (TREE_CODE (t) == UNION_TYPE)
6977 pedwarn (loc, OPT_pedantic, "union has no named members");
6979 pedwarn (loc, OPT_pedantic, "union has no members");
6984 pedwarn (loc, OPT_pedantic, "struct has no named members");
6986 pedwarn (loc, OPT_pedantic, "struct has no members");
6991 /* Install struct as DECL_CONTEXT of each field decl.
6992 Also process specified field sizes, found in the DECL_INITIAL,
6993 storing 0 there after the type has been changed to precision equal
6994 to its width, rather than the precision of the specified standard
6995 type. (Correct layout requires the original type to have been preserved
6998 saw_named_field = 0;
6999 for (x = fieldlist; x; x = DECL_CHAIN (x))
7001 if (TREE_TYPE (x) == error_mark_node)
7004 DECL_CONTEXT (x) = t;
7006 /* If any field is const, the structure type is pseudo-const. */
7007 if (TREE_READONLY (x))
7008 C_TYPE_FIELDS_READONLY (t) = 1;
7011 /* A field that is pseudo-const makes the structure likewise. */
7012 tree t1 = strip_array_types (TREE_TYPE (x));
7013 if ((TREE_CODE (t1) == RECORD_TYPE || TREE_CODE (t1) == UNION_TYPE)
7014 && C_TYPE_FIELDS_READONLY (t1))
7015 C_TYPE_FIELDS_READONLY (t) = 1;
7018 /* Any field that is volatile means variables of this type must be
7019 treated in some ways as volatile. */
7020 if (TREE_THIS_VOLATILE (x))
7021 C_TYPE_FIELDS_VOLATILE (t) = 1;
7023 /* Any field of nominal variable size implies structure is too. */
7024 if (C_DECL_VARIABLE_SIZE (x))
7025 C_TYPE_VARIABLE_SIZE (t) = 1;
7027 if (DECL_INITIAL (x))
7029 unsigned HOST_WIDE_INT width = tree_low_cst (DECL_INITIAL (x), 1);
7030 DECL_SIZE (x) = bitsize_int (width);
7031 DECL_BIT_FIELD (x) = 1;
7032 SET_DECL_C_BIT_FIELD (x);
7036 && (DECL_BIT_FIELD (x)
7037 || TYPE_ALIGN (TREE_TYPE (x)) > BITS_PER_UNIT))
7038 DECL_PACKED (x) = 1;
7040 /* Detect flexible array member in an invalid context. */
7041 if (TREE_CODE (TREE_TYPE (x)) == ARRAY_TYPE
7042 && TYPE_SIZE (TREE_TYPE (x)) == NULL_TREE
7043 && TYPE_DOMAIN (TREE_TYPE (x)) != NULL_TREE
7044 && TYPE_MAX_VALUE (TYPE_DOMAIN (TREE_TYPE (x))) == NULL_TREE)
7046 if (TREE_CODE (t) == UNION_TYPE)
7048 error_at (DECL_SOURCE_LOCATION (x),
7049 "flexible array member in union");
7050 TREE_TYPE (x) = error_mark_node;
7052 else if (DECL_CHAIN (x) != NULL_TREE)
7054 error_at (DECL_SOURCE_LOCATION (x),
7055 "flexible array member not at end of struct");
7056 TREE_TYPE (x) = error_mark_node;
7058 else if (!saw_named_field)
7060 error_at (DECL_SOURCE_LOCATION (x),
7061 "flexible array member in otherwise empty struct");
7062 TREE_TYPE (x) = error_mark_node;
7066 if (pedantic && TREE_CODE (t) == RECORD_TYPE
7067 && flexible_array_type_p (TREE_TYPE (x)))
7068 pedwarn (DECL_SOURCE_LOCATION (x), OPT_pedantic,
7069 "invalid use of structure with flexible array member");
7072 || TREE_CODE (TREE_TYPE (x)) == RECORD_TYPE
7073 || TREE_CODE (TREE_TYPE (x)) == UNION_TYPE)
7074 saw_named_field = 1;
7077 detect_field_duplicates (fieldlist);
7079 /* Now we have the nearly final fieldlist. Record it,
7080 then lay out the structure or union (including the fields). */
7082 TYPE_FIELDS (t) = fieldlist;
7086 /* Give bit-fields their proper types. */
7088 tree *fieldlistp = &fieldlist;
7090 if (TREE_CODE (*fieldlistp) == FIELD_DECL && DECL_INITIAL (*fieldlistp)
7091 && TREE_TYPE (*fieldlistp) != error_mark_node)
7093 unsigned HOST_WIDE_INT width
7094 = tree_low_cst (DECL_INITIAL (*fieldlistp), 1);
7095 tree type = TREE_TYPE (*fieldlistp);
7096 if (width != TYPE_PRECISION (type))
7098 TREE_TYPE (*fieldlistp)
7099 = c_build_bitfield_integer_type (width, TYPE_UNSIGNED (type));
7100 DECL_MODE (*fieldlistp) = TYPE_MODE (TREE_TYPE (*fieldlistp));
7102 DECL_INITIAL (*fieldlistp) = 0;
7105 fieldlistp = &DECL_CHAIN (*fieldlistp);
7108 /* Now we have the truly final field list.
7109 Store it in this type and in the variants. */
7111 TYPE_FIELDS (t) = fieldlist;
7113 /* If there are lots of fields, sort so we can look through them fast.
7114 We arbitrarily consider 16 or more elts to be "a lot". */
7119 for (x = fieldlist; x; x = DECL_CHAIN (x))
7121 if (len > 15 || DECL_NAME (x) == NULL)
7129 struct lang_type *space;
7130 struct sorted_fields_type *space2;
7132 len += list_length (x);
7134 /* Use the same allocation policy here that make_node uses, to
7135 ensure that this lives as long as the rest of the struct decl.
7136 All decls in an inline function need to be saved. */
7138 space = ggc_alloc_cleared_lang_type (sizeof (struct lang_type));
7139 space2 = ggc_alloc_sorted_fields_type
7140 (sizeof (struct sorted_fields_type) + len * sizeof (tree));
7144 field_array = &space2->elts[0];
7145 for (x = fieldlist; x; x = DECL_CHAIN (x))
7147 field_array[len++] = x;
7149 /* If there is anonymous struct or union, break out of the loop. */
7150 if (DECL_NAME (x) == NULL)
7153 /* Found no anonymous struct/union. Add the TYPE_LANG_SPECIFIC. */
7156 TYPE_LANG_SPECIFIC (t) = space;
7157 TYPE_LANG_SPECIFIC (t)->s->len = len;
7158 field_array = TYPE_LANG_SPECIFIC (t)->s->elts;
7159 qsort (field_array, len, sizeof (tree), field_decl_cmp);
7164 for (x = TYPE_MAIN_VARIANT (t); x; x = TYPE_NEXT_VARIANT (x))
7166 TYPE_FIELDS (x) = TYPE_FIELDS (t);
7167 TYPE_LANG_SPECIFIC (x) = TYPE_LANG_SPECIFIC (t);
7168 C_TYPE_FIELDS_READONLY (x) = C_TYPE_FIELDS_READONLY (t);
7169 C_TYPE_FIELDS_VOLATILE (x) = C_TYPE_FIELDS_VOLATILE (t);
7170 C_TYPE_VARIABLE_SIZE (x) = C_TYPE_VARIABLE_SIZE (t);
7173 /* If this was supposed to be a transparent union, but we can't
7174 make it one, warn and turn off the flag. */
7175 if (TREE_CODE (t) == UNION_TYPE
7176 && TYPE_TRANSPARENT_AGGR (t)
7177 && (!TYPE_FIELDS (t) || TYPE_MODE (t) != DECL_MODE (TYPE_FIELDS (t))))
7179 TYPE_TRANSPARENT_AGGR (t) = 0;
7180 warning_at (loc, 0, "union cannot be made transparent");
7183 /* If this structure or union completes the type of any previous
7184 variable declaration, lay it out and output its rtl. */
7185 for (x = C_TYPE_INCOMPLETE_VARS (TYPE_MAIN_VARIANT (t));
7189 tree decl = TREE_VALUE (x);
7190 if (TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE)
7191 layout_array_type (TREE_TYPE (decl));
7192 if (TREE_CODE (decl) != TYPE_DECL)
7194 layout_decl (decl, 0);
7195 if (c_dialect_objc ())
7196 objc_check_decl (decl);
7197 rest_of_decl_compilation (decl, toplevel, 0);
7202 C_TYPE_INCOMPLETE_VARS (TYPE_MAIN_VARIANT (t)) = 0;
7204 /* Update type location to the one of the definition, instead of e.g.
7205 a forward declaration. */
7206 if (TYPE_STUB_DECL (t))
7207 DECL_SOURCE_LOCATION (TYPE_STUB_DECL (t)) = loc;
7209 /* Finish debugging output for this type. */
7210 rest_of_type_compilation (t, toplevel);
7212 /* If we're inside a function proper, i.e. not file-scope and not still
7213 parsing parameters, then arrange for the size of a variable sized type
7215 if (cur_stmt_list && variably_modified_type_p (t, NULL_TREE))
7216 add_stmt (build_stmt (loc,
7217 DECL_EXPR, build_decl (loc, TYPE_DECL, NULL, t)));
7219 if (warn_cxx_compat)
7220 warn_cxx_compat_finish_struct (fieldlist);
7222 VEC_free (tree, heap, struct_parse_info->struct_types);
7223 VEC_free (c_binding_ptr, heap, struct_parse_info->fields);
7224 VEC_free (tree, heap, struct_parse_info->typedefs_seen);
7225 XDELETE (struct_parse_info);
7227 struct_parse_info = enclosing_struct_parse_info;
7229 /* If this struct is defined inside a struct, add it to
7232 && struct_parse_info != NULL
7233 && !in_sizeof && !in_typeof && !in_alignof)
7234 VEC_safe_push (tree, heap, struct_parse_info->struct_types, t);
7239 /* Lay out the type T, and its element type, and so on. */
7242 layout_array_type (tree t)
7244 if (TREE_CODE (TREE_TYPE (t)) == ARRAY_TYPE)
7245 layout_array_type (TREE_TYPE (t));
7249 /* Begin compiling the definition of an enumeration type.
7250 NAME is its name (or null if anonymous).
7251 LOC is the enum's location.
7252 Returns the type object, as yet incomplete.
7253 Also records info about it so that build_enumerator
7254 may be used to declare the individual values as they are read. */
7257 start_enum (location_t loc, struct c_enum_contents *the_enum, tree name)
7259 tree enumtype = NULL_TREE;
7260 location_t enumloc = UNKNOWN_LOCATION;
7262 /* If this is the real definition for a previous forward reference,
7263 fill in the contents in the same object that used to be the
7264 forward reference. */
7266 if (name != NULL_TREE)
7267 enumtype = lookup_tag (ENUMERAL_TYPE, name, 1, &enumloc);
7269 if (enumtype == 0 || TREE_CODE (enumtype) != ENUMERAL_TYPE)
7271 enumtype = make_node (ENUMERAL_TYPE);
7272 pushtag (loc, name, enumtype);
7275 if (C_TYPE_BEING_DEFINED (enumtype))
7276 error_at (loc, "nested redefinition of %<enum %E%>", name);
7278 C_TYPE_BEING_DEFINED (enumtype) = 1;
7280 if (TYPE_VALUES (enumtype) != 0)
7282 /* This enum is a named one that has been declared already. */
7283 error_at (loc, "redeclaration of %<enum %E%>", name);
7284 if (enumloc != UNKNOWN_LOCATION)
7285 inform (enumloc, "originally defined here");
7287 /* Completely replace its old definition.
7288 The old enumerators remain defined, however. */
7289 TYPE_VALUES (enumtype) = 0;
7292 the_enum->enum_next_value = integer_zero_node;
7293 the_enum->enum_overflow = 0;
7295 if (flag_short_enums)
7296 TYPE_PACKED (enumtype) = 1;
7298 /* FIXME: This will issue a warning for a use of a type defined
7299 within sizeof in a statement expr. This is not terribly serious
7300 as C++ doesn't permit statement exprs within sizeof anyhow. */
7301 if (warn_cxx_compat && (in_sizeof || in_typeof || in_alignof))
7302 warning_at (loc, OPT_Wc___compat,
7303 "defining type in %qs expression is invalid in C++",
7306 : (in_typeof ? "typeof" : "alignof")));
7311 /* After processing and defining all the values of an enumeration type,
7312 install their decls in the enumeration type and finish it off.
7313 ENUMTYPE is the type object, VALUES a list of decl-value pairs,
7314 and ATTRIBUTES are the specified attributes.
7315 Returns ENUMTYPE. */
7318 finish_enum (tree enumtype, tree values, tree attributes)
7321 tree minnode = 0, maxnode = 0;
7322 int precision, unsign;
7323 bool toplevel = (file_scope == current_scope);
7324 struct lang_type *lt;
7326 decl_attributes (&enumtype, attributes, (int) ATTR_FLAG_TYPE_IN_PLACE);
7328 /* Calculate the maximum value of any enumerator in this type. */
7330 if (values == error_mark_node)
7331 minnode = maxnode = integer_zero_node;
7334 minnode = maxnode = TREE_VALUE (values);
7335 for (pair = TREE_CHAIN (values); pair; pair = TREE_CHAIN (pair))
7337 tree value = TREE_VALUE (pair);
7338 if (tree_int_cst_lt (maxnode, value))
7340 if (tree_int_cst_lt (value, minnode))
7345 /* Construct the final type of this enumeration. It is the same
7346 as one of the integral types - the narrowest one that fits, except
7347 that normally we only go as narrow as int - and signed iff any of
7348 the values are negative. */
7349 unsign = (tree_int_cst_sgn (minnode) >= 0);
7350 precision = MAX (tree_int_cst_min_precision (minnode, unsign),
7351 tree_int_cst_min_precision (maxnode, unsign));
7353 if (TYPE_PACKED (enumtype) || precision > TYPE_PRECISION (integer_type_node))
7355 tem = c_common_type_for_size (precision, unsign);
7358 warning (0, "enumeration values exceed range of largest integer");
7359 tem = long_long_integer_type_node;
7363 tem = unsign ? unsigned_type_node : integer_type_node;
7365 TYPE_MIN_VALUE (enumtype) = TYPE_MIN_VALUE (tem);
7366 TYPE_MAX_VALUE (enumtype) = TYPE_MAX_VALUE (tem);
7367 TYPE_UNSIGNED (enumtype) = TYPE_UNSIGNED (tem);
7368 TYPE_SIZE (enumtype) = 0;
7370 /* If the precision of the type was specific with an attribute and it
7371 was too small, give an error. Otherwise, use it. */
7372 if (TYPE_PRECISION (enumtype))
7374 if (precision > TYPE_PRECISION (enumtype))
7375 error ("specified mode too small for enumeral values");
7378 TYPE_PRECISION (enumtype) = TYPE_PRECISION (tem);
7380 layout_type (enumtype);
7382 if (values != error_mark_node)
7384 /* Change the type of the enumerators to be the enum type. We
7385 need to do this irrespective of the size of the enum, for
7386 proper type checking. Replace the DECL_INITIALs of the
7387 enumerators, and the value slots of the list, with copies
7388 that have the enum type; they cannot be modified in place
7389 because they may be shared (e.g. integer_zero_node) Finally,
7390 change the purpose slots to point to the names of the decls. */
7391 for (pair = values; pair; pair = TREE_CHAIN (pair))
7393 tree enu = TREE_PURPOSE (pair);
7394 tree ini = DECL_INITIAL (enu);
7396 TREE_TYPE (enu) = enumtype;
7398 /* The ISO C Standard mandates enumerators to have type int,
7399 even though the underlying type of an enum type is
7400 unspecified. However, GCC allows enumerators of any
7401 integer type as an extensions. build_enumerator()
7402 converts any enumerators that fit in an int to type int,
7403 to avoid promotions to unsigned types when comparing
7404 integers with enumerators that fit in the int range.
7405 When -pedantic is given, build_enumerator() would have
7406 already warned about those that don't fit. Here we
7407 convert the rest to the enumerator type. */
7408 if (TREE_TYPE (ini) != integer_type_node)
7409 ini = convert (enumtype, ini);
7411 DECL_INITIAL (enu) = ini;
7412 TREE_PURPOSE (pair) = DECL_NAME (enu);
7413 TREE_VALUE (pair) = ini;
7416 TYPE_VALUES (enumtype) = values;
7419 /* Record the min/max values so that we can warn about bit-field
7420 enumerations that are too small for the values. */
7421 lt = ggc_alloc_cleared_lang_type (sizeof (struct lang_type));
7422 lt->enum_min = minnode;
7423 lt->enum_max = maxnode;
7424 TYPE_LANG_SPECIFIC (enumtype) = lt;
7426 /* Fix up all variant types of this enum type. */
7427 for (tem = TYPE_MAIN_VARIANT (enumtype); tem; tem = TYPE_NEXT_VARIANT (tem))
7429 if (tem == enumtype)
7431 TYPE_VALUES (tem) = TYPE_VALUES (enumtype);
7432 TYPE_MIN_VALUE (tem) = TYPE_MIN_VALUE (enumtype);
7433 TYPE_MAX_VALUE (tem) = TYPE_MAX_VALUE (enumtype);
7434 TYPE_SIZE (tem) = TYPE_SIZE (enumtype);
7435 TYPE_SIZE_UNIT (tem) = TYPE_SIZE_UNIT (enumtype);
7436 SET_TYPE_MODE (tem, TYPE_MODE (enumtype));
7437 TYPE_PRECISION (tem) = TYPE_PRECISION (enumtype);
7438 TYPE_ALIGN (tem) = TYPE_ALIGN (enumtype);
7439 TYPE_USER_ALIGN (tem) = TYPE_USER_ALIGN (enumtype);
7440 TYPE_UNSIGNED (tem) = TYPE_UNSIGNED (enumtype);
7441 TYPE_LANG_SPECIFIC (tem) = TYPE_LANG_SPECIFIC (enumtype);
7444 /* Finish debugging output for this type. */
7445 rest_of_type_compilation (enumtype, toplevel);
7447 /* If this enum is defined inside a struct, add it to
7450 && struct_parse_info != NULL
7451 && !in_sizeof && !in_typeof && !in_alignof)
7452 VEC_safe_push (tree, heap, struct_parse_info->struct_types, enumtype);
7457 /* Build and install a CONST_DECL for one value of the
7458 current enumeration type (one that was begun with start_enum).
7459 DECL_LOC is the location of the enumerator.
7460 LOC is the location of the '=' operator if any, DECL_LOC otherwise.
7461 Return a tree-list containing the CONST_DECL and its value.
7462 Assignment of sequential values by default is handled here. */
7465 build_enumerator (location_t decl_loc, location_t loc,
7466 struct c_enum_contents *the_enum, tree name, tree value)
7470 /* Validate and default VALUE. */
7474 /* Don't issue more errors for error_mark_node (i.e. an
7475 undeclared identifier) - just ignore the value expression. */
7476 if (value == error_mark_node)
7478 else if (!INTEGRAL_TYPE_P (TREE_TYPE (value)))
7480 error_at (loc, "enumerator value for %qE is not an integer constant",
7486 if (TREE_CODE (value) != INTEGER_CST)
7488 value = c_fully_fold (value, false, NULL);
7489 if (TREE_CODE (value) == INTEGER_CST)
7490 pedwarn (loc, OPT_pedantic,
7491 "enumerator value for %qE is not an integer "
7492 "constant expression", name);
7494 if (TREE_CODE (value) != INTEGER_CST)
7496 error ("enumerator value for %qE is not an integer constant",
7502 value = default_conversion (value);
7503 constant_expression_warning (value);
7508 /* Default based on previous value. */
7509 /* It should no longer be possible to have NON_LVALUE_EXPR
7513 value = the_enum->enum_next_value;
7514 if (the_enum->enum_overflow)
7515 error_at (loc, "overflow in enumeration values");
7517 /* Even though the underlying type of an enum is unspecified, the
7518 type of enumeration constants is explicitly defined as int
7519 (6.4.4.3/2 in the C99 Standard). GCC allows any integer type as
7521 else if (!int_fits_type_p (value, integer_type_node))
7522 pedwarn (loc, OPT_pedantic,
7523 "ISO C restricts enumerator values to range of %<int%>");
7525 /* The ISO C Standard mandates enumerators to have type int, even
7526 though the underlying type of an enum type is unspecified.
7527 However, GCC allows enumerators of any integer type as an
7528 extensions. Here we convert any enumerators that fit in an int
7529 to type int, to avoid promotions to unsigned types when comparing
7530 integers with enumerators that fit in the int range. When
7531 -pedantic is given, we would have already warned about those that
7532 don't fit. We have to do this here rather than in finish_enum
7533 because this value may be used to define more enumerators. */
7534 if (int_fits_type_p (value, integer_type_node))
7535 value = convert (integer_type_node, value);
7537 /* Set basis for default for next value. */
7538 the_enum->enum_next_value
7539 = build_binary_op (EXPR_LOC_OR_HERE (value),
7540 PLUS_EXPR, value, integer_one_node, 0);
7541 the_enum->enum_overflow = tree_int_cst_lt (the_enum->enum_next_value, value);
7543 /* Now create a declaration for the enum value name. */
7545 type = TREE_TYPE (value);
7546 type = c_common_type_for_size (MAX (TYPE_PRECISION (type),
7547 TYPE_PRECISION (integer_type_node)),
7548 (TYPE_PRECISION (type)
7549 >= TYPE_PRECISION (integer_type_node)
7550 && TYPE_UNSIGNED (type)));
7552 decl = build_decl (decl_loc, CONST_DECL, name, type);
7553 DECL_INITIAL (decl) = convert (type, value);
7556 return tree_cons (decl, value, NULL_TREE);
7560 /* Create the FUNCTION_DECL for a function definition.
7561 DECLSPECS, DECLARATOR and ATTRIBUTES are the parts of
7562 the declaration; they describe the function's name and the type it returns,
7563 but twisted together in a fashion that parallels the syntax of C.
7565 This function creates a binding context for the function body
7566 as well as setting up the FUNCTION_DECL in current_function_decl.
7568 Returns 1 on success. If the DECLARATOR is not suitable for a function
7569 (it defines a datum instead), we return 0, which tells
7570 yyparse to report a parse error. */
7573 start_function (struct c_declspecs *declspecs, struct c_declarator *declarator,
7576 tree decl1, old_decl;
7577 tree restype, resdecl;
7580 current_function_returns_value = 0; /* Assume, until we see it does. */
7581 current_function_returns_null = 0;
7582 current_function_returns_abnormally = 0;
7583 warn_about_return_type = 0;
7584 c_switch_stack = NULL;
7586 /* Indicate no valid break/continue context by setting these variables
7587 to some non-null, non-label value. We'll notice and emit the proper
7588 error message in c_finish_bc_stmt. */
7589 c_break_label = c_cont_label = size_zero_node;
7591 decl1 = grokdeclarator (declarator, declspecs, FUNCDEF, true, NULL,
7592 &attributes, NULL, NULL, DEPRECATED_NORMAL);
7594 /* If the declarator is not suitable for a function definition,
7595 cause a syntax error. */
7599 loc = DECL_SOURCE_LOCATION (decl1);
7601 decl_attributes (&decl1, attributes, 0);
7603 if (DECL_DECLARED_INLINE_P (decl1)
7604 && DECL_UNINLINABLE (decl1)
7605 && lookup_attribute ("noinline", DECL_ATTRIBUTES (decl1)))
7606 warning_at (loc, OPT_Wattributes,
7607 "inline function %qD given attribute noinline",
7610 /* Handle gnu_inline attribute. */
7611 if (declspecs->inline_p
7612 && !flag_gnu89_inline
7613 && TREE_CODE (decl1) == FUNCTION_DECL
7614 && (lookup_attribute ("gnu_inline", DECL_ATTRIBUTES (decl1))
7615 || current_function_decl))
7617 if (declspecs->storage_class != csc_static)
7618 DECL_EXTERNAL (decl1) = !DECL_EXTERNAL (decl1);
7621 announce_function (decl1);
7623 if (!COMPLETE_OR_VOID_TYPE_P (TREE_TYPE (TREE_TYPE (decl1))))
7625 error_at (loc, "return type is an incomplete type");
7626 /* Make it return void instead. */
7628 = build_function_type (void_type_node,
7629 TYPE_ARG_TYPES (TREE_TYPE (decl1)));
7632 if (warn_about_return_type)
7633 pedwarn_c99 (loc, flag_isoc99 ? 0
7634 : (warn_return_type ? OPT_Wreturn_type : OPT_Wimplicit_int),
7635 "return type defaults to %<int%>");
7637 /* Make the init_value nonzero so pushdecl knows this is not tentative.
7638 error_mark_node is replaced below (in pop_scope) with the BLOCK. */
7639 DECL_INITIAL (decl1) = error_mark_node;
7641 /* A nested function is not global. */
7642 if (current_function_decl != 0)
7643 TREE_PUBLIC (decl1) = 0;
7645 /* If this definition isn't a prototype and we had a prototype declaration
7646 before, copy the arg type info from that prototype. */
7647 old_decl = lookup_name_in_scope (DECL_NAME (decl1), current_scope);
7648 if (old_decl && TREE_CODE (old_decl) != FUNCTION_DECL)
7650 current_function_prototype_locus = UNKNOWN_LOCATION;
7651 current_function_prototype_built_in = false;
7652 current_function_prototype_arg_types = NULL_TREE;
7653 if (!prototype_p (TREE_TYPE (decl1)))
7655 if (old_decl != 0 && TREE_CODE (TREE_TYPE (old_decl)) == FUNCTION_TYPE
7656 && comptypes (TREE_TYPE (TREE_TYPE (decl1)),
7657 TREE_TYPE (TREE_TYPE (old_decl))))
7659 TREE_TYPE (decl1) = composite_type (TREE_TYPE (old_decl),
7661 current_function_prototype_locus = DECL_SOURCE_LOCATION (old_decl);
7662 current_function_prototype_built_in
7663 = C_DECL_BUILTIN_PROTOTYPE (old_decl);
7664 current_function_prototype_arg_types
7665 = TYPE_ARG_TYPES (TREE_TYPE (decl1));
7667 if (TREE_PUBLIC (decl1))
7669 /* If there is an external prototype declaration of this
7670 function, record its location but do not copy information
7671 to this decl. This may be an invisible declaration
7672 (built-in or in a scope which has finished) or simply
7673 have more refined argument types than any declaration
7675 struct c_binding *b;
7676 for (b = I_SYMBOL_BINDING (DECL_NAME (decl1)); b; b = b->shadowed)
7677 if (B_IN_SCOPE (b, external_scope))
7681 tree ext_decl, ext_type;
7683 ext_type = b->u.type ? b->u.type : TREE_TYPE (ext_decl);
7684 if (TREE_CODE (ext_type) == FUNCTION_TYPE
7685 && comptypes (TREE_TYPE (TREE_TYPE (decl1)),
7686 TREE_TYPE (ext_type)))
7688 current_function_prototype_locus
7689 = DECL_SOURCE_LOCATION (ext_decl);
7690 current_function_prototype_built_in
7691 = C_DECL_BUILTIN_PROTOTYPE (ext_decl);
7692 current_function_prototype_arg_types
7693 = TYPE_ARG_TYPES (ext_type);
7699 /* Optionally warn of old-fashioned def with no previous prototype. */
7700 if (warn_strict_prototypes
7701 && old_decl != error_mark_node
7702 && !prototype_p (TREE_TYPE (decl1))
7703 && C_DECL_ISNT_PROTOTYPE (old_decl))
7704 warning_at (loc, OPT_Wstrict_prototypes,
7705 "function declaration isn%'t a prototype");
7706 /* Optionally warn of any global def with no previous prototype. */
7707 else if (warn_missing_prototypes
7708 && old_decl != error_mark_node
7709 && TREE_PUBLIC (decl1)
7710 && !MAIN_NAME_P (DECL_NAME (decl1))
7711 && C_DECL_ISNT_PROTOTYPE (old_decl))
7712 warning_at (loc, OPT_Wmissing_prototypes,
7713 "no previous prototype for %qD", decl1);
7714 /* Optionally warn of any def with no previous prototype
7715 if the function has already been used. */
7716 else if (warn_missing_prototypes
7718 && old_decl != error_mark_node
7719 && TREE_USED (old_decl)
7720 && !prototype_p (TREE_TYPE (old_decl)))
7721 warning_at (loc, OPT_Wmissing_prototypes,
7722 "%qD was used with no prototype before its definition", decl1);
7723 /* Optionally warn of any global def with no previous declaration. */
7724 else if (warn_missing_declarations
7725 && TREE_PUBLIC (decl1)
7727 && !MAIN_NAME_P (DECL_NAME (decl1)))
7728 warning_at (loc, OPT_Wmissing_declarations,
7729 "no previous declaration for %qD",
7731 /* Optionally warn of any def with no previous declaration
7732 if the function has already been used. */
7733 else if (warn_missing_declarations
7735 && old_decl != error_mark_node
7736 && TREE_USED (old_decl)
7737 && C_DECL_IMPLICIT (old_decl))
7738 warning_at (loc, OPT_Wmissing_declarations,
7739 "%qD was used with no declaration before its definition", decl1);
7741 /* This function exists in static storage.
7742 (This does not mean `static' in the C sense!) */
7743 TREE_STATIC (decl1) = 1;
7745 /* This is the earliest point at which we might know the assembler
7746 name of the function. Thus, if it's set before this, die horribly. */
7747 gcc_assert (!DECL_ASSEMBLER_NAME_SET_P (decl1));
7749 /* If #pragma weak was used, mark the decl weak now. */
7750 if (current_scope == file_scope)
7751 maybe_apply_pragma_weak (decl1);
7753 /* Warn for unlikely, improbable, or stupid declarations of `main'. */
7754 if (warn_main && MAIN_NAME_P (DECL_NAME (decl1)))
7756 if (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (decl1)))
7757 != integer_type_node)
7758 pedwarn (loc, OPT_Wmain, "return type of %qD is not %<int%>", decl1);
7760 check_main_parameter_types (decl1);
7762 if (!TREE_PUBLIC (decl1))
7763 pedwarn (loc, OPT_Wmain,
7764 "%qD is normally a non-static function", decl1);
7767 /* Record the decl so that the function name is defined.
7768 If we already have a decl for this name, and it is a FUNCTION_DECL,
7769 use the old decl. */
7771 current_function_decl = pushdecl (decl1);
7774 declare_parm_level ();
7776 restype = TREE_TYPE (TREE_TYPE (current_function_decl));
7777 resdecl = build_decl (loc, RESULT_DECL, NULL_TREE, restype);
7778 DECL_ARTIFICIAL (resdecl) = 1;
7779 DECL_IGNORED_P (resdecl) = 1;
7780 DECL_RESULT (current_function_decl) = resdecl;
7782 start_fname_decls ();
7787 /* Subroutine of store_parm_decls which handles new-style function
7788 definitions (prototype format). The parms already have decls, so we
7789 need only record them as in effect and complain if any redundant
7790 old-style parm decls were written. */
7792 store_parm_decls_newstyle (tree fndecl, const struct c_arg_info *arg_info)
7798 if (current_scope->bindings)
7800 error_at (DECL_SOURCE_LOCATION (fndecl),
7801 "old-style parameter declarations in prototyped "
7802 "function definition");
7804 /* Get rid of the old-style declarations. */
7808 /* Don't issue this warning for nested functions, and don't issue this
7809 warning if we got here because ARG_INFO_TYPES was error_mark_node
7810 (this happens when a function definition has just an ellipsis in
7811 its parameter list). */
7812 else if (!in_system_header && !current_function_scope
7813 && arg_info->types != error_mark_node)
7814 warning_at (DECL_SOURCE_LOCATION (fndecl), OPT_Wtraditional,
7815 "traditional C rejects ISO C style function definitions");
7817 /* Now make all the parameter declarations visible in the function body.
7818 We can bypass most of the grunt work of pushdecl. */
7819 for (decl = arg_info->parms; decl; decl = DECL_CHAIN (decl))
7821 DECL_CONTEXT (decl) = current_function_decl;
7822 if (DECL_NAME (decl))
7824 bind (DECL_NAME (decl), decl, current_scope,
7825 /*invisible=*/false, /*nested=*/false,
7827 if (!TREE_USED (decl))
7828 warn_if_shadowing (decl);
7831 error_at (DECL_SOURCE_LOCATION (decl), "parameter name omitted");
7834 /* Record the parameter list in the function declaration. */
7835 DECL_ARGUMENTS (fndecl) = arg_info->parms;
7837 /* Now make all the ancillary declarations visible, likewise. */
7838 for (decl = arg_info->others; decl; decl = DECL_CHAIN (decl))
7840 DECL_CONTEXT (decl) = current_function_decl;
7841 if (DECL_NAME (decl))
7842 bind (DECL_NAME (decl), decl, current_scope,
7843 /*invisible=*/false,
7844 /*nested=*/(TREE_CODE (decl) == FUNCTION_DECL),
7848 /* And all the tag declarations. */
7849 FOR_EACH_VEC_ELT_REVERSE (c_arg_tag, arg_info->tags, ix, tag)
7851 bind (tag->id, tag->type, current_scope,
7852 /*invisible=*/false, /*nested=*/false, UNKNOWN_LOCATION);
7855 /* Subroutine of store_parm_decls which handles old-style function
7856 definitions (separate parameter list and declarations). */
7859 store_parm_decls_oldstyle (tree fndecl, const struct c_arg_info *arg_info)
7861 struct c_binding *b;
7862 tree parm, decl, last;
7863 tree parmids = arg_info->parms;
7864 struct pointer_set_t *seen_args = pointer_set_create ();
7866 if (!in_system_header)
7867 warning_at (DECL_SOURCE_LOCATION (fndecl),
7868 OPT_Wold_style_definition, "old-style function definition");
7870 /* Match each formal parameter name with its declaration. Save each
7871 decl in the appropriate TREE_PURPOSE slot of the parmids chain. */
7872 for (parm = parmids; parm; parm = TREE_CHAIN (parm))
7874 if (TREE_VALUE (parm) == 0)
7876 error_at (DECL_SOURCE_LOCATION (fndecl),
7877 "parameter name missing from parameter list");
7878 TREE_PURPOSE (parm) = 0;
7882 b = I_SYMBOL_BINDING (TREE_VALUE (parm));
7883 if (b && B_IN_CURRENT_SCOPE (b))
7886 /* Skip erroneous parameters. */
7887 if (decl == error_mark_node)
7889 /* If we got something other than a PARM_DECL it is an error. */
7890 if (TREE_CODE (decl) != PARM_DECL)
7891 error_at (DECL_SOURCE_LOCATION (decl),
7892 "%qD declared as a non-parameter", decl);
7893 /* If the declaration is already marked, we have a duplicate
7894 name. Complain and ignore the duplicate. */
7895 else if (pointer_set_contains (seen_args, decl))
7897 error_at (DECL_SOURCE_LOCATION (decl),
7898 "multiple parameters named %qD", decl);
7899 TREE_PURPOSE (parm) = 0;
7902 /* If the declaration says "void", complain and turn it into
7904 else if (VOID_TYPE_P (TREE_TYPE (decl)))
7906 error_at (DECL_SOURCE_LOCATION (decl),
7907 "parameter %qD declared with void type", decl);
7908 TREE_TYPE (decl) = integer_type_node;
7909 DECL_ARG_TYPE (decl) = integer_type_node;
7910 layout_decl (decl, 0);
7912 warn_if_shadowing (decl);
7914 /* If no declaration found, default to int. */
7917 /* FIXME diagnostics: This should be the location of the argument,
7918 not the FNDECL. E.g., for an old-style declaration
7920 int f10(v) { blah; }
7922 We should use the location of the V, not the F10.
7923 Unfortunately, the V is an IDENTIFIER_NODE which has no
7924 location. In the future we need locations for c_arg_info
7927 See gcc.dg/Wshadow-3.c for an example of this problem. */
7928 decl = build_decl (DECL_SOURCE_LOCATION (fndecl),
7929 PARM_DECL, TREE_VALUE (parm), integer_type_node);
7930 DECL_ARG_TYPE (decl) = TREE_TYPE (decl);
7932 warn_if_shadowing (decl);
7935 pedwarn (DECL_SOURCE_LOCATION (decl),
7936 0, "type of %qD defaults to %<int%>", decl);
7938 warning_at (DECL_SOURCE_LOCATION (decl),
7939 OPT_Wmissing_parameter_type,
7940 "type of %qD defaults to %<int%>", decl);
7943 TREE_PURPOSE (parm) = decl;
7944 pointer_set_insert (seen_args, decl);
7947 /* Now examine the parms chain for incomplete declarations
7948 and declarations with no corresponding names. */
7950 for (b = current_scope->bindings; b; b = b->prev)
7953 if (TREE_CODE (parm) != PARM_DECL)
7956 if (TREE_TYPE (parm) != error_mark_node
7957 && !COMPLETE_TYPE_P (TREE_TYPE (parm)))
7959 error_at (DECL_SOURCE_LOCATION (parm),
7960 "parameter %qD has incomplete type", parm);
7961 TREE_TYPE (parm) = error_mark_node;
7964 if (!pointer_set_contains (seen_args, parm))
7966 error_at (DECL_SOURCE_LOCATION (parm),
7967 "declaration for parameter %qD but no such parameter",
7970 /* Pretend the parameter was not missing.
7971 This gets us to a standard state and minimizes
7972 further error messages. */
7973 parmids = chainon (parmids, tree_cons (parm, 0, 0));
7977 /* Chain the declarations together in the order of the list of
7978 names. Store that chain in the function decl, replacing the
7979 list of names. Update the current scope to match. */
7980 DECL_ARGUMENTS (fndecl) = 0;
7982 for (parm = parmids; parm; parm = TREE_CHAIN (parm))
7983 if (TREE_PURPOSE (parm))
7985 if (parm && TREE_PURPOSE (parm))
7987 last = TREE_PURPOSE (parm);
7988 DECL_ARGUMENTS (fndecl) = last;
7990 for (parm = TREE_CHAIN (parm); parm; parm = TREE_CHAIN (parm))
7991 if (TREE_PURPOSE (parm))
7993 DECL_CHAIN (last) = TREE_PURPOSE (parm);
7994 last = TREE_PURPOSE (parm);
7996 DECL_CHAIN (last) = 0;
7999 pointer_set_destroy (seen_args);
8001 /* If there was a previous prototype,
8002 set the DECL_ARG_TYPE of each argument according to
8003 the type previously specified, and report any mismatches. */
8005 if (current_function_prototype_arg_types)
8008 for (parm = DECL_ARGUMENTS (fndecl),
8009 type = current_function_prototype_arg_types;
8010 parm || (type && TREE_VALUE (type) != error_mark_node
8011 && (TYPE_MAIN_VARIANT (TREE_VALUE (type)) != void_type_node));
8012 parm = DECL_CHAIN (parm), type = TREE_CHAIN (type))
8014 if (parm == 0 || type == 0
8015 || TYPE_MAIN_VARIANT (TREE_VALUE (type)) == void_type_node)
8017 if (current_function_prototype_built_in)
8018 warning_at (DECL_SOURCE_LOCATION (fndecl),
8019 0, "number of arguments doesn%'t match "
8020 "built-in prototype");
8023 /* FIXME diagnostics: This should be the location of
8024 FNDECL, but there is bug when a prototype is
8025 declared inside function context, but defined
8026 outside of it (e.g., gcc.dg/pr15698-2.c). In
8027 which case FNDECL gets the location of the
8028 prototype, not the definition. */
8029 error_at (input_location,
8030 "number of arguments doesn%'t match prototype");
8032 error_at (current_function_prototype_locus,
8033 "prototype declaration");
8037 /* Type for passing arg must be consistent with that
8038 declared for the arg. ISO C says we take the unqualified
8039 type for parameters declared with qualified type. */
8040 if (TREE_TYPE (parm) != error_mark_node
8041 && TREE_TYPE (type) != error_mark_node
8042 && !comptypes (TYPE_MAIN_VARIANT (DECL_ARG_TYPE (parm)),
8043 TYPE_MAIN_VARIANT (TREE_VALUE (type))))
8045 if (TYPE_MAIN_VARIANT (TREE_TYPE (parm))
8046 == TYPE_MAIN_VARIANT (TREE_VALUE (type)))
8048 /* Adjust argument to match prototype. E.g. a previous
8049 `int foo(float);' prototype causes
8050 `int foo(x) float x; {...}' to be treated like
8051 `int foo(float x) {...}'. This is particularly
8052 useful for argument types like uid_t. */
8053 DECL_ARG_TYPE (parm) = TREE_TYPE (parm);
8055 if (targetm.calls.promote_prototypes (TREE_TYPE (current_function_decl))
8056 && INTEGRAL_TYPE_P (TREE_TYPE (parm))
8057 && TYPE_PRECISION (TREE_TYPE (parm))
8058 < TYPE_PRECISION (integer_type_node))
8059 DECL_ARG_TYPE (parm) = integer_type_node;
8061 /* ??? Is it possible to get here with a
8062 built-in prototype or will it always have
8063 been diagnosed as conflicting with an
8064 old-style definition and discarded? */
8065 if (current_function_prototype_built_in)
8066 warning_at (DECL_SOURCE_LOCATION (parm),
8067 OPT_pedantic, "promoted argument %qD "
8068 "doesn%'t match built-in prototype", parm);
8071 pedwarn (DECL_SOURCE_LOCATION (parm),
8072 OPT_pedantic, "promoted argument %qD "
8073 "doesn%'t match prototype", parm);
8074 pedwarn (current_function_prototype_locus, OPT_pedantic,
8075 "prototype declaration");
8080 if (current_function_prototype_built_in)
8081 warning_at (DECL_SOURCE_LOCATION (parm),
8082 0, "argument %qD doesn%'t match "
8083 "built-in prototype", parm);
8086 error_at (DECL_SOURCE_LOCATION (parm),
8087 "argument %qD doesn%'t match prototype", parm);
8088 error_at (current_function_prototype_locus,
8089 "prototype declaration");
8094 TYPE_ACTUAL_ARG_TYPES (TREE_TYPE (fndecl)) = 0;
8097 /* Otherwise, create a prototype that would match. */
8101 tree actual = 0, last = 0, type;
8103 for (parm = DECL_ARGUMENTS (fndecl); parm; parm = DECL_CHAIN (parm))
8105 type = tree_cons (NULL_TREE, DECL_ARG_TYPE (parm), NULL_TREE);
8107 TREE_CHAIN (last) = type;
8112 type = tree_cons (NULL_TREE, void_type_node, NULL_TREE);
8114 TREE_CHAIN (last) = type;
8118 /* We are going to assign a new value for the TYPE_ACTUAL_ARG_TYPES
8119 of the type of this function, but we need to avoid having this
8120 affect the types of other similarly-typed functions, so we must
8121 first force the generation of an identical (but separate) type
8122 node for the relevant function type. The new node we create
8123 will be a variant of the main variant of the original function
8126 TREE_TYPE (fndecl) = build_variant_type_copy (TREE_TYPE (fndecl));
8128 TYPE_ACTUAL_ARG_TYPES (TREE_TYPE (fndecl)) = actual;
8132 /* Store parameter declarations passed in ARG_INFO into the current
8133 function declaration. */
8136 store_parm_decls_from (struct c_arg_info *arg_info)
8138 current_function_arg_info = arg_info;
8139 store_parm_decls ();
8142 /* Store the parameter declarations into the current function declaration.
8143 This is called after parsing the parameter declarations, before
8144 digesting the body of the function.
8146 For an old-style definition, construct a prototype out of the old-style
8147 parameter declarations and inject it into the function's type. */
8150 store_parm_decls (void)
8152 tree fndecl = current_function_decl;
8155 /* The argument information block for FNDECL. */
8156 struct c_arg_info *arg_info = current_function_arg_info;
8157 current_function_arg_info = 0;
8159 /* True if this definition is written with a prototype. Note:
8160 despite C99 6.7.5.3p14, we can *not* treat an empty argument
8161 list in a function definition as equivalent to (void) -- an
8162 empty argument list specifies the function has no parameters,
8163 but only (void) sets up a prototype for future calls. */
8164 proto = arg_info->types != 0;
8167 store_parm_decls_newstyle (fndecl, arg_info);
8169 store_parm_decls_oldstyle (fndecl, arg_info);
8171 /* The next call to push_scope will be a function body. */
8173 next_is_function_body = true;
8175 /* Write a record describing this function definition to the prototypes
8176 file (if requested). */
8178 gen_aux_info_record (fndecl, 1, 0, proto);
8180 /* Initialize the RTL code for the function. */
8181 allocate_struct_function (fndecl, false);
8183 /* Begin the statement tree for this function. */
8184 DECL_SAVED_TREE (fndecl) = push_stmt_list ();
8186 /* ??? Insert the contents of the pending sizes list into the function
8187 to be evaluated. The only reason left to have this is
8188 void foo(int n, int array[n++])
8189 because we throw away the array type in favor of a pointer type, and
8190 thus won't naturally see the SAVE_EXPR containing the increment. All
8191 other pending sizes would be handled by gimplify_parameters. */
8193 VEC(tree,gc) *pending_sizes = get_pending_sizes ();
8197 FOR_EACH_VEC_ELT (tree, pending_sizes, i, t)
8201 /* Even though we're inside a function body, we still don't want to
8202 call expand_expr to calculate the size of a variable-sized array.
8203 We haven't necessarily assigned RTL to all variables yet, so it's
8204 not safe to try to expand expressions involving them. */
8205 cfun->dont_save_pending_sizes_p = 1;
8209 /* Finish up a function declaration and compile that function
8210 all the way to assembler language output. Then free the storage
8211 for the function definition.
8213 This is called after parsing the body of the function definition. */
8216 finish_function (void)
8218 tree fndecl = current_function_decl;
8220 if (c_dialect_objc ())
8221 objc_finish_function ();
8223 if (TREE_CODE (fndecl) == FUNCTION_DECL
8224 && targetm.calls.promote_prototypes (TREE_TYPE (fndecl)))
8226 tree args = DECL_ARGUMENTS (fndecl);
8227 for (; args; args = DECL_CHAIN (args))
8229 tree type = TREE_TYPE (args);
8230 if (INTEGRAL_TYPE_P (type)
8231 && TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node))
8232 DECL_ARG_TYPE (args) = integer_type_node;
8236 if (DECL_INITIAL (fndecl) && DECL_INITIAL (fndecl) != error_mark_node)
8237 BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl)) = fndecl;
8239 /* Must mark the RESULT_DECL as being in this function. */
8241 if (DECL_RESULT (fndecl) && DECL_RESULT (fndecl) != error_mark_node)
8242 DECL_CONTEXT (DECL_RESULT (fndecl)) = fndecl;
8244 if (MAIN_NAME_P (DECL_NAME (fndecl)) && flag_hosted
8245 && TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (fndecl)))
8246 == integer_type_node && flag_isoc99)
8248 /* Hack. We don't want the middle-end to warn that this return
8249 is unreachable, so we mark its location as special. Using
8250 UNKNOWN_LOCATION has the problem that it gets clobbered in
8251 annotate_one_with_locus. A cleaner solution might be to
8252 ensure ! should_carry_locus_p (stmt), but that needs a flag.
8254 c_finish_return (BUILTINS_LOCATION, integer_zero_node, NULL_TREE);
8257 /* Tie off the statement tree for this function. */
8258 DECL_SAVED_TREE (fndecl) = pop_stmt_list (DECL_SAVED_TREE (fndecl));
8260 finish_fname_decls ();
8262 /* Complain if there's just no return statement. */
8263 if (warn_return_type
8264 && TREE_CODE (TREE_TYPE (TREE_TYPE (fndecl))) != VOID_TYPE
8265 && !current_function_returns_value && !current_function_returns_null
8266 /* Don't complain if we are no-return. */
8267 && !current_function_returns_abnormally
8268 /* Don't complain if we are declared noreturn. */
8269 && !TREE_THIS_VOLATILE (fndecl)
8270 /* Don't warn for main(). */
8271 && !MAIN_NAME_P (DECL_NAME (fndecl))
8272 /* Or if they didn't actually specify a return type. */
8273 && !C_FUNCTION_IMPLICIT_INT (fndecl)
8274 /* Normally, with -Wreturn-type, flow will complain, but we might
8275 optimize out static functions. */
8276 && !TREE_PUBLIC (fndecl))
8278 warning (OPT_Wreturn_type,
8279 "no return statement in function returning non-void");
8280 TREE_NO_WARNING (fndecl) = 1;
8283 /* Complain about parameters that are only set, but never otherwise used. */
8284 if (warn_unused_but_set_parameter)
8288 for (decl = DECL_ARGUMENTS (fndecl);
8290 decl = DECL_CHAIN (decl))
8291 if (TREE_USED (decl)
8292 && TREE_CODE (decl) == PARM_DECL
8293 && !DECL_READ_P (decl)
8295 && !DECL_ARTIFICIAL (decl)
8296 && !TREE_NO_WARNING (decl))
8297 warning_at (DECL_SOURCE_LOCATION (decl),
8298 OPT_Wunused_but_set_parameter,
8299 "parameter %qD set but not used", decl);
8302 /* Store the end of the function, so that we get good line number
8303 info for the epilogue. */
8304 cfun->function_end_locus = input_location;
8306 /* Finalize the ELF visibility for the function. */
8307 c_determine_visibility (fndecl);
8309 /* For GNU C extern inline functions disregard inline limits. */
8310 if (DECL_EXTERNAL (fndecl)
8311 && DECL_DECLARED_INLINE_P (fndecl))
8312 DECL_DISREGARD_INLINE_LIMITS (fndecl) = 1;
8314 /* Genericize before inlining. Delay genericizing nested functions
8315 until their parent function is genericized. Since finalizing
8316 requires GENERIC, delay that as well. */
8318 if (DECL_INITIAL (fndecl) && DECL_INITIAL (fndecl) != error_mark_node
8319 && !undef_nested_function)
8321 if (!decl_function_context (fndecl))
8323 invoke_plugin_callbacks (PLUGIN_PRE_GENERICIZE, fndecl);
8324 c_genericize (fndecl);
8326 /* ??? Objc emits functions after finalizing the compilation unit.
8327 This should be cleaned up later and this conditional removed. */
8328 if (cgraph_global_info_ready)
8330 cgraph_add_new_function (fndecl, false);
8333 cgraph_finalize_function (fndecl, false);
8337 /* Register this function with cgraph just far enough to get it
8338 added to our parent's nested function list. Handy, since the
8339 C front end doesn't have such a list. */
8340 (void) cgraph_node (fndecl);
8344 if (!decl_function_context (fndecl))
8345 undef_nested_function = false;
8347 /* We're leaving the context of this function, so zap cfun.
8348 It's still in DECL_STRUCT_FUNCTION, and we'll restore it in
8349 tree_rest_of_compilation. */
8351 current_function_decl = NULL;
8354 /* Check the declarations given in a for-loop for satisfying the C99
8355 constraints. If exactly one such decl is found, return it. LOC is
8356 the location of the opening parenthesis of the for loop. The last
8357 parameter allows you to control the "for loop initial declarations
8358 are only allowed in C99 mode". Normally, you should pass
8359 flag_isoc99 as that parameter. But in some cases (Objective-C
8360 foreach loop, for example) we want to run the checks in this
8361 function even if not in C99 mode, so we allow the caller to turn
8362 off the error about not being in C99 mode.
8366 check_for_loop_decls (location_t loc, bool turn_off_iso_c99_error)
8368 struct c_binding *b;
8369 tree one_decl = NULL_TREE;
8372 if (!turn_off_iso_c99_error)
8374 static bool hint = true;
8375 /* If we get here, declarations have been used in a for loop without
8376 the C99 for loop scope. This doesn't make much sense, so don't
8378 error_at (loc, "%<for%> loop initial declarations "
8379 "are only allowed in C99 mode");
8383 "use option -std=c99 or -std=gnu99 to compile your code");
8388 /* C99 subclause 6.8.5 paragraph 3:
8390 [#3] The declaration part of a for statement shall only
8391 declare identifiers for objects having storage class auto or
8394 It isn't clear whether, in this sentence, "identifiers" binds to
8395 "shall only declare" or to "objects" - that is, whether all identifiers
8396 declared must be identifiers for objects, or whether the restriction
8397 only applies to those that are. (A question on this in comp.std.c
8398 in November 2000 received no answer.) We implement the strictest
8399 interpretation, to avoid creating an extension which later causes
8402 for (b = current_scope->bindings; b; b = b->prev)
8405 tree decl = b->decl;
8410 switch (TREE_CODE (decl))
8414 location_t decl_loc = DECL_SOURCE_LOCATION (decl);
8415 if (TREE_STATIC (decl))
8417 "declaration of static variable %qD in %<for%> loop "
8418 "initial declaration", decl);
8419 else if (DECL_EXTERNAL (decl))
8421 "declaration of %<extern%> variable %qD in %<for%> loop "
8422 "initial declaration", decl);
8428 "%<struct %E%> declared in %<for%> loop initial "
8433 "%<union %E%> declared in %<for%> loop initial declaration",
8437 error_at (loc, "%<enum %E%> declared in %<for%> loop "
8438 "initial declaration", id);
8441 error_at (loc, "declaration of non-variable "
8442 "%qD in %<for%> loop initial declaration", decl);
8449 return n_decls == 1 ? one_decl : NULL_TREE;
8452 /* Save and reinitialize the variables
8453 used during compilation of a C function. */
8456 c_push_function_context (void)
8458 struct language_function *p;
8459 p = ggc_alloc_language_function ();
8462 p->base.x_stmt_tree = c_stmt_tree;
8463 p->x_break_label = c_break_label;
8464 p->x_cont_label = c_cont_label;
8465 p->x_switch_stack = c_switch_stack;
8466 p->arg_info = current_function_arg_info;
8467 p->returns_value = current_function_returns_value;
8468 p->returns_null = current_function_returns_null;
8469 p->returns_abnormally = current_function_returns_abnormally;
8470 p->warn_about_return_type = warn_about_return_type;
8472 push_function_context ();
8475 /* Restore the variables used during compilation of a C function. */
8478 c_pop_function_context (void)
8480 struct language_function *p;
8482 pop_function_context ();
8484 cfun->language = NULL;
8486 if (DECL_STRUCT_FUNCTION (current_function_decl) == 0
8487 && DECL_SAVED_TREE (current_function_decl) == NULL_TREE)
8489 /* Stop pointing to the local nodes about to be freed. */
8490 /* But DECL_INITIAL must remain nonzero so we know this
8491 was an actual function definition. */
8492 DECL_INITIAL (current_function_decl) = error_mark_node;
8493 DECL_ARGUMENTS (current_function_decl) = 0;
8496 c_stmt_tree = p->base.x_stmt_tree;
8497 c_break_label = p->x_break_label;
8498 c_cont_label = p->x_cont_label;
8499 c_switch_stack = p->x_switch_stack;
8500 current_function_arg_info = p->arg_info;
8501 current_function_returns_value = p->returns_value;
8502 current_function_returns_null = p->returns_null;
8503 current_function_returns_abnormally = p->returns_abnormally;
8504 warn_about_return_type = p->warn_about_return_type;
8507 /* The functions below are required for functionality of doing
8508 function at once processing in the C front end. Currently these
8509 functions are not called from anywhere in the C front end, but as
8510 these changes continue, that will change. */
8512 /* Returns the stmt_tree (if any) to which statements are currently
8513 being added. If there is no active statement-tree, NULL is
8517 current_stmt_tree (void)
8519 return &c_stmt_tree;
8522 /* Return the global value of T as a symbol. */
8525 identifier_global_value (tree t)
8527 struct c_binding *b;
8529 for (b = I_SYMBOL_BINDING (t); b; b = b->shadowed)
8530 if (B_IN_FILE_SCOPE (b) || B_IN_EXTERNAL_SCOPE (b))
8536 /* Record a builtin type for C. If NAME is non-NULL, it is the name used;
8537 otherwise the name is found in ridpointers from RID_INDEX. */
8540 record_builtin_type (enum rid rid_index, const char *name, tree type)
8544 id = ridpointers[(int) rid_index];
8546 id = get_identifier (name);
8547 decl = build_decl (UNKNOWN_LOCATION, TYPE_DECL, id, type);
8549 if (debug_hooks->type_decl)
8550 debug_hooks->type_decl (decl, false);
8553 /* Build the void_list_node (void_type_node having been created). */
8555 build_void_list_node (void)
8557 tree t = build_tree_list (NULL_TREE, void_type_node);
8561 /* Return a c_parm structure with the given SPECS, ATTRS and DECLARATOR. */
8564 build_c_parm (struct c_declspecs *specs, tree attrs,
8565 struct c_declarator *declarator)
8567 struct c_parm *ret = XOBNEW (&parser_obstack, struct c_parm);
8570 ret->declarator = declarator;
8574 /* Return a declarator with nested attributes. TARGET is the inner
8575 declarator to which these attributes apply. ATTRS are the
8578 struct c_declarator *
8579 build_attrs_declarator (tree attrs, struct c_declarator *target)
8581 struct c_declarator *ret = XOBNEW (&parser_obstack, struct c_declarator);
8582 ret->kind = cdk_attrs;
8583 ret->declarator = target;
8584 ret->u.attrs = attrs;
8588 /* Return a declarator for a function with arguments specified by ARGS
8589 and return type specified by TARGET. */
8591 struct c_declarator *
8592 build_function_declarator (struct c_arg_info *args,
8593 struct c_declarator *target)
8595 struct c_declarator *ret = XOBNEW (&parser_obstack, struct c_declarator);
8596 ret->kind = cdk_function;
8597 ret->declarator = target;
8598 ret->u.arg_info = args;
8602 /* Return a declarator for the identifier IDENT (which may be
8603 NULL_TREE for an abstract declarator). */
8605 struct c_declarator *
8606 build_id_declarator (tree ident)
8608 struct c_declarator *ret = XOBNEW (&parser_obstack, struct c_declarator);
8610 ret->declarator = 0;
8612 /* Default value - may get reset to a more precise location. */
8613 ret->id_loc = input_location;
8617 /* Return something to represent absolute declarators containing a *.
8618 TARGET is the absolute declarator that the * contains.
8619 TYPE_QUALS_ATTRS is a structure for type qualifiers and attributes
8620 to apply to the pointer type. */
8622 struct c_declarator *
8623 make_pointer_declarator (struct c_declspecs *type_quals_attrs,
8624 struct c_declarator *target)
8628 struct c_declarator *itarget = target;
8629 struct c_declarator *ret = XOBNEW (&parser_obstack, struct c_declarator);
8630 if (type_quals_attrs)
8632 attrs = type_quals_attrs->attrs;
8633 quals = quals_from_declspecs (type_quals_attrs);
8634 if (attrs != NULL_TREE)
8635 itarget = build_attrs_declarator (attrs, target);
8637 ret->kind = cdk_pointer;
8638 ret->declarator = itarget;
8639 ret->u.pointer_quals = quals;
8643 /* Return a pointer to a structure for an empty list of declaration
8646 struct c_declspecs *
8647 build_null_declspecs (void)
8649 struct c_declspecs *ret = XOBNEW (&parser_obstack, struct c_declspecs);
8654 ret->typespec_word = cts_none;
8655 ret->storage_class = csc_none;
8656 ret->expr_const_operands = true;
8657 ret->declspecs_seen_p = false;
8658 ret->typespec_kind = ctsk_none;
8659 ret->non_sc_seen_p = false;
8660 ret->typedef_p = false;
8661 ret->explicit_signed_p = false;
8662 ret->deprecated_p = false;
8663 ret->default_int_p = false;
8664 ret->long_p = false;
8665 ret->long_long_p = false;
8666 ret->short_p = false;
8667 ret->signed_p = false;
8668 ret->unsigned_p = false;
8669 ret->complex_p = false;
8670 ret->inline_p = false;
8671 ret->thread_p = false;
8672 ret->const_p = false;
8673 ret->volatile_p = false;
8674 ret->restrict_p = false;
8675 ret->saturating_p = false;
8676 ret->address_space = ADDR_SPACE_GENERIC;
8680 /* Add the address space ADDRSPACE to the declaration specifiers
8681 SPECS, returning SPECS. */
8683 struct c_declspecs *
8684 declspecs_add_addrspace (struct c_declspecs *specs, addr_space_t as)
8686 specs->non_sc_seen_p = true;
8687 specs->declspecs_seen_p = true;
8689 if (!ADDR_SPACE_GENERIC_P (specs->address_space)
8690 && specs->address_space != as)
8691 error ("incompatible address space qualifiers %qs and %qs",
8692 c_addr_space_name (as),
8693 c_addr_space_name (specs->address_space));
8695 specs->address_space = as;
8699 /* Add the type qualifier QUAL to the declaration specifiers SPECS,
8702 struct c_declspecs *
8703 declspecs_add_qual (struct c_declspecs *specs, tree qual)
8707 specs->non_sc_seen_p = true;
8708 specs->declspecs_seen_p = true;
8709 gcc_assert (TREE_CODE (qual) == IDENTIFIER_NODE
8710 && C_IS_RESERVED_WORD (qual));
8711 i = C_RID_CODE (qual);
8715 dupe = specs->const_p;
8716 specs->const_p = true;
8719 dupe = specs->volatile_p;
8720 specs->volatile_p = true;
8723 dupe = specs->restrict_p;
8724 specs->restrict_p = true;
8729 if (dupe && !flag_isoc99)
8730 pedwarn (input_location, OPT_pedantic, "duplicate %qE", qual);
8734 /* Add the type specifier TYPE to the declaration specifiers SPECS,
8737 struct c_declspecs *
8738 declspecs_add_type (location_t loc, struct c_declspecs *specs,
8739 struct c_typespec spec)
8741 tree type = spec.spec;
8742 specs->non_sc_seen_p = true;
8743 specs->declspecs_seen_p = true;
8744 specs->typespec_kind = spec.kind;
8745 if (TREE_DEPRECATED (type))
8746 specs->deprecated_p = true;
8748 /* Handle type specifier keywords. */
8749 if (TREE_CODE (type) == IDENTIFIER_NODE
8750 && C_IS_RESERVED_WORD (type)
8751 && C_RID_CODE (type) != RID_CXX_COMPAT_WARN)
8753 enum rid i = C_RID_CODE (type);
8756 error_at (loc, "two or more data types in declaration specifiers");
8759 if ((int) i <= (int) RID_LAST_MODIFIER)
8761 /* "long", "short", "signed", "unsigned", "_Complex" or "_Sat". */
8766 if (specs->long_long_p)
8768 error_at (loc, "%<long long long%> is too long for GCC");
8773 if (specs->typespec_word == cts_double)
8776 ("both %<long long%> and %<double%> in "
8777 "declaration specifiers"));
8780 pedwarn_c90 (loc, OPT_Wlong_long,
8781 "ISO C90 does not support %<long long%>");
8782 specs->long_long_p = 1;
8787 ("both %<long%> and %<short%> in "
8788 "declaration specifiers"));
8789 else if (specs->typespec_word == cts_void)
8791 ("both %<long%> and %<void%> in "
8792 "declaration specifiers"));
8793 else if (specs->typespec_word == cts_int128)
8795 ("both %<long%> and %<__int128%> in "
8796 "declaration specifiers"));
8797 else if (specs->typespec_word == cts_bool)
8799 ("both %<long%> and %<_Bool%> in "
8800 "declaration specifiers"));
8801 else if (specs->typespec_word == cts_char)
8803 ("both %<long%> and %<char%> in "
8804 "declaration specifiers"));
8805 else if (specs->typespec_word == cts_float)
8807 ("both %<long%> and %<float%> in "
8808 "declaration specifiers"));
8809 else if (specs->typespec_word == cts_dfloat32)
8811 ("both %<long%> and %<_Decimal32%> in "
8812 "declaration specifiers"));
8813 else if (specs->typespec_word == cts_dfloat64)
8815 ("both %<long%> and %<_Decimal64%> in "
8816 "declaration specifiers"));
8817 else if (specs->typespec_word == cts_dfloat128)
8819 ("both %<long%> and %<_Decimal128%> in "
8820 "declaration specifiers"));
8822 specs->long_p = true;
8825 dupe = specs->short_p;
8828 ("both %<long%> and %<short%> in "
8829 "declaration specifiers"));
8830 else if (specs->typespec_word == cts_void)
8832 ("both %<short%> and %<void%> in "
8833 "declaration specifiers"));
8834 else if (specs->typespec_word == cts_int128)
8836 ("both %<short%> and %<__int128%> in "
8837 "declaration specifiers"));
8838 else if (specs->typespec_word == cts_bool)
8840 ("both %<short%> and %<_Bool%> in "
8841 "declaration specifiers"));
8842 else if (specs->typespec_word == cts_char)
8844 ("both %<short%> and %<char%> in "
8845 "declaration specifiers"));
8846 else if (specs->typespec_word == cts_float)
8848 ("both %<short%> and %<float%> in "
8849 "declaration specifiers"));
8850 else if (specs->typespec_word == cts_double)
8852 ("both %<short%> and %<double%> in "
8853 "declaration specifiers"));
8854 else if (specs->typespec_word == cts_dfloat32)
8856 ("both %<short%> and %<_Decimal32%> in "
8857 "declaration specifiers"));
8858 else if (specs->typespec_word == cts_dfloat64)
8860 ("both %<short%> and %<_Decimal64%> in "
8861 "declaration specifiers"));
8862 else if (specs->typespec_word == cts_dfloat128)
8864 ("both %<short%> and %<_Decimal128%> in "
8865 "declaration specifiers"));
8867 specs->short_p = true;
8870 dupe = specs->signed_p;
8871 if (specs->unsigned_p)
8873 ("both %<signed%> and %<unsigned%> in "
8874 "declaration specifiers"));
8875 else if (specs->typespec_word == cts_void)
8877 ("both %<signed%> and %<void%> in "
8878 "declaration specifiers"));
8879 else if (specs->typespec_word == cts_bool)
8881 ("both %<signed%> and %<_Bool%> in "
8882 "declaration specifiers"));
8883 else if (specs->typespec_word == cts_float)
8885 ("both %<signed%> and %<float%> in "
8886 "declaration specifiers"));
8887 else if (specs->typespec_word == cts_double)
8889 ("both %<signed%> and %<double%> in "
8890 "declaration specifiers"));
8891 else if (specs->typespec_word == cts_dfloat32)
8893 ("both %<signed%> and %<_Decimal32%> in "
8894 "declaration specifiers"));
8895 else if (specs->typespec_word == cts_dfloat64)
8897 ("both %<signed%> and %<_Decimal64%> in "
8898 "declaration specifiers"));
8899 else if (specs->typespec_word == cts_dfloat128)
8901 ("both %<signed%> and %<_Decimal128%> in "
8902 "declaration specifiers"));
8904 specs->signed_p = true;
8907 dupe = specs->unsigned_p;
8908 if (specs->signed_p)
8910 ("both %<signed%> and %<unsigned%> in "
8911 "declaration specifiers"));
8912 else if (specs->typespec_word == cts_void)
8914 ("both %<unsigned%> and %<void%> in "
8915 "declaration specifiers"));
8916 else if (specs->typespec_word == cts_bool)
8918 ("both %<unsigned%> and %<_Bool%> in "
8919 "declaration specifiers"));
8920 else if (specs->typespec_word == cts_float)
8922 ("both %<unsigned%> and %<float%> in "
8923 "declaration specifiers"));
8924 else if (specs->typespec_word == cts_double)
8926 ("both %<unsigned%> and %<double%> in "
8927 "declaration specifiers"));
8928 else if (specs->typespec_word == cts_dfloat32)
8930 ("both %<unsigned%> and %<_Decimal32%> in "
8931 "declaration specifiers"));
8932 else if (specs->typespec_word == cts_dfloat64)
8934 ("both %<unsigned%> and %<_Decimal64%> in "
8935 "declaration specifiers"));
8936 else if (specs->typespec_word == cts_dfloat128)
8938 ("both %<unsigned%> and %<_Decimal128%> in "
8939 "declaration specifiers"));
8941 specs->unsigned_p = true;
8944 dupe = specs->complex_p;
8945 if (!flag_isoc99 && !in_system_header)
8946 pedwarn (loc, OPT_pedantic,
8947 "ISO C90 does not support complex types");
8948 if (specs->typespec_word == cts_void)
8950 ("both %<complex%> and %<void%> in "
8951 "declaration specifiers"));
8952 else if (specs->typespec_word == cts_bool)
8954 ("both %<complex%> and %<_Bool%> in "
8955 "declaration specifiers"));
8956 else if (specs->typespec_word == cts_dfloat32)
8958 ("both %<complex%> and %<_Decimal32%> in "
8959 "declaration specifiers"));
8960 else if (specs->typespec_word == cts_dfloat64)
8962 ("both %<complex%> and %<_Decimal64%> in "
8963 "declaration specifiers"));
8964 else if (specs->typespec_word == cts_dfloat128)
8966 ("both %<complex%> and %<_Decimal128%> in "
8967 "declaration specifiers"));
8968 else if (specs->typespec_word == cts_fract)
8970 ("both %<complex%> and %<_Fract%> in "
8971 "declaration specifiers"));
8972 else if (specs->typespec_word == cts_accum)
8974 ("both %<complex%> and %<_Accum%> in "
8975 "declaration specifiers"));
8976 else if (specs->saturating_p)
8978 ("both %<complex%> and %<_Sat%> in "
8979 "declaration specifiers"));
8981 specs->complex_p = true;
8984 dupe = specs->saturating_p;
8985 pedwarn (loc, OPT_pedantic,
8986 "ISO C does not support saturating types");
8987 if (specs->typespec_word == cts_int128)
8990 ("both %<_Sat%> and %<__int128%> in "
8991 "declaration specifiers"));
8993 else if (specs->typespec_word == cts_void)
8995 ("both %<_Sat%> and %<void%> in "
8996 "declaration specifiers"));
8997 else if (specs->typespec_word == cts_bool)
8999 ("both %<_Sat%> and %<_Bool%> in "
9000 "declaration specifiers"));
9001 else if (specs->typespec_word == cts_char)
9003 ("both %<_Sat%> and %<char%> in "
9004 "declaration specifiers"));
9005 else if (specs->typespec_word == cts_int)
9007 ("both %<_Sat%> and %<int%> in "
9008 "declaration specifiers"));
9009 else if (specs->typespec_word == cts_float)
9011 ("both %<_Sat%> and %<float%> in "
9012 "declaration specifiers"));
9013 else if (specs->typespec_word == cts_double)
9015 ("both %<_Sat%> and %<double%> in "
9016 "declaration specifiers"));
9017 else if (specs->typespec_word == cts_dfloat32)
9019 ("both %<_Sat%> and %<_Decimal32%> in "
9020 "declaration specifiers"));
9021 else if (specs->typespec_word == cts_dfloat64)
9023 ("both %<_Sat%> and %<_Decimal64%> in "
9024 "declaration specifiers"));
9025 else if (specs->typespec_word == cts_dfloat128)
9027 ("both %<_Sat%> and %<_Decimal128%> in "
9028 "declaration specifiers"));
9029 else if (specs->complex_p)
9031 ("both %<_Sat%> and %<complex%> in "
9032 "declaration specifiers"));
9034 specs->saturating_p = true;
9041 error_at (loc, "duplicate %qE", type);
9047 /* "void", "_Bool", "char", "int", "float", "double", "_Decimal32",
9048 "__int128", "_Decimal64", "_Decimal128", "_Fract" or "_Accum". */
9049 if (specs->typespec_word != cts_none)
9052 "two or more data types in declaration specifiers");
9058 if (int128_integer_type_node == NULL_TREE)
9060 error_at (loc, "%<__int128%> is not supported for this target");
9063 if (!in_system_header)
9064 pedwarn (loc, OPT_pedantic,
9065 "ISO C does not support %<__int128%> type");
9069 ("both %<__int128%> and %<long%> in "
9070 "declaration specifiers"));
9071 else if (specs->saturating_p)
9073 ("both %<_Sat%> and %<__int128%> in "
9074 "declaration specifiers"));
9075 else if (specs->short_p)
9077 ("both %<__int128%> and %<short%> in "
9078 "declaration specifiers"));
9080 specs->typespec_word = cts_int128;
9085 ("both %<long%> and %<void%> in "
9086 "declaration specifiers"));
9087 else if (specs->short_p)
9089 ("both %<short%> and %<void%> in "
9090 "declaration specifiers"));
9091 else if (specs->signed_p)
9093 ("both %<signed%> and %<void%> in "
9094 "declaration specifiers"));
9095 else if (specs->unsigned_p)
9097 ("both %<unsigned%> and %<void%> in "
9098 "declaration specifiers"));
9099 else if (specs->complex_p)
9101 ("both %<complex%> and %<void%> in "
9102 "declaration specifiers"));
9103 else if (specs->saturating_p)
9105 ("both %<_Sat%> and %<void%> in "
9106 "declaration specifiers"));
9108 specs->typespec_word = cts_void;
9113 ("both %<long%> and %<_Bool%> in "
9114 "declaration specifiers"));
9115 else if (specs->short_p)
9117 ("both %<short%> and %<_Bool%> in "
9118 "declaration specifiers"));
9119 else if (specs->signed_p)
9121 ("both %<signed%> and %<_Bool%> in "
9122 "declaration specifiers"));
9123 else if (specs->unsigned_p)
9125 ("both %<unsigned%> and %<_Bool%> in "
9126 "declaration specifiers"));
9127 else if (specs->complex_p)
9129 ("both %<complex%> and %<_Bool%> in "
9130 "declaration specifiers"));
9131 else if (specs->saturating_p)
9133 ("both %<_Sat%> and %<_Bool%> in "
9134 "declaration specifiers"));
9136 specs->typespec_word = cts_bool;
9141 ("both %<long%> and %<char%> in "
9142 "declaration specifiers"));
9143 else if (specs->short_p)
9145 ("both %<short%> and %<char%> in "
9146 "declaration specifiers"));
9147 else if (specs->saturating_p)
9149 ("both %<_Sat%> and %<char%> in "
9150 "declaration specifiers"));
9152 specs->typespec_word = cts_char;
9155 if (specs->saturating_p)
9157 ("both %<_Sat%> and %<int%> in "
9158 "declaration specifiers"));
9160 specs->typespec_word = cts_int;
9165 ("both %<long%> and %<float%> in "
9166 "declaration specifiers"));
9167 else if (specs->short_p)
9169 ("both %<short%> and %<float%> in "
9170 "declaration specifiers"));
9171 else if (specs->signed_p)
9173 ("both %<signed%> and %<float%> in "
9174 "declaration specifiers"));
9175 else if (specs->unsigned_p)
9177 ("both %<unsigned%> and %<float%> in "
9178 "declaration specifiers"));
9179 else if (specs->saturating_p)
9181 ("both %<_Sat%> and %<float%> in "
9182 "declaration specifiers"));
9184 specs->typespec_word = cts_float;
9187 if (specs->long_long_p)
9189 ("both %<long long%> and %<double%> in "
9190 "declaration specifiers"));
9191 else if (specs->short_p)
9193 ("both %<short%> and %<double%> in "
9194 "declaration specifiers"));
9195 else if (specs->signed_p)
9197 ("both %<signed%> and %<double%> in "
9198 "declaration specifiers"));
9199 else if (specs->unsigned_p)
9201 ("both %<unsigned%> and %<double%> in "
9202 "declaration specifiers"));
9203 else if (specs->saturating_p)
9205 ("both %<_Sat%> and %<double%> in "
9206 "declaration specifiers"));
9208 specs->typespec_word = cts_double;
9215 if (i == RID_DFLOAT32)
9217 else if (i == RID_DFLOAT64)
9220 str = "_Decimal128";
9221 if (specs->long_long_p)
9223 ("both %<long long%> and %<%s%> in "
9224 "declaration specifiers"),
9228 ("both %<long%> and %<%s%> in "
9229 "declaration specifiers"),
9231 else if (specs->short_p)
9233 ("both %<short%> and %<%s%> in "
9234 "declaration specifiers"),
9236 else if (specs->signed_p)
9238 ("both %<signed%> and %<%s%> in "
9239 "declaration specifiers"),
9241 else if (specs->unsigned_p)
9243 ("both %<unsigned%> and %<%s%> in "
9244 "declaration specifiers"),
9246 else if (specs->complex_p)
9248 ("both %<complex%> and %<%s%> in "
9249 "declaration specifiers"),
9251 else if (specs->saturating_p)
9253 ("both %<_Sat%> and %<%s%> in "
9254 "declaration specifiers"),
9256 else if (i == RID_DFLOAT32)
9257 specs->typespec_word = cts_dfloat32;
9258 else if (i == RID_DFLOAT64)
9259 specs->typespec_word = cts_dfloat64;
9261 specs->typespec_word = cts_dfloat128;
9263 if (!targetm.decimal_float_supported_p ())
9265 ("decimal floating point not supported "
9266 "for this target"));
9267 pedwarn (loc, OPT_pedantic,
9268 "ISO C does not support decimal floating point");
9278 if (specs->complex_p)
9280 ("both %<complex%> and %<%s%> in "
9281 "declaration specifiers"),
9283 else if (i == RID_FRACT)
9284 specs->typespec_word = cts_fract;
9286 specs->typespec_word = cts_accum;
9288 if (!targetm.fixed_point_supported_p ())
9290 "fixed-point types not supported for this target");
9291 pedwarn (loc, OPT_pedantic,
9292 "ISO C does not support fixed-point types");
9295 /* ObjC reserved word "id", handled below. */
9301 /* Now we have a typedef (a TYPE_DECL node), an identifier (some
9302 form of ObjC type, cases such as "int" and "long" being handled
9303 above), a TYPE (struct, union, enum and typeof specifiers) or an
9304 ERROR_MARK. In none of these cases may there have previously
9305 been any type specifiers. */
9306 if (specs->type || specs->typespec_word != cts_none
9307 || specs->long_p || specs->short_p || specs->signed_p
9308 || specs->unsigned_p || specs->complex_p)
9309 error_at (loc, "two or more data types in declaration specifiers");
9310 else if (TREE_CODE (type) == TYPE_DECL)
9312 if (TREE_TYPE (type) == error_mark_node)
9313 ; /* Allow the type to default to int to avoid cascading errors. */
9316 specs->type = TREE_TYPE (type);
9317 specs->decl_attr = DECL_ATTRIBUTES (type);
9318 specs->typedef_p = true;
9319 specs->explicit_signed_p = C_TYPEDEF_EXPLICITLY_SIGNED (type);
9321 /* If this typedef name is defined in a struct, then a C++
9322 lookup would return a different value. */
9324 && I_SYMBOL_BINDING (DECL_NAME (type))->in_struct)
9325 warning_at (loc, OPT_Wc___compat,
9326 "C++ lookup of %qD would return a field, not a type",
9329 /* If we are parsing a struct, record that a struct field
9331 if (warn_cxx_compat && struct_parse_info != NULL)
9332 VEC_safe_push (tree, heap, struct_parse_info->typedefs_seen, type);
9335 else if (TREE_CODE (type) == IDENTIFIER_NODE)
9337 tree t = lookup_name (type);
9338 if (!t || TREE_CODE (t) != TYPE_DECL)
9339 error_at (loc, "%qE fails to be a typedef or built in type", type);
9340 else if (TREE_TYPE (t) == error_mark_node)
9343 specs->type = TREE_TYPE (t);
9347 if (TREE_CODE (type) != ERROR_MARK && spec.kind == ctsk_typeof)
9349 specs->typedef_p = true;
9353 specs->expr = build2 (COMPOUND_EXPR, TREE_TYPE (spec.expr),
9354 specs->expr, spec.expr);
9356 specs->expr = spec.expr;
9357 specs->expr_const_operands &= spec.expr_const_operands;
9366 /* Add the storage class specifier or function specifier SCSPEC to the
9367 declaration specifiers SPECS, returning SPECS. */
9369 struct c_declspecs *
9370 declspecs_add_scspec (struct c_declspecs *specs, tree scspec)
9373 enum c_storage_class n = csc_none;
9375 specs->declspecs_seen_p = true;
9376 gcc_assert (TREE_CODE (scspec) == IDENTIFIER_NODE
9377 && C_IS_RESERVED_WORD (scspec));
9378 i = C_RID_CODE (scspec);
9379 if (specs->non_sc_seen_p)
9380 warning (OPT_Wold_style_declaration,
9381 "%qE is not at beginning of declaration", scspec);
9385 /* C99 permits duplicate inline. Although of doubtful utility,
9386 it seems simplest to permit it in gnu89 mode as well, as
9387 there is also little utility in maintaining this as a
9388 difference between gnu89 and C99 inline. */
9390 specs->inline_p = true;
9393 dupe = specs->thread_p;
9394 if (specs->storage_class == csc_auto)
9395 error ("%<__thread%> used with %<auto%>");
9396 else if (specs->storage_class == csc_register)
9397 error ("%<__thread%> used with %<register%>");
9398 else if (specs->storage_class == csc_typedef)
9399 error ("%<__thread%> used with %<typedef%>");
9401 specs->thread_p = true;
9408 /* Diagnose "__thread extern". */
9409 if (specs->thread_p)
9410 error ("%<__thread%> before %<extern%>");
9417 /* Diagnose "__thread static". */
9418 if (specs->thread_p)
9419 error ("%<__thread%> before %<static%>");
9427 if (n != csc_none && n == specs->storage_class)
9430 error ("duplicate %qE", scspec);
9433 if (specs->storage_class != csc_none && n != specs->storage_class)
9435 error ("multiple storage classes in declaration specifiers");
9439 specs->storage_class = n;
9440 if (n != csc_extern && n != csc_static && specs->thread_p)
9442 error ("%<__thread%> used with %qE", scspec);
9443 specs->thread_p = false;
9450 /* Add the attributes ATTRS to the declaration specifiers SPECS,
9453 struct c_declspecs *
9454 declspecs_add_attrs (struct c_declspecs *specs, tree attrs)
9456 specs->attrs = chainon (attrs, specs->attrs);
9457 specs->declspecs_seen_p = true;
9461 /* Combine "long", "short", "signed", "unsigned" and "_Complex" type
9462 specifiers with any other type specifier to determine the resulting
9463 type. This is where ISO C checks on complex types are made, since
9464 "_Complex long" is a prefix of the valid ISO C type "_Complex long
9467 struct c_declspecs *
9468 finish_declspecs (struct c_declspecs *specs)
9470 /* If a type was specified as a whole, we have no modifiers and are
9472 if (specs->type != NULL_TREE)
9474 gcc_assert (!specs->long_p && !specs->long_long_p && !specs->short_p
9475 && !specs->signed_p && !specs->unsigned_p
9476 && !specs->complex_p);
9478 /* Set a dummy type. */
9479 if (TREE_CODE (specs->type) == ERROR_MARK)
9480 specs->type = integer_type_node;
9484 /* If none of "void", "_Bool", "char", "int", "float" or "double"
9485 has been specified, treat it as "int" unless "_Complex" is
9486 present and there are no other specifiers. If we just have
9487 "_Complex", it is equivalent to "_Complex double", but e.g.
9488 "_Complex short" is equivalent to "_Complex short int". */
9489 if (specs->typespec_word == cts_none)
9491 if (specs->saturating_p)
9493 error ("%<_Sat%> is used without %<_Fract%> or %<_Accum%>");
9494 if (!targetm.fixed_point_supported_p ())
9495 error ("fixed-point types not supported for this target");
9496 specs->typespec_word = cts_fract;
9498 else if (specs->long_p || specs->short_p
9499 || specs->signed_p || specs->unsigned_p)
9501 specs->typespec_word = cts_int;
9503 else if (specs->complex_p)
9505 specs->typespec_word = cts_double;
9506 pedwarn (input_location, OPT_pedantic,
9507 "ISO C does not support plain %<complex%> meaning "
9508 "%<double complex%>");
9512 specs->typespec_word = cts_int;
9513 specs->default_int_p = true;
9514 /* We don't diagnose this here because grokdeclarator will
9515 give more specific diagnostics according to whether it is
9516 a function definition. */
9520 /* If "signed" was specified, record this to distinguish "int" and
9521 "signed int" in the case of a bit-field with
9522 -funsigned-bitfields. */
9523 specs->explicit_signed_p = specs->signed_p;
9525 /* Now compute the actual type. */
9526 switch (specs->typespec_word)
9529 gcc_assert (!specs->long_p && !specs->short_p
9530 && !specs->signed_p && !specs->unsigned_p
9531 && !specs->complex_p);
9532 specs->type = void_type_node;
9535 gcc_assert (!specs->long_p && !specs->short_p
9536 && !specs->signed_p && !specs->unsigned_p
9537 && !specs->complex_p);
9538 specs->type = boolean_type_node;
9541 gcc_assert (!specs->long_p && !specs->short_p);
9542 gcc_assert (!(specs->signed_p && specs->unsigned_p));
9543 if (specs->signed_p)
9544 specs->type = signed_char_type_node;
9545 else if (specs->unsigned_p)
9546 specs->type = unsigned_char_type_node;
9548 specs->type = char_type_node;
9549 if (specs->complex_p)
9551 pedwarn (input_location, OPT_pedantic,
9552 "ISO C does not support complex integer types");
9553 specs->type = build_complex_type (specs->type);
9557 gcc_assert (!specs->long_p && !specs->short_p && !specs->long_long_p);
9558 gcc_assert (!(specs->signed_p && specs->unsigned_p));
9559 specs->type = (specs->unsigned_p
9560 ? int128_unsigned_type_node
9561 : int128_integer_type_node);
9562 if (specs->complex_p)
9564 pedwarn (input_location, OPT_pedantic,
9565 "ISO C does not support complex integer types");
9566 specs->type = build_complex_type (specs->type);
9570 gcc_assert (!(specs->long_p && specs->short_p));
9571 gcc_assert (!(specs->signed_p && specs->unsigned_p));
9572 if (specs->long_long_p)
9573 specs->type = (specs->unsigned_p
9574 ? long_long_unsigned_type_node
9575 : long_long_integer_type_node);
9576 else if (specs->long_p)
9577 specs->type = (specs->unsigned_p
9578 ? long_unsigned_type_node
9579 : long_integer_type_node);
9580 else if (specs->short_p)
9581 specs->type = (specs->unsigned_p
9582 ? short_unsigned_type_node
9583 : short_integer_type_node);
9585 specs->type = (specs->unsigned_p
9586 ? unsigned_type_node
9587 : integer_type_node);
9588 if (specs->complex_p)
9590 pedwarn (input_location, OPT_pedantic,
9591 "ISO C does not support complex integer types");
9592 specs->type = build_complex_type (specs->type);
9596 gcc_assert (!specs->long_p && !specs->short_p
9597 && !specs->signed_p && !specs->unsigned_p);
9598 specs->type = (specs->complex_p
9599 ? complex_float_type_node
9603 gcc_assert (!specs->long_long_p && !specs->short_p
9604 && !specs->signed_p && !specs->unsigned_p);
9607 specs->type = (specs->complex_p
9608 ? complex_long_double_type_node
9609 : long_double_type_node);
9613 specs->type = (specs->complex_p
9614 ? complex_double_type_node
9615 : double_type_node);
9621 gcc_assert (!specs->long_p && !specs->long_long_p && !specs->short_p
9622 && !specs->signed_p && !specs->unsigned_p && !specs->complex_p);
9623 if (specs->typespec_word == cts_dfloat32)
9624 specs->type = dfloat32_type_node;
9625 else if (specs->typespec_word == cts_dfloat64)
9626 specs->type = dfloat64_type_node;
9628 specs->type = dfloat128_type_node;
9631 gcc_assert (!specs->complex_p);
9632 if (!targetm.fixed_point_supported_p ())
9633 specs->type = integer_type_node;
9634 else if (specs->saturating_p)
9636 if (specs->long_long_p)
9637 specs->type = specs->unsigned_p
9638 ? sat_unsigned_long_long_fract_type_node
9639 : sat_long_long_fract_type_node;
9640 else if (specs->long_p)
9641 specs->type = specs->unsigned_p
9642 ? sat_unsigned_long_fract_type_node
9643 : sat_long_fract_type_node;
9644 else if (specs->short_p)
9645 specs->type = specs->unsigned_p
9646 ? sat_unsigned_short_fract_type_node
9647 : sat_short_fract_type_node;
9649 specs->type = specs->unsigned_p
9650 ? sat_unsigned_fract_type_node
9651 : sat_fract_type_node;
9655 if (specs->long_long_p)
9656 specs->type = specs->unsigned_p
9657 ? unsigned_long_long_fract_type_node
9658 : long_long_fract_type_node;
9659 else if (specs->long_p)
9660 specs->type = specs->unsigned_p
9661 ? unsigned_long_fract_type_node
9662 : long_fract_type_node;
9663 else if (specs->short_p)
9664 specs->type = specs->unsigned_p
9665 ? unsigned_short_fract_type_node
9666 : short_fract_type_node;
9668 specs->type = specs->unsigned_p
9669 ? unsigned_fract_type_node
9674 gcc_assert (!specs->complex_p);
9675 if (!targetm.fixed_point_supported_p ())
9676 specs->type = integer_type_node;
9677 else if (specs->saturating_p)
9679 if (specs->long_long_p)
9680 specs->type = specs->unsigned_p
9681 ? sat_unsigned_long_long_accum_type_node
9682 : sat_long_long_accum_type_node;
9683 else if (specs->long_p)
9684 specs->type = specs->unsigned_p
9685 ? sat_unsigned_long_accum_type_node
9686 : sat_long_accum_type_node;
9687 else if (specs->short_p)
9688 specs->type = specs->unsigned_p
9689 ? sat_unsigned_short_accum_type_node
9690 : sat_short_accum_type_node;
9692 specs->type = specs->unsigned_p
9693 ? sat_unsigned_accum_type_node
9694 : sat_accum_type_node;
9698 if (specs->long_long_p)
9699 specs->type = specs->unsigned_p
9700 ? unsigned_long_long_accum_type_node
9701 : long_long_accum_type_node;
9702 else if (specs->long_p)
9703 specs->type = specs->unsigned_p
9704 ? unsigned_long_accum_type_node
9705 : long_accum_type_node;
9706 else if (specs->short_p)
9707 specs->type = specs->unsigned_p
9708 ? unsigned_short_accum_type_node
9709 : short_accum_type_node;
9711 specs->type = specs->unsigned_p
9712 ? unsigned_accum_type_node
9723 /* A subroutine of c_write_global_declarations. Perform final processing
9724 on one file scope's declarations (or the external scope's declarations),
9728 c_write_global_declarations_1 (tree globals)
9733 /* Process the decls in the order they were written. */
9734 for (decl = globals; decl; decl = DECL_CHAIN (decl))
9736 /* Check for used but undefined static functions using the C
9737 standard's definition of "used", and set TREE_NO_WARNING so
9738 that check_global_declarations doesn't repeat the check. */
9739 if (TREE_CODE (decl) == FUNCTION_DECL
9740 && DECL_INITIAL (decl) == 0
9741 && DECL_EXTERNAL (decl)
9742 && !TREE_PUBLIC (decl)
9743 && C_DECL_USED (decl))
9745 pedwarn (input_location, 0, "%q+F used but never defined", decl);
9746 TREE_NO_WARNING (decl) = 1;
9749 wrapup_global_declaration_1 (decl);
9755 for (decl = globals; decl; decl = DECL_CHAIN (decl))
9756 reconsider |= wrapup_global_declaration_2 (decl);
9760 for (decl = globals; decl; decl = DECL_CHAIN (decl))
9761 check_global_declaration_1 (decl);
9764 /* A subroutine of c_write_global_declarations Emit debug information for each
9765 of the declarations in GLOBALS. */
9768 c_write_global_declarations_2 (tree globals)
9772 for (decl = globals; decl ; decl = DECL_CHAIN (decl))
9773 debug_hooks->global_decl (decl);
9776 /* Callback to collect a source_ref from a DECL. */
9779 collect_source_ref_cb (tree decl)
9781 if (!DECL_IS_BUILTIN (decl))
9782 collect_source_ref (LOCATION_FILE (decl_sloc (decl, false)));
9785 /* Preserve the external declarations scope across a garbage collect. */
9786 static GTY(()) tree ext_block;
9788 /* Collect all references relevant to SOURCE_FILE. */
9791 collect_all_refs (const char *source_file)
9796 FOR_EACH_VEC_ELT (tree, all_translation_units, i, t)
9797 collect_ada_nodes (BLOCK_VARS (DECL_INITIAL (t)), source_file);
9799 collect_ada_nodes (BLOCK_VARS (ext_block), source_file);
9802 /* Iterate over all global declarations and call CALLBACK. */
9805 for_each_global_decl (void (*callback) (tree decl))
9812 FOR_EACH_VEC_ELT (tree, all_translation_units, i, t)
9814 decls = DECL_INITIAL (t);
9815 for (decl = BLOCK_VARS (decls); decl; decl = TREE_CHAIN (decl))
9819 for (decl = BLOCK_VARS (ext_block); decl; decl = TREE_CHAIN (decl))
9824 c_write_global_declarations (void)
9829 /* We don't want to do this if generating a PCH. */
9833 /* Do the Objective-C stuff. This is where all the Objective-C
9834 module stuff gets generated (symtab, class/protocol/selector
9836 if (c_dialect_objc ())
9837 objc_write_global_declarations ();
9839 /* Close the external scope. */
9840 ext_block = pop_scope ();
9842 gcc_assert (!current_scope);
9844 /* Handle -fdump-ada-spec[-slim]. */
9845 if (dump_enabled_p (TDI_ada))
9847 /* Build a table of files to generate specs for */
9848 if (get_dump_file_info (TDI_ada)->flags & TDF_SLIM)
9849 collect_source_ref (main_input_filename);
9851 for_each_global_decl (collect_source_ref_cb);
9853 dump_ada_specs (collect_all_refs, NULL);
9858 tree tmp = BLOCK_VARS (ext_block);
9860 FILE * stream = dump_begin (TDI_tu, &flags);
9863 dump_node (tmp, flags & ~TDF_SLIM, stream);
9864 dump_end (TDI_tu, stream);
9868 /* Process all file scopes in this compilation, and the external_scope,
9869 through wrapup_global_declarations and check_global_declarations. */
9870 FOR_EACH_VEC_ELT (tree, all_translation_units, i, t)
9871 c_write_global_declarations_1 (BLOCK_VARS (DECL_INITIAL (t)));
9872 c_write_global_declarations_1 (BLOCK_VARS (ext_block));
9874 /* We're done parsing; proceed to optimize and emit assembly.
9875 FIXME: shouldn't be the front end's responsibility to call this. */
9876 cgraph_finalize_compilation_unit ();
9878 /* After cgraph has had a chance to emit everything that's going to
9879 be emitted, output debug information for globals. */
9882 timevar_push (TV_SYMOUT);
9883 FOR_EACH_VEC_ELT (tree, all_translation_units, i, t)
9884 c_write_global_declarations_2 (BLOCK_VARS (DECL_INITIAL (t)));
9885 c_write_global_declarations_2 (BLOCK_VARS (ext_block));
9886 timevar_pop (TV_SYMOUT);
9892 /* Register reserved keyword WORD as qualifier for address space AS. */
9895 c_register_addr_space (const char *word, addr_space_t as)
9897 int rid = RID_FIRST_ADDR_SPACE + as;
9900 /* Address space qualifiers are only supported
9901 in C with GNU extensions enabled. */
9902 if (c_dialect_objc () || flag_no_asm)
9905 id = get_identifier (word);
9906 C_SET_RID_CODE (id, rid);
9907 C_IS_RESERVED_WORD (id) = 1;
9908 ridpointers [rid] = id;
9911 #include "gt-c-decl.h"