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
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"
53 #include "langhooks.h"
54 #include "tree-mudflap.h"
56 #include "tree-iterator.h"
57 #include "diagnostic.h"
58 #include "tree-dump.h"
63 #include "langhooks-def.h"
64 #include "pointer-set.h"
68 /* In grokdeclarator, distinguish syntactic contexts of declarators. */
70 { NORMAL, /* Ordinary declaration */
71 FUNCDEF, /* Function definition */
72 PARM, /* Declaration of parm before function body */
73 FIELD, /* Declaration inside struct or union */
74 TYPENAME}; /* Typename (inside cast or sizeof) */
76 /* States indicating how grokdeclarator() should handle declspecs marked
77 with __attribute__((deprecated)). An object declared as
78 __attribute__((deprecated)) suppresses warnings of uses of other
81 enum deprecated_states {
87 /* Nonzero if we have seen an invalid cross reference
88 to a struct, union, or enum, but not yet printed the message. */
89 tree pending_invalid_xref;
91 /* File and line to appear in the eventual error message. */
92 location_t pending_invalid_xref_location;
94 /* True means we've initialized exception handling. */
95 bool c_eh_initialized_p;
97 /* The file and line that the prototype came from if this is an
98 old-style definition; used for diagnostics in
99 store_parm_decls_oldstyle. */
101 static location_t current_function_prototype_locus;
103 /* Whether this prototype was built-in. */
105 static bool current_function_prototype_built_in;
107 /* The argument type information of this prototype. */
109 static tree current_function_prototype_arg_types;
111 /* The argument information structure for the function currently being
114 static struct c_arg_info *current_function_arg_info;
116 /* The obstack on which parser and related data structures, which are
117 not live beyond their top-level declaration or definition, are
119 struct obstack parser_obstack;
121 /* The current statement tree. */
123 static GTY(()) struct stmt_tree_s c_stmt_tree;
125 /* State saving variables. */
129 /* Linked list of TRANSLATION_UNIT_DECLS for the translation units
130 included in this invocation. Note that the current translation
131 unit is not included in this list. */
133 static GTY(()) tree all_translation_units;
135 /* A list of decls to be made automatically visible in each file scope. */
136 static GTY(()) tree visible_builtins;
138 /* Set to 0 at beginning of a function definition, set to 1 if
139 a return statement that specifies a return value is seen. */
141 int current_function_returns_value;
143 /* Set to 0 at beginning of a function definition, set to 1 if
144 a return statement with no argument is seen. */
146 int current_function_returns_null;
148 /* Set to 0 at beginning of a function definition, set to 1 if
149 a call to a noreturn function is seen. */
151 int current_function_returns_abnormally;
153 /* Set to nonzero by `grokdeclarator' for a function
154 whose return type is defaulted, if warnings for this are desired. */
156 static int warn_about_return_type;
158 /* Nonzero when the current toplevel function contains a declaration
159 of a nested function which is never defined. */
161 static bool undef_nested_function;
163 /* True means global_bindings_p should return false even if the scope stack
164 says we are in file scope. */
165 bool c_override_global_bindings_to_false;
168 /* Each c_binding structure describes one binding of an identifier to
169 a decl. All the decls in a scope - irrespective of namespace - are
170 chained together by the ->prev field, which (as the name implies)
171 runs in reverse order. All the decls in a given namespace bound to
172 a given identifier are chained by the ->shadowed field, which runs
173 from inner to outer scopes.
175 The ->decl field usually points to a DECL node, but there are two
176 exceptions. In the namespace of type tags, the bound entity is a
177 RECORD_TYPE, UNION_TYPE, or ENUMERAL_TYPE node. If an undeclared
178 identifier is encountered, it is bound to error_mark_node to
179 suppress further errors about that identifier in the current
182 The ->u.type field stores the type of the declaration in this scope;
183 if NULL, the type is the type of the ->decl field. This is only of
184 relevance for objects with external or internal linkage which may
185 be redeclared in inner scopes, forming composite types that only
186 persist for the duration of those scopes. In the external scope,
187 this stores the composite of all the types declared for this
188 object, visible or not. The ->inner_comp field (used only at file
189 scope) stores whether an incomplete array type at file scope was
190 completed at an inner scope to an array size other than 1.
192 The ->u.label field is used for labels. It points to a structure
193 which stores additional information used for warnings.
195 The depth field is copied from the scope structure that holds this
196 decl. It is used to preserve the proper ordering of the ->shadowed
197 field (see bind()) and also for a handful of special-case checks.
198 Finally, the invisible bit is true for a decl which should be
199 ignored for purposes of normal name lookup, and the nested bit is
200 true for a decl that's been bound a second time in an inner scope;
201 in all such cases, the binding in the outer scope will have its
202 invisible bit true. */
204 struct GTY((chain_next ("%h.prev"))) c_binding {
205 union GTY(()) { /* first so GTY desc can use decl */
206 tree GTY((tag ("0"))) type; /* the type in this scope */
207 struct c_label_vars * GTY((tag ("1"))) label; /* for warnings */
208 } GTY((desc ("TREE_CODE (%0.decl) == LABEL_DECL"))) u;
209 tree decl; /* the decl bound */
210 tree id; /* the identifier it's bound to */
211 struct c_binding *prev; /* the previous decl in this scope */
212 struct c_binding *shadowed; /* the innermost decl shadowed by this one */
213 unsigned int depth : 28; /* depth of this scope */
214 BOOL_BITFIELD invisible : 1; /* normal lookup should ignore this binding */
215 BOOL_BITFIELD nested : 1; /* do not set DECL_CONTEXT when popping */
216 BOOL_BITFIELD inner_comp : 1; /* incomplete array completed in inner scope */
217 BOOL_BITFIELD in_struct : 1; /* currently defined as struct field */
218 location_t locus; /* location for nested bindings */
220 #define B_IN_SCOPE(b1, b2) ((b1)->depth == (b2)->depth)
221 #define B_IN_CURRENT_SCOPE(b) ((b)->depth == current_scope->depth)
222 #define B_IN_FILE_SCOPE(b) ((b)->depth == 1 /*file_scope->depth*/)
223 #define B_IN_EXTERNAL_SCOPE(b) ((b)->depth == 0 /*external_scope->depth*/)
225 #define I_SYMBOL_BINDING(node) \
226 (((struct lang_identifier *) IDENTIFIER_NODE_CHECK(node))->symbol_binding)
227 #define I_SYMBOL_DECL(node) \
228 (I_SYMBOL_BINDING(node) ? I_SYMBOL_BINDING(node)->decl : 0)
230 #define I_TAG_BINDING(node) \
231 (((struct lang_identifier *) IDENTIFIER_NODE_CHECK(node))->tag_binding)
232 #define I_TAG_DECL(node) \
233 (I_TAG_BINDING(node) ? I_TAG_BINDING(node)->decl : 0)
235 #define I_LABEL_BINDING(node) \
236 (((struct lang_identifier *) IDENTIFIER_NODE_CHECK(node))->label_binding)
237 #define I_LABEL_DECL(node) \
238 (I_LABEL_BINDING(node) ? I_LABEL_BINDING(node)->decl : 0)
240 /* Each C symbol points to three linked lists of c_binding structures.
241 These describe the values of the identifier in the three different
242 namespaces defined by the language. */
244 struct GTY(()) lang_identifier {
245 struct c_common_identifier common_id;
246 struct c_binding *symbol_binding; /* vars, funcs, constants, typedefs */
247 struct c_binding *tag_binding; /* struct/union/enum tags */
248 struct c_binding *label_binding; /* labels */
251 /* Validate c-lang.c's assumptions. */
252 extern char C_SIZEOF_STRUCT_LANG_IDENTIFIER_isnt_accurate
253 [(sizeof(struct lang_identifier) == C_SIZEOF_STRUCT_LANG_IDENTIFIER) ? 1 : -1];
255 /* The resulting tree type. */
257 union GTY((desc ("TREE_CODE (&%h.generic) == IDENTIFIER_NODE"),
258 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
260 union tree_node GTY ((tag ("0"),
261 desc ("tree_node_structure (&%h)")))
263 struct lang_identifier GTY ((tag ("1"))) identifier;
266 /* Track bindings and other things that matter for goto warnings. For
267 efficiency, we do not gather all the decls at the point of
268 definition. Instead, we point into the bindings structure. As
269 scopes are popped, we update these structures and gather the decls
270 that matter at that time. */
272 struct GTY(()) c_spot_bindings {
273 /* The currently open scope which holds bindings defined when the
274 label was defined or the goto statement was found. */
275 struct c_scope *scope;
276 /* The bindings in the scope field which were defined at the point
277 of the label or goto. This lets us look at older or newer
278 bindings in the scope, as appropriate. */
279 struct c_binding *bindings_in_scope;
280 /* The number of statement expressions that have started since this
281 label or goto statement was defined. This is zero if we are at
282 the same statement expression level. It is positive if we are in
283 a statement expression started since this spot. It is negative
284 if this spot was in a statement expression and we have left
287 /* Whether we started in a statement expression but are no longer in
288 it. This is set to true if stmt_exprs ever goes negative. */
292 /* This structure is used to keep track of bindings seen when a goto
293 statement is defined. This is only used if we see the goto
294 statement before we see the label. */
296 struct GTY(()) c_goto_bindings {
297 /* The location of the goto statement. */
299 /* The bindings of the goto statement. */
300 struct c_spot_bindings goto_bindings;
303 typedef struct c_goto_bindings *c_goto_bindings_p;
304 DEF_VEC_P(c_goto_bindings_p);
305 DEF_VEC_ALLOC_P(c_goto_bindings_p,gc);
307 /* The additional information we keep track of for a label binding.
308 These fields are updated as scopes are popped. */
310 struct GTY(()) c_label_vars {
311 /* The shadowed c_label_vars, when one label shadows another (which
312 can only happen using a __label__ declaration). */
313 struct c_label_vars *shadowed;
314 /* The bindings when the label was defined. */
315 struct c_spot_bindings label_bindings;
316 /* A list of decls that we care about: decls about which we should
317 warn if a goto branches to this label from later in the function.
318 Decls are added to this list as scopes are popped. We only add
319 the decls that matter. */
320 VEC(tree,gc) *decls_in_scope;
321 /* A list of goto statements to this label. This is only used for
322 goto statements seen before the label was defined, so that we can
323 issue appropriate warnings for them. */
324 VEC(c_goto_bindings_p,gc) *gotos;
327 /* Each c_scope structure describes the complete contents of one
328 scope. Four scopes are distinguished specially: the innermost or
329 current scope, the innermost function scope, the file scope (always
330 the second to outermost) and the outermost or external scope.
332 Most declarations are recorded in the current scope.
334 All normal label declarations are recorded in the innermost
335 function scope, as are bindings of undeclared identifiers to
336 error_mark_node. (GCC permits nested functions as an extension,
337 hence the 'innermost' qualifier.) Explicitly declared labels
338 (using the __label__ extension) appear in the current scope.
340 Being in the file scope (current_scope == file_scope) causes
341 special behavior in several places below. Also, under some
342 conditions the Objective-C front end records declarations in the
343 file scope even though that isn't the current scope.
345 All declarations with external linkage are recorded in the external
346 scope, even if they aren't visible there; this models the fact that
347 such declarations are visible to the entire program, and (with a
348 bit of cleverness, see pushdecl) allows diagnosis of some violations
349 of C99 6.2.2p7 and 6.2.7p2:
351 If, within the same translation unit, the same identifier appears
352 with both internal and external linkage, the behavior is
355 All declarations that refer to the same object or function shall
356 have compatible type; otherwise, the behavior is undefined.
358 Initially only the built-in declarations, which describe compiler
359 intrinsic functions plus a subset of the standard library, are in
362 The order of the blocks list matters, and it is frequently appended
363 to. To avoid having to walk all the way to the end of the list on
364 each insertion, or reverse the list later, we maintain a pointer to
365 the last list entry. (FIXME: It should be feasible to use a reversed
368 The bindings list is strictly in reverse order of declarations;
369 pop_scope relies on this. */
372 struct GTY((chain_next ("%h.outer"))) c_scope {
373 /* The scope containing this one. */
374 struct c_scope *outer;
376 /* The next outermost function scope. */
377 struct c_scope *outer_function;
379 /* All bindings in this scope. */
380 struct c_binding *bindings;
382 /* For each scope (except the global one), a chain of BLOCK nodes
383 for all the scopes that were entered and exited one level down. */
387 /* The depth of this scope. Used to keep the ->shadowed chain of
388 bindings sorted innermost to outermost. */
389 unsigned int depth : 28;
391 /* True if we are currently filling this scope with parameter
393 BOOL_BITFIELD parm_flag : 1;
395 /* True if we saw [*] in this scope. Used to give an error messages
396 if these appears in a function definition. */
397 BOOL_BITFIELD had_vla_unspec : 1;
399 /* True if we already complained about forward parameter decls
400 in this scope. This prevents double warnings on
401 foo (int a; int b; ...) */
402 BOOL_BITFIELD warned_forward_parm_decls : 1;
404 /* True if this is the outermost block scope of a function body.
405 This scope contains the parameters, the local variables declared
406 in the outermost block, and all the labels (except those in
407 nested functions, or declared at block scope with __label__). */
408 BOOL_BITFIELD function_body : 1;
410 /* True means make a BLOCK for this scope no matter what. */
411 BOOL_BITFIELD keep : 1;
413 /* True means that an unsuffixed float constant is _Decimal64. */
414 BOOL_BITFIELD float_const_decimal64 : 1;
416 /* True if this scope has any label bindings. This is used to speed
417 up searching for labels when popping scopes, particularly since
418 labels are normally only found at function scope. */
419 BOOL_BITFIELD has_label_bindings : 1;
422 /* The scope currently in effect. */
424 static GTY(()) struct c_scope *current_scope;
426 /* The innermost function scope. Ordinary (not explicitly declared)
427 labels, bindings to error_mark_node, and the lazily-created
428 bindings of __func__ and its friends get this scope. */
430 static GTY(()) struct c_scope *current_function_scope;
432 /* The C file scope. This is reset for each input translation unit. */
434 static GTY(()) struct c_scope *file_scope;
436 /* The outermost scope. This is used for all declarations with
437 external linkage, and only these, hence the name. */
439 static GTY(()) struct c_scope *external_scope;
441 /* A chain of c_scope structures awaiting reuse. */
443 static GTY((deletable)) struct c_scope *scope_freelist;
445 /* A chain of c_binding structures awaiting reuse. */
447 static GTY((deletable)) struct c_binding *binding_freelist;
449 /* Append VAR to LIST in scope SCOPE. */
450 #define SCOPE_LIST_APPEND(scope, list, decl) do { \
451 struct c_scope *s_ = (scope); \
453 if (s_->list##_last) \
454 BLOCK_CHAIN (s_->list##_last) = d_; \
457 s_->list##_last = d_; \
460 /* Concatenate FROM in scope FSCOPE onto TO in scope TSCOPE. */
461 #define SCOPE_LIST_CONCAT(tscope, to, fscope, from) do { \
462 struct c_scope *t_ = (tscope); \
463 struct c_scope *f_ = (fscope); \
465 BLOCK_CHAIN (t_->to##_last) = f_->from; \
468 t_->to##_last = f_->from##_last; \
471 /* A c_inline_static structure stores details of a static identifier
472 referenced in a definition of a function that may be an inline
473 definition if no subsequent declaration of that function uses
474 "extern" or does not use "inline". */
476 struct GTY((chain_next ("%h.next"))) c_inline_static {
477 /* The location for a diagnostic. */
480 /* The function that may be an inline definition. */
483 /* The object or function referenced. */
486 /* What sort of reference this is. */
487 enum c_inline_static_type type;
489 /* The next such structure or NULL. */
490 struct c_inline_static *next;
493 /* List of static identifiers used or referenced in functions that may
494 be inline definitions. */
495 static GTY(()) struct c_inline_static *c_inline_statics;
497 /* True means unconditionally make a BLOCK for the next scope pushed. */
499 static bool keep_next_level_flag;
501 /* True means the next call to push_scope will be the outermost scope
502 of a function body, so do not push a new scope, merely cease
503 expecting parameter decls. */
505 static bool next_is_function_body;
507 /* A VEC of pointers to c_binding structures. */
509 typedef struct c_binding *c_binding_ptr;
510 DEF_VEC_P(c_binding_ptr);
511 DEF_VEC_ALLOC_P(c_binding_ptr,heap);
513 /* Information that we keep for a struct or union while it is being
516 struct c_struct_parse_info
518 /* If warn_cxx_compat, a list of types defined within this
520 VEC(tree,heap) *struct_types;
521 /* If warn_cxx_compat, a list of field names which have bindings,
522 and which are defined in this struct, but which are not defined
523 in any enclosing struct. This is used to clear the in_struct
524 field of the c_bindings structure. */
525 VEC(c_binding_ptr,heap) *fields;
526 /* If warn_cxx_compat, a list of typedef names used when defining
527 fields in this struct. */
528 VEC(tree,heap) *typedefs_seen;
531 /* Information for the struct or union currently being parsed, or
532 NULL if not parsing a struct or union. */
533 static struct c_struct_parse_info *struct_parse_info;
535 /* Forward declarations. */
536 static tree lookup_name_in_scope (tree, struct c_scope *);
537 static tree c_make_fname_decl (location_t, tree, int);
538 static tree grokdeclarator (const struct c_declarator *,
539 struct c_declspecs *,
540 enum decl_context, bool, tree *, tree *, tree *,
541 bool *, enum deprecated_states);
542 static tree grokparms (struct c_arg_info *, bool);
543 static void layout_array_type (tree);
545 /* T is a statement. Add it to the statement-tree. This is the
546 C/ObjC version--C++ has a slightly different version of this
552 enum tree_code code = TREE_CODE (t);
554 if (CAN_HAVE_LOCATION_P (t) && code != LABEL_EXPR)
556 if (!EXPR_HAS_LOCATION (t))
557 SET_EXPR_LOCATION (t, input_location);
560 if (code == LABEL_EXPR || code == CASE_LABEL_EXPR)
561 STATEMENT_LIST_HAS_LABEL (cur_stmt_list) = 1;
563 /* Add T to the statement-tree. Non-side-effect statements need to be
564 recorded during statement expressions. */
565 append_to_statement_list_force (t, &cur_stmt_list);
572 c_print_identifier (FILE *file, tree node, int indent)
574 print_node (file, "symbol", I_SYMBOL_DECL (node), indent + 4);
575 print_node (file, "tag", I_TAG_DECL (node), indent + 4);
576 print_node (file, "label", I_LABEL_DECL (node), indent + 4);
577 if (C_IS_RESERVED_WORD (node) && C_RID_CODE (node) != RID_CXX_COMPAT_WARN)
579 tree rid = ridpointers[C_RID_CODE (node)];
580 indent_to (file, indent + 4);
581 fprintf (file, "rid %p \"%s\"",
582 (void *) rid, IDENTIFIER_POINTER (rid));
586 /* Establish a binding between NAME, an IDENTIFIER_NODE, and DECL,
587 which may be any of several kinds of DECL or TYPE or error_mark_node,
588 in the scope SCOPE. */
590 bind (tree name, tree decl, struct c_scope *scope, bool invisible,
591 bool nested, location_t locus)
593 struct c_binding *b, **here;
595 if (binding_freelist)
597 b = binding_freelist;
598 binding_freelist = b->prev;
601 b = GGC_NEW (struct c_binding);
606 b->depth = scope->depth;
607 b->invisible = invisible;
615 b->prev = scope->bindings;
621 switch (TREE_CODE (decl))
623 case LABEL_DECL: here = &I_LABEL_BINDING (name); break;
626 case RECORD_TYPE: here = &I_TAG_BINDING (name); break;
632 case ERROR_MARK: here = &I_SYMBOL_BINDING (name); break;
638 /* Locate the appropriate place in the chain of shadowed decls
639 to insert this binding. Normally, scope == current_scope and
640 this does nothing. */
641 while (*here && (*here)->depth > scope->depth)
642 here = &(*here)->shadowed;
648 /* Clear the binding structure B, stick it on the binding_freelist,
649 and return the former value of b->prev. This is used by pop_scope
650 and get_parm_info to iterate destructively over all the bindings
651 from a given scope. */
652 static struct c_binding *
653 free_binding_and_advance (struct c_binding *b)
655 struct c_binding *prev = b->prev;
657 memset (b, 0, sizeof (struct c_binding));
658 b->prev = binding_freelist;
659 binding_freelist = b;
664 /* Bind a label. Like bind, but skip fields which aren't used for
665 labels, and add the LABEL_VARS value. */
667 bind_label (tree name, tree label, struct c_scope *scope,
668 struct c_label_vars *label_vars)
672 bind (name, label, scope, /*invisible=*/false, /*nested=*/false,
675 scope->has_label_bindings = true;
678 gcc_assert (b->decl == label);
679 label_vars->shadowed = b->u.label;
680 b->u.label = label_vars;
683 /* Hook called at end of compilation to assume 1 elt
684 for a file-scope tentative array defn that wasn't complete before. */
687 c_finish_incomplete_decl (tree decl)
689 if (TREE_CODE (decl) == VAR_DECL)
691 tree type = TREE_TYPE (decl);
692 if (type != error_mark_node
693 && TREE_CODE (type) == ARRAY_TYPE
694 && !DECL_EXTERNAL (decl)
695 && TYPE_DOMAIN (type) == 0)
697 warning_at (DECL_SOURCE_LOCATION (decl),
698 0, "array %q+D assumed to have one element", decl);
700 complete_array_type (&TREE_TYPE (decl), NULL_TREE, true);
702 layout_decl (decl, 0);
707 /* Record that inline function FUNC contains a reference (location
708 LOC) to static DECL (file-scope or function-local according to
712 record_inline_static (location_t loc, tree func, tree decl,
713 enum c_inline_static_type type)
715 struct c_inline_static *csi = GGC_NEW (struct c_inline_static);
717 csi->function = func;
718 csi->static_decl = decl;
720 csi->next = c_inline_statics;
721 c_inline_statics = csi;
724 /* Check for references to static declarations in inline functions at
725 the end of the translation unit and diagnose them if the functions
726 are still inline definitions. */
729 check_inline_statics (void)
731 struct c_inline_static *csi;
732 for (csi = c_inline_statics; csi; csi = csi->next)
734 if (DECL_EXTERNAL (csi->function))
738 pedwarn (csi->location, 0,
739 "%qD is static but used in inline function %qD "
740 "which is not static", csi->static_decl, csi->function);
743 pedwarn (csi->location, 0,
744 "%q+D is static but declared in inline function %qD "
745 "which is not static", csi->static_decl, csi->function);
751 c_inline_statics = NULL;
754 /* Fill in a c_spot_bindings structure. If DEFINING is true, set it
755 for the current state, otherwise set it to uninitialized. */
758 set_spot_bindings (struct c_spot_bindings *p, bool defining)
762 p->scope = current_scope;
763 p->bindings_in_scope = current_scope->bindings;
768 p->bindings_in_scope = NULL;
771 p->left_stmt_expr = false;
774 /* Return true if we will want to say something if a goto statement
778 decl_jump_unsafe (tree decl)
780 if (decl == error_mark_node || TREE_TYPE (decl) == error_mark_node)
783 /* Always warn about crossing variably modified types. */
784 if ((TREE_CODE (decl) == VAR_DECL || TREE_CODE (decl) == TYPE_DECL)
785 && variably_modified_type_p (TREE_TYPE (decl), NULL_TREE))
788 /* Otherwise, only warn if -Wgoto-misses-init and this is an
789 initialized automatic decl. */
790 if (warn_jump_misses_init
791 && TREE_CODE (decl) == VAR_DECL
792 && !TREE_STATIC (decl)
793 && DECL_INITIAL (decl) != NULL_TREE)
799 /* Update spot bindings P as we pop out of SCOPE. Return true if we
800 should push decls for a label. */
803 update_spot_bindings (struct c_scope *scope, struct c_spot_bindings *p)
805 if (p->scope != scope)
807 /* This label or goto is defined in some other scope, or it is a
808 label which is not yet defined. There is nothing to
813 /* Adjust the spot bindings to refer to the bindings already defined
814 in the enclosing scope. */
815 p->scope = scope->outer;
816 p->bindings_in_scope = p->scope->bindings;
821 /* The Objective-C front-end often needs to determine the current scope. */
824 objc_get_current_scope (void)
826 return current_scope;
829 /* The following function is used only by Objective-C. It needs to live here
830 because it accesses the innards of c_scope. */
833 objc_mark_locals_volatile (void *enclosing_blk)
835 struct c_scope *scope;
838 for (scope = current_scope;
839 scope && scope != enclosing_blk;
840 scope = scope->outer)
842 for (b = scope->bindings; b; b = b->prev)
843 objc_volatilize_decl (b->decl);
845 /* Do not climb up past the current function. */
846 if (scope->function_body)
851 /* Nonzero if we are currently in file scope. */
854 global_bindings_p (void)
856 return (current_scope == file_scope && !c_override_global_bindings_to_false
862 keep_next_level (void)
864 keep_next_level_flag = true;
867 /* Set the flag for the FLOAT_CONST_DECIMAL64 pragma being ON. */
870 set_float_const_decimal64 (void)
872 current_scope->float_const_decimal64 = true;
875 /* Clear the flag for the FLOAT_CONST_DECIMAL64 pragma. */
878 clear_float_const_decimal64 (void)
880 current_scope->float_const_decimal64 = false;
883 /* Return nonzero if an unsuffixed float constant is _Decimal64. */
886 float_const_decimal64_p (void)
888 return current_scope->float_const_decimal64;
891 /* Identify this scope as currently being filled with parameters. */
894 declare_parm_level (void)
896 current_scope->parm_flag = true;
902 if (next_is_function_body)
904 /* This is the transition from the parameters to the top level
905 of the function body. These are the same scope
906 (C99 6.2.1p4,6) so we do not push another scope structure.
907 next_is_function_body is set only by store_parm_decls, which
908 in turn is called when and only when we are about to
909 encounter the opening curly brace for the function body.
911 The outermost block of a function always gets a BLOCK node,
912 because the debugging output routines expect that each
913 function has at least one BLOCK. */
914 current_scope->parm_flag = false;
915 current_scope->function_body = true;
916 current_scope->keep = true;
917 current_scope->outer_function = current_function_scope;
918 current_function_scope = current_scope;
920 keep_next_level_flag = false;
921 next_is_function_body = false;
923 /* The FLOAT_CONST_DECIMAL64 pragma applies to nested scopes. */
924 if (current_scope->outer)
925 current_scope->float_const_decimal64
926 = current_scope->outer->float_const_decimal64;
928 current_scope->float_const_decimal64 = false;
932 struct c_scope *scope;
935 scope = scope_freelist;
936 scope_freelist = scope->outer;
939 scope = GGC_CNEW (struct c_scope);
941 /* The FLOAT_CONST_DECIMAL64 pragma applies to nested scopes. */
943 scope->float_const_decimal64 = current_scope->float_const_decimal64;
945 scope->float_const_decimal64 = false;
947 scope->keep = keep_next_level_flag;
948 scope->outer = current_scope;
949 scope->depth = current_scope ? (current_scope->depth + 1) : 0;
951 /* Check for scope depth overflow. Unlikely (2^28 == 268,435,456) but
953 if (current_scope && scope->depth == 0)
956 sorry ("GCC supports only %u nested scopes", scope->depth);
959 current_scope = scope;
960 keep_next_level_flag = false;
964 /* This is called when we are leaving SCOPE. For each label defined
965 in SCOPE, add any appropriate decls to its decls_in_scope fields.
966 These are the decls whose initialization will be skipped by a goto
967 later in the function. */
970 update_label_decls (struct c_scope *scope)
977 if (s->has_label_bindings)
981 for (b = s->bindings; b != NULL; b = b->prev)
983 struct c_label_vars *label_vars;
984 struct c_binding *b1;
986 struct c_goto_bindings *g;
988 if (TREE_CODE (b->decl) != LABEL_DECL)
990 label_vars = b->u.label;
992 b1 = label_vars->label_bindings.bindings_in_scope;
993 if (update_spot_bindings (scope, &label_vars->label_bindings))
995 /* This label is defined in this scope. */
996 for (; b1 != NULL; b1 = b1->prev)
998 /* A goto from later in the function to this
999 label will never see the initialization of
1000 B1, if any. Save it to issue a warning if
1002 if (decl_jump_unsafe (b1->decl))
1003 VEC_safe_push (tree, gc, label_vars->decls_in_scope,
1008 /* Update the bindings of any goto statements associated
1011 VEC_iterate (c_goto_bindings_p, label_vars->gotos, ix, g);
1013 update_spot_bindings (scope, &g->goto_bindings);
1017 /* Don't search beyond the current function. */
1018 if (s == current_function_scope)
1025 /* Set the TYPE_CONTEXT of all of TYPE's variants to CONTEXT. */
1028 set_type_context (tree type, tree context)
1030 for (type = TYPE_MAIN_VARIANT (type); type;
1031 type = TYPE_NEXT_VARIANT (type))
1032 TYPE_CONTEXT (type) = context;
1035 /* Exit a scope. Restore the state of the identifier-decl mappings
1036 that were in effect when this scope was entered. Return a BLOCK
1037 node containing all the DECLs in this scope that are of interest
1038 to debug info generation. */
1043 struct c_scope *scope = current_scope;
1044 tree block, context, p;
1045 struct c_binding *b;
1047 bool functionbody = scope->function_body;
1048 bool keep = functionbody || scope->keep || scope->bindings;
1050 update_label_decls (scope);
1052 /* If appropriate, create a BLOCK to record the decls for the life
1053 of this function. */
1057 block = make_node (BLOCK);
1058 BLOCK_SUBBLOCKS (block) = scope->blocks;
1059 TREE_USED (block) = 1;
1061 /* In each subblock, record that this is its superior. */
1062 for (p = scope->blocks; p; p = BLOCK_CHAIN (p))
1063 BLOCK_SUPERCONTEXT (p) = block;
1065 BLOCK_VARS (block) = 0;
1068 /* The TYPE_CONTEXTs for all of the tagged types belonging to this
1069 scope must be set so that they point to the appropriate
1070 construct, i.e. either to the current FUNCTION_DECL node, or
1071 else to the BLOCK node we just constructed.
1073 Note that for tagged types whose scope is just the formal
1074 parameter list for some function type specification, we can't
1075 properly set their TYPE_CONTEXTs here, because we don't have a
1076 pointer to the appropriate FUNCTION_TYPE node readily available
1077 to us. For those cases, the TYPE_CONTEXTs of the relevant tagged
1078 type nodes get set in `grokdeclarator' as soon as we have created
1079 the FUNCTION_TYPE node which will represent the "scope" for these
1080 "parameter list local" tagged types. */
1081 if (scope->function_body)
1082 context = current_function_decl;
1083 else if (scope == file_scope)
1085 tree file_decl = build_decl (UNKNOWN_LOCATION,
1086 TRANSLATION_UNIT_DECL, 0, 0);
1087 TREE_CHAIN (file_decl) = all_translation_units;
1088 all_translation_units = file_decl;
1089 context = file_decl;
1094 /* Clear all bindings in this scope. */
1095 for (b = scope->bindings; b; b = free_binding_and_advance (b))
1098 switch (TREE_CODE (p))
1101 /* Warnings for unused labels, errors for undefined labels. */
1102 if (TREE_USED (p) && !DECL_INITIAL (p))
1104 error ("label %q+D used but not defined", p);
1105 DECL_INITIAL (p) = error_mark_node;
1108 warn_for_unused_label (p);
1110 /* Labels go in BLOCK_VARS. */
1111 TREE_CHAIN (p) = BLOCK_VARS (block);
1112 BLOCK_VARS (block) = p;
1113 gcc_assert (I_LABEL_BINDING (b->id) == b);
1114 I_LABEL_BINDING (b->id) = b->shadowed;
1116 /* Also pop back to the shadowed label_vars. */
1117 release_tree_vector (b->u.label->decls_in_scope);
1118 b->u.label = b->u.label->shadowed;
1124 set_type_context (p, context);
1126 /* Types may not have tag-names, in which case the type
1127 appears in the bindings list with b->id NULL. */
1130 gcc_assert (I_TAG_BINDING (b->id) == b);
1131 I_TAG_BINDING (b->id) = b->shadowed;
1136 /* Propagate TREE_ADDRESSABLE from nested functions to their
1137 containing functions. */
1138 if (!TREE_ASM_WRITTEN (p)
1139 && DECL_INITIAL (p) != 0
1140 && TREE_ADDRESSABLE (p)
1141 && DECL_ABSTRACT_ORIGIN (p) != 0
1142 && DECL_ABSTRACT_ORIGIN (p) != p)
1143 TREE_ADDRESSABLE (DECL_ABSTRACT_ORIGIN (p)) = 1;
1144 if (!DECL_EXTERNAL (p)
1145 && !DECL_INITIAL (p)
1146 && scope != file_scope
1147 && scope != external_scope)
1149 error ("nested function %q+D declared but never defined", p);
1150 undef_nested_function = true;
1152 else if (DECL_DECLARED_INLINE_P (p)
1154 && !DECL_INITIAL (p))
1156 /* C99 6.7.4p6: "a function with external linkage... declared
1157 with an inline function specifier ... shall also be defined
1158 in the same translation unit." */
1159 if (!flag_gnu89_inline)
1160 pedwarn (input_location, 0,
1161 "inline function %q+D declared but never defined", p);
1162 DECL_EXTERNAL (p) = 1;
1168 /* Warnings for unused variables. */
1170 && !TREE_NO_WARNING (p)
1171 && !DECL_IN_SYSTEM_HEADER (p)
1173 && !DECL_ARTIFICIAL (p)
1174 && scope != file_scope
1175 && scope != external_scope)
1176 warning (OPT_Wunused_variable, "unused variable %q+D", p);
1180 error ("type of array %q+D completed incompatibly with"
1181 " implicit initialization", p);
1188 /* All of these go in BLOCK_VARS, but only if this is the
1189 binding in the home scope. */
1192 TREE_CHAIN (p) = BLOCK_VARS (block);
1193 BLOCK_VARS (block) = p;
1195 else if (VAR_OR_FUNCTION_DECL_P (p))
1197 /* For block local externs add a special
1198 DECL_EXTERNAL decl for debug info generation. */
1199 tree extp = copy_node (p);
1201 DECL_EXTERNAL (extp) = 1;
1202 TREE_STATIC (extp) = 0;
1203 TREE_PUBLIC (extp) = 1;
1204 DECL_INITIAL (extp) = NULL_TREE;
1205 DECL_LANG_SPECIFIC (extp) = NULL;
1206 DECL_CONTEXT (extp) = current_function_decl;
1207 if (TREE_CODE (p) == FUNCTION_DECL)
1209 DECL_RESULT (extp) = NULL_TREE;
1210 DECL_SAVED_TREE (extp) = NULL_TREE;
1211 DECL_STRUCT_FUNCTION (extp) = NULL;
1213 if (b->locus != UNKNOWN_LOCATION)
1214 DECL_SOURCE_LOCATION (extp) = b->locus;
1215 TREE_CHAIN (extp) = BLOCK_VARS (block);
1216 BLOCK_VARS (block) = extp;
1218 /* If this is the file scope, and we are processing more
1219 than one translation unit in this compilation, set
1220 DECL_CONTEXT of each decl to the TRANSLATION_UNIT_DECL.
1221 This makes same_translation_unit_p work, and causes
1222 static declarations to be given disambiguating suffixes. */
1223 if (scope == file_scope && num_in_fnames > 1)
1225 DECL_CONTEXT (p) = context;
1226 if (TREE_CODE (p) == TYPE_DECL)
1227 set_type_context (TREE_TYPE (p), context);
1231 /* Parameters go in DECL_ARGUMENTS, not BLOCK_VARS, and have
1232 already been put there by store_parm_decls. Unused-
1233 parameter warnings are handled by function.c.
1234 error_mark_node obviously does not go in BLOCK_VARS and
1235 does not get unused-variable warnings. */
1238 /* It is possible for a decl not to have a name. We get
1239 here with b->id NULL in this case. */
1242 gcc_assert (I_SYMBOL_BINDING (b->id) == b);
1243 I_SYMBOL_BINDING (b->id) = b->shadowed;
1244 if (b->shadowed && b->shadowed->u.type)
1245 TREE_TYPE (b->shadowed->decl) = b->shadowed->u.type;
1255 /* Dispose of the block that we just made inside some higher level. */
1256 if ((scope->function_body || scope == file_scope) && context)
1258 DECL_INITIAL (context) = block;
1259 BLOCK_SUPERCONTEXT (block) = context;
1261 else if (scope->outer)
1264 SCOPE_LIST_APPEND (scope->outer, blocks, block);
1265 /* If we did not make a block for the scope just exited, any
1266 blocks made for inner scopes must be carried forward so they
1267 will later become subblocks of something else. */
1268 else if (scope->blocks)
1269 SCOPE_LIST_CONCAT (scope->outer, blocks, scope, blocks);
1272 /* Pop the current scope, and free the structure for reuse. */
1273 current_scope = scope->outer;
1274 if (scope->function_body)
1275 current_function_scope = scope->outer_function;
1277 memset (scope, 0, sizeof (struct c_scope));
1278 scope->outer = scope_freelist;
1279 scope_freelist = scope;
1285 push_file_scope (void)
1293 file_scope = current_scope;
1295 start_fname_decls ();
1297 for (decl = visible_builtins; decl; decl = TREE_CHAIN (decl))
1298 bind (DECL_NAME (decl), decl, file_scope,
1299 /*invisible=*/false, /*nested=*/true, DECL_SOURCE_LOCATION (decl));
1303 pop_file_scope (void)
1305 /* In case there were missing closebraces, get us back to the global
1307 while (current_scope != file_scope)
1310 /* __FUNCTION__ is defined at file scope (""). This
1311 call may not be necessary as my tests indicate it
1312 still works without it. */
1313 finish_fname_decls ();
1315 check_inline_statics ();
1317 /* This is the point to write out a PCH if we're doing that.
1318 In that case we do not want to do anything else. */
1321 c_common_write_pch ();
1325 /* Pop off the file scope and close this translation unit. */
1329 maybe_apply_pending_pragma_weaks ();
1330 cgraph_finalize_compilation_unit ();
1333 /* Adjust the bindings for the start of a statement expression. */
1336 c_bindings_start_stmt_expr (struct c_spot_bindings* switch_bindings)
1338 struct c_scope *scope;
1340 for (scope = current_scope; scope != NULL; scope = scope->outer)
1342 struct c_binding *b;
1344 if (!scope->has_label_bindings)
1347 for (b = scope->bindings; b != NULL; b = b->prev)
1349 struct c_label_vars *label_vars;
1351 struct c_goto_bindings *g;
1353 if (TREE_CODE (b->decl) != LABEL_DECL)
1355 label_vars = b->u.label;
1356 ++label_vars->label_bindings.stmt_exprs;
1358 VEC_iterate (c_goto_bindings_p, label_vars->gotos, ix, g);
1360 ++g->goto_bindings.stmt_exprs;
1364 if (switch_bindings != NULL)
1365 ++switch_bindings->stmt_exprs;
1368 /* Adjust the bindings for the end of a statement expression. */
1371 c_bindings_end_stmt_expr (struct c_spot_bindings *switch_bindings)
1373 struct c_scope *scope;
1375 for (scope = current_scope; scope != NULL; scope = scope->outer)
1377 struct c_binding *b;
1379 if (!scope->has_label_bindings)
1382 for (b = scope->bindings; b != NULL; b = b->prev)
1384 struct c_label_vars *label_vars;
1386 struct c_goto_bindings *g;
1388 if (TREE_CODE (b->decl) != LABEL_DECL)
1390 label_vars = b->u.label;
1391 --label_vars->label_bindings.stmt_exprs;
1392 if (label_vars->label_bindings.stmt_exprs < 0)
1394 label_vars->label_bindings.left_stmt_expr = true;
1395 label_vars->label_bindings.stmt_exprs = 0;
1398 VEC_iterate (c_goto_bindings_p, label_vars->gotos, ix, g);
1401 --g->goto_bindings.stmt_exprs;
1402 if (g->goto_bindings.stmt_exprs < 0)
1404 g->goto_bindings.left_stmt_expr = true;
1405 g->goto_bindings.stmt_exprs = 0;
1411 if (switch_bindings != NULL)
1413 --switch_bindings->stmt_exprs;
1414 gcc_assert (switch_bindings->stmt_exprs >= 0);
1418 /* Push a definition or a declaration of struct, union or enum tag "name".
1419 "type" should be the type node.
1420 We assume that the tag "name" is not already defined, and has a location
1423 Note that the definition may really be just a forward reference.
1424 In that case, the TYPE_SIZE will be zero. */
1427 pushtag (location_t loc, tree name, tree type)
1429 /* Record the identifier as the type's name if it has none. */
1430 if (name && !TYPE_NAME (type))
1431 TYPE_NAME (type) = name;
1432 bind (name, type, current_scope, /*invisible=*/false, /*nested=*/false, loc);
1434 /* Create a fake NULL-named TYPE_DECL node whose TREE_TYPE will be the
1435 tagged type we just added to the current scope. This fake
1436 NULL-named TYPE_DECL node helps dwarfout.c to know when it needs
1437 to output a representation of a tagged type, and it also gives
1438 us a convenient place to record the "scope start" address for the
1441 TYPE_STUB_DECL (type) = pushdecl (build_decl (loc,
1442 TYPE_DECL, NULL_TREE, type));
1444 /* An approximation for now, so we can tell this is a function-scope tag.
1445 This will be updated in pop_scope. */
1446 TYPE_CONTEXT (type) = DECL_CONTEXT (TYPE_STUB_DECL (type));
1448 if (warn_cxx_compat && name != NULL_TREE)
1450 struct c_binding *b = I_SYMBOL_BINDING (name);
1453 && b->decl != NULL_TREE
1454 && TREE_CODE (b->decl) == TYPE_DECL
1455 && (B_IN_CURRENT_SCOPE (b)
1456 || (current_scope == file_scope && B_IN_EXTERNAL_SCOPE (b)))
1457 && (TYPE_MAIN_VARIANT (TREE_TYPE (b->decl))
1458 != TYPE_MAIN_VARIANT (type)))
1460 warning_at (loc, OPT_Wc___compat,
1461 ("using %qD as both a typedef and a tag is "
1464 if (b->locus != UNKNOWN_LOCATION)
1465 inform (b->locus, "originally defined here");
1470 /* Subroutine of compare_decls. Allow harmless mismatches in return
1471 and argument types provided that the type modes match. This function
1472 return a unified type given a suitable match, and 0 otherwise. */
1475 match_builtin_function_types (tree newtype, tree oldtype)
1477 tree newrettype, oldrettype;
1478 tree newargs, oldargs;
1479 tree trytype, tryargs;
1481 /* Accept the return type of the new declaration if same modes. */
1482 oldrettype = TREE_TYPE (oldtype);
1483 newrettype = TREE_TYPE (newtype);
1485 if (TYPE_MODE (oldrettype) != TYPE_MODE (newrettype))
1488 oldargs = TYPE_ARG_TYPES (oldtype);
1489 newargs = TYPE_ARG_TYPES (newtype);
1492 while (oldargs || newargs)
1496 || !TREE_VALUE (oldargs)
1497 || !TREE_VALUE (newargs)
1498 || TYPE_MODE (TREE_VALUE (oldargs))
1499 != TYPE_MODE (TREE_VALUE (newargs)))
1502 oldargs = TREE_CHAIN (oldargs);
1503 newargs = TREE_CHAIN (newargs);
1506 trytype = build_function_type (newrettype, tryargs);
1507 return build_type_attribute_variant (trytype, TYPE_ATTRIBUTES (oldtype));
1510 /* Subroutine of diagnose_mismatched_decls. Check for function type
1511 mismatch involving an empty arglist vs a nonempty one and give clearer
1514 diagnose_arglist_conflict (tree newdecl, tree olddecl,
1515 tree newtype, tree oldtype)
1519 if (TREE_CODE (olddecl) != FUNCTION_DECL
1520 || !comptypes (TREE_TYPE (oldtype), TREE_TYPE (newtype))
1521 || !((TYPE_ARG_TYPES (oldtype) == 0 && DECL_INITIAL (olddecl) == 0)
1523 (TYPE_ARG_TYPES (newtype) == 0 && DECL_INITIAL (newdecl) == 0)))
1526 t = TYPE_ARG_TYPES (oldtype);
1528 t = TYPE_ARG_TYPES (newtype);
1529 for (; t; t = TREE_CHAIN (t))
1531 tree type = TREE_VALUE (t);
1533 if (TREE_CHAIN (t) == 0
1534 && TYPE_MAIN_VARIANT (type) != void_type_node)
1536 inform (input_location, "a parameter list with an ellipsis can%'t match "
1537 "an empty parameter name list declaration");
1541 if (c_type_promotes_to (type) != type)
1543 inform (input_location, "an argument type that has a default promotion can%'t match "
1544 "an empty parameter name list declaration");
1550 /* Another subroutine of diagnose_mismatched_decls. OLDDECL is an
1551 old-style function definition, NEWDECL is a prototype declaration.
1552 Diagnose inconsistencies in the argument list. Returns TRUE if
1553 the prototype is compatible, FALSE if not. */
1555 validate_proto_after_old_defn (tree newdecl, tree newtype, tree oldtype)
1557 tree newargs, oldargs;
1560 #define END_OF_ARGLIST(t) ((t) == void_type_node)
1562 oldargs = TYPE_ACTUAL_ARG_TYPES (oldtype);
1563 newargs = TYPE_ARG_TYPES (newtype);
1568 tree oldargtype = TREE_VALUE (oldargs);
1569 tree newargtype = TREE_VALUE (newargs);
1571 if (oldargtype == error_mark_node || newargtype == error_mark_node)
1574 oldargtype = TYPE_MAIN_VARIANT (oldargtype);
1575 newargtype = TYPE_MAIN_VARIANT (newargtype);
1577 if (END_OF_ARGLIST (oldargtype) && END_OF_ARGLIST (newargtype))
1580 /* Reaching the end of just one list means the two decls don't
1581 agree on the number of arguments. */
1582 if (END_OF_ARGLIST (oldargtype))
1584 error ("prototype for %q+D declares more arguments "
1585 "than previous old-style definition", newdecl);
1588 else if (END_OF_ARGLIST (newargtype))
1590 error ("prototype for %q+D declares fewer arguments "
1591 "than previous old-style definition", newdecl);
1595 /* Type for passing arg must be consistent with that declared
1597 else if (!comptypes (oldargtype, newargtype))
1599 error ("prototype for %q+D declares argument %d"
1600 " with incompatible type",
1605 oldargs = TREE_CHAIN (oldargs);
1606 newargs = TREE_CHAIN (newargs);
1610 /* If we get here, no errors were found, but do issue a warning
1611 for this poor-style construct. */
1612 warning (0, "prototype for %q+D follows non-prototype definition",
1615 #undef END_OF_ARGLIST
1618 /* Subroutine of diagnose_mismatched_decls. Report the location of DECL,
1619 first in a pair of mismatched declarations, using the diagnostic
1622 locate_old_decl (tree decl)
1624 if (TREE_CODE (decl) == FUNCTION_DECL && DECL_BUILT_IN (decl))
1626 else if (DECL_INITIAL (decl))
1627 inform (input_location, "previous definition of %q+D was here", decl);
1628 else if (C_DECL_IMPLICIT (decl))
1629 inform (input_location, "previous implicit declaration of %q+D was here", decl);
1631 inform (input_location, "previous declaration of %q+D was here", decl);
1634 /* Subroutine of duplicate_decls. Compare NEWDECL to OLDDECL.
1635 Returns true if the caller should proceed to merge the two, false
1636 if OLDDECL should simply be discarded. As a side effect, issues
1637 all necessary diagnostics for invalid or poor-style combinations.
1638 If it returns true, writes the types of NEWDECL and OLDDECL to
1639 *NEWTYPEP and *OLDTYPEP - these may have been adjusted from
1640 TREE_TYPE (NEWDECL, OLDDECL) respectively. */
1643 diagnose_mismatched_decls (tree newdecl, tree olddecl,
1644 tree *newtypep, tree *oldtypep)
1646 tree newtype, oldtype;
1647 bool pedwarned = false;
1648 bool warned = false;
1651 #define DECL_EXTERN_INLINE(DECL) (DECL_DECLARED_INLINE_P (DECL) \
1652 && DECL_EXTERNAL (DECL))
1654 /* If we have error_mark_node for either decl or type, just discard
1655 the previous decl - we're in an error cascade already. */
1656 if (olddecl == error_mark_node || newdecl == error_mark_node)
1658 *oldtypep = oldtype = TREE_TYPE (olddecl);
1659 *newtypep = newtype = TREE_TYPE (newdecl);
1660 if (oldtype == error_mark_node || newtype == error_mark_node)
1663 /* Two different categories of symbol altogether. This is an error
1664 unless OLDDECL is a builtin. OLDDECL will be discarded in any case. */
1665 if (TREE_CODE (olddecl) != TREE_CODE (newdecl))
1667 if (!(TREE_CODE (olddecl) == FUNCTION_DECL
1668 && DECL_BUILT_IN (olddecl)
1669 && !C_DECL_DECLARED_BUILTIN (olddecl)))
1671 error ("%q+D redeclared as different kind of symbol", newdecl);
1672 locate_old_decl (olddecl);
1674 else if (TREE_PUBLIC (newdecl))
1675 warning (0, "built-in function %q+D declared as non-function",
1678 warning (OPT_Wshadow, "declaration of %q+D shadows "
1679 "a built-in function", newdecl);
1683 /* Enumerators have no linkage, so may only be declared once in a
1685 if (TREE_CODE (olddecl) == CONST_DECL)
1687 error ("redeclaration of enumerator %q+D", newdecl);
1688 locate_old_decl (olddecl);
1692 if (!comptypes (oldtype, newtype))
1694 if (TREE_CODE (olddecl) == FUNCTION_DECL
1695 && DECL_BUILT_IN (olddecl) && !C_DECL_DECLARED_BUILTIN (olddecl))
1697 /* Accept harmless mismatch in function types.
1698 This is for the ffs and fprintf builtins. */
1699 tree trytype = match_builtin_function_types (newtype, oldtype);
1701 if (trytype && comptypes (newtype, trytype))
1702 *oldtypep = oldtype = trytype;
1705 /* If types don't match for a built-in, throw away the
1706 built-in. No point in calling locate_old_decl here, it
1707 won't print anything. */
1708 warning (0, "conflicting types for built-in function %q+D",
1713 else if (TREE_CODE (olddecl) == FUNCTION_DECL
1714 && DECL_IS_BUILTIN (olddecl))
1716 /* A conflicting function declaration for a predeclared
1717 function that isn't actually built in. Objective C uses
1718 these. The new declaration silently overrides everything
1719 but the volatility (i.e. noreturn) indication. See also
1720 below. FIXME: Make Objective C use normal builtins. */
1721 TREE_THIS_VOLATILE (newdecl) |= TREE_THIS_VOLATILE (olddecl);
1724 /* Permit void foo (...) to match int foo (...) if the latter is
1725 the definition and implicit int was used. See
1726 c-torture/compile/920625-2.c. */
1727 else if (TREE_CODE (newdecl) == FUNCTION_DECL && DECL_INITIAL (newdecl)
1728 && TYPE_MAIN_VARIANT (TREE_TYPE (oldtype)) == void_type_node
1729 && TYPE_MAIN_VARIANT (TREE_TYPE (newtype)) == integer_type_node
1730 && C_FUNCTION_IMPLICIT_INT (newdecl) && !DECL_INITIAL (olddecl))
1732 pedwarned = pedwarn (input_location, 0,
1733 "conflicting types for %q+D", newdecl);
1734 /* Make sure we keep void as the return type. */
1735 TREE_TYPE (newdecl) = *newtypep = newtype = oldtype;
1736 C_FUNCTION_IMPLICIT_INT (newdecl) = 0;
1738 /* Permit void foo (...) to match an earlier call to foo (...) with
1739 no declared type (thus, implicitly int). */
1740 else if (TREE_CODE (newdecl) == FUNCTION_DECL
1741 && TYPE_MAIN_VARIANT (TREE_TYPE (newtype)) == void_type_node
1742 && TYPE_MAIN_VARIANT (TREE_TYPE (oldtype)) == integer_type_node
1743 && C_DECL_IMPLICIT (olddecl) && !DECL_INITIAL (olddecl))
1745 pedwarned = pedwarn (input_location, 0,
1746 "conflicting types for %q+D", newdecl);
1747 /* Make sure we keep void as the return type. */
1748 TREE_TYPE (olddecl) = *oldtypep = oldtype = newtype;
1752 if (TYPE_QUALS (newtype) != TYPE_QUALS (oldtype))
1753 error ("conflicting type qualifiers for %q+D", newdecl);
1755 error ("conflicting types for %q+D", newdecl);
1756 diagnose_arglist_conflict (newdecl, olddecl, newtype, oldtype);
1757 locate_old_decl (olddecl);
1762 /* Redeclaration of a type is a constraint violation (6.7.2.3p1),
1763 but silently ignore the redeclaration if either is in a system
1764 header. (Conflicting redeclarations were handled above.) */
1765 if (TREE_CODE (newdecl) == TYPE_DECL)
1767 if (DECL_IN_SYSTEM_HEADER (newdecl)
1768 || DECL_IN_SYSTEM_HEADER (olddecl)
1769 || TREE_NO_WARNING (newdecl)
1770 || TREE_NO_WARNING (olddecl))
1771 return true; /* Allow OLDDECL to continue in use. */
1773 error ("redefinition of typedef %q+D", newdecl);
1774 locate_old_decl (olddecl);
1778 /* Function declarations can either be 'static' or 'extern' (no
1779 qualifier is equivalent to 'extern' - C99 6.2.2p5) and therefore
1780 can never conflict with each other on account of linkage
1781 (6.2.2p4). Multiple definitions are not allowed (6.9p3,5) but
1782 gnu89 mode permits two definitions if one is 'extern inline' and
1783 one is not. The non- extern-inline definition supersedes the
1784 extern-inline definition. */
1786 else if (TREE_CODE (newdecl) == FUNCTION_DECL)
1788 /* If you declare a built-in function name as static, or
1789 define the built-in with an old-style definition (so we
1790 can't validate the argument list) the built-in definition is
1791 overridden, but optionally warn this was a bad choice of name. */
1792 if (DECL_BUILT_IN (olddecl)
1793 && !C_DECL_DECLARED_BUILTIN (olddecl)
1794 && (!TREE_PUBLIC (newdecl)
1795 || (DECL_INITIAL (newdecl)
1796 && !TYPE_ARG_TYPES (TREE_TYPE (newdecl)))))
1798 warning (OPT_Wshadow, "declaration of %q+D shadows "
1799 "a built-in function", newdecl);
1800 /* Discard the old built-in function. */
1804 if (DECL_INITIAL (newdecl))
1806 if (DECL_INITIAL (olddecl))
1808 /* If both decls are in the same TU and the new declaration
1809 isn't overriding an extern inline reject the new decl.
1810 In c99, no overriding is allowed in the same translation
1812 if ((!DECL_EXTERN_INLINE (olddecl)
1813 || DECL_EXTERN_INLINE (newdecl)
1814 || (!flag_gnu89_inline
1815 && (!DECL_DECLARED_INLINE_P (olddecl)
1816 || !lookup_attribute ("gnu_inline",
1817 DECL_ATTRIBUTES (olddecl)))
1818 && (!DECL_DECLARED_INLINE_P (newdecl)
1819 || !lookup_attribute ("gnu_inline",
1820 DECL_ATTRIBUTES (newdecl))))
1822 && same_translation_unit_p (newdecl, olddecl))
1824 error ("redefinition of %q+D", newdecl);
1825 locate_old_decl (olddecl);
1830 /* If we have a prototype after an old-style function definition,
1831 the argument types must be checked specially. */
1832 else if (DECL_INITIAL (olddecl)
1833 && !TYPE_ARG_TYPES (oldtype) && TYPE_ARG_TYPES (newtype)
1834 && TYPE_ACTUAL_ARG_TYPES (oldtype)
1835 && !validate_proto_after_old_defn (newdecl, newtype, oldtype))
1837 locate_old_decl (olddecl);
1840 /* A non-static declaration (even an "extern") followed by a
1841 static declaration is undefined behavior per C99 6.2.2p3-5,7.
1842 The same is true for a static forward declaration at block
1843 scope followed by a non-static declaration/definition at file
1844 scope. Static followed by non-static at the same scope is
1845 not undefined behavior, and is the most convenient way to get
1846 some effects (see e.g. what unwind-dw2-fde-glibc.c does to
1847 the definition of _Unwind_Find_FDE in unwind-dw2-fde.c), but
1848 we do diagnose it if -Wtraditional. */
1849 if (TREE_PUBLIC (olddecl) && !TREE_PUBLIC (newdecl))
1851 /* Two exceptions to the rule. If olddecl is an extern
1852 inline, or a predeclared function that isn't actually
1853 built in, newdecl silently overrides olddecl. The latter
1854 occur only in Objective C; see also above. (FIXME: Make
1855 Objective C use normal builtins.) */
1856 if (!DECL_IS_BUILTIN (olddecl)
1857 && !DECL_EXTERN_INLINE (olddecl))
1859 error ("static declaration of %q+D follows "
1860 "non-static declaration", newdecl);
1861 locate_old_decl (olddecl);
1865 else if (TREE_PUBLIC (newdecl) && !TREE_PUBLIC (olddecl))
1867 if (DECL_CONTEXT (olddecl))
1869 error ("non-static declaration of %q+D follows "
1870 "static declaration", newdecl);
1871 locate_old_decl (olddecl);
1874 else if (warn_traditional)
1876 warned |= warning (OPT_Wtraditional,
1877 "non-static declaration of %q+D "
1878 "follows static declaration", newdecl);
1882 /* Make sure gnu_inline attribute is either not present, or
1883 present on all inline decls. */
1884 if (DECL_DECLARED_INLINE_P (olddecl)
1885 && DECL_DECLARED_INLINE_P (newdecl))
1887 bool newa = lookup_attribute ("gnu_inline",
1888 DECL_ATTRIBUTES (newdecl)) != NULL;
1889 bool olda = lookup_attribute ("gnu_inline",
1890 DECL_ATTRIBUTES (olddecl)) != NULL;
1893 error ("%<gnu_inline%> attribute present on %q+D",
1894 newa ? newdecl : olddecl);
1895 error ("%Jbut not here", newa ? olddecl : newdecl);
1899 else if (TREE_CODE (newdecl) == VAR_DECL)
1901 /* Only variables can be thread-local, and all declarations must
1902 agree on this property. */
1903 if (C_DECL_THREADPRIVATE_P (olddecl) && !DECL_THREAD_LOCAL_P (newdecl))
1905 /* Nothing to check. Since OLDDECL is marked threadprivate
1906 and NEWDECL does not have a thread-local attribute, we
1907 will merge the threadprivate attribute into NEWDECL. */
1910 else if (DECL_THREAD_LOCAL_P (newdecl) != DECL_THREAD_LOCAL_P (olddecl))
1912 if (DECL_THREAD_LOCAL_P (newdecl))
1913 error ("thread-local declaration of %q+D follows "
1914 "non-thread-local declaration", newdecl);
1916 error ("non-thread-local declaration of %q+D follows "
1917 "thread-local declaration", newdecl);
1919 locate_old_decl (olddecl);
1923 /* Multiple initialized definitions are not allowed (6.9p3,5). */
1924 if (DECL_INITIAL (newdecl) && DECL_INITIAL (olddecl))
1926 error ("redefinition of %q+D", newdecl);
1927 locate_old_decl (olddecl);
1931 /* Objects declared at file scope: if the first declaration had
1932 external linkage (even if it was an external reference) the
1933 second must have external linkage as well, or the behavior is
1934 undefined. If the first declaration had internal linkage, then
1935 the second must too, or else be an external reference (in which
1936 case the composite declaration still has internal linkage).
1937 As for function declarations, we warn about the static-then-
1938 extern case only for -Wtraditional. See generally 6.2.2p3-5,7. */
1939 if (DECL_FILE_SCOPE_P (newdecl)
1940 && TREE_PUBLIC (newdecl) != TREE_PUBLIC (olddecl))
1942 if (DECL_EXTERNAL (newdecl))
1944 if (!DECL_FILE_SCOPE_P (olddecl))
1946 error ("extern declaration of %q+D follows "
1947 "declaration with no linkage", newdecl);
1948 locate_old_decl (olddecl);
1951 else if (warn_traditional)
1953 warned |= warning (OPT_Wtraditional,
1954 "non-static declaration of %q+D "
1955 "follows static declaration", newdecl);
1960 if (TREE_PUBLIC (newdecl))
1961 error ("non-static declaration of %q+D follows "
1962 "static declaration", newdecl);
1964 error ("static declaration of %q+D follows "
1965 "non-static declaration", newdecl);
1967 locate_old_decl (olddecl);
1971 /* Two objects with the same name declared at the same block
1972 scope must both be external references (6.7p3). */
1973 else if (!DECL_FILE_SCOPE_P (newdecl))
1975 if (DECL_EXTERNAL (newdecl))
1977 /* Extern with initializer at block scope, which will
1978 already have received an error. */
1980 else if (DECL_EXTERNAL (olddecl))
1982 error ("declaration of %q+D with no linkage follows "
1983 "extern declaration", newdecl);
1984 locate_old_decl (olddecl);
1988 error ("redeclaration of %q+D with no linkage", newdecl);
1989 locate_old_decl (olddecl);
1997 /* All decls must agree on a visibility. */
1998 if (CODE_CONTAINS_STRUCT (TREE_CODE (newdecl), TS_DECL_WITH_VIS)
1999 && DECL_VISIBILITY_SPECIFIED (newdecl) && DECL_VISIBILITY_SPECIFIED (olddecl)
2000 && DECL_VISIBILITY (newdecl) != DECL_VISIBILITY (olddecl))
2002 warned |= warning (0, "redeclaration of %q+D with different visibility "
2003 "(old visibility preserved)", newdecl);
2006 if (TREE_CODE (newdecl) == FUNCTION_DECL)
2008 /* Diagnose inline __attribute__ ((noinline)) which is silly. */
2009 if (DECL_DECLARED_INLINE_P (newdecl)
2010 && lookup_attribute ("noinline", DECL_ATTRIBUTES (olddecl)))
2012 warned |= warning (OPT_Wattributes,
2013 "inline declaration of %qD follows "
2014 "declaration with attribute noinline", newdecl);
2016 else if (DECL_DECLARED_INLINE_P (olddecl)
2017 && lookup_attribute ("noinline", DECL_ATTRIBUTES (newdecl)))
2019 warned |= warning (OPT_Wattributes,
2020 "declaration of %q+D with attribute "
2021 "noinline follows inline declaration ", newdecl);
2024 else /* PARM_DECL, VAR_DECL */
2026 /* Redeclaration of a parameter is a constraint violation (this is
2027 not explicitly stated, but follows from C99 6.7p3 [no more than
2028 one declaration of the same identifier with no linkage in the
2029 same scope, except type tags] and 6.2.2p6 [parameters have no
2030 linkage]). We must check for a forward parameter declaration,
2031 indicated by TREE_ASM_WRITTEN on the old declaration - this is
2032 an extension, the mandatory diagnostic for which is handled by
2033 mark_forward_parm_decls. */
2035 if (TREE_CODE (newdecl) == PARM_DECL
2036 && (!TREE_ASM_WRITTEN (olddecl) || TREE_ASM_WRITTEN (newdecl)))
2038 error ("redefinition of parameter %q+D", newdecl);
2039 locate_old_decl (olddecl);
2044 /* Optional warning for completely redundant decls. */
2045 if (!warned && !pedwarned
2046 && warn_redundant_decls
2047 /* Don't warn about a function declaration followed by a
2049 && !(TREE_CODE (newdecl) == FUNCTION_DECL
2050 && DECL_INITIAL (newdecl) && !DECL_INITIAL (olddecl))
2051 /* Don't warn about redundant redeclarations of builtins. */
2052 && !(TREE_CODE (newdecl) == FUNCTION_DECL
2053 && !DECL_BUILT_IN (newdecl)
2054 && DECL_BUILT_IN (olddecl)
2055 && !C_DECL_DECLARED_BUILTIN (olddecl))
2056 /* Don't warn about an extern followed by a definition. */
2057 && !(DECL_EXTERNAL (olddecl) && !DECL_EXTERNAL (newdecl))
2058 /* Don't warn about forward parameter decls. */
2059 && !(TREE_CODE (newdecl) == PARM_DECL
2060 && TREE_ASM_WRITTEN (olddecl) && !TREE_ASM_WRITTEN (newdecl))
2061 /* Don't warn about a variable definition following a declaration. */
2062 && !(TREE_CODE (newdecl) == VAR_DECL
2063 && DECL_INITIAL (newdecl) && !DECL_INITIAL (olddecl)))
2065 warned = warning (OPT_Wredundant_decls, "redundant redeclaration of %q+D",
2069 /* Report location of previous decl/defn. */
2070 if (warned || pedwarned)
2071 locate_old_decl (olddecl);
2073 #undef DECL_EXTERN_INLINE
2078 /* Subroutine of duplicate_decls. NEWDECL has been found to be
2079 consistent with OLDDECL, but carries new information. Merge the
2080 new information into OLDDECL. This function issues no
2084 merge_decls (tree newdecl, tree olddecl, tree newtype, tree oldtype)
2086 bool new_is_definition = (TREE_CODE (newdecl) == FUNCTION_DECL
2087 && DECL_INITIAL (newdecl) != 0);
2088 bool new_is_prototype = (TREE_CODE (newdecl) == FUNCTION_DECL
2089 && TYPE_ARG_TYPES (TREE_TYPE (newdecl)) != 0);
2090 bool old_is_prototype = (TREE_CODE (olddecl) == FUNCTION_DECL
2091 && TYPE_ARG_TYPES (TREE_TYPE (olddecl)) != 0);
2092 bool extern_changed = false;
2094 /* For real parm decl following a forward decl, rechain the old decl
2095 in its new location and clear TREE_ASM_WRITTEN (it's not a
2096 forward decl anymore). */
2097 if (TREE_CODE (newdecl) == PARM_DECL
2098 && TREE_ASM_WRITTEN (olddecl) && !TREE_ASM_WRITTEN (newdecl))
2100 struct c_binding *b, **here;
2102 for (here = ¤t_scope->bindings; *here; here = &(*here)->prev)
2103 if ((*here)->decl == olddecl)
2110 b->prev = current_scope->bindings;
2111 current_scope->bindings = b;
2113 TREE_ASM_WRITTEN (olddecl) = 0;
2116 DECL_ATTRIBUTES (newdecl)
2117 = targetm.merge_decl_attributes (olddecl, newdecl);
2119 /* Merge the data types specified in the two decls. */
2121 = TREE_TYPE (olddecl)
2122 = composite_type (newtype, oldtype);
2124 /* Lay the type out, unless already done. */
2125 if (!comptypes (oldtype, TREE_TYPE (newdecl)))
2127 if (TREE_TYPE (newdecl) != error_mark_node)
2128 layout_type (TREE_TYPE (newdecl));
2129 if (TREE_CODE (newdecl) != FUNCTION_DECL
2130 && TREE_CODE (newdecl) != TYPE_DECL
2131 && TREE_CODE (newdecl) != CONST_DECL)
2132 layout_decl (newdecl, 0);
2136 /* Since the type is OLDDECL's, make OLDDECL's size go with. */
2137 DECL_SIZE (newdecl) = DECL_SIZE (olddecl);
2138 DECL_SIZE_UNIT (newdecl) = DECL_SIZE_UNIT (olddecl);
2139 DECL_MODE (newdecl) = DECL_MODE (olddecl);
2140 if (DECL_ALIGN (olddecl) > DECL_ALIGN (newdecl))
2142 DECL_ALIGN (newdecl) = DECL_ALIGN (olddecl);
2143 DECL_USER_ALIGN (newdecl) |= DECL_USER_ALIGN (olddecl);
2147 /* Keep the old rtl since we can safely use it. */
2148 if (HAS_RTL_P (olddecl))
2149 COPY_DECL_RTL (olddecl, newdecl);
2151 /* Merge the type qualifiers. */
2152 if (TREE_READONLY (newdecl))
2153 TREE_READONLY (olddecl) = 1;
2155 if (TREE_THIS_VOLATILE (newdecl))
2156 TREE_THIS_VOLATILE (olddecl) = 1;
2158 /* Merge deprecatedness. */
2159 if (TREE_DEPRECATED (newdecl))
2160 TREE_DEPRECATED (olddecl) = 1;
2162 /* If a decl is in a system header and the other isn't, keep the one on the
2163 system header. Otherwise, keep source location of definition rather than
2164 declaration and of prototype rather than non-prototype unless that
2165 prototype is built-in. */
2166 if (CODE_CONTAINS_STRUCT (TREE_CODE (olddecl), TS_DECL_WITH_VIS)
2167 && DECL_IN_SYSTEM_HEADER (olddecl)
2168 && !DECL_IN_SYSTEM_HEADER (newdecl) )
2169 DECL_SOURCE_LOCATION (newdecl) = DECL_SOURCE_LOCATION (olddecl);
2170 else if (CODE_CONTAINS_STRUCT (TREE_CODE (olddecl), TS_DECL_WITH_VIS)
2171 && DECL_IN_SYSTEM_HEADER (newdecl)
2172 && !DECL_IN_SYSTEM_HEADER (olddecl))
2173 DECL_SOURCE_LOCATION (olddecl) = DECL_SOURCE_LOCATION (newdecl);
2174 else if ((DECL_INITIAL (newdecl) == 0 && DECL_INITIAL (olddecl) != 0)
2175 || (old_is_prototype && !new_is_prototype
2176 && !C_DECL_BUILTIN_PROTOTYPE (olddecl)))
2177 DECL_SOURCE_LOCATION (newdecl) = DECL_SOURCE_LOCATION (olddecl);
2179 /* Merge the initialization information. */
2180 if (DECL_INITIAL (newdecl) == 0)
2181 DECL_INITIAL (newdecl) = DECL_INITIAL (olddecl);
2183 /* Merge the threadprivate attribute. */
2184 if (TREE_CODE (olddecl) == VAR_DECL && C_DECL_THREADPRIVATE_P (olddecl))
2186 DECL_TLS_MODEL (newdecl) = DECL_TLS_MODEL (olddecl);
2187 C_DECL_THREADPRIVATE_P (newdecl) = 1;
2190 if (CODE_CONTAINS_STRUCT (TREE_CODE (olddecl), TS_DECL_WITH_VIS))
2192 /* Merge the section attribute.
2193 We want to issue an error if the sections conflict but that
2194 must be done later in decl_attributes since we are called
2195 before attributes are assigned. */
2196 if (DECL_SECTION_NAME (newdecl) == NULL_TREE)
2197 DECL_SECTION_NAME (newdecl) = DECL_SECTION_NAME (olddecl);
2199 /* Copy the assembler name.
2200 Currently, it can only be defined in the prototype. */
2201 COPY_DECL_ASSEMBLER_NAME (olddecl, newdecl);
2203 /* Use visibility of whichever declaration had it specified */
2204 if (DECL_VISIBILITY_SPECIFIED (olddecl))
2206 DECL_VISIBILITY (newdecl) = DECL_VISIBILITY (olddecl);
2207 DECL_VISIBILITY_SPECIFIED (newdecl) = 1;
2210 if (TREE_CODE (newdecl) == FUNCTION_DECL)
2212 DECL_STATIC_CONSTRUCTOR(newdecl) |= DECL_STATIC_CONSTRUCTOR(olddecl);
2213 DECL_STATIC_DESTRUCTOR (newdecl) |= DECL_STATIC_DESTRUCTOR (olddecl);
2214 DECL_NO_LIMIT_STACK (newdecl) |= DECL_NO_LIMIT_STACK (olddecl);
2215 DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (newdecl)
2216 |= DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (olddecl);
2217 TREE_THIS_VOLATILE (newdecl) |= TREE_THIS_VOLATILE (olddecl);
2218 DECL_IS_MALLOC (newdecl) |= DECL_IS_MALLOC (olddecl);
2219 DECL_IS_OPERATOR_NEW (newdecl) |= DECL_IS_OPERATOR_NEW (olddecl);
2220 TREE_READONLY (newdecl) |= TREE_READONLY (olddecl);
2221 DECL_PURE_P (newdecl) |= DECL_PURE_P (olddecl);
2222 DECL_IS_NOVOPS (newdecl) |= DECL_IS_NOVOPS (olddecl);
2225 /* Merge the storage class information. */
2226 merge_weak (newdecl, olddecl);
2228 /* For functions, static overrides non-static. */
2229 if (TREE_CODE (newdecl) == FUNCTION_DECL)
2231 TREE_PUBLIC (newdecl) &= TREE_PUBLIC (olddecl);
2232 /* This is since we don't automatically
2233 copy the attributes of NEWDECL into OLDDECL. */
2234 TREE_PUBLIC (olddecl) = TREE_PUBLIC (newdecl);
2235 /* If this clears `static', clear it in the identifier too. */
2236 if (!TREE_PUBLIC (olddecl))
2237 TREE_PUBLIC (DECL_NAME (olddecl)) = 0;
2241 /* In c99, 'extern' declaration before (or after) 'inline' means this
2242 function is not DECL_EXTERNAL, unless 'gnu_inline' attribute
2244 if (TREE_CODE (newdecl) == FUNCTION_DECL
2245 && !flag_gnu89_inline
2246 && (DECL_DECLARED_INLINE_P (newdecl)
2247 || DECL_DECLARED_INLINE_P (olddecl))
2248 && (!DECL_DECLARED_INLINE_P (newdecl)
2249 || !DECL_DECLARED_INLINE_P (olddecl)
2250 || !DECL_EXTERNAL (olddecl))
2251 && DECL_EXTERNAL (newdecl)
2252 && !lookup_attribute ("gnu_inline", DECL_ATTRIBUTES (newdecl))
2253 && !current_function_decl)
2254 DECL_EXTERNAL (newdecl) = 0;
2256 if (DECL_EXTERNAL (newdecl))
2258 TREE_STATIC (newdecl) = TREE_STATIC (olddecl);
2259 DECL_EXTERNAL (newdecl) = DECL_EXTERNAL (olddecl);
2261 /* An extern decl does not override previous storage class. */
2262 TREE_PUBLIC (newdecl) = TREE_PUBLIC (olddecl);
2263 if (!DECL_EXTERNAL (newdecl))
2265 DECL_CONTEXT (newdecl) = DECL_CONTEXT (olddecl);
2266 DECL_COMMON (newdecl) = DECL_COMMON (olddecl);
2271 TREE_STATIC (olddecl) = TREE_STATIC (newdecl);
2272 TREE_PUBLIC (olddecl) = TREE_PUBLIC (newdecl);
2275 if (TREE_CODE (newdecl) == FUNCTION_DECL)
2277 /* If we're redefining a function previously defined as extern
2278 inline, make sure we emit debug info for the inline before we
2279 throw it away, in case it was inlined into a function that
2280 hasn't been written out yet. */
2281 if (new_is_definition && DECL_INITIAL (olddecl))
2282 /* The new defn must not be inline. */
2283 DECL_UNINLINABLE (newdecl) = 1;
2286 /* If either decl says `inline', this fn is inline, unless
2287 its definition was passed already. */
2288 if (DECL_DECLARED_INLINE_P (newdecl)
2289 || DECL_DECLARED_INLINE_P (olddecl))
2290 DECL_DECLARED_INLINE_P (newdecl) = 1;
2292 DECL_UNINLINABLE (newdecl) = DECL_UNINLINABLE (olddecl)
2293 = (DECL_UNINLINABLE (newdecl) || DECL_UNINLINABLE (olddecl));
2295 DECL_DISREGARD_INLINE_LIMITS (newdecl)
2296 = DECL_DISREGARD_INLINE_LIMITS (olddecl)
2297 = (DECL_DISREGARD_INLINE_LIMITS (newdecl)
2298 || DECL_DISREGARD_INLINE_LIMITS (olddecl));
2301 if (DECL_BUILT_IN (olddecl))
2303 /* If redeclaring a builtin function, it stays built in.
2304 But it gets tagged as having been declared. */
2305 DECL_BUILT_IN_CLASS (newdecl) = DECL_BUILT_IN_CLASS (olddecl);
2306 DECL_FUNCTION_CODE (newdecl) = DECL_FUNCTION_CODE (olddecl);
2307 C_DECL_DECLARED_BUILTIN (newdecl) = 1;
2308 if (new_is_prototype)
2309 C_DECL_BUILTIN_PROTOTYPE (newdecl) = 0;
2311 C_DECL_BUILTIN_PROTOTYPE (newdecl)
2312 = C_DECL_BUILTIN_PROTOTYPE (olddecl);
2315 /* Preserve function specific target and optimization options */
2316 if (DECL_FUNCTION_SPECIFIC_TARGET (olddecl)
2317 && !DECL_FUNCTION_SPECIFIC_TARGET (newdecl))
2318 DECL_FUNCTION_SPECIFIC_TARGET (newdecl)
2319 = DECL_FUNCTION_SPECIFIC_TARGET (olddecl);
2321 if (DECL_FUNCTION_SPECIFIC_OPTIMIZATION (olddecl)
2322 && !DECL_FUNCTION_SPECIFIC_OPTIMIZATION (newdecl))
2323 DECL_FUNCTION_SPECIFIC_OPTIMIZATION (newdecl)
2324 = DECL_FUNCTION_SPECIFIC_OPTIMIZATION (olddecl);
2326 /* Also preserve various other info from the definition. */
2327 if (!new_is_definition)
2330 DECL_RESULT (newdecl) = DECL_RESULT (olddecl);
2331 DECL_INITIAL (newdecl) = DECL_INITIAL (olddecl);
2332 DECL_STRUCT_FUNCTION (newdecl) = DECL_STRUCT_FUNCTION (olddecl);
2333 DECL_SAVED_TREE (newdecl) = DECL_SAVED_TREE (olddecl);
2334 gimple_set_body (newdecl, gimple_body (olddecl));
2335 DECL_ARGUMENTS (newdecl) = copy_list (DECL_ARGUMENTS (olddecl));
2336 for (t = DECL_ARGUMENTS (newdecl); t ; t = TREE_CHAIN (t))
2337 DECL_CONTEXT (t) = newdecl;
2339 /* See if we've got a function to instantiate from. */
2340 if (DECL_SAVED_TREE (olddecl))
2341 DECL_ABSTRACT_ORIGIN (newdecl)
2342 = DECL_ABSTRACT_ORIGIN (olddecl);
2346 extern_changed = DECL_EXTERNAL (olddecl) && !DECL_EXTERNAL (newdecl);
2348 /* Merge the USED information. */
2349 if (TREE_USED (olddecl))
2350 TREE_USED (newdecl) = 1;
2351 else if (TREE_USED (newdecl))
2352 TREE_USED (olddecl) = 1;
2354 /* Copy most of the decl-specific fields of NEWDECL into OLDDECL.
2355 But preserve OLDDECL's DECL_UID and DECL_CONTEXT. */
2357 unsigned olddecl_uid = DECL_UID (olddecl);
2358 tree olddecl_context = DECL_CONTEXT (olddecl);
2359 tree olddecl_arguments = NULL;
2360 if (TREE_CODE (olddecl) == FUNCTION_DECL)
2361 olddecl_arguments = DECL_ARGUMENTS (olddecl);
2363 memcpy ((char *) olddecl + sizeof (struct tree_common),
2364 (char *) newdecl + sizeof (struct tree_common),
2365 sizeof (struct tree_decl_common) - sizeof (struct tree_common));
2366 switch (TREE_CODE (olddecl))
2369 gimple_set_body (olddecl, gimple_body (newdecl));
2379 memcpy ((char *) olddecl + sizeof (struct tree_decl_common),
2380 (char *) newdecl + sizeof (struct tree_decl_common),
2381 tree_code_size (TREE_CODE (olddecl)) - sizeof (struct tree_decl_common));
2386 memcpy ((char *) olddecl + sizeof (struct tree_decl_common),
2387 (char *) newdecl + sizeof (struct tree_decl_common),
2388 sizeof (struct tree_decl_non_common) - sizeof (struct tree_decl_common));
2390 DECL_UID (olddecl) = olddecl_uid;
2391 DECL_CONTEXT (olddecl) = olddecl_context;
2392 if (TREE_CODE (olddecl) == FUNCTION_DECL)
2393 DECL_ARGUMENTS (olddecl) = olddecl_arguments;
2396 /* If OLDDECL had its DECL_RTL instantiated, re-invoke make_decl_rtl
2397 so that encode_section_info has a chance to look at the new decl
2398 flags and attributes. */
2399 if (DECL_RTL_SET_P (olddecl)
2400 && (TREE_CODE (olddecl) == FUNCTION_DECL
2401 || (TREE_CODE (olddecl) == VAR_DECL
2402 && TREE_STATIC (olddecl))))
2403 make_decl_rtl (olddecl);
2405 /* If we changed a function from DECL_EXTERNAL to !DECL_EXTERNAL,
2406 and the definition is coming from the old version, cgraph needs
2407 to be called again. */
2408 if (extern_changed && !new_is_definition
2409 && TREE_CODE (olddecl) == FUNCTION_DECL && DECL_INITIAL (olddecl))
2410 cgraph_mark_if_needed (olddecl);
2413 /* Handle when a new declaration NEWDECL has the same name as an old
2414 one OLDDECL in the same binding contour. Prints an error message
2417 If safely possible, alter OLDDECL to look like NEWDECL, and return
2418 true. Otherwise, return false. */
2421 duplicate_decls (tree newdecl, tree olddecl)
2423 tree newtype = NULL, oldtype = NULL;
2425 if (!diagnose_mismatched_decls (newdecl, olddecl, &newtype, &oldtype))
2427 /* Avoid `unused variable' and other warnings for OLDDECL. */
2428 TREE_NO_WARNING (olddecl) = 1;
2432 merge_decls (newdecl, olddecl, newtype, oldtype);
2437 /* Check whether decl-node NEW_DECL shadows an existing declaration. */
2439 warn_if_shadowing (tree new_decl)
2441 struct c_binding *b;
2443 /* Shadow warnings wanted? */
2445 /* No shadow warnings for internally generated vars. */
2446 || DECL_IS_BUILTIN (new_decl)
2447 /* No shadow warnings for vars made for inlining. */
2448 || DECL_FROM_INLINE (new_decl))
2451 /* Is anything being shadowed? Invisible decls do not count. */
2452 for (b = I_SYMBOL_BINDING (DECL_NAME (new_decl)); b; b = b->shadowed)
2453 if (b->decl && b->decl != new_decl && !b->invisible)
2455 tree old_decl = b->decl;
2457 if (old_decl == error_mark_node)
2459 warning (OPT_Wshadow, "declaration of %q+D shadows previous "
2460 "non-variable", new_decl);
2463 else if (TREE_CODE (old_decl) == PARM_DECL)
2464 warning (OPT_Wshadow, "declaration of %q+D shadows a parameter",
2466 else if (DECL_FILE_SCOPE_P (old_decl))
2467 warning (OPT_Wshadow, "declaration of %q+D shadows a global "
2468 "declaration", new_decl);
2469 else if (TREE_CODE (old_decl) == FUNCTION_DECL
2470 && DECL_BUILT_IN (old_decl))
2472 warning (OPT_Wshadow, "declaration of %q+D shadows "
2473 "a built-in function", new_decl);
2477 warning (OPT_Wshadow, "declaration of %q+D shadows a previous local",
2480 warning (OPT_Wshadow, "%Jshadowed declaration is here", old_decl);
2486 /* Record a decl-node X as belonging to the current lexical scope.
2487 Check for errors (such as an incompatible declaration for the same
2488 name already seen in the same scope).
2490 Returns either X or an old decl for the same name.
2491 If an old decl is returned, it may have been smashed
2492 to agree with what X says. */
2497 tree name = DECL_NAME (x);
2498 struct c_scope *scope = current_scope;
2499 struct c_binding *b;
2500 bool nested = false;
2501 location_t locus = DECL_SOURCE_LOCATION (x);
2503 /* Must set DECL_CONTEXT for everything not at file scope or
2504 DECL_FILE_SCOPE_P won't work. Local externs don't count
2505 unless they have initializers (which generate code). */
2506 if (current_function_decl
2507 && ((TREE_CODE (x) != FUNCTION_DECL && TREE_CODE (x) != VAR_DECL)
2508 || DECL_INITIAL (x) || !DECL_EXTERNAL (x)))
2509 DECL_CONTEXT (x) = current_function_decl;
2511 /* Anonymous decls are just inserted in the scope. */
2514 bind (name, x, scope, /*invisible=*/false, /*nested=*/false,
2519 /* First, see if there is another declaration with the same name in
2520 the current scope. If there is, duplicate_decls may do all the
2521 work for us. If duplicate_decls returns false, that indicates
2522 two incompatible decls in the same scope; we are to silently
2523 replace the old one (duplicate_decls has issued all appropriate
2524 diagnostics). In particular, we should not consider possible
2525 duplicates in the external scope, or shadowing. */
2526 b = I_SYMBOL_BINDING (name);
2527 if (b && B_IN_SCOPE (b, scope))
2529 struct c_binding *b_ext, *b_use;
2530 tree type = TREE_TYPE (x);
2531 tree visdecl = b->decl;
2532 tree vistype = TREE_TYPE (visdecl);
2533 if (TREE_CODE (TREE_TYPE (x)) == ARRAY_TYPE
2534 && COMPLETE_TYPE_P (TREE_TYPE (x)))
2535 b->inner_comp = false;
2538 /* If this is an external linkage declaration, we should check
2539 for compatibility with the type in the external scope before
2540 setting the type at this scope based on the visible
2541 information only. */
2542 if (TREE_PUBLIC (x) && TREE_PUBLIC (visdecl))
2544 while (b_ext && !B_IN_EXTERNAL_SCOPE (b_ext))
2545 b_ext = b_ext->shadowed;
2550 TREE_TYPE (b_use->decl) = b_use->u.type;
2553 if (duplicate_decls (x, b_use->decl))
2557 /* Save the updated type in the external scope and
2558 restore the proper type for this scope. */
2560 if (comptypes (vistype, type))
2561 thistype = composite_type (vistype, type);
2563 thistype = TREE_TYPE (b_use->decl);
2564 b_use->u.type = TREE_TYPE (b_use->decl);
2565 if (TREE_CODE (b_use->decl) == FUNCTION_DECL
2566 && DECL_BUILT_IN (b_use->decl))
2568 = build_type_attribute_variant (thistype,
2571 TREE_TYPE (b_use->decl) = thistype;
2576 goto skip_external_and_shadow_checks;
2579 /* All declarations with external linkage, and all external
2580 references, go in the external scope, no matter what scope is
2581 current. However, the binding in that scope is ignored for
2582 purposes of normal name lookup. A separate binding structure is
2583 created in the requested scope; this governs the normal
2584 visibility of the symbol.
2586 The binding in the externals scope is used exclusively for
2587 detecting duplicate declarations of the same object, no matter
2588 what scope they are in; this is what we do here. (C99 6.2.7p2:
2589 All declarations that refer to the same object or function shall
2590 have compatible type; otherwise, the behavior is undefined.) */
2591 if (DECL_EXTERNAL (x) || scope == file_scope)
2593 tree type = TREE_TYPE (x);
2596 bool type_saved = false;
2597 if (b && !B_IN_EXTERNAL_SCOPE (b)
2598 && (TREE_CODE (b->decl) == FUNCTION_DECL
2599 || TREE_CODE (b->decl) == VAR_DECL)
2600 && DECL_FILE_SCOPE_P (b->decl))
2603 vistype = TREE_TYPE (visdecl);
2605 if (scope != file_scope
2606 && !DECL_IN_SYSTEM_HEADER (x))
2607 warning (OPT_Wnested_externs, "nested extern declaration of %qD", x);
2609 while (b && !B_IN_EXTERNAL_SCOPE (b))
2611 /* If this decl might be modified, save its type. This is
2612 done here rather than when the decl is first bound
2613 because the type may change after first binding, through
2614 being completed or through attributes being added. If we
2615 encounter multiple such decls, only the first should have
2616 its type saved; the others will already have had their
2617 proper types saved and the types will not have changed as
2618 their scopes will not have been re-entered. */
2619 if (DECL_P (b->decl) && DECL_FILE_SCOPE_P (b->decl) && !type_saved)
2621 b->u.type = TREE_TYPE (b->decl);
2624 if (B_IN_FILE_SCOPE (b)
2625 && TREE_CODE (b->decl) == VAR_DECL
2626 && TREE_STATIC (b->decl)
2627 && TREE_CODE (TREE_TYPE (b->decl)) == ARRAY_TYPE
2628 && !TYPE_DOMAIN (TREE_TYPE (b->decl))
2629 && TREE_CODE (type) == ARRAY_TYPE
2630 && TYPE_DOMAIN (type)
2631 && TYPE_MAX_VALUE (TYPE_DOMAIN (type))
2632 && !integer_zerop (TYPE_MAX_VALUE (TYPE_DOMAIN (type))))
2634 /* Array type completed in inner scope, which should be
2635 diagnosed if the completion does not have size 1 and
2636 it does not get completed in the file scope. */
2637 b->inner_comp = true;
2642 /* If a matching external declaration has been found, set its
2643 type to the composite of all the types of that declaration.
2644 After the consistency checks, it will be reset to the
2645 composite of the visible types only. */
2646 if (b && (TREE_PUBLIC (x) || same_translation_unit_p (x, b->decl))
2648 TREE_TYPE (b->decl) = b->u.type;
2650 /* The point of the same_translation_unit_p check here is,
2651 we want to detect a duplicate decl for a construct like
2652 foo() { extern bar(); } ... static bar(); but not if
2653 they are in different translation units. In any case,
2654 the static does not go in the externals scope. */
2656 && (TREE_PUBLIC (x) || same_translation_unit_p (x, b->decl))
2657 && duplicate_decls (x, b->decl))
2662 if (comptypes (vistype, type))
2663 thistype = composite_type (vistype, type);
2665 thistype = TREE_TYPE (b->decl);
2669 b->u.type = TREE_TYPE (b->decl);
2670 if (TREE_CODE (b->decl) == FUNCTION_DECL && DECL_BUILT_IN (b->decl))
2672 = build_type_attribute_variant (thistype,
2673 TYPE_ATTRIBUTES (b->u.type));
2674 TREE_TYPE (b->decl) = thistype;
2675 bind (name, b->decl, scope, /*invisible=*/false, /*nested=*/true,
2679 else if (TREE_PUBLIC (x))
2681 if (visdecl && !b && duplicate_decls (x, visdecl))
2683 /* An external declaration at block scope referring to a
2684 visible entity with internal linkage. The composite
2685 type will already be correct for this scope, so we
2686 just need to fall through to make the declaration in
2693 bind (name, x, external_scope, /*invisible=*/true,
2694 /*nested=*/false, locus);
2700 if (TREE_CODE (x) != PARM_DECL)
2701 warn_if_shadowing (x);
2703 skip_external_and_shadow_checks:
2704 if (TREE_CODE (x) == TYPE_DECL)
2705 set_underlying_type (x);
2707 bind (name, x, scope, /*invisible=*/false, nested, locus);
2709 /* If x's type is incomplete because it's based on a
2710 structure or union which has not yet been fully declared,
2711 attach it to that structure or union type, so we can go
2712 back and complete the variable declaration later, if the
2713 structure or union gets fully declared.
2715 If the input is erroneous, we can have error_mark in the type
2716 slot (e.g. "f(void a, ...)") - that doesn't count as an
2718 if (TREE_TYPE (x) != error_mark_node
2719 && !COMPLETE_TYPE_P (TREE_TYPE (x)))
2721 tree element = TREE_TYPE (x);
2723 while (TREE_CODE (element) == ARRAY_TYPE)
2724 element = TREE_TYPE (element);
2725 element = TYPE_MAIN_VARIANT (element);
2727 if ((TREE_CODE (element) == RECORD_TYPE
2728 || TREE_CODE (element) == UNION_TYPE)
2729 && (TREE_CODE (x) != TYPE_DECL
2730 || TREE_CODE (TREE_TYPE (x)) == ARRAY_TYPE)
2731 && !COMPLETE_TYPE_P (element))
2732 C_TYPE_INCOMPLETE_VARS (element)
2733 = tree_cons (NULL_TREE, x, C_TYPE_INCOMPLETE_VARS (element));
2738 /* Record X as belonging to file scope.
2739 This is used only internally by the Objective-C front end,
2740 and is limited to its needs. duplicate_decls is not called;
2741 if there is any preexisting decl for this identifier, it is an ICE. */
2744 pushdecl_top_level (tree x)
2747 bool nested = false;
2748 gcc_assert (TREE_CODE (x) == VAR_DECL || TREE_CODE (x) == CONST_DECL);
2750 name = DECL_NAME (x);
2752 gcc_assert (TREE_CODE (x) == CONST_DECL || !I_SYMBOL_BINDING (name));
2754 if (TREE_PUBLIC (x))
2756 bind (name, x, external_scope, /*invisible=*/true, /*nested=*/false,
2761 bind (name, x, file_scope, /*invisible=*/false, nested, UNKNOWN_LOCATION);
2767 implicit_decl_warning (tree id, tree olddecl)
2769 if (warn_implicit_function_declaration)
2774 warned = pedwarn (input_location, OPT_Wimplicit_function_declaration,
2775 "implicit declaration of function %qE", id);
2777 warned = warning (OPT_Wimplicit_function_declaration,
2778 G_("implicit declaration of function %qE"), id);
2779 if (olddecl && warned)
2780 locate_old_decl (olddecl);
2784 /* Generate an implicit declaration for identifier FUNCTIONID at LOC as a
2785 function of type int (). */
2788 implicitly_declare (location_t loc, tree functionid)
2790 struct c_binding *b;
2794 for (b = I_SYMBOL_BINDING (functionid); b; b = b->shadowed)
2796 if (B_IN_SCOPE (b, external_scope))
2805 if (decl == error_mark_node)
2808 /* FIXME: Objective-C has weird not-really-builtin functions
2809 which are supposed to be visible automatically. They wind up
2810 in the external scope because they're pushed before the file
2811 scope gets created. Catch this here and rebind them into the
2813 if (!DECL_BUILT_IN (decl) && DECL_IS_BUILTIN (decl))
2815 bind (functionid, decl, file_scope,
2816 /*invisible=*/false, /*nested=*/true,
2817 DECL_SOURCE_LOCATION (decl));
2822 tree newtype = default_function_type;
2824 TREE_TYPE (decl) = b->u.type;
2825 /* Implicit declaration of a function already declared
2826 (somehow) in a different scope, or as a built-in.
2827 If this is the first time this has happened, warn;
2828 then recycle the old declaration but with the new type. */
2829 if (!C_DECL_IMPLICIT (decl))
2831 implicit_decl_warning (functionid, decl);
2832 C_DECL_IMPLICIT (decl) = 1;
2834 if (DECL_BUILT_IN (decl))
2836 newtype = build_type_attribute_variant (newtype,
2838 (TREE_TYPE (decl)));
2839 if (!comptypes (newtype, TREE_TYPE (decl)))
2841 warning_at (loc, 0, "incompatible implicit declaration of "
2842 "built-in function %qD", decl);
2843 newtype = TREE_TYPE (decl);
2848 if (!comptypes (newtype, TREE_TYPE (decl)))
2850 error_at (loc, "incompatible implicit declaration of function %qD", decl);
2851 locate_old_decl (decl);
2854 b->u.type = TREE_TYPE (decl);
2855 TREE_TYPE (decl) = newtype;
2856 bind (functionid, decl, current_scope,
2857 /*invisible=*/false, /*nested=*/true,
2858 DECL_SOURCE_LOCATION (decl));
2863 /* Not seen before. */
2864 decl = build_decl (loc, FUNCTION_DECL, functionid, default_function_type);
2865 DECL_EXTERNAL (decl) = 1;
2866 TREE_PUBLIC (decl) = 1;
2867 C_DECL_IMPLICIT (decl) = 1;
2868 implicit_decl_warning (functionid, 0);
2869 asmspec_tree = maybe_apply_renaming_pragma (decl, /*asmname=*/NULL);
2871 set_user_assembler_name (decl, TREE_STRING_POINTER (asmspec_tree));
2873 /* C89 says implicit declarations are in the innermost block.
2874 So we record the decl in the standard fashion. */
2875 decl = pushdecl (decl);
2877 /* No need to call objc_check_decl here - it's a function type. */
2878 rest_of_decl_compilation (decl, 0, 0);
2880 /* Write a record describing this implicit function declaration
2881 to the prototypes file (if requested). */
2882 gen_aux_info_record (decl, 0, 1, 0);
2884 /* Possibly apply some default attributes to this implicit declaration. */
2885 decl_attributes (&decl, NULL_TREE, 0);
2890 /* Issue an error message for a reference to an undeclared variable
2891 ID, including a reference to a builtin outside of function-call
2892 context. Establish a binding of the identifier to error_mark_node
2893 in an appropriate scope, which will suppress further errors for the
2894 same identifier. The error message should be given location LOC. */
2896 undeclared_variable (location_t loc, tree id)
2898 static bool already = false;
2899 struct c_scope *scope;
2901 if (current_function_decl == 0)
2903 error ("%H%qE undeclared here (not in a function)", &loc, id);
2904 scope = current_scope;
2908 error ("%H%qE undeclared (first use in this function)", &loc, id);
2912 error ("%H(Each undeclared identifier is reported only once", &loc);
2913 error ("%Hfor each function it appears in.)", &loc);
2917 /* If we are parsing old-style parameter decls, current_function_decl
2918 will be nonnull but current_function_scope will be null. */
2919 scope = current_function_scope ? current_function_scope : current_scope;
2921 bind (id, error_mark_node, scope, /*invisible=*/false, /*nested=*/false,
2925 /* Subroutine of lookup_label, declare_label, define_label: construct a
2926 LABEL_DECL with all the proper frills. Also create a struct
2927 c_label_vars initialized for the current scope. */
2930 make_label (location_t location, tree name, bool defining,
2931 struct c_label_vars **p_label_vars)
2933 tree label = build_decl (location, LABEL_DECL, name, void_type_node);
2934 struct c_label_vars *label_vars;
2936 DECL_CONTEXT (label) = current_function_decl;
2937 DECL_MODE (label) = VOIDmode;
2939 label_vars = GGC_NEW (struct c_label_vars);
2940 label_vars->shadowed = NULL;
2941 set_spot_bindings (&label_vars->label_bindings, defining);
2942 label_vars->decls_in_scope = make_tree_vector ();
2943 label_vars->gotos = VEC_alloc (c_goto_bindings_p, gc, 0);
2944 *p_label_vars = label_vars;
2949 /* Get the LABEL_DECL corresponding to identifier NAME as a label.
2950 Create one if none exists so far for the current function.
2951 This is called when a label is used in a goto expression or
2952 has its address taken. */
2955 lookup_label (tree name)
2958 struct c_label_vars *label_vars;
2960 if (current_function_decl == 0)
2962 error ("label %qE referenced outside of any function", name);
2966 /* Use a label already defined or ref'd with this name, but not if
2967 it is inherited from a containing function and wasn't declared
2969 label = I_LABEL_DECL (name);
2970 if (label && (DECL_CONTEXT (label) == current_function_decl
2971 || C_DECLARED_LABEL_FLAG (label)))
2973 /* If the label has only been declared, update its apparent
2974 location to point here, for better diagnostics if it
2975 turns out not to have been defined. */
2976 if (DECL_INITIAL (label) == NULL_TREE)
2977 DECL_SOURCE_LOCATION (label) = input_location;
2981 /* No label binding for that identifier; make one. */
2982 label = make_label (input_location, name, false, &label_vars);
2984 /* Ordinary labels go in the current function scope. */
2985 bind_label (name, label, current_function_scope, label_vars);
2990 /* Issue a warning about DECL for a goto statement at GOTO_LOC going
2994 warn_about_goto (location_t goto_loc, tree label, tree decl)
2996 if (variably_modified_type_p (TREE_TYPE (decl), NULL_TREE))
2998 "jump into scope of identifier with variably modified type");
3000 warning_at (goto_loc, OPT_Wjump_misses_init,
3001 "jump skips variable initialization");
3002 inform (DECL_SOURCE_LOCATION (label), "label %qD defined here", label);
3003 inform (DECL_SOURCE_LOCATION (decl), "%qD declared here", decl);
3006 /* Look up a label because of a goto statement. This is like
3007 lookup_label, but also issues any appropriate warnings. */
3010 lookup_label_for_goto (location_t loc, tree name)
3013 struct c_label_vars *label_vars;
3017 label = lookup_label (name);
3018 if (label == NULL_TREE)
3021 /* If we are jumping to a different function, we can't issue any
3023 if (DECL_CONTEXT (label) != current_function_decl)
3025 gcc_assert (C_DECLARED_LABEL_FLAG (label));
3029 label_vars = I_LABEL_BINDING (name)->u.label;
3031 /* If the label has not yet been defined, then push this goto on a
3032 list for possible later warnings. */
3033 if (label_vars->label_bindings.scope == NULL)
3035 struct c_goto_bindings *g;
3037 g = GGC_NEW (struct c_goto_bindings);
3039 set_spot_bindings (&g->goto_bindings, true);
3040 VEC_safe_push (c_goto_bindings_p, gc, label_vars->gotos, g);
3044 /* If there are any decls in label_vars->decls_in_scope, then this
3045 goto has missed the declaration of the decl. This happens for a
3051 Issue a warning or error. */
3052 for (ix = 0; VEC_iterate (tree, label_vars->decls_in_scope, ix, decl); ++ix)
3053 warn_about_goto (loc, label, decl);
3055 if (label_vars->label_bindings.left_stmt_expr)
3057 error_at (loc, "jump into statement expression");
3058 inform (DECL_SOURCE_LOCATION (label), "label %qD defined here", label);
3064 /* Make a label named NAME in the current function, shadowing silently
3065 any that may be inherited from containing functions or containing
3066 scopes. This is called for __label__ declarations. */
3069 declare_label (tree name)
3071 struct c_binding *b = I_LABEL_BINDING (name);
3073 struct c_label_vars *label_vars;
3075 /* Check to make sure that the label hasn't already been declared
3077 if (b && B_IN_CURRENT_SCOPE (b))
3079 error ("duplicate label declaration %qE", name);
3080 locate_old_decl (b->decl);
3082 /* Just use the previous declaration. */
3086 label = make_label (input_location, name, false, &label_vars);
3087 C_DECLARED_LABEL_FLAG (label) = 1;
3089 /* Declared labels go in the current scope. */
3090 bind_label (name, label, current_scope, label_vars);
3095 /* When we define a label, issue any appropriate warnings if there are
3096 any gotos earlier in the function which jump to this label. */
3099 check_earlier_gotos (tree label, struct c_label_vars* label_vars)
3102 struct c_goto_bindings *g;
3105 VEC_iterate (c_goto_bindings_p, label_vars->gotos, ix, g);
3108 struct c_binding *b;
3109 struct c_scope *scope;
3111 /* We have a goto to this label. The goto is going forward. In
3112 g->scope, the goto is going to skip any binding which was
3113 defined after g->bindings_in_scope. */
3114 for (b = g->goto_bindings.scope->bindings;
3115 b != g->goto_bindings.bindings_in_scope;
3118 if (decl_jump_unsafe (b->decl))
3119 warn_about_goto (g->loc, label, b->decl);
3122 /* We also need to warn about decls defined in any scopes
3123 between the scope of the label and the scope of the goto. */
3124 for (scope = label_vars->label_bindings.scope;
3125 scope != g->goto_bindings.scope;
3126 scope = scope->outer)
3128 gcc_assert (scope != NULL);
3129 if (scope == label_vars->label_bindings.scope)
3130 b = label_vars->label_bindings.bindings_in_scope;
3132 b = scope->bindings;
3133 for (; b != NULL; b = b->prev)
3135 if (decl_jump_unsafe (b->decl))
3136 warn_about_goto (g->loc, label, b->decl);
3140 if (g->goto_bindings.stmt_exprs > 0)
3142 error_at (g->loc, "jump into statement expression");
3143 inform (DECL_SOURCE_LOCATION (label), "label %qD defined here",
3148 /* Now that the label is defined, we will issue warnings about
3149 subsequent gotos to this label when we see them. */
3150 VEC_truncate (c_goto_bindings_p, label_vars->gotos, 0);
3151 label_vars->gotos = NULL;
3154 /* Define a label, specifying the location in the source file.
3155 Return the LABEL_DECL node for the label, if the definition is valid.
3156 Otherwise return 0. */
3159 define_label (location_t location, tree name)
3161 /* Find any preexisting label with this name. It is an error
3162 if that label has already been defined in this function, or
3163 if there is a containing function with a declared label with
3165 tree label = I_LABEL_DECL (name);
3168 && ((DECL_CONTEXT (label) == current_function_decl
3169 && DECL_INITIAL (label) != 0)
3170 || (DECL_CONTEXT (label) != current_function_decl
3171 && C_DECLARED_LABEL_FLAG (label))))
3173 error_at (location, "duplicate label %qD", label);
3174 locate_old_decl (label);
3177 else if (label && DECL_CONTEXT (label) == current_function_decl)
3179 struct c_label_vars *label_vars = I_LABEL_BINDING (name)->u.label;
3181 /* The label has been used or declared already in this function,
3182 but not defined. Update its location to point to this
3184 DECL_SOURCE_LOCATION (label) = location;
3185 set_spot_bindings (&label_vars->label_bindings, true);
3187 /* Issue warnings as required about any goto statements from
3188 earlier in the function. */
3189 check_earlier_gotos (label, label_vars);
3193 struct c_label_vars *label_vars;
3195 /* No label binding for that identifier; make one. */
3196 label = make_label (location, name, true, &label_vars);
3198 /* Ordinary labels go in the current function scope. */
3199 bind_label (name, label, current_function_scope, label_vars);
3202 if (!in_system_header && lookup_name (name))
3203 warning_at (location, OPT_Wtraditional,
3204 "traditional C lacks a separate namespace "
3205 "for labels, identifier %qE conflicts", name);
3207 /* Mark label as having been defined. */
3208 DECL_INITIAL (label) = error_mark_node;
3212 /* Get the bindings for a new switch statement. This is used to issue
3213 warnings as appropriate for jumps from the switch to case or
3216 struct c_spot_bindings *
3217 c_get_switch_bindings (void)
3219 struct c_spot_bindings *switch_bindings;
3221 switch_bindings = XNEW (struct c_spot_bindings);
3222 set_spot_bindings (switch_bindings, true);
3223 return switch_bindings;
3227 c_release_switch_bindings (struct c_spot_bindings *bindings)
3229 gcc_assert (bindings->stmt_exprs == 0 && !bindings->left_stmt_expr);
3233 /* This is called at the point of a case or default label to issue
3234 warnings about decls as needed. It returns true if it found an
3235 error, not just a warning. */
3238 c_check_switch_jump_warnings (struct c_spot_bindings *switch_bindings,
3239 location_t switch_loc, location_t case_loc)
3242 struct c_scope *scope;
3245 for (scope = current_scope;
3246 scope != switch_bindings->scope;
3247 scope = scope->outer)
3249 struct c_binding *b;
3251 gcc_assert (scope != NULL);
3252 for (b = scope->bindings; b != NULL; b = b->prev)
3254 if (decl_jump_unsafe (b->decl))
3256 if (variably_modified_type_p (TREE_TYPE (b->decl), NULL_TREE))
3260 ("switch jumps into scope of identifier with "
3261 "variably modified type"));
3264 warning_at (case_loc, OPT_Wjump_misses_init,
3265 "switch jumps over variable initialization");
3266 inform (switch_loc, "switch starts here");
3267 inform (DECL_SOURCE_LOCATION (b->decl), "%qD declared here",
3273 if (switch_bindings->stmt_exprs > 0)
3276 error_at (case_loc, "switch jumps into statement expression");
3277 inform (switch_loc, "switch starts here");
3283 /* Given NAME, an IDENTIFIER_NODE,
3284 return the structure (or union or enum) definition for that name.
3285 If THISLEVEL_ONLY is nonzero, searches only the current_scope.
3286 CODE says which kind of type the caller wants;
3287 it is RECORD_TYPE or UNION_TYPE or ENUMERAL_TYPE.
3288 If PLOC is not NULL and this returns non-null, it sets *PLOC to the
3289 location where the tag was defined.
3290 If the wrong kind of type is found, an error is reported. */
3293 lookup_tag (enum tree_code code, tree name, int thislevel_only,
3296 struct c_binding *b = I_TAG_BINDING (name);
3302 /* We only care about whether it's in this level if
3303 thislevel_only was set or it might be a type clash. */
3304 if (thislevel_only || TREE_CODE (b->decl) != code)
3306 /* For our purposes, a tag in the external scope is the same as
3307 a tag in the file scope. (Primarily relevant to Objective-C
3308 and its builtin structure tags, which get pushed before the
3309 file scope is created.) */
3310 if (B_IN_CURRENT_SCOPE (b)
3311 || (current_scope == file_scope && B_IN_EXTERNAL_SCOPE (b)))
3315 if (thislevel_only && !thislevel)
3318 if (TREE_CODE (b->decl) != code)
3320 /* Definition isn't the kind we were looking for. */
3321 pending_invalid_xref = name;
3322 pending_invalid_xref_location = input_location;
3324 /* If in the same binding level as a declaration as a tag
3325 of a different type, this must not be allowed to
3326 shadow that tag, so give the error immediately.
3327 (For example, "struct foo; union foo;" is invalid.) */
3329 pending_xref_error ();
3338 /* Print an error message now
3339 for a recent invalid struct, union or enum cross reference.
3340 We don't print them immediately because they are not invalid
3341 when used in the `struct foo;' construct for shadowing. */
3344 pending_xref_error (void)
3346 if (pending_invalid_xref != 0)
3347 error ("%H%qE defined as wrong kind of tag",
3348 &pending_invalid_xref_location, pending_invalid_xref);
3349 pending_invalid_xref = 0;
3353 /* Look up NAME in the current scope and its superiors
3354 in the namespace of variables, functions and typedefs.
3355 Return a ..._DECL node of some kind representing its definition,
3356 or return 0 if it is undefined. */
3359 lookup_name (tree name)
3361 struct c_binding *b = I_SYMBOL_BINDING (name);
3362 if (b && !b->invisible)
3367 /* Similar to `lookup_name' but look only at the indicated scope. */
3370 lookup_name_in_scope (tree name, struct c_scope *scope)
3372 struct c_binding *b;
3374 for (b = I_SYMBOL_BINDING (name); b; b = b->shadowed)
3375 if (B_IN_SCOPE (b, scope))
3380 /* Create the predefined scalar types of C,
3381 and some nodes representing standard constants (0, 1, (void *) 0).
3382 Initialize the global scope.
3383 Make definitions for built-in primitive functions. */
3386 c_init_decl_processing (void)
3388 location_t save_loc = input_location;
3390 /* Initialize reserved words for parser. */
3393 current_function_decl = 0;
3395 gcc_obstack_init (&parser_obstack);
3397 /* Make the externals scope. */
3399 external_scope = current_scope;
3401 /* Declarations from c_common_nodes_and_builtins must not be associated
3402 with this input file, lest we get differences between using and not
3403 using preprocessed headers. */
3404 input_location = BUILTINS_LOCATION;
3406 build_common_tree_nodes (flag_signed_char, false);
3408 c_common_nodes_and_builtins ();
3410 /* In C, comparisons and TRUTH_* expressions have type int. */
3411 truthvalue_type_node = integer_type_node;
3412 truthvalue_true_node = integer_one_node;
3413 truthvalue_false_node = integer_zero_node;
3415 /* Even in C99, which has a real boolean type. */
3416 pushdecl (build_decl (UNKNOWN_LOCATION, TYPE_DECL, get_identifier ("_Bool"),
3417 boolean_type_node));
3419 input_location = save_loc;
3421 pedantic_lvalues = true;
3423 make_fname_decl = c_make_fname_decl;
3424 start_fname_decls ();
3427 /* Create the VAR_DECL at LOC for __FUNCTION__ etc. ID is the name to
3428 give the decl, NAME is the initialization string and TYPE_DEP
3429 indicates whether NAME depended on the type of the function. As we
3430 don't yet implement delayed emission of static data, we mark the
3431 decl as emitted so it is not placed in the output. Anything using
3432 it must therefore pull out the STRING_CST initializer directly.
3436 c_make_fname_decl (location_t loc, tree id, int type_dep)
3438 const char *name = fname_as_string (type_dep);
3439 tree decl, type, init;
3440 size_t length = strlen (name);
3442 type = build_array_type (char_type_node,
3443 build_index_type (size_int (length)));
3444 type = c_build_qualified_type (type, TYPE_QUAL_CONST);
3446 decl = build_decl (loc, VAR_DECL, id, type);
3448 TREE_STATIC (decl) = 1;
3449 TREE_READONLY (decl) = 1;
3450 DECL_ARTIFICIAL (decl) = 1;
3452 init = build_string (length + 1, name);
3453 free (CONST_CAST (char *, name));
3454 TREE_TYPE (init) = type;
3455 DECL_INITIAL (decl) = init;
3457 TREE_USED (decl) = 1;
3459 if (current_function_decl
3460 /* For invalid programs like this:
3463 const char* p = __FUNCTION__;
3465 the __FUNCTION__ is believed to appear in K&R style function
3466 parameter declarator. In that case we still don't have
3468 && (!errorcount || current_function_scope))
3470 DECL_CONTEXT (decl) = current_function_decl;
3471 bind (id, decl, current_function_scope,
3472 /*invisible=*/false, /*nested=*/false, UNKNOWN_LOCATION);
3475 finish_decl (decl, loc, init, NULL_TREE, NULL_TREE);
3481 c_builtin_function (tree decl)
3483 tree type = TREE_TYPE (decl);
3484 tree id = DECL_NAME (decl);
3486 const char *name = IDENTIFIER_POINTER (id);
3487 C_DECL_BUILTIN_PROTOTYPE (decl) = (TYPE_ARG_TYPES (type) != 0);
3489 /* Should never be called on a symbol with a preexisting meaning. */
3490 gcc_assert (!I_SYMBOL_BINDING (id));
3492 bind (id, decl, external_scope, /*invisible=*/true, /*nested=*/false,
3495 /* Builtins in the implementation namespace are made visible without
3496 needing to be explicitly declared. See push_file_scope. */
3497 if (name[0] == '_' && (name[1] == '_' || ISUPPER (name[1])))
3499 TREE_CHAIN (decl) = visible_builtins;
3500 visible_builtins = decl;
3507 c_builtin_function_ext_scope (tree decl)
3509 tree type = TREE_TYPE (decl);
3510 tree id = DECL_NAME (decl);
3512 const char *name = IDENTIFIER_POINTER (id);
3513 C_DECL_BUILTIN_PROTOTYPE (decl) = (TYPE_ARG_TYPES (type) != 0);
3515 /* Should never be called on a symbol with a preexisting meaning. */
3516 gcc_assert (!I_SYMBOL_BINDING (id));
3518 bind (id, decl, external_scope, /*invisible=*/false, /*nested=*/false,
3521 /* Builtins in the implementation namespace are made visible without
3522 needing to be explicitly declared. See push_file_scope. */
3523 if (name[0] == '_' && (name[1] == '_' || ISUPPER (name[1])))
3525 TREE_CHAIN (decl) = visible_builtins;
3526 visible_builtins = decl;
3532 /* Called when a declaration is seen that contains no names to declare.
3533 If its type is a reference to a structure, union or enum inherited
3534 from a containing scope, shadow that tag name for the current scope
3535 with a forward reference.
3536 If its type defines a new named structure or union
3537 or defines an enum, it is valid but we need not do anything here.
3538 Otherwise, it is an error. */
3541 shadow_tag (const struct c_declspecs *declspecs)
3543 shadow_tag_warned (declspecs, 0);
3546 /* WARNED is 1 if we have done a pedwarn, 2 if we have done a warning,
3549 shadow_tag_warned (const struct c_declspecs *declspecs, int warned)
3551 bool found_tag = false;
3553 if (declspecs->type && !declspecs->default_int_p && !declspecs->typedef_p)
3555 tree value = declspecs->type;
3556 enum tree_code code = TREE_CODE (value);
3558 if (code == RECORD_TYPE || code == UNION_TYPE || code == ENUMERAL_TYPE)
3559 /* Used to test also that TYPE_SIZE (value) != 0.
3560 That caused warning for `struct foo;' at top level in the file. */
3562 tree name = TYPE_NAME (value);
3567 if (declspecs->restrict_p)
3569 error ("invalid use of %<restrict%>");
3575 if (warned != 1 && code != ENUMERAL_TYPE)
3576 /* Empty unnamed enum OK */
3578 pedwarn (input_location, 0,
3579 "unnamed struct/union that defines no instances");
3583 else if (!declspecs->tag_defined_p
3584 && declspecs->storage_class != csc_none)
3587 pedwarn (input_location, 0,
3588 "empty declaration with storage class specifier "
3589 "does not redeclare tag");
3591 pending_xref_error ();
3593 else if (!declspecs->tag_defined_p
3594 && (declspecs->const_p
3595 || declspecs->volatile_p
3596 || declspecs->restrict_p))
3599 pedwarn (input_location, 0,
3600 "empty declaration with type qualifier "
3601 "does not redeclare tag");
3603 pending_xref_error ();
3607 pending_invalid_xref = 0;
3608 t = lookup_tag (code, name, 1, NULL);
3612 t = make_node (code);
3613 pushtag (input_location, name, t);
3619 if (warned != 1 && !in_system_header)
3621 pedwarn (input_location, 0,
3622 "useless type name in empty declaration");
3627 else if (warned != 1 && !in_system_header && declspecs->typedef_p)
3629 pedwarn (input_location, 0, "useless type name in empty declaration");
3633 pending_invalid_xref = 0;
3635 if (declspecs->inline_p)
3637 error ("%<inline%> in empty declaration");
3641 if (current_scope == file_scope && declspecs->storage_class == csc_auto)
3643 error ("%<auto%> in file-scope empty declaration");
3647 if (current_scope == file_scope && declspecs->storage_class == csc_register)
3649 error ("%<register%> in file-scope empty declaration");
3653 if (!warned && !in_system_header && declspecs->storage_class != csc_none)
3655 warning (0, "useless storage class specifier in empty declaration");
3659 if (!warned && !in_system_header && declspecs->thread_p)
3661 warning (0, "useless %<__thread%> in empty declaration");
3665 if (!warned && !in_system_header && (declspecs->const_p
3666 || declspecs->volatile_p
3667 || declspecs->restrict_p))
3669 warning (0, "useless type qualifier in empty declaration");
3676 pedwarn (input_location, 0, "empty declaration");
3681 /* Return the qualifiers from SPECS as a bitwise OR of TYPE_QUAL_*
3682 bits. SPECS represents declaration specifiers that the grammar
3683 only permits to contain type qualifiers and attributes. */
3686 quals_from_declspecs (const struct c_declspecs *specs)
3688 int quals = ((specs->const_p ? TYPE_QUAL_CONST : 0)
3689 | (specs->volatile_p ? TYPE_QUAL_VOLATILE : 0)
3690 | (specs->restrict_p ? TYPE_QUAL_RESTRICT : 0));
3691 gcc_assert (!specs->type
3692 && !specs->decl_attr
3693 && specs->typespec_word == cts_none
3694 && specs->storage_class == csc_none
3695 && !specs->typedef_p
3696 && !specs->explicit_signed_p
3697 && !specs->deprecated_p
3699 && !specs->long_long_p
3702 && !specs->unsigned_p
3703 && !specs->complex_p
3705 && !specs->thread_p);
3709 /* Construct an array declarator. LOC is the location of the
3710 beginning of the array (usually the opening brace). EXPR is the
3711 expression inside [], or NULL_TREE. QUALS are the type qualifiers
3712 inside the [] (to be applied to the pointer to which a parameter
3713 array is converted). STATIC_P is true if "static" is inside the
3714 [], false otherwise. VLA_UNSPEC_P is true if the array is [*], a
3715 VLA of unspecified length which is nevertheless a complete type,
3716 false otherwise. The field for the contained declarator is left to
3717 be filled in by set_array_declarator_inner. */
3719 struct c_declarator *
3720 build_array_declarator (location_t loc,
3721 tree expr, struct c_declspecs *quals, bool static_p,
3724 struct c_declarator *declarator = XOBNEW (&parser_obstack,
3725 struct c_declarator);
3726 declarator->id_loc = loc;
3727 declarator->kind = cdk_array;
3728 declarator->declarator = 0;
3729 declarator->u.array.dimen = expr;
3732 declarator->u.array.attrs = quals->attrs;
3733 declarator->u.array.quals = quals_from_declspecs (quals);
3737 declarator->u.array.attrs = NULL_TREE;
3738 declarator->u.array.quals = 0;
3740 declarator->u.array.static_p = static_p;
3741 declarator->u.array.vla_unspec_p = vla_unspec_p;
3744 if (static_p || quals != NULL)
3745 pedwarn (loc, OPT_pedantic,
3746 "ISO C90 does not support %<static%> or type "
3747 "qualifiers in parameter array declarators");
3749 pedwarn (loc, OPT_pedantic,
3750 "ISO C90 does not support %<[*]%> array declarators");
3754 if (!current_scope->parm_flag)
3757 error_at (loc, "%<[*]%> not allowed in other than "
3758 "function prototype scope");
3759 declarator->u.array.vla_unspec_p = false;
3762 current_scope->had_vla_unspec = true;
3767 /* Set the contained declarator of an array declarator. DECL is the
3768 declarator, as constructed by build_array_declarator; INNER is what
3769 appears on the left of the []. */
3771 struct c_declarator *
3772 set_array_declarator_inner (struct c_declarator *decl,
3773 struct c_declarator *inner)
3775 decl->declarator = inner;
3779 /* INIT is a constructor that forms DECL's initializer. If the final
3780 element initializes a flexible array field, add the size of that
3781 initializer to DECL's size. */
3784 add_flexible_array_elts_to_size (tree decl, tree init)
3788 if (VEC_empty (constructor_elt, CONSTRUCTOR_ELTS (init)))
3791 elt = VEC_last (constructor_elt, CONSTRUCTOR_ELTS (init))->value;
3792 type = TREE_TYPE (elt);
3793 if (TREE_CODE (type) == ARRAY_TYPE
3794 && TYPE_SIZE (type) == NULL_TREE
3795 && TYPE_DOMAIN (type) != NULL_TREE
3796 && TYPE_MAX_VALUE (TYPE_DOMAIN (type)) == NULL_TREE)
3798 complete_array_type (&type, elt, false);
3800 = size_binop (PLUS_EXPR, DECL_SIZE (decl), TYPE_SIZE (type));
3801 DECL_SIZE_UNIT (decl)
3802 = size_binop (PLUS_EXPR, DECL_SIZE_UNIT (decl), TYPE_SIZE_UNIT (type));
3806 /* Decode a "typename", such as "int **", returning a ..._TYPE node.
3807 Set *EXPR, if EXPR not NULL, to any expression to be evaluated
3808 before the type name, and set *EXPR_CONST_OPERANDS, if
3809 EXPR_CONST_OPERANDS not NULL, to indicate whether the type name may
3810 appear in a constant expression. */
3813 groktypename (struct c_type_name *type_name, tree *expr,
3814 bool *expr_const_operands)
3817 tree attrs = type_name->specs->attrs;
3819 type_name->specs->attrs = NULL_TREE;
3821 type = grokdeclarator (type_name->declarator, type_name->specs, TYPENAME,
3822 false, NULL, &attrs, expr, expr_const_operands,
3825 /* Apply attributes. */
3826 decl_attributes (&type, attrs, 0);
3831 /* Decode a declarator in an ordinary declaration or data definition.
3832 This is called as soon as the type information and variable name
3833 have been parsed, before parsing the initializer if any.
3834 Here we create the ..._DECL node, fill in its type,
3835 and put it on the list of decls for the current context.
3836 The ..._DECL node is returned as the value.
3838 Exception: for arrays where the length is not specified,
3839 the type is left null, to be filled in by `finish_decl'.
3841 Function definitions do not come here; they go to start_function
3842 instead. However, external and forward declarations of functions
3843 do go through here. Structure field declarations are done by
3844 grokfield and not through here. */
3847 start_decl (struct c_declarator *declarator, struct c_declspecs *declspecs,
3848 bool initialized, tree attributes)
3852 tree expr = NULL_TREE;
3853 enum deprecated_states deprecated_state = DEPRECATED_NORMAL;
3855 /* An object declared as __attribute__((deprecated)) suppresses
3856 warnings of uses of other deprecated items. */
3857 if (lookup_attribute ("deprecated", attributes))
3858 deprecated_state = DEPRECATED_SUPPRESS;
3860 decl = grokdeclarator (declarator, declspecs,
3861 NORMAL, initialized, NULL, &attributes, &expr, NULL,
3869 if (TREE_CODE (decl) != FUNCTION_DECL && MAIN_NAME_P (DECL_NAME (decl)))
3870 warning (OPT_Wmain, "%q+D is usually a function", decl);
3873 /* Is it valid for this decl to have an initializer at all?
3874 If not, set INITIALIZED to zero, which will indirectly
3875 tell 'finish_decl' to ignore the initializer once it is parsed. */
3876 switch (TREE_CODE (decl))
3879 error ("typedef %qD is initialized (use __typeof__ instead)", decl);
3884 error ("function %qD is initialized like a variable", decl);
3889 /* DECL_INITIAL in a PARM_DECL is really DECL_ARG_TYPE. */
3890 error ("parameter %qD is initialized", decl);
3895 /* Don't allow initializations for incomplete types except for
3896 arrays which might be completed by the initialization. */
3898 /* This can happen if the array size is an undefined macro.
3899 We already gave a warning, so we don't need another one. */
3900 if (TREE_TYPE (decl) == error_mark_node)
3902 else if (COMPLETE_TYPE_P (TREE_TYPE (decl)))
3904 /* A complete type is ok if size is fixed. */
3906 if (TREE_CODE (TYPE_SIZE (TREE_TYPE (decl))) != INTEGER_CST
3907 || C_DECL_VARIABLE_SIZE (decl))
3909 error ("variable-sized object may not be initialized");
3913 else if (TREE_CODE (TREE_TYPE (decl)) != ARRAY_TYPE)
3915 error ("variable %qD has initializer but incomplete type", decl);
3918 else if (C_DECL_VARIABLE_SIZE (decl))
3920 /* Although C99 is unclear about whether incomplete arrays
3921 of VLAs themselves count as VLAs, it does not make
3922 sense to permit them to be initialized given that
3923 ordinary VLAs may not be initialized. */
3924 error ("variable-sized object may not be initialized");
3931 if (current_scope == file_scope)
3932 TREE_STATIC (decl) = 1;
3934 /* Tell 'pushdecl' this is an initialized decl
3935 even though we don't yet have the initializer expression.
3936 Also tell 'finish_decl' it may store the real initializer. */
3937 DECL_INITIAL (decl) = error_mark_node;
3940 /* If this is a function declaration, write a record describing it to the
3941 prototypes file (if requested). */
3943 if (TREE_CODE (decl) == FUNCTION_DECL)
3944 gen_aux_info_record (decl, 0, 0, TYPE_ARG_TYPES (TREE_TYPE (decl)) != 0);
3946 /* ANSI specifies that a tentative definition which is not merged with
3947 a non-tentative definition behaves exactly like a definition with an
3948 initializer equal to zero. (Section 3.7.2)
3950 -fno-common gives strict ANSI behavior, though this tends to break
3951 a large body of code that grew up without this rule.
3953 Thread-local variables are never common, since there's no entrenched
3954 body of code to break, and it allows more efficient variable references
3955 in the presence of dynamic linking. */
3957 if (TREE_CODE (decl) == VAR_DECL
3959 && TREE_PUBLIC (decl)
3960 && !DECL_THREAD_LOCAL_P (decl)
3962 DECL_COMMON (decl) = 1;
3964 /* Set attributes here so if duplicate decl, will have proper attributes. */
3965 decl_attributes (&decl, attributes, 0);
3967 /* Handle gnu_inline attribute. */
3968 if (declspecs->inline_p
3969 && !flag_gnu89_inline
3970 && TREE_CODE (decl) == FUNCTION_DECL
3971 && (lookup_attribute ("gnu_inline", DECL_ATTRIBUTES (decl))
3972 || current_function_decl))
3974 if (declspecs->storage_class == csc_auto && current_scope != file_scope)
3976 else if (declspecs->storage_class != csc_static)
3977 DECL_EXTERNAL (decl) = !DECL_EXTERNAL (decl);
3980 if (TREE_CODE (decl) == FUNCTION_DECL
3981 && targetm.calls.promote_prototypes (TREE_TYPE (decl)))
3983 struct c_declarator *ce = declarator;
3985 if (ce->kind == cdk_pointer)
3986 ce = declarator->declarator;
3987 if (ce->kind == cdk_function)
3989 tree args = ce->u.arg_info->parms;
3990 for (; args; args = TREE_CHAIN (args))
3992 tree type = TREE_TYPE (args);
3993 if (type && INTEGRAL_TYPE_P (type)
3994 && TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node))
3995 DECL_ARG_TYPE (args) = integer_type_node;
4000 if (TREE_CODE (decl) == FUNCTION_DECL
4001 && DECL_DECLARED_INLINE_P (decl)
4002 && DECL_UNINLINABLE (decl)
4003 && lookup_attribute ("noinline", DECL_ATTRIBUTES (decl)))
4004 warning (OPT_Wattributes, "inline function %q+D given attribute noinline",
4007 /* C99 6.7.4p3: An inline definition of a function with external
4008 linkage shall not contain a definition of a modifiable object
4009 with static storage duration... */
4010 if (TREE_CODE (decl) == VAR_DECL
4011 && current_scope != file_scope
4012 && TREE_STATIC (decl)
4013 && !TREE_READONLY (decl)
4014 && DECL_DECLARED_INLINE_P (current_function_decl)
4015 && DECL_EXTERNAL (current_function_decl))
4016 record_inline_static (input_location, current_function_decl,
4017 decl, csi_modifiable);
4019 /* Add this decl to the current scope.
4020 TEM may equal DECL or it may be a previous decl of the same name. */
4021 tem = pushdecl (decl);
4023 if (initialized && DECL_EXTERNAL (tem))
4025 DECL_EXTERNAL (tem) = 0;
4026 TREE_STATIC (tem) = 1;
4032 /* Initialize EH if not initialized yet and exceptions are enabled. */
4035 c_maybe_initialize_eh (void)
4037 if (!flag_exceptions || c_eh_initialized_p)
4040 c_eh_initialized_p = true;
4041 eh_personality_libfunc
4042 = init_one_libfunc (USING_SJLJ_EXCEPTIONS
4043 ? "__gcc_personality_sj0"
4044 : "__gcc_personality_v0");
4045 default_init_unwind_resume_libfunc ();
4046 using_eh_for_cleanups ();
4049 /* Finish processing of a declaration;
4050 install its initial value.
4051 If ORIGTYPE is not NULL_TREE, it is the original type of INIT.
4052 If the length of an array type is not known before,
4053 it must be determined now, from the initial value, or it is an error.
4055 INIT_LOC is the location of the initial value. */
4058 finish_decl (tree decl, location_t init_loc, tree init,
4059 tree origtype, tree asmspec_tree)
4062 bool was_incomplete = (DECL_SIZE (decl) == 0);
4063 const char *asmspec = 0;
4065 /* If a name was specified, get the string. */
4066 if ((TREE_CODE (decl) == FUNCTION_DECL || TREE_CODE (decl) == VAR_DECL)
4067 && DECL_FILE_SCOPE_P (decl))
4068 asmspec_tree = maybe_apply_renaming_pragma (decl, asmspec_tree);
4070 asmspec = TREE_STRING_POINTER (asmspec_tree);
4072 /* If `start_decl' didn't like having an initialization, ignore it now. */
4073 if (init != 0 && DECL_INITIAL (decl) == 0)
4076 /* Don't crash if parm is initialized. */
4077 if (TREE_CODE (decl) == PARM_DECL)
4081 store_init_value (init_loc, decl, init, origtype);
4083 if (c_dialect_objc () && (TREE_CODE (decl) == VAR_DECL
4084 || TREE_CODE (decl) == FUNCTION_DECL
4085 || TREE_CODE (decl) == FIELD_DECL))
4086 objc_check_decl (decl);
4088 type = TREE_TYPE (decl);
4090 /* Deduce size of array from initialization, if not already known. */
4091 if (TREE_CODE (type) == ARRAY_TYPE
4092 && TYPE_DOMAIN (type) == 0
4093 && TREE_CODE (decl) != TYPE_DECL)
4096 = (TREE_STATIC (decl)
4097 /* Even if pedantic, an external linkage array
4098 may have incomplete type at first. */
4099 ? pedantic && !TREE_PUBLIC (decl)
4100 : !DECL_EXTERNAL (decl));
4102 = complete_array_type (&TREE_TYPE (decl), DECL_INITIAL (decl),
4105 /* Get the completed type made by complete_array_type. */
4106 type = TREE_TYPE (decl);
4111 error ("initializer fails to determine size of %q+D", decl);
4116 error ("array size missing in %q+D", decl);
4117 /* If a `static' var's size isn't known,
4118 make it extern as well as static, so it does not get
4120 If it is not `static', then do not mark extern;
4121 finish_incomplete_decl will give it a default size
4122 and it will get allocated. */
4123 else if (!pedantic && TREE_STATIC (decl) && !TREE_PUBLIC (decl))
4124 DECL_EXTERNAL (decl) = 1;
4128 error ("zero or negative size array %q+D", decl);
4132 /* For global variables, update the copy of the type that
4133 exists in the binding. */
4134 if (TREE_PUBLIC (decl))
4136 struct c_binding *b_ext = I_SYMBOL_BINDING (DECL_NAME (decl));
4137 while (b_ext && !B_IN_EXTERNAL_SCOPE (b_ext))
4138 b_ext = b_ext->shadowed;
4142 b_ext->u.type = composite_type (b_ext->u.type, type);
4144 b_ext->u.type = type;
4153 if (DECL_INITIAL (decl))
4154 TREE_TYPE (DECL_INITIAL (decl)) = type;
4156 layout_decl (decl, 0);
4159 if (TREE_CODE (decl) == VAR_DECL)
4161 if (init && TREE_CODE (init) == CONSTRUCTOR)
4162 add_flexible_array_elts_to_size (decl, init);
4164 if (DECL_SIZE (decl) == 0 && TREE_TYPE (decl) != error_mark_node
4165 && COMPLETE_TYPE_P (TREE_TYPE (decl)))
4166 layout_decl (decl, 0);
4168 if (DECL_SIZE (decl) == 0
4169 /* Don't give an error if we already gave one earlier. */
4170 && TREE_TYPE (decl) != error_mark_node
4171 && (TREE_STATIC (decl)
4172 /* A static variable with an incomplete type
4173 is an error if it is initialized.
4174 Also if it is not file scope.
4175 Otherwise, let it through, but if it is not `extern'
4176 then it may cause an error message later. */
4177 ? (DECL_INITIAL (decl) != 0
4178 || !DECL_FILE_SCOPE_P (decl))
4179 /* An automatic variable with an incomplete type
4181 : !DECL_EXTERNAL (decl)))
4183 error ("storage size of %q+D isn%'t known", decl);
4184 TREE_TYPE (decl) = error_mark_node;
4187 if ((DECL_EXTERNAL (decl) || TREE_STATIC (decl))
4188 && DECL_SIZE (decl) != 0)
4190 if (TREE_CODE (DECL_SIZE (decl)) == INTEGER_CST)
4191 constant_expression_warning (DECL_SIZE (decl));
4194 error ("storage size of %q+D isn%'t constant", decl);
4195 TREE_TYPE (decl) = error_mark_node;
4199 if (TREE_USED (type))
4200 TREE_USED (decl) = 1;
4203 /* If this is a function and an assembler name is specified, reset DECL_RTL
4204 so we can give it its new name. Also, update built_in_decls if it
4205 was a normal built-in. */
4206 if (TREE_CODE (decl) == FUNCTION_DECL && asmspec)
4208 if (DECL_BUILT_IN_CLASS (decl) == BUILT_IN_NORMAL)
4209 set_builtin_user_assembler_name (decl, asmspec);
4210 set_user_assembler_name (decl, asmspec);
4213 /* If #pragma weak was used, mark the decl weak now. */
4214 maybe_apply_pragma_weak (decl);
4216 /* Output the assembler code and/or RTL code for variables and functions,
4217 unless the type is an undefined structure or union.
4218 If not, it will get done when the type is completed. */
4220 if (TREE_CODE (decl) == VAR_DECL || TREE_CODE (decl) == FUNCTION_DECL)
4222 /* Determine the ELF visibility. */
4223 if (TREE_PUBLIC (decl))
4224 c_determine_visibility (decl);
4226 /* This is a no-op in c-lang.c or something real in objc-act.c. */
4227 if (c_dialect_objc ())
4228 objc_check_decl (decl);
4232 /* If this is not a static variable, issue a warning.
4233 It doesn't make any sense to give an ASMSPEC for an
4234 ordinary, non-register local variable. Historically,
4235 GCC has accepted -- but ignored -- the ASMSPEC in
4237 if (!DECL_FILE_SCOPE_P (decl)
4238 && TREE_CODE (decl) == VAR_DECL
4239 && !C_DECL_REGISTER (decl)
4240 && !TREE_STATIC (decl))
4241 warning (0, "ignoring asm-specifier for non-static local "
4242 "variable %q+D", decl);
4244 set_user_assembler_name (decl, asmspec);
4247 if (DECL_FILE_SCOPE_P (decl))
4249 if (DECL_INITIAL (decl) == NULL_TREE
4250 || DECL_INITIAL (decl) == error_mark_node)
4251 /* Don't output anything
4252 when a tentative file-scope definition is seen.
4253 But at end of compilation, do output code for them. */
4254 DECL_DEFER_OUTPUT (decl) = 1;
4255 rest_of_decl_compilation (decl, true, 0);
4259 /* In conjunction with an ASMSPEC, the `register'
4260 keyword indicates that we should place the variable
4261 in a particular register. */
4262 if (asmspec && C_DECL_REGISTER (decl))
4264 DECL_HARD_REGISTER (decl) = 1;
4265 /* This cannot be done for a structure with volatile
4266 fields, on which DECL_REGISTER will have been
4268 if (!DECL_REGISTER (decl))
4269 error ("cannot put object with volatile field into register");
4272 if (TREE_CODE (decl) != FUNCTION_DECL)
4274 /* If we're building a variable sized type, and we might be
4275 reachable other than via the top of the current binding
4276 level, then create a new BIND_EXPR so that we deallocate
4277 the object at the right time. */
4278 /* Note that DECL_SIZE can be null due to errors. */
4279 if (DECL_SIZE (decl)
4280 && !TREE_CONSTANT (DECL_SIZE (decl))
4281 && STATEMENT_LIST_HAS_LABEL (cur_stmt_list))
4284 bind = build3 (BIND_EXPR, void_type_node, NULL, NULL, NULL);
4285 TREE_SIDE_EFFECTS (bind) = 1;
4287 BIND_EXPR_BODY (bind) = push_stmt_list ();
4289 add_stmt (build_stmt (DECL_SOURCE_LOCATION (decl),
4295 if (!DECL_FILE_SCOPE_P (decl))
4297 /* Recompute the RTL of a local array now
4298 if it used to be an incomplete type. */
4300 && !TREE_STATIC (decl) && !DECL_EXTERNAL (decl))
4302 /* If we used it already as memory, it must stay in memory. */
4303 TREE_ADDRESSABLE (decl) = TREE_USED (decl);
4304 /* If it's still incomplete now, no init will save it. */
4305 if (DECL_SIZE (decl) == 0)
4306 DECL_INITIAL (decl) = 0;
4311 if (TREE_CODE (decl) == TYPE_DECL)
4313 if (!DECL_FILE_SCOPE_P (decl)
4314 && variably_modified_type_p (TREE_TYPE (decl), NULL_TREE))
4315 add_stmt (build_stmt (DECL_SOURCE_LOCATION (decl), DECL_EXPR, decl));
4317 rest_of_decl_compilation (decl, DECL_FILE_SCOPE_P (decl), 0);
4320 /* At the end of a declaration, throw away any variable type sizes
4321 of types defined inside that declaration. There is no use
4322 computing them in the following function definition. */
4323 if (current_scope == file_scope)
4324 get_pending_sizes ();
4326 /* Install a cleanup (aka destructor) if one was given. */
4327 if (TREE_CODE (decl) == VAR_DECL && !TREE_STATIC (decl))
4329 tree attr = lookup_attribute ("cleanup", DECL_ATTRIBUTES (decl));
4332 tree cleanup_id = TREE_VALUE (TREE_VALUE (attr));
4333 tree cleanup_decl = lookup_name (cleanup_id);
4337 /* Build "cleanup(&decl)" for the destructor. */
4338 cleanup = build_unary_op (input_location, ADDR_EXPR, decl, 0);
4339 vec = VEC_alloc (tree, gc, 1);
4340 VEC_quick_push (tree, vec, cleanup);
4341 cleanup = build_function_call_vec (DECL_SOURCE_LOCATION (decl),
4342 cleanup_decl, vec, NULL);
4343 VEC_free (tree, gc, vec);
4345 /* Don't warn about decl unused; the cleanup uses it. */
4346 TREE_USED (decl) = 1;
4347 TREE_USED (cleanup_decl) = 1;
4349 /* Initialize EH, if we've been told to do so. */
4350 c_maybe_initialize_eh ();
4352 push_cleanup (decl, cleanup, false);
4357 && TREE_CODE (decl) == VAR_DECL
4358 && TREE_READONLY (decl)
4359 && !DECL_EXTERNAL (decl)
4360 && DECL_INITIAL (decl) == NULL_TREE)
4361 warning_at (DECL_SOURCE_LOCATION (decl), OPT_Wc___compat,
4362 "uninitialized const %qD is invalid in C++", decl);
4365 /* Given a parsed parameter declaration, decode it into a PARM_DECL. */
4368 grokparm (const struct c_parm *parm)
4370 tree attrs = parm->attrs;
4371 tree decl = grokdeclarator (parm->declarator, parm->specs, PARM, false,
4372 NULL, &attrs, NULL, NULL, DEPRECATED_NORMAL);
4374 decl_attributes (&decl, attrs, 0);
4379 /* Given a parsed parameter declaration, decode it into a PARM_DECL
4380 and push that on the current scope. */
4383 push_parm_decl (const struct c_parm *parm)
4385 tree attrs = parm->attrs;
4388 decl = grokdeclarator (parm->declarator, parm->specs, PARM, false, NULL,
4389 &attrs, NULL, NULL, DEPRECATED_NORMAL);
4390 decl_attributes (&decl, attrs, 0);
4392 decl = pushdecl (decl);
4394 finish_decl (decl, input_location, NULL_TREE, NULL_TREE, NULL_TREE);
4397 /* Mark all the parameter declarations to date as forward decls.
4398 Also diagnose use of this extension. */
4401 mark_forward_parm_decls (void)
4403 struct c_binding *b;
4405 if (pedantic && !current_scope->warned_forward_parm_decls)
4407 pedwarn (input_location, OPT_pedantic,
4408 "ISO C forbids forward parameter declarations");
4409 current_scope->warned_forward_parm_decls = true;
4412 for (b = current_scope->bindings; b; b = b->prev)
4413 if (TREE_CODE (b->decl) == PARM_DECL)
4414 TREE_ASM_WRITTEN (b->decl) = 1;
4417 /* Build a COMPOUND_LITERAL_EXPR. TYPE is the type given in the compound
4418 literal, which may be an incomplete array type completed by the
4419 initializer; INIT is a CONSTRUCTOR at LOC that initializes the compound
4420 literal. NON_CONST is true if the initializers contain something
4421 that cannot occur in a constant expression. */
4424 build_compound_literal (location_t loc, tree type, tree init, bool non_const)
4426 /* We do not use start_decl here because we have a type, not a declarator;
4427 and do not use finish_decl because the decl should be stored inside
4428 the COMPOUND_LITERAL_EXPR rather than added elsewhere as a DECL_EXPR. */
4433 if (type == error_mark_node)
4434 return error_mark_node;
4436 decl = build_decl (loc, VAR_DECL, NULL_TREE, type);
4437 DECL_EXTERNAL (decl) = 0;
4438 TREE_PUBLIC (decl) = 0;
4439 TREE_STATIC (decl) = (current_scope == file_scope);
4440 DECL_CONTEXT (decl) = current_function_decl;
4441 TREE_USED (decl) = 1;
4442 TREE_TYPE (decl) = type;
4443 TREE_READONLY (decl) = TYPE_READONLY (type);
4444 store_init_value (loc, decl, init, NULL_TREE);
4446 if (TREE_CODE (type) == ARRAY_TYPE && !COMPLETE_TYPE_P (type))
4448 int failure = complete_array_type (&TREE_TYPE (decl),
4449 DECL_INITIAL (decl), true);
4450 gcc_assert (!failure);
4452 type = TREE_TYPE (decl);
4453 TREE_TYPE (DECL_INITIAL (decl)) = type;
4456 if (type == error_mark_node || !COMPLETE_TYPE_P (type))
4457 return error_mark_node;
4459 stmt = build_stmt (DECL_SOURCE_LOCATION (decl), DECL_EXPR, decl);
4460 complit = build1 (COMPOUND_LITERAL_EXPR, type, stmt);
4461 TREE_SIDE_EFFECTS (complit) = 1;
4463 layout_decl (decl, 0);
4465 if (TREE_STATIC (decl))
4467 /* This decl needs a name for the assembler output. */
4468 set_compound_literal_name (decl);
4469 DECL_DEFER_OUTPUT (decl) = 1;
4470 DECL_COMDAT (decl) = 1;
4471 DECL_ARTIFICIAL (decl) = 1;
4472 DECL_IGNORED_P (decl) = 1;
4474 rest_of_decl_compilation (decl, 1, 0);
4479 complit = build2 (C_MAYBE_CONST_EXPR, type, NULL, complit);
4480 C_MAYBE_CONST_EXPR_NON_CONST (complit) = 1;
4486 /* Check the type of a compound literal. Here we just check that it
4487 is valid for C++. */
4490 check_compound_literal_type (location_t loc, struct c_type_name *type_name)
4492 if (warn_cxx_compat && type_name->specs->tag_defined_p)
4493 warning_at (loc, OPT_Wc___compat,
4494 "defining a type in a compound literal is invalid in C++");
4497 /* Determine whether TYPE is a structure with a flexible array member,
4498 or a union containing such a structure (possibly recursively). */
4501 flexible_array_type_p (tree type)
4504 switch (TREE_CODE (type))
4507 x = TYPE_FIELDS (type);
4510 while (TREE_CHAIN (x) != NULL_TREE)
4512 if (TREE_CODE (TREE_TYPE (x)) == ARRAY_TYPE
4513 && TYPE_SIZE (TREE_TYPE (x)) == NULL_TREE
4514 && TYPE_DOMAIN (TREE_TYPE (x)) != NULL_TREE
4515 && TYPE_MAX_VALUE (TYPE_DOMAIN (TREE_TYPE (x))) == NULL_TREE)
4519 for (x = TYPE_FIELDS (type); x != NULL_TREE; x = TREE_CHAIN (x))
4521 if (flexible_array_type_p (TREE_TYPE (x)))
4530 /* Performs sanity checks on the TYPE and WIDTH of the bit-field NAME,
4531 replacing with appropriate values if they are invalid. */
4533 check_bitfield_type_and_width (tree *type, tree *width, tree orig_name)
4536 unsigned int max_width;
4537 unsigned HOST_WIDE_INT w;
4538 const char *name = (orig_name
4539 ? identifier_to_locale (IDENTIFIER_POINTER (orig_name))
4540 : _("<anonymous>"));
4542 /* Detect and ignore out of range field width and process valid
4544 if (!INTEGRAL_TYPE_P (TREE_TYPE (*width))
4545 || TREE_CODE (*width) != INTEGER_CST)
4547 error ("bit-field %qs width not an integer constant", name);
4548 *width = integer_one_node;
4552 constant_expression_warning (*width);
4553 if (tree_int_cst_sgn (*width) < 0)
4555 error ("negative width in bit-field %qs", name);
4556 *width = integer_one_node;
4558 else if (integer_zerop (*width) && orig_name)
4560 error ("zero width for bit-field %qs", name);
4561 *width = integer_one_node;
4565 /* Detect invalid bit-field type. */
4566 if (TREE_CODE (*type) != INTEGER_TYPE
4567 && TREE_CODE (*type) != BOOLEAN_TYPE
4568 && TREE_CODE (*type) != ENUMERAL_TYPE)
4570 error ("bit-field %qs has invalid type", name);
4571 *type = unsigned_type_node;
4574 type_mv = TYPE_MAIN_VARIANT (*type);
4575 if (!in_system_header
4576 && type_mv != integer_type_node
4577 && type_mv != unsigned_type_node
4578 && type_mv != boolean_type_node)
4579 pedwarn (input_location, OPT_pedantic,
4580 "type of bit-field %qs is a GCC extension", name);
4582 max_width = TYPE_PRECISION (*type);
4584 if (0 < compare_tree_int (*width, max_width))
4586 error ("width of %qs exceeds its type", name);
4588 *width = build_int_cst (NULL_TREE, w);
4591 w = tree_low_cst (*width, 1);
4593 if (TREE_CODE (*type) == ENUMERAL_TYPE)
4595 struct lang_type *lt = TYPE_LANG_SPECIFIC (*type);
4597 || w < tree_int_cst_min_precision (lt->enum_min, TYPE_UNSIGNED (*type))
4598 || w < tree_int_cst_min_precision (lt->enum_max, TYPE_UNSIGNED (*type)))
4599 warning (0, "%qs is narrower than values of its type", name);
4605 /* Print warning about variable length array if necessary. */
4608 warn_variable_length_array (tree name, tree size)
4610 int const_size = TREE_CONSTANT (size);
4612 if (!flag_isoc99 && pedantic && warn_vla != 0)
4617 pedwarn (input_location, OPT_Wvla,
4618 "ISO C90 forbids array %qE whose size "
4619 "can%'t be evaluated",
4622 pedwarn (input_location, OPT_Wvla, "ISO C90 forbids array whose size "
4623 "can%'t be evaluated");
4628 pedwarn (input_location, OPT_Wvla,
4629 "ISO C90 forbids variable length array %qE",
4632 pedwarn (input_location, OPT_Wvla, "ISO C90 forbids variable length array");
4635 else if (warn_vla > 0)
4641 "the size of array %qE can"
4642 "%'t be evaluated", name);
4645 "the size of array can %'t be evaluated");
4651 "variable length array %qE is used",
4655 "variable length array is used");
4660 /* Given a size SIZE that may not be a constant, return a SAVE_EXPR to
4661 serve as the actual size-expression for a type or decl. This is
4662 like variable_size in stor-layout.c, but we make global_bindings_p
4663 return negative to avoid calls to that function from outside the
4664 front end resulting in errors at file scope, then call this version
4665 instead from front-end code. */
4668 c_variable_size (tree size)
4672 if (TREE_CONSTANT (size))
4675 size = save_expr (size);
4677 save = skip_simple_arithmetic (size);
4679 if (cfun && cfun->dont_save_pending_sizes_p)
4682 if (!global_bindings_p ())
4683 put_pending_size (save);
4688 /* Given declspecs and a declarator,
4689 determine the name and type of the object declared
4690 and construct a ..._DECL node for it.
4691 (In one case we can return a ..._TYPE node instead.
4692 For invalid input we sometimes return 0.)
4694 DECLSPECS is a c_declspecs structure for the declaration specifiers.
4696 DECL_CONTEXT says which syntactic context this declaration is in:
4697 NORMAL for most contexts. Make a VAR_DECL or FUNCTION_DECL or TYPE_DECL.
4698 FUNCDEF for a function definition. Like NORMAL but a few different
4699 error messages in each case. Return value may be zero meaning
4700 this definition is too screwy to try to parse.
4701 PARM for a parameter declaration (either within a function prototype
4702 or before a function body). Make a PARM_DECL, or return void_type_node.
4703 TYPENAME if for a typename (in a cast or sizeof).
4704 Don't make a DECL node; just return the ..._TYPE node.
4705 FIELD for a struct or union field; make a FIELD_DECL.
4706 INITIALIZED is true if the decl has an initializer.
4707 WIDTH is non-NULL for bit-fields, and is a pointer to an INTEGER_CST node
4708 representing the width of the bit-field.
4709 DECL_ATTRS points to the list of attributes that should be added to this
4710 decl. Any nested attributes that belong on the decl itself will be
4712 If EXPR is not NULL, any expressions that need to be evaluated as
4713 part of evaluating variably modified types will be stored in *EXPR.
4714 If EXPR_CONST_OPERANDS is not NULL, *EXPR_CONST_OPERANDS will be
4715 set to indicate whether operands in *EXPR can be used in constant
4717 DEPRECATED_STATE is a deprecated_states value indicating whether
4718 deprecation warnings should be suppressed.
4720 In the TYPENAME case, DECLARATOR is really an absolute declarator.
4721 It may also be so in the PARM case, for a prototype where the
4722 argument type is specified but not the name.
4724 This function is where the complicated C meanings of `static'
4725 and `extern' are interpreted. */
4728 grokdeclarator (const struct c_declarator *declarator,
4729 struct c_declspecs *declspecs,
4730 enum decl_context decl_context, bool initialized, tree *width,
4731 tree *decl_attrs, tree *expr, bool *expr_const_operands,
4732 enum deprecated_states deprecated_state)
4734 tree type = declspecs->type;
4735 bool threadp = declspecs->thread_p;
4736 enum c_storage_class storage_class = declspecs->storage_class;
4740 int type_quals = TYPE_UNQUALIFIED;
4741 tree name = NULL_TREE;
4742 bool funcdef_flag = false;
4743 bool funcdef_syntax = false;
4744 bool size_varies = false;
4745 tree decl_attr = declspecs->decl_attr;
4746 int array_ptr_quals = TYPE_UNQUALIFIED;
4747 tree array_ptr_attrs = NULL_TREE;
4748 int array_parm_static = 0;
4749 bool array_parm_vla_unspec_p = false;
4750 tree returned_attrs = NULL_TREE;
4751 bool bitfield = width != NULL;
4753 struct c_arg_info *arg_info = 0;
4754 location_t loc = UNKNOWN_LOCATION;
4757 bool expr_const_operands_dummy;
4761 if (expr_const_operands == NULL)
4762 expr_const_operands = &expr_const_operands_dummy;
4764 *expr = declspecs->expr;
4765 *expr_const_operands = declspecs->expr_const_operands;
4767 if (decl_context == FUNCDEF)
4768 funcdef_flag = true, decl_context = NORMAL;
4770 /* Look inside a declarator for the name being declared
4771 and get it as an IDENTIFIER_NODE, for an error message. */
4773 const struct c_declarator *decl = declarator;
4784 funcdef_syntax = (decl->kind == cdk_function);
4785 decl = decl->declarator;
4789 decl = decl->declarator;
4804 gcc_assert (decl_context == PARM
4805 || decl_context == TYPENAME
4806 || (decl_context == FIELD
4807 && declarator->kind == cdk_id));
4808 gcc_assert (!initialized);
4812 /* A function definition's declarator must have the form of
4813 a function declarator. */
4815 if (funcdef_flag && !funcdef_syntax)
4818 /* If this looks like a function definition, make it one,
4819 even if it occurs where parms are expected.
4820 Then store_parm_decls will reject it and not use it as a parm. */
4821 if (decl_context == NORMAL && !funcdef_flag && current_scope->parm_flag)
4822 decl_context = PARM;
4824 if (declspecs->deprecated_p && deprecated_state != DEPRECATED_SUPPRESS)
4825 warn_deprecated_use (declspecs->type, declspecs->decl_attr);
4827 if ((decl_context == NORMAL || decl_context == FIELD)
4828 && current_scope == file_scope
4829 && variably_modified_type_p (type, NULL_TREE))
4832 error_at (loc, "variably modified %qE at file scope", name);
4834 error_at (loc, "variably modified field at file scope");
4835 type = integer_type_node;
4838 size_varies = C_TYPE_VARIABLE_SIZE (type) != 0;
4840 /* Diagnose defaulting to "int". */
4842 if (declspecs->default_int_p && !in_system_header)
4844 /* Issue a warning if this is an ISO C 99 program or if
4845 -Wreturn-type and this is a function, or if -Wimplicit;
4846 prefer the former warning since it is more explicit. */
4847 if ((warn_implicit_int || warn_return_type || flag_isoc99)
4849 warn_about_return_type = 1;
4853 pedwarn_c99 (loc, flag_isoc99 ? 0 : OPT_Wimplicit_int,
4854 "type defaults to %<int%> in declaration of %qE",
4857 pedwarn_c99 (input_location, flag_isoc99 ? 0 : OPT_Wimplicit_int,
4858 "type defaults to %<int%> in type name");
4862 /* Adjust the type if a bit-field is being declared,
4863 -funsigned-bitfields applied and the type is not explicitly
4865 if (bitfield && !flag_signed_bitfields && !declspecs->explicit_signed_p
4866 && TREE_CODE (type) == INTEGER_TYPE)
4867 type = unsigned_type_for (type);
4869 /* Figure out the type qualifiers for the declaration. There are
4870 two ways a declaration can become qualified. One is something
4871 like `const int i' where the `const' is explicit. Another is
4872 something like `typedef const int CI; CI i' where the type of the
4873 declaration contains the `const'. A third possibility is that
4874 there is a type qualifier on the element type of a typedefed
4875 array type, in which case we should extract that qualifier so
4876 that c_apply_type_quals_to_decl receives the full list of
4877 qualifiers to work with (C90 is not entirely clear about whether
4878 duplicate qualifiers should be diagnosed in this case, but it
4879 seems most appropriate to do so). */
4880 element_type = strip_array_types (type);
4881 constp = declspecs->const_p + TYPE_READONLY (element_type);
4882 restrictp = declspecs->restrict_p + TYPE_RESTRICT (element_type);
4883 volatilep = declspecs->volatile_p + TYPE_VOLATILE (element_type);
4884 if (pedantic && !flag_isoc99)
4887 pedwarn (loc, OPT_pedantic, "duplicate %<const%>");
4889 pedwarn (loc, OPT_pedantic, "duplicate %<restrict%>");
4891 pedwarn (loc, OPT_pedantic, "duplicate %<volatile%>");
4893 if (!flag_gen_aux_info && (TYPE_QUALS (element_type)))
4894 type = TYPE_MAIN_VARIANT (type);
4895 type_quals = ((constp ? TYPE_QUAL_CONST : 0)
4896 | (restrictp ? TYPE_QUAL_RESTRICT : 0)
4897 | (volatilep ? TYPE_QUAL_VOLATILE : 0));
4899 /* Warn about storage classes that are invalid for certain
4900 kinds of declarations (parameters, typenames, etc.). */
4904 || storage_class == csc_auto
4905 || storage_class == csc_register
4906 || storage_class == csc_typedef))
4908 if (storage_class == csc_auto)
4910 (current_scope == file_scope) ? 0 : OPT_pedantic,
4911 "function definition declared %<auto%>");
4912 if (storage_class == csc_register)
4913 error_at (loc, "function definition declared %<register%>");
4914 if (storage_class == csc_typedef)
4915 error_at (loc, "function definition declared %<typedef%>");
4917 error_at (loc, "function definition declared %<__thread%>");
4919 if (storage_class == csc_auto
4920 || storage_class == csc_register
4921 || storage_class == csc_typedef)
4922 storage_class = csc_none;
4924 else if (decl_context != NORMAL && (storage_class != csc_none || threadp))
4926 if (decl_context == PARM && storage_class == csc_register)
4930 switch (decl_context)
4934 error_at (loc, "storage class specified for structure "
4937 error_at (loc, "storage class specified for structure field");
4941 error_at (loc, "storage class specified for parameter %qE",
4944 error_at (loc, "storage class specified for unnamed parameter");
4947 error_at (loc, "storage class specified for typename");
4950 storage_class = csc_none;
4954 else if (storage_class == csc_extern
4958 /* 'extern' with initialization is invalid if not at file scope. */
4959 if (current_scope == file_scope)
4961 /* It is fine to have 'extern const' when compiling at C
4962 and C++ intersection. */
4963 if (!(warn_cxx_compat && constp))
4964 warning_at (loc, 0, "%qE initialized and declared %<extern%>",
4968 error_at (loc, "%qE has both %<extern%> and initializer", name);
4970 else if (current_scope == file_scope)
4972 if (storage_class == csc_auto)
4973 error_at (loc, "file-scope declaration of %qE specifies %<auto%>",
4975 if (pedantic && storage_class == csc_register)
4976 pedwarn (input_location, OPT_pedantic,
4977 "file-scope declaration of %qE specifies %<register%>", name);
4981 if (storage_class == csc_extern && funcdef_flag)
4982 error_at (loc, "nested function %qE declared %<extern%>", name);
4983 else if (threadp && storage_class == csc_none)
4985 error_at (loc, "function-scope %qE implicitly auto and declared "
4992 /* Now figure out the structure of the declarator proper.
4993 Descend through it, creating more complex types, until we reach
4994 the declared identifier (or NULL_TREE, in an absolute declarator).
4995 At each stage we maintain an unqualified version of the type
4996 together with any qualifiers that should be applied to it with
4997 c_build_qualified_type; this way, array types including
4998 multidimensional array types are first built up in unqualified
4999 form and then the qualified form is created with
5000 TYPE_MAIN_VARIANT pointing to the unqualified form. */
5002 while (declarator && declarator->kind != cdk_id)
5004 if (type == error_mark_node)
5006 declarator = declarator->declarator;
5010 /* Each level of DECLARATOR is either a cdk_array (for ...[..]),
5011 a cdk_pointer (for *...),
5012 a cdk_function (for ...(...)),
5013 a cdk_attrs (for nested attributes),
5014 or a cdk_id (for the name being declared
5015 or the place in an absolute declarator
5016 where the name was omitted).
5017 For the last case, we have just exited the loop.
5019 At this point, TYPE is the type of elements of an array,
5020 or for a function to return, or for a pointer to point to.
5021 After this sequence of ifs, TYPE is the type of the
5022 array or function or pointer, and DECLARATOR has had its
5023 outermost layer removed. */
5025 if (array_ptr_quals != TYPE_UNQUALIFIED
5026 || array_ptr_attrs != NULL_TREE
5027 || array_parm_static)
5029 /* Only the innermost declarator (making a parameter be of
5030 array type which is converted to pointer type)
5031 may have static or type qualifiers. */
5032 error_at (loc, "static or type qualifiers in non-parameter array declarator");
5033 array_ptr_quals = TYPE_UNQUALIFIED;
5034 array_ptr_attrs = NULL_TREE;
5035 array_parm_static = 0;
5038 switch (declarator->kind)
5042 /* A declarator with embedded attributes. */
5043 tree attrs = declarator->u.attrs;
5044 const struct c_declarator *inner_decl;
5046 declarator = declarator->declarator;
5047 inner_decl = declarator;
5048 while (inner_decl->kind == cdk_attrs)
5049 inner_decl = inner_decl->declarator;
5050 if (inner_decl->kind == cdk_id)
5051 attr_flags |= (int) ATTR_FLAG_DECL_NEXT;
5052 else if (inner_decl->kind == cdk_function)
5053 attr_flags |= (int) ATTR_FLAG_FUNCTION_NEXT;
5054 else if (inner_decl->kind == cdk_array)
5055 attr_flags |= (int) ATTR_FLAG_ARRAY_NEXT;
5056 returned_attrs = decl_attributes (&type,
5057 chainon (returned_attrs, attrs),
5063 tree itype = NULL_TREE;
5064 tree size = declarator->u.array.dimen;
5065 /* The index is a signed object `sizetype' bits wide. */
5066 tree index_type = c_common_signed_type (sizetype);
5068 array_ptr_quals = declarator->u.array.quals;
5069 array_ptr_attrs = declarator->u.array.attrs;
5070 array_parm_static = declarator->u.array.static_p;
5071 array_parm_vla_unspec_p = declarator->u.array.vla_unspec_p;
5073 declarator = declarator->declarator;
5075 /* Check for some types that there cannot be arrays of. */
5077 if (VOID_TYPE_P (type))
5080 error_at (loc, "declaration of %qE as array of voids", name);
5082 error_at (loc, "declaration of type name as array of voids");
5083 type = error_mark_node;
5086 if (TREE_CODE (type) == FUNCTION_TYPE)
5089 error_at (loc, "declaration of %qE as array of functions",
5092 error_at (loc, "declaration of type name as array of "
5094 type = error_mark_node;
5097 if (pedantic && !in_system_header && flexible_array_type_p (type))
5098 pedwarn (loc, OPT_pedantic,
5099 "invalid use of structure with flexible array member");
5101 if (size == error_mark_node)
5102 type = error_mark_node;
5104 if (type == error_mark_node)
5107 /* If size was specified, set ITYPE to a range-type for
5108 that size. Otherwise, ITYPE remains null. finish_decl
5109 may figure it out from an initial value. */
5113 bool size_maybe_const = true;
5114 bool size_int_const = (TREE_CODE (size) == INTEGER_CST
5115 && !TREE_OVERFLOW (size));
5116 bool this_size_varies = false;
5118 /* Strip NON_LVALUE_EXPRs since we aren't using as an
5120 STRIP_TYPE_NOPS (size);
5122 if (!INTEGRAL_TYPE_P (TREE_TYPE (size)))
5125 error_at (loc, "size of array %qE has non-integer type",
5129 "size of unnamed array has non-integer type");
5130 size = integer_one_node;
5133 size = c_fully_fold (size, false, &size_maybe_const);
5135 if (pedantic && size_maybe_const && integer_zerop (size))
5138 pedwarn (loc, OPT_pedantic,
5139 "ISO C forbids zero-size array %qE", name);
5141 pedwarn (loc, OPT_pedantic,
5142 "ISO C forbids zero-size array");
5145 if (TREE_CODE (size) == INTEGER_CST && size_maybe_const)
5147 constant_expression_warning (size);
5148 if (tree_int_cst_sgn (size) < 0)
5151 error_at (loc, "size of array %qE is negative", name);
5153 error_at (loc, "size of unnamed array is negative");
5154 size = integer_one_node;
5156 /* Handle a size folded to an integer constant but
5157 not an integer constant expression. */
5158 if (!size_int_const)
5160 /* If this is a file scope declaration of an
5161 ordinary identifier, this is invalid code;
5162 diagnosing it here and not subsequently
5163 treating the type as variable-length avoids
5164 more confusing diagnostics later. */
5165 if ((decl_context == NORMAL || decl_context == FIELD)
5166 && current_scope == file_scope)
5167 pedwarn (input_location, 0,
5168 "variably modified %qE at file scope",
5171 this_size_varies = size_varies = true;
5172 warn_variable_length_array (name, size);
5175 else if ((decl_context == NORMAL || decl_context == FIELD)
5176 && current_scope == file_scope)
5178 error_at (loc, "variably modified %qE at file scope", name);
5179 size = integer_one_node;
5183 /* Make sure the array size remains visibly
5184 nonconstant even if it is (eg) a const variable
5185 with known value. */
5186 this_size_varies = size_varies = true;
5187 warn_variable_length_array (name, size);
5190 if (integer_zerop (size) && !this_size_varies)
5192 /* A zero-length array cannot be represented with
5193 an unsigned index type, which is what we'll
5194 get with build_index_type. Create an
5195 open-ended range instead. */
5196 itype = build_range_type (sizetype, size, NULL_TREE);
5200 /* Arrange for the SAVE_EXPR on the inside of the
5201 MINUS_EXPR, which allows the -1 to get folded
5202 with the +1 that happens when building TYPE_SIZE. */
5204 size = c_variable_size (size);
5205 if (this_size_varies && TREE_CODE (size) == INTEGER_CST)
5206 size = build2 (COMPOUND_EXPR, TREE_TYPE (size),
5207 integer_zero_node, size);
5209 /* Compute the maximum valid index, that is, size
5210 - 1. Do the calculation in index_type, so that
5211 if it is a variable the computations will be
5212 done in the proper mode. */
5213 itype = fold_build2 (MINUS_EXPR, index_type,
5214 convert (index_type, size),
5215 convert (index_type,
5218 /* If that overflowed, the array is too big. ???
5219 While a size of INT_MAX+1 technically shouldn't
5220 cause an overflow (because we subtract 1), the
5221 overflow is recorded during the conversion to
5222 index_type, before the subtraction. Handling
5223 this case seems like an unnecessary
5225 if (TREE_CODE (itype) == INTEGER_CST
5226 && TREE_OVERFLOW (itype))
5229 error_at (loc, "size of array %qE is too large",
5232 error_at (loc, "size of unnamed array is too large");
5233 type = error_mark_node;
5237 itype = build_index_type (itype);
5239 if (this_size_varies)
5242 *expr = build2 (COMPOUND_EXPR, TREE_TYPE (size),
5246 *expr_const_operands &= size_maybe_const;
5249 else if (decl_context == FIELD)
5251 bool flexible_array_member = false;
5252 if (array_parm_vla_unspec_p)
5253 /* Field names can in fact have function prototype
5254 scope so [*] is disallowed here through making
5255 the field variably modified, not through being
5256 something other than a declaration with function
5261 const struct c_declarator *t = declarator;
5262 while (t->kind == cdk_attrs)
5264 flexible_array_member = (t->kind == cdk_id);
5266 if (flexible_array_member
5267 && pedantic && !flag_isoc99 && !in_system_header)
5268 pedwarn (loc, OPT_pedantic,
5269 "ISO C90 does not support flexible array members");
5271 /* ISO C99 Flexible array members are effectively
5272 identical to GCC's zero-length array extension. */
5273 if (flexible_array_member || array_parm_vla_unspec_p)
5274 itype = build_range_type (sizetype, size_zero_node,
5277 else if (decl_context == PARM)
5279 if (array_parm_vla_unspec_p)
5281 itype = build_range_type (sizetype, size_zero_node, NULL_TREE);
5285 else if (decl_context == TYPENAME)
5287 if (array_parm_vla_unspec_p)
5290 warning (0, "%<[*]%> not in a declaration");
5291 /* We use this to avoid messing up with incomplete
5292 array types of the same type, that would
5293 otherwise be modified below. */
5294 itype = build_range_type (sizetype, size_zero_node,
5300 /* Complain about arrays of incomplete types. */
5301 if (!COMPLETE_TYPE_P (type))
5303 error_at (loc, "array type has incomplete element type");
5304 type = error_mark_node;
5307 /* When itype is NULL, a shared incomplete array type is
5308 returned for all array of a given type. Elsewhere we
5309 make sure we don't complete that type before copying
5310 it, but here we want to make sure we don't ever
5311 modify the shared type, so we gcc_assert (itype)
5313 type = build_array_type (type, itype);
5315 if (type != error_mark_node)
5319 /* It is ok to modify type here even if itype is
5320 NULL: if size_varies, we're in a
5321 multi-dimensional array and the inner type has
5322 variable size, so the enclosing shared array type
5324 if (size && TREE_CODE (size) == INTEGER_CST)
5326 = build_distinct_type_copy (TYPE_MAIN_VARIANT (type));
5327 C_TYPE_VARIABLE_SIZE (type) = 1;
5330 /* The GCC extension for zero-length arrays differs from
5331 ISO flexible array members in that sizeof yields
5333 if (size && integer_zerop (size))
5336 TYPE_SIZE (type) = bitsize_zero_node;
5337 TYPE_SIZE_UNIT (type) = size_zero_node;
5339 if (array_parm_vla_unspec_p)
5342 /* The type is complete. C99 6.7.5.2p4 */
5343 TYPE_SIZE (type) = bitsize_zero_node;
5344 TYPE_SIZE_UNIT (type) = size_zero_node;
5348 if (decl_context != PARM
5349 && (array_ptr_quals != TYPE_UNQUALIFIED
5350 || array_ptr_attrs != NULL_TREE
5351 || array_parm_static))
5353 error_at (loc, "static or type qualifiers in non-parameter array declarator");
5354 array_ptr_quals = TYPE_UNQUALIFIED;
5355 array_ptr_attrs = NULL_TREE;
5356 array_parm_static = 0;
5362 /* Say it's a definition only for the declarator closest
5363 to the identifier, apart possibly from some
5365 bool really_funcdef = false;
5369 const struct c_declarator *t = declarator->declarator;
5370 while (t->kind == cdk_attrs)
5372 really_funcdef = (t->kind == cdk_id);
5375 /* Declaring a function type. Make sure we have a valid
5376 type for the function to return. */
5377 if (type == error_mark_node)
5380 size_varies = false;
5382 /* Warn about some types functions can't return. */
5383 if (TREE_CODE (type) == FUNCTION_TYPE)
5386 error_at (loc, "%qE declared as function returning a "
5389 error_at (loc, "type name declared as function "
5390 "returning a function");
5391 type = integer_type_node;
5393 if (TREE_CODE (type) == ARRAY_TYPE)
5396 error_at (loc, "%qE declared as function returning an array",
5399 error_at (loc, "type name declared as function returning "
5401 type = integer_type_node;
5403 errmsg = targetm.invalid_return_type (type);
5407 type = integer_type_node;
5410 /* Construct the function type and go to the next
5411 inner layer of declarator. */
5412 arg_info = declarator->u.arg_info;
5413 arg_types = grokparms (arg_info, really_funcdef);
5415 put_pending_sizes (arg_info->pending_sizes);
5417 /* Type qualifiers before the return type of the function
5418 qualify the return type, not the function type. */
5421 /* Type qualifiers on a function return type are
5422 normally permitted by the standard but have no
5423 effect, so give a warning at -Wreturn-type.
5424 Qualifiers on a void return type are banned on
5425 function definitions in ISO C; GCC used to used
5426 them for noreturn functions. */
5427 if (VOID_TYPE_P (type) && really_funcdef)
5429 "function definition has qualified void return type");
5431 warning_at (loc, OPT_Wignored_qualifiers,
5432 "type qualifiers ignored on function return type");
5434 type = c_build_qualified_type (type, type_quals);
5436 type_quals = TYPE_UNQUALIFIED;
5438 type = build_function_type (type, arg_types);
5439 declarator = declarator->declarator;
5441 /* Set the TYPE_CONTEXTs for each tagged type which is local to
5442 the formal parameter list of this FUNCTION_TYPE to point to
5443 the FUNCTION_TYPE node itself. */
5447 for (link = arg_info->tags;
5449 link = TREE_CHAIN (link))
5450 TYPE_CONTEXT (TREE_VALUE (link)) = type;
5456 /* Merge any constancy or volatility into the target type
5459 if (pedantic && TREE_CODE (type) == FUNCTION_TYPE
5461 pedwarn (loc, OPT_pedantic,
5462 "ISO C forbids qualified function types");
5464 type = c_build_qualified_type (type, type_quals);
5465 size_varies = false;
5467 /* When the pointed-to type involves components of variable size,
5468 care must be taken to ensure that the size evaluation code is
5469 emitted early enough to dominate all the possible later uses
5470 and late enough for the variables on which it depends to have
5473 This is expected to happen automatically when the pointed-to
5474 type has a name/declaration of it's own, but special attention
5475 is required if the type is anonymous.
5477 We handle the NORMAL and FIELD contexts here by attaching an
5478 artificial TYPE_DECL to such pointed-to type. This forces the
5479 sizes evaluation at a safe point and ensures it is not deferred
5480 until e.g. within a deeper conditional context.
5482 We expect nothing to be needed here for PARM or TYPENAME.
5483 Pushing a TYPE_DECL at this point for TYPENAME would actually
5484 be incorrect, as we might be in the middle of an expression
5485 with side effects on the pointed-to type size "arguments" prior
5486 to the pointer declaration point and the fake TYPE_DECL in the
5487 enclosing context would force the size evaluation prior to the
5490 if (!TYPE_NAME (type)
5491 && (decl_context == NORMAL || decl_context == FIELD)
5492 && variably_modified_type_p (type, NULL_TREE))
5494 tree decl = build_decl (loc, TYPE_DECL, NULL_TREE, type);
5495 DECL_ARTIFICIAL (decl) = 1;
5497 finish_decl (decl, loc, NULL_TREE, NULL_TREE, NULL_TREE);
5498 TYPE_NAME (type) = decl;
5501 type = build_pointer_type (type);
5503 /* Process type qualifiers (such as const or volatile)
5504 that were given inside the `*'. */
5505 type_quals = declarator->u.pointer_quals;
5507 declarator = declarator->declarator;
5514 *decl_attrs = chainon (returned_attrs, *decl_attrs);
5516 /* Now TYPE has the actual type, apart from any qualifiers in
5519 /* Check the type and width of a bit-field. */
5521 check_bitfield_type_and_width (&type, width, name);
5523 /* Did array size calculations overflow? */
5525 if (TREE_CODE (type) == ARRAY_TYPE
5526 && COMPLETE_TYPE_P (type)
5527 && TREE_CODE (TYPE_SIZE_UNIT (type)) == INTEGER_CST
5528 && TREE_OVERFLOW (TYPE_SIZE_UNIT (type)))
5531 error_at (loc, "size of array %qE is too large", name);
5533 error_at (loc, "size of unnamed array is too large");
5534 /* If we proceed with the array type as it is, we'll eventually
5535 crash in tree_low_cst(). */
5536 type = error_mark_node;
5539 /* If this is declaring a typedef name, return a TYPE_DECL. */
5541 if (storage_class == csc_typedef)
5544 if (pedantic && TREE_CODE (type) == FUNCTION_TYPE
5546 pedwarn (loc, OPT_pedantic,
5547 "ISO C forbids qualified function types");
5549 type = c_build_qualified_type (type, type_quals);
5550 decl = build_decl (declarator->id_loc,
5551 TYPE_DECL, declarator->u.id, type);
5552 if (declspecs->explicit_signed_p)
5553 C_TYPEDEF_EXPLICITLY_SIGNED (decl) = 1;
5554 if (declspecs->inline_p)
5555 pedwarn (loc, 0,"typedef %q+D declared %<inline%>", decl);
5557 if (warn_cxx_compat && declarator->u.id != NULL_TREE)
5559 struct c_binding *b = I_TAG_BINDING (declarator->u.id);
5562 && b->decl != NULL_TREE
5563 && (B_IN_CURRENT_SCOPE (b)
5564 || (current_scope == file_scope && B_IN_EXTERNAL_SCOPE (b)))
5565 && TYPE_MAIN_VARIANT (b->decl) != TYPE_MAIN_VARIANT (type))
5567 warning_at (declarator->id_loc, OPT_Wc___compat,
5568 ("using %qD as both a typedef and a tag is "
5571 if (b->locus != UNKNOWN_LOCATION)
5572 inform (b->locus, "originally defined here");
5579 /* If this is a type name (such as, in a cast or sizeof),
5580 compute the type and return it now. */
5582 if (decl_context == TYPENAME)
5584 /* Note that the grammar rejects storage classes in typenames
5586 gcc_assert (storage_class == csc_none && !threadp
5587 && !declspecs->inline_p);
5588 if (pedantic && TREE_CODE (type) == FUNCTION_TYPE
5590 pedwarn (loc, OPT_pedantic,
5591 "ISO C forbids const or volatile function types");
5593 type = c_build_qualified_type (type, type_quals);
5597 if (pedantic && decl_context == FIELD
5598 && variably_modified_type_p (type, NULL_TREE))
5601 pedwarn (loc, OPT_pedantic, "a member of a structure or union cannot "
5602 "have a variably modified type");
5605 /* Aside from typedefs and type names (handle above),
5606 `void' at top level (not within pointer)
5607 is allowed only in public variables.
5608 We don't complain about parms either, but that is because
5609 a better error message can be made later. */
5611 if (VOID_TYPE_P (type) && decl_context != PARM
5612 && !((decl_context != FIELD && TREE_CODE (type) != FUNCTION_TYPE)
5613 && (storage_class == csc_extern
5614 || (current_scope == file_scope
5615 && !(storage_class == csc_static
5616 || storage_class == csc_register)))))
5618 error_at (loc, "variable or field %qE declared void", name);
5619 type = integer_type_node;
5622 /* Now create the decl, which may be a VAR_DECL, a PARM_DECL
5623 or a FUNCTION_DECL, depending on DECL_CONTEXT and TYPE. */
5628 if (decl_context == PARM)
5632 /* A parameter declared as an array of T is really a pointer to T.
5633 One declared as a function is really a pointer to a function. */
5635 if (TREE_CODE (type) == ARRAY_TYPE)
5637 /* Transfer const-ness of array into that of type pointed to. */
5638 type = TREE_TYPE (type);
5640 type = c_build_qualified_type (type, type_quals);
5641 type = build_pointer_type (type);
5642 type_quals = array_ptr_quals;
5644 type = c_build_qualified_type (type, type_quals);
5646 /* We don't yet implement attributes in this context. */
5647 if (array_ptr_attrs != NULL_TREE)
5648 warning_at (loc, OPT_Wattributes,
5649 "attributes in parameter array declarator ignored");
5651 size_varies = false;
5653 else if (TREE_CODE (type) == FUNCTION_TYPE)
5656 pedwarn (loc, OPT_pedantic,
5657 "ISO C forbids qualified function types");
5659 type = c_build_qualified_type (type, type_quals);
5660 type = build_pointer_type (type);
5661 type_quals = TYPE_UNQUALIFIED;
5663 else if (type_quals)
5664 type = c_build_qualified_type (type, type_quals);
5666 decl = build_decl (declarator->id_loc,
5667 PARM_DECL, declarator->u.id, type);
5669 C_DECL_VARIABLE_SIZE (decl) = 1;
5671 /* Compute the type actually passed in the parmlist,
5672 for the case where there is no prototype.
5673 (For example, shorts and chars are passed as ints.)
5674 When there is a prototype, this is overridden later. */
5676 if (type == error_mark_node)
5677 promoted_type = type;
5679 promoted_type = c_type_promotes_to (type);
5681 DECL_ARG_TYPE (decl) = promoted_type;
5682 if (declspecs->inline_p)
5683 pedwarn (loc, 0, "parameter %q+D declared %<inline%>", decl);
5685 else if (decl_context == FIELD)
5687 /* Note that the grammar rejects storage classes in typenames
5689 gcc_assert (storage_class == csc_none && !threadp
5690 && !declspecs->inline_p);
5692 /* Structure field. It may not be a function. */
5694 if (TREE_CODE (type) == FUNCTION_TYPE)
5696 error_at (loc, "field %qE declared as a function", name);
5697 type = build_pointer_type (type);
5699 else if (TREE_CODE (type) != ERROR_MARK
5700 && !COMPLETE_OR_UNBOUND_ARRAY_TYPE_P (type))
5703 error_at (loc, "field %qE has incomplete type", name);
5705 error_at (loc, "unnamed field has incomplete type");
5706 type = error_mark_node;
5708 type = c_build_qualified_type (type, type_quals);
5709 decl = build_decl (declarator->id_loc,
5710 FIELD_DECL, declarator->u.id, type);
5711 DECL_NONADDRESSABLE_P (decl) = bitfield;
5712 if (bitfield && !declarator->u.id)
5713 TREE_NO_WARNING (decl) = 1;
5716 C_DECL_VARIABLE_SIZE (decl) = 1;
5718 else if (TREE_CODE (type) == FUNCTION_TYPE)
5720 if (storage_class == csc_register || threadp)
5722 error_at (loc, "invalid storage class for function %qE", name);
5724 else if (current_scope != file_scope)
5726 /* Function declaration not at file scope. Storage
5727 classes other than `extern' are not allowed, C99
5728 6.7.1p5, and `extern' makes no difference. However,
5729 GCC allows 'auto', perhaps with 'inline', to support
5730 nested functions. */
5731 if (storage_class == csc_auto)
5732 pedwarn (loc, OPT_pedantic,
5733 "invalid storage class for function %qE", name);
5734 else if (storage_class == csc_static)
5736 error_at (loc, "invalid storage class for function %qE", name);
5738 storage_class = declspecs->storage_class = csc_none;
5744 decl = build_decl (declarator->id_loc,
5745 FUNCTION_DECL, declarator->u.id, type);
5746 decl = build_decl_attribute_variant (decl, decl_attr);
5748 if (pedantic && type_quals && !DECL_IN_SYSTEM_HEADER (decl))
5749 pedwarn (loc, OPT_pedantic,
5750 "ISO C forbids qualified function types");
5752 /* GNU C interprets a volatile-qualified function type to indicate
5753 that the function does not return. */
5754 if ((type_quals & TYPE_QUAL_VOLATILE)
5755 && !VOID_TYPE_P (TREE_TYPE (TREE_TYPE (decl))))
5756 warning_at (loc, 0, "%<noreturn%> function returns non-void value");
5758 /* Every function declaration is an external reference
5759 (DECL_EXTERNAL) except for those which are not at file
5760 scope and are explicitly declared "auto". This is
5761 forbidden by standard C (C99 6.7.1p5) and is interpreted by
5762 GCC to signify a forward declaration of a nested function. */
5763 if (storage_class == csc_auto && current_scope != file_scope)
5764 DECL_EXTERNAL (decl) = 0;
5765 /* In C99, a function which is declared 'inline' with 'extern'
5766 is not an external reference (which is confusing). It
5767 means that the later definition of the function must be output
5768 in this file, C99 6.7.4p6. In GNU C89, a function declared
5769 'extern inline' is an external reference. */
5770 else if (declspecs->inline_p && storage_class != csc_static)
5771 DECL_EXTERNAL (decl) = ((storage_class == csc_extern)
5772 == flag_gnu89_inline);
5774 DECL_EXTERNAL (decl) = !initialized;
5776 /* Record absence of global scope for `static' or `auto'. */
5778 = !(storage_class == csc_static || storage_class == csc_auto);
5780 /* For a function definition, record the argument information
5781 block where store_parm_decls will look for it. */
5783 current_function_arg_info = arg_info;
5785 if (declspecs->default_int_p)
5786 C_FUNCTION_IMPLICIT_INT (decl) = 1;
5788 /* Record presence of `inline', if it is reasonable. */
5789 if (flag_hosted && MAIN_NAME_P (declarator->u.id))
5791 if (declspecs->inline_p)
5792 pedwarn (loc, 0, "cannot inline function %<main%>");
5794 else if (declspecs->inline_p)
5795 /* Record that the function is declared `inline'. */
5796 DECL_DECLARED_INLINE_P (decl) = 1;
5800 /* It's a variable. */
5801 /* An uninitialized decl with `extern' is a reference. */
5802 int extern_ref = !initialized && storage_class == csc_extern;
5804 type = c_build_qualified_type (type, type_quals);
5806 /* C99 6.2.2p7: It is invalid (compile-time undefined
5807 behavior) to create an 'extern' declaration for a
5808 variable if there is a global declaration that is
5809 'static' and the global declaration is not visible.
5810 (If the static declaration _is_ currently visible,
5811 the 'extern' declaration is taken to refer to that decl.) */
5812 if (extern_ref && current_scope != file_scope)
5814 tree global_decl = identifier_global_value (declarator->u.id);
5815 tree visible_decl = lookup_name (declarator->u.id);
5818 && global_decl != visible_decl
5819 && TREE_CODE (global_decl) == VAR_DECL
5820 && !TREE_PUBLIC (global_decl))
5821 error_at (loc, "variable previously declared %<static%> "
5822 "redeclared %<extern%>");
5825 decl = build_decl (declarator->id_loc,
5826 VAR_DECL, declarator->u.id, type);
5828 C_DECL_VARIABLE_SIZE (decl) = 1;
5830 if (declspecs->inline_p)
5831 pedwarn (loc, 0, "variable %q+D declared %<inline%>", decl);
5833 /* At file scope, an initialized extern declaration may follow
5834 a static declaration. In that case, DECL_EXTERNAL will be
5835 reset later in start_decl. */
5836 DECL_EXTERNAL (decl) = (storage_class == csc_extern);
5838 /* At file scope, the presence of a `static' or `register' storage
5839 class specifier, or the absence of all storage class specifiers
5840 makes this declaration a definition (perhaps tentative). Also,
5841 the absence of `static' makes it public. */
5842 if (current_scope == file_scope)
5844 TREE_PUBLIC (decl) = storage_class != csc_static;
5845 TREE_STATIC (decl) = !extern_ref;
5847 /* Not at file scope, only `static' makes a static definition. */
5850 TREE_STATIC (decl) = (storage_class == csc_static);
5851 TREE_PUBLIC (decl) = extern_ref;
5855 DECL_TLS_MODEL (decl) = decl_default_tls_model (decl);
5858 if ((storage_class == csc_extern
5859 || (storage_class == csc_none
5860 && TREE_CODE (type) == FUNCTION_TYPE
5862 && variably_modified_type_p (type, NULL_TREE))
5865 if (TREE_CODE (type) == FUNCTION_TYPE)
5866 error_at (loc, "non-nested function with variably modified type");
5868 error_at (loc, "object with variably modified type must have "
5872 /* Record `register' declaration for warnings on &
5873 and in case doing stupid register allocation. */
5875 if (storage_class == csc_register)
5877 C_DECL_REGISTER (decl) = 1;
5878 DECL_REGISTER (decl) = 1;
5881 /* Record constancy and volatility. */
5882 c_apply_type_quals_to_decl (type_quals, decl);
5884 /* If a type has volatile components, it should be stored in memory.
5885 Otherwise, the fact that those components are volatile
5886 will be ignored, and would even crash the compiler.
5887 Of course, this only makes sense on VAR,PARM, and RESULT decl's. */
5888 if (C_TYPE_FIELDS_VOLATILE (TREE_TYPE (decl))
5889 && (TREE_CODE (decl) == VAR_DECL || TREE_CODE (decl) == PARM_DECL
5890 || TREE_CODE (decl) == RESULT_DECL))
5892 /* It is not an error for a structure with volatile fields to
5893 be declared register, but reset DECL_REGISTER since it
5894 cannot actually go in a register. */
5895 int was_reg = C_DECL_REGISTER (decl);
5896 C_DECL_REGISTER (decl) = 0;
5897 DECL_REGISTER (decl) = 0;
5898 c_mark_addressable (decl);
5899 C_DECL_REGISTER (decl) = was_reg;
5902 /* This is the earliest point at which we might know the assembler
5903 name of a variable. Thus, if it's known before this, die horribly. */
5904 gcc_assert (!DECL_ASSEMBLER_NAME_SET_P (decl));
5907 && TREE_CODE (decl) == VAR_DECL
5908 && TREE_PUBLIC (decl)
5909 && TREE_STATIC (decl)
5910 && (TREE_CODE (TREE_TYPE (decl)) == RECORD_TYPE
5911 || TREE_CODE (TREE_TYPE (decl)) == UNION_TYPE
5912 || TREE_CODE (TREE_TYPE (decl)) == ENUMERAL_TYPE)
5913 && TYPE_NAME (TREE_TYPE (decl)) == NULL_TREE)
5914 warning_at (DECL_SOURCE_LOCATION (decl), OPT_Wc___compat,
5915 ("non-local variable %qD with anonymous type is "
5916 "questionable in C++"),
5923 /* Decode the parameter-list info for a function type or function definition.
5924 The argument is the value returned by `get_parm_info' (or made in c-parse.c
5925 if there is an identifier list instead of a parameter decl list).
5926 These two functions are separate because when a function returns
5927 or receives functions then each is called multiple times but the order
5928 of calls is different. The last call to `grokparms' is always the one
5929 that contains the formal parameter names of a function definition.
5931 Return a list of arg types to use in the FUNCTION_TYPE for this function.
5933 FUNCDEF_FLAG is true for a function definition, false for
5934 a mere declaration. A nonempty identifier-list gets an error message
5935 when FUNCDEF_FLAG is false. */
5938 grokparms (struct c_arg_info *arg_info, bool funcdef_flag)
5940 tree arg_types = arg_info->types;
5942 if (funcdef_flag && arg_info->had_vla_unspec)
5944 /* A function definition isn't function prototype scope C99 6.2.1p4. */
5946 error ("%<[*]%> not allowed in other than function prototype scope");
5949 if (arg_types == 0 && !funcdef_flag && !in_system_header)
5950 warning (OPT_Wstrict_prototypes,
5951 "function declaration isn%'t a prototype");
5953 if (arg_types == error_mark_node)
5954 return 0; /* don't set TYPE_ARG_TYPES in this case */
5956 else if (arg_types && TREE_CODE (TREE_VALUE (arg_types)) == IDENTIFIER_NODE)
5959 pedwarn (input_location, 0, "parameter names (without types) in function declaration");
5961 arg_info->parms = arg_info->types;
5962 arg_info->types = 0;
5967 tree parm, type, typelt;
5968 unsigned int parmno;
5971 /* If there is a parameter of incomplete type in a definition,
5972 this is an error. In a declaration this is valid, and a
5973 struct or union type may be completed later, before any calls
5974 or definition of the function. In the case where the tag was
5975 first declared within the parameter list, a warning has
5976 already been given. If a parameter has void type, then
5977 however the function cannot be defined or called, so
5980 for (parm = arg_info->parms, typelt = arg_types, parmno = 1;
5982 parm = TREE_CHAIN (parm), typelt = TREE_CHAIN (typelt), parmno++)
5984 type = TREE_VALUE (typelt);
5985 if (type == error_mark_node)
5988 if (!COMPLETE_TYPE_P (type))
5992 if (DECL_NAME (parm))
5993 error ("parameter %u (%q+D) has incomplete type",
5996 error ("%Jparameter %u has incomplete type",
5999 TREE_VALUE (typelt) = error_mark_node;
6000 TREE_TYPE (parm) = error_mark_node;
6002 else if (VOID_TYPE_P (type))
6004 if (DECL_NAME (parm))
6005 warning (0, "parameter %u (%q+D) has void type",
6008 warning (0, "%Jparameter %u has void type",
6013 errmsg = targetm.invalid_parameter_type (type);
6017 TREE_VALUE (typelt) = error_mark_node;
6018 TREE_TYPE (parm) = error_mark_node;
6021 if (DECL_NAME (parm) && TREE_USED (parm))
6022 warn_if_shadowing (parm);
6028 /* Take apart the current scope and return a c_arg_info structure with
6029 info on a parameter list just parsed.
6031 This structure is later fed to 'grokparms' and 'store_parm_decls'.
6033 ELLIPSIS being true means the argument list ended in '...' so don't
6034 append a sentinel (void_list_node) to the end of the type-list. */
6037 get_parm_info (bool ellipsis)
6039 struct c_binding *b = current_scope->bindings;
6040 struct c_arg_info *arg_info = XOBNEW (&parser_obstack,
6047 static bool explained_incomplete_types = false;
6048 bool gave_void_only_once_err = false;
6050 arg_info->parms = 0;
6052 arg_info->types = 0;
6053 arg_info->others = 0;
6054 arg_info->pending_sizes = 0;
6055 arg_info->had_vla_unspec = current_scope->had_vla_unspec;
6057 /* The bindings in this scope must not get put into a block.
6058 We will take care of deleting the binding nodes. */
6059 current_scope->bindings = 0;
6061 /* This function is only called if there was *something* on the
6065 /* A parameter list consisting solely of 'void' indicates that the
6066 function takes no arguments. But if the 'void' is qualified
6067 (by 'const' or 'volatile'), or has a storage class specifier
6068 ('register'), then the behavior is undefined; issue an error.
6069 Typedefs for 'void' are OK (see DR#157). */
6070 if (b->prev == 0 /* one binding */
6071 && TREE_CODE (b->decl) == PARM_DECL /* which is a parameter */
6072 && !DECL_NAME (b->decl) /* anonymous */
6073 && VOID_TYPE_P (TREE_TYPE (b->decl))) /* of void type */
6075 if (TREE_THIS_VOLATILE (b->decl)
6076 || TREE_READONLY (b->decl)
6077 || C_DECL_REGISTER (b->decl))
6078 error ("%<void%> as only parameter may not be qualified");
6080 /* There cannot be an ellipsis. */
6082 error ("%<void%> must be the only parameter");
6084 arg_info->types = void_list_node;
6089 types = void_list_node;
6091 /* Break up the bindings list into parms, tags, types, and others;
6092 apply sanity checks; purge the name-to-decl bindings. */
6095 tree decl = b->decl;
6096 tree type = TREE_TYPE (decl);
6097 const char *keyword;
6099 switch (TREE_CODE (decl))
6104 gcc_assert (I_SYMBOL_BINDING (b->id) == b);
6105 I_SYMBOL_BINDING (b->id) = b->shadowed;
6108 /* Check for forward decls that never got their actual decl. */
6109 if (TREE_ASM_WRITTEN (decl))
6110 error ("parameter %q+D has just a forward declaration", decl);
6111 /* Check for (..., void, ...) and issue an error. */
6112 else if (VOID_TYPE_P (type) && !DECL_NAME (decl))
6114 if (!gave_void_only_once_err)
6116 error ("%<void%> must be the only parameter");
6117 gave_void_only_once_err = true;
6122 /* Valid parameter, add it to the list. */
6123 TREE_CHAIN (decl) = parms;
6126 /* Since there is a prototype, args are passed in their
6127 declared types. The back end may override this later. */
6128 DECL_ARG_TYPE (decl) = type;
6129 types = tree_cons (0, type, types);
6133 case ENUMERAL_TYPE: keyword = "enum"; goto tag;
6134 case UNION_TYPE: keyword = "union"; goto tag;
6135 case RECORD_TYPE: keyword = "struct"; goto tag;
6137 /* Types may not have tag-names, in which case the type
6138 appears in the bindings list with b->id NULL. */
6141 gcc_assert (I_TAG_BINDING (b->id) == b);
6142 I_TAG_BINDING (b->id) = b->shadowed;
6145 /* Warn about any struct, union or enum tags defined in a
6146 parameter list. The scope of such types is limited to
6147 the parameter list, which is rarely if ever desirable
6148 (it's impossible to call such a function with type-
6149 correct arguments). An anonymous union parm type is
6150 meaningful as a GNU extension, so don't warn for that. */
6151 if (TREE_CODE (decl) != UNION_TYPE || b->id != 0)
6154 /* The %s will be one of 'struct', 'union', or 'enum'. */
6155 warning (0, "%<%s %E%> declared inside parameter list",
6158 /* The %s will be one of 'struct', 'union', or 'enum'. */
6159 warning (0, "anonymous %s declared inside parameter list",
6162 if (!explained_incomplete_types)
6164 warning (0, "its scope is only this definition or declaration,"
6165 " which is probably not what you want");
6166 explained_incomplete_types = true;
6170 tags = tree_cons (b->id, decl, tags);
6176 /* CONST_DECLs appear here when we have an embedded enum,
6177 and TYPE_DECLs appear here when we have an embedded struct
6178 or union. No warnings for this - we already warned about the
6179 type itself. FUNCTION_DECLs appear when there is an implicit
6180 function declaration in the parameter list. */
6182 TREE_CHAIN (decl) = others;
6187 /* error_mark_node appears here when we have an undeclared
6188 variable. Just throw it away. */
6191 gcc_assert (I_SYMBOL_BINDING (b->id) == b);
6192 I_SYMBOL_BINDING (b->id) = b->shadowed;
6196 /* Other things that might be encountered. */
6203 b = free_binding_and_advance (b);
6206 arg_info->parms = parms;
6207 arg_info->tags = tags;
6208 arg_info->types = types;
6209 arg_info->others = others;
6210 arg_info->pending_sizes = get_pending_sizes ();
6214 /* Get the struct, enum or union (CODE says which) with tag NAME.
6215 Define the tag as a forward-reference with location LOC if it is
6216 not defined. Return a c_typespec structure for the type
6220 parser_xref_tag (location_t loc, enum tree_code code, tree name)
6222 struct c_typespec ret;
6226 ret.expr = NULL_TREE;
6227 ret.expr_const_operands = true;
6229 /* If a cross reference is requested, look up the type
6230 already defined for this tag and return it. */
6232 ref = lookup_tag (code, name, 0, &refloc);
6233 /* If this is the right type of tag, return what we found.
6234 (This reference will be shadowed by shadow_tag later if appropriate.)
6235 If this is the wrong type of tag, do not return it. If it was the
6236 wrong type in the same scope, we will have had an error
6237 message already; if in a different scope and declaring
6238 a name, pending_xref_error will give an error message; but if in a
6239 different scope and not declaring a name, this tag should
6240 shadow the previous declaration of a different type of tag, and
6241 this would not work properly if we return the reference found.
6242 (For example, with "struct foo" in an outer scope, "union foo;"
6243 must shadow that tag with a new one of union type.) */
6244 ret.kind = (ref ? ctsk_tagref : ctsk_tagfirstref);
6245 if (ref && TREE_CODE (ref) == code)
6247 if (C_TYPE_DEFINED_IN_STRUCT (ref)
6248 && loc != UNKNOWN_LOCATION
6254 warning_at (loc, OPT_Wc___compat,
6255 ("enum type defined in struct or union "
6256 "is not visible in C++"));
6257 inform (refloc, "enum type defined here");
6260 warning_at (loc, OPT_Wc___compat,
6261 ("struct defined in struct or union "
6262 "is not visible in C++"));
6263 inform (refloc, "struct defined here");
6266 warning_at (loc, OPT_Wc___compat,
6267 ("union defined in struct or union "
6268 "is not visible in C++"));
6269 inform (refloc, "union defined here");
6280 /* If no such tag is yet defined, create a forward-reference node
6281 and record it as the "definition".
6282 When a real declaration of this type is found,
6283 the forward-reference will be altered into a real type. */
6285 ref = make_node (code);
6286 if (code == ENUMERAL_TYPE)
6288 /* Give the type a default layout like unsigned int
6289 to avoid crashing if it does not get defined. */
6290 SET_TYPE_MODE (ref, TYPE_MODE (unsigned_type_node));
6291 TYPE_ALIGN (ref) = TYPE_ALIGN (unsigned_type_node);
6292 TYPE_USER_ALIGN (ref) = 0;
6293 TYPE_UNSIGNED (ref) = 1;
6294 TYPE_PRECISION (ref) = TYPE_PRECISION (unsigned_type_node);
6295 TYPE_MIN_VALUE (ref) = TYPE_MIN_VALUE (unsigned_type_node);
6296 TYPE_MAX_VALUE (ref) = TYPE_MAX_VALUE (unsigned_type_node);
6299 pushtag (loc, name, ref);
6305 /* Get the struct, enum or union (CODE says which) with tag NAME.
6306 Define the tag as a forward-reference if it is not defined.
6307 Return a tree for the type. */
6310 xref_tag (enum tree_code code, tree name)
6312 return parser_xref_tag (input_location, code, name).spec;
6315 /* Make sure that the tag NAME is defined *in the current scope*
6316 at least as a forward reference.
6317 LOC is the location of the struct's definition.
6318 CODE says which kind of tag NAME ought to be.
6320 This stores the current value of the file static STRUCT_PARSE_INFO
6321 in *ENCLOSING_STRUCT_PARSE_INFO, and points STRUCT_PARSE_INFO at a
6322 new c_struct_parse_info structure. The old value of
6323 STRUCT_PARSE_INFO is restored in finish_struct. */
6326 start_struct (location_t loc, enum tree_code code, tree name,
6327 struct c_struct_parse_info **enclosing_struct_parse_info)
6329 /* If there is already a tag defined at this scope
6330 (as a forward reference), just return it. */
6332 tree ref = NULL_TREE;
6333 location_t refloc = UNKNOWN_LOCATION;
6335 if (name != NULL_TREE)
6336 ref = lookup_tag (code, name, 1, &refloc);
6337 if (ref && TREE_CODE (ref) == code)
6339 if (TYPE_SIZE (ref))
6341 if (code == UNION_TYPE)
6342 error_at (loc, "redefinition of %<union %E%>", name);
6344 error_at (loc, "redefinition of %<struct %E%>", name);
6345 if (refloc != UNKNOWN_LOCATION)
6346 inform (refloc, "originally defined here");
6347 /* Don't create structures using a name already in use. */
6350 else if (C_TYPE_BEING_DEFINED (ref))
6352 if (code == UNION_TYPE)
6353 error_at (loc, "nested redefinition of %<union %E%>", name);
6355 error_at (loc, "nested redefinition of %<struct %E%>", name);
6356 /* Don't bother to report "originally defined here" for a
6357 nested redefinition; the original definition should be
6359 /* Don't create structures that contain themselves. */
6364 /* Otherwise create a forward-reference just so the tag is in scope. */
6366 if (ref == NULL_TREE || TREE_CODE (ref) != code)
6368 ref = make_node (code);
6369 pushtag (loc, name, ref);
6372 C_TYPE_BEING_DEFINED (ref) = 1;
6373 TYPE_PACKED (ref) = flag_pack_struct;
6375 *enclosing_struct_parse_info = struct_parse_info;
6376 struct_parse_info = XNEW (struct c_struct_parse_info);
6377 struct_parse_info->struct_types = VEC_alloc (tree, heap, 0);
6378 struct_parse_info->fields = VEC_alloc (c_binding_ptr, heap, 0);
6379 struct_parse_info->typedefs_seen = VEC_alloc (tree, heap, 0);
6381 /* FIXME: This will issue a warning for a use of a type defined
6382 within a statement expr used within sizeof, et. al. This is not
6383 terribly serious as C++ doesn't permit statement exprs within
6385 if (warn_cxx_compat && (in_sizeof || in_typeof || in_alignof))
6386 warning_at (loc, OPT_Wc___compat,
6387 "defining type in %qs expression is invalid in C++",
6390 : (in_typeof ? "typeof" : "alignof")));
6395 /* Process the specs, declarator and width (NULL if omitted)
6396 of a structure component, returning a FIELD_DECL node.
6397 WIDTH is non-NULL for bit-fields only, and is an INTEGER_CST node.
6398 DECL_ATTRS is as for grokdeclarator.
6400 LOC is the location of the structure component.
6402 This is done during the parsing of the struct declaration.
6403 The FIELD_DECL nodes are chained together and the lot of them
6404 are ultimately passed to `build_struct' to make the RECORD_TYPE node. */
6407 grokfield (location_t loc,
6408 struct c_declarator *declarator, struct c_declspecs *declspecs,
6409 tree width, tree *decl_attrs)
6413 if (declarator->kind == cdk_id && declarator->u.id == NULL_TREE
6414 && width == NULL_TREE)
6416 /* This is an unnamed decl.
6418 If we have something of the form "union { list } ;" then this
6419 is the anonymous union extension. Similarly for struct.
6421 If this is something of the form "struct foo;", then
6422 If MS extensions are enabled, this is handled as an
6424 Otherwise this is a forward declaration of a structure tag.
6426 If this is something of the form "foo;" and foo is a TYPE_DECL, then
6427 If MS extensions are enabled and foo names a structure, then
6428 again this is an anonymous struct.
6429 Otherwise this is an error.
6431 Oh what a horrid tangled web we weave. I wonder if MS consciously
6432 took this from Plan 9 or if it was an accident of implementation
6433 that took root before someone noticed the bug... */
6435 tree type = declspecs->type;
6436 bool type_ok = (TREE_CODE (type) == RECORD_TYPE
6437 || TREE_CODE (type) == UNION_TYPE);
6441 && (flag_ms_extensions || !declspecs->typedef_p))
6443 if (flag_ms_extensions)
6447 else if (TYPE_NAME (type) == NULL)
6454 pedwarn (loc, 0, "declaration does not declare anything");
6457 pedwarn (loc, OPT_pedantic, "ISO C doesn%'t support unnamed structs/unions");
6460 value = grokdeclarator (declarator, declspecs, FIELD, false,
6461 width ? &width : NULL, decl_attrs, NULL, NULL,
6464 finish_decl (value, loc, NULL_TREE, NULL_TREE, NULL_TREE);
6465 DECL_INITIAL (value) = width;
6467 if (warn_cxx_compat && DECL_NAME (value) != NULL_TREE)
6469 /* If we currently have a binding for this field, set the
6470 in_struct field in the binding, so that we warn about lookups
6472 struct c_binding *b = I_SYMBOL_BINDING (DECL_NAME (value));
6475 /* If the in_struct field is not yet set, push it on a list
6476 to be cleared when this struct is finished. */
6479 VEC_safe_push (c_binding_ptr, heap,
6480 struct_parse_info->fields, b);
6489 /* Generate an error for any duplicate field names in FIELDLIST. Munge
6490 the list such that this does not present a problem later. */
6493 detect_field_duplicates (tree fieldlist)
6498 /* First, see if there are more than "a few" fields.
6499 This is trivially true if there are zero or one fields. */
6502 x = TREE_CHAIN (fieldlist);
6508 } while (timeout > 0 && x);
6510 /* If there were "few" fields, avoid the overhead of allocating
6511 a hash table. Instead just do the nested traversal thing. */
6514 for (x = TREE_CHAIN (fieldlist); x ; x = TREE_CHAIN (x))
6517 for (y = fieldlist; y != x; y = TREE_CHAIN (y))
6518 if (DECL_NAME (y) == DECL_NAME (x))
6520 error ("duplicate member %q+D", x);
6521 DECL_NAME (x) = NULL_TREE;
6527 htab_t htab = htab_create (37, htab_hash_pointer, htab_eq_pointer, NULL);
6530 for (x = fieldlist; x ; x = TREE_CHAIN (x))
6531 if ((y = DECL_NAME (x)) != 0)
6533 slot = htab_find_slot (htab, y, INSERT);
6536 error ("duplicate member %q+D", x);
6537 DECL_NAME (x) = NULL_TREE;
6546 /* Finish up struct info used by -Wc++-compat. */
6549 warn_cxx_compat_finish_struct (tree fieldlist)
6553 struct c_binding *b;
6555 /* Set the C_TYPE_DEFINED_IN_STRUCT flag for each type defined in
6556 the current struct. We do this now at the end of the struct
6557 because the flag is used to issue visibility warnings, and we
6558 only want to issue those warnings if the type is referenced
6559 outside of the struct declaration. */
6560 for (ix = 0; VEC_iterate (tree, struct_parse_info->struct_types, ix, x); ++ix)
6561 C_TYPE_DEFINED_IN_STRUCT (x) = 1;
6563 /* The TYPEDEFS_SEEN field of STRUCT_PARSE_INFO is a list of
6564 typedefs used when declaring fields in this struct. If the name
6565 of any of the fields is also a typedef name then the struct would
6566 not parse in C++, because the C++ lookup rules say that the
6567 typedef name would be looked up in the context of the struct, and
6568 would thus be the field rather than the typedef. */
6569 if (!VEC_empty (tree, struct_parse_info->typedefs_seen)
6570 && fieldlist != NULL_TREE)
6572 /* Use a pointer_set using the name of the typedef. We can use
6573 a pointer_set because identifiers are interned. */
6574 struct pointer_set_t *tset = pointer_set_create ();
6577 VEC_iterate (tree, struct_parse_info->typedefs_seen, ix, x);
6579 pointer_set_insert (tset, DECL_NAME (x));
6581 for (x = fieldlist; x != NULL_TREE; x = TREE_CHAIN (x))
6583 if (pointer_set_contains (tset, DECL_NAME (x)))
6585 warning_at (DECL_SOURCE_LOCATION (x), OPT_Wc___compat,
6586 ("using %qD as both field and typedef name is "
6589 /* FIXME: It would be nice to report the location where
6590 the typedef name is used. */
6594 pointer_set_destroy (tset);
6597 /* For each field which has a binding and which was not defined in
6598 an enclosing struct, clear the in_struct field. */
6600 VEC_iterate (c_binding_ptr, struct_parse_info->fields, ix, b);
6605 /* Fill in the fields of a RECORD_TYPE or UNION_TYPE node, T.
6606 LOC is the location of the RECORD_TYPE or UNION_TYPE's definition.
6607 FIELDLIST is a chain of FIELD_DECL nodes for the fields.
6608 ATTRIBUTES are attributes to be applied to the structure.
6610 ENCLOSING_STRUCT_PARSE_INFO is the value of STRUCT_PARSE_INFO when
6611 the struct was started. */
6614 finish_struct (location_t loc, tree t, tree fieldlist, tree attributes,
6615 struct c_struct_parse_info *enclosing_struct_parse_info)
6618 bool toplevel = file_scope == current_scope;
6619 int saw_named_field;
6621 /* If this type was previously laid out as a forward reference,
6622 make sure we lay it out again. */
6626 decl_attributes (&t, attributes, (int) ATTR_FLAG_TYPE_IN_PLACE);
6630 for (x = fieldlist; x; x = TREE_CHAIN (x))
6631 if (DECL_NAME (x) != 0)
6636 if (TREE_CODE (t) == UNION_TYPE)
6639 pedwarn (loc, OPT_pedantic, "union has no named members");
6641 pedwarn (loc, OPT_pedantic, "union has no members");
6646 pedwarn (loc, OPT_pedantic, "struct has no named members");
6648 pedwarn (loc, OPT_pedantic, "struct has no members");
6653 /* Install struct as DECL_CONTEXT of each field decl.
6654 Also process specified field sizes, found in the DECL_INITIAL,
6655 storing 0 there after the type has been changed to precision equal
6656 to its width, rather than the precision of the specified standard
6657 type. (Correct layout requires the original type to have been preserved
6660 saw_named_field = 0;
6661 for (x = fieldlist; x; x = TREE_CHAIN (x))
6663 if (TREE_TYPE (x) == error_mark_node)
6666 DECL_CONTEXT (x) = t;
6668 /* If any field is const, the structure type is pseudo-const. */
6669 if (TREE_READONLY (x))
6670 C_TYPE_FIELDS_READONLY (t) = 1;
6673 /* A field that is pseudo-const makes the structure likewise. */
6674 tree t1 = TREE_TYPE (x);
6675 while (TREE_CODE (t1) == ARRAY_TYPE)
6676 t1 = TREE_TYPE (t1);
6677 if ((TREE_CODE (t1) == RECORD_TYPE || TREE_CODE (t1) == UNION_TYPE)
6678 && C_TYPE_FIELDS_READONLY (t1))
6679 C_TYPE_FIELDS_READONLY (t) = 1;
6682 /* Any field that is volatile means variables of this type must be
6683 treated in some ways as volatile. */
6684 if (TREE_THIS_VOLATILE (x))
6685 C_TYPE_FIELDS_VOLATILE (t) = 1;
6687 /* Any field of nominal variable size implies structure is too. */
6688 if (C_DECL_VARIABLE_SIZE (x))
6689 C_TYPE_VARIABLE_SIZE (t) = 1;
6691 if (DECL_INITIAL (x))
6693 unsigned HOST_WIDE_INT width = tree_low_cst (DECL_INITIAL (x), 1);
6694 DECL_SIZE (x) = bitsize_int (width);
6695 DECL_BIT_FIELD (x) = 1;
6696 SET_DECL_C_BIT_FIELD (x);
6700 && (DECL_BIT_FIELD (x)
6701 || TYPE_ALIGN (TREE_TYPE (x)) > BITS_PER_UNIT))
6702 DECL_PACKED (x) = 1;
6704 /* Detect flexible array member in an invalid context. */
6705 if (TREE_CODE (TREE_TYPE (x)) == ARRAY_TYPE
6706 && TYPE_SIZE (TREE_TYPE (x)) == NULL_TREE
6707 && TYPE_DOMAIN (TREE_TYPE (x)) != NULL_TREE
6708 && TYPE_MAX_VALUE (TYPE_DOMAIN (TREE_TYPE (x))) == NULL_TREE)
6710 if (TREE_CODE (t) == UNION_TYPE)
6712 error_at (DECL_SOURCE_LOCATION (x),
6713 "%Jflexible array member in union", x);
6714 TREE_TYPE (x) = error_mark_node;
6716 else if (TREE_CHAIN (x) != NULL_TREE)
6718 error_at (DECL_SOURCE_LOCATION (x),
6719 "%Jflexible array member not at end of struct", x);
6720 TREE_TYPE (x) = error_mark_node;
6722 else if (!saw_named_field)
6724 error_at (DECL_SOURCE_LOCATION (x),
6725 "%Jflexible array member in otherwise empty struct",
6727 TREE_TYPE (x) = error_mark_node;
6731 if (pedantic && !in_system_header && TREE_CODE (t) == RECORD_TYPE
6732 && flexible_array_type_p (TREE_TYPE (x)))
6733 pedwarn (loc, OPT_pedantic,
6734 "%Jinvalid use of structure with flexible array member", x);
6737 saw_named_field = 1;
6740 detect_field_duplicates (fieldlist);
6742 /* Now we have the nearly final fieldlist. Record it,
6743 then lay out the structure or union (including the fields). */
6745 TYPE_FIELDS (t) = fieldlist;
6749 /* Give bit-fields their proper types. */
6751 tree *fieldlistp = &fieldlist;
6753 if (TREE_CODE (*fieldlistp) == FIELD_DECL && DECL_INITIAL (*fieldlistp)
6754 && TREE_TYPE (*fieldlistp) != error_mark_node)
6756 unsigned HOST_WIDE_INT width
6757 = tree_low_cst (DECL_INITIAL (*fieldlistp), 1);
6758 tree type = TREE_TYPE (*fieldlistp);
6759 if (width != TYPE_PRECISION (type))
6761 TREE_TYPE (*fieldlistp)
6762 = c_build_bitfield_integer_type (width, TYPE_UNSIGNED (type));
6763 DECL_MODE (*fieldlistp) = TYPE_MODE (TREE_TYPE (*fieldlistp));
6765 DECL_INITIAL (*fieldlistp) = 0;
6768 fieldlistp = &TREE_CHAIN (*fieldlistp);
6771 /* Now we have the truly final field list.
6772 Store it in this type and in the variants. */
6774 TYPE_FIELDS (t) = fieldlist;
6776 /* If there are lots of fields, sort so we can look through them fast.
6777 We arbitrarily consider 16 or more elts to be "a lot". */
6782 for (x = fieldlist; x; x = TREE_CHAIN (x))
6784 if (len > 15 || DECL_NAME (x) == NULL)
6792 struct lang_type *space;
6793 struct sorted_fields_type *space2;
6795 len += list_length (x);
6797 /* Use the same allocation policy here that make_node uses, to
6798 ensure that this lives as long as the rest of the struct decl.
6799 All decls in an inline function need to be saved. */
6801 space = GGC_CNEW (struct lang_type);
6802 space2 = GGC_NEWVAR (struct sorted_fields_type,
6803 sizeof (struct sorted_fields_type) + len * sizeof (tree));
6807 field_array = &space2->elts[0];
6808 for (x = fieldlist; x; x = TREE_CHAIN (x))
6810 field_array[len++] = x;
6812 /* If there is anonymous struct or union, break out of the loop. */
6813 if (DECL_NAME (x) == NULL)
6816 /* Found no anonymous struct/union. Add the TYPE_LANG_SPECIFIC. */
6819 TYPE_LANG_SPECIFIC (t) = space;
6820 TYPE_LANG_SPECIFIC (t)->s->len = len;
6821 field_array = TYPE_LANG_SPECIFIC (t)->s->elts;
6822 qsort (field_array, len, sizeof (tree), field_decl_cmp);
6827 for (x = TYPE_MAIN_VARIANT (t); x; x = TYPE_NEXT_VARIANT (x))
6829 TYPE_FIELDS (x) = TYPE_FIELDS (t);
6830 TYPE_LANG_SPECIFIC (x) = TYPE_LANG_SPECIFIC (t);
6831 C_TYPE_FIELDS_READONLY (x) = C_TYPE_FIELDS_READONLY (t);
6832 C_TYPE_FIELDS_VOLATILE (x) = C_TYPE_FIELDS_VOLATILE (t);
6833 C_TYPE_VARIABLE_SIZE (x) = C_TYPE_VARIABLE_SIZE (t);
6836 /* If this was supposed to be a transparent union, but we can't
6837 make it one, warn and turn off the flag. */
6838 if (TREE_CODE (t) == UNION_TYPE
6839 && TYPE_TRANSPARENT_UNION (t)
6840 && (!TYPE_FIELDS (t) || TYPE_MODE (t) != DECL_MODE (TYPE_FIELDS (t))))
6842 TYPE_TRANSPARENT_UNION (t) = 0;
6843 warning_at (loc, 0, "union cannot be made transparent");
6846 /* If this structure or union completes the type of any previous
6847 variable declaration, lay it out and output its rtl. */
6848 for (x = C_TYPE_INCOMPLETE_VARS (TYPE_MAIN_VARIANT (t));
6852 tree decl = TREE_VALUE (x);
6853 if (TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE)
6854 layout_array_type (TREE_TYPE (decl));
6855 if (TREE_CODE (decl) != TYPE_DECL)
6857 layout_decl (decl, 0);
6858 if (c_dialect_objc ())
6859 objc_check_decl (decl);
6860 rest_of_decl_compilation (decl, toplevel, 0);
6865 C_TYPE_INCOMPLETE_VARS (TYPE_MAIN_VARIANT (t)) = 0;
6867 /* Finish debugging output for this type. */
6868 rest_of_type_compilation (t, toplevel);
6870 /* If we're inside a function proper, i.e. not file-scope and not still
6871 parsing parameters, then arrange for the size of a variable sized type
6873 if (cur_stmt_list && variably_modified_type_p (t, NULL_TREE))
6874 add_stmt (build_stmt (loc,
6875 DECL_EXPR, build_decl (loc, TYPE_DECL, NULL, t)));
6877 if (warn_cxx_compat)
6878 warn_cxx_compat_finish_struct (fieldlist);
6880 VEC_free (tree, heap, struct_parse_info->struct_types);
6881 VEC_free (c_binding_ptr, heap, struct_parse_info->fields);
6882 VEC_free (tree, heap, struct_parse_info->typedefs_seen);
6883 XDELETE (struct_parse_info);
6885 struct_parse_info = enclosing_struct_parse_info;
6887 /* If this struct is defined inside a struct, add it to
6890 && struct_parse_info != NULL
6891 && !in_sizeof && !in_typeof && !in_alignof)
6892 VEC_safe_push (tree, heap, struct_parse_info->struct_types, t);
6897 /* Lay out the type T, and its element type, and so on. */
6900 layout_array_type (tree t)
6902 if (TREE_CODE (TREE_TYPE (t)) == ARRAY_TYPE)
6903 layout_array_type (TREE_TYPE (t));
6907 /* Begin compiling the definition of an enumeration type.
6908 NAME is its name (or null if anonymous).
6909 LOC is the enum's location.
6910 Returns the type object, as yet incomplete.
6911 Also records info about it so that build_enumerator
6912 may be used to declare the individual values as they are read. */
6915 start_enum (location_t loc, struct c_enum_contents *the_enum, tree name)
6917 tree enumtype = NULL_TREE;
6918 location_t enumloc = UNKNOWN_LOCATION;
6920 /* If this is the real definition for a previous forward reference,
6921 fill in the contents in the same object that used to be the
6922 forward reference. */
6924 if (name != NULL_TREE)
6925 enumtype = lookup_tag (ENUMERAL_TYPE, name, 1, &enumloc);
6927 if (enumtype == 0 || TREE_CODE (enumtype) != ENUMERAL_TYPE)
6929 enumtype = make_node (ENUMERAL_TYPE);
6930 pushtag (loc, name, enumtype);
6933 if (C_TYPE_BEING_DEFINED (enumtype))
6934 error_at (loc, "nested redefinition of %<enum %E%>", name);
6936 C_TYPE_BEING_DEFINED (enumtype) = 1;
6938 if (TYPE_VALUES (enumtype) != 0)
6940 /* This enum is a named one that has been declared already. */
6941 error_at (loc, "redeclaration of %<enum %E%>", name);
6942 if (enumloc != UNKNOWN_LOCATION)
6943 inform (enumloc, "originally defined here");
6945 /* Completely replace its old definition.
6946 The old enumerators remain defined, however. */
6947 TYPE_VALUES (enumtype) = 0;
6950 the_enum->enum_next_value = integer_zero_node;
6951 the_enum->enum_overflow = 0;
6953 if (flag_short_enums)
6954 TYPE_PACKED (enumtype) = 1;
6956 /* FIXME: This will issue a warning for a use of a type defined
6957 within sizeof in a statement expr. This is not terribly serious
6958 as C++ doesn't permit statement exprs within sizeof anyhow. */
6959 if (warn_cxx_compat && (in_sizeof || in_typeof || in_alignof))
6960 warning_at (loc, OPT_Wc___compat,
6961 "defining type in %qs expression is invalid in C++",
6964 : (in_typeof ? "typeof" : "alignof")));
6969 /* After processing and defining all the values of an enumeration type,
6970 install their decls in the enumeration type and finish it off.
6971 ENUMTYPE is the type object, VALUES a list of decl-value pairs,
6972 and ATTRIBUTES are the specified attributes.
6973 Returns ENUMTYPE. */
6976 finish_enum (tree enumtype, tree values, tree attributes)
6979 tree minnode = 0, maxnode = 0;
6980 int precision, unsign;
6981 bool toplevel = (file_scope == current_scope);
6982 struct lang_type *lt;
6984 decl_attributes (&enumtype, attributes, (int) ATTR_FLAG_TYPE_IN_PLACE);
6986 /* Calculate the maximum value of any enumerator in this type. */
6988 if (values == error_mark_node)
6989 minnode = maxnode = integer_zero_node;
6992 minnode = maxnode = TREE_VALUE (values);
6993 for (pair = TREE_CHAIN (values); pair; pair = TREE_CHAIN (pair))
6995 tree value = TREE_VALUE (pair);
6996 if (tree_int_cst_lt (maxnode, value))
6998 if (tree_int_cst_lt (value, minnode))
7003 /* Construct the final type of this enumeration. It is the same
7004 as one of the integral types - the narrowest one that fits, except
7005 that normally we only go as narrow as int - and signed iff any of
7006 the values are negative. */
7007 unsign = (tree_int_cst_sgn (minnode) >= 0);
7008 precision = MAX (tree_int_cst_min_precision (minnode, unsign),
7009 tree_int_cst_min_precision (maxnode, unsign));
7011 if (TYPE_PACKED (enumtype) || precision > TYPE_PRECISION (integer_type_node))
7013 tem = c_common_type_for_size (precision, unsign);
7016 warning (0, "enumeration values exceed range of largest integer");
7017 tem = long_long_integer_type_node;
7021 tem = unsign ? unsigned_type_node : integer_type_node;
7023 TYPE_MIN_VALUE (enumtype) = TYPE_MIN_VALUE (tem);
7024 TYPE_MAX_VALUE (enumtype) = TYPE_MAX_VALUE (tem);
7025 TYPE_UNSIGNED (enumtype) = TYPE_UNSIGNED (tem);
7026 TYPE_SIZE (enumtype) = 0;
7028 /* If the precision of the type was specific with an attribute and it
7029 was too small, give an error. Otherwise, use it. */
7030 if (TYPE_PRECISION (enumtype))
7032 if (precision > TYPE_PRECISION (enumtype))
7033 error ("specified mode too small for enumeral values");
7036 TYPE_PRECISION (enumtype) = TYPE_PRECISION (tem);
7038 layout_type (enumtype);
7040 if (values != error_mark_node)
7042 /* Change the type of the enumerators to be the enum type. We
7043 need to do this irrespective of the size of the enum, for
7044 proper type checking. Replace the DECL_INITIALs of the
7045 enumerators, and the value slots of the list, with copies
7046 that have the enum type; they cannot be modified in place
7047 because they may be shared (e.g. integer_zero_node) Finally,
7048 change the purpose slots to point to the names of the decls. */
7049 for (pair = values; pair; pair = TREE_CHAIN (pair))
7051 tree enu = TREE_PURPOSE (pair);
7052 tree ini = DECL_INITIAL (enu);
7054 TREE_TYPE (enu) = enumtype;
7056 /* The ISO C Standard mandates enumerators to have type int,
7057 even though the underlying type of an enum type is
7058 unspecified. However, GCC allows enumerators of any
7059 integer type as an extensions. build_enumerator()
7060 converts any enumerators that fit in an int to type int,
7061 to avoid promotions to unsigned types when comparing
7062 integers with enumerators that fit in the int range.
7063 When -pedantic is given, build_enumerator() would have
7064 already warned about those that don't fit. Here we
7065 convert the rest to the enumerator type. */
7066 if (TREE_TYPE (ini) != integer_type_node)
7067 ini = convert (enumtype, ini);
7069 DECL_INITIAL (enu) = ini;
7070 TREE_PURPOSE (pair) = DECL_NAME (enu);
7071 TREE_VALUE (pair) = ini;
7074 TYPE_VALUES (enumtype) = values;
7077 /* Record the min/max values so that we can warn about bit-field
7078 enumerations that are too small for the values. */
7079 lt = GGC_CNEW (struct lang_type);
7080 lt->enum_min = minnode;
7081 lt->enum_max = maxnode;
7082 TYPE_LANG_SPECIFIC (enumtype) = lt;
7084 /* Fix up all variant types of this enum type. */
7085 for (tem = TYPE_MAIN_VARIANT (enumtype); tem; tem = TYPE_NEXT_VARIANT (tem))
7087 if (tem == enumtype)
7089 TYPE_VALUES (tem) = TYPE_VALUES (enumtype);
7090 TYPE_MIN_VALUE (tem) = TYPE_MIN_VALUE (enumtype);
7091 TYPE_MAX_VALUE (tem) = TYPE_MAX_VALUE (enumtype);
7092 TYPE_SIZE (tem) = TYPE_SIZE (enumtype);
7093 TYPE_SIZE_UNIT (tem) = TYPE_SIZE_UNIT (enumtype);
7094 SET_TYPE_MODE (tem, TYPE_MODE (enumtype));
7095 TYPE_PRECISION (tem) = TYPE_PRECISION (enumtype);
7096 TYPE_ALIGN (tem) = TYPE_ALIGN (enumtype);
7097 TYPE_USER_ALIGN (tem) = TYPE_USER_ALIGN (enumtype);
7098 TYPE_UNSIGNED (tem) = TYPE_UNSIGNED (enumtype);
7099 TYPE_LANG_SPECIFIC (tem) = TYPE_LANG_SPECIFIC (enumtype);
7102 /* Finish debugging output for this type. */
7103 rest_of_type_compilation (enumtype, toplevel);
7105 /* If this enum is defined inside a struct, add it to
7108 && struct_parse_info != NULL
7109 && !in_sizeof && !in_typeof && !in_alignof)
7110 VEC_safe_push (tree, heap, struct_parse_info->struct_types, enumtype);
7115 /* Build and install a CONST_DECL for one value of the
7116 current enumeration type (one that was begun with start_enum).
7117 LOC is the location of the enumerator.
7118 Return a tree-list containing the CONST_DECL and its value.
7119 Assignment of sequential values by default is handled here. */
7122 build_enumerator (location_t loc,
7123 struct c_enum_contents *the_enum, tree name, tree value)
7127 /* Validate and default VALUE. */
7131 /* Don't issue more errors for error_mark_node (i.e. an
7132 undeclared identifier) - just ignore the value expression. */
7133 if (value == error_mark_node)
7135 else if (!INTEGRAL_TYPE_P (TREE_TYPE (value)))
7137 error_at (loc, "enumerator value for %qE is not an integer constant",
7143 if (TREE_CODE (value) != INTEGER_CST)
7145 value = c_fully_fold (value, false, NULL);
7146 if (TREE_CODE (value) == INTEGER_CST)
7147 pedwarn (loc, OPT_pedantic,
7148 "enumerator value for %qE is not an integer "
7149 "constant expression", name);
7151 if (TREE_CODE (value) != INTEGER_CST)
7153 error ("enumerator value for %qE is not an integer constant",
7159 value = default_conversion (value);
7160 constant_expression_warning (value);
7165 /* Default based on previous value. */
7166 /* It should no longer be possible to have NON_LVALUE_EXPR
7170 value = the_enum->enum_next_value;
7171 if (the_enum->enum_overflow)
7172 error_at (loc, "overflow in enumeration values");
7174 /* Even though the underlying type of an enum is unspecified, the
7175 type of enumeration constants is explicitly defined as int
7176 (6.4.4.3/2 in the C99 Standard). GCC allows any integer type as
7178 else if (!int_fits_type_p (value, integer_type_node))
7179 pedwarn (loc, OPT_pedantic,
7180 "ISO C restricts enumerator values to range of %<int%>");
7182 /* The ISO C Standard mandates enumerators to have type int, even
7183 though the underlying type of an enum type is unspecified.
7184 However, GCC allows enumerators of any integer type as an
7185 extensions. Here we convert any enumerators that fit in an int
7186 to type int, to avoid promotions to unsigned types when comparing
7187 integers with enumerators that fit in the int range. When
7188 -pedantic is given, we would have already warned about those that
7189 don't fit. We have to do this here rather than in finish_enum
7190 because this value may be used to define more enumerators. */
7191 if (int_fits_type_p (value, integer_type_node))
7192 value = convert (integer_type_node, value);
7194 /* Set basis for default for next value. */
7195 the_enum->enum_next_value
7197 (EXPR_HAS_LOCATION (value) ? EXPR_LOCATION (value) : input_location,
7198 PLUS_EXPR, value, integer_one_node, 0);
7199 the_enum->enum_overflow = tree_int_cst_lt (the_enum->enum_next_value, value);
7201 /* Now create a declaration for the enum value name. */
7203 type = TREE_TYPE (value);
7204 type = c_common_type_for_size (MAX (TYPE_PRECISION (type),
7205 TYPE_PRECISION (integer_type_node)),
7206 (TYPE_PRECISION (type)
7207 >= TYPE_PRECISION (integer_type_node)
7208 && TYPE_UNSIGNED (type)));
7210 decl = build_decl (loc, CONST_DECL, name, type);
7211 DECL_INITIAL (decl) = convert (type, value);
7214 return tree_cons (decl, value, NULL_TREE);
7218 /* Create the FUNCTION_DECL for a function definition.
7219 DECLSPECS, DECLARATOR and ATTRIBUTES are the parts of
7220 the declaration; they describe the function's name and the type it returns,
7221 but twisted together in a fashion that parallels the syntax of C.
7223 This function creates a binding context for the function body
7224 as well as setting up the FUNCTION_DECL in current_function_decl.
7226 Returns 1 on success. If the DECLARATOR is not suitable for a function
7227 (it defines a datum instead), we return 0, which tells
7228 yyparse to report a parse error. */
7231 start_function (struct c_declspecs *declspecs, struct c_declarator *declarator,
7234 tree decl1, old_decl;
7235 tree restype, resdecl;
7238 current_function_returns_value = 0; /* Assume, until we see it does. */
7239 current_function_returns_null = 0;
7240 current_function_returns_abnormally = 0;
7241 warn_about_return_type = 0;
7242 c_switch_stack = NULL;
7244 /* Indicate no valid break/continue context by setting these variables
7245 to some non-null, non-label value. We'll notice and emit the proper
7246 error message in c_finish_bc_stmt. */
7247 c_break_label = c_cont_label = size_zero_node;
7249 decl1 = grokdeclarator (declarator, declspecs, FUNCDEF, true, NULL,
7250 &attributes, NULL, NULL, DEPRECATED_NORMAL);
7252 /* If the declarator is not suitable for a function definition,
7253 cause a syntax error. */
7257 loc = DECL_SOURCE_LOCATION (decl1);
7259 decl_attributes (&decl1, attributes, 0);
7261 if (DECL_DECLARED_INLINE_P (decl1)
7262 && DECL_UNINLINABLE (decl1)
7263 && lookup_attribute ("noinline", DECL_ATTRIBUTES (decl1)))
7264 warning_at (loc, OPT_Wattributes,
7265 "inline function %qD given attribute noinline",
7268 /* Handle gnu_inline attribute. */
7269 if (declspecs->inline_p
7270 && !flag_gnu89_inline
7271 && TREE_CODE (decl1) == FUNCTION_DECL
7272 && (lookup_attribute ("gnu_inline", DECL_ATTRIBUTES (decl1))
7273 || current_function_decl))
7275 if (declspecs->storage_class != csc_static)
7276 DECL_EXTERNAL (decl1) = !DECL_EXTERNAL (decl1);
7279 announce_function (decl1);
7281 if (!COMPLETE_OR_VOID_TYPE_P (TREE_TYPE (TREE_TYPE (decl1))))
7283 error_at (loc, "return type is an incomplete type");
7284 /* Make it return void instead. */
7286 = build_function_type (void_type_node,
7287 TYPE_ARG_TYPES (TREE_TYPE (decl1)));
7290 if (warn_about_return_type)
7291 pedwarn_c99 (loc, flag_isoc99 ? 0
7292 : (warn_return_type ? OPT_Wreturn_type : OPT_Wimplicit_int),
7293 "return type defaults to %<int%>");
7295 /* Make the init_value nonzero so pushdecl knows this is not tentative.
7296 error_mark_node is replaced below (in pop_scope) with the BLOCK. */
7297 DECL_INITIAL (decl1) = error_mark_node;
7299 /* If this definition isn't a prototype and we had a prototype declaration
7300 before, copy the arg type info from that prototype. */
7301 old_decl = lookup_name_in_scope (DECL_NAME (decl1), current_scope);
7302 if (old_decl && TREE_CODE (old_decl) != FUNCTION_DECL)
7304 current_function_prototype_locus = UNKNOWN_LOCATION;
7305 current_function_prototype_built_in = false;
7306 current_function_prototype_arg_types = NULL_TREE;
7307 if (TYPE_ARG_TYPES (TREE_TYPE (decl1)) == 0)
7309 if (old_decl != 0 && TREE_CODE (TREE_TYPE (old_decl)) == FUNCTION_TYPE
7310 && comptypes (TREE_TYPE (TREE_TYPE (decl1)),
7311 TREE_TYPE (TREE_TYPE (old_decl))))
7313 TREE_TYPE (decl1) = composite_type (TREE_TYPE (old_decl),
7315 current_function_prototype_locus = DECL_SOURCE_LOCATION (old_decl);
7316 current_function_prototype_built_in
7317 = C_DECL_BUILTIN_PROTOTYPE (old_decl);
7318 current_function_prototype_arg_types
7319 = TYPE_ARG_TYPES (TREE_TYPE (decl1));
7321 if (TREE_PUBLIC (decl1))
7323 /* If there is an external prototype declaration of this
7324 function, record its location but do not copy information
7325 to this decl. This may be an invisible declaration
7326 (built-in or in a scope which has finished) or simply
7327 have more refined argument types than any declaration
7329 struct c_binding *b;
7330 for (b = I_SYMBOL_BINDING (DECL_NAME (decl1)); b; b = b->shadowed)
7331 if (B_IN_SCOPE (b, external_scope))
7335 tree ext_decl, ext_type;
7337 ext_type = b->u.type ? b->u.type : TREE_TYPE (ext_decl);
7338 if (TREE_CODE (ext_type) == FUNCTION_TYPE
7339 && comptypes (TREE_TYPE (TREE_TYPE (decl1)),
7340 TREE_TYPE (ext_type)))
7342 current_function_prototype_locus
7343 = DECL_SOURCE_LOCATION (ext_decl);
7344 current_function_prototype_built_in
7345 = C_DECL_BUILTIN_PROTOTYPE (ext_decl);
7346 current_function_prototype_arg_types
7347 = TYPE_ARG_TYPES (ext_type);
7353 /* Optionally warn of old-fashioned def with no previous prototype. */
7354 if (warn_strict_prototypes
7355 && old_decl != error_mark_node
7356 && TYPE_ARG_TYPES (TREE_TYPE (decl1)) == 0
7357 && C_DECL_ISNT_PROTOTYPE (old_decl))
7358 warning_at (loc, OPT_Wstrict_prototypes,
7359 "function declaration isn%'t a prototype");
7360 /* Optionally warn of any global def with no previous prototype. */
7361 else if (warn_missing_prototypes
7362 && old_decl != error_mark_node
7363 && TREE_PUBLIC (decl1)
7364 && !MAIN_NAME_P (DECL_NAME (decl1))
7365 && C_DECL_ISNT_PROTOTYPE (old_decl))
7366 warning_at (loc, OPT_Wmissing_prototypes,
7367 "no previous prototype for %qD", decl1);
7368 /* Optionally warn of any def with no previous prototype
7369 if the function has already been used. */
7370 else if (warn_missing_prototypes
7372 && old_decl != error_mark_node
7373 && TREE_USED (old_decl)
7374 && TYPE_ARG_TYPES (TREE_TYPE (old_decl)) == 0)
7375 warning_at (loc, OPT_Wmissing_prototypes,
7376 "%qD was used with no prototype before its definition", decl1);
7377 /* Optionally warn of any global def with no previous declaration. */
7378 else if (warn_missing_declarations
7379 && TREE_PUBLIC (decl1)
7381 && !MAIN_NAME_P (DECL_NAME (decl1)))
7382 warning_at (loc, OPT_Wmissing_declarations,
7383 "no previous declaration for %qD",
7385 /* Optionally warn of any def with no previous declaration
7386 if the function has already been used. */
7387 else if (warn_missing_declarations
7389 && old_decl != error_mark_node
7390 && TREE_USED (old_decl)
7391 && C_DECL_IMPLICIT (old_decl))
7392 warning_at (loc, OPT_Wmissing_declarations,
7393 "%qD was used with no declaration before its definition", decl1);
7395 /* This function exists in static storage.
7396 (This does not mean `static' in the C sense!) */
7397 TREE_STATIC (decl1) = 1;
7399 /* A nested function is not global. */
7400 if (current_function_decl != 0)
7401 TREE_PUBLIC (decl1) = 0;
7403 /* This is the earliest point at which we might know the assembler
7404 name of the function. Thus, if it's set before this, die horribly. */
7405 gcc_assert (!DECL_ASSEMBLER_NAME_SET_P (decl1));
7407 /* If #pragma weak was used, mark the decl weak now. */
7408 if (current_scope == file_scope)
7409 maybe_apply_pragma_weak (decl1);
7411 /* Warn for unlikely, improbable, or stupid declarations of `main'. */
7412 if (warn_main && MAIN_NAME_P (DECL_NAME (decl1)))
7414 if (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (decl1)))
7415 != integer_type_node)
7416 pedwarn (loc, OPT_Wmain, "return type of %qD is not %<int%>", decl1);
7418 check_main_parameter_types (decl1);
7420 if (!TREE_PUBLIC (decl1))
7421 pedwarn (loc, OPT_Wmain,
7422 "%qD is normally a non-static function", decl1);
7425 /* Record the decl so that the function name is defined.
7426 If we already have a decl for this name, and it is a FUNCTION_DECL,
7427 use the old decl. */
7429 current_function_decl = pushdecl (decl1);
7432 declare_parm_level ();
7434 restype = TREE_TYPE (TREE_TYPE (current_function_decl));
7435 resdecl = build_decl (loc, RESULT_DECL, NULL_TREE, restype);
7436 DECL_ARTIFICIAL (resdecl) = 1;
7437 DECL_IGNORED_P (resdecl) = 1;
7438 DECL_RESULT (current_function_decl) = resdecl;
7440 start_fname_decls ();
7445 /* Subroutine of store_parm_decls which handles new-style function
7446 definitions (prototype format). The parms already have decls, so we
7447 need only record them as in effect and complain if any redundant
7448 old-style parm decls were written. */
7450 store_parm_decls_newstyle (tree fndecl, const struct c_arg_info *arg_info)
7454 if (current_scope->bindings)
7456 error ("%Jold-style parameter declarations in prototyped "
7457 "function definition", fndecl);
7459 /* Get rid of the old-style declarations. */
7463 /* Don't issue this warning for nested functions, and don't issue this
7464 warning if we got here because ARG_INFO_TYPES was error_mark_node
7465 (this happens when a function definition has just an ellipsis in
7466 its parameter list). */
7467 else if (!in_system_header && !current_function_scope
7468 && arg_info->types != error_mark_node)
7469 warning (OPT_Wtraditional,
7470 "%Jtraditional C rejects ISO C style function definitions",
7473 /* Now make all the parameter declarations visible in the function body.
7474 We can bypass most of the grunt work of pushdecl. */
7475 for (decl = arg_info->parms; decl; decl = TREE_CHAIN (decl))
7477 DECL_CONTEXT (decl) = current_function_decl;
7478 if (DECL_NAME (decl))
7480 bind (DECL_NAME (decl), decl, current_scope,
7481 /*invisible=*/false, /*nested=*/false,
7483 if (!TREE_USED (decl))
7484 warn_if_shadowing (decl);
7487 error ("%Jparameter name omitted", decl);
7490 /* Record the parameter list in the function declaration. */
7491 DECL_ARGUMENTS (fndecl) = arg_info->parms;
7493 /* Now make all the ancillary declarations visible, likewise. */
7494 for (decl = arg_info->others; decl; decl = TREE_CHAIN (decl))
7496 DECL_CONTEXT (decl) = current_function_decl;
7497 if (DECL_NAME (decl))
7498 bind (DECL_NAME (decl), decl, current_scope,
7499 /*invisible=*/false, /*nested=*/false, UNKNOWN_LOCATION);
7502 /* And all the tag declarations. */
7503 for (decl = arg_info->tags; decl; decl = TREE_CHAIN (decl))
7504 if (TREE_PURPOSE (decl))
7505 bind (TREE_PURPOSE (decl), TREE_VALUE (decl), current_scope,
7506 /*invisible=*/false, /*nested=*/false, UNKNOWN_LOCATION);
7509 /* Subroutine of store_parm_decls which handles old-style function
7510 definitions (separate parameter list and declarations). */
7513 store_parm_decls_oldstyle (tree fndecl, const struct c_arg_info *arg_info)
7515 struct c_binding *b;
7516 tree parm, decl, last;
7517 tree parmids = arg_info->parms;
7518 struct pointer_set_t *seen_args = pointer_set_create ();
7520 if (!in_system_header)
7521 warning_at (DECL_SOURCE_LOCATION (fndecl),
7522 OPT_Wold_style_definition, "old-style function definition");
7524 /* Match each formal parameter name with its declaration. Save each
7525 decl in the appropriate TREE_PURPOSE slot of the parmids chain. */
7526 for (parm = parmids; parm; parm = TREE_CHAIN (parm))
7528 if (TREE_VALUE (parm) == 0)
7530 error_at (DECL_SOURCE_LOCATION (fndecl),
7531 "parameter name missing from parameter list");
7532 TREE_PURPOSE (parm) = 0;
7536 b = I_SYMBOL_BINDING (TREE_VALUE (parm));
7537 if (b && B_IN_CURRENT_SCOPE (b))
7540 /* If we got something other than a PARM_DECL it is an error. */
7541 if (TREE_CODE (decl) != PARM_DECL)
7542 error_at (DECL_SOURCE_LOCATION (decl),
7543 "%qD declared as a non-parameter", decl);
7544 /* If the declaration is already marked, we have a duplicate
7545 name. Complain and ignore the duplicate. */
7546 else if (pointer_set_contains (seen_args, decl))
7548 error_at (DECL_SOURCE_LOCATION (decl),
7549 "multiple parameters named %qD", decl);
7550 TREE_PURPOSE (parm) = 0;
7553 /* If the declaration says "void", complain and turn it into
7555 else if (VOID_TYPE_P (TREE_TYPE (decl)))
7557 error_at (DECL_SOURCE_LOCATION (decl),
7558 "parameter %qD declared with void type", decl);
7559 TREE_TYPE (decl) = integer_type_node;
7560 DECL_ARG_TYPE (decl) = integer_type_node;
7561 layout_decl (decl, 0);
7563 warn_if_shadowing (decl);
7565 /* If no declaration found, default to int. */
7568 /* FIXME diagnostics: This should be the location of the argument,
7569 not the FNDECL. E.g., for an old-style declaration
7571 int f10(v) { blah; }
7573 We should use the location of the V, not the F10.
7574 Unfortunately, the V is an IDENTIFIER_NODE which has no
7575 location. In the future we need locations for c_arg_info
7578 See gcc.dg/Wshadow-3.c for an example of this problem. */
7579 decl = build_decl (DECL_SOURCE_LOCATION (fndecl),
7580 PARM_DECL, TREE_VALUE (parm), integer_type_node);
7581 DECL_ARG_TYPE (decl) = TREE_TYPE (decl);
7583 warn_if_shadowing (decl);
7586 pedwarn (DECL_SOURCE_LOCATION (decl),
7587 0, "type of %qD defaults to %<int%>", decl);
7589 warning_at (DECL_SOURCE_LOCATION (decl),
7590 OPT_Wmissing_parameter_type,
7591 "type of %qD defaults to %<int%>", decl);
7594 TREE_PURPOSE (parm) = decl;
7595 pointer_set_insert (seen_args, decl);
7598 /* Now examine the parms chain for incomplete declarations
7599 and declarations with no corresponding names. */
7601 for (b = current_scope->bindings; b; b = b->prev)
7604 if (TREE_CODE (parm) != PARM_DECL)
7607 if (TREE_TYPE (parm) != error_mark_node
7608 && !COMPLETE_TYPE_P (TREE_TYPE (parm)))
7610 error_at (DECL_SOURCE_LOCATION (parm),
7611 "parameter %qD has incomplete type", parm);
7612 TREE_TYPE (parm) = error_mark_node;
7615 if (!pointer_set_contains (seen_args, parm))
7617 error_at (DECL_SOURCE_LOCATION (parm),
7618 "declaration for parameter %qD but no such parameter",
7621 /* Pretend the parameter was not missing.
7622 This gets us to a standard state and minimizes
7623 further error messages. */
7624 parmids = chainon (parmids, tree_cons (parm, 0, 0));
7628 /* Chain the declarations together in the order of the list of
7629 names. Store that chain in the function decl, replacing the
7630 list of names. Update the current scope to match. */
7631 DECL_ARGUMENTS (fndecl) = 0;
7633 for (parm = parmids; parm; parm = TREE_CHAIN (parm))
7634 if (TREE_PURPOSE (parm))
7636 if (parm && TREE_PURPOSE (parm))
7638 last = TREE_PURPOSE (parm);
7639 DECL_ARGUMENTS (fndecl) = last;
7641 for (parm = TREE_CHAIN (parm); parm; parm = TREE_CHAIN (parm))
7642 if (TREE_PURPOSE (parm))
7644 TREE_CHAIN (last) = TREE_PURPOSE (parm);
7645 last = TREE_PURPOSE (parm);
7647 TREE_CHAIN (last) = 0;
7650 pointer_set_destroy (seen_args);
7652 /* If there was a previous prototype,
7653 set the DECL_ARG_TYPE of each argument according to
7654 the type previously specified, and report any mismatches. */
7656 if (current_function_prototype_arg_types)
7659 for (parm = DECL_ARGUMENTS (fndecl),
7660 type = current_function_prototype_arg_types;
7661 parm || (type && TREE_VALUE (type) != error_mark_node
7662 && (TYPE_MAIN_VARIANT (TREE_VALUE (type)) != void_type_node));
7663 parm = TREE_CHAIN (parm), type = TREE_CHAIN (type))
7665 if (parm == 0 || type == 0
7666 || TYPE_MAIN_VARIANT (TREE_VALUE (type)) == void_type_node)
7668 if (current_function_prototype_built_in)
7669 warning_at (DECL_SOURCE_LOCATION (fndecl),
7670 0, "number of arguments doesn%'t match "
7671 "built-in prototype");
7674 /* FIXME diagnostics: This should be the location of
7675 FNDECL, but there is bug when a prototype is
7676 declared inside function context, but defined
7677 outside of it (e.g., gcc.dg/pr15698-2.c). In
7678 which case FNDECL gets the location of the
7679 prototype, not the definition. */
7680 error_at (input_location,
7681 "number of arguments doesn%'t match prototype");
7683 error_at (current_function_prototype_locus,
7684 "prototype declaration");
7688 /* Type for passing arg must be consistent with that
7689 declared for the arg. ISO C says we take the unqualified
7690 type for parameters declared with qualified type. */
7691 if (TREE_TYPE (parm) != error_mark_node
7692 && TREE_TYPE (type) != error_mark_node
7693 && !comptypes (TYPE_MAIN_VARIANT (DECL_ARG_TYPE (parm)),
7694 TYPE_MAIN_VARIANT (TREE_VALUE (type))))
7696 if (TYPE_MAIN_VARIANT (TREE_TYPE (parm))
7697 == TYPE_MAIN_VARIANT (TREE_VALUE (type)))
7699 /* Adjust argument to match prototype. E.g. a previous
7700 `int foo(float);' prototype causes
7701 `int foo(x) float x; {...}' to be treated like
7702 `int foo(float x) {...}'. This is particularly
7703 useful for argument types like uid_t. */
7704 DECL_ARG_TYPE (parm) = TREE_TYPE (parm);
7706 if (targetm.calls.promote_prototypes (TREE_TYPE (current_function_decl))
7707 && INTEGRAL_TYPE_P (TREE_TYPE (parm))
7708 && TYPE_PRECISION (TREE_TYPE (parm))
7709 < TYPE_PRECISION (integer_type_node))
7710 DECL_ARG_TYPE (parm) = integer_type_node;
7712 /* ??? Is it possible to get here with a
7713 built-in prototype or will it always have
7714 been diagnosed as conflicting with an
7715 old-style definition and discarded? */
7716 if (current_function_prototype_built_in)
7717 warning_at (DECL_SOURCE_LOCATION (parm),
7718 OPT_pedantic, "promoted argument %qD "
7719 "doesn%'t match built-in prototype", parm);
7722 pedwarn (DECL_SOURCE_LOCATION (parm),
7723 OPT_pedantic, "promoted argument %qD "
7724 "doesn%'t match prototype", parm);
7725 pedwarn (current_function_prototype_locus, OPT_pedantic,
7726 "prototype declaration");
7731 if (current_function_prototype_built_in)
7732 warning_at (DECL_SOURCE_LOCATION (parm),
7733 0, "argument %qD doesn%'t match "
7734 "built-in prototype", parm);
7737 error_at (DECL_SOURCE_LOCATION (parm),
7738 "argument %qD doesn%'t match prototype", parm);
7739 error_at (current_function_prototype_locus,
7740 "prototype declaration");
7745 TYPE_ACTUAL_ARG_TYPES (TREE_TYPE (fndecl)) = 0;
7748 /* Otherwise, create a prototype that would match. */
7752 tree actual = 0, last = 0, type;
7754 for (parm = DECL_ARGUMENTS (fndecl); parm; parm = TREE_CHAIN (parm))
7756 type = tree_cons (NULL_TREE, DECL_ARG_TYPE (parm), NULL_TREE);
7758 TREE_CHAIN (last) = type;
7763 type = tree_cons (NULL_TREE, void_type_node, NULL_TREE);
7765 TREE_CHAIN (last) = type;
7769 /* We are going to assign a new value for the TYPE_ACTUAL_ARG_TYPES
7770 of the type of this function, but we need to avoid having this
7771 affect the types of other similarly-typed functions, so we must
7772 first force the generation of an identical (but separate) type
7773 node for the relevant function type. The new node we create
7774 will be a variant of the main variant of the original function
7777 TREE_TYPE (fndecl) = build_variant_type_copy (TREE_TYPE (fndecl));
7779 TYPE_ACTUAL_ARG_TYPES (TREE_TYPE (fndecl)) = actual;
7783 /* Store parameter declarations passed in ARG_INFO into the current
7784 function declaration. */
7787 store_parm_decls_from (struct c_arg_info *arg_info)
7789 current_function_arg_info = arg_info;
7790 store_parm_decls ();
7793 /* Store the parameter declarations into the current function declaration.
7794 This is called after parsing the parameter declarations, before
7795 digesting the body of the function.
7797 For an old-style definition, construct a prototype out of the old-style
7798 parameter declarations and inject it into the function's type. */
7801 store_parm_decls (void)
7803 tree fndecl = current_function_decl;
7806 /* The argument information block for FNDECL. */
7807 struct c_arg_info *arg_info = current_function_arg_info;
7808 current_function_arg_info = 0;
7810 /* True if this definition is written with a prototype. Note:
7811 despite C99 6.7.5.3p14, we can *not* treat an empty argument
7812 list in a function definition as equivalent to (void) -- an
7813 empty argument list specifies the function has no parameters,
7814 but only (void) sets up a prototype for future calls. */
7815 proto = arg_info->types != 0;
7818 store_parm_decls_newstyle (fndecl, arg_info);
7820 store_parm_decls_oldstyle (fndecl, arg_info);
7822 /* The next call to push_scope will be a function body. */
7824 next_is_function_body = true;
7826 /* Write a record describing this function definition to the prototypes
7827 file (if requested). */
7829 gen_aux_info_record (fndecl, 1, 0, proto);
7831 /* Initialize the RTL code for the function. */
7832 allocate_struct_function (fndecl, false);
7834 /* Begin the statement tree for this function. */
7835 DECL_SAVED_TREE (fndecl) = push_stmt_list ();
7837 /* ??? Insert the contents of the pending sizes list into the function
7838 to be evaluated. The only reason left to have this is
7839 void foo(int n, int array[n++])
7840 because we throw away the array type in favor of a pointer type, and
7841 thus won't naturally see the SAVE_EXPR containing the increment. All
7842 other pending sizes would be handled by gimplify_parameters. */
7845 for (t = nreverse (get_pending_sizes ()); t ; t = TREE_CHAIN (t))
7846 add_stmt (TREE_VALUE (t));
7849 /* Even though we're inside a function body, we still don't want to
7850 call expand_expr to calculate the size of a variable-sized array.
7851 We haven't necessarily assigned RTL to all variables yet, so it's
7852 not safe to try to expand expressions involving them. */
7853 cfun->dont_save_pending_sizes_p = 1;
7856 /* Emit diagnostics that require gimple input for detection. Operate on
7857 FNDECL and all its nested functions. */
7860 c_gimple_diagnostics_recursively (tree fndecl)
7862 struct cgraph_node *cgn;
7863 gimple_seq body = gimple_body (fndecl);
7865 /* Handle attribute((warn_unused_result)). Relies on gimple input. */
7866 c_warn_unused_result (body);
7868 /* Notice when OpenMP structured block constraints are violated. */
7870 diagnose_omp_structured_block_errors (fndecl);
7872 /* Finalize all nested functions now. */
7873 cgn = cgraph_node (fndecl);
7874 for (cgn = cgn->nested; cgn ; cgn = cgn->next_nested)
7875 c_gimple_diagnostics_recursively (cgn->decl);
7878 /* Finish up a function declaration and compile that function
7879 all the way to assembler language output. The free the storage
7880 for the function definition.
7882 This is called after parsing the body of the function definition. */
7885 finish_function (void)
7887 tree fndecl = current_function_decl;
7889 if (TREE_CODE (fndecl) == FUNCTION_DECL
7890 && targetm.calls.promote_prototypes (TREE_TYPE (fndecl)))
7892 tree args = DECL_ARGUMENTS (fndecl);
7893 for (; args; args = TREE_CHAIN (args))
7895 tree type = TREE_TYPE (args);
7896 if (INTEGRAL_TYPE_P (type)
7897 && TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node))
7898 DECL_ARG_TYPE (args) = integer_type_node;
7902 if (DECL_INITIAL (fndecl) && DECL_INITIAL (fndecl) != error_mark_node)
7903 BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl)) = fndecl;
7905 /* Must mark the RESULT_DECL as being in this function. */
7907 if (DECL_RESULT (fndecl) && DECL_RESULT (fndecl) != error_mark_node)
7908 DECL_CONTEXT (DECL_RESULT (fndecl)) = fndecl;
7910 if (MAIN_NAME_P (DECL_NAME (fndecl)) && flag_hosted
7911 && TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (fndecl)))
7912 == integer_type_node && flag_isoc99)
7914 /* Hack. We don't want the middle-end to warn that this return
7915 is unreachable, so we mark its location as special. Using
7916 UNKNOWN_LOCATION has the problem that it gets clobbered in
7917 annotate_one_with_locus. A cleaner solution might be to
7918 ensure ! should_carry_locus_p (stmt), but that needs a flag.
7920 c_finish_return (BUILTINS_LOCATION, integer_zero_node, NULL_TREE);
7923 /* Tie off the statement tree for this function. */
7924 DECL_SAVED_TREE (fndecl) = pop_stmt_list (DECL_SAVED_TREE (fndecl));
7926 finish_fname_decls ();
7928 /* Complain if there's just no return statement. */
7929 if (warn_return_type
7930 && TREE_CODE (TREE_TYPE (TREE_TYPE (fndecl))) != VOID_TYPE
7931 && !current_function_returns_value && !current_function_returns_null
7932 /* Don't complain if we are no-return. */
7933 && !current_function_returns_abnormally
7934 /* Don't warn for main(). */
7935 && !MAIN_NAME_P (DECL_NAME (fndecl))
7936 /* Or if they didn't actually specify a return type. */
7937 && !C_FUNCTION_IMPLICIT_INT (fndecl)
7938 /* Normally, with -Wreturn-type, flow will complain, but we might
7939 optimize out static functions. */
7940 && !TREE_PUBLIC (fndecl))
7942 warning (OPT_Wreturn_type,
7943 "no return statement in function returning non-void");
7944 TREE_NO_WARNING (fndecl) = 1;
7947 /* Store the end of the function, so that we get good line number
7948 info for the epilogue. */
7949 cfun->function_end_locus = input_location;
7951 /* Finalize the ELF visibility for the function. */
7952 c_determine_visibility (fndecl);
7954 /* For GNU C extern inline functions disregard inline limits. */
7955 if (DECL_EXTERNAL (fndecl)
7956 && DECL_DECLARED_INLINE_P (fndecl))
7957 DECL_DISREGARD_INLINE_LIMITS (fndecl) = 1;
7959 /* Genericize before inlining. Delay genericizing nested functions
7960 until their parent function is genericized. Since finalizing
7961 requires GENERIC, delay that as well. */
7963 if (DECL_INITIAL (fndecl) && DECL_INITIAL (fndecl) != error_mark_node
7964 && !undef_nested_function)
7966 if (!decl_function_context (fndecl))
7968 c_genericize (fndecl);
7969 c_gimple_diagnostics_recursively (fndecl);
7971 /* ??? Objc emits functions after finalizing the compilation unit.
7972 This should be cleaned up later and this conditional removed. */
7973 if (cgraph_global_info_ready)
7975 cgraph_add_new_function (fndecl, false);
7978 cgraph_finalize_function (fndecl, false);
7982 /* Register this function with cgraph just far enough to get it
7983 added to our parent's nested function list. Handy, since the
7984 C front end doesn't have such a list. */
7985 (void) cgraph_node (fndecl);
7989 if (!decl_function_context (fndecl))
7990 undef_nested_function = false;
7992 /* We're leaving the context of this function, so zap cfun.
7993 It's still in DECL_STRUCT_FUNCTION, and we'll restore it in
7994 tree_rest_of_compilation. */
7996 current_function_decl = NULL;
7999 /* Check the declarations given in a for-loop for satisfying the C99
8000 constraints. If exactly one such decl is found, return it. LOC is
8001 the location of the opening parenthesis of the for loop. */
8004 check_for_loop_decls (location_t loc)
8006 struct c_binding *b;
8007 tree one_decl = NULL_TREE;
8012 static bool hint = true;
8013 /* If we get here, declarations have been used in a for loop without
8014 the C99 for loop scope. This doesn't make much sense, so don't
8016 error_at (loc, "%<for%> loop initial declarations "
8017 "are only allowed in C99 mode");
8021 "use option -std=c99 or -std=gnu99 to compile your code");
8026 /* C99 subclause 6.8.5 paragraph 3:
8028 [#3] The declaration part of a for statement shall only
8029 declare identifiers for objects having storage class auto or
8032 It isn't clear whether, in this sentence, "identifiers" binds to
8033 "shall only declare" or to "objects" - that is, whether all identifiers
8034 declared must be identifiers for objects, or whether the restriction
8035 only applies to those that are. (A question on this in comp.std.c
8036 in November 2000 received no answer.) We implement the strictest
8037 interpretation, to avoid creating an extension which later causes
8040 for (b = current_scope->bindings; b; b = b->prev)
8043 tree decl = b->decl;
8048 switch (TREE_CODE (decl))
8052 location_t decl_loc = DECL_SOURCE_LOCATION (decl);
8053 if (TREE_STATIC (decl))
8055 "declaration of static variable %qD in %<for%> loop "
8056 "initial declaration", decl);
8057 else if (DECL_EXTERNAL (decl))
8059 "declaration of %<extern%> variable %qD in %<for%> loop "
8060 "initial declaration", decl);
8066 "%<struct %E%> declared in %<for%> loop initial "
8071 "%<union %E%> declared in %<for%> loop initial declaration",
8075 error_at (loc, "%<enum %E%> declared in %<for%> loop "
8076 "initial declaration", id);
8079 error_at (loc, "declaration of non-variable "
8080 "%qD in %<for%> loop initial declaration", decl);
8087 return n_decls == 1 ? one_decl : NULL_TREE;
8090 /* Save and reinitialize the variables
8091 used during compilation of a C function. */
8094 c_push_function_context (void)
8096 struct language_function *p;
8097 p = GGC_NEW (struct language_function);
8100 p->base.x_stmt_tree = c_stmt_tree;
8101 p->x_break_label = c_break_label;
8102 p->x_cont_label = c_cont_label;
8103 p->x_switch_stack = c_switch_stack;
8104 p->arg_info = current_function_arg_info;
8105 p->returns_value = current_function_returns_value;
8106 p->returns_null = current_function_returns_null;
8107 p->returns_abnormally = current_function_returns_abnormally;
8108 p->warn_about_return_type = warn_about_return_type;
8110 push_function_context ();
8113 /* Restore the variables used during compilation of a C function. */
8116 c_pop_function_context (void)
8118 struct language_function *p;
8120 pop_function_context ();
8122 cfun->language = NULL;
8124 if (DECL_STRUCT_FUNCTION (current_function_decl) == 0
8125 && DECL_SAVED_TREE (current_function_decl) == NULL_TREE)
8127 /* Stop pointing to the local nodes about to be freed. */
8128 /* But DECL_INITIAL must remain nonzero so we know this
8129 was an actual function definition. */
8130 DECL_INITIAL (current_function_decl) = error_mark_node;
8131 DECL_ARGUMENTS (current_function_decl) = 0;
8134 c_stmt_tree = p->base.x_stmt_tree;
8135 c_break_label = p->x_break_label;
8136 c_cont_label = p->x_cont_label;
8137 c_switch_stack = p->x_switch_stack;
8138 current_function_arg_info = p->arg_info;
8139 current_function_returns_value = p->returns_value;
8140 current_function_returns_null = p->returns_null;
8141 current_function_returns_abnormally = p->returns_abnormally;
8142 warn_about_return_type = p->warn_about_return_type;
8145 /* Copy the DECL_LANG_SPECIFIC data associated with DECL. */
8148 c_dup_lang_specific_decl (tree decl)
8150 struct lang_decl *ld;
8152 if (!DECL_LANG_SPECIFIC (decl))
8155 ld = GGC_NEW (struct lang_decl);
8156 memcpy (ld, DECL_LANG_SPECIFIC (decl), sizeof (struct lang_decl));
8157 DECL_LANG_SPECIFIC (decl) = ld;
8160 /* The functions below are required for functionality of doing
8161 function at once processing in the C front end. Currently these
8162 functions are not called from anywhere in the C front end, but as
8163 these changes continue, that will change. */
8165 /* Returns the stmt_tree (if any) to which statements are currently
8166 being added. If there is no active statement-tree, NULL is
8170 current_stmt_tree (void)
8172 return &c_stmt_tree;
8175 /* Return the global value of T as a symbol. */
8178 identifier_global_value (tree t)
8180 struct c_binding *b;
8182 for (b = I_SYMBOL_BINDING (t); b; b = b->shadowed)
8183 if (B_IN_FILE_SCOPE (b) || B_IN_EXTERNAL_SCOPE (b))
8189 /* Record a builtin type for C. If NAME is non-NULL, it is the name used;
8190 otherwise the name is found in ridpointers from RID_INDEX. */
8193 record_builtin_type (enum rid rid_index, const char *name, tree type)
8197 id = ridpointers[(int) rid_index];
8199 id = get_identifier (name);
8200 decl = build_decl (UNKNOWN_LOCATION, TYPE_DECL, id, type);
8202 if (debug_hooks->type_decl)
8203 debug_hooks->type_decl (decl, false);
8206 /* Build the void_list_node (void_type_node having been created). */
8208 build_void_list_node (void)
8210 tree t = build_tree_list (NULL_TREE, void_type_node);
8214 /* Return a c_parm structure with the given SPECS, ATTRS and DECLARATOR. */
8217 build_c_parm (struct c_declspecs *specs, tree attrs,
8218 struct c_declarator *declarator)
8220 struct c_parm *ret = XOBNEW (&parser_obstack, struct c_parm);
8223 ret->declarator = declarator;
8227 /* Return a declarator with nested attributes. TARGET is the inner
8228 declarator to which these attributes apply. ATTRS are the
8231 struct c_declarator *
8232 build_attrs_declarator (tree attrs, struct c_declarator *target)
8234 struct c_declarator *ret = XOBNEW (&parser_obstack, struct c_declarator);
8235 ret->kind = cdk_attrs;
8236 ret->declarator = target;
8237 ret->u.attrs = attrs;
8241 /* Return a declarator for a function with arguments specified by ARGS
8242 and return type specified by TARGET. */
8244 struct c_declarator *
8245 build_function_declarator (struct c_arg_info *args,
8246 struct c_declarator *target)
8248 struct c_declarator *ret = XOBNEW (&parser_obstack, struct c_declarator);
8249 ret->kind = cdk_function;
8250 ret->declarator = target;
8251 ret->u.arg_info = args;
8255 /* Return a declarator for the identifier IDENT (which may be
8256 NULL_TREE for an abstract declarator). */
8258 struct c_declarator *
8259 build_id_declarator (tree ident)
8261 struct c_declarator *ret = XOBNEW (&parser_obstack, struct c_declarator);
8263 ret->declarator = 0;
8265 /* Default value - may get reset to a more precise location. */
8266 ret->id_loc = input_location;
8270 /* Return something to represent absolute declarators containing a *.
8271 TARGET is the absolute declarator that the * contains.
8272 TYPE_QUALS_ATTRS is a structure for type qualifiers and attributes
8273 to apply to the pointer type. */
8275 struct c_declarator *
8276 make_pointer_declarator (struct c_declspecs *type_quals_attrs,
8277 struct c_declarator *target)
8281 struct c_declarator *itarget = target;
8282 struct c_declarator *ret = XOBNEW (&parser_obstack, struct c_declarator);
8283 if (type_quals_attrs)
8285 attrs = type_quals_attrs->attrs;
8286 quals = quals_from_declspecs (type_quals_attrs);
8287 if (attrs != NULL_TREE)
8288 itarget = build_attrs_declarator (attrs, target);
8290 ret->kind = cdk_pointer;
8291 ret->declarator = itarget;
8292 ret->u.pointer_quals = quals;
8296 /* Return a pointer to a structure for an empty list of declaration
8299 struct c_declspecs *
8300 build_null_declspecs (void)
8302 struct c_declspecs *ret = XOBNEW (&parser_obstack, struct c_declspecs);
8307 ret->typespec_word = cts_none;
8308 ret->storage_class = csc_none;
8309 ret->expr_const_operands = true;
8310 ret->declspecs_seen_p = false;
8311 ret->type_seen_p = false;
8312 ret->non_sc_seen_p = false;
8313 ret->typedef_p = false;
8314 ret->tag_defined_p = false;
8315 ret->explicit_signed_p = false;
8316 ret->deprecated_p = false;
8317 ret->default_int_p = false;
8318 ret->long_p = false;
8319 ret->long_long_p = false;
8320 ret->short_p = false;
8321 ret->signed_p = false;
8322 ret->unsigned_p = false;
8323 ret->complex_p = false;
8324 ret->inline_p = false;
8325 ret->thread_p = false;
8326 ret->const_p = false;
8327 ret->volatile_p = false;
8328 ret->restrict_p = false;
8329 ret->saturating_p = false;
8333 /* Add the type qualifier QUAL to the declaration specifiers SPECS,
8336 struct c_declspecs *
8337 declspecs_add_qual (struct c_declspecs *specs, tree qual)
8341 specs->non_sc_seen_p = true;
8342 specs->declspecs_seen_p = true;
8343 gcc_assert (TREE_CODE (qual) == IDENTIFIER_NODE
8344 && C_IS_RESERVED_WORD (qual));
8345 i = C_RID_CODE (qual);
8349 dupe = specs->const_p;
8350 specs->const_p = true;
8353 dupe = specs->volatile_p;
8354 specs->volatile_p = true;
8357 dupe = specs->restrict_p;
8358 specs->restrict_p = true;
8363 if (dupe && !flag_isoc99)
8364 pedwarn (input_location, OPT_pedantic, "duplicate %qE", qual);
8368 /* Add the type specifier TYPE to the declaration specifiers SPECS,
8371 struct c_declspecs *
8372 declspecs_add_type (location_t loc, struct c_declspecs *specs,
8373 struct c_typespec spec)
8375 tree type = spec.spec;
8376 specs->non_sc_seen_p = true;
8377 specs->declspecs_seen_p = true;
8378 specs->type_seen_p = true;
8379 if (TREE_DEPRECATED (type))
8380 specs->deprecated_p = true;
8382 /* Handle type specifier keywords. */
8383 if (TREE_CODE (type) == IDENTIFIER_NODE
8384 && C_IS_RESERVED_WORD (type)
8385 && C_RID_CODE (type) != RID_CXX_COMPAT_WARN)
8387 enum rid i = C_RID_CODE (type);
8390 error_at (loc, "two or more data types in declaration specifiers");
8393 if ((int) i <= (int) RID_LAST_MODIFIER)
8395 /* "long", "short", "signed", "unsigned", "_Complex" or "_Sat". */
8400 if (specs->long_long_p)
8402 error_at (loc, "%<long long long%> is too long for GCC");
8407 if (specs->typespec_word == cts_double)
8410 ("both %<long long%> and %<double%> in "
8411 "declaration specifiers"));
8414 pedwarn_c90 (loc, OPT_Wlong_long,
8415 "ISO C90 does not support %<long long%>");
8416 specs->long_long_p = 1;
8421 ("both %<long%> and %<short%> in "
8422 "declaration specifiers"));
8423 else if (specs->typespec_word == cts_void)
8425 ("both %<long%> and %<void%> in "
8426 "declaration specifiers"));
8427 else if (specs->typespec_word == cts_bool)
8429 ("both %<long%> and %<_Bool%> in "
8430 "declaration specifiers"));
8431 else if (specs->typespec_word == cts_char)
8433 ("both %<long%> and %<char%> in "
8434 "declaration specifiers"));
8435 else if (specs->typespec_word == cts_float)
8437 ("both %<long%> and %<float%> in "
8438 "declaration specifiers"));
8439 else if (specs->typespec_word == cts_dfloat32)
8441 ("both %<long%> and %<_Decimal32%> in "
8442 "declaration specifiers"));
8443 else if (specs->typespec_word == cts_dfloat64)
8445 ("both %<long%> and %<_Decimal64%> in "
8446 "declaration specifiers"));
8447 else if (specs->typespec_word == cts_dfloat128)
8449 ("both %<long%> and %<_Decimal128%> in "
8450 "declaration specifiers"));
8452 specs->long_p = true;
8455 dupe = specs->short_p;
8458 ("both %<long%> and %<short%> in "
8459 "declaration specifiers"));
8460 else if (specs->typespec_word == cts_void)
8462 ("both %<short%> and %<void%> in "
8463 "declaration specifiers"));
8464 else if (specs->typespec_word == cts_bool)
8466 ("both %<short%> and %<_Bool%> in "
8467 "declaration specifiers"));
8468 else if (specs->typespec_word == cts_char)
8470 ("both %<short%> and %<char%> in "
8471 "declaration specifiers"));
8472 else if (specs->typespec_word == cts_float)
8474 ("both %<short%> and %<float%> in "
8475 "declaration specifiers"));
8476 else if (specs->typespec_word == cts_double)
8478 ("both %<short%> and %<double%> in "
8479 "declaration specifiers"));
8480 else if (specs->typespec_word == cts_dfloat32)
8482 ("both %<short%> and %<_Decimal32%> in "
8483 "declaration specifiers"));
8484 else if (specs->typespec_word == cts_dfloat64)
8486 ("both %<short%> and %<_Decimal64%> in "
8487 "declaration specifiers"));
8488 else if (specs->typespec_word == cts_dfloat128)
8490 ("both %<short%> and %<_Decimal128%> in "
8491 "declaration specifiers"));
8493 specs->short_p = true;
8496 dupe = specs->signed_p;
8497 if (specs->unsigned_p)
8499 ("both %<signed%> and %<unsigned%> in "
8500 "declaration specifiers"));
8501 else if (specs->typespec_word == cts_void)
8503 ("both %<signed%> and %<void%> in "
8504 "declaration specifiers"));
8505 else if (specs->typespec_word == cts_bool)
8507 ("both %<signed%> and %<_Bool%> in "
8508 "declaration specifiers"));
8509 else if (specs->typespec_word == cts_float)
8511 ("both %<signed%> and %<float%> in "
8512 "declaration specifiers"));
8513 else if (specs->typespec_word == cts_double)
8515 ("both %<signed%> and %<double%> in "
8516 "declaration specifiers"));
8517 else if (specs->typespec_word == cts_dfloat32)
8519 ("both %<signed%> and %<_Decimal32%> in "
8520 "declaration specifiers"));
8521 else if (specs->typespec_word == cts_dfloat64)
8523 ("both %<signed%> and %<_Decimal64%> in "
8524 "declaration specifiers"));
8525 else if (specs->typespec_word == cts_dfloat128)
8527 ("both %<signed%> and %<_Decimal128%> in "
8528 "declaration specifiers"));
8530 specs->signed_p = true;
8533 dupe = specs->unsigned_p;
8534 if (specs->signed_p)
8536 ("both %<signed%> and %<unsigned%> in "
8537 "declaration specifiers"));
8538 else if (specs->typespec_word == cts_void)
8540 ("both %<unsigned%> and %<void%> in "
8541 "declaration specifiers"));
8542 else if (specs->typespec_word == cts_bool)
8544 ("both %<unsigned%> and %<_Bool%> in "
8545 "declaration specifiers"));
8546 else if (specs->typespec_word == cts_float)
8548 ("both %<unsigned%> and %<float%> in "
8549 "declaration specifiers"));
8550 else if (specs->typespec_word == cts_double)
8552 ("both %<unsigned%> and %<double%> in "
8553 "declaration specifiers"));
8554 else if (specs->typespec_word == cts_dfloat32)
8556 ("both %<unsigned%> and %<_Decimal32%> in "
8557 "declaration specifiers"));
8558 else if (specs->typespec_word == cts_dfloat64)
8560 ("both %<unsigned%> and %<_Decimal64%> in "
8561 "declaration specifiers"));
8562 else if (specs->typespec_word == cts_dfloat128)
8564 ("both %<unsigned%> and %<_Decimal128%> in "
8565 "declaration specifiers"));
8567 specs->unsigned_p = true;
8570 dupe = specs->complex_p;
8571 if (!flag_isoc99 && !in_system_header)
8572 pedwarn (loc, OPT_pedantic,
8573 "ISO C90 does not support complex types");
8574 if (specs->typespec_word == cts_void)
8576 ("both %<complex%> and %<void%> in "
8577 "declaration specifiers"));
8578 else if (specs->typespec_word == cts_bool)
8580 ("both %<complex%> and %<_Bool%> in "
8581 "declaration specifiers"));
8582 else if (specs->typespec_word == cts_dfloat32)
8584 ("both %<complex%> and %<_Decimal32%> in "
8585 "declaration specifiers"));
8586 else if (specs->typespec_word == cts_dfloat64)
8588 ("both %<complex%> and %<_Decimal64%> in "
8589 "declaration specifiers"));
8590 else if (specs->typespec_word == cts_dfloat128)
8592 ("both %<complex%> and %<_Decimal128%> in "
8593 "declaration specifiers"));
8594 else if (specs->typespec_word == cts_fract)
8596 ("both %<complex%> and %<_Fract%> in "
8597 "declaration specifiers"));
8598 else if (specs->typespec_word == cts_accum)
8600 ("both %<complex%> and %<_Accum%> in "
8601 "declaration specifiers"));
8602 else if (specs->saturating_p)
8604 ("both %<complex%> and %<_Sat%> in "
8605 "declaration specifiers"));
8607 specs->complex_p = true;
8610 dupe = specs->saturating_p;
8611 pedwarn (loc, OPT_pedantic,
8612 "ISO C does not support saturating types");
8613 if (specs->typespec_word == cts_void)
8615 ("both %<_Sat%> and %<void%> in "
8616 "declaration specifiers"));
8617 else if (specs->typespec_word == cts_bool)
8619 ("both %<_Sat%> and %<_Bool%> in "
8620 "declaration specifiers"));
8621 else if (specs->typespec_word == cts_char)
8623 ("both %<_Sat%> and %<char%> in "
8624 "declaration specifiers"));
8625 else if (specs->typespec_word == cts_int)
8627 ("both %<_Sat%> and %<int%> in "
8628 "declaration specifiers"));
8629 else if (specs->typespec_word == cts_float)
8631 ("both %<_Sat%> and %<float%> in "
8632 "declaration specifiers"));
8633 else if (specs->typespec_word == cts_double)
8635 ("both %<_Sat%> and %<double%> in "
8636 "declaration specifiers"));
8637 else if (specs->typespec_word == cts_dfloat32)
8639 ("both %<_Sat%> and %<_Decimal32%> in "
8640 "declaration specifiers"));
8641 else if (specs->typespec_word == cts_dfloat64)
8643 ("both %<_Sat%> and %<_Decimal64%> in "
8644 "declaration specifiers"));
8645 else if (specs->typespec_word == cts_dfloat128)
8647 ("both %<_Sat%> and %<_Decimal128%> in "
8648 "declaration specifiers"));
8649 else if (specs->complex_p)
8651 ("both %<_Sat%> and %<complex%> in "
8652 "declaration specifiers"));
8654 specs->saturating_p = true;
8661 error_at (loc, "duplicate %qE", type);
8667 /* "void", "_Bool", "char", "int", "float", "double", "_Decimal32",
8668 "_Decimal64", "_Decimal128", "_Fract" or "_Accum". */
8669 if (specs->typespec_word != cts_none)
8672 "two or more data types in declaration specifiers");
8680 ("both %<long%> and %<void%> in "
8681 "declaration specifiers"));
8682 else if (specs->short_p)
8684 ("both %<short%> and %<void%> in "
8685 "declaration specifiers"));
8686 else if (specs->signed_p)
8688 ("both %<signed%> and %<void%> in "
8689 "declaration specifiers"));
8690 else if (specs->unsigned_p)
8692 ("both %<unsigned%> and %<void%> in "
8693 "declaration specifiers"));
8694 else if (specs->complex_p)
8696 ("both %<complex%> and %<void%> in "
8697 "declaration specifiers"));
8698 else if (specs->saturating_p)
8700 ("both %<_Sat%> and %<void%> in "
8701 "declaration specifiers"));
8703 specs->typespec_word = cts_void;
8708 ("both %<long%> and %<_Bool%> in "
8709 "declaration specifiers"));
8710 else if (specs->short_p)
8712 ("both %<short%> and %<_Bool%> in "
8713 "declaration specifiers"));
8714 else if (specs->signed_p)
8716 ("both %<signed%> and %<_Bool%> in "
8717 "declaration specifiers"));
8718 else if (specs->unsigned_p)
8720 ("both %<unsigned%> and %<_Bool%> in "
8721 "declaration specifiers"));
8722 else if (specs->complex_p)
8724 ("both %<complex%> and %<_Bool%> in "
8725 "declaration specifiers"));
8726 else if (specs->saturating_p)
8728 ("both %<_Sat%> and %<_Bool%> in "
8729 "declaration specifiers"));
8731 specs->typespec_word = cts_bool;
8736 ("both %<long%> and %<char%> in "
8737 "declaration specifiers"));
8738 else if (specs->short_p)
8740 ("both %<short%> and %<char%> in "
8741 "declaration specifiers"));
8742 else if (specs->saturating_p)
8744 ("both %<_Sat%> and %<char%> in "
8745 "declaration specifiers"));
8747 specs->typespec_word = cts_char;
8750 if (specs->saturating_p)
8752 ("both %<_Sat%> and %<int%> in "
8753 "declaration specifiers"));
8755 specs->typespec_word = cts_int;
8760 ("both %<long%> and %<float%> in "
8761 "declaration specifiers"));
8762 else if (specs->short_p)
8764 ("both %<short%> and %<float%> in "
8765 "declaration specifiers"));
8766 else if (specs->signed_p)
8768 ("both %<signed%> and %<float%> in "
8769 "declaration specifiers"));
8770 else if (specs->unsigned_p)
8772 ("both %<unsigned%> and %<float%> in "
8773 "declaration specifiers"));
8774 else if (specs->saturating_p)
8776 ("both %<_Sat%> and %<float%> in "
8777 "declaration specifiers"));
8779 specs->typespec_word = cts_float;
8782 if (specs->long_long_p)
8784 ("both %<long long%> and %<double%> in "
8785 "declaration specifiers"));
8786 else if (specs->short_p)
8788 ("both %<short%> and %<double%> in "
8789 "declaration specifiers"));
8790 else if (specs->signed_p)
8792 ("both %<signed%> and %<double%> in "
8793 "declaration specifiers"));
8794 else if (specs->unsigned_p)
8796 ("both %<unsigned%> and %<double%> in "
8797 "declaration specifiers"));
8798 else if (specs->saturating_p)
8800 ("both %<_Sat%> and %<double%> in "
8801 "declaration specifiers"));
8803 specs->typespec_word = cts_double;
8810 if (i == RID_DFLOAT32)
8812 else if (i == RID_DFLOAT64)
8815 str = "_Decimal128";
8816 if (specs->long_long_p)
8818 ("both %<long long%> and %<%s%> in "
8819 "declaration specifiers"),
8823 ("both %<long%> and %<%s%> in "
8824 "declaration specifiers"),
8826 else if (specs->short_p)
8828 ("both %<short%> and %<%s%> in "
8829 "declaration specifiers"),
8831 else if (specs->signed_p)
8833 ("both %<signed%> and %<%s%> in "
8834 "declaration specifiers"),
8836 else if (specs->unsigned_p)
8838 ("both %<unsigned%> and %<%s%> in "
8839 "declaration specifiers"),
8841 else if (specs->complex_p)
8843 ("both %<complex%> and %<%s%> in "
8844 "declaration specifiers"),
8846 else if (specs->saturating_p)
8848 ("both %<_Sat%> and %<%s%> in "
8849 "declaration specifiers"),
8851 else if (i == RID_DFLOAT32)
8852 specs->typespec_word = cts_dfloat32;
8853 else if (i == RID_DFLOAT64)
8854 specs->typespec_word = cts_dfloat64;
8856 specs->typespec_word = cts_dfloat128;
8858 if (!targetm.decimal_float_supported_p ())
8860 ("decimal floating point not supported "
8861 "for this target"));
8862 pedwarn (loc, OPT_pedantic,
8863 "ISO C does not support decimal floating point");
8873 if (specs->complex_p)
8875 ("both %<complex%> and %<%s%> in "
8876 "declaration specifiers"),
8878 else if (i == RID_FRACT)
8879 specs->typespec_word = cts_fract;
8881 specs->typespec_word = cts_accum;
8883 if (!targetm.fixed_point_supported_p ())
8885 "fixed-point types not supported for this target");
8886 pedwarn (loc, OPT_pedantic,
8887 "ISO C does not support fixed-point types");
8890 /* ObjC reserved word "id", handled below. */
8896 /* Now we have a typedef (a TYPE_DECL node), an identifier (some
8897 form of ObjC type, cases such as "int" and "long" being handled
8898 above), a TYPE (struct, union, enum and typeof specifiers) or an
8899 ERROR_MARK. In none of these cases may there have previously
8900 been any type specifiers. */
8901 if (specs->type || specs->typespec_word != cts_none
8902 || specs->long_p || specs->short_p || specs->signed_p
8903 || specs->unsigned_p || specs->complex_p)
8904 error_at (loc, "two or more data types in declaration specifiers");
8905 else if (TREE_CODE (type) == TYPE_DECL)
8907 if (TREE_TYPE (type) == error_mark_node)
8908 ; /* Allow the type to default to int to avoid cascading errors. */
8911 specs->type = TREE_TYPE (type);
8912 specs->decl_attr = DECL_ATTRIBUTES (type);
8913 specs->typedef_p = true;
8914 specs->explicit_signed_p = C_TYPEDEF_EXPLICITLY_SIGNED (type);
8916 /* If this typedef name is defined in a struct, then a C++
8917 lookup would return a different value. */
8919 && I_SYMBOL_BINDING (DECL_NAME (type))->in_struct)
8920 warning_at (loc, OPT_Wc___compat,
8921 "C++ lookup of %qD would return a field, not a type",
8924 /* If we are parsing a struct, record that a struct field
8926 if (warn_cxx_compat && struct_parse_info != NULL)
8927 VEC_safe_push (tree, heap, struct_parse_info->typedefs_seen, type);
8930 else if (TREE_CODE (type) == IDENTIFIER_NODE)
8932 tree t = lookup_name (type);
8933 if (!t || TREE_CODE (t) != TYPE_DECL)
8934 error_at (loc, "%qE fails to be a typedef or built in type", type);
8935 else if (TREE_TYPE (t) == error_mark_node)
8938 specs->type = TREE_TYPE (t);
8940 else if (TREE_CODE (type) != ERROR_MARK)
8942 if (spec.kind == ctsk_tagdef || spec.kind == ctsk_tagfirstref)
8943 specs->tag_defined_p = true;
8944 if (spec.kind == ctsk_typeof)
8946 specs->typedef_p = true;
8950 specs->expr = build2 (COMPOUND_EXPR, TREE_TYPE (spec.expr),
8951 specs->expr, spec.expr);
8953 specs->expr = spec.expr;
8954 specs->expr_const_operands &= spec.expr_const_operands;
8963 /* Add the storage class specifier or function specifier SCSPEC to the
8964 declaration specifiers SPECS, returning SPECS. */
8966 struct c_declspecs *
8967 declspecs_add_scspec (struct c_declspecs *specs, tree scspec)
8970 enum c_storage_class n = csc_none;
8972 specs->declspecs_seen_p = true;
8973 gcc_assert (TREE_CODE (scspec) == IDENTIFIER_NODE
8974 && C_IS_RESERVED_WORD (scspec));
8975 i = C_RID_CODE (scspec);
8976 if (specs->non_sc_seen_p)
8977 warning (OPT_Wold_style_declaration,
8978 "%qE is not at beginning of declaration", scspec);
8982 /* C99 permits duplicate inline. Although of doubtful utility,
8983 it seems simplest to permit it in gnu89 mode as well, as
8984 there is also little utility in maintaining this as a
8985 difference between gnu89 and C99 inline. */
8987 specs->inline_p = true;
8990 dupe = specs->thread_p;
8991 if (specs->storage_class == csc_auto)
8992 error ("%<__thread%> used with %<auto%>");
8993 else if (specs->storage_class == csc_register)
8994 error ("%<__thread%> used with %<register%>");
8995 else if (specs->storage_class == csc_typedef)
8996 error ("%<__thread%> used with %<typedef%>");
8998 specs->thread_p = true;
9005 /* Diagnose "__thread extern". */
9006 if (specs->thread_p)
9007 error ("%<__thread%> before %<extern%>");
9014 /* Diagnose "__thread static". */
9015 if (specs->thread_p)
9016 error ("%<__thread%> before %<static%>");
9024 if (n != csc_none && n == specs->storage_class)
9027 error ("duplicate %qE", scspec);
9030 if (specs->storage_class != csc_none && n != specs->storage_class)
9032 error ("multiple storage classes in declaration specifiers");
9036 specs->storage_class = n;
9037 if (n != csc_extern && n != csc_static && specs->thread_p)
9039 error ("%<__thread%> used with %qE", scspec);
9040 specs->thread_p = false;
9047 /* Add the attributes ATTRS to the declaration specifiers SPECS,
9050 struct c_declspecs *
9051 declspecs_add_attrs (struct c_declspecs *specs, tree attrs)
9053 specs->attrs = chainon (attrs, specs->attrs);
9054 specs->declspecs_seen_p = true;
9058 /* Combine "long", "short", "signed", "unsigned" and "_Complex" type
9059 specifiers with any other type specifier to determine the resulting
9060 type. This is where ISO C checks on complex types are made, since
9061 "_Complex long" is a prefix of the valid ISO C type "_Complex long
9064 struct c_declspecs *
9065 finish_declspecs (struct c_declspecs *specs)
9067 /* If a type was specified as a whole, we have no modifiers and are
9069 if (specs->type != NULL_TREE)
9071 gcc_assert (!specs->long_p && !specs->long_long_p && !specs->short_p
9072 && !specs->signed_p && !specs->unsigned_p
9073 && !specs->complex_p);
9077 /* If none of "void", "_Bool", "char", "int", "float" or "double"
9078 has been specified, treat it as "int" unless "_Complex" is
9079 present and there are no other specifiers. If we just have
9080 "_Complex", it is equivalent to "_Complex double", but e.g.
9081 "_Complex short" is equivalent to "_Complex short int". */
9082 if (specs->typespec_word == cts_none)
9084 if (specs->saturating_p)
9086 error ("%<_Sat%> is used without %<_Fract%> or %<_Accum%>");
9087 if (!targetm.fixed_point_supported_p ())
9088 error ("fixed-point types not supported for this target");
9089 specs->typespec_word = cts_fract;
9091 else if (specs->long_p || specs->short_p
9092 || specs->signed_p || specs->unsigned_p)
9094 specs->typespec_word = cts_int;
9096 else if (specs->complex_p)
9098 specs->typespec_word = cts_double;
9099 pedwarn (input_location, OPT_pedantic,
9100 "ISO C does not support plain %<complex%> meaning "
9101 "%<double complex%>");
9105 specs->typespec_word = cts_int;
9106 specs->default_int_p = true;
9107 /* We don't diagnose this here because grokdeclarator will
9108 give more specific diagnostics according to whether it is
9109 a function definition. */
9113 /* If "signed" was specified, record this to distinguish "int" and
9114 "signed int" in the case of a bit-field with
9115 -funsigned-bitfields. */
9116 specs->explicit_signed_p = specs->signed_p;
9118 /* Now compute the actual type. */
9119 switch (specs->typespec_word)
9122 gcc_assert (!specs->long_p && !specs->short_p
9123 && !specs->signed_p && !specs->unsigned_p
9124 && !specs->complex_p);
9125 specs->type = void_type_node;
9128 gcc_assert (!specs->long_p && !specs->short_p
9129 && !specs->signed_p && !specs->unsigned_p
9130 && !specs->complex_p);
9131 specs->type = boolean_type_node;
9134 gcc_assert (!specs->long_p && !specs->short_p);
9135 gcc_assert (!(specs->signed_p && specs->unsigned_p));
9136 if (specs->signed_p)
9137 specs->type = signed_char_type_node;
9138 else if (specs->unsigned_p)
9139 specs->type = unsigned_char_type_node;
9141 specs->type = char_type_node;
9142 if (specs->complex_p)
9144 pedwarn (input_location, OPT_pedantic,
9145 "ISO C does not support complex integer types");
9146 specs->type = build_complex_type (specs->type);
9150 gcc_assert (!(specs->long_p && specs->short_p));
9151 gcc_assert (!(specs->signed_p && specs->unsigned_p));
9152 if (specs->long_long_p)
9153 specs->type = (specs->unsigned_p
9154 ? long_long_unsigned_type_node
9155 : long_long_integer_type_node);
9156 else if (specs->long_p)
9157 specs->type = (specs->unsigned_p
9158 ? long_unsigned_type_node
9159 : long_integer_type_node);
9160 else if (specs->short_p)
9161 specs->type = (specs->unsigned_p
9162 ? short_unsigned_type_node
9163 : short_integer_type_node);
9165 specs->type = (specs->unsigned_p
9166 ? unsigned_type_node
9167 : integer_type_node);
9168 if (specs->complex_p)
9170 pedwarn (input_location, OPT_pedantic,
9171 "ISO C does not support complex integer types");
9172 specs->type = build_complex_type (specs->type);
9176 gcc_assert (!specs->long_p && !specs->short_p
9177 && !specs->signed_p && !specs->unsigned_p);
9178 specs->type = (specs->complex_p
9179 ? complex_float_type_node
9183 gcc_assert (!specs->long_long_p && !specs->short_p
9184 && !specs->signed_p && !specs->unsigned_p);
9187 specs->type = (specs->complex_p
9188 ? complex_long_double_type_node
9189 : long_double_type_node);
9193 specs->type = (specs->complex_p
9194 ? complex_double_type_node
9195 : double_type_node);
9201 gcc_assert (!specs->long_p && !specs->long_long_p && !specs->short_p
9202 && !specs->signed_p && !specs->unsigned_p && !specs->complex_p);
9203 if (specs->typespec_word == cts_dfloat32)
9204 specs->type = dfloat32_type_node;
9205 else if (specs->typespec_word == cts_dfloat64)
9206 specs->type = dfloat64_type_node;
9208 specs->type = dfloat128_type_node;
9211 gcc_assert (!specs->complex_p);
9212 if (!targetm.fixed_point_supported_p ())
9213 specs->type = integer_type_node;
9214 else if (specs->saturating_p)
9216 if (specs->long_long_p)
9217 specs->type = specs->unsigned_p
9218 ? sat_unsigned_long_long_fract_type_node
9219 : sat_long_long_fract_type_node;
9220 else if (specs->long_p)
9221 specs->type = specs->unsigned_p
9222 ? sat_unsigned_long_fract_type_node
9223 : sat_long_fract_type_node;
9224 else if (specs->short_p)
9225 specs->type = specs->unsigned_p
9226 ? sat_unsigned_short_fract_type_node
9227 : sat_short_fract_type_node;
9229 specs->type = specs->unsigned_p
9230 ? sat_unsigned_fract_type_node
9231 : sat_fract_type_node;
9235 if (specs->long_long_p)
9236 specs->type = specs->unsigned_p
9237 ? unsigned_long_long_fract_type_node
9238 : long_long_fract_type_node;
9239 else if (specs->long_p)
9240 specs->type = specs->unsigned_p
9241 ? unsigned_long_fract_type_node
9242 : long_fract_type_node;
9243 else if (specs->short_p)
9244 specs->type = specs->unsigned_p
9245 ? unsigned_short_fract_type_node
9246 : short_fract_type_node;
9248 specs->type = specs->unsigned_p
9249 ? unsigned_fract_type_node
9254 gcc_assert (!specs->complex_p);
9255 if (!targetm.fixed_point_supported_p ())
9256 specs->type = integer_type_node;
9257 else if (specs->saturating_p)
9259 if (specs->long_long_p)
9260 specs->type = specs->unsigned_p
9261 ? sat_unsigned_long_long_accum_type_node
9262 : sat_long_long_accum_type_node;
9263 else if (specs->long_p)
9264 specs->type = specs->unsigned_p
9265 ? sat_unsigned_long_accum_type_node
9266 : sat_long_accum_type_node;
9267 else if (specs->short_p)
9268 specs->type = specs->unsigned_p
9269 ? sat_unsigned_short_accum_type_node
9270 : sat_short_accum_type_node;
9272 specs->type = specs->unsigned_p
9273 ? sat_unsigned_accum_type_node
9274 : sat_accum_type_node;
9278 if (specs->long_long_p)
9279 specs->type = specs->unsigned_p
9280 ? unsigned_long_long_accum_type_node
9281 : long_long_accum_type_node;
9282 else if (specs->long_p)
9283 specs->type = specs->unsigned_p
9284 ? unsigned_long_accum_type_node
9285 : long_accum_type_node;
9286 else if (specs->short_p)
9287 specs->type = specs->unsigned_p
9288 ? unsigned_short_accum_type_node
9289 : short_accum_type_node;
9291 specs->type = specs->unsigned_p
9292 ? unsigned_accum_type_node
9303 /* A subroutine of c_write_global_declarations. Perform final processing
9304 on one file scope's declarations (or the external scope's declarations),
9308 c_write_global_declarations_1 (tree globals)
9313 /* Process the decls in the order they were written. */
9314 for (decl = globals; decl; decl = TREE_CHAIN (decl))
9316 /* Check for used but undefined static functions using the C
9317 standard's definition of "used", and set TREE_NO_WARNING so
9318 that check_global_declarations doesn't repeat the check. */
9319 if (TREE_CODE (decl) == FUNCTION_DECL
9320 && DECL_INITIAL (decl) == 0
9321 && DECL_EXTERNAL (decl)
9322 && !TREE_PUBLIC (decl)
9323 && C_DECL_USED (decl))
9325 pedwarn (input_location, 0, "%q+F used but never defined", decl);
9326 TREE_NO_WARNING (decl) = 1;
9329 wrapup_global_declaration_1 (decl);
9335 for (decl = globals; decl; decl = TREE_CHAIN (decl))
9336 reconsider |= wrapup_global_declaration_2 (decl);
9340 for (decl = globals; decl; decl = TREE_CHAIN (decl))
9341 check_global_declaration_1 (decl);
9344 /* A subroutine of c_write_global_declarations Emit debug information for each
9345 of the declarations in GLOBALS. */
9348 c_write_global_declarations_2 (tree globals)
9352 for (decl = globals; decl ; decl = TREE_CHAIN (decl))
9353 debug_hooks->global_decl (decl);
9356 /* Preserve the external declarations scope across a garbage collect. */
9357 static GTY(()) tree ext_block;
9360 c_write_global_declarations (void)
9364 /* We don't want to do this if generating a PCH. */
9368 /* Don't waste time on further processing if -fsyntax-only or we've
9369 encountered errors. */
9370 if (flag_syntax_only || errorcount || sorrycount)
9373 /* Close the external scope. */
9374 ext_block = pop_scope ();
9376 gcc_assert (!current_scope);
9380 tree tmp = BLOCK_VARS (ext_block);
9382 FILE * stream = dump_begin (TDI_tu, &flags);
9385 dump_node (tmp, flags & ~TDF_SLIM, stream);
9386 dump_end (TDI_tu, stream);
9390 /* Process all file scopes in this compilation, and the external_scope,
9391 through wrapup_global_declarations and check_global_declarations. */
9392 for (t = all_translation_units; t; t = TREE_CHAIN (t))
9393 c_write_global_declarations_1 (BLOCK_VARS (DECL_INITIAL (t)));
9394 c_write_global_declarations_1 (BLOCK_VARS (ext_block));
9396 /* We're done parsing; proceed to optimize and emit assembly.
9397 FIXME: shouldn't be the front end's responsibility to call this. */
9400 /* After cgraph has had a chance to emit everything that's going to
9401 be emitted, output debug information for globals. */
9402 if (errorcount == 0 && sorrycount == 0)
9404 timevar_push (TV_SYMOUT);
9405 for (t = all_translation_units; t; t = TREE_CHAIN (t))
9406 c_write_global_declarations_2 (BLOCK_VARS (DECL_INITIAL (t)));
9407 c_write_global_declarations_2 (BLOCK_VARS (ext_block));
9408 timevar_pop (TV_SYMOUT);
9414 #include "gt-c-decl.h"