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 ();
1332 /* Adjust the bindings for the start of a statement expression. */
1335 c_bindings_start_stmt_expr (struct c_spot_bindings* switch_bindings)
1337 struct c_scope *scope;
1339 for (scope = current_scope; scope != NULL; scope = scope->outer)
1341 struct c_binding *b;
1343 if (!scope->has_label_bindings)
1346 for (b = scope->bindings; b != NULL; b = b->prev)
1348 struct c_label_vars *label_vars;
1350 struct c_goto_bindings *g;
1352 if (TREE_CODE (b->decl) != LABEL_DECL)
1354 label_vars = b->u.label;
1355 ++label_vars->label_bindings.stmt_exprs;
1357 VEC_iterate (c_goto_bindings_p, label_vars->gotos, ix, g);
1359 ++g->goto_bindings.stmt_exprs;
1363 if (switch_bindings != NULL)
1364 ++switch_bindings->stmt_exprs;
1367 /* Adjust the bindings for the end of a statement expression. */
1370 c_bindings_end_stmt_expr (struct c_spot_bindings *switch_bindings)
1372 struct c_scope *scope;
1374 for (scope = current_scope; scope != NULL; scope = scope->outer)
1376 struct c_binding *b;
1378 if (!scope->has_label_bindings)
1381 for (b = scope->bindings; b != NULL; b = b->prev)
1383 struct c_label_vars *label_vars;
1385 struct c_goto_bindings *g;
1387 if (TREE_CODE (b->decl) != LABEL_DECL)
1389 label_vars = b->u.label;
1390 --label_vars->label_bindings.stmt_exprs;
1391 if (label_vars->label_bindings.stmt_exprs < 0)
1393 label_vars->label_bindings.left_stmt_expr = true;
1394 label_vars->label_bindings.stmt_exprs = 0;
1397 VEC_iterate (c_goto_bindings_p, label_vars->gotos, ix, g);
1400 --g->goto_bindings.stmt_exprs;
1401 if (g->goto_bindings.stmt_exprs < 0)
1403 g->goto_bindings.left_stmt_expr = true;
1404 g->goto_bindings.stmt_exprs = 0;
1410 if (switch_bindings != NULL)
1412 --switch_bindings->stmt_exprs;
1413 gcc_assert (switch_bindings->stmt_exprs >= 0);
1417 /* Push a definition or a declaration of struct, union or enum tag "name".
1418 "type" should be the type node.
1419 We assume that the tag "name" is not already defined, and has a location
1422 Note that the definition may really be just a forward reference.
1423 In that case, the TYPE_SIZE will be zero. */
1426 pushtag (location_t loc, tree name, tree type)
1428 /* Record the identifier as the type's name if it has none. */
1429 if (name && !TYPE_NAME (type))
1430 TYPE_NAME (type) = name;
1431 bind (name, type, current_scope, /*invisible=*/false, /*nested=*/false, loc);
1433 /* Create a fake NULL-named TYPE_DECL node whose TREE_TYPE will be the
1434 tagged type we just added to the current scope. This fake
1435 NULL-named TYPE_DECL node helps dwarfout.c to know when it needs
1436 to output a representation of a tagged type, and it also gives
1437 us a convenient place to record the "scope start" address for the
1440 TYPE_STUB_DECL (type) = pushdecl (build_decl (loc,
1441 TYPE_DECL, NULL_TREE, type));
1443 /* An approximation for now, so we can tell this is a function-scope tag.
1444 This will be updated in pop_scope. */
1445 TYPE_CONTEXT (type) = DECL_CONTEXT (TYPE_STUB_DECL (type));
1447 if (warn_cxx_compat && name != NULL_TREE)
1449 struct c_binding *b = I_SYMBOL_BINDING (name);
1452 && b->decl != NULL_TREE
1453 && TREE_CODE (b->decl) == TYPE_DECL
1454 && (B_IN_CURRENT_SCOPE (b)
1455 || (current_scope == file_scope && B_IN_EXTERNAL_SCOPE (b)))
1456 && (TYPE_MAIN_VARIANT (TREE_TYPE (b->decl))
1457 != TYPE_MAIN_VARIANT (type)))
1459 warning_at (loc, OPT_Wc___compat,
1460 ("using %qD as both a typedef and a tag is "
1463 if (b->locus != UNKNOWN_LOCATION)
1464 inform (b->locus, "originally defined here");
1469 /* Subroutine of compare_decls. Allow harmless mismatches in return
1470 and argument types provided that the type modes match. This function
1471 return a unified type given a suitable match, and 0 otherwise. */
1474 match_builtin_function_types (tree newtype, tree oldtype)
1476 tree newrettype, oldrettype;
1477 tree newargs, oldargs;
1478 tree trytype, tryargs;
1480 /* Accept the return type of the new declaration if same modes. */
1481 oldrettype = TREE_TYPE (oldtype);
1482 newrettype = TREE_TYPE (newtype);
1484 if (TYPE_MODE (oldrettype) != TYPE_MODE (newrettype))
1487 oldargs = TYPE_ARG_TYPES (oldtype);
1488 newargs = TYPE_ARG_TYPES (newtype);
1491 while (oldargs || newargs)
1495 || !TREE_VALUE (oldargs)
1496 || !TREE_VALUE (newargs)
1497 || TYPE_MODE (TREE_VALUE (oldargs))
1498 != TYPE_MODE (TREE_VALUE (newargs)))
1501 oldargs = TREE_CHAIN (oldargs);
1502 newargs = TREE_CHAIN (newargs);
1505 trytype = build_function_type (newrettype, tryargs);
1506 return build_type_attribute_variant (trytype, TYPE_ATTRIBUTES (oldtype));
1509 /* Subroutine of diagnose_mismatched_decls. Check for function type
1510 mismatch involving an empty arglist vs a nonempty one and give clearer
1513 diagnose_arglist_conflict (tree newdecl, tree olddecl,
1514 tree newtype, tree oldtype)
1518 if (TREE_CODE (olddecl) != FUNCTION_DECL
1519 || !comptypes (TREE_TYPE (oldtype), TREE_TYPE (newtype))
1520 || !((TYPE_ARG_TYPES (oldtype) == 0 && DECL_INITIAL (olddecl) == 0)
1522 (TYPE_ARG_TYPES (newtype) == 0 && DECL_INITIAL (newdecl) == 0)))
1525 t = TYPE_ARG_TYPES (oldtype);
1527 t = TYPE_ARG_TYPES (newtype);
1528 for (; t; t = TREE_CHAIN (t))
1530 tree type = TREE_VALUE (t);
1532 if (TREE_CHAIN (t) == 0
1533 && TYPE_MAIN_VARIANT (type) != void_type_node)
1535 inform (input_location, "a parameter list with an ellipsis can%'t match "
1536 "an empty parameter name list declaration");
1540 if (c_type_promotes_to (type) != type)
1542 inform (input_location, "an argument type that has a default promotion can%'t match "
1543 "an empty parameter name list declaration");
1549 /* Another subroutine of diagnose_mismatched_decls. OLDDECL is an
1550 old-style function definition, NEWDECL is a prototype declaration.
1551 Diagnose inconsistencies in the argument list. Returns TRUE if
1552 the prototype is compatible, FALSE if not. */
1554 validate_proto_after_old_defn (tree newdecl, tree newtype, tree oldtype)
1556 tree newargs, oldargs;
1559 #define END_OF_ARGLIST(t) ((t) == void_type_node)
1561 oldargs = TYPE_ACTUAL_ARG_TYPES (oldtype);
1562 newargs = TYPE_ARG_TYPES (newtype);
1567 tree oldargtype = TREE_VALUE (oldargs);
1568 tree newargtype = TREE_VALUE (newargs);
1570 if (oldargtype == error_mark_node || newargtype == error_mark_node)
1573 oldargtype = TYPE_MAIN_VARIANT (oldargtype);
1574 newargtype = TYPE_MAIN_VARIANT (newargtype);
1576 if (END_OF_ARGLIST (oldargtype) && END_OF_ARGLIST (newargtype))
1579 /* Reaching the end of just one list means the two decls don't
1580 agree on the number of arguments. */
1581 if (END_OF_ARGLIST (oldargtype))
1583 error ("prototype for %q+D declares more arguments "
1584 "than previous old-style definition", newdecl);
1587 else if (END_OF_ARGLIST (newargtype))
1589 error ("prototype for %q+D declares fewer arguments "
1590 "than previous old-style definition", newdecl);
1594 /* Type for passing arg must be consistent with that declared
1596 else if (!comptypes (oldargtype, newargtype))
1598 error ("prototype for %q+D declares argument %d"
1599 " with incompatible type",
1604 oldargs = TREE_CHAIN (oldargs);
1605 newargs = TREE_CHAIN (newargs);
1609 /* If we get here, no errors were found, but do issue a warning
1610 for this poor-style construct. */
1611 warning (0, "prototype for %q+D follows non-prototype definition",
1614 #undef END_OF_ARGLIST
1617 /* Subroutine of diagnose_mismatched_decls. Report the location of DECL,
1618 first in a pair of mismatched declarations, using the diagnostic
1621 locate_old_decl (tree decl)
1623 if (TREE_CODE (decl) == FUNCTION_DECL && DECL_BUILT_IN (decl))
1625 else if (DECL_INITIAL (decl))
1626 inform (input_location, "previous definition of %q+D was here", decl);
1627 else if (C_DECL_IMPLICIT (decl))
1628 inform (input_location, "previous implicit declaration of %q+D was here", decl);
1630 inform (input_location, "previous declaration of %q+D was here", decl);
1633 /* Subroutine of duplicate_decls. Compare NEWDECL to OLDDECL.
1634 Returns true if the caller should proceed to merge the two, false
1635 if OLDDECL should simply be discarded. As a side effect, issues
1636 all necessary diagnostics for invalid or poor-style combinations.
1637 If it returns true, writes the types of NEWDECL and OLDDECL to
1638 *NEWTYPEP and *OLDTYPEP - these may have been adjusted from
1639 TREE_TYPE (NEWDECL, OLDDECL) respectively. */
1642 diagnose_mismatched_decls (tree newdecl, tree olddecl,
1643 tree *newtypep, tree *oldtypep)
1645 tree newtype, oldtype;
1646 bool pedwarned = false;
1647 bool warned = false;
1650 #define DECL_EXTERN_INLINE(DECL) (DECL_DECLARED_INLINE_P (DECL) \
1651 && DECL_EXTERNAL (DECL))
1653 /* If we have error_mark_node for either decl or type, just discard
1654 the previous decl - we're in an error cascade already. */
1655 if (olddecl == error_mark_node || newdecl == error_mark_node)
1657 *oldtypep = oldtype = TREE_TYPE (olddecl);
1658 *newtypep = newtype = TREE_TYPE (newdecl);
1659 if (oldtype == error_mark_node || newtype == error_mark_node)
1662 /* Two different categories of symbol altogether. This is an error
1663 unless OLDDECL is a builtin. OLDDECL will be discarded in any case. */
1664 if (TREE_CODE (olddecl) != TREE_CODE (newdecl))
1666 if (!(TREE_CODE (olddecl) == FUNCTION_DECL
1667 && DECL_BUILT_IN (olddecl)
1668 && !C_DECL_DECLARED_BUILTIN (olddecl)))
1670 error ("%q+D redeclared as different kind of symbol", newdecl);
1671 locate_old_decl (olddecl);
1673 else if (TREE_PUBLIC (newdecl))
1674 warning (0, "built-in function %q+D declared as non-function",
1677 warning (OPT_Wshadow, "declaration of %q+D shadows "
1678 "a built-in function", newdecl);
1682 /* Enumerators have no linkage, so may only be declared once in a
1684 if (TREE_CODE (olddecl) == CONST_DECL)
1686 error ("redeclaration of enumerator %q+D", newdecl);
1687 locate_old_decl (olddecl);
1691 if (!comptypes (oldtype, newtype))
1693 if (TREE_CODE (olddecl) == FUNCTION_DECL
1694 && DECL_BUILT_IN (olddecl) && !C_DECL_DECLARED_BUILTIN (olddecl))
1696 /* Accept harmless mismatch in function types.
1697 This is for the ffs and fprintf builtins. */
1698 tree trytype = match_builtin_function_types (newtype, oldtype);
1700 if (trytype && comptypes (newtype, trytype))
1701 *oldtypep = oldtype = trytype;
1704 /* If types don't match for a built-in, throw away the
1705 built-in. No point in calling locate_old_decl here, it
1706 won't print anything. */
1707 warning (0, "conflicting types for built-in function %q+D",
1712 else if (TREE_CODE (olddecl) == FUNCTION_DECL
1713 && DECL_IS_BUILTIN (olddecl))
1715 /* A conflicting function declaration for a predeclared
1716 function that isn't actually built in. Objective C uses
1717 these. The new declaration silently overrides everything
1718 but the volatility (i.e. noreturn) indication. See also
1719 below. FIXME: Make Objective C use normal builtins. */
1720 TREE_THIS_VOLATILE (newdecl) |= TREE_THIS_VOLATILE (olddecl);
1723 /* Permit void foo (...) to match int foo (...) if the latter is
1724 the definition and implicit int was used. See
1725 c-torture/compile/920625-2.c. */
1726 else if (TREE_CODE (newdecl) == FUNCTION_DECL && DECL_INITIAL (newdecl)
1727 && TYPE_MAIN_VARIANT (TREE_TYPE (oldtype)) == void_type_node
1728 && TYPE_MAIN_VARIANT (TREE_TYPE (newtype)) == integer_type_node
1729 && C_FUNCTION_IMPLICIT_INT (newdecl) && !DECL_INITIAL (olddecl))
1731 pedwarned = pedwarn (input_location, 0,
1732 "conflicting types for %q+D", newdecl);
1733 /* Make sure we keep void as the return type. */
1734 TREE_TYPE (newdecl) = *newtypep = newtype = oldtype;
1735 C_FUNCTION_IMPLICIT_INT (newdecl) = 0;
1737 /* Permit void foo (...) to match an earlier call to foo (...) with
1738 no declared type (thus, implicitly int). */
1739 else if (TREE_CODE (newdecl) == FUNCTION_DECL
1740 && TYPE_MAIN_VARIANT (TREE_TYPE (newtype)) == void_type_node
1741 && TYPE_MAIN_VARIANT (TREE_TYPE (oldtype)) == integer_type_node
1742 && C_DECL_IMPLICIT (olddecl) && !DECL_INITIAL (olddecl))
1744 pedwarned = pedwarn (input_location, 0,
1745 "conflicting types for %q+D", newdecl);
1746 /* Make sure we keep void as the return type. */
1747 TREE_TYPE (olddecl) = *oldtypep = oldtype = newtype;
1751 if (TYPE_QUALS (newtype) != TYPE_QUALS (oldtype))
1752 error ("conflicting type qualifiers for %q+D", newdecl);
1754 error ("conflicting types for %q+D", newdecl);
1755 diagnose_arglist_conflict (newdecl, olddecl, newtype, oldtype);
1756 locate_old_decl (olddecl);
1761 /* Redeclaration of a type is a constraint violation (6.7.2.3p1),
1762 but silently ignore the redeclaration if either is in a system
1763 header. (Conflicting redeclarations were handled above.) */
1764 if (TREE_CODE (newdecl) == TYPE_DECL)
1766 if (DECL_IN_SYSTEM_HEADER (newdecl)
1767 || DECL_IN_SYSTEM_HEADER (olddecl)
1768 || TREE_NO_WARNING (newdecl)
1769 || TREE_NO_WARNING (olddecl))
1770 return true; /* Allow OLDDECL to continue in use. */
1772 error ("redefinition of typedef %q+D", newdecl);
1773 locate_old_decl (olddecl);
1777 /* Function declarations can either be 'static' or 'extern' (no
1778 qualifier is equivalent to 'extern' - C99 6.2.2p5) and therefore
1779 can never conflict with each other on account of linkage
1780 (6.2.2p4). Multiple definitions are not allowed (6.9p3,5) but
1781 gnu89 mode permits two definitions if one is 'extern inline' and
1782 one is not. The non- extern-inline definition supersedes the
1783 extern-inline definition. */
1785 else if (TREE_CODE (newdecl) == FUNCTION_DECL)
1787 /* If you declare a built-in function name as static, or
1788 define the built-in with an old-style definition (so we
1789 can't validate the argument list) the built-in definition is
1790 overridden, but optionally warn this was a bad choice of name. */
1791 if (DECL_BUILT_IN (olddecl)
1792 && !C_DECL_DECLARED_BUILTIN (olddecl)
1793 && (!TREE_PUBLIC (newdecl)
1794 || (DECL_INITIAL (newdecl)
1795 && !TYPE_ARG_TYPES (TREE_TYPE (newdecl)))))
1797 warning (OPT_Wshadow, "declaration of %q+D shadows "
1798 "a built-in function", newdecl);
1799 /* Discard the old built-in function. */
1803 if (DECL_INITIAL (newdecl))
1805 if (DECL_INITIAL (olddecl))
1807 /* If both decls are in the same TU and the new declaration
1808 isn't overriding an extern inline reject the new decl.
1809 In c99, no overriding is allowed in the same translation
1811 if ((!DECL_EXTERN_INLINE (olddecl)
1812 || DECL_EXTERN_INLINE (newdecl)
1813 || (!flag_gnu89_inline
1814 && (!DECL_DECLARED_INLINE_P (olddecl)
1815 || !lookup_attribute ("gnu_inline",
1816 DECL_ATTRIBUTES (olddecl)))
1817 && (!DECL_DECLARED_INLINE_P (newdecl)
1818 || !lookup_attribute ("gnu_inline",
1819 DECL_ATTRIBUTES (newdecl))))
1821 && same_translation_unit_p (newdecl, olddecl))
1823 error ("redefinition of %q+D", newdecl);
1824 locate_old_decl (olddecl);
1829 /* If we have a prototype after an old-style function definition,
1830 the argument types must be checked specially. */
1831 else if (DECL_INITIAL (olddecl)
1832 && !TYPE_ARG_TYPES (oldtype) && TYPE_ARG_TYPES (newtype)
1833 && TYPE_ACTUAL_ARG_TYPES (oldtype)
1834 && !validate_proto_after_old_defn (newdecl, newtype, oldtype))
1836 locate_old_decl (olddecl);
1839 /* A non-static declaration (even an "extern") followed by a
1840 static declaration is undefined behavior per C99 6.2.2p3-5,7.
1841 The same is true for a static forward declaration at block
1842 scope followed by a non-static declaration/definition at file
1843 scope. Static followed by non-static at the same scope is
1844 not undefined behavior, and is the most convenient way to get
1845 some effects (see e.g. what unwind-dw2-fde-glibc.c does to
1846 the definition of _Unwind_Find_FDE in unwind-dw2-fde.c), but
1847 we do diagnose it if -Wtraditional. */
1848 if (TREE_PUBLIC (olddecl) && !TREE_PUBLIC (newdecl))
1850 /* Two exceptions to the rule. If olddecl is an extern
1851 inline, or a predeclared function that isn't actually
1852 built in, newdecl silently overrides olddecl. The latter
1853 occur only in Objective C; see also above. (FIXME: Make
1854 Objective C use normal builtins.) */
1855 if (!DECL_IS_BUILTIN (olddecl)
1856 && !DECL_EXTERN_INLINE (olddecl))
1858 error ("static declaration of %q+D follows "
1859 "non-static declaration", newdecl);
1860 locate_old_decl (olddecl);
1864 else if (TREE_PUBLIC (newdecl) && !TREE_PUBLIC (olddecl))
1866 if (DECL_CONTEXT (olddecl))
1868 error ("non-static declaration of %q+D follows "
1869 "static declaration", newdecl);
1870 locate_old_decl (olddecl);
1873 else if (warn_traditional)
1875 warned |= warning (OPT_Wtraditional,
1876 "non-static declaration of %q+D "
1877 "follows static declaration", newdecl);
1881 /* Make sure gnu_inline attribute is either not present, or
1882 present on all inline decls. */
1883 if (DECL_DECLARED_INLINE_P (olddecl)
1884 && DECL_DECLARED_INLINE_P (newdecl))
1886 bool newa = lookup_attribute ("gnu_inline",
1887 DECL_ATTRIBUTES (newdecl)) != NULL;
1888 bool olda = lookup_attribute ("gnu_inline",
1889 DECL_ATTRIBUTES (olddecl)) != NULL;
1892 error_at (input_location, "%<gnu_inline%> attribute present on %q+D",
1893 newa ? newdecl : olddecl);
1894 error_at (DECL_SOURCE_LOCATION (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);
1995 /* C++ does not permit a decl to appear multiple times at file
1998 && DECL_FILE_SCOPE_P (newdecl)
1999 && !DECL_EXTERNAL (newdecl)
2000 && !DECL_EXTERNAL (olddecl))
2001 warned |= warning_at (DECL_SOURCE_LOCATION (newdecl),
2003 ("duplicate declaration of %qD is "
2009 /* All decls must agree on a visibility. */
2010 if (CODE_CONTAINS_STRUCT (TREE_CODE (newdecl), TS_DECL_WITH_VIS)
2011 && DECL_VISIBILITY_SPECIFIED (newdecl) && DECL_VISIBILITY_SPECIFIED (olddecl)
2012 && DECL_VISIBILITY (newdecl) != DECL_VISIBILITY (olddecl))
2014 warned |= warning (0, "redeclaration of %q+D with different visibility "
2015 "(old visibility preserved)", newdecl);
2018 if (TREE_CODE (newdecl) == FUNCTION_DECL)
2020 /* Diagnose inline __attribute__ ((noinline)) which is silly. */
2021 if (DECL_DECLARED_INLINE_P (newdecl)
2022 && lookup_attribute ("noinline", DECL_ATTRIBUTES (olddecl)))
2024 warned |= warning (OPT_Wattributes,
2025 "inline declaration of %qD follows "
2026 "declaration with attribute noinline", newdecl);
2028 else if (DECL_DECLARED_INLINE_P (olddecl)
2029 && lookup_attribute ("noinline", DECL_ATTRIBUTES (newdecl)))
2031 warned |= warning (OPT_Wattributes,
2032 "declaration of %q+D with attribute "
2033 "noinline follows inline declaration ", newdecl);
2036 else /* PARM_DECL, VAR_DECL */
2038 /* Redeclaration of a parameter is a constraint violation (this is
2039 not explicitly stated, but follows from C99 6.7p3 [no more than
2040 one declaration of the same identifier with no linkage in the
2041 same scope, except type tags] and 6.2.2p6 [parameters have no
2042 linkage]). We must check for a forward parameter declaration,
2043 indicated by TREE_ASM_WRITTEN on the old declaration - this is
2044 an extension, the mandatory diagnostic for which is handled by
2045 mark_forward_parm_decls. */
2047 if (TREE_CODE (newdecl) == PARM_DECL
2048 && (!TREE_ASM_WRITTEN (olddecl) || TREE_ASM_WRITTEN (newdecl)))
2050 error ("redefinition of parameter %q+D", newdecl);
2051 locate_old_decl (olddecl);
2056 /* Optional warning for completely redundant decls. */
2057 if (!warned && !pedwarned
2058 && warn_redundant_decls
2059 /* Don't warn about a function declaration followed by a
2061 && !(TREE_CODE (newdecl) == FUNCTION_DECL
2062 && DECL_INITIAL (newdecl) && !DECL_INITIAL (olddecl))
2063 /* Don't warn about redundant redeclarations of builtins. */
2064 && !(TREE_CODE (newdecl) == FUNCTION_DECL
2065 && !DECL_BUILT_IN (newdecl)
2066 && DECL_BUILT_IN (olddecl)
2067 && !C_DECL_DECLARED_BUILTIN (olddecl))
2068 /* Don't warn about an extern followed by a definition. */
2069 && !(DECL_EXTERNAL (olddecl) && !DECL_EXTERNAL (newdecl))
2070 /* Don't warn about forward parameter decls. */
2071 && !(TREE_CODE (newdecl) == PARM_DECL
2072 && TREE_ASM_WRITTEN (olddecl) && !TREE_ASM_WRITTEN (newdecl))
2073 /* Don't warn about a variable definition following a declaration. */
2074 && !(TREE_CODE (newdecl) == VAR_DECL
2075 && DECL_INITIAL (newdecl) && !DECL_INITIAL (olddecl)))
2077 warned = warning (OPT_Wredundant_decls, "redundant redeclaration of %q+D",
2081 /* Report location of previous decl/defn. */
2082 if (warned || pedwarned)
2083 locate_old_decl (olddecl);
2085 #undef DECL_EXTERN_INLINE
2090 /* Subroutine of duplicate_decls. NEWDECL has been found to be
2091 consistent with OLDDECL, but carries new information. Merge the
2092 new information into OLDDECL. This function issues no
2096 merge_decls (tree newdecl, tree olddecl, tree newtype, tree oldtype)
2098 bool new_is_definition = (TREE_CODE (newdecl) == FUNCTION_DECL
2099 && DECL_INITIAL (newdecl) != 0);
2100 bool new_is_prototype = (TREE_CODE (newdecl) == FUNCTION_DECL
2101 && TYPE_ARG_TYPES (TREE_TYPE (newdecl)) != 0);
2102 bool old_is_prototype = (TREE_CODE (olddecl) == FUNCTION_DECL
2103 && TYPE_ARG_TYPES (TREE_TYPE (olddecl)) != 0);
2104 bool extern_changed = false;
2106 /* For real parm decl following a forward decl, rechain the old decl
2107 in its new location and clear TREE_ASM_WRITTEN (it's not a
2108 forward decl anymore). */
2109 if (TREE_CODE (newdecl) == PARM_DECL
2110 && TREE_ASM_WRITTEN (olddecl) && !TREE_ASM_WRITTEN (newdecl))
2112 struct c_binding *b, **here;
2114 for (here = ¤t_scope->bindings; *here; here = &(*here)->prev)
2115 if ((*here)->decl == olddecl)
2122 b->prev = current_scope->bindings;
2123 current_scope->bindings = b;
2125 TREE_ASM_WRITTEN (olddecl) = 0;
2128 DECL_ATTRIBUTES (newdecl)
2129 = targetm.merge_decl_attributes (olddecl, newdecl);
2131 /* Merge the data types specified in the two decls. */
2133 = TREE_TYPE (olddecl)
2134 = composite_type (newtype, oldtype);
2136 /* Lay the type out, unless already done. */
2137 if (!comptypes (oldtype, TREE_TYPE (newdecl)))
2139 if (TREE_TYPE (newdecl) != error_mark_node)
2140 layout_type (TREE_TYPE (newdecl));
2141 if (TREE_CODE (newdecl) != FUNCTION_DECL
2142 && TREE_CODE (newdecl) != TYPE_DECL
2143 && TREE_CODE (newdecl) != CONST_DECL)
2144 layout_decl (newdecl, 0);
2148 /* Since the type is OLDDECL's, make OLDDECL's size go with. */
2149 DECL_SIZE (newdecl) = DECL_SIZE (olddecl);
2150 DECL_SIZE_UNIT (newdecl) = DECL_SIZE_UNIT (olddecl);
2151 DECL_MODE (newdecl) = DECL_MODE (olddecl);
2152 if (DECL_ALIGN (olddecl) > DECL_ALIGN (newdecl))
2154 DECL_ALIGN (newdecl) = DECL_ALIGN (olddecl);
2155 DECL_USER_ALIGN (newdecl) |= DECL_USER_ALIGN (olddecl);
2159 /* Keep the old rtl since we can safely use it. */
2160 if (HAS_RTL_P (olddecl))
2161 COPY_DECL_RTL (olddecl, newdecl);
2163 /* Merge the type qualifiers. */
2164 if (TREE_READONLY (newdecl))
2165 TREE_READONLY (olddecl) = 1;
2167 if (TREE_THIS_VOLATILE (newdecl))
2168 TREE_THIS_VOLATILE (olddecl) = 1;
2170 /* Merge deprecatedness. */
2171 if (TREE_DEPRECATED (newdecl))
2172 TREE_DEPRECATED (olddecl) = 1;
2174 /* If a decl is in a system header and the other isn't, keep the one on the
2175 system header. Otherwise, keep source location of definition rather than
2176 declaration and of prototype rather than non-prototype unless that
2177 prototype is built-in. */
2178 if (CODE_CONTAINS_STRUCT (TREE_CODE (olddecl), TS_DECL_WITH_VIS)
2179 && DECL_IN_SYSTEM_HEADER (olddecl)
2180 && !DECL_IN_SYSTEM_HEADER (newdecl) )
2181 DECL_SOURCE_LOCATION (newdecl) = DECL_SOURCE_LOCATION (olddecl);
2182 else if (CODE_CONTAINS_STRUCT (TREE_CODE (olddecl), TS_DECL_WITH_VIS)
2183 && DECL_IN_SYSTEM_HEADER (newdecl)
2184 && !DECL_IN_SYSTEM_HEADER (olddecl))
2185 DECL_SOURCE_LOCATION (olddecl) = DECL_SOURCE_LOCATION (newdecl);
2186 else if ((DECL_INITIAL (newdecl) == 0 && DECL_INITIAL (olddecl) != 0)
2187 || (old_is_prototype && !new_is_prototype
2188 && !C_DECL_BUILTIN_PROTOTYPE (olddecl)))
2189 DECL_SOURCE_LOCATION (newdecl) = DECL_SOURCE_LOCATION (olddecl);
2191 /* Merge the initialization information. */
2192 if (DECL_INITIAL (newdecl) == 0)
2193 DECL_INITIAL (newdecl) = DECL_INITIAL (olddecl);
2195 /* Merge the threadprivate attribute. */
2196 if (TREE_CODE (olddecl) == VAR_DECL && C_DECL_THREADPRIVATE_P (olddecl))
2198 DECL_TLS_MODEL (newdecl) = DECL_TLS_MODEL (olddecl);
2199 C_DECL_THREADPRIVATE_P (newdecl) = 1;
2202 if (CODE_CONTAINS_STRUCT (TREE_CODE (olddecl), TS_DECL_WITH_VIS))
2204 /* Merge the section attribute.
2205 We want to issue an error if the sections conflict but that
2206 must be done later in decl_attributes since we are called
2207 before attributes are assigned. */
2208 if (DECL_SECTION_NAME (newdecl) == NULL_TREE)
2209 DECL_SECTION_NAME (newdecl) = DECL_SECTION_NAME (olddecl);
2211 /* Copy the assembler name.
2212 Currently, it can only be defined in the prototype. */
2213 COPY_DECL_ASSEMBLER_NAME (olddecl, newdecl);
2215 /* Use visibility of whichever declaration had it specified */
2216 if (DECL_VISIBILITY_SPECIFIED (olddecl))
2218 DECL_VISIBILITY (newdecl) = DECL_VISIBILITY (olddecl);
2219 DECL_VISIBILITY_SPECIFIED (newdecl) = 1;
2222 if (TREE_CODE (newdecl) == FUNCTION_DECL)
2224 DECL_STATIC_CONSTRUCTOR(newdecl) |= DECL_STATIC_CONSTRUCTOR(olddecl);
2225 DECL_STATIC_DESTRUCTOR (newdecl) |= DECL_STATIC_DESTRUCTOR (olddecl);
2226 DECL_NO_LIMIT_STACK (newdecl) |= DECL_NO_LIMIT_STACK (olddecl);
2227 DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (newdecl)
2228 |= DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (olddecl);
2229 TREE_THIS_VOLATILE (newdecl) |= TREE_THIS_VOLATILE (olddecl);
2230 DECL_IS_MALLOC (newdecl) |= DECL_IS_MALLOC (olddecl);
2231 DECL_IS_OPERATOR_NEW (newdecl) |= DECL_IS_OPERATOR_NEW (olddecl);
2232 TREE_READONLY (newdecl) |= TREE_READONLY (olddecl);
2233 DECL_PURE_P (newdecl) |= DECL_PURE_P (olddecl);
2234 DECL_IS_NOVOPS (newdecl) |= DECL_IS_NOVOPS (olddecl);
2237 /* Merge the storage class information. */
2238 merge_weak (newdecl, olddecl);
2240 /* For functions, static overrides non-static. */
2241 if (TREE_CODE (newdecl) == FUNCTION_DECL)
2243 TREE_PUBLIC (newdecl) &= TREE_PUBLIC (olddecl);
2244 /* This is since we don't automatically
2245 copy the attributes of NEWDECL into OLDDECL. */
2246 TREE_PUBLIC (olddecl) = TREE_PUBLIC (newdecl);
2247 /* If this clears `static', clear it in the identifier too. */
2248 if (!TREE_PUBLIC (olddecl))
2249 TREE_PUBLIC (DECL_NAME (olddecl)) = 0;
2253 /* In c99, 'extern' declaration before (or after) 'inline' means this
2254 function is not DECL_EXTERNAL, unless 'gnu_inline' attribute
2256 if (TREE_CODE (newdecl) == FUNCTION_DECL
2257 && !flag_gnu89_inline
2258 && (DECL_DECLARED_INLINE_P (newdecl)
2259 || DECL_DECLARED_INLINE_P (olddecl))
2260 && (!DECL_DECLARED_INLINE_P (newdecl)
2261 || !DECL_DECLARED_INLINE_P (olddecl)
2262 || !DECL_EXTERNAL (olddecl))
2263 && DECL_EXTERNAL (newdecl)
2264 && !lookup_attribute ("gnu_inline", DECL_ATTRIBUTES (newdecl))
2265 && !current_function_decl)
2266 DECL_EXTERNAL (newdecl) = 0;
2268 if (DECL_EXTERNAL (newdecl))
2270 TREE_STATIC (newdecl) = TREE_STATIC (olddecl);
2271 DECL_EXTERNAL (newdecl) = DECL_EXTERNAL (olddecl);
2273 /* An extern decl does not override previous storage class. */
2274 TREE_PUBLIC (newdecl) = TREE_PUBLIC (olddecl);
2275 if (!DECL_EXTERNAL (newdecl))
2277 DECL_CONTEXT (newdecl) = DECL_CONTEXT (olddecl);
2278 DECL_COMMON (newdecl) = DECL_COMMON (olddecl);
2283 TREE_STATIC (olddecl) = TREE_STATIC (newdecl);
2284 TREE_PUBLIC (olddecl) = TREE_PUBLIC (newdecl);
2287 if (TREE_CODE (newdecl) == FUNCTION_DECL)
2289 /* If we're redefining a function previously defined as extern
2290 inline, make sure we emit debug info for the inline before we
2291 throw it away, in case it was inlined into a function that
2292 hasn't been written out yet. */
2293 if (new_is_definition && DECL_INITIAL (olddecl))
2294 /* The new defn must not be inline. */
2295 DECL_UNINLINABLE (newdecl) = 1;
2298 /* If either decl says `inline', this fn is inline, unless
2299 its definition was passed already. */
2300 if (DECL_DECLARED_INLINE_P (newdecl)
2301 || DECL_DECLARED_INLINE_P (olddecl))
2302 DECL_DECLARED_INLINE_P (newdecl) = 1;
2304 DECL_UNINLINABLE (newdecl) = DECL_UNINLINABLE (olddecl)
2305 = (DECL_UNINLINABLE (newdecl) || DECL_UNINLINABLE (olddecl));
2307 DECL_DISREGARD_INLINE_LIMITS (newdecl)
2308 = DECL_DISREGARD_INLINE_LIMITS (olddecl)
2309 = (DECL_DISREGARD_INLINE_LIMITS (newdecl)
2310 || DECL_DISREGARD_INLINE_LIMITS (olddecl));
2313 if (DECL_BUILT_IN (olddecl))
2315 /* If redeclaring a builtin function, it stays built in.
2316 But it gets tagged as having been declared. */
2317 DECL_BUILT_IN_CLASS (newdecl) = DECL_BUILT_IN_CLASS (olddecl);
2318 DECL_FUNCTION_CODE (newdecl) = DECL_FUNCTION_CODE (olddecl);
2319 C_DECL_DECLARED_BUILTIN (newdecl) = 1;
2320 if (new_is_prototype)
2321 C_DECL_BUILTIN_PROTOTYPE (newdecl) = 0;
2323 C_DECL_BUILTIN_PROTOTYPE (newdecl)
2324 = C_DECL_BUILTIN_PROTOTYPE (olddecl);
2327 /* Preserve function specific target and optimization options */
2328 if (DECL_FUNCTION_SPECIFIC_TARGET (olddecl)
2329 && !DECL_FUNCTION_SPECIFIC_TARGET (newdecl))
2330 DECL_FUNCTION_SPECIFIC_TARGET (newdecl)
2331 = DECL_FUNCTION_SPECIFIC_TARGET (olddecl);
2333 if (DECL_FUNCTION_SPECIFIC_OPTIMIZATION (olddecl)
2334 && !DECL_FUNCTION_SPECIFIC_OPTIMIZATION (newdecl))
2335 DECL_FUNCTION_SPECIFIC_OPTIMIZATION (newdecl)
2336 = DECL_FUNCTION_SPECIFIC_OPTIMIZATION (olddecl);
2338 /* Also preserve various other info from the definition. */
2339 if (!new_is_definition)
2342 DECL_RESULT (newdecl) = DECL_RESULT (olddecl);
2343 DECL_INITIAL (newdecl) = DECL_INITIAL (olddecl);
2344 DECL_STRUCT_FUNCTION (newdecl) = DECL_STRUCT_FUNCTION (olddecl);
2345 DECL_SAVED_TREE (newdecl) = DECL_SAVED_TREE (olddecl);
2346 gimple_set_body (newdecl, gimple_body (olddecl));
2347 DECL_ARGUMENTS (newdecl) = copy_list (DECL_ARGUMENTS (olddecl));
2348 for (t = DECL_ARGUMENTS (newdecl); t ; t = TREE_CHAIN (t))
2349 DECL_CONTEXT (t) = newdecl;
2351 /* See if we've got a function to instantiate from. */
2352 if (DECL_SAVED_TREE (olddecl))
2353 DECL_ABSTRACT_ORIGIN (newdecl)
2354 = DECL_ABSTRACT_ORIGIN (olddecl);
2358 extern_changed = DECL_EXTERNAL (olddecl) && !DECL_EXTERNAL (newdecl);
2360 /* Merge the USED information. */
2361 if (TREE_USED (olddecl))
2362 TREE_USED (newdecl) = 1;
2363 else if (TREE_USED (newdecl))
2364 TREE_USED (olddecl) = 1;
2366 /* Copy most of the decl-specific fields of NEWDECL into OLDDECL.
2367 But preserve OLDDECL's DECL_UID and DECL_CONTEXT. */
2369 unsigned olddecl_uid = DECL_UID (olddecl);
2370 tree olddecl_context = DECL_CONTEXT (olddecl);
2371 tree olddecl_arguments = NULL;
2372 if (TREE_CODE (olddecl) == FUNCTION_DECL)
2373 olddecl_arguments = DECL_ARGUMENTS (olddecl);
2375 memcpy ((char *) olddecl + sizeof (struct tree_common),
2376 (char *) newdecl + sizeof (struct tree_common),
2377 sizeof (struct tree_decl_common) - sizeof (struct tree_common));
2378 switch (TREE_CODE (olddecl))
2381 gimple_set_body (olddecl, gimple_body (newdecl));
2391 memcpy ((char *) olddecl + sizeof (struct tree_decl_common),
2392 (char *) newdecl + sizeof (struct tree_decl_common),
2393 tree_code_size (TREE_CODE (olddecl)) - sizeof (struct tree_decl_common));
2398 memcpy ((char *) olddecl + sizeof (struct tree_decl_common),
2399 (char *) newdecl + sizeof (struct tree_decl_common),
2400 sizeof (struct tree_decl_non_common) - sizeof (struct tree_decl_common));
2402 DECL_UID (olddecl) = olddecl_uid;
2403 DECL_CONTEXT (olddecl) = olddecl_context;
2404 if (TREE_CODE (olddecl) == FUNCTION_DECL)
2405 DECL_ARGUMENTS (olddecl) = olddecl_arguments;
2408 /* If OLDDECL had its DECL_RTL instantiated, re-invoke make_decl_rtl
2409 so that encode_section_info has a chance to look at the new decl
2410 flags and attributes. */
2411 if (DECL_RTL_SET_P (olddecl)
2412 && (TREE_CODE (olddecl) == FUNCTION_DECL
2413 || (TREE_CODE (olddecl) == VAR_DECL
2414 && TREE_STATIC (olddecl))))
2415 make_decl_rtl (olddecl);
2417 /* If we changed a function from DECL_EXTERNAL to !DECL_EXTERNAL,
2418 and the definition is coming from the old version, cgraph needs
2419 to be called again. */
2420 if (extern_changed && !new_is_definition
2421 && TREE_CODE (olddecl) == FUNCTION_DECL && DECL_INITIAL (olddecl))
2422 cgraph_mark_if_needed (olddecl);
2425 /* Handle when a new declaration NEWDECL has the same name as an old
2426 one OLDDECL in the same binding contour. Prints an error message
2429 If safely possible, alter OLDDECL to look like NEWDECL, and return
2430 true. Otherwise, return false. */
2433 duplicate_decls (tree newdecl, tree olddecl)
2435 tree newtype = NULL, oldtype = NULL;
2437 if (!diagnose_mismatched_decls (newdecl, olddecl, &newtype, &oldtype))
2439 /* Avoid `unused variable' and other warnings for OLDDECL. */
2440 TREE_NO_WARNING (olddecl) = 1;
2444 merge_decls (newdecl, olddecl, newtype, oldtype);
2449 /* Check whether decl-node NEW_DECL shadows an existing declaration. */
2451 warn_if_shadowing (tree new_decl)
2453 struct c_binding *b;
2455 /* Shadow warnings wanted? */
2457 /* No shadow warnings for internally generated vars. */
2458 || DECL_IS_BUILTIN (new_decl)
2459 /* No shadow warnings for vars made for inlining. */
2460 || DECL_FROM_INLINE (new_decl))
2463 /* Is anything being shadowed? Invisible decls do not count. */
2464 for (b = I_SYMBOL_BINDING (DECL_NAME (new_decl)); b; b = b->shadowed)
2465 if (b->decl && b->decl != new_decl && !b->invisible)
2467 tree old_decl = b->decl;
2469 if (old_decl == error_mark_node)
2471 warning (OPT_Wshadow, "declaration of %q+D shadows previous "
2472 "non-variable", new_decl);
2475 else if (TREE_CODE (old_decl) == PARM_DECL)
2476 warning (OPT_Wshadow, "declaration of %q+D shadows a parameter",
2478 else if (DECL_FILE_SCOPE_P (old_decl))
2479 warning (OPT_Wshadow, "declaration of %q+D shadows a global "
2480 "declaration", new_decl);
2481 else if (TREE_CODE (old_decl) == FUNCTION_DECL
2482 && DECL_BUILT_IN (old_decl))
2484 warning (OPT_Wshadow, "declaration of %q+D shadows "
2485 "a built-in function", new_decl);
2489 warning (OPT_Wshadow, "declaration of %q+D shadows a previous local",
2492 warning_at (DECL_SOURCE_LOCATION (old_decl), OPT_Wshadow,
2493 "shadowed declaration is here");
2499 /* Record a decl-node X as belonging to the current lexical scope.
2500 Check for errors (such as an incompatible declaration for the same
2501 name already seen in the same scope).
2503 Returns either X or an old decl for the same name.
2504 If an old decl is returned, it may have been smashed
2505 to agree with what X says. */
2510 tree name = DECL_NAME (x);
2511 struct c_scope *scope = current_scope;
2512 struct c_binding *b;
2513 bool nested = false;
2514 location_t locus = DECL_SOURCE_LOCATION (x);
2516 /* Must set DECL_CONTEXT for everything not at file scope or
2517 DECL_FILE_SCOPE_P won't work. Local externs don't count
2518 unless they have initializers (which generate code). */
2519 if (current_function_decl
2520 && ((TREE_CODE (x) != FUNCTION_DECL && TREE_CODE (x) != VAR_DECL)
2521 || DECL_INITIAL (x) || !DECL_EXTERNAL (x)))
2522 DECL_CONTEXT (x) = current_function_decl;
2524 /* Anonymous decls are just inserted in the scope. */
2527 bind (name, x, scope, /*invisible=*/false, /*nested=*/false,
2532 /* First, see if there is another declaration with the same name in
2533 the current scope. If there is, duplicate_decls may do all the
2534 work for us. If duplicate_decls returns false, that indicates
2535 two incompatible decls in the same scope; we are to silently
2536 replace the old one (duplicate_decls has issued all appropriate
2537 diagnostics). In particular, we should not consider possible
2538 duplicates in the external scope, or shadowing. */
2539 b = I_SYMBOL_BINDING (name);
2540 if (b && B_IN_SCOPE (b, scope))
2542 struct c_binding *b_ext, *b_use;
2543 tree type = TREE_TYPE (x);
2544 tree visdecl = b->decl;
2545 tree vistype = TREE_TYPE (visdecl);
2546 if (TREE_CODE (TREE_TYPE (x)) == ARRAY_TYPE
2547 && COMPLETE_TYPE_P (TREE_TYPE (x)))
2548 b->inner_comp = false;
2551 /* If this is an external linkage declaration, we should check
2552 for compatibility with the type in the external scope before
2553 setting the type at this scope based on the visible
2554 information only. */
2555 if (TREE_PUBLIC (x) && TREE_PUBLIC (visdecl))
2557 while (b_ext && !B_IN_EXTERNAL_SCOPE (b_ext))
2558 b_ext = b_ext->shadowed;
2563 TREE_TYPE (b_use->decl) = b_use->u.type;
2566 if (duplicate_decls (x, b_use->decl))
2570 /* Save the updated type in the external scope and
2571 restore the proper type for this scope. */
2573 if (comptypes (vistype, type))
2574 thistype = composite_type (vistype, type);
2576 thistype = TREE_TYPE (b_use->decl);
2577 b_use->u.type = TREE_TYPE (b_use->decl);
2578 if (TREE_CODE (b_use->decl) == FUNCTION_DECL
2579 && DECL_BUILT_IN (b_use->decl))
2581 = build_type_attribute_variant (thistype,
2584 TREE_TYPE (b_use->decl) = thistype;
2589 goto skip_external_and_shadow_checks;
2592 /* All declarations with external linkage, and all external
2593 references, go in the external scope, no matter what scope is
2594 current. However, the binding in that scope is ignored for
2595 purposes of normal name lookup. A separate binding structure is
2596 created in the requested scope; this governs the normal
2597 visibility of the symbol.
2599 The binding in the externals scope is used exclusively for
2600 detecting duplicate declarations of the same object, no matter
2601 what scope they are in; this is what we do here. (C99 6.2.7p2:
2602 All declarations that refer to the same object or function shall
2603 have compatible type; otherwise, the behavior is undefined.) */
2604 if (DECL_EXTERNAL (x) || scope == file_scope)
2606 tree type = TREE_TYPE (x);
2609 bool type_saved = false;
2610 if (b && !B_IN_EXTERNAL_SCOPE (b)
2611 && (TREE_CODE (b->decl) == FUNCTION_DECL
2612 || TREE_CODE (b->decl) == VAR_DECL)
2613 && DECL_FILE_SCOPE_P (b->decl))
2616 vistype = TREE_TYPE (visdecl);
2618 if (scope != file_scope
2619 && !DECL_IN_SYSTEM_HEADER (x))
2620 warning (OPT_Wnested_externs, "nested extern declaration of %qD", x);
2622 while (b && !B_IN_EXTERNAL_SCOPE (b))
2624 /* If this decl might be modified, save its type. This is
2625 done here rather than when the decl is first bound
2626 because the type may change after first binding, through
2627 being completed or through attributes being added. If we
2628 encounter multiple such decls, only the first should have
2629 its type saved; the others will already have had their
2630 proper types saved and the types will not have changed as
2631 their scopes will not have been re-entered. */
2632 if (DECL_P (b->decl) && DECL_FILE_SCOPE_P (b->decl) && !type_saved)
2634 b->u.type = TREE_TYPE (b->decl);
2637 if (B_IN_FILE_SCOPE (b)
2638 && TREE_CODE (b->decl) == VAR_DECL
2639 && TREE_STATIC (b->decl)
2640 && TREE_CODE (TREE_TYPE (b->decl)) == ARRAY_TYPE
2641 && !TYPE_DOMAIN (TREE_TYPE (b->decl))
2642 && TREE_CODE (type) == ARRAY_TYPE
2643 && TYPE_DOMAIN (type)
2644 && TYPE_MAX_VALUE (TYPE_DOMAIN (type))
2645 && !integer_zerop (TYPE_MAX_VALUE (TYPE_DOMAIN (type))))
2647 /* Array type completed in inner scope, which should be
2648 diagnosed if the completion does not have size 1 and
2649 it does not get completed in the file scope. */
2650 b->inner_comp = true;
2655 /* If a matching external declaration has been found, set its
2656 type to the composite of all the types of that declaration.
2657 After the consistency checks, it will be reset to the
2658 composite of the visible types only. */
2659 if (b && (TREE_PUBLIC (x) || same_translation_unit_p (x, b->decl))
2661 TREE_TYPE (b->decl) = b->u.type;
2663 /* The point of the same_translation_unit_p check here is,
2664 we want to detect a duplicate decl for a construct like
2665 foo() { extern bar(); } ... static bar(); but not if
2666 they are in different translation units. In any case,
2667 the static does not go in the externals scope. */
2669 && (TREE_PUBLIC (x) || same_translation_unit_p (x, b->decl))
2670 && duplicate_decls (x, b->decl))
2675 if (comptypes (vistype, type))
2676 thistype = composite_type (vistype, type);
2678 thistype = TREE_TYPE (b->decl);
2682 b->u.type = TREE_TYPE (b->decl);
2683 if (TREE_CODE (b->decl) == FUNCTION_DECL && DECL_BUILT_IN (b->decl))
2685 = build_type_attribute_variant (thistype,
2686 TYPE_ATTRIBUTES (b->u.type));
2687 TREE_TYPE (b->decl) = thistype;
2688 bind (name, b->decl, scope, /*invisible=*/false, /*nested=*/true,
2692 else if (TREE_PUBLIC (x))
2694 if (visdecl && !b && duplicate_decls (x, visdecl))
2696 /* An external declaration at block scope referring to a
2697 visible entity with internal linkage. The composite
2698 type will already be correct for this scope, so we
2699 just need to fall through to make the declaration in
2706 bind (name, x, external_scope, /*invisible=*/true,
2707 /*nested=*/false, locus);
2713 if (TREE_CODE (x) != PARM_DECL)
2714 warn_if_shadowing (x);
2716 skip_external_and_shadow_checks:
2717 if (TREE_CODE (x) == TYPE_DECL)
2718 set_underlying_type (x);
2720 bind (name, x, scope, /*invisible=*/false, nested, locus);
2722 /* If x's type is incomplete because it's based on a
2723 structure or union which has not yet been fully declared,
2724 attach it to that structure or union type, so we can go
2725 back and complete the variable declaration later, if the
2726 structure or union gets fully declared.
2728 If the input is erroneous, we can have error_mark in the type
2729 slot (e.g. "f(void a, ...)") - that doesn't count as an
2731 if (TREE_TYPE (x) != error_mark_node
2732 && !COMPLETE_TYPE_P (TREE_TYPE (x)))
2734 tree element = TREE_TYPE (x);
2736 while (TREE_CODE (element) == ARRAY_TYPE)
2737 element = TREE_TYPE (element);
2738 element = TYPE_MAIN_VARIANT (element);
2740 if ((TREE_CODE (element) == RECORD_TYPE
2741 || TREE_CODE (element) == UNION_TYPE)
2742 && (TREE_CODE (x) != TYPE_DECL
2743 || TREE_CODE (TREE_TYPE (x)) == ARRAY_TYPE)
2744 && !COMPLETE_TYPE_P (element))
2745 C_TYPE_INCOMPLETE_VARS (element)
2746 = tree_cons (NULL_TREE, x, C_TYPE_INCOMPLETE_VARS (element));
2751 /* Record X as belonging to file scope.
2752 This is used only internally by the Objective-C front end,
2753 and is limited to its needs. duplicate_decls is not called;
2754 if there is any preexisting decl for this identifier, it is an ICE. */
2757 pushdecl_top_level (tree x)
2760 bool nested = false;
2761 gcc_assert (TREE_CODE (x) == VAR_DECL || TREE_CODE (x) == CONST_DECL);
2763 name = DECL_NAME (x);
2765 gcc_assert (TREE_CODE (x) == CONST_DECL || !I_SYMBOL_BINDING (name));
2767 if (TREE_PUBLIC (x))
2769 bind (name, x, external_scope, /*invisible=*/true, /*nested=*/false,
2774 bind (name, x, file_scope, /*invisible=*/false, nested, UNKNOWN_LOCATION);
2780 implicit_decl_warning (tree id, tree olddecl)
2782 if (warn_implicit_function_declaration)
2787 warned = pedwarn (input_location, OPT_Wimplicit_function_declaration,
2788 "implicit declaration of function %qE", id);
2790 warned = warning (OPT_Wimplicit_function_declaration,
2791 G_("implicit declaration of function %qE"), id);
2792 if (olddecl && warned)
2793 locate_old_decl (olddecl);
2797 /* Generate an implicit declaration for identifier FUNCTIONID at LOC as a
2798 function of type int (). */
2801 implicitly_declare (location_t loc, tree functionid)
2803 struct c_binding *b;
2807 for (b = I_SYMBOL_BINDING (functionid); b; b = b->shadowed)
2809 if (B_IN_SCOPE (b, external_scope))
2818 if (decl == error_mark_node)
2821 /* FIXME: Objective-C has weird not-really-builtin functions
2822 which are supposed to be visible automatically. They wind up
2823 in the external scope because they're pushed before the file
2824 scope gets created. Catch this here and rebind them into the
2826 if (!DECL_BUILT_IN (decl) && DECL_IS_BUILTIN (decl))
2828 bind (functionid, decl, file_scope,
2829 /*invisible=*/false, /*nested=*/true,
2830 DECL_SOURCE_LOCATION (decl));
2835 tree newtype = default_function_type;
2837 TREE_TYPE (decl) = b->u.type;
2838 /* Implicit declaration of a function already declared
2839 (somehow) in a different scope, or as a built-in.
2840 If this is the first time this has happened, warn;
2841 then recycle the old declaration but with the new type. */
2842 if (!C_DECL_IMPLICIT (decl))
2844 implicit_decl_warning (functionid, decl);
2845 C_DECL_IMPLICIT (decl) = 1;
2847 if (DECL_BUILT_IN (decl))
2849 newtype = build_type_attribute_variant (newtype,
2851 (TREE_TYPE (decl)));
2852 if (!comptypes (newtype, TREE_TYPE (decl)))
2854 warning_at (loc, 0, "incompatible implicit declaration of "
2855 "built-in function %qD", decl);
2856 newtype = TREE_TYPE (decl);
2861 if (!comptypes (newtype, TREE_TYPE (decl)))
2863 error_at (loc, "incompatible implicit declaration of function %qD", decl);
2864 locate_old_decl (decl);
2867 b->u.type = TREE_TYPE (decl);
2868 TREE_TYPE (decl) = newtype;
2869 bind (functionid, decl, current_scope,
2870 /*invisible=*/false, /*nested=*/true,
2871 DECL_SOURCE_LOCATION (decl));
2876 /* Not seen before. */
2877 decl = build_decl (loc, FUNCTION_DECL, functionid, default_function_type);
2878 DECL_EXTERNAL (decl) = 1;
2879 TREE_PUBLIC (decl) = 1;
2880 C_DECL_IMPLICIT (decl) = 1;
2881 implicit_decl_warning (functionid, 0);
2882 asmspec_tree = maybe_apply_renaming_pragma (decl, /*asmname=*/NULL);
2884 set_user_assembler_name (decl, TREE_STRING_POINTER (asmspec_tree));
2886 /* C89 says implicit declarations are in the innermost block.
2887 So we record the decl in the standard fashion. */
2888 decl = pushdecl (decl);
2890 /* No need to call objc_check_decl here - it's a function type. */
2891 rest_of_decl_compilation (decl, 0, 0);
2893 /* Write a record describing this implicit function declaration
2894 to the prototypes file (if requested). */
2895 gen_aux_info_record (decl, 0, 1, 0);
2897 /* Possibly apply some default attributes to this implicit declaration. */
2898 decl_attributes (&decl, NULL_TREE, 0);
2903 /* Issue an error message for a reference to an undeclared variable
2904 ID, including a reference to a builtin outside of function-call
2905 context. Establish a binding of the identifier to error_mark_node
2906 in an appropriate scope, which will suppress further errors for the
2907 same identifier. The error message should be given location LOC. */
2909 undeclared_variable (location_t loc, tree id)
2911 static bool already = false;
2912 struct c_scope *scope;
2914 if (current_function_decl == 0)
2916 error_at (loc, "%qE undeclared here (not in a function)", id);
2917 scope = current_scope;
2921 error_at (loc, "%qE undeclared (first use in this function)", id);
2925 error_at (loc, "(Each undeclared identifier is reported only once");
2926 error_at (loc, "for each function it appears in.)");
2930 /* If we are parsing old-style parameter decls, current_function_decl
2931 will be nonnull but current_function_scope will be null. */
2932 scope = current_function_scope ? current_function_scope : current_scope;
2934 bind (id, error_mark_node, scope, /*invisible=*/false, /*nested=*/false,
2938 /* Subroutine of lookup_label, declare_label, define_label: construct a
2939 LABEL_DECL with all the proper frills. Also create a struct
2940 c_label_vars initialized for the current scope. */
2943 make_label (location_t location, tree name, bool defining,
2944 struct c_label_vars **p_label_vars)
2946 tree label = build_decl (location, LABEL_DECL, name, void_type_node);
2947 struct c_label_vars *label_vars;
2949 DECL_CONTEXT (label) = current_function_decl;
2950 DECL_MODE (label) = VOIDmode;
2952 label_vars = GGC_NEW (struct c_label_vars);
2953 label_vars->shadowed = NULL;
2954 set_spot_bindings (&label_vars->label_bindings, defining);
2955 label_vars->decls_in_scope = make_tree_vector ();
2956 label_vars->gotos = VEC_alloc (c_goto_bindings_p, gc, 0);
2957 *p_label_vars = label_vars;
2962 /* Get the LABEL_DECL corresponding to identifier NAME as a label.
2963 Create one if none exists so far for the current function.
2964 This is called when a label is used in a goto expression or
2965 has its address taken. */
2968 lookup_label (tree name)
2971 struct c_label_vars *label_vars;
2973 if (current_function_decl == 0)
2975 error ("label %qE referenced outside of any function", name);
2979 /* Use a label already defined or ref'd with this name, but not if
2980 it is inherited from a containing function and wasn't declared
2982 label = I_LABEL_DECL (name);
2983 if (label && (DECL_CONTEXT (label) == current_function_decl
2984 || C_DECLARED_LABEL_FLAG (label)))
2986 /* If the label has only been declared, update its apparent
2987 location to point here, for better diagnostics if it
2988 turns out not to have been defined. */
2989 if (DECL_INITIAL (label) == NULL_TREE)
2990 DECL_SOURCE_LOCATION (label) = input_location;
2994 /* No label binding for that identifier; make one. */
2995 label = make_label (input_location, name, false, &label_vars);
2997 /* Ordinary labels go in the current function scope. */
2998 bind_label (name, label, current_function_scope, label_vars);
3003 /* Issue a warning about DECL for a goto statement at GOTO_LOC going
3007 warn_about_goto (location_t goto_loc, tree label, tree decl)
3009 if (variably_modified_type_p (TREE_TYPE (decl), NULL_TREE))
3011 "jump into scope of identifier with variably modified type");
3013 warning_at (goto_loc, OPT_Wjump_misses_init,
3014 "jump skips variable initialization");
3015 inform (DECL_SOURCE_LOCATION (label), "label %qD defined here", label);
3016 inform (DECL_SOURCE_LOCATION (decl), "%qD declared here", decl);
3019 /* Look up a label because of a goto statement. This is like
3020 lookup_label, but also issues any appropriate warnings. */
3023 lookup_label_for_goto (location_t loc, tree name)
3026 struct c_label_vars *label_vars;
3030 label = lookup_label (name);
3031 if (label == NULL_TREE)
3034 /* If we are jumping to a different function, we can't issue any
3036 if (DECL_CONTEXT (label) != current_function_decl)
3038 gcc_assert (C_DECLARED_LABEL_FLAG (label));
3042 label_vars = I_LABEL_BINDING (name)->u.label;
3044 /* If the label has not yet been defined, then push this goto on a
3045 list for possible later warnings. */
3046 if (label_vars->label_bindings.scope == NULL)
3048 struct c_goto_bindings *g;
3050 g = GGC_NEW (struct c_goto_bindings);
3052 set_spot_bindings (&g->goto_bindings, true);
3053 VEC_safe_push (c_goto_bindings_p, gc, label_vars->gotos, g);
3057 /* If there are any decls in label_vars->decls_in_scope, then this
3058 goto has missed the declaration of the decl. This happens for a
3064 Issue a warning or error. */
3065 for (ix = 0; VEC_iterate (tree, label_vars->decls_in_scope, ix, decl); ++ix)
3066 warn_about_goto (loc, label, decl);
3068 if (label_vars->label_bindings.left_stmt_expr)
3070 error_at (loc, "jump into statement expression");
3071 inform (DECL_SOURCE_LOCATION (label), "label %qD defined here", label);
3077 /* Make a label named NAME in the current function, shadowing silently
3078 any that may be inherited from containing functions or containing
3079 scopes. This is called for __label__ declarations. */
3082 declare_label (tree name)
3084 struct c_binding *b = I_LABEL_BINDING (name);
3086 struct c_label_vars *label_vars;
3088 /* Check to make sure that the label hasn't already been declared
3090 if (b && B_IN_CURRENT_SCOPE (b))
3092 error ("duplicate label declaration %qE", name);
3093 locate_old_decl (b->decl);
3095 /* Just use the previous declaration. */
3099 label = make_label (input_location, name, false, &label_vars);
3100 C_DECLARED_LABEL_FLAG (label) = 1;
3102 /* Declared labels go in the current scope. */
3103 bind_label (name, label, current_scope, label_vars);
3108 /* When we define a label, issue any appropriate warnings if there are
3109 any gotos earlier in the function which jump to this label. */
3112 check_earlier_gotos (tree label, struct c_label_vars* label_vars)
3115 struct c_goto_bindings *g;
3118 VEC_iterate (c_goto_bindings_p, label_vars->gotos, ix, g);
3121 struct c_binding *b;
3122 struct c_scope *scope;
3124 /* We have a goto to this label. The goto is going forward. In
3125 g->scope, the goto is going to skip any binding which was
3126 defined after g->bindings_in_scope. */
3127 for (b = g->goto_bindings.scope->bindings;
3128 b != g->goto_bindings.bindings_in_scope;
3131 if (decl_jump_unsafe (b->decl))
3132 warn_about_goto (g->loc, label, b->decl);
3135 /* We also need to warn about decls defined in any scopes
3136 between the scope of the label and the scope of the goto. */
3137 for (scope = label_vars->label_bindings.scope;
3138 scope != g->goto_bindings.scope;
3139 scope = scope->outer)
3141 gcc_assert (scope != NULL);
3142 if (scope == label_vars->label_bindings.scope)
3143 b = label_vars->label_bindings.bindings_in_scope;
3145 b = scope->bindings;
3146 for (; b != NULL; b = b->prev)
3148 if (decl_jump_unsafe (b->decl))
3149 warn_about_goto (g->loc, label, b->decl);
3153 if (g->goto_bindings.stmt_exprs > 0)
3155 error_at (g->loc, "jump into statement expression");
3156 inform (DECL_SOURCE_LOCATION (label), "label %qD defined here",
3161 /* Now that the label is defined, we will issue warnings about
3162 subsequent gotos to this label when we see them. */
3163 VEC_truncate (c_goto_bindings_p, label_vars->gotos, 0);
3164 label_vars->gotos = NULL;
3167 /* Define a label, specifying the location in the source file.
3168 Return the LABEL_DECL node for the label, if the definition is valid.
3169 Otherwise return 0. */
3172 define_label (location_t location, tree name)
3174 /* Find any preexisting label with this name. It is an error
3175 if that label has already been defined in this function, or
3176 if there is a containing function with a declared label with
3178 tree label = I_LABEL_DECL (name);
3181 && ((DECL_CONTEXT (label) == current_function_decl
3182 && DECL_INITIAL (label) != 0)
3183 || (DECL_CONTEXT (label) != current_function_decl
3184 && C_DECLARED_LABEL_FLAG (label))))
3186 error_at (location, "duplicate label %qD", label);
3187 locate_old_decl (label);
3190 else if (label && DECL_CONTEXT (label) == current_function_decl)
3192 struct c_label_vars *label_vars = I_LABEL_BINDING (name)->u.label;
3194 /* The label has been used or declared already in this function,
3195 but not defined. Update its location to point to this
3197 DECL_SOURCE_LOCATION (label) = location;
3198 set_spot_bindings (&label_vars->label_bindings, true);
3200 /* Issue warnings as required about any goto statements from
3201 earlier in the function. */
3202 check_earlier_gotos (label, label_vars);
3206 struct c_label_vars *label_vars;
3208 /* No label binding for that identifier; make one. */
3209 label = make_label (location, name, true, &label_vars);
3211 /* Ordinary labels go in the current function scope. */
3212 bind_label (name, label, current_function_scope, label_vars);
3215 if (!in_system_header && lookup_name (name))
3216 warning_at (location, OPT_Wtraditional,
3217 "traditional C lacks a separate namespace "
3218 "for labels, identifier %qE conflicts", name);
3220 /* Mark label as having been defined. */
3221 DECL_INITIAL (label) = error_mark_node;
3225 /* Get the bindings for a new switch statement. This is used to issue
3226 warnings as appropriate for jumps from the switch to case or
3229 struct c_spot_bindings *
3230 c_get_switch_bindings (void)
3232 struct c_spot_bindings *switch_bindings;
3234 switch_bindings = XNEW (struct c_spot_bindings);
3235 set_spot_bindings (switch_bindings, true);
3236 return switch_bindings;
3240 c_release_switch_bindings (struct c_spot_bindings *bindings)
3242 gcc_assert (bindings->stmt_exprs == 0 && !bindings->left_stmt_expr);
3246 /* This is called at the point of a case or default label to issue
3247 warnings about decls as needed. It returns true if it found an
3248 error, not just a warning. */
3251 c_check_switch_jump_warnings (struct c_spot_bindings *switch_bindings,
3252 location_t switch_loc, location_t case_loc)
3255 struct c_scope *scope;
3258 for (scope = current_scope;
3259 scope != switch_bindings->scope;
3260 scope = scope->outer)
3262 struct c_binding *b;
3264 gcc_assert (scope != NULL);
3265 for (b = scope->bindings; b != NULL; b = b->prev)
3267 if (decl_jump_unsafe (b->decl))
3269 if (variably_modified_type_p (TREE_TYPE (b->decl), NULL_TREE))
3273 ("switch jumps into scope of identifier with "
3274 "variably modified type"));
3277 warning_at (case_loc, OPT_Wjump_misses_init,
3278 "switch jumps over variable initialization");
3279 inform (switch_loc, "switch starts here");
3280 inform (DECL_SOURCE_LOCATION (b->decl), "%qD declared here",
3286 if (switch_bindings->stmt_exprs > 0)
3289 error_at (case_loc, "switch jumps into statement expression");
3290 inform (switch_loc, "switch starts here");
3296 /* Given NAME, an IDENTIFIER_NODE,
3297 return the structure (or union or enum) definition for that name.
3298 If THISLEVEL_ONLY is nonzero, searches only the current_scope.
3299 CODE says which kind of type the caller wants;
3300 it is RECORD_TYPE or UNION_TYPE or ENUMERAL_TYPE.
3301 If PLOC is not NULL and this returns non-null, it sets *PLOC to the
3302 location where the tag was defined.
3303 If the wrong kind of type is found, an error is reported. */
3306 lookup_tag (enum tree_code code, tree name, int thislevel_only,
3309 struct c_binding *b = I_TAG_BINDING (name);
3315 /* We only care about whether it's in this level if
3316 thislevel_only was set or it might be a type clash. */
3317 if (thislevel_only || TREE_CODE (b->decl) != code)
3319 /* For our purposes, a tag in the external scope is the same as
3320 a tag in the file scope. (Primarily relevant to Objective-C
3321 and its builtin structure tags, which get pushed before the
3322 file scope is created.) */
3323 if (B_IN_CURRENT_SCOPE (b)
3324 || (current_scope == file_scope && B_IN_EXTERNAL_SCOPE (b)))
3328 if (thislevel_only && !thislevel)
3331 if (TREE_CODE (b->decl) != code)
3333 /* Definition isn't the kind we were looking for. */
3334 pending_invalid_xref = name;
3335 pending_invalid_xref_location = input_location;
3337 /* If in the same binding level as a declaration as a tag
3338 of a different type, this must not be allowed to
3339 shadow that tag, so give the error immediately.
3340 (For example, "struct foo; union foo;" is invalid.) */
3342 pending_xref_error ();
3351 /* Print an error message now
3352 for a recent invalid struct, union or enum cross reference.
3353 We don't print them immediately because they are not invalid
3354 when used in the `struct foo;' construct for shadowing. */
3357 pending_xref_error (void)
3359 if (pending_invalid_xref != 0)
3360 error_at (pending_invalid_xref_location, "%qE defined as wrong kind of tag",
3361 pending_invalid_xref);
3362 pending_invalid_xref = 0;
3366 /* Look up NAME in the current scope and its superiors
3367 in the namespace of variables, functions and typedefs.
3368 Return a ..._DECL node of some kind representing its definition,
3369 or return 0 if it is undefined. */
3372 lookup_name (tree name)
3374 struct c_binding *b = I_SYMBOL_BINDING (name);
3375 if (b && !b->invisible)
3380 /* Similar to `lookup_name' but look only at the indicated scope. */
3383 lookup_name_in_scope (tree name, struct c_scope *scope)
3385 struct c_binding *b;
3387 for (b = I_SYMBOL_BINDING (name); b; b = b->shadowed)
3388 if (B_IN_SCOPE (b, scope))
3393 /* Create the predefined scalar types of C,
3394 and some nodes representing standard constants (0, 1, (void *) 0).
3395 Initialize the global scope.
3396 Make definitions for built-in primitive functions. */
3399 c_init_decl_processing (void)
3401 location_t save_loc = input_location;
3403 /* Initialize reserved words for parser. */
3406 current_function_decl = 0;
3408 gcc_obstack_init (&parser_obstack);
3410 /* Make the externals scope. */
3412 external_scope = current_scope;
3414 /* Declarations from c_common_nodes_and_builtins must not be associated
3415 with this input file, lest we get differences between using and not
3416 using preprocessed headers. */
3417 input_location = BUILTINS_LOCATION;
3419 build_common_tree_nodes (flag_signed_char, false);
3421 c_common_nodes_and_builtins ();
3423 /* In C, comparisons and TRUTH_* expressions have type int. */
3424 truthvalue_type_node = integer_type_node;
3425 truthvalue_true_node = integer_one_node;
3426 truthvalue_false_node = integer_zero_node;
3428 /* Even in C99, which has a real boolean type. */
3429 pushdecl (build_decl (UNKNOWN_LOCATION, TYPE_DECL, get_identifier ("_Bool"),
3430 boolean_type_node));
3432 input_location = save_loc;
3434 pedantic_lvalues = true;
3436 make_fname_decl = c_make_fname_decl;
3437 start_fname_decls ();
3440 /* Create the VAR_DECL at LOC for __FUNCTION__ etc. ID is the name to
3441 give the decl, NAME is the initialization string and TYPE_DEP
3442 indicates whether NAME depended on the type of the function. As we
3443 don't yet implement delayed emission of static data, we mark the
3444 decl as emitted so it is not placed in the output. Anything using
3445 it must therefore pull out the STRING_CST initializer directly.
3449 c_make_fname_decl (location_t loc, tree id, int type_dep)
3451 const char *name = fname_as_string (type_dep);
3452 tree decl, type, init;
3453 size_t length = strlen (name);
3455 type = build_array_type (char_type_node,
3456 build_index_type (size_int (length)));
3457 type = c_build_qualified_type (type, TYPE_QUAL_CONST);
3459 decl = build_decl (loc, VAR_DECL, id, type);
3461 TREE_STATIC (decl) = 1;
3462 TREE_READONLY (decl) = 1;
3463 DECL_ARTIFICIAL (decl) = 1;
3465 init = build_string (length + 1, name);
3466 free (CONST_CAST (char *, name));
3467 TREE_TYPE (init) = type;
3468 DECL_INITIAL (decl) = init;
3470 TREE_USED (decl) = 1;
3472 if (current_function_decl
3473 /* For invalid programs like this:
3476 const char* p = __FUNCTION__;
3478 the __FUNCTION__ is believed to appear in K&R style function
3479 parameter declarator. In that case we still don't have
3481 && (!errorcount || current_function_scope))
3483 DECL_CONTEXT (decl) = current_function_decl;
3484 bind (id, decl, current_function_scope,
3485 /*invisible=*/false, /*nested=*/false, UNKNOWN_LOCATION);
3488 finish_decl (decl, loc, init, NULL_TREE, NULL_TREE);
3494 c_builtin_function (tree decl)
3496 tree type = TREE_TYPE (decl);
3497 tree id = DECL_NAME (decl);
3499 const char *name = IDENTIFIER_POINTER (id);
3500 C_DECL_BUILTIN_PROTOTYPE (decl) = (TYPE_ARG_TYPES (type) != 0);
3502 /* Should never be called on a symbol with a preexisting meaning. */
3503 gcc_assert (!I_SYMBOL_BINDING (id));
3505 bind (id, decl, external_scope, /*invisible=*/true, /*nested=*/false,
3508 /* Builtins in the implementation namespace are made visible without
3509 needing to be explicitly declared. See push_file_scope. */
3510 if (name[0] == '_' && (name[1] == '_' || ISUPPER (name[1])))
3512 TREE_CHAIN (decl) = visible_builtins;
3513 visible_builtins = decl;
3520 c_builtin_function_ext_scope (tree decl)
3522 tree type = TREE_TYPE (decl);
3523 tree id = DECL_NAME (decl);
3525 const char *name = IDENTIFIER_POINTER (id);
3526 C_DECL_BUILTIN_PROTOTYPE (decl) = (TYPE_ARG_TYPES (type) != 0);
3528 /* Should never be called on a symbol with a preexisting meaning. */
3529 gcc_assert (!I_SYMBOL_BINDING (id));
3531 bind (id, decl, external_scope, /*invisible=*/false, /*nested=*/false,
3534 /* Builtins in the implementation namespace are made visible without
3535 needing to be explicitly declared. See push_file_scope. */
3536 if (name[0] == '_' && (name[1] == '_' || ISUPPER (name[1])))
3538 TREE_CHAIN (decl) = visible_builtins;
3539 visible_builtins = decl;
3545 /* Called when a declaration is seen that contains no names to declare.
3546 If its type is a reference to a structure, union or enum inherited
3547 from a containing scope, shadow that tag name for the current scope
3548 with a forward reference.
3549 If its type defines a new named structure or union
3550 or defines an enum, it is valid but we need not do anything here.
3551 Otherwise, it is an error. */
3554 shadow_tag (const struct c_declspecs *declspecs)
3556 shadow_tag_warned (declspecs, 0);
3559 /* WARNED is 1 if we have done a pedwarn, 2 if we have done a warning,
3562 shadow_tag_warned (const struct c_declspecs *declspecs, int warned)
3564 bool found_tag = false;
3566 if (declspecs->type && !declspecs->default_int_p && !declspecs->typedef_p)
3568 tree value = declspecs->type;
3569 enum tree_code code = TREE_CODE (value);
3571 if (code == RECORD_TYPE || code == UNION_TYPE || code == ENUMERAL_TYPE)
3572 /* Used to test also that TYPE_SIZE (value) != 0.
3573 That caused warning for `struct foo;' at top level in the file. */
3575 tree name = TYPE_NAME (value);
3580 if (declspecs->restrict_p)
3582 error ("invalid use of %<restrict%>");
3588 if (warned != 1 && code != ENUMERAL_TYPE)
3589 /* Empty unnamed enum OK */
3591 pedwarn (input_location, 0,
3592 "unnamed struct/union that defines no instances");
3596 else if (!declspecs->tag_defined_p
3597 && declspecs->storage_class != csc_none)
3600 pedwarn (input_location, 0,
3601 "empty declaration with storage class specifier "
3602 "does not redeclare tag");
3604 pending_xref_error ();
3606 else if (!declspecs->tag_defined_p
3607 && (declspecs->const_p
3608 || declspecs->volatile_p
3609 || declspecs->restrict_p))
3612 pedwarn (input_location, 0,
3613 "empty declaration with type qualifier "
3614 "does not redeclare tag");
3616 pending_xref_error ();
3620 pending_invalid_xref = 0;
3621 t = lookup_tag (code, name, 1, NULL);
3625 t = make_node (code);
3626 pushtag (input_location, name, t);
3632 if (warned != 1 && !in_system_header)
3634 pedwarn (input_location, 0,
3635 "useless type name in empty declaration");
3640 else if (warned != 1 && !in_system_header && declspecs->typedef_p)
3642 pedwarn (input_location, 0, "useless type name in empty declaration");
3646 pending_invalid_xref = 0;
3648 if (declspecs->inline_p)
3650 error ("%<inline%> in empty declaration");
3654 if (current_scope == file_scope && declspecs->storage_class == csc_auto)
3656 error ("%<auto%> in file-scope empty declaration");
3660 if (current_scope == file_scope && declspecs->storage_class == csc_register)
3662 error ("%<register%> in file-scope empty declaration");
3666 if (!warned && !in_system_header && declspecs->storage_class != csc_none)
3668 warning (0, "useless storage class specifier in empty declaration");
3672 if (!warned && !in_system_header && declspecs->thread_p)
3674 warning (0, "useless %<__thread%> in empty declaration");
3678 if (!warned && !in_system_header && (declspecs->const_p
3679 || declspecs->volatile_p
3680 || declspecs->restrict_p))
3682 warning (0, "useless type qualifier in empty declaration");
3689 pedwarn (input_location, 0, "empty declaration");
3694 /* Return the qualifiers from SPECS as a bitwise OR of TYPE_QUAL_*
3695 bits. SPECS represents declaration specifiers that the grammar
3696 only permits to contain type qualifiers and attributes. */
3699 quals_from_declspecs (const struct c_declspecs *specs)
3701 int quals = ((specs->const_p ? TYPE_QUAL_CONST : 0)
3702 | (specs->volatile_p ? TYPE_QUAL_VOLATILE : 0)
3703 | (specs->restrict_p ? TYPE_QUAL_RESTRICT : 0));
3704 gcc_assert (!specs->type
3705 && !specs->decl_attr
3706 && specs->typespec_word == cts_none
3707 && specs->storage_class == csc_none
3708 && !specs->typedef_p
3709 && !specs->explicit_signed_p
3710 && !specs->deprecated_p
3712 && !specs->long_long_p
3715 && !specs->unsigned_p
3716 && !specs->complex_p
3718 && !specs->thread_p);
3722 /* Construct an array declarator. LOC is the location of the
3723 beginning of the array (usually the opening brace). EXPR is the
3724 expression inside [], or NULL_TREE. QUALS are the type qualifiers
3725 inside the [] (to be applied to the pointer to which a parameter
3726 array is converted). STATIC_P is true if "static" is inside the
3727 [], false otherwise. VLA_UNSPEC_P is true if the array is [*], a
3728 VLA of unspecified length which is nevertheless a complete type,
3729 false otherwise. The field for the contained declarator is left to
3730 be filled in by set_array_declarator_inner. */
3732 struct c_declarator *
3733 build_array_declarator (location_t loc,
3734 tree expr, struct c_declspecs *quals, bool static_p,
3737 struct c_declarator *declarator = XOBNEW (&parser_obstack,
3738 struct c_declarator);
3739 declarator->id_loc = loc;
3740 declarator->kind = cdk_array;
3741 declarator->declarator = 0;
3742 declarator->u.array.dimen = expr;
3745 declarator->u.array.attrs = quals->attrs;
3746 declarator->u.array.quals = quals_from_declspecs (quals);
3750 declarator->u.array.attrs = NULL_TREE;
3751 declarator->u.array.quals = 0;
3753 declarator->u.array.static_p = static_p;
3754 declarator->u.array.vla_unspec_p = vla_unspec_p;
3757 if (static_p || quals != NULL)
3758 pedwarn (loc, OPT_pedantic,
3759 "ISO C90 does not support %<static%> or type "
3760 "qualifiers in parameter array declarators");
3762 pedwarn (loc, OPT_pedantic,
3763 "ISO C90 does not support %<[*]%> array declarators");
3767 if (!current_scope->parm_flag)
3770 error_at (loc, "%<[*]%> not allowed in other than "
3771 "function prototype scope");
3772 declarator->u.array.vla_unspec_p = false;
3775 current_scope->had_vla_unspec = true;
3780 /* Set the contained declarator of an array declarator. DECL is the
3781 declarator, as constructed by build_array_declarator; INNER is what
3782 appears on the left of the []. */
3784 struct c_declarator *
3785 set_array_declarator_inner (struct c_declarator *decl,
3786 struct c_declarator *inner)
3788 decl->declarator = inner;
3792 /* INIT is a constructor that forms DECL's initializer. If the final
3793 element initializes a flexible array field, add the size of that
3794 initializer to DECL's size. */
3797 add_flexible_array_elts_to_size (tree decl, tree init)
3801 if (VEC_empty (constructor_elt, CONSTRUCTOR_ELTS (init)))
3804 elt = VEC_last (constructor_elt, CONSTRUCTOR_ELTS (init))->value;
3805 type = TREE_TYPE (elt);
3806 if (TREE_CODE (type) == ARRAY_TYPE
3807 && TYPE_SIZE (type) == NULL_TREE
3808 && TYPE_DOMAIN (type) != NULL_TREE
3809 && TYPE_MAX_VALUE (TYPE_DOMAIN (type)) == NULL_TREE)
3811 complete_array_type (&type, elt, false);
3813 = size_binop (PLUS_EXPR, DECL_SIZE (decl), TYPE_SIZE (type));
3814 DECL_SIZE_UNIT (decl)
3815 = size_binop (PLUS_EXPR, DECL_SIZE_UNIT (decl), TYPE_SIZE_UNIT (type));
3819 /* Decode a "typename", such as "int **", returning a ..._TYPE node.
3820 Set *EXPR, if EXPR not NULL, to any expression to be evaluated
3821 before the type name, and set *EXPR_CONST_OPERANDS, if
3822 EXPR_CONST_OPERANDS not NULL, to indicate whether the type name may
3823 appear in a constant expression. */
3826 groktypename (struct c_type_name *type_name, tree *expr,
3827 bool *expr_const_operands)
3830 tree attrs = type_name->specs->attrs;
3832 type_name->specs->attrs = NULL_TREE;
3834 type = grokdeclarator (type_name->declarator, type_name->specs, TYPENAME,
3835 false, NULL, &attrs, expr, expr_const_operands,
3838 /* Apply attributes. */
3839 decl_attributes (&type, attrs, 0);
3844 /* Decode a declarator in an ordinary declaration or data definition.
3845 This is called as soon as the type information and variable name
3846 have been parsed, before parsing the initializer if any.
3847 Here we create the ..._DECL node, fill in its type,
3848 and put it on the list of decls for the current context.
3849 The ..._DECL node is returned as the value.
3851 Exception: for arrays where the length is not specified,
3852 the type is left null, to be filled in by `finish_decl'.
3854 Function definitions do not come here; they go to start_function
3855 instead. However, external and forward declarations of functions
3856 do go through here. Structure field declarations are done by
3857 grokfield and not through here. */
3860 start_decl (struct c_declarator *declarator, struct c_declspecs *declspecs,
3861 bool initialized, tree attributes)
3865 tree expr = NULL_TREE;
3866 enum deprecated_states deprecated_state = DEPRECATED_NORMAL;
3868 /* An object declared as __attribute__((deprecated)) suppresses
3869 warnings of uses of other deprecated items. */
3870 if (lookup_attribute ("deprecated", attributes))
3871 deprecated_state = DEPRECATED_SUPPRESS;
3873 decl = grokdeclarator (declarator, declspecs,
3874 NORMAL, initialized, NULL, &attributes, &expr, NULL,
3882 if (TREE_CODE (decl) != FUNCTION_DECL && MAIN_NAME_P (DECL_NAME (decl)))
3883 warning (OPT_Wmain, "%q+D is usually a function", decl);
3886 /* Is it valid for this decl to have an initializer at all?
3887 If not, set INITIALIZED to zero, which will indirectly
3888 tell 'finish_decl' to ignore the initializer once it is parsed. */
3889 switch (TREE_CODE (decl))
3892 error ("typedef %qD is initialized (use __typeof__ instead)", decl);
3897 error ("function %qD is initialized like a variable", decl);
3902 /* DECL_INITIAL in a PARM_DECL is really DECL_ARG_TYPE. */
3903 error ("parameter %qD is initialized", decl);
3908 /* Don't allow initializations for incomplete types except for
3909 arrays which might be completed by the initialization. */
3911 /* This can happen if the array size is an undefined macro.
3912 We already gave a warning, so we don't need another one. */
3913 if (TREE_TYPE (decl) == error_mark_node)
3915 else if (COMPLETE_TYPE_P (TREE_TYPE (decl)))
3917 /* A complete type is ok if size is fixed. */
3919 if (TREE_CODE (TYPE_SIZE (TREE_TYPE (decl))) != INTEGER_CST
3920 || C_DECL_VARIABLE_SIZE (decl))
3922 error ("variable-sized object may not be initialized");
3926 else if (TREE_CODE (TREE_TYPE (decl)) != ARRAY_TYPE)
3928 error ("variable %qD has initializer but incomplete type", decl);
3931 else if (C_DECL_VARIABLE_SIZE (decl))
3933 /* Although C99 is unclear about whether incomplete arrays
3934 of VLAs themselves count as VLAs, it does not make
3935 sense to permit them to be initialized given that
3936 ordinary VLAs may not be initialized. */
3937 error ("variable-sized object may not be initialized");
3944 if (current_scope == file_scope)
3945 TREE_STATIC (decl) = 1;
3947 /* Tell 'pushdecl' this is an initialized decl
3948 even though we don't yet have the initializer expression.
3949 Also tell 'finish_decl' it may store the real initializer. */
3950 DECL_INITIAL (decl) = error_mark_node;
3953 /* If this is a function declaration, write a record describing it to the
3954 prototypes file (if requested). */
3956 if (TREE_CODE (decl) == FUNCTION_DECL)
3957 gen_aux_info_record (decl, 0, 0, TYPE_ARG_TYPES (TREE_TYPE (decl)) != 0);
3959 /* ANSI specifies that a tentative definition which is not merged with
3960 a non-tentative definition behaves exactly like a definition with an
3961 initializer equal to zero. (Section 3.7.2)
3963 -fno-common gives strict ANSI behavior, though this tends to break
3964 a large body of code that grew up without this rule.
3966 Thread-local variables are never common, since there's no entrenched
3967 body of code to break, and it allows more efficient variable references
3968 in the presence of dynamic linking. */
3970 if (TREE_CODE (decl) == VAR_DECL
3972 && TREE_PUBLIC (decl)
3973 && !DECL_THREAD_LOCAL_P (decl)
3975 DECL_COMMON (decl) = 1;
3977 /* Set attributes here so if duplicate decl, will have proper attributes. */
3978 decl_attributes (&decl, attributes, 0);
3980 /* Handle gnu_inline attribute. */
3981 if (declspecs->inline_p
3982 && !flag_gnu89_inline
3983 && TREE_CODE (decl) == FUNCTION_DECL
3984 && (lookup_attribute ("gnu_inline", DECL_ATTRIBUTES (decl))
3985 || current_function_decl))
3987 if (declspecs->storage_class == csc_auto && current_scope != file_scope)
3989 else if (declspecs->storage_class != csc_static)
3990 DECL_EXTERNAL (decl) = !DECL_EXTERNAL (decl);
3993 if (TREE_CODE (decl) == FUNCTION_DECL
3994 && targetm.calls.promote_prototypes (TREE_TYPE (decl)))
3996 struct c_declarator *ce = declarator;
3998 if (ce->kind == cdk_pointer)
3999 ce = declarator->declarator;
4000 if (ce->kind == cdk_function)
4002 tree args = ce->u.arg_info->parms;
4003 for (; args; args = TREE_CHAIN (args))
4005 tree type = TREE_TYPE (args);
4006 if (type && INTEGRAL_TYPE_P (type)
4007 && TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node))
4008 DECL_ARG_TYPE (args) = integer_type_node;
4013 if (TREE_CODE (decl) == FUNCTION_DECL
4014 && DECL_DECLARED_INLINE_P (decl)
4015 && DECL_UNINLINABLE (decl)
4016 && lookup_attribute ("noinline", DECL_ATTRIBUTES (decl)))
4017 warning (OPT_Wattributes, "inline function %q+D given attribute noinline",
4020 /* C99 6.7.4p3: An inline definition of a function with external
4021 linkage shall not contain a definition of a modifiable object
4022 with static storage duration... */
4023 if (TREE_CODE (decl) == VAR_DECL
4024 && current_scope != file_scope
4025 && TREE_STATIC (decl)
4026 && !TREE_READONLY (decl)
4027 && DECL_DECLARED_INLINE_P (current_function_decl)
4028 && DECL_EXTERNAL (current_function_decl))
4029 record_inline_static (input_location, current_function_decl,
4030 decl, csi_modifiable);
4032 /* Add this decl to the current scope.
4033 TEM may equal DECL or it may be a previous decl of the same name. */
4034 tem = pushdecl (decl);
4036 if (initialized && DECL_EXTERNAL (tem))
4038 DECL_EXTERNAL (tem) = 0;
4039 TREE_STATIC (tem) = 1;
4045 /* Initialize EH if not initialized yet and exceptions are enabled. */
4048 c_maybe_initialize_eh (void)
4050 if (!flag_exceptions || c_eh_initialized_p)
4053 c_eh_initialized_p = true;
4054 eh_personality_libfunc
4055 = init_one_libfunc (USING_SJLJ_EXCEPTIONS
4056 ? "__gcc_personality_sj0"
4057 : "__gcc_personality_v0");
4058 default_init_unwind_resume_libfunc ();
4059 using_eh_for_cleanups ();
4062 /* Finish processing of a declaration;
4063 install its initial value.
4064 If ORIGTYPE is not NULL_TREE, it is the original type of INIT.
4065 If the length of an array type is not known before,
4066 it must be determined now, from the initial value, or it is an error.
4068 INIT_LOC is the location of the initial value. */
4071 finish_decl (tree decl, location_t init_loc, tree init,
4072 tree origtype, tree asmspec_tree)
4075 bool was_incomplete = (DECL_SIZE (decl) == 0);
4076 const char *asmspec = 0;
4078 /* If a name was specified, get the string. */
4079 if ((TREE_CODE (decl) == FUNCTION_DECL || TREE_CODE (decl) == VAR_DECL)
4080 && DECL_FILE_SCOPE_P (decl))
4081 asmspec_tree = maybe_apply_renaming_pragma (decl, asmspec_tree);
4083 asmspec = TREE_STRING_POINTER (asmspec_tree);
4085 /* If `start_decl' didn't like having an initialization, ignore it now. */
4086 if (init != 0 && DECL_INITIAL (decl) == 0)
4089 /* Don't crash if parm is initialized. */
4090 if (TREE_CODE (decl) == PARM_DECL)
4094 store_init_value (init_loc, decl, init, origtype);
4096 if (c_dialect_objc () && (TREE_CODE (decl) == VAR_DECL
4097 || TREE_CODE (decl) == FUNCTION_DECL
4098 || TREE_CODE (decl) == FIELD_DECL))
4099 objc_check_decl (decl);
4101 type = TREE_TYPE (decl);
4103 /* Deduce size of array from initialization, if not already known. */
4104 if (TREE_CODE (type) == ARRAY_TYPE
4105 && TYPE_DOMAIN (type) == 0
4106 && TREE_CODE (decl) != TYPE_DECL)
4109 = (TREE_STATIC (decl)
4110 /* Even if pedantic, an external linkage array
4111 may have incomplete type at first. */
4112 ? pedantic && !TREE_PUBLIC (decl)
4113 : !DECL_EXTERNAL (decl));
4115 = complete_array_type (&TREE_TYPE (decl), DECL_INITIAL (decl),
4118 /* Get the completed type made by complete_array_type. */
4119 type = TREE_TYPE (decl);
4124 error ("initializer fails to determine size of %q+D", decl);
4129 error ("array size missing in %q+D", decl);
4130 /* If a `static' var's size isn't known,
4131 make it extern as well as static, so it does not get
4133 If it is not `static', then do not mark extern;
4134 finish_incomplete_decl will give it a default size
4135 and it will get allocated. */
4136 else if (!pedantic && TREE_STATIC (decl) && !TREE_PUBLIC (decl))
4137 DECL_EXTERNAL (decl) = 1;
4141 error ("zero or negative size array %q+D", decl);
4145 /* For global variables, update the copy of the type that
4146 exists in the binding. */
4147 if (TREE_PUBLIC (decl))
4149 struct c_binding *b_ext = I_SYMBOL_BINDING (DECL_NAME (decl));
4150 while (b_ext && !B_IN_EXTERNAL_SCOPE (b_ext))
4151 b_ext = b_ext->shadowed;
4155 b_ext->u.type = composite_type (b_ext->u.type, type);
4157 b_ext->u.type = type;
4166 if (DECL_INITIAL (decl))
4167 TREE_TYPE (DECL_INITIAL (decl)) = type;
4169 layout_decl (decl, 0);
4172 if (TREE_CODE (decl) == VAR_DECL)
4174 if (init && TREE_CODE (init) == CONSTRUCTOR)
4175 add_flexible_array_elts_to_size (decl, init);
4177 if (DECL_SIZE (decl) == 0 && TREE_TYPE (decl) != error_mark_node
4178 && COMPLETE_TYPE_P (TREE_TYPE (decl)))
4179 layout_decl (decl, 0);
4181 if (DECL_SIZE (decl) == 0
4182 /* Don't give an error if we already gave one earlier. */
4183 && TREE_TYPE (decl) != error_mark_node
4184 && (TREE_STATIC (decl)
4185 /* A static variable with an incomplete type
4186 is an error if it is initialized.
4187 Also if it is not file scope.
4188 Otherwise, let it through, but if it is not `extern'
4189 then it may cause an error message later. */
4190 ? (DECL_INITIAL (decl) != 0
4191 || !DECL_FILE_SCOPE_P (decl))
4192 /* An automatic variable with an incomplete type
4194 : !DECL_EXTERNAL (decl)))
4196 error ("storage size of %q+D isn%'t known", decl);
4197 TREE_TYPE (decl) = error_mark_node;
4200 if ((DECL_EXTERNAL (decl) || TREE_STATIC (decl))
4201 && DECL_SIZE (decl) != 0)
4203 if (TREE_CODE (DECL_SIZE (decl)) == INTEGER_CST)
4204 constant_expression_warning (DECL_SIZE (decl));
4207 error ("storage size of %q+D isn%'t constant", decl);
4208 TREE_TYPE (decl) = error_mark_node;
4212 if (TREE_USED (type))
4213 TREE_USED (decl) = 1;
4216 /* If this is a function and an assembler name is specified, reset DECL_RTL
4217 so we can give it its new name. Also, update built_in_decls if it
4218 was a normal built-in. */
4219 if (TREE_CODE (decl) == FUNCTION_DECL && asmspec)
4221 if (DECL_BUILT_IN_CLASS (decl) == BUILT_IN_NORMAL)
4222 set_builtin_user_assembler_name (decl, asmspec);
4223 set_user_assembler_name (decl, asmspec);
4226 /* If #pragma weak was used, mark the decl weak now. */
4227 maybe_apply_pragma_weak (decl);
4229 /* Output the assembler code and/or RTL code for variables and functions,
4230 unless the type is an undefined structure or union.
4231 If not, it will get done when the type is completed. */
4233 if (TREE_CODE (decl) == VAR_DECL || TREE_CODE (decl) == FUNCTION_DECL)
4235 /* Determine the ELF visibility. */
4236 if (TREE_PUBLIC (decl))
4237 c_determine_visibility (decl);
4239 /* This is a no-op in c-lang.c or something real in objc-act.c. */
4240 if (c_dialect_objc ())
4241 objc_check_decl (decl);
4245 /* If this is not a static variable, issue a warning.
4246 It doesn't make any sense to give an ASMSPEC for an
4247 ordinary, non-register local variable. Historically,
4248 GCC has accepted -- but ignored -- the ASMSPEC in
4250 if (!DECL_FILE_SCOPE_P (decl)
4251 && TREE_CODE (decl) == VAR_DECL
4252 && !C_DECL_REGISTER (decl)
4253 && !TREE_STATIC (decl))
4254 warning (0, "ignoring asm-specifier for non-static local "
4255 "variable %q+D", decl);
4257 set_user_assembler_name (decl, asmspec);
4260 if (DECL_FILE_SCOPE_P (decl))
4262 if (DECL_INITIAL (decl) == NULL_TREE
4263 || DECL_INITIAL (decl) == error_mark_node)
4264 /* Don't output anything
4265 when a tentative file-scope definition is seen.
4266 But at end of compilation, do output code for them. */
4267 DECL_DEFER_OUTPUT (decl) = 1;
4268 rest_of_decl_compilation (decl, true, 0);
4272 /* In conjunction with an ASMSPEC, the `register'
4273 keyword indicates that we should place the variable
4274 in a particular register. */
4275 if (asmspec && C_DECL_REGISTER (decl))
4277 DECL_HARD_REGISTER (decl) = 1;
4278 /* This cannot be done for a structure with volatile
4279 fields, on which DECL_REGISTER will have been
4281 if (!DECL_REGISTER (decl))
4282 error ("cannot put object with volatile field into register");
4285 if (TREE_CODE (decl) != FUNCTION_DECL)
4287 /* If we're building a variable sized type, and we might be
4288 reachable other than via the top of the current binding
4289 level, then create a new BIND_EXPR so that we deallocate
4290 the object at the right time. */
4291 /* Note that DECL_SIZE can be null due to errors. */
4292 if (DECL_SIZE (decl)
4293 && !TREE_CONSTANT (DECL_SIZE (decl))
4294 && STATEMENT_LIST_HAS_LABEL (cur_stmt_list))
4297 bind = build3 (BIND_EXPR, void_type_node, NULL, NULL, NULL);
4298 TREE_SIDE_EFFECTS (bind) = 1;
4300 BIND_EXPR_BODY (bind) = push_stmt_list ();
4302 add_stmt (build_stmt (DECL_SOURCE_LOCATION (decl),
4308 if (!DECL_FILE_SCOPE_P (decl))
4310 /* Recompute the RTL of a local array now
4311 if it used to be an incomplete type. */
4313 && !TREE_STATIC (decl) && !DECL_EXTERNAL (decl))
4315 /* If we used it already as memory, it must stay in memory. */
4316 TREE_ADDRESSABLE (decl) = TREE_USED (decl);
4317 /* If it's still incomplete now, no init will save it. */
4318 if (DECL_SIZE (decl) == 0)
4319 DECL_INITIAL (decl) = 0;
4324 if (TREE_CODE (decl) == TYPE_DECL)
4326 if (!DECL_FILE_SCOPE_P (decl)
4327 && variably_modified_type_p (TREE_TYPE (decl), NULL_TREE))
4328 add_stmt (build_stmt (DECL_SOURCE_LOCATION (decl), DECL_EXPR, decl));
4330 rest_of_decl_compilation (decl, DECL_FILE_SCOPE_P (decl), 0);
4333 /* At the end of a declaration, throw away any variable type sizes
4334 of types defined inside that declaration. There is no use
4335 computing them in the following function definition. */
4336 if (current_scope == file_scope)
4337 get_pending_sizes ();
4339 /* Install a cleanup (aka destructor) if one was given. */
4340 if (TREE_CODE (decl) == VAR_DECL && !TREE_STATIC (decl))
4342 tree attr = lookup_attribute ("cleanup", DECL_ATTRIBUTES (decl));
4345 tree cleanup_id = TREE_VALUE (TREE_VALUE (attr));
4346 tree cleanup_decl = lookup_name (cleanup_id);
4350 /* Build "cleanup(&decl)" for the destructor. */
4351 cleanup = build_unary_op (input_location, ADDR_EXPR, decl, 0);
4352 vec = VEC_alloc (tree, gc, 1);
4353 VEC_quick_push (tree, vec, cleanup);
4354 cleanup = build_function_call_vec (DECL_SOURCE_LOCATION (decl),
4355 cleanup_decl, vec, NULL);
4356 VEC_free (tree, gc, vec);
4358 /* Don't warn about decl unused; the cleanup uses it. */
4359 TREE_USED (decl) = 1;
4360 TREE_USED (cleanup_decl) = 1;
4362 /* Initialize EH, if we've been told to do so. */
4363 c_maybe_initialize_eh ();
4365 push_cleanup (decl, cleanup, false);
4370 && TREE_CODE (decl) == VAR_DECL
4371 && TREE_READONLY (decl)
4372 && !DECL_EXTERNAL (decl)
4373 && DECL_INITIAL (decl) == NULL_TREE)
4374 warning_at (DECL_SOURCE_LOCATION (decl), OPT_Wc___compat,
4375 "uninitialized const %qD is invalid in C++", decl);
4378 /* Given a parsed parameter declaration, decode it into a PARM_DECL. */
4381 grokparm (const struct c_parm *parm)
4383 tree attrs = parm->attrs;
4384 tree decl = grokdeclarator (parm->declarator, parm->specs, PARM, false,
4385 NULL, &attrs, NULL, NULL, DEPRECATED_NORMAL);
4387 decl_attributes (&decl, attrs, 0);
4392 /* Given a parsed parameter declaration, decode it into a PARM_DECL
4393 and push that on the current scope. */
4396 push_parm_decl (const struct c_parm *parm)
4398 tree attrs = parm->attrs;
4401 decl = grokdeclarator (parm->declarator, parm->specs, PARM, false, NULL,
4402 &attrs, NULL, NULL, DEPRECATED_NORMAL);
4403 decl_attributes (&decl, attrs, 0);
4405 decl = pushdecl (decl);
4407 finish_decl (decl, input_location, NULL_TREE, NULL_TREE, NULL_TREE);
4410 /* Mark all the parameter declarations to date as forward decls.
4411 Also diagnose use of this extension. */
4414 mark_forward_parm_decls (void)
4416 struct c_binding *b;
4418 if (pedantic && !current_scope->warned_forward_parm_decls)
4420 pedwarn (input_location, OPT_pedantic,
4421 "ISO C forbids forward parameter declarations");
4422 current_scope->warned_forward_parm_decls = true;
4425 for (b = current_scope->bindings; b; b = b->prev)
4426 if (TREE_CODE (b->decl) == PARM_DECL)
4427 TREE_ASM_WRITTEN (b->decl) = 1;
4430 /* Build a COMPOUND_LITERAL_EXPR. TYPE is the type given in the compound
4431 literal, which may be an incomplete array type completed by the
4432 initializer; INIT is a CONSTRUCTOR at LOC that initializes the compound
4433 literal. NON_CONST is true if the initializers contain something
4434 that cannot occur in a constant expression. */
4437 build_compound_literal (location_t loc, tree type, tree init, bool non_const)
4439 /* We do not use start_decl here because we have a type, not a declarator;
4440 and do not use finish_decl because the decl should be stored inside
4441 the COMPOUND_LITERAL_EXPR rather than added elsewhere as a DECL_EXPR. */
4446 if (type == error_mark_node)
4447 return error_mark_node;
4449 decl = build_decl (loc, VAR_DECL, NULL_TREE, type);
4450 DECL_EXTERNAL (decl) = 0;
4451 TREE_PUBLIC (decl) = 0;
4452 TREE_STATIC (decl) = (current_scope == file_scope);
4453 DECL_CONTEXT (decl) = current_function_decl;
4454 TREE_USED (decl) = 1;
4455 TREE_TYPE (decl) = type;
4456 TREE_READONLY (decl) = TYPE_READONLY (type);
4457 store_init_value (loc, decl, init, NULL_TREE);
4459 if (TREE_CODE (type) == ARRAY_TYPE && !COMPLETE_TYPE_P (type))
4461 int failure = complete_array_type (&TREE_TYPE (decl),
4462 DECL_INITIAL (decl), true);
4463 gcc_assert (!failure);
4465 type = TREE_TYPE (decl);
4466 TREE_TYPE (DECL_INITIAL (decl)) = type;
4469 if (type == error_mark_node || !COMPLETE_TYPE_P (type))
4470 return error_mark_node;
4472 stmt = build_stmt (DECL_SOURCE_LOCATION (decl), DECL_EXPR, decl);
4473 complit = build1 (COMPOUND_LITERAL_EXPR, type, stmt);
4474 TREE_SIDE_EFFECTS (complit) = 1;
4476 layout_decl (decl, 0);
4478 if (TREE_STATIC (decl))
4480 /* This decl needs a name for the assembler output. */
4481 set_compound_literal_name (decl);
4482 DECL_DEFER_OUTPUT (decl) = 1;
4483 DECL_COMDAT (decl) = 1;
4484 DECL_ARTIFICIAL (decl) = 1;
4485 DECL_IGNORED_P (decl) = 1;
4487 rest_of_decl_compilation (decl, 1, 0);
4492 complit = build2 (C_MAYBE_CONST_EXPR, type, NULL, complit);
4493 C_MAYBE_CONST_EXPR_NON_CONST (complit) = 1;
4499 /* Check the type of a compound literal. Here we just check that it
4500 is valid for C++. */
4503 check_compound_literal_type (location_t loc, struct c_type_name *type_name)
4505 if (warn_cxx_compat && type_name->specs->tag_defined_p)
4506 warning_at (loc, OPT_Wc___compat,
4507 "defining a type in a compound literal is invalid in C++");
4510 /* Determine whether TYPE is a structure with a flexible array member,
4511 or a union containing such a structure (possibly recursively). */
4514 flexible_array_type_p (tree type)
4517 switch (TREE_CODE (type))
4520 x = TYPE_FIELDS (type);
4523 while (TREE_CHAIN (x) != NULL_TREE)
4525 if (TREE_CODE (TREE_TYPE (x)) == ARRAY_TYPE
4526 && TYPE_SIZE (TREE_TYPE (x)) == NULL_TREE
4527 && TYPE_DOMAIN (TREE_TYPE (x)) != NULL_TREE
4528 && TYPE_MAX_VALUE (TYPE_DOMAIN (TREE_TYPE (x))) == NULL_TREE)
4532 for (x = TYPE_FIELDS (type); x != NULL_TREE; x = TREE_CHAIN (x))
4534 if (flexible_array_type_p (TREE_TYPE (x)))
4543 /* Performs sanity checks on the TYPE and WIDTH of the bit-field NAME,
4544 replacing with appropriate values if they are invalid. */
4546 check_bitfield_type_and_width (tree *type, tree *width, tree orig_name)
4549 unsigned int max_width;
4550 unsigned HOST_WIDE_INT w;
4551 const char *name = (orig_name
4552 ? identifier_to_locale (IDENTIFIER_POINTER (orig_name))
4553 : _("<anonymous>"));
4555 /* Detect and ignore out of range field width and process valid
4557 if (!INTEGRAL_TYPE_P (TREE_TYPE (*width))
4558 || TREE_CODE (*width) != INTEGER_CST)
4560 error ("bit-field %qs width not an integer constant", name);
4561 *width = integer_one_node;
4565 constant_expression_warning (*width);
4566 if (tree_int_cst_sgn (*width) < 0)
4568 error ("negative width in bit-field %qs", name);
4569 *width = integer_one_node;
4571 else if (integer_zerop (*width) && orig_name)
4573 error ("zero width for bit-field %qs", name);
4574 *width = integer_one_node;
4578 /* Detect invalid bit-field type. */
4579 if (TREE_CODE (*type) != INTEGER_TYPE
4580 && TREE_CODE (*type) != BOOLEAN_TYPE
4581 && TREE_CODE (*type) != ENUMERAL_TYPE)
4583 error ("bit-field %qs has invalid type", name);
4584 *type = unsigned_type_node;
4587 type_mv = TYPE_MAIN_VARIANT (*type);
4588 if (!in_system_header
4589 && type_mv != integer_type_node
4590 && type_mv != unsigned_type_node
4591 && type_mv != boolean_type_node)
4592 pedwarn (input_location, OPT_pedantic,
4593 "type of bit-field %qs is a GCC extension", name);
4595 max_width = TYPE_PRECISION (*type);
4597 if (0 < compare_tree_int (*width, max_width))
4599 error ("width of %qs exceeds its type", name);
4601 *width = build_int_cst (NULL_TREE, w);
4604 w = tree_low_cst (*width, 1);
4606 if (TREE_CODE (*type) == ENUMERAL_TYPE)
4608 struct lang_type *lt = TYPE_LANG_SPECIFIC (*type);
4610 || w < tree_int_cst_min_precision (lt->enum_min, TYPE_UNSIGNED (*type))
4611 || w < tree_int_cst_min_precision (lt->enum_max, TYPE_UNSIGNED (*type)))
4612 warning (0, "%qs is narrower than values of its type", name);
4618 /* Print warning about variable length array if necessary. */
4621 warn_variable_length_array (tree name, tree size)
4623 int const_size = TREE_CONSTANT (size);
4625 if (!flag_isoc99 && pedantic && warn_vla != 0)
4630 pedwarn (input_location, OPT_Wvla,
4631 "ISO C90 forbids array %qE whose size "
4632 "can%'t be evaluated",
4635 pedwarn (input_location, OPT_Wvla, "ISO C90 forbids array whose size "
4636 "can%'t be evaluated");
4641 pedwarn (input_location, OPT_Wvla,
4642 "ISO C90 forbids variable length array %qE",
4645 pedwarn (input_location, OPT_Wvla, "ISO C90 forbids variable length array");
4648 else if (warn_vla > 0)
4654 "the size of array %qE can"
4655 "%'t be evaluated", name);
4658 "the size of array can %'t be evaluated");
4664 "variable length array %qE is used",
4668 "variable length array is used");
4673 /* Given a size SIZE that may not be a constant, return a SAVE_EXPR to
4674 serve as the actual size-expression for a type or decl. This is
4675 like variable_size in stor-layout.c, but we make global_bindings_p
4676 return negative to avoid calls to that function from outside the
4677 front end resulting in errors at file scope, then call this version
4678 instead from front-end code. */
4681 c_variable_size (tree size)
4685 if (TREE_CONSTANT (size))
4688 size = save_expr (size);
4690 save = skip_simple_arithmetic (size);
4692 if (cfun && cfun->dont_save_pending_sizes_p)
4695 if (!global_bindings_p ())
4696 put_pending_size (save);
4701 /* Given declspecs and a declarator,
4702 determine the name and type of the object declared
4703 and construct a ..._DECL node for it.
4704 (In one case we can return a ..._TYPE node instead.
4705 For invalid input we sometimes return 0.)
4707 DECLSPECS is a c_declspecs structure for the declaration specifiers.
4709 DECL_CONTEXT says which syntactic context this declaration is in:
4710 NORMAL for most contexts. Make a VAR_DECL or FUNCTION_DECL or TYPE_DECL.
4711 FUNCDEF for a function definition. Like NORMAL but a few different
4712 error messages in each case. Return value may be zero meaning
4713 this definition is too screwy to try to parse.
4714 PARM for a parameter declaration (either within a function prototype
4715 or before a function body). Make a PARM_DECL, or return void_type_node.
4716 TYPENAME if for a typename (in a cast or sizeof).
4717 Don't make a DECL node; just return the ..._TYPE node.
4718 FIELD for a struct or union field; make a FIELD_DECL.
4719 INITIALIZED is true if the decl has an initializer.
4720 WIDTH is non-NULL for bit-fields, and is a pointer to an INTEGER_CST node
4721 representing the width of the bit-field.
4722 DECL_ATTRS points to the list of attributes that should be added to this
4723 decl. Any nested attributes that belong on the decl itself will be
4725 If EXPR is not NULL, any expressions that need to be evaluated as
4726 part of evaluating variably modified types will be stored in *EXPR.
4727 If EXPR_CONST_OPERANDS is not NULL, *EXPR_CONST_OPERANDS will be
4728 set to indicate whether operands in *EXPR can be used in constant
4730 DEPRECATED_STATE is a deprecated_states value indicating whether
4731 deprecation warnings should be suppressed.
4733 In the TYPENAME case, DECLARATOR is really an absolute declarator.
4734 It may also be so in the PARM case, for a prototype where the
4735 argument type is specified but not the name.
4737 This function is where the complicated C meanings of `static'
4738 and `extern' are interpreted. */
4741 grokdeclarator (const struct c_declarator *declarator,
4742 struct c_declspecs *declspecs,
4743 enum decl_context decl_context, bool initialized, tree *width,
4744 tree *decl_attrs, tree *expr, bool *expr_const_operands,
4745 enum deprecated_states deprecated_state)
4747 tree type = declspecs->type;
4748 bool threadp = declspecs->thread_p;
4749 enum c_storage_class storage_class = declspecs->storage_class;
4753 int type_quals = TYPE_UNQUALIFIED;
4754 tree name = NULL_TREE;
4755 bool funcdef_flag = false;
4756 bool funcdef_syntax = false;
4757 bool size_varies = false;
4758 tree decl_attr = declspecs->decl_attr;
4759 int array_ptr_quals = TYPE_UNQUALIFIED;
4760 tree array_ptr_attrs = NULL_TREE;
4761 int array_parm_static = 0;
4762 bool array_parm_vla_unspec_p = false;
4763 tree returned_attrs = NULL_TREE;
4764 bool bitfield = width != NULL;
4766 struct c_arg_info *arg_info = 0;
4767 location_t loc = UNKNOWN_LOCATION;
4770 bool expr_const_operands_dummy;
4774 if (expr_const_operands == NULL)
4775 expr_const_operands = &expr_const_operands_dummy;
4777 *expr = declspecs->expr;
4778 *expr_const_operands = declspecs->expr_const_operands;
4780 if (decl_context == FUNCDEF)
4781 funcdef_flag = true, decl_context = NORMAL;
4783 /* Look inside a declarator for the name being declared
4784 and get it as an IDENTIFIER_NODE, for an error message. */
4786 const struct c_declarator *decl = declarator;
4797 funcdef_syntax = (decl->kind == cdk_function);
4798 decl = decl->declarator;
4802 decl = decl->declarator;
4817 gcc_assert (decl_context == PARM
4818 || decl_context == TYPENAME
4819 || (decl_context == FIELD
4820 && declarator->kind == cdk_id));
4821 gcc_assert (!initialized);
4825 /* A function definition's declarator must have the form of
4826 a function declarator. */
4828 if (funcdef_flag && !funcdef_syntax)
4831 /* If this looks like a function definition, make it one,
4832 even if it occurs where parms are expected.
4833 Then store_parm_decls will reject it and not use it as a parm. */
4834 if (decl_context == NORMAL && !funcdef_flag && current_scope->parm_flag)
4835 decl_context = PARM;
4837 if (declspecs->deprecated_p && deprecated_state != DEPRECATED_SUPPRESS)
4838 warn_deprecated_use (declspecs->type, declspecs->decl_attr);
4840 if ((decl_context == NORMAL || decl_context == FIELD)
4841 && current_scope == file_scope
4842 && variably_modified_type_p (type, NULL_TREE))
4845 error_at (loc, "variably modified %qE at file scope", name);
4847 error_at (loc, "variably modified field at file scope");
4848 type = integer_type_node;
4851 size_varies = C_TYPE_VARIABLE_SIZE (type) != 0;
4853 /* Diagnose defaulting to "int". */
4855 if (declspecs->default_int_p && !in_system_header)
4857 /* Issue a warning if this is an ISO C 99 program or if
4858 -Wreturn-type and this is a function, or if -Wimplicit;
4859 prefer the former warning since it is more explicit. */
4860 if ((warn_implicit_int || warn_return_type || flag_isoc99)
4862 warn_about_return_type = 1;
4866 pedwarn_c99 (loc, flag_isoc99 ? 0 : OPT_Wimplicit_int,
4867 "type defaults to %<int%> in declaration of %qE",
4870 pedwarn_c99 (input_location, flag_isoc99 ? 0 : OPT_Wimplicit_int,
4871 "type defaults to %<int%> in type name");
4875 /* Adjust the type if a bit-field is being declared,
4876 -funsigned-bitfields applied and the type is not explicitly
4878 if (bitfield && !flag_signed_bitfields && !declspecs->explicit_signed_p
4879 && TREE_CODE (type) == INTEGER_TYPE)
4880 type = unsigned_type_for (type);
4882 /* Figure out the type qualifiers for the declaration. There are
4883 two ways a declaration can become qualified. One is something
4884 like `const int i' where the `const' is explicit. Another is
4885 something like `typedef const int CI; CI i' where the type of the
4886 declaration contains the `const'. A third possibility is that
4887 there is a type qualifier on the element type of a typedefed
4888 array type, in which case we should extract that qualifier so
4889 that c_apply_type_quals_to_decl receives the full list of
4890 qualifiers to work with (C90 is not entirely clear about whether
4891 duplicate qualifiers should be diagnosed in this case, but it
4892 seems most appropriate to do so). */
4893 element_type = strip_array_types (type);
4894 constp = declspecs->const_p + TYPE_READONLY (element_type);
4895 restrictp = declspecs->restrict_p + TYPE_RESTRICT (element_type);
4896 volatilep = declspecs->volatile_p + TYPE_VOLATILE (element_type);
4897 if (pedantic && !flag_isoc99)
4900 pedwarn (loc, OPT_pedantic, "duplicate %<const%>");
4902 pedwarn (loc, OPT_pedantic, "duplicate %<restrict%>");
4904 pedwarn (loc, OPT_pedantic, "duplicate %<volatile%>");
4906 if (!flag_gen_aux_info && (TYPE_QUALS (element_type)))
4907 type = TYPE_MAIN_VARIANT (type);
4908 type_quals = ((constp ? TYPE_QUAL_CONST : 0)
4909 | (restrictp ? TYPE_QUAL_RESTRICT : 0)
4910 | (volatilep ? TYPE_QUAL_VOLATILE : 0));
4912 /* Warn about storage classes that are invalid for certain
4913 kinds of declarations (parameters, typenames, etc.). */
4917 || storage_class == csc_auto
4918 || storage_class == csc_register
4919 || storage_class == csc_typedef))
4921 if (storage_class == csc_auto)
4923 (current_scope == file_scope) ? 0 : OPT_pedantic,
4924 "function definition declared %<auto%>");
4925 if (storage_class == csc_register)
4926 error_at (loc, "function definition declared %<register%>");
4927 if (storage_class == csc_typedef)
4928 error_at (loc, "function definition declared %<typedef%>");
4930 error_at (loc, "function definition declared %<__thread%>");
4932 if (storage_class == csc_auto
4933 || storage_class == csc_register
4934 || storage_class == csc_typedef)
4935 storage_class = csc_none;
4937 else if (decl_context != NORMAL && (storage_class != csc_none || threadp))
4939 if (decl_context == PARM && storage_class == csc_register)
4943 switch (decl_context)
4947 error_at (loc, "storage class specified for structure "
4950 error_at (loc, "storage class specified for structure field");
4954 error_at (loc, "storage class specified for parameter %qE",
4957 error_at (loc, "storage class specified for unnamed parameter");
4960 error_at (loc, "storage class specified for typename");
4963 storage_class = csc_none;
4967 else if (storage_class == csc_extern
4971 /* 'extern' with initialization is invalid if not at file scope. */
4972 if (current_scope == file_scope)
4974 /* It is fine to have 'extern const' when compiling at C
4975 and C++ intersection. */
4976 if (!(warn_cxx_compat && constp))
4977 warning_at (loc, 0, "%qE initialized and declared %<extern%>",
4981 error_at (loc, "%qE has both %<extern%> and initializer", name);
4983 else if (current_scope == file_scope)
4985 if (storage_class == csc_auto)
4986 error_at (loc, "file-scope declaration of %qE specifies %<auto%>",
4988 if (pedantic && storage_class == csc_register)
4989 pedwarn (input_location, OPT_pedantic,
4990 "file-scope declaration of %qE specifies %<register%>", name);
4994 if (storage_class == csc_extern && funcdef_flag)
4995 error_at (loc, "nested function %qE declared %<extern%>", name);
4996 else if (threadp && storage_class == csc_none)
4998 error_at (loc, "function-scope %qE implicitly auto and declared "
5005 /* Now figure out the structure of the declarator proper.
5006 Descend through it, creating more complex types, until we reach
5007 the declared identifier (or NULL_TREE, in an absolute declarator).
5008 At each stage we maintain an unqualified version of the type
5009 together with any qualifiers that should be applied to it with
5010 c_build_qualified_type; this way, array types including
5011 multidimensional array types are first built up in unqualified
5012 form and then the qualified form is created with
5013 TYPE_MAIN_VARIANT pointing to the unqualified form. */
5015 while (declarator && declarator->kind != cdk_id)
5017 if (type == error_mark_node)
5019 declarator = declarator->declarator;
5023 /* Each level of DECLARATOR is either a cdk_array (for ...[..]),
5024 a cdk_pointer (for *...),
5025 a cdk_function (for ...(...)),
5026 a cdk_attrs (for nested attributes),
5027 or a cdk_id (for the name being declared
5028 or the place in an absolute declarator
5029 where the name was omitted).
5030 For the last case, we have just exited the loop.
5032 At this point, TYPE is the type of elements of an array,
5033 or for a function to return, or for a pointer to point to.
5034 After this sequence of ifs, TYPE is the type of the
5035 array or function or pointer, and DECLARATOR has had its
5036 outermost layer removed. */
5038 if (array_ptr_quals != TYPE_UNQUALIFIED
5039 || array_ptr_attrs != NULL_TREE
5040 || array_parm_static)
5042 /* Only the innermost declarator (making a parameter be of
5043 array type which is converted to pointer type)
5044 may have static or type qualifiers. */
5045 error_at (loc, "static or type qualifiers in non-parameter array declarator");
5046 array_ptr_quals = TYPE_UNQUALIFIED;
5047 array_ptr_attrs = NULL_TREE;
5048 array_parm_static = 0;
5051 switch (declarator->kind)
5055 /* A declarator with embedded attributes. */
5056 tree attrs = declarator->u.attrs;
5057 const struct c_declarator *inner_decl;
5059 declarator = declarator->declarator;
5060 inner_decl = declarator;
5061 while (inner_decl->kind == cdk_attrs)
5062 inner_decl = inner_decl->declarator;
5063 if (inner_decl->kind == cdk_id)
5064 attr_flags |= (int) ATTR_FLAG_DECL_NEXT;
5065 else if (inner_decl->kind == cdk_function)
5066 attr_flags |= (int) ATTR_FLAG_FUNCTION_NEXT;
5067 else if (inner_decl->kind == cdk_array)
5068 attr_flags |= (int) ATTR_FLAG_ARRAY_NEXT;
5069 returned_attrs = decl_attributes (&type,
5070 chainon (returned_attrs, attrs),
5076 tree itype = NULL_TREE;
5077 tree size = declarator->u.array.dimen;
5078 /* The index is a signed object `sizetype' bits wide. */
5079 tree index_type = c_common_signed_type (sizetype);
5081 array_ptr_quals = declarator->u.array.quals;
5082 array_ptr_attrs = declarator->u.array.attrs;
5083 array_parm_static = declarator->u.array.static_p;
5084 array_parm_vla_unspec_p = declarator->u.array.vla_unspec_p;
5086 declarator = declarator->declarator;
5088 /* Check for some types that there cannot be arrays of. */
5090 if (VOID_TYPE_P (type))
5093 error_at (loc, "declaration of %qE as array of voids", name);
5095 error_at (loc, "declaration of type name as array of voids");
5096 type = error_mark_node;
5099 if (TREE_CODE (type) == FUNCTION_TYPE)
5102 error_at (loc, "declaration of %qE as array of functions",
5105 error_at (loc, "declaration of type name as array of "
5107 type = error_mark_node;
5110 if (pedantic && !in_system_header && flexible_array_type_p (type))
5111 pedwarn (loc, OPT_pedantic,
5112 "invalid use of structure with flexible array member");
5114 if (size == error_mark_node)
5115 type = error_mark_node;
5117 if (type == error_mark_node)
5120 /* If size was specified, set ITYPE to a range-type for
5121 that size. Otherwise, ITYPE remains null. finish_decl
5122 may figure it out from an initial value. */
5126 bool size_maybe_const = true;
5127 bool size_int_const = (TREE_CODE (size) == INTEGER_CST
5128 && !TREE_OVERFLOW (size));
5129 bool this_size_varies = false;
5131 /* Strip NON_LVALUE_EXPRs since we aren't using as an
5133 STRIP_TYPE_NOPS (size);
5135 if (!INTEGRAL_TYPE_P (TREE_TYPE (size)))
5138 error_at (loc, "size of array %qE has non-integer type",
5142 "size of unnamed array has non-integer type");
5143 size = integer_one_node;
5146 size = c_fully_fold (size, false, &size_maybe_const);
5148 if (pedantic && size_maybe_const && integer_zerop (size))
5151 pedwarn (loc, OPT_pedantic,
5152 "ISO C forbids zero-size array %qE", name);
5154 pedwarn (loc, OPT_pedantic,
5155 "ISO C forbids zero-size array");
5158 if (TREE_CODE (size) == INTEGER_CST && size_maybe_const)
5160 constant_expression_warning (size);
5161 if (tree_int_cst_sgn (size) < 0)
5164 error_at (loc, "size of array %qE is negative", name);
5166 error_at (loc, "size of unnamed array is negative");
5167 size = integer_one_node;
5169 /* Handle a size folded to an integer constant but
5170 not an integer constant expression. */
5171 if (!size_int_const)
5173 /* If this is a file scope declaration of an
5174 ordinary identifier, this is invalid code;
5175 diagnosing it here and not subsequently
5176 treating the type as variable-length avoids
5177 more confusing diagnostics later. */
5178 if ((decl_context == NORMAL || decl_context == FIELD)
5179 && current_scope == file_scope)
5180 pedwarn (input_location, 0,
5181 "variably modified %qE at file scope",
5184 this_size_varies = size_varies = true;
5185 warn_variable_length_array (name, size);
5188 else if ((decl_context == NORMAL || decl_context == FIELD)
5189 && current_scope == file_scope)
5191 error_at (loc, "variably modified %qE at file scope", name);
5192 size = integer_one_node;
5196 /* Make sure the array size remains visibly
5197 nonconstant even if it is (eg) a const variable
5198 with known value. */
5199 this_size_varies = size_varies = true;
5200 warn_variable_length_array (name, size);
5203 if (integer_zerop (size) && !this_size_varies)
5205 /* A zero-length array cannot be represented with
5206 an unsigned index type, which is what we'll
5207 get with build_index_type. Create an
5208 open-ended range instead. */
5209 itype = build_range_type (sizetype, size, NULL_TREE);
5213 /* Arrange for the SAVE_EXPR on the inside of the
5214 MINUS_EXPR, which allows the -1 to get folded
5215 with the +1 that happens when building TYPE_SIZE. */
5217 size = c_variable_size (size);
5218 if (this_size_varies && TREE_CODE (size) == INTEGER_CST)
5219 size = build2 (COMPOUND_EXPR, TREE_TYPE (size),
5220 integer_zero_node, size);
5222 /* Compute the maximum valid index, that is, size
5223 - 1. Do the calculation in index_type, so that
5224 if it is a variable the computations will be
5225 done in the proper mode. */
5226 itype = fold_build2_loc (loc, MINUS_EXPR, index_type,
5227 convert (index_type, size),
5228 convert (index_type,
5231 /* If that overflowed, the array is too big. ???
5232 While a size of INT_MAX+1 technically shouldn't
5233 cause an overflow (because we subtract 1), the
5234 overflow is recorded during the conversion to
5235 index_type, before the subtraction. Handling
5236 this case seems like an unnecessary
5238 if (TREE_CODE (itype) == INTEGER_CST
5239 && TREE_OVERFLOW (itype))
5242 error_at (loc, "size of array %qE is too large",
5245 error_at (loc, "size of unnamed array is too large");
5246 type = error_mark_node;
5250 itype = build_index_type (itype);
5252 if (this_size_varies)
5255 *expr = build2 (COMPOUND_EXPR, TREE_TYPE (size),
5259 *expr_const_operands &= size_maybe_const;
5262 else if (decl_context == FIELD)
5264 bool flexible_array_member = false;
5265 if (array_parm_vla_unspec_p)
5266 /* Field names can in fact have function prototype
5267 scope so [*] is disallowed here through making
5268 the field variably modified, not through being
5269 something other than a declaration with function
5274 const struct c_declarator *t = declarator;
5275 while (t->kind == cdk_attrs)
5277 flexible_array_member = (t->kind == cdk_id);
5279 if (flexible_array_member
5280 && pedantic && !flag_isoc99 && !in_system_header)
5281 pedwarn (loc, OPT_pedantic,
5282 "ISO C90 does not support flexible array members");
5284 /* ISO C99 Flexible array members are effectively
5285 identical to GCC's zero-length array extension. */
5286 if (flexible_array_member || array_parm_vla_unspec_p)
5287 itype = build_range_type (sizetype, size_zero_node,
5290 else if (decl_context == PARM)
5292 if (array_parm_vla_unspec_p)
5294 itype = build_range_type (sizetype, size_zero_node, NULL_TREE);
5298 else if (decl_context == TYPENAME)
5300 if (array_parm_vla_unspec_p)
5303 warning (0, "%<[*]%> not in a declaration");
5304 /* We use this to avoid messing up with incomplete
5305 array types of the same type, that would
5306 otherwise be modified below. */
5307 itype = build_range_type (sizetype, size_zero_node,
5313 /* Complain about arrays of incomplete types. */
5314 if (!COMPLETE_TYPE_P (type))
5316 error_at (loc, "array type has incomplete element type");
5317 type = error_mark_node;
5320 /* When itype is NULL, a shared incomplete array type is
5321 returned for all array of a given type. Elsewhere we
5322 make sure we don't complete that type before copying
5323 it, but here we want to make sure we don't ever
5324 modify the shared type, so we gcc_assert (itype)
5326 type = build_array_type (type, itype);
5328 if (type != error_mark_node)
5332 /* It is ok to modify type here even if itype is
5333 NULL: if size_varies, we're in a
5334 multi-dimensional array and the inner type has
5335 variable size, so the enclosing shared array type
5337 if (size && TREE_CODE (size) == INTEGER_CST)
5339 = build_distinct_type_copy (TYPE_MAIN_VARIANT (type));
5340 C_TYPE_VARIABLE_SIZE (type) = 1;
5343 /* The GCC extension for zero-length arrays differs from
5344 ISO flexible array members in that sizeof yields
5346 if (size && integer_zerop (size))
5349 TYPE_SIZE (type) = bitsize_zero_node;
5350 TYPE_SIZE_UNIT (type) = size_zero_node;
5352 if (array_parm_vla_unspec_p)
5355 /* The type is complete. C99 6.7.5.2p4 */
5356 TYPE_SIZE (type) = bitsize_zero_node;
5357 TYPE_SIZE_UNIT (type) = size_zero_node;
5361 if (decl_context != PARM
5362 && (array_ptr_quals != TYPE_UNQUALIFIED
5363 || array_ptr_attrs != NULL_TREE
5364 || array_parm_static))
5366 error_at (loc, "static or type qualifiers in non-parameter array declarator");
5367 array_ptr_quals = TYPE_UNQUALIFIED;
5368 array_ptr_attrs = NULL_TREE;
5369 array_parm_static = 0;
5375 /* Say it's a definition only for the declarator closest
5376 to the identifier, apart possibly from some
5378 bool really_funcdef = false;
5382 const struct c_declarator *t = declarator->declarator;
5383 while (t->kind == cdk_attrs)
5385 really_funcdef = (t->kind == cdk_id);
5388 /* Declaring a function type. Make sure we have a valid
5389 type for the function to return. */
5390 if (type == error_mark_node)
5393 size_varies = false;
5395 /* Warn about some types functions can't return. */
5396 if (TREE_CODE (type) == FUNCTION_TYPE)
5399 error_at (loc, "%qE declared as function returning a "
5402 error_at (loc, "type name declared as function "
5403 "returning a function");
5404 type = integer_type_node;
5406 if (TREE_CODE (type) == ARRAY_TYPE)
5409 error_at (loc, "%qE declared as function returning an array",
5412 error_at (loc, "type name declared as function returning "
5414 type = integer_type_node;
5416 errmsg = targetm.invalid_return_type (type);
5420 type = integer_type_node;
5423 /* Construct the function type and go to the next
5424 inner layer of declarator. */
5425 arg_info = declarator->u.arg_info;
5426 arg_types = grokparms (arg_info, really_funcdef);
5428 put_pending_sizes (arg_info->pending_sizes);
5430 /* Type qualifiers before the return type of the function
5431 qualify the return type, not the function type. */
5434 /* Type qualifiers on a function return type are
5435 normally permitted by the standard but have no
5436 effect, so give a warning at -Wreturn-type.
5437 Qualifiers on a void return type are banned on
5438 function definitions in ISO C; GCC used to used
5439 them for noreturn functions. */
5440 if (VOID_TYPE_P (type) && really_funcdef)
5442 "function definition has qualified void return type");
5444 warning_at (loc, OPT_Wignored_qualifiers,
5445 "type qualifiers ignored on function return type");
5447 type = c_build_qualified_type (type, type_quals);
5449 type_quals = TYPE_UNQUALIFIED;
5451 type = build_function_type (type, arg_types);
5452 declarator = declarator->declarator;
5454 /* Set the TYPE_CONTEXTs for each tagged type which is local to
5455 the formal parameter list of this FUNCTION_TYPE to point to
5456 the FUNCTION_TYPE node itself. */
5460 for (link = arg_info->tags;
5462 link = TREE_CHAIN (link))
5463 TYPE_CONTEXT (TREE_VALUE (link)) = type;
5469 /* Merge any constancy or volatility into the target type
5472 if (pedantic && TREE_CODE (type) == FUNCTION_TYPE
5474 pedwarn (loc, OPT_pedantic,
5475 "ISO C forbids qualified function types");
5477 type = c_build_qualified_type (type, type_quals);
5478 size_varies = false;
5480 /* When the pointed-to type involves components of variable size,
5481 care must be taken to ensure that the size evaluation code is
5482 emitted early enough to dominate all the possible later uses
5483 and late enough for the variables on which it depends to have
5486 This is expected to happen automatically when the pointed-to
5487 type has a name/declaration of it's own, but special attention
5488 is required if the type is anonymous.
5490 We handle the NORMAL and FIELD contexts here by attaching an
5491 artificial TYPE_DECL to such pointed-to type. This forces the
5492 sizes evaluation at a safe point and ensures it is not deferred
5493 until e.g. within a deeper conditional context.
5495 We expect nothing to be needed here for PARM or TYPENAME.
5496 Pushing a TYPE_DECL at this point for TYPENAME would actually
5497 be incorrect, as we might be in the middle of an expression
5498 with side effects on the pointed-to type size "arguments" prior
5499 to the pointer declaration point and the fake TYPE_DECL in the
5500 enclosing context would force the size evaluation prior to the
5503 if (!TYPE_NAME (type)
5504 && (decl_context == NORMAL || decl_context == FIELD)
5505 && variably_modified_type_p (type, NULL_TREE))
5507 tree decl = build_decl (loc, TYPE_DECL, NULL_TREE, type);
5508 DECL_ARTIFICIAL (decl) = 1;
5510 finish_decl (decl, loc, NULL_TREE, NULL_TREE, NULL_TREE);
5511 TYPE_NAME (type) = decl;
5514 type = build_pointer_type (type);
5516 /* Process type qualifiers (such as const or volatile)
5517 that were given inside the `*'. */
5518 type_quals = declarator->u.pointer_quals;
5520 declarator = declarator->declarator;
5527 *decl_attrs = chainon (returned_attrs, *decl_attrs);
5529 /* Now TYPE has the actual type, apart from any qualifiers in
5532 /* Check the type and width of a bit-field. */
5534 check_bitfield_type_and_width (&type, width, name);
5536 /* Did array size calculations overflow? */
5538 if (TREE_CODE (type) == ARRAY_TYPE
5539 && COMPLETE_TYPE_P (type)
5540 && TREE_CODE (TYPE_SIZE_UNIT (type)) == INTEGER_CST
5541 && TREE_OVERFLOW (TYPE_SIZE_UNIT (type)))
5544 error_at (loc, "size of array %qE is too large", name);
5546 error_at (loc, "size of unnamed array is too large");
5547 /* If we proceed with the array type as it is, we'll eventually
5548 crash in tree_low_cst(). */
5549 type = error_mark_node;
5552 /* If this is declaring a typedef name, return a TYPE_DECL. */
5554 if (storage_class == csc_typedef)
5557 if (pedantic && TREE_CODE (type) == FUNCTION_TYPE
5559 pedwarn (loc, OPT_pedantic,
5560 "ISO C forbids qualified function types");
5562 type = c_build_qualified_type (type, type_quals);
5563 decl = build_decl (declarator->id_loc,
5564 TYPE_DECL, declarator->u.id, type);
5565 if (declspecs->explicit_signed_p)
5566 C_TYPEDEF_EXPLICITLY_SIGNED (decl) = 1;
5567 if (declspecs->inline_p)
5568 pedwarn (loc, 0,"typedef %q+D declared %<inline%>", decl);
5570 if (warn_cxx_compat && declarator->u.id != NULL_TREE)
5572 struct c_binding *b = I_TAG_BINDING (declarator->u.id);
5575 && b->decl != NULL_TREE
5576 && (B_IN_CURRENT_SCOPE (b)
5577 || (current_scope == file_scope && B_IN_EXTERNAL_SCOPE (b)))
5578 && TYPE_MAIN_VARIANT (b->decl) != TYPE_MAIN_VARIANT (type))
5580 warning_at (declarator->id_loc, OPT_Wc___compat,
5581 ("using %qD as both a typedef and a tag is "
5584 if (b->locus != UNKNOWN_LOCATION)
5585 inform (b->locus, "originally defined here");
5592 /* If this is a type name (such as, in a cast or sizeof),
5593 compute the type and return it now. */
5595 if (decl_context == TYPENAME)
5597 /* Note that the grammar rejects storage classes in typenames
5599 gcc_assert (storage_class == csc_none && !threadp
5600 && !declspecs->inline_p);
5601 if (pedantic && TREE_CODE (type) == FUNCTION_TYPE
5603 pedwarn (loc, OPT_pedantic,
5604 "ISO C forbids const or volatile function types");
5606 type = c_build_qualified_type (type, type_quals);
5610 if (pedantic && decl_context == FIELD
5611 && variably_modified_type_p (type, NULL_TREE))
5614 pedwarn (loc, OPT_pedantic, "a member of a structure or union cannot "
5615 "have a variably modified type");
5618 /* Aside from typedefs and type names (handle above),
5619 `void' at top level (not within pointer)
5620 is allowed only in public variables.
5621 We don't complain about parms either, but that is because
5622 a better error message can be made later. */
5624 if (VOID_TYPE_P (type) && decl_context != PARM
5625 && !((decl_context != FIELD && TREE_CODE (type) != FUNCTION_TYPE)
5626 && (storage_class == csc_extern
5627 || (current_scope == file_scope
5628 && !(storage_class == csc_static
5629 || storage_class == csc_register)))))
5631 error_at (loc, "variable or field %qE declared void", name);
5632 type = integer_type_node;
5635 /* Now create the decl, which may be a VAR_DECL, a PARM_DECL
5636 or a FUNCTION_DECL, depending on DECL_CONTEXT and TYPE. */
5641 if (decl_context == PARM)
5645 /* A parameter declared as an array of T is really a pointer to T.
5646 One declared as a function is really a pointer to a function. */
5648 if (TREE_CODE (type) == ARRAY_TYPE)
5650 /* Transfer const-ness of array into that of type pointed to. */
5651 type = TREE_TYPE (type);
5653 type = c_build_qualified_type (type, type_quals);
5654 type = build_pointer_type (type);
5655 type_quals = array_ptr_quals;
5657 type = c_build_qualified_type (type, type_quals);
5659 /* We don't yet implement attributes in this context. */
5660 if (array_ptr_attrs != NULL_TREE)
5661 warning_at (loc, OPT_Wattributes,
5662 "attributes in parameter array declarator ignored");
5664 size_varies = false;
5666 else if (TREE_CODE (type) == FUNCTION_TYPE)
5669 pedwarn (loc, OPT_pedantic,
5670 "ISO C forbids qualified function types");
5672 type = c_build_qualified_type (type, type_quals);
5673 type = build_pointer_type (type);
5674 type_quals = TYPE_UNQUALIFIED;
5676 else if (type_quals)
5677 type = c_build_qualified_type (type, type_quals);
5679 decl = build_decl (declarator->id_loc,
5680 PARM_DECL, declarator->u.id, type);
5682 C_DECL_VARIABLE_SIZE (decl) = 1;
5684 /* Compute the type actually passed in the parmlist,
5685 for the case where there is no prototype.
5686 (For example, shorts and chars are passed as ints.)
5687 When there is a prototype, this is overridden later. */
5689 if (type == error_mark_node)
5690 promoted_type = type;
5692 promoted_type = c_type_promotes_to (type);
5694 DECL_ARG_TYPE (decl) = promoted_type;
5695 if (declspecs->inline_p)
5696 pedwarn (loc, 0, "parameter %q+D declared %<inline%>", decl);
5698 else if (decl_context == FIELD)
5700 /* Note that the grammar rejects storage classes in typenames
5702 gcc_assert (storage_class == csc_none && !threadp
5703 && !declspecs->inline_p);
5705 /* Structure field. It may not be a function. */
5707 if (TREE_CODE (type) == FUNCTION_TYPE)
5709 error_at (loc, "field %qE declared as a function", name);
5710 type = build_pointer_type (type);
5712 else if (TREE_CODE (type) != ERROR_MARK
5713 && !COMPLETE_OR_UNBOUND_ARRAY_TYPE_P (type))
5716 error_at (loc, "field %qE has incomplete type", name);
5718 error_at (loc, "unnamed field has incomplete type");
5719 type = error_mark_node;
5721 type = c_build_qualified_type (type, type_quals);
5722 decl = build_decl (declarator->id_loc,
5723 FIELD_DECL, declarator->u.id, type);
5724 DECL_NONADDRESSABLE_P (decl) = bitfield;
5725 if (bitfield && !declarator->u.id)
5726 TREE_NO_WARNING (decl) = 1;
5729 C_DECL_VARIABLE_SIZE (decl) = 1;
5731 else if (TREE_CODE (type) == FUNCTION_TYPE)
5733 if (storage_class == csc_register || threadp)
5735 error_at (loc, "invalid storage class for function %qE", name);
5737 else if (current_scope != file_scope)
5739 /* Function declaration not at file scope. Storage
5740 classes other than `extern' are not allowed, C99
5741 6.7.1p5, and `extern' makes no difference. However,
5742 GCC allows 'auto', perhaps with 'inline', to support
5743 nested functions. */
5744 if (storage_class == csc_auto)
5745 pedwarn (loc, OPT_pedantic,
5746 "invalid storage class for function %qE", name);
5747 else if (storage_class == csc_static)
5749 error_at (loc, "invalid storage class for function %qE", name);
5751 storage_class = declspecs->storage_class = csc_none;
5757 decl = build_decl (declarator->id_loc,
5758 FUNCTION_DECL, declarator->u.id, type);
5759 decl = build_decl_attribute_variant (decl, decl_attr);
5761 if (pedantic && type_quals && !DECL_IN_SYSTEM_HEADER (decl))
5762 pedwarn (loc, OPT_pedantic,
5763 "ISO C forbids qualified function types");
5765 /* GNU C interprets a volatile-qualified function type to indicate
5766 that the function does not return. */
5767 if ((type_quals & TYPE_QUAL_VOLATILE)
5768 && !VOID_TYPE_P (TREE_TYPE (TREE_TYPE (decl))))
5769 warning_at (loc, 0, "%<noreturn%> function returns non-void value");
5771 /* Every function declaration is an external reference
5772 (DECL_EXTERNAL) except for those which are not at file
5773 scope and are explicitly declared "auto". This is
5774 forbidden by standard C (C99 6.7.1p5) and is interpreted by
5775 GCC to signify a forward declaration of a nested function. */
5776 if (storage_class == csc_auto && current_scope != file_scope)
5777 DECL_EXTERNAL (decl) = 0;
5778 /* In C99, a function which is declared 'inline' with 'extern'
5779 is not an external reference (which is confusing). It
5780 means that the later definition of the function must be output
5781 in this file, C99 6.7.4p6. In GNU C89, a function declared
5782 'extern inline' is an external reference. */
5783 else if (declspecs->inline_p && storage_class != csc_static)
5784 DECL_EXTERNAL (decl) = ((storage_class == csc_extern)
5785 == flag_gnu89_inline);
5787 DECL_EXTERNAL (decl) = !initialized;
5789 /* Record absence of global scope for `static' or `auto'. */
5791 = !(storage_class == csc_static || storage_class == csc_auto);
5793 /* For a function definition, record the argument information
5794 block where store_parm_decls will look for it. */
5796 current_function_arg_info = arg_info;
5798 if (declspecs->default_int_p)
5799 C_FUNCTION_IMPLICIT_INT (decl) = 1;
5801 /* Record presence of `inline', if it is reasonable. */
5802 if (flag_hosted && MAIN_NAME_P (declarator->u.id))
5804 if (declspecs->inline_p)
5805 pedwarn (loc, 0, "cannot inline function %<main%>");
5807 else if (declspecs->inline_p)
5808 /* Record that the function is declared `inline'. */
5809 DECL_DECLARED_INLINE_P (decl) = 1;
5813 /* It's a variable. */
5814 /* An uninitialized decl with `extern' is a reference. */
5815 int extern_ref = !initialized && storage_class == csc_extern;
5817 type = c_build_qualified_type (type, type_quals);
5819 /* C99 6.2.2p7: It is invalid (compile-time undefined
5820 behavior) to create an 'extern' declaration for a
5821 variable if there is a global declaration that is
5822 'static' and the global declaration is not visible.
5823 (If the static declaration _is_ currently visible,
5824 the 'extern' declaration is taken to refer to that decl.) */
5825 if (extern_ref && current_scope != file_scope)
5827 tree global_decl = identifier_global_value (declarator->u.id);
5828 tree visible_decl = lookup_name (declarator->u.id);
5831 && global_decl != visible_decl
5832 && TREE_CODE (global_decl) == VAR_DECL
5833 && !TREE_PUBLIC (global_decl))
5834 error_at (loc, "variable previously declared %<static%> "
5835 "redeclared %<extern%>");
5838 decl = build_decl (declarator->id_loc,
5839 VAR_DECL, declarator->u.id, type);
5841 C_DECL_VARIABLE_SIZE (decl) = 1;
5843 if (declspecs->inline_p)
5844 pedwarn (loc, 0, "variable %q+D declared %<inline%>", decl);
5846 /* At file scope, an initialized extern declaration may follow
5847 a static declaration. In that case, DECL_EXTERNAL will be
5848 reset later in start_decl. */
5849 DECL_EXTERNAL (decl) = (storage_class == csc_extern);
5851 /* At file scope, the presence of a `static' or `register' storage
5852 class specifier, or the absence of all storage class specifiers
5853 makes this declaration a definition (perhaps tentative). Also,
5854 the absence of `static' makes it public. */
5855 if (current_scope == file_scope)
5857 TREE_PUBLIC (decl) = storage_class != csc_static;
5858 TREE_STATIC (decl) = !extern_ref;
5860 /* Not at file scope, only `static' makes a static definition. */
5863 TREE_STATIC (decl) = (storage_class == csc_static);
5864 TREE_PUBLIC (decl) = extern_ref;
5868 DECL_TLS_MODEL (decl) = decl_default_tls_model (decl);
5871 if ((storage_class == csc_extern
5872 || (storage_class == csc_none
5873 && TREE_CODE (type) == FUNCTION_TYPE
5875 && variably_modified_type_p (type, NULL_TREE))
5878 if (TREE_CODE (type) == FUNCTION_TYPE)
5879 error_at (loc, "non-nested function with variably modified type");
5881 error_at (loc, "object with variably modified type must have "
5885 /* Record `register' declaration for warnings on &
5886 and in case doing stupid register allocation. */
5888 if (storage_class == csc_register)
5890 C_DECL_REGISTER (decl) = 1;
5891 DECL_REGISTER (decl) = 1;
5894 /* Record constancy and volatility. */
5895 c_apply_type_quals_to_decl (type_quals, decl);
5897 /* If a type has volatile components, it should be stored in memory.
5898 Otherwise, the fact that those components are volatile
5899 will be ignored, and would even crash the compiler.
5900 Of course, this only makes sense on VAR,PARM, and RESULT decl's. */
5901 if (C_TYPE_FIELDS_VOLATILE (TREE_TYPE (decl))
5902 && (TREE_CODE (decl) == VAR_DECL || TREE_CODE (decl) == PARM_DECL
5903 || TREE_CODE (decl) == RESULT_DECL))
5905 /* It is not an error for a structure with volatile fields to
5906 be declared register, but reset DECL_REGISTER since it
5907 cannot actually go in a register. */
5908 int was_reg = C_DECL_REGISTER (decl);
5909 C_DECL_REGISTER (decl) = 0;
5910 DECL_REGISTER (decl) = 0;
5911 c_mark_addressable (decl);
5912 C_DECL_REGISTER (decl) = was_reg;
5915 /* This is the earliest point at which we might know the assembler
5916 name of a variable. Thus, if it's known before this, die horribly. */
5917 gcc_assert (!DECL_ASSEMBLER_NAME_SET_P (decl));
5920 && TREE_CODE (decl) == VAR_DECL
5921 && TREE_PUBLIC (decl)
5922 && TREE_STATIC (decl)
5923 && (TREE_CODE (TREE_TYPE (decl)) == RECORD_TYPE
5924 || TREE_CODE (TREE_TYPE (decl)) == UNION_TYPE
5925 || TREE_CODE (TREE_TYPE (decl)) == ENUMERAL_TYPE)
5926 && TYPE_NAME (TREE_TYPE (decl)) == NULL_TREE)
5927 warning_at (DECL_SOURCE_LOCATION (decl), OPT_Wc___compat,
5928 ("non-local variable %qD with anonymous type is "
5929 "questionable in C++"),
5936 /* Decode the parameter-list info for a function type or function definition.
5937 The argument is the value returned by `get_parm_info' (or made in c-parse.c
5938 if there is an identifier list instead of a parameter decl list).
5939 These two functions are separate because when a function returns
5940 or receives functions then each is called multiple times but the order
5941 of calls is different. The last call to `grokparms' is always the one
5942 that contains the formal parameter names of a function definition.
5944 Return a list of arg types to use in the FUNCTION_TYPE for this function.
5946 FUNCDEF_FLAG is true for a function definition, false for
5947 a mere declaration. A nonempty identifier-list gets an error message
5948 when FUNCDEF_FLAG is false. */
5951 grokparms (struct c_arg_info *arg_info, bool funcdef_flag)
5953 tree arg_types = arg_info->types;
5955 if (funcdef_flag && arg_info->had_vla_unspec)
5957 /* A function definition isn't function prototype scope C99 6.2.1p4. */
5959 error ("%<[*]%> not allowed in other than function prototype scope");
5962 if (arg_types == 0 && !funcdef_flag && !in_system_header)
5963 warning (OPT_Wstrict_prototypes,
5964 "function declaration isn%'t a prototype");
5966 if (arg_types == error_mark_node)
5967 return 0; /* don't set TYPE_ARG_TYPES in this case */
5969 else if (arg_types && TREE_CODE (TREE_VALUE (arg_types)) == IDENTIFIER_NODE)
5972 pedwarn (input_location, 0, "parameter names (without types) in function declaration");
5974 arg_info->parms = arg_info->types;
5975 arg_info->types = 0;
5980 tree parm, type, typelt;
5981 unsigned int parmno;
5984 /* If there is a parameter of incomplete type in a definition,
5985 this is an error. In a declaration this is valid, and a
5986 struct or union type may be completed later, before any calls
5987 or definition of the function. In the case where the tag was
5988 first declared within the parameter list, a warning has
5989 already been given. If a parameter has void type, then
5990 however the function cannot be defined or called, so
5993 for (parm = arg_info->parms, typelt = arg_types, parmno = 1;
5995 parm = TREE_CHAIN (parm), typelt = TREE_CHAIN (typelt), parmno++)
5997 type = TREE_VALUE (typelt);
5998 if (type == error_mark_node)
6001 if (!COMPLETE_TYPE_P (type))
6005 if (DECL_NAME (parm))
6006 error_at (input_location,
6007 "parameter %u (%q+D) has incomplete type",
6010 error_at (DECL_SOURCE_LOCATION (parm),
6011 "parameter %u has incomplete type",
6014 TREE_VALUE (typelt) = error_mark_node;
6015 TREE_TYPE (parm) = error_mark_node;
6017 else if (VOID_TYPE_P (type))
6019 if (DECL_NAME (parm))
6020 warning_at (input_location, 0,
6021 "parameter %u (%q+D) has void type",
6024 warning_at (DECL_SOURCE_LOCATION (parm), 0,
6025 "parameter %u has void type",
6030 errmsg = targetm.invalid_parameter_type (type);
6034 TREE_VALUE (typelt) = error_mark_node;
6035 TREE_TYPE (parm) = error_mark_node;
6038 if (DECL_NAME (parm) && TREE_USED (parm))
6039 warn_if_shadowing (parm);
6045 /* Take apart the current scope and return a c_arg_info structure with
6046 info on a parameter list just parsed.
6048 This structure is later fed to 'grokparms' and 'store_parm_decls'.
6050 ELLIPSIS being true means the argument list ended in '...' so don't
6051 append a sentinel (void_list_node) to the end of the type-list. */
6054 get_parm_info (bool ellipsis)
6056 struct c_binding *b = current_scope->bindings;
6057 struct c_arg_info *arg_info = XOBNEW (&parser_obstack,
6064 static bool explained_incomplete_types = false;
6065 bool gave_void_only_once_err = false;
6067 arg_info->parms = 0;
6069 arg_info->types = 0;
6070 arg_info->others = 0;
6071 arg_info->pending_sizes = 0;
6072 arg_info->had_vla_unspec = current_scope->had_vla_unspec;
6074 /* The bindings in this scope must not get put into a block.
6075 We will take care of deleting the binding nodes. */
6076 current_scope->bindings = 0;
6078 /* This function is only called if there was *something* on the
6082 /* A parameter list consisting solely of 'void' indicates that the
6083 function takes no arguments. But if the 'void' is qualified
6084 (by 'const' or 'volatile'), or has a storage class specifier
6085 ('register'), then the behavior is undefined; issue an error.
6086 Typedefs for 'void' are OK (see DR#157). */
6087 if (b->prev == 0 /* one binding */
6088 && TREE_CODE (b->decl) == PARM_DECL /* which is a parameter */
6089 && !DECL_NAME (b->decl) /* anonymous */
6090 && VOID_TYPE_P (TREE_TYPE (b->decl))) /* of void type */
6092 if (TREE_THIS_VOLATILE (b->decl)
6093 || TREE_READONLY (b->decl)
6094 || C_DECL_REGISTER (b->decl))
6095 error ("%<void%> as only parameter may not be qualified");
6097 /* There cannot be an ellipsis. */
6099 error ("%<void%> must be the only parameter");
6101 arg_info->types = void_list_node;
6106 types = void_list_node;
6108 /* Break up the bindings list into parms, tags, types, and others;
6109 apply sanity checks; purge the name-to-decl bindings. */
6112 tree decl = b->decl;
6113 tree type = TREE_TYPE (decl);
6114 const char *keyword;
6116 switch (TREE_CODE (decl))
6121 gcc_assert (I_SYMBOL_BINDING (b->id) == b);
6122 I_SYMBOL_BINDING (b->id) = b->shadowed;
6125 /* Check for forward decls that never got their actual decl. */
6126 if (TREE_ASM_WRITTEN (decl))
6127 error ("parameter %q+D has just a forward declaration", decl);
6128 /* Check for (..., void, ...) and issue an error. */
6129 else if (VOID_TYPE_P (type) && !DECL_NAME (decl))
6131 if (!gave_void_only_once_err)
6133 error ("%<void%> must be the only parameter");
6134 gave_void_only_once_err = true;
6139 /* Valid parameter, add it to the list. */
6140 TREE_CHAIN (decl) = parms;
6143 /* Since there is a prototype, args are passed in their
6144 declared types. The back end may override this later. */
6145 DECL_ARG_TYPE (decl) = type;
6146 types = tree_cons (0, type, types);
6150 case ENUMERAL_TYPE: keyword = "enum"; goto tag;
6151 case UNION_TYPE: keyword = "union"; goto tag;
6152 case RECORD_TYPE: keyword = "struct"; goto tag;
6154 /* Types may not have tag-names, in which case the type
6155 appears in the bindings list with b->id NULL. */
6158 gcc_assert (I_TAG_BINDING (b->id) == b);
6159 I_TAG_BINDING (b->id) = b->shadowed;
6162 /* Warn about any struct, union or enum tags defined in a
6163 parameter list. The scope of such types is limited to
6164 the parameter list, which is rarely if ever desirable
6165 (it's impossible to call such a function with type-
6166 correct arguments). An anonymous union parm type is
6167 meaningful as a GNU extension, so don't warn for that. */
6168 if (TREE_CODE (decl) != UNION_TYPE || b->id != 0)
6171 /* The %s will be one of 'struct', 'union', or 'enum'. */
6172 warning (0, "%<%s %E%> declared inside parameter list",
6175 /* The %s will be one of 'struct', 'union', or 'enum'. */
6176 warning (0, "anonymous %s declared inside parameter list",
6179 if (!explained_incomplete_types)
6181 warning (0, "its scope is only this definition or declaration,"
6182 " which is probably not what you want");
6183 explained_incomplete_types = true;
6187 tags = tree_cons (b->id, decl, tags);
6193 /* CONST_DECLs appear here when we have an embedded enum,
6194 and TYPE_DECLs appear here when we have an embedded struct
6195 or union. No warnings for this - we already warned about the
6196 type itself. FUNCTION_DECLs appear when there is an implicit
6197 function declaration in the parameter list. */
6199 TREE_CHAIN (decl) = others;
6204 /* error_mark_node appears here when we have an undeclared
6205 variable. Just throw it away. */
6208 gcc_assert (I_SYMBOL_BINDING (b->id) == b);
6209 I_SYMBOL_BINDING (b->id) = b->shadowed;
6213 /* Other things that might be encountered. */
6220 b = free_binding_and_advance (b);
6223 arg_info->parms = parms;
6224 arg_info->tags = tags;
6225 arg_info->types = types;
6226 arg_info->others = others;
6227 arg_info->pending_sizes = get_pending_sizes ();
6231 /* Get the struct, enum or union (CODE says which) with tag NAME.
6232 Define the tag as a forward-reference with location LOC if it is
6233 not defined. Return a c_typespec structure for the type
6237 parser_xref_tag (location_t loc, enum tree_code code, tree name)
6239 struct c_typespec ret;
6243 ret.expr = NULL_TREE;
6244 ret.expr_const_operands = true;
6246 /* If a cross reference is requested, look up the type
6247 already defined for this tag and return it. */
6249 ref = lookup_tag (code, name, 0, &refloc);
6250 /* If this is the right type of tag, return what we found.
6251 (This reference will be shadowed by shadow_tag later if appropriate.)
6252 If this is the wrong type of tag, do not return it. If it was the
6253 wrong type in the same scope, we will have had an error
6254 message already; if in a different scope and declaring
6255 a name, pending_xref_error will give an error message; but if in a
6256 different scope and not declaring a name, this tag should
6257 shadow the previous declaration of a different type of tag, and
6258 this would not work properly if we return the reference found.
6259 (For example, with "struct foo" in an outer scope, "union foo;"
6260 must shadow that tag with a new one of union type.) */
6261 ret.kind = (ref ? ctsk_tagref : ctsk_tagfirstref);
6262 if (ref && TREE_CODE (ref) == code)
6264 if (C_TYPE_DEFINED_IN_STRUCT (ref)
6265 && loc != UNKNOWN_LOCATION
6271 warning_at (loc, OPT_Wc___compat,
6272 ("enum type defined in struct or union "
6273 "is not visible in C++"));
6274 inform (refloc, "enum type defined here");
6277 warning_at (loc, OPT_Wc___compat,
6278 ("struct defined in struct or union "
6279 "is not visible in C++"));
6280 inform (refloc, "struct defined here");
6283 warning_at (loc, OPT_Wc___compat,
6284 ("union defined in struct or union "
6285 "is not visible in C++"));
6286 inform (refloc, "union defined here");
6297 /* If no such tag is yet defined, create a forward-reference node
6298 and record it as the "definition".
6299 When a real declaration of this type is found,
6300 the forward-reference will be altered into a real type. */
6302 ref = make_node (code);
6303 if (code == ENUMERAL_TYPE)
6305 /* Give the type a default layout like unsigned int
6306 to avoid crashing if it does not get defined. */
6307 SET_TYPE_MODE (ref, TYPE_MODE (unsigned_type_node));
6308 TYPE_ALIGN (ref) = TYPE_ALIGN (unsigned_type_node);
6309 TYPE_USER_ALIGN (ref) = 0;
6310 TYPE_UNSIGNED (ref) = 1;
6311 TYPE_PRECISION (ref) = TYPE_PRECISION (unsigned_type_node);
6312 TYPE_MIN_VALUE (ref) = TYPE_MIN_VALUE (unsigned_type_node);
6313 TYPE_MAX_VALUE (ref) = TYPE_MAX_VALUE (unsigned_type_node);
6316 pushtag (loc, name, ref);
6322 /* Get the struct, enum or union (CODE says which) with tag NAME.
6323 Define the tag as a forward-reference if it is not defined.
6324 Return a tree for the type. */
6327 xref_tag (enum tree_code code, tree name)
6329 return parser_xref_tag (input_location, code, name).spec;
6332 /* Make sure that the tag NAME is defined *in the current scope*
6333 at least as a forward reference.
6334 LOC is the location of the struct's definition.
6335 CODE says which kind of tag NAME ought to be.
6337 This stores the current value of the file static STRUCT_PARSE_INFO
6338 in *ENCLOSING_STRUCT_PARSE_INFO, and points STRUCT_PARSE_INFO at a
6339 new c_struct_parse_info structure. The old value of
6340 STRUCT_PARSE_INFO is restored in finish_struct. */
6343 start_struct (location_t loc, enum tree_code code, tree name,
6344 struct c_struct_parse_info **enclosing_struct_parse_info)
6346 /* If there is already a tag defined at this scope
6347 (as a forward reference), just return it. */
6349 tree ref = NULL_TREE;
6350 location_t refloc = UNKNOWN_LOCATION;
6352 if (name != NULL_TREE)
6353 ref = lookup_tag (code, name, 1, &refloc);
6354 if (ref && TREE_CODE (ref) == code)
6356 if (TYPE_SIZE (ref))
6358 if (code == UNION_TYPE)
6359 error_at (loc, "redefinition of %<union %E%>", name);
6361 error_at (loc, "redefinition of %<struct %E%>", name);
6362 if (refloc != UNKNOWN_LOCATION)
6363 inform (refloc, "originally defined here");
6364 /* Don't create structures using a name already in use. */
6367 else if (C_TYPE_BEING_DEFINED (ref))
6369 if (code == UNION_TYPE)
6370 error_at (loc, "nested redefinition of %<union %E%>", name);
6372 error_at (loc, "nested redefinition of %<struct %E%>", name);
6373 /* Don't bother to report "originally defined here" for a
6374 nested redefinition; the original definition should be
6376 /* Don't create structures that contain themselves. */
6381 /* Otherwise create a forward-reference just so the tag is in scope. */
6383 if (ref == NULL_TREE || TREE_CODE (ref) != code)
6385 ref = make_node (code);
6386 pushtag (loc, name, ref);
6389 C_TYPE_BEING_DEFINED (ref) = 1;
6390 TYPE_PACKED (ref) = flag_pack_struct;
6392 *enclosing_struct_parse_info = struct_parse_info;
6393 struct_parse_info = XNEW (struct c_struct_parse_info);
6394 struct_parse_info->struct_types = VEC_alloc (tree, heap, 0);
6395 struct_parse_info->fields = VEC_alloc (c_binding_ptr, heap, 0);
6396 struct_parse_info->typedefs_seen = VEC_alloc (tree, heap, 0);
6398 /* FIXME: This will issue a warning for a use of a type defined
6399 within a statement expr used within sizeof, et. al. This is not
6400 terribly serious as C++ doesn't permit statement exprs within
6402 if (warn_cxx_compat && (in_sizeof || in_typeof || in_alignof))
6403 warning_at (loc, OPT_Wc___compat,
6404 "defining type in %qs expression is invalid in C++",
6407 : (in_typeof ? "typeof" : "alignof")));
6412 /* Process the specs, declarator and width (NULL if omitted)
6413 of a structure component, returning a FIELD_DECL node.
6414 WIDTH is non-NULL for bit-fields only, and is an INTEGER_CST node.
6415 DECL_ATTRS is as for grokdeclarator.
6417 LOC is the location of the structure component.
6419 This is done during the parsing of the struct declaration.
6420 The FIELD_DECL nodes are chained together and the lot of them
6421 are ultimately passed to `build_struct' to make the RECORD_TYPE node. */
6424 grokfield (location_t loc,
6425 struct c_declarator *declarator, struct c_declspecs *declspecs,
6426 tree width, tree *decl_attrs)
6430 if (declarator->kind == cdk_id && declarator->u.id == NULL_TREE
6431 && width == NULL_TREE)
6433 /* This is an unnamed decl.
6435 If we have something of the form "union { list } ;" then this
6436 is the anonymous union extension. Similarly for struct.
6438 If this is something of the form "struct foo;", then
6439 If MS extensions are enabled, this is handled as an
6441 Otherwise this is a forward declaration of a structure tag.
6443 If this is something of the form "foo;" and foo is a TYPE_DECL, then
6444 If MS extensions are enabled and foo names a structure, then
6445 again this is an anonymous struct.
6446 Otherwise this is an error.
6448 Oh what a horrid tangled web we weave. I wonder if MS consciously
6449 took this from Plan 9 or if it was an accident of implementation
6450 that took root before someone noticed the bug... */
6452 tree type = declspecs->type;
6453 bool type_ok = (TREE_CODE (type) == RECORD_TYPE
6454 || TREE_CODE (type) == UNION_TYPE);
6458 && (flag_ms_extensions || !declspecs->typedef_p))
6460 if (flag_ms_extensions)
6464 else if (TYPE_NAME (type) == NULL)
6471 pedwarn (loc, 0, "declaration does not declare anything");
6474 pedwarn (loc, OPT_pedantic, "ISO C doesn%'t support unnamed structs/unions");
6477 value = grokdeclarator (declarator, declspecs, FIELD, false,
6478 width ? &width : NULL, decl_attrs, NULL, NULL,
6481 finish_decl (value, loc, NULL_TREE, NULL_TREE, NULL_TREE);
6482 DECL_INITIAL (value) = width;
6484 if (warn_cxx_compat && DECL_NAME (value) != NULL_TREE)
6486 /* If we currently have a binding for this field, set the
6487 in_struct field in the binding, so that we warn about lookups
6489 struct c_binding *b = I_SYMBOL_BINDING (DECL_NAME (value));
6492 /* If the in_struct field is not yet set, push it on a list
6493 to be cleared when this struct is finished. */
6496 VEC_safe_push (c_binding_ptr, heap,
6497 struct_parse_info->fields, b);
6506 /* Generate an error for any duplicate field names in FIELDLIST. Munge
6507 the list such that this does not present a problem later. */
6510 detect_field_duplicates (tree fieldlist)
6515 /* First, see if there are more than "a few" fields.
6516 This is trivially true if there are zero or one fields. */
6519 x = TREE_CHAIN (fieldlist);
6525 } while (timeout > 0 && x);
6527 /* If there were "few" fields, avoid the overhead of allocating
6528 a hash table. Instead just do the nested traversal thing. */
6531 for (x = TREE_CHAIN (fieldlist); x ; x = TREE_CHAIN (x))
6534 for (y = fieldlist; y != x; y = TREE_CHAIN (y))
6535 if (DECL_NAME (y) == DECL_NAME (x))
6537 error ("duplicate member %q+D", x);
6538 DECL_NAME (x) = NULL_TREE;
6544 htab_t htab = htab_create (37, htab_hash_pointer, htab_eq_pointer, NULL);
6547 for (x = fieldlist; x ; x = TREE_CHAIN (x))
6548 if ((y = DECL_NAME (x)) != 0)
6550 slot = htab_find_slot (htab, y, INSERT);
6553 error ("duplicate member %q+D", x);
6554 DECL_NAME (x) = NULL_TREE;
6563 /* Finish up struct info used by -Wc++-compat. */
6566 warn_cxx_compat_finish_struct (tree fieldlist)
6570 struct c_binding *b;
6572 /* Set the C_TYPE_DEFINED_IN_STRUCT flag for each type defined in
6573 the current struct. We do this now at the end of the struct
6574 because the flag is used to issue visibility warnings, and we
6575 only want to issue those warnings if the type is referenced
6576 outside of the struct declaration. */
6577 for (ix = 0; VEC_iterate (tree, struct_parse_info->struct_types, ix, x); ++ix)
6578 C_TYPE_DEFINED_IN_STRUCT (x) = 1;
6580 /* The TYPEDEFS_SEEN field of STRUCT_PARSE_INFO is a list of
6581 typedefs used when declaring fields in this struct. If the name
6582 of any of the fields is also a typedef name then the struct would
6583 not parse in C++, because the C++ lookup rules say that the
6584 typedef name would be looked up in the context of the struct, and
6585 would thus be the field rather than the typedef. */
6586 if (!VEC_empty (tree, struct_parse_info->typedefs_seen)
6587 && fieldlist != NULL_TREE)
6589 /* Use a pointer_set using the name of the typedef. We can use
6590 a pointer_set because identifiers are interned. */
6591 struct pointer_set_t *tset = pointer_set_create ();
6594 VEC_iterate (tree, struct_parse_info->typedefs_seen, ix, x);
6596 pointer_set_insert (tset, DECL_NAME (x));
6598 for (x = fieldlist; x != NULL_TREE; x = TREE_CHAIN (x))
6600 if (pointer_set_contains (tset, DECL_NAME (x)))
6602 warning_at (DECL_SOURCE_LOCATION (x), OPT_Wc___compat,
6603 ("using %qD as both field and typedef name is "
6606 /* FIXME: It would be nice to report the location where
6607 the typedef name is used. */
6611 pointer_set_destroy (tset);
6614 /* For each field which has a binding and which was not defined in
6615 an enclosing struct, clear the in_struct field. */
6617 VEC_iterate (c_binding_ptr, struct_parse_info->fields, ix, b);
6622 /* Fill in the fields of a RECORD_TYPE or UNION_TYPE node, T.
6623 LOC is the location of the RECORD_TYPE or UNION_TYPE's definition.
6624 FIELDLIST is a chain of FIELD_DECL nodes for the fields.
6625 ATTRIBUTES are attributes to be applied to the structure.
6627 ENCLOSING_STRUCT_PARSE_INFO is the value of STRUCT_PARSE_INFO when
6628 the struct was started. */
6631 finish_struct (location_t loc, tree t, tree fieldlist, tree attributes,
6632 struct c_struct_parse_info *enclosing_struct_parse_info)
6635 bool toplevel = file_scope == current_scope;
6636 int saw_named_field;
6638 /* If this type was previously laid out as a forward reference,
6639 make sure we lay it out again. */
6643 decl_attributes (&t, attributes, (int) ATTR_FLAG_TYPE_IN_PLACE);
6647 for (x = fieldlist; x; x = TREE_CHAIN (x))
6648 if (DECL_NAME (x) != 0)
6653 if (TREE_CODE (t) == UNION_TYPE)
6656 pedwarn (loc, OPT_pedantic, "union has no named members");
6658 pedwarn (loc, OPT_pedantic, "union has no members");
6663 pedwarn (loc, OPT_pedantic, "struct has no named members");
6665 pedwarn (loc, OPT_pedantic, "struct has no members");
6670 /* Install struct as DECL_CONTEXT of each field decl.
6671 Also process specified field sizes, found in the DECL_INITIAL,
6672 storing 0 there after the type has been changed to precision equal
6673 to its width, rather than the precision of the specified standard
6674 type. (Correct layout requires the original type to have been preserved
6677 saw_named_field = 0;
6678 for (x = fieldlist; x; x = TREE_CHAIN (x))
6680 if (TREE_TYPE (x) == error_mark_node)
6683 DECL_CONTEXT (x) = t;
6685 /* If any field is const, the structure type is pseudo-const. */
6686 if (TREE_READONLY (x))
6687 C_TYPE_FIELDS_READONLY (t) = 1;
6690 /* A field that is pseudo-const makes the structure likewise. */
6691 tree t1 = TREE_TYPE (x);
6692 while (TREE_CODE (t1) == ARRAY_TYPE)
6693 t1 = TREE_TYPE (t1);
6694 if ((TREE_CODE (t1) == RECORD_TYPE || TREE_CODE (t1) == UNION_TYPE)
6695 && C_TYPE_FIELDS_READONLY (t1))
6696 C_TYPE_FIELDS_READONLY (t) = 1;
6699 /* Any field that is volatile means variables of this type must be
6700 treated in some ways as volatile. */
6701 if (TREE_THIS_VOLATILE (x))
6702 C_TYPE_FIELDS_VOLATILE (t) = 1;
6704 /* Any field of nominal variable size implies structure is too. */
6705 if (C_DECL_VARIABLE_SIZE (x))
6706 C_TYPE_VARIABLE_SIZE (t) = 1;
6708 if (DECL_INITIAL (x))
6710 unsigned HOST_WIDE_INT width = tree_low_cst (DECL_INITIAL (x), 1);
6711 DECL_SIZE (x) = bitsize_int (width);
6712 DECL_BIT_FIELD (x) = 1;
6713 SET_DECL_C_BIT_FIELD (x);
6717 && (DECL_BIT_FIELD (x)
6718 || TYPE_ALIGN (TREE_TYPE (x)) > BITS_PER_UNIT))
6719 DECL_PACKED (x) = 1;
6721 /* Detect flexible array member in an invalid context. */
6722 if (TREE_CODE (TREE_TYPE (x)) == ARRAY_TYPE
6723 && TYPE_SIZE (TREE_TYPE (x)) == NULL_TREE
6724 && TYPE_DOMAIN (TREE_TYPE (x)) != NULL_TREE
6725 && TYPE_MAX_VALUE (TYPE_DOMAIN (TREE_TYPE (x))) == NULL_TREE)
6727 if (TREE_CODE (t) == UNION_TYPE)
6729 error_at (DECL_SOURCE_LOCATION (x),
6730 "flexible array member in union");
6731 TREE_TYPE (x) = error_mark_node;
6733 else if (TREE_CHAIN (x) != NULL_TREE)
6735 error_at (DECL_SOURCE_LOCATION (x),
6736 "flexible array member not at end of struct");
6737 TREE_TYPE (x) = error_mark_node;
6739 else if (!saw_named_field)
6741 error_at (DECL_SOURCE_LOCATION (x),
6742 "flexible array member in otherwise empty struct");
6743 TREE_TYPE (x) = error_mark_node;
6747 if (pedantic && TREE_CODE (t) == RECORD_TYPE
6748 && flexible_array_type_p (TREE_TYPE (x)))
6749 pedwarn (DECL_SOURCE_LOCATION (x), OPT_pedantic,
6750 "invalid use of structure with flexible array member");
6753 saw_named_field = 1;
6756 detect_field_duplicates (fieldlist);
6758 /* Now we have the nearly final fieldlist. Record it,
6759 then lay out the structure or union (including the fields). */
6761 TYPE_FIELDS (t) = fieldlist;
6765 /* Give bit-fields their proper types. */
6767 tree *fieldlistp = &fieldlist;
6769 if (TREE_CODE (*fieldlistp) == FIELD_DECL && DECL_INITIAL (*fieldlistp)
6770 && TREE_TYPE (*fieldlistp) != error_mark_node)
6772 unsigned HOST_WIDE_INT width
6773 = tree_low_cst (DECL_INITIAL (*fieldlistp), 1);
6774 tree type = TREE_TYPE (*fieldlistp);
6775 if (width != TYPE_PRECISION (type))
6777 TREE_TYPE (*fieldlistp)
6778 = c_build_bitfield_integer_type (width, TYPE_UNSIGNED (type));
6779 DECL_MODE (*fieldlistp) = TYPE_MODE (TREE_TYPE (*fieldlistp));
6781 DECL_INITIAL (*fieldlistp) = 0;
6784 fieldlistp = &TREE_CHAIN (*fieldlistp);
6787 /* Now we have the truly final field list.
6788 Store it in this type and in the variants. */
6790 TYPE_FIELDS (t) = fieldlist;
6792 /* If there are lots of fields, sort so we can look through them fast.
6793 We arbitrarily consider 16 or more elts to be "a lot". */
6798 for (x = fieldlist; x; x = TREE_CHAIN (x))
6800 if (len > 15 || DECL_NAME (x) == NULL)
6808 struct lang_type *space;
6809 struct sorted_fields_type *space2;
6811 len += list_length (x);
6813 /* Use the same allocation policy here that make_node uses, to
6814 ensure that this lives as long as the rest of the struct decl.
6815 All decls in an inline function need to be saved. */
6817 space = GGC_CNEW (struct lang_type);
6818 space2 = GGC_NEWVAR (struct sorted_fields_type,
6819 sizeof (struct sorted_fields_type) + len * sizeof (tree));
6823 field_array = &space2->elts[0];
6824 for (x = fieldlist; x; x = TREE_CHAIN (x))
6826 field_array[len++] = x;
6828 /* If there is anonymous struct or union, break out of the loop. */
6829 if (DECL_NAME (x) == NULL)
6832 /* Found no anonymous struct/union. Add the TYPE_LANG_SPECIFIC. */
6835 TYPE_LANG_SPECIFIC (t) = space;
6836 TYPE_LANG_SPECIFIC (t)->s->len = len;
6837 field_array = TYPE_LANG_SPECIFIC (t)->s->elts;
6838 qsort (field_array, len, sizeof (tree), field_decl_cmp);
6843 for (x = TYPE_MAIN_VARIANT (t); x; x = TYPE_NEXT_VARIANT (x))
6845 TYPE_FIELDS (x) = TYPE_FIELDS (t);
6846 TYPE_LANG_SPECIFIC (x) = TYPE_LANG_SPECIFIC (t);
6847 C_TYPE_FIELDS_READONLY (x) = C_TYPE_FIELDS_READONLY (t);
6848 C_TYPE_FIELDS_VOLATILE (x) = C_TYPE_FIELDS_VOLATILE (t);
6849 C_TYPE_VARIABLE_SIZE (x) = C_TYPE_VARIABLE_SIZE (t);
6852 /* If this was supposed to be a transparent union, but we can't
6853 make it one, warn and turn off the flag. */
6854 if (TREE_CODE (t) == UNION_TYPE
6855 && TYPE_TRANSPARENT_UNION (t)
6856 && (!TYPE_FIELDS (t) || TYPE_MODE (t) != DECL_MODE (TYPE_FIELDS (t))))
6858 TYPE_TRANSPARENT_UNION (t) = 0;
6859 warning_at (loc, 0, "union cannot be made transparent");
6862 /* If this structure or union completes the type of any previous
6863 variable declaration, lay it out and output its rtl. */
6864 for (x = C_TYPE_INCOMPLETE_VARS (TYPE_MAIN_VARIANT (t));
6868 tree decl = TREE_VALUE (x);
6869 if (TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE)
6870 layout_array_type (TREE_TYPE (decl));
6871 if (TREE_CODE (decl) != TYPE_DECL)
6873 layout_decl (decl, 0);
6874 if (c_dialect_objc ())
6875 objc_check_decl (decl);
6876 rest_of_decl_compilation (decl, toplevel, 0);
6881 C_TYPE_INCOMPLETE_VARS (TYPE_MAIN_VARIANT (t)) = 0;
6883 /* Finish debugging output for this type. */
6884 rest_of_type_compilation (t, toplevel);
6886 /* If we're inside a function proper, i.e. not file-scope and not still
6887 parsing parameters, then arrange for the size of a variable sized type
6889 if (cur_stmt_list && variably_modified_type_p (t, NULL_TREE))
6890 add_stmt (build_stmt (loc,
6891 DECL_EXPR, build_decl (loc, TYPE_DECL, NULL, t)));
6893 if (warn_cxx_compat)
6894 warn_cxx_compat_finish_struct (fieldlist);
6896 VEC_free (tree, heap, struct_parse_info->struct_types);
6897 VEC_free (c_binding_ptr, heap, struct_parse_info->fields);
6898 VEC_free (tree, heap, struct_parse_info->typedefs_seen);
6899 XDELETE (struct_parse_info);
6901 struct_parse_info = enclosing_struct_parse_info;
6903 /* If this struct is defined inside a struct, add it to
6906 && struct_parse_info != NULL
6907 && !in_sizeof && !in_typeof && !in_alignof)
6908 VEC_safe_push (tree, heap, struct_parse_info->struct_types, t);
6913 /* Lay out the type T, and its element type, and so on. */
6916 layout_array_type (tree t)
6918 if (TREE_CODE (TREE_TYPE (t)) == ARRAY_TYPE)
6919 layout_array_type (TREE_TYPE (t));
6923 /* Begin compiling the definition of an enumeration type.
6924 NAME is its name (or null if anonymous).
6925 LOC is the enum's location.
6926 Returns the type object, as yet incomplete.
6927 Also records info about it so that build_enumerator
6928 may be used to declare the individual values as they are read. */
6931 start_enum (location_t loc, struct c_enum_contents *the_enum, tree name)
6933 tree enumtype = NULL_TREE;
6934 location_t enumloc = UNKNOWN_LOCATION;
6936 /* If this is the real definition for a previous forward reference,
6937 fill in the contents in the same object that used to be the
6938 forward reference. */
6940 if (name != NULL_TREE)
6941 enumtype = lookup_tag (ENUMERAL_TYPE, name, 1, &enumloc);
6943 if (enumtype == 0 || TREE_CODE (enumtype) != ENUMERAL_TYPE)
6945 enumtype = make_node (ENUMERAL_TYPE);
6946 pushtag (loc, name, enumtype);
6949 if (C_TYPE_BEING_DEFINED (enumtype))
6950 error_at (loc, "nested redefinition of %<enum %E%>", name);
6952 C_TYPE_BEING_DEFINED (enumtype) = 1;
6954 if (TYPE_VALUES (enumtype) != 0)
6956 /* This enum is a named one that has been declared already. */
6957 error_at (loc, "redeclaration of %<enum %E%>", name);
6958 if (enumloc != UNKNOWN_LOCATION)
6959 inform (enumloc, "originally defined here");
6961 /* Completely replace its old definition.
6962 The old enumerators remain defined, however. */
6963 TYPE_VALUES (enumtype) = 0;
6966 the_enum->enum_next_value = integer_zero_node;
6967 the_enum->enum_overflow = 0;
6969 if (flag_short_enums)
6970 TYPE_PACKED (enumtype) = 1;
6972 /* FIXME: This will issue a warning for a use of a type defined
6973 within sizeof in a statement expr. This is not terribly serious
6974 as C++ doesn't permit statement exprs within sizeof anyhow. */
6975 if (warn_cxx_compat && (in_sizeof || in_typeof || in_alignof))
6976 warning_at (loc, OPT_Wc___compat,
6977 "defining type in %qs expression is invalid in C++",
6980 : (in_typeof ? "typeof" : "alignof")));
6985 /* After processing and defining all the values of an enumeration type,
6986 install their decls in the enumeration type and finish it off.
6987 ENUMTYPE is the type object, VALUES a list of decl-value pairs,
6988 and ATTRIBUTES are the specified attributes.
6989 Returns ENUMTYPE. */
6992 finish_enum (tree enumtype, tree values, tree attributes)
6995 tree minnode = 0, maxnode = 0;
6996 int precision, unsign;
6997 bool toplevel = (file_scope == current_scope);
6998 struct lang_type *lt;
7000 decl_attributes (&enumtype, attributes, (int) ATTR_FLAG_TYPE_IN_PLACE);
7002 /* Calculate the maximum value of any enumerator in this type. */
7004 if (values == error_mark_node)
7005 minnode = maxnode = integer_zero_node;
7008 minnode = maxnode = TREE_VALUE (values);
7009 for (pair = TREE_CHAIN (values); pair; pair = TREE_CHAIN (pair))
7011 tree value = TREE_VALUE (pair);
7012 if (tree_int_cst_lt (maxnode, value))
7014 if (tree_int_cst_lt (value, minnode))
7019 /* Construct the final type of this enumeration. It is the same
7020 as one of the integral types - the narrowest one that fits, except
7021 that normally we only go as narrow as int - and signed iff any of
7022 the values are negative. */
7023 unsign = (tree_int_cst_sgn (minnode) >= 0);
7024 precision = MAX (tree_int_cst_min_precision (minnode, unsign),
7025 tree_int_cst_min_precision (maxnode, unsign));
7027 if (TYPE_PACKED (enumtype) || precision > TYPE_PRECISION (integer_type_node))
7029 tem = c_common_type_for_size (precision, unsign);
7032 warning (0, "enumeration values exceed range of largest integer");
7033 tem = long_long_integer_type_node;
7037 tem = unsign ? unsigned_type_node : integer_type_node;
7039 TYPE_MIN_VALUE (enumtype) = TYPE_MIN_VALUE (tem);
7040 TYPE_MAX_VALUE (enumtype) = TYPE_MAX_VALUE (tem);
7041 TYPE_UNSIGNED (enumtype) = TYPE_UNSIGNED (tem);
7042 TYPE_SIZE (enumtype) = 0;
7044 /* If the precision of the type was specific with an attribute and it
7045 was too small, give an error. Otherwise, use it. */
7046 if (TYPE_PRECISION (enumtype))
7048 if (precision > TYPE_PRECISION (enumtype))
7049 error ("specified mode too small for enumeral values");
7052 TYPE_PRECISION (enumtype) = TYPE_PRECISION (tem);
7054 layout_type (enumtype);
7056 if (values != error_mark_node)
7058 /* Change the type of the enumerators to be the enum type. We
7059 need to do this irrespective of the size of the enum, for
7060 proper type checking. Replace the DECL_INITIALs of the
7061 enumerators, and the value slots of the list, with copies
7062 that have the enum type; they cannot be modified in place
7063 because they may be shared (e.g. integer_zero_node) Finally,
7064 change the purpose slots to point to the names of the decls. */
7065 for (pair = values; pair; pair = TREE_CHAIN (pair))
7067 tree enu = TREE_PURPOSE (pair);
7068 tree ini = DECL_INITIAL (enu);
7070 TREE_TYPE (enu) = enumtype;
7072 /* The ISO C Standard mandates enumerators to have type int,
7073 even though the underlying type of an enum type is
7074 unspecified. However, GCC allows enumerators of any
7075 integer type as an extensions. build_enumerator()
7076 converts any enumerators that fit in an int to type int,
7077 to avoid promotions to unsigned types when comparing
7078 integers with enumerators that fit in the int range.
7079 When -pedantic is given, build_enumerator() would have
7080 already warned about those that don't fit. Here we
7081 convert the rest to the enumerator type. */
7082 if (TREE_TYPE (ini) != integer_type_node)
7083 ini = convert (enumtype, ini);
7085 DECL_INITIAL (enu) = ini;
7086 TREE_PURPOSE (pair) = DECL_NAME (enu);
7087 TREE_VALUE (pair) = ini;
7090 TYPE_VALUES (enumtype) = values;
7093 /* Record the min/max values so that we can warn about bit-field
7094 enumerations that are too small for the values. */
7095 lt = GGC_CNEW (struct lang_type);
7096 lt->enum_min = minnode;
7097 lt->enum_max = maxnode;
7098 TYPE_LANG_SPECIFIC (enumtype) = lt;
7100 /* Fix up all variant types of this enum type. */
7101 for (tem = TYPE_MAIN_VARIANT (enumtype); tem; tem = TYPE_NEXT_VARIANT (tem))
7103 if (tem == enumtype)
7105 TYPE_VALUES (tem) = TYPE_VALUES (enumtype);
7106 TYPE_MIN_VALUE (tem) = TYPE_MIN_VALUE (enumtype);
7107 TYPE_MAX_VALUE (tem) = TYPE_MAX_VALUE (enumtype);
7108 TYPE_SIZE (tem) = TYPE_SIZE (enumtype);
7109 TYPE_SIZE_UNIT (tem) = TYPE_SIZE_UNIT (enumtype);
7110 SET_TYPE_MODE (tem, TYPE_MODE (enumtype));
7111 TYPE_PRECISION (tem) = TYPE_PRECISION (enumtype);
7112 TYPE_ALIGN (tem) = TYPE_ALIGN (enumtype);
7113 TYPE_USER_ALIGN (tem) = TYPE_USER_ALIGN (enumtype);
7114 TYPE_UNSIGNED (tem) = TYPE_UNSIGNED (enumtype);
7115 TYPE_LANG_SPECIFIC (tem) = TYPE_LANG_SPECIFIC (enumtype);
7118 /* Finish debugging output for this type. */
7119 rest_of_type_compilation (enumtype, toplevel);
7121 /* If this enum is defined inside a struct, add it to
7124 && struct_parse_info != NULL
7125 && !in_sizeof && !in_typeof && !in_alignof)
7126 VEC_safe_push (tree, heap, struct_parse_info->struct_types, enumtype);
7131 /* Build and install a CONST_DECL for one value of the
7132 current enumeration type (one that was begun with start_enum).
7133 LOC is the location of the enumerator.
7134 Return a tree-list containing the CONST_DECL and its value.
7135 Assignment of sequential values by default is handled here. */
7138 build_enumerator (location_t loc,
7139 struct c_enum_contents *the_enum, tree name, tree value)
7143 /* Validate and default VALUE. */
7147 /* Don't issue more errors for error_mark_node (i.e. an
7148 undeclared identifier) - just ignore the value expression. */
7149 if (value == error_mark_node)
7151 else if (!INTEGRAL_TYPE_P (TREE_TYPE (value)))
7153 error_at (loc, "enumerator value for %qE is not an integer constant",
7159 if (TREE_CODE (value) != INTEGER_CST)
7161 value = c_fully_fold (value, false, NULL);
7162 if (TREE_CODE (value) == INTEGER_CST)
7163 pedwarn (loc, OPT_pedantic,
7164 "enumerator value for %qE is not an integer "
7165 "constant expression", name);
7167 if (TREE_CODE (value) != INTEGER_CST)
7169 error ("enumerator value for %qE is not an integer constant",
7175 value = default_conversion (value);
7176 constant_expression_warning (value);
7181 /* Default based on previous value. */
7182 /* It should no longer be possible to have NON_LVALUE_EXPR
7186 value = the_enum->enum_next_value;
7187 if (the_enum->enum_overflow)
7188 error_at (loc, "overflow in enumeration values");
7190 /* Even though the underlying type of an enum is unspecified, the
7191 type of enumeration constants is explicitly defined as int
7192 (6.4.4.3/2 in the C99 Standard). GCC allows any integer type as
7194 else if (!int_fits_type_p (value, integer_type_node))
7195 pedwarn (loc, OPT_pedantic,
7196 "ISO C restricts enumerator values to range of %<int%>");
7198 /* The ISO C Standard mandates enumerators to have type int, even
7199 though the underlying type of an enum type is unspecified.
7200 However, GCC allows enumerators of any integer type as an
7201 extensions. Here we convert any enumerators that fit in an int
7202 to type int, to avoid promotions to unsigned types when comparing
7203 integers with enumerators that fit in the int range. When
7204 -pedantic is given, we would have already warned about those that
7205 don't fit. We have to do this here rather than in finish_enum
7206 because this value may be used to define more enumerators. */
7207 if (int_fits_type_p (value, integer_type_node))
7208 value = convert (integer_type_node, value);
7210 /* Set basis for default for next value. */
7211 the_enum->enum_next_value
7213 (EXPR_HAS_LOCATION (value) ? EXPR_LOCATION (value) : input_location,
7214 PLUS_EXPR, value, integer_one_node, 0);
7215 the_enum->enum_overflow = tree_int_cst_lt (the_enum->enum_next_value, value);
7217 /* Now create a declaration for the enum value name. */
7219 type = TREE_TYPE (value);
7220 type = c_common_type_for_size (MAX (TYPE_PRECISION (type),
7221 TYPE_PRECISION (integer_type_node)),
7222 (TYPE_PRECISION (type)
7223 >= TYPE_PRECISION (integer_type_node)
7224 && TYPE_UNSIGNED (type)));
7226 decl = build_decl (loc, CONST_DECL, name, type);
7227 DECL_INITIAL (decl) = convert (type, value);
7230 return tree_cons (decl, value, NULL_TREE);
7234 /* Create the FUNCTION_DECL for a function definition.
7235 DECLSPECS, DECLARATOR and ATTRIBUTES are the parts of
7236 the declaration; they describe the function's name and the type it returns,
7237 but twisted together in a fashion that parallels the syntax of C.
7239 This function creates a binding context for the function body
7240 as well as setting up the FUNCTION_DECL in current_function_decl.
7242 Returns 1 on success. If the DECLARATOR is not suitable for a function
7243 (it defines a datum instead), we return 0, which tells
7244 yyparse to report a parse error. */
7247 start_function (struct c_declspecs *declspecs, struct c_declarator *declarator,
7250 tree decl1, old_decl;
7251 tree restype, resdecl;
7254 current_function_returns_value = 0; /* Assume, until we see it does. */
7255 current_function_returns_null = 0;
7256 current_function_returns_abnormally = 0;
7257 warn_about_return_type = 0;
7258 c_switch_stack = NULL;
7260 /* Indicate no valid break/continue context by setting these variables
7261 to some non-null, non-label value. We'll notice and emit the proper
7262 error message in c_finish_bc_stmt. */
7263 c_break_label = c_cont_label = size_zero_node;
7265 decl1 = grokdeclarator (declarator, declspecs, FUNCDEF, true, NULL,
7266 &attributes, NULL, NULL, DEPRECATED_NORMAL);
7268 /* If the declarator is not suitable for a function definition,
7269 cause a syntax error. */
7273 loc = DECL_SOURCE_LOCATION (decl1);
7275 decl_attributes (&decl1, attributes, 0);
7277 if (DECL_DECLARED_INLINE_P (decl1)
7278 && DECL_UNINLINABLE (decl1)
7279 && lookup_attribute ("noinline", DECL_ATTRIBUTES (decl1)))
7280 warning_at (loc, OPT_Wattributes,
7281 "inline function %qD given attribute noinline",
7284 /* Handle gnu_inline attribute. */
7285 if (declspecs->inline_p
7286 && !flag_gnu89_inline
7287 && TREE_CODE (decl1) == FUNCTION_DECL
7288 && (lookup_attribute ("gnu_inline", DECL_ATTRIBUTES (decl1))
7289 || current_function_decl))
7291 if (declspecs->storage_class != csc_static)
7292 DECL_EXTERNAL (decl1) = !DECL_EXTERNAL (decl1);
7295 announce_function (decl1);
7297 if (!COMPLETE_OR_VOID_TYPE_P (TREE_TYPE (TREE_TYPE (decl1))))
7299 error_at (loc, "return type is an incomplete type");
7300 /* Make it return void instead. */
7302 = build_function_type (void_type_node,
7303 TYPE_ARG_TYPES (TREE_TYPE (decl1)));
7306 if (warn_about_return_type)
7307 pedwarn_c99 (loc, flag_isoc99 ? 0
7308 : (warn_return_type ? OPT_Wreturn_type : OPT_Wimplicit_int),
7309 "return type defaults to %<int%>");
7311 /* Make the init_value nonzero so pushdecl knows this is not tentative.
7312 error_mark_node is replaced below (in pop_scope) with the BLOCK. */
7313 DECL_INITIAL (decl1) = error_mark_node;
7315 /* If this definition isn't a prototype and we had a prototype declaration
7316 before, copy the arg type info from that prototype. */
7317 old_decl = lookup_name_in_scope (DECL_NAME (decl1), current_scope);
7318 if (old_decl && TREE_CODE (old_decl) != FUNCTION_DECL)
7320 current_function_prototype_locus = UNKNOWN_LOCATION;
7321 current_function_prototype_built_in = false;
7322 current_function_prototype_arg_types = NULL_TREE;
7323 if (TYPE_ARG_TYPES (TREE_TYPE (decl1)) == 0)
7325 if (old_decl != 0 && TREE_CODE (TREE_TYPE (old_decl)) == FUNCTION_TYPE
7326 && comptypes (TREE_TYPE (TREE_TYPE (decl1)),
7327 TREE_TYPE (TREE_TYPE (old_decl))))
7329 TREE_TYPE (decl1) = composite_type (TREE_TYPE (old_decl),
7331 current_function_prototype_locus = DECL_SOURCE_LOCATION (old_decl);
7332 current_function_prototype_built_in
7333 = C_DECL_BUILTIN_PROTOTYPE (old_decl);
7334 current_function_prototype_arg_types
7335 = TYPE_ARG_TYPES (TREE_TYPE (decl1));
7337 if (TREE_PUBLIC (decl1))
7339 /* If there is an external prototype declaration of this
7340 function, record its location but do not copy information
7341 to this decl. This may be an invisible declaration
7342 (built-in or in a scope which has finished) or simply
7343 have more refined argument types than any declaration
7345 struct c_binding *b;
7346 for (b = I_SYMBOL_BINDING (DECL_NAME (decl1)); b; b = b->shadowed)
7347 if (B_IN_SCOPE (b, external_scope))
7351 tree ext_decl, ext_type;
7353 ext_type = b->u.type ? b->u.type : TREE_TYPE (ext_decl);
7354 if (TREE_CODE (ext_type) == FUNCTION_TYPE
7355 && comptypes (TREE_TYPE (TREE_TYPE (decl1)),
7356 TREE_TYPE (ext_type)))
7358 current_function_prototype_locus
7359 = DECL_SOURCE_LOCATION (ext_decl);
7360 current_function_prototype_built_in
7361 = C_DECL_BUILTIN_PROTOTYPE (ext_decl);
7362 current_function_prototype_arg_types
7363 = TYPE_ARG_TYPES (ext_type);
7369 /* Optionally warn of old-fashioned def with no previous prototype. */
7370 if (warn_strict_prototypes
7371 && old_decl != error_mark_node
7372 && TYPE_ARG_TYPES (TREE_TYPE (decl1)) == 0
7373 && C_DECL_ISNT_PROTOTYPE (old_decl))
7374 warning_at (loc, OPT_Wstrict_prototypes,
7375 "function declaration isn%'t a prototype");
7376 /* Optionally warn of any global def with no previous prototype. */
7377 else if (warn_missing_prototypes
7378 && old_decl != error_mark_node
7379 && TREE_PUBLIC (decl1)
7380 && !MAIN_NAME_P (DECL_NAME (decl1))
7381 && C_DECL_ISNT_PROTOTYPE (old_decl))
7382 warning_at (loc, OPT_Wmissing_prototypes,
7383 "no previous prototype for %qD", decl1);
7384 /* Optionally warn of any def with no previous prototype
7385 if the function has already been used. */
7386 else if (warn_missing_prototypes
7388 && old_decl != error_mark_node
7389 && TREE_USED (old_decl)
7390 && TYPE_ARG_TYPES (TREE_TYPE (old_decl)) == 0)
7391 warning_at (loc, OPT_Wmissing_prototypes,
7392 "%qD was used with no prototype before its definition", decl1);
7393 /* Optionally warn of any global def with no previous declaration. */
7394 else if (warn_missing_declarations
7395 && TREE_PUBLIC (decl1)
7397 && !MAIN_NAME_P (DECL_NAME (decl1)))
7398 warning_at (loc, OPT_Wmissing_declarations,
7399 "no previous declaration for %qD",
7401 /* Optionally warn of any def with no previous declaration
7402 if the function has already been used. */
7403 else if (warn_missing_declarations
7405 && old_decl != error_mark_node
7406 && TREE_USED (old_decl)
7407 && C_DECL_IMPLICIT (old_decl))
7408 warning_at (loc, OPT_Wmissing_declarations,
7409 "%qD was used with no declaration before its definition", decl1);
7411 /* This function exists in static storage.
7412 (This does not mean `static' in the C sense!) */
7413 TREE_STATIC (decl1) = 1;
7415 /* A nested function is not global. */
7416 if (current_function_decl != 0)
7417 TREE_PUBLIC (decl1) = 0;
7419 /* This is the earliest point at which we might know the assembler
7420 name of the function. Thus, if it's set before this, die horribly. */
7421 gcc_assert (!DECL_ASSEMBLER_NAME_SET_P (decl1));
7423 /* If #pragma weak was used, mark the decl weak now. */
7424 if (current_scope == file_scope)
7425 maybe_apply_pragma_weak (decl1);
7427 /* Warn for unlikely, improbable, or stupid declarations of `main'. */
7428 if (warn_main && MAIN_NAME_P (DECL_NAME (decl1)))
7430 if (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (decl1)))
7431 != integer_type_node)
7432 pedwarn (loc, OPT_Wmain, "return type of %qD is not %<int%>", decl1);
7434 check_main_parameter_types (decl1);
7436 if (!TREE_PUBLIC (decl1))
7437 pedwarn (loc, OPT_Wmain,
7438 "%qD is normally a non-static function", decl1);
7441 /* Record the decl so that the function name is defined.
7442 If we already have a decl for this name, and it is a FUNCTION_DECL,
7443 use the old decl. */
7445 current_function_decl = pushdecl (decl1);
7448 declare_parm_level ();
7450 restype = TREE_TYPE (TREE_TYPE (current_function_decl));
7451 resdecl = build_decl (loc, RESULT_DECL, NULL_TREE, restype);
7452 DECL_ARTIFICIAL (resdecl) = 1;
7453 DECL_IGNORED_P (resdecl) = 1;
7454 DECL_RESULT (current_function_decl) = resdecl;
7456 start_fname_decls ();
7461 /* Subroutine of store_parm_decls which handles new-style function
7462 definitions (prototype format). The parms already have decls, so we
7463 need only record them as in effect and complain if any redundant
7464 old-style parm decls were written. */
7466 store_parm_decls_newstyle (tree fndecl, const struct c_arg_info *arg_info)
7470 if (current_scope->bindings)
7472 error_at (DECL_SOURCE_LOCATION (fndecl),
7473 "old-style parameter declarations in prototyped "
7474 "function definition");
7476 /* Get rid of the old-style declarations. */
7480 /* Don't issue this warning for nested functions, and don't issue this
7481 warning if we got here because ARG_INFO_TYPES was error_mark_node
7482 (this happens when a function definition has just an ellipsis in
7483 its parameter list). */
7484 else if (!in_system_header && !current_function_scope
7485 && arg_info->types != error_mark_node)
7486 warning_at (DECL_SOURCE_LOCATION (fndecl), OPT_Wtraditional,
7487 "traditional C rejects ISO C style function definitions");
7489 /* Now make all the parameter declarations visible in the function body.
7490 We can bypass most of the grunt work of pushdecl. */
7491 for (decl = arg_info->parms; decl; decl = TREE_CHAIN (decl))
7493 DECL_CONTEXT (decl) = current_function_decl;
7494 if (DECL_NAME (decl))
7496 bind (DECL_NAME (decl), decl, current_scope,
7497 /*invisible=*/false, /*nested=*/false,
7499 if (!TREE_USED (decl))
7500 warn_if_shadowing (decl);
7503 error_at (DECL_SOURCE_LOCATION (decl), "parameter name omitted");
7506 /* Record the parameter list in the function declaration. */
7507 DECL_ARGUMENTS (fndecl) = arg_info->parms;
7509 /* Now make all the ancillary declarations visible, likewise. */
7510 for (decl = arg_info->others; decl; decl = TREE_CHAIN (decl))
7512 DECL_CONTEXT (decl) = current_function_decl;
7513 if (DECL_NAME (decl))
7514 bind (DECL_NAME (decl), decl, current_scope,
7515 /*invisible=*/false, /*nested=*/false, UNKNOWN_LOCATION);
7518 /* And all the tag declarations. */
7519 for (decl = arg_info->tags; decl; decl = TREE_CHAIN (decl))
7520 if (TREE_PURPOSE (decl))
7521 bind (TREE_PURPOSE (decl), TREE_VALUE (decl), current_scope,
7522 /*invisible=*/false, /*nested=*/false, UNKNOWN_LOCATION);
7525 /* Subroutine of store_parm_decls which handles old-style function
7526 definitions (separate parameter list and declarations). */
7529 store_parm_decls_oldstyle (tree fndecl, const struct c_arg_info *arg_info)
7531 struct c_binding *b;
7532 tree parm, decl, last;
7533 tree parmids = arg_info->parms;
7534 struct pointer_set_t *seen_args = pointer_set_create ();
7536 if (!in_system_header)
7537 warning_at (DECL_SOURCE_LOCATION (fndecl),
7538 OPT_Wold_style_definition, "old-style function definition");
7540 /* Match each formal parameter name with its declaration. Save each
7541 decl in the appropriate TREE_PURPOSE slot of the parmids chain. */
7542 for (parm = parmids; parm; parm = TREE_CHAIN (parm))
7544 if (TREE_VALUE (parm) == 0)
7546 error_at (DECL_SOURCE_LOCATION (fndecl),
7547 "parameter name missing from parameter list");
7548 TREE_PURPOSE (parm) = 0;
7552 b = I_SYMBOL_BINDING (TREE_VALUE (parm));
7553 if (b && B_IN_CURRENT_SCOPE (b))
7556 /* If we got something other than a PARM_DECL it is an error. */
7557 if (TREE_CODE (decl) != PARM_DECL)
7558 error_at (DECL_SOURCE_LOCATION (decl),
7559 "%qD declared as a non-parameter", decl);
7560 /* If the declaration is already marked, we have a duplicate
7561 name. Complain and ignore the duplicate. */
7562 else if (pointer_set_contains (seen_args, decl))
7564 error_at (DECL_SOURCE_LOCATION (decl),
7565 "multiple parameters named %qD", decl);
7566 TREE_PURPOSE (parm) = 0;
7569 /* If the declaration says "void", complain and turn it into
7571 else if (VOID_TYPE_P (TREE_TYPE (decl)))
7573 error_at (DECL_SOURCE_LOCATION (decl),
7574 "parameter %qD declared with void type", decl);
7575 TREE_TYPE (decl) = integer_type_node;
7576 DECL_ARG_TYPE (decl) = integer_type_node;
7577 layout_decl (decl, 0);
7579 warn_if_shadowing (decl);
7581 /* If no declaration found, default to int. */
7584 /* FIXME diagnostics: This should be the location of the argument,
7585 not the FNDECL. E.g., for an old-style declaration
7587 int f10(v) { blah; }
7589 We should use the location of the V, not the F10.
7590 Unfortunately, the V is an IDENTIFIER_NODE which has no
7591 location. In the future we need locations for c_arg_info
7594 See gcc.dg/Wshadow-3.c for an example of this problem. */
7595 decl = build_decl (DECL_SOURCE_LOCATION (fndecl),
7596 PARM_DECL, TREE_VALUE (parm), integer_type_node);
7597 DECL_ARG_TYPE (decl) = TREE_TYPE (decl);
7599 warn_if_shadowing (decl);
7602 pedwarn (DECL_SOURCE_LOCATION (decl),
7603 0, "type of %qD defaults to %<int%>", decl);
7605 warning_at (DECL_SOURCE_LOCATION (decl),
7606 OPT_Wmissing_parameter_type,
7607 "type of %qD defaults to %<int%>", decl);
7610 TREE_PURPOSE (parm) = decl;
7611 pointer_set_insert (seen_args, decl);
7614 /* Now examine the parms chain for incomplete declarations
7615 and declarations with no corresponding names. */
7617 for (b = current_scope->bindings; b; b = b->prev)
7620 if (TREE_CODE (parm) != PARM_DECL)
7623 if (TREE_TYPE (parm) != error_mark_node
7624 && !COMPLETE_TYPE_P (TREE_TYPE (parm)))
7626 error_at (DECL_SOURCE_LOCATION (parm),
7627 "parameter %qD has incomplete type", parm);
7628 TREE_TYPE (parm) = error_mark_node;
7631 if (!pointer_set_contains (seen_args, parm))
7633 error_at (DECL_SOURCE_LOCATION (parm),
7634 "declaration for parameter %qD but no such parameter",
7637 /* Pretend the parameter was not missing.
7638 This gets us to a standard state and minimizes
7639 further error messages. */
7640 parmids = chainon (parmids, tree_cons (parm, 0, 0));
7644 /* Chain the declarations together in the order of the list of
7645 names. Store that chain in the function decl, replacing the
7646 list of names. Update the current scope to match. */
7647 DECL_ARGUMENTS (fndecl) = 0;
7649 for (parm = parmids; parm; parm = TREE_CHAIN (parm))
7650 if (TREE_PURPOSE (parm))
7652 if (parm && TREE_PURPOSE (parm))
7654 last = TREE_PURPOSE (parm);
7655 DECL_ARGUMENTS (fndecl) = last;
7657 for (parm = TREE_CHAIN (parm); parm; parm = TREE_CHAIN (parm))
7658 if (TREE_PURPOSE (parm))
7660 TREE_CHAIN (last) = TREE_PURPOSE (parm);
7661 last = TREE_PURPOSE (parm);
7663 TREE_CHAIN (last) = 0;
7666 pointer_set_destroy (seen_args);
7668 /* If there was a previous prototype,
7669 set the DECL_ARG_TYPE of each argument according to
7670 the type previously specified, and report any mismatches. */
7672 if (current_function_prototype_arg_types)
7675 for (parm = DECL_ARGUMENTS (fndecl),
7676 type = current_function_prototype_arg_types;
7677 parm || (type && TREE_VALUE (type) != error_mark_node
7678 && (TYPE_MAIN_VARIANT (TREE_VALUE (type)) != void_type_node));
7679 parm = TREE_CHAIN (parm), type = TREE_CHAIN (type))
7681 if (parm == 0 || type == 0
7682 || TYPE_MAIN_VARIANT (TREE_VALUE (type)) == void_type_node)
7684 if (current_function_prototype_built_in)
7685 warning_at (DECL_SOURCE_LOCATION (fndecl),
7686 0, "number of arguments doesn%'t match "
7687 "built-in prototype");
7690 /* FIXME diagnostics: This should be the location of
7691 FNDECL, but there is bug when a prototype is
7692 declared inside function context, but defined
7693 outside of it (e.g., gcc.dg/pr15698-2.c). In
7694 which case FNDECL gets the location of the
7695 prototype, not the definition. */
7696 error_at (input_location,
7697 "number of arguments doesn%'t match prototype");
7699 error_at (current_function_prototype_locus,
7700 "prototype declaration");
7704 /* Type for passing arg must be consistent with that
7705 declared for the arg. ISO C says we take the unqualified
7706 type for parameters declared with qualified type. */
7707 if (TREE_TYPE (parm) != error_mark_node
7708 && TREE_TYPE (type) != error_mark_node
7709 && !comptypes (TYPE_MAIN_VARIANT (DECL_ARG_TYPE (parm)),
7710 TYPE_MAIN_VARIANT (TREE_VALUE (type))))
7712 if (TYPE_MAIN_VARIANT (TREE_TYPE (parm))
7713 == TYPE_MAIN_VARIANT (TREE_VALUE (type)))
7715 /* Adjust argument to match prototype. E.g. a previous
7716 `int foo(float);' prototype causes
7717 `int foo(x) float x; {...}' to be treated like
7718 `int foo(float x) {...}'. This is particularly
7719 useful for argument types like uid_t. */
7720 DECL_ARG_TYPE (parm) = TREE_TYPE (parm);
7722 if (targetm.calls.promote_prototypes (TREE_TYPE (current_function_decl))
7723 && INTEGRAL_TYPE_P (TREE_TYPE (parm))
7724 && TYPE_PRECISION (TREE_TYPE (parm))
7725 < TYPE_PRECISION (integer_type_node))
7726 DECL_ARG_TYPE (parm) = integer_type_node;
7728 /* ??? Is it possible to get here with a
7729 built-in prototype or will it always have
7730 been diagnosed as conflicting with an
7731 old-style definition and discarded? */
7732 if (current_function_prototype_built_in)
7733 warning_at (DECL_SOURCE_LOCATION (parm),
7734 OPT_pedantic, "promoted argument %qD "
7735 "doesn%'t match built-in prototype", parm);
7738 pedwarn (DECL_SOURCE_LOCATION (parm),
7739 OPT_pedantic, "promoted argument %qD "
7740 "doesn%'t match prototype", parm);
7741 pedwarn (current_function_prototype_locus, OPT_pedantic,
7742 "prototype declaration");
7747 if (current_function_prototype_built_in)
7748 warning_at (DECL_SOURCE_LOCATION (parm),
7749 0, "argument %qD doesn%'t match "
7750 "built-in prototype", parm);
7753 error_at (DECL_SOURCE_LOCATION (parm),
7754 "argument %qD doesn%'t match prototype", parm);
7755 error_at (current_function_prototype_locus,
7756 "prototype declaration");
7761 TYPE_ACTUAL_ARG_TYPES (TREE_TYPE (fndecl)) = 0;
7764 /* Otherwise, create a prototype that would match. */
7768 tree actual = 0, last = 0, type;
7770 for (parm = DECL_ARGUMENTS (fndecl); parm; parm = TREE_CHAIN (parm))
7772 type = tree_cons (NULL_TREE, DECL_ARG_TYPE (parm), NULL_TREE);
7774 TREE_CHAIN (last) = type;
7779 type = tree_cons (NULL_TREE, void_type_node, NULL_TREE);
7781 TREE_CHAIN (last) = type;
7785 /* We are going to assign a new value for the TYPE_ACTUAL_ARG_TYPES
7786 of the type of this function, but we need to avoid having this
7787 affect the types of other similarly-typed functions, so we must
7788 first force the generation of an identical (but separate) type
7789 node for the relevant function type. The new node we create
7790 will be a variant of the main variant of the original function
7793 TREE_TYPE (fndecl) = build_variant_type_copy (TREE_TYPE (fndecl));
7795 TYPE_ACTUAL_ARG_TYPES (TREE_TYPE (fndecl)) = actual;
7799 /* Store parameter declarations passed in ARG_INFO into the current
7800 function declaration. */
7803 store_parm_decls_from (struct c_arg_info *arg_info)
7805 current_function_arg_info = arg_info;
7806 store_parm_decls ();
7809 /* Store the parameter declarations into the current function declaration.
7810 This is called after parsing the parameter declarations, before
7811 digesting the body of the function.
7813 For an old-style definition, construct a prototype out of the old-style
7814 parameter declarations and inject it into the function's type. */
7817 store_parm_decls (void)
7819 tree fndecl = current_function_decl;
7822 /* The argument information block for FNDECL. */
7823 struct c_arg_info *arg_info = current_function_arg_info;
7824 current_function_arg_info = 0;
7826 /* True if this definition is written with a prototype. Note:
7827 despite C99 6.7.5.3p14, we can *not* treat an empty argument
7828 list in a function definition as equivalent to (void) -- an
7829 empty argument list specifies the function has no parameters,
7830 but only (void) sets up a prototype for future calls. */
7831 proto = arg_info->types != 0;
7834 store_parm_decls_newstyle (fndecl, arg_info);
7836 store_parm_decls_oldstyle (fndecl, arg_info);
7838 /* The next call to push_scope will be a function body. */
7840 next_is_function_body = true;
7842 /* Write a record describing this function definition to the prototypes
7843 file (if requested). */
7845 gen_aux_info_record (fndecl, 1, 0, proto);
7847 /* Initialize the RTL code for the function. */
7848 allocate_struct_function (fndecl, false);
7850 /* Begin the statement tree for this function. */
7851 DECL_SAVED_TREE (fndecl) = push_stmt_list ();
7853 /* ??? Insert the contents of the pending sizes list into the function
7854 to be evaluated. The only reason left to have this is
7855 void foo(int n, int array[n++])
7856 because we throw away the array type in favor of a pointer type, and
7857 thus won't naturally see the SAVE_EXPR containing the increment. All
7858 other pending sizes would be handled by gimplify_parameters. */
7861 for (t = nreverse (get_pending_sizes ()); t ; t = TREE_CHAIN (t))
7862 add_stmt (TREE_VALUE (t));
7865 /* Even though we're inside a function body, we still don't want to
7866 call expand_expr to calculate the size of a variable-sized array.
7867 We haven't necessarily assigned RTL to all variables yet, so it's
7868 not safe to try to expand expressions involving them. */
7869 cfun->dont_save_pending_sizes_p = 1;
7873 /* Finish up a function declaration and compile that function
7874 all the way to assembler language output. The free the storage
7875 for the function definition.
7877 This is called after parsing the body of the function definition. */
7880 finish_function (void)
7882 tree fndecl = current_function_decl;
7884 if (TREE_CODE (fndecl) == FUNCTION_DECL
7885 && targetm.calls.promote_prototypes (TREE_TYPE (fndecl)))
7887 tree args = DECL_ARGUMENTS (fndecl);
7888 for (; args; args = TREE_CHAIN (args))
7890 tree type = TREE_TYPE (args);
7891 if (INTEGRAL_TYPE_P (type)
7892 && TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node))
7893 DECL_ARG_TYPE (args) = integer_type_node;
7897 if (DECL_INITIAL (fndecl) && DECL_INITIAL (fndecl) != error_mark_node)
7898 BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl)) = fndecl;
7900 /* Must mark the RESULT_DECL as being in this function. */
7902 if (DECL_RESULT (fndecl) && DECL_RESULT (fndecl) != error_mark_node)
7903 DECL_CONTEXT (DECL_RESULT (fndecl)) = fndecl;
7905 if (MAIN_NAME_P (DECL_NAME (fndecl)) && flag_hosted
7906 && TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (fndecl)))
7907 == integer_type_node && flag_isoc99)
7909 /* Hack. We don't want the middle-end to warn that this return
7910 is unreachable, so we mark its location as special. Using
7911 UNKNOWN_LOCATION has the problem that it gets clobbered in
7912 annotate_one_with_locus. A cleaner solution might be to
7913 ensure ! should_carry_locus_p (stmt), but that needs a flag.
7915 c_finish_return (BUILTINS_LOCATION, integer_zero_node, NULL_TREE);
7918 /* Tie off the statement tree for this function. */
7919 DECL_SAVED_TREE (fndecl) = pop_stmt_list (DECL_SAVED_TREE (fndecl));
7921 finish_fname_decls ();
7923 /* Complain if there's just no return statement. */
7924 if (warn_return_type
7925 && TREE_CODE (TREE_TYPE (TREE_TYPE (fndecl))) != VOID_TYPE
7926 && !current_function_returns_value && !current_function_returns_null
7927 /* Don't complain if we are no-return. */
7928 && !current_function_returns_abnormally
7929 /* Don't warn for main(). */
7930 && !MAIN_NAME_P (DECL_NAME (fndecl))
7931 /* Or if they didn't actually specify a return type. */
7932 && !C_FUNCTION_IMPLICIT_INT (fndecl)
7933 /* Normally, with -Wreturn-type, flow will complain, but we might
7934 optimize out static functions. */
7935 && !TREE_PUBLIC (fndecl))
7937 warning (OPT_Wreturn_type,
7938 "no return statement in function returning non-void");
7939 TREE_NO_WARNING (fndecl) = 1;
7942 /* Store the end of the function, so that we get good line number
7943 info for the epilogue. */
7944 cfun->function_end_locus = input_location;
7946 /* Finalize the ELF visibility for the function. */
7947 c_determine_visibility (fndecl);
7949 /* For GNU C extern inline functions disregard inline limits. */
7950 if (DECL_EXTERNAL (fndecl)
7951 && DECL_DECLARED_INLINE_P (fndecl))
7952 DECL_DISREGARD_INLINE_LIMITS (fndecl) = 1;
7954 /* Genericize before inlining. Delay genericizing nested functions
7955 until their parent function is genericized. Since finalizing
7956 requires GENERIC, delay that as well. */
7958 if (DECL_INITIAL (fndecl) && DECL_INITIAL (fndecl) != error_mark_node
7959 && !undef_nested_function)
7961 if (!decl_function_context (fndecl))
7963 c_genericize (fndecl);
7965 /* ??? Objc emits functions after finalizing the compilation unit.
7966 This should be cleaned up later and this conditional removed. */
7967 if (cgraph_global_info_ready)
7969 cgraph_add_new_function (fndecl, false);
7972 cgraph_finalize_function (fndecl, false);
7976 /* Register this function with cgraph just far enough to get it
7977 added to our parent's nested function list. Handy, since the
7978 C front end doesn't have such a list. */
7979 (void) cgraph_node (fndecl);
7983 if (!decl_function_context (fndecl))
7984 undef_nested_function = false;
7986 /* We're leaving the context of this function, so zap cfun.
7987 It's still in DECL_STRUCT_FUNCTION, and we'll restore it in
7988 tree_rest_of_compilation. */
7990 current_function_decl = NULL;
7993 /* Check the declarations given in a for-loop for satisfying the C99
7994 constraints. If exactly one such decl is found, return it. LOC is
7995 the location of the opening parenthesis of the for loop. */
7998 check_for_loop_decls (location_t loc)
8000 struct c_binding *b;
8001 tree one_decl = NULL_TREE;
8006 static bool hint = true;
8007 /* If we get here, declarations have been used in a for loop without
8008 the C99 for loop scope. This doesn't make much sense, so don't
8010 error_at (loc, "%<for%> loop initial declarations "
8011 "are only allowed in C99 mode");
8015 "use option -std=c99 or -std=gnu99 to compile your code");
8020 /* C99 subclause 6.8.5 paragraph 3:
8022 [#3] The declaration part of a for statement shall only
8023 declare identifiers for objects having storage class auto or
8026 It isn't clear whether, in this sentence, "identifiers" binds to
8027 "shall only declare" or to "objects" - that is, whether all identifiers
8028 declared must be identifiers for objects, or whether the restriction
8029 only applies to those that are. (A question on this in comp.std.c
8030 in November 2000 received no answer.) We implement the strictest
8031 interpretation, to avoid creating an extension which later causes
8034 for (b = current_scope->bindings; b; b = b->prev)
8037 tree decl = b->decl;
8042 switch (TREE_CODE (decl))
8046 location_t decl_loc = DECL_SOURCE_LOCATION (decl);
8047 if (TREE_STATIC (decl))
8049 "declaration of static variable %qD in %<for%> loop "
8050 "initial declaration", decl);
8051 else if (DECL_EXTERNAL (decl))
8053 "declaration of %<extern%> variable %qD in %<for%> loop "
8054 "initial declaration", decl);
8060 "%<struct %E%> declared in %<for%> loop initial "
8065 "%<union %E%> declared in %<for%> loop initial declaration",
8069 error_at (loc, "%<enum %E%> declared in %<for%> loop "
8070 "initial declaration", id);
8073 error_at (loc, "declaration of non-variable "
8074 "%qD in %<for%> loop initial declaration", decl);
8081 return n_decls == 1 ? one_decl : NULL_TREE;
8084 /* Save and reinitialize the variables
8085 used during compilation of a C function. */
8088 c_push_function_context (void)
8090 struct language_function *p;
8091 p = GGC_NEW (struct language_function);
8094 p->base.x_stmt_tree = c_stmt_tree;
8095 p->x_break_label = c_break_label;
8096 p->x_cont_label = c_cont_label;
8097 p->x_switch_stack = c_switch_stack;
8098 p->arg_info = current_function_arg_info;
8099 p->returns_value = current_function_returns_value;
8100 p->returns_null = current_function_returns_null;
8101 p->returns_abnormally = current_function_returns_abnormally;
8102 p->warn_about_return_type = warn_about_return_type;
8104 push_function_context ();
8107 /* Restore the variables used during compilation of a C function. */
8110 c_pop_function_context (void)
8112 struct language_function *p;
8114 pop_function_context ();
8116 cfun->language = NULL;
8118 if (DECL_STRUCT_FUNCTION (current_function_decl) == 0
8119 && DECL_SAVED_TREE (current_function_decl) == NULL_TREE)
8121 /* Stop pointing to the local nodes about to be freed. */
8122 /* But DECL_INITIAL must remain nonzero so we know this
8123 was an actual function definition. */
8124 DECL_INITIAL (current_function_decl) = error_mark_node;
8125 DECL_ARGUMENTS (current_function_decl) = 0;
8128 c_stmt_tree = p->base.x_stmt_tree;
8129 c_break_label = p->x_break_label;
8130 c_cont_label = p->x_cont_label;
8131 c_switch_stack = p->x_switch_stack;
8132 current_function_arg_info = p->arg_info;
8133 current_function_returns_value = p->returns_value;
8134 current_function_returns_null = p->returns_null;
8135 current_function_returns_abnormally = p->returns_abnormally;
8136 warn_about_return_type = p->warn_about_return_type;
8139 /* Copy the DECL_LANG_SPECIFIC data associated with DECL. */
8142 c_dup_lang_specific_decl (tree decl)
8144 struct lang_decl *ld;
8146 if (!DECL_LANG_SPECIFIC (decl))
8149 ld = GGC_NEW (struct lang_decl);
8150 memcpy (ld, DECL_LANG_SPECIFIC (decl), sizeof (struct lang_decl));
8151 DECL_LANG_SPECIFIC (decl) = ld;
8154 /* The functions below are required for functionality of doing
8155 function at once processing in the C front end. Currently these
8156 functions are not called from anywhere in the C front end, but as
8157 these changes continue, that will change. */
8159 /* Returns the stmt_tree (if any) to which statements are currently
8160 being added. If there is no active statement-tree, NULL is
8164 current_stmt_tree (void)
8166 return &c_stmt_tree;
8169 /* Return the global value of T as a symbol. */
8172 identifier_global_value (tree t)
8174 struct c_binding *b;
8176 for (b = I_SYMBOL_BINDING (t); b; b = b->shadowed)
8177 if (B_IN_FILE_SCOPE (b) || B_IN_EXTERNAL_SCOPE (b))
8183 /* Record a builtin type for C. If NAME is non-NULL, it is the name used;
8184 otherwise the name is found in ridpointers from RID_INDEX. */
8187 record_builtin_type (enum rid rid_index, const char *name, tree type)
8191 id = ridpointers[(int) rid_index];
8193 id = get_identifier (name);
8194 decl = build_decl (UNKNOWN_LOCATION, TYPE_DECL, id, type);
8196 if (debug_hooks->type_decl)
8197 debug_hooks->type_decl (decl, false);
8200 /* Build the void_list_node (void_type_node having been created). */
8202 build_void_list_node (void)
8204 tree t = build_tree_list (NULL_TREE, void_type_node);
8208 /* Return a c_parm structure with the given SPECS, ATTRS and DECLARATOR. */
8211 build_c_parm (struct c_declspecs *specs, tree attrs,
8212 struct c_declarator *declarator)
8214 struct c_parm *ret = XOBNEW (&parser_obstack, struct c_parm);
8217 ret->declarator = declarator;
8221 /* Return a declarator with nested attributes. TARGET is the inner
8222 declarator to which these attributes apply. ATTRS are the
8225 struct c_declarator *
8226 build_attrs_declarator (tree attrs, struct c_declarator *target)
8228 struct c_declarator *ret = XOBNEW (&parser_obstack, struct c_declarator);
8229 ret->kind = cdk_attrs;
8230 ret->declarator = target;
8231 ret->u.attrs = attrs;
8235 /* Return a declarator for a function with arguments specified by ARGS
8236 and return type specified by TARGET. */
8238 struct c_declarator *
8239 build_function_declarator (struct c_arg_info *args,
8240 struct c_declarator *target)
8242 struct c_declarator *ret = XOBNEW (&parser_obstack, struct c_declarator);
8243 ret->kind = cdk_function;
8244 ret->declarator = target;
8245 ret->u.arg_info = args;
8249 /* Return a declarator for the identifier IDENT (which may be
8250 NULL_TREE for an abstract declarator). */
8252 struct c_declarator *
8253 build_id_declarator (tree ident)
8255 struct c_declarator *ret = XOBNEW (&parser_obstack, struct c_declarator);
8257 ret->declarator = 0;
8259 /* Default value - may get reset to a more precise location. */
8260 ret->id_loc = input_location;
8264 /* Return something to represent absolute declarators containing a *.
8265 TARGET is the absolute declarator that the * contains.
8266 TYPE_QUALS_ATTRS is a structure for type qualifiers and attributes
8267 to apply to the pointer type. */
8269 struct c_declarator *
8270 make_pointer_declarator (struct c_declspecs *type_quals_attrs,
8271 struct c_declarator *target)
8275 struct c_declarator *itarget = target;
8276 struct c_declarator *ret = XOBNEW (&parser_obstack, struct c_declarator);
8277 if (type_quals_attrs)
8279 attrs = type_quals_attrs->attrs;
8280 quals = quals_from_declspecs (type_quals_attrs);
8281 if (attrs != NULL_TREE)
8282 itarget = build_attrs_declarator (attrs, target);
8284 ret->kind = cdk_pointer;
8285 ret->declarator = itarget;
8286 ret->u.pointer_quals = quals;
8290 /* Return a pointer to a structure for an empty list of declaration
8293 struct c_declspecs *
8294 build_null_declspecs (void)
8296 struct c_declspecs *ret = XOBNEW (&parser_obstack, struct c_declspecs);
8301 ret->typespec_word = cts_none;
8302 ret->storage_class = csc_none;
8303 ret->expr_const_operands = true;
8304 ret->declspecs_seen_p = false;
8305 ret->type_seen_p = false;
8306 ret->non_sc_seen_p = false;
8307 ret->typedef_p = false;
8308 ret->tag_defined_p = false;
8309 ret->explicit_signed_p = false;
8310 ret->deprecated_p = false;
8311 ret->default_int_p = false;
8312 ret->long_p = false;
8313 ret->long_long_p = false;
8314 ret->short_p = false;
8315 ret->signed_p = false;
8316 ret->unsigned_p = false;
8317 ret->complex_p = false;
8318 ret->inline_p = false;
8319 ret->thread_p = false;
8320 ret->const_p = false;
8321 ret->volatile_p = false;
8322 ret->restrict_p = false;
8323 ret->saturating_p = false;
8327 /* Add the type qualifier QUAL to the declaration specifiers SPECS,
8330 struct c_declspecs *
8331 declspecs_add_qual (struct c_declspecs *specs, tree qual)
8335 specs->non_sc_seen_p = true;
8336 specs->declspecs_seen_p = true;
8337 gcc_assert (TREE_CODE (qual) == IDENTIFIER_NODE
8338 && C_IS_RESERVED_WORD (qual));
8339 i = C_RID_CODE (qual);
8343 dupe = specs->const_p;
8344 specs->const_p = true;
8347 dupe = specs->volatile_p;
8348 specs->volatile_p = true;
8351 dupe = specs->restrict_p;
8352 specs->restrict_p = true;
8357 if (dupe && !flag_isoc99)
8358 pedwarn (input_location, OPT_pedantic, "duplicate %qE", qual);
8362 /* Add the type specifier TYPE to the declaration specifiers SPECS,
8365 struct c_declspecs *
8366 declspecs_add_type (location_t loc, struct c_declspecs *specs,
8367 struct c_typespec spec)
8369 tree type = spec.spec;
8370 specs->non_sc_seen_p = true;
8371 specs->declspecs_seen_p = true;
8372 specs->type_seen_p = true;
8373 if (TREE_DEPRECATED (type))
8374 specs->deprecated_p = true;
8376 /* Handle type specifier keywords. */
8377 if (TREE_CODE (type) == IDENTIFIER_NODE
8378 && C_IS_RESERVED_WORD (type)
8379 && C_RID_CODE (type) != RID_CXX_COMPAT_WARN)
8381 enum rid i = C_RID_CODE (type);
8384 error_at (loc, "two or more data types in declaration specifiers");
8387 if ((int) i <= (int) RID_LAST_MODIFIER)
8389 /* "long", "short", "signed", "unsigned", "_Complex" or "_Sat". */
8394 if (specs->long_long_p)
8396 error_at (loc, "%<long long long%> is too long for GCC");
8401 if (specs->typespec_word == cts_double)
8404 ("both %<long long%> and %<double%> in "
8405 "declaration specifiers"));
8408 pedwarn_c90 (loc, OPT_Wlong_long,
8409 "ISO C90 does not support %<long long%>");
8410 specs->long_long_p = 1;
8415 ("both %<long%> and %<short%> in "
8416 "declaration specifiers"));
8417 else if (specs->typespec_word == cts_void)
8419 ("both %<long%> and %<void%> in "
8420 "declaration specifiers"));
8421 else if (specs->typespec_word == cts_bool)
8423 ("both %<long%> and %<_Bool%> in "
8424 "declaration specifiers"));
8425 else if (specs->typespec_word == cts_char)
8427 ("both %<long%> and %<char%> in "
8428 "declaration specifiers"));
8429 else if (specs->typespec_word == cts_float)
8431 ("both %<long%> and %<float%> in "
8432 "declaration specifiers"));
8433 else if (specs->typespec_word == cts_dfloat32)
8435 ("both %<long%> and %<_Decimal32%> in "
8436 "declaration specifiers"));
8437 else if (specs->typespec_word == cts_dfloat64)
8439 ("both %<long%> and %<_Decimal64%> in "
8440 "declaration specifiers"));
8441 else if (specs->typespec_word == cts_dfloat128)
8443 ("both %<long%> and %<_Decimal128%> in "
8444 "declaration specifiers"));
8446 specs->long_p = true;
8449 dupe = specs->short_p;
8452 ("both %<long%> and %<short%> in "
8453 "declaration specifiers"));
8454 else if (specs->typespec_word == cts_void)
8456 ("both %<short%> and %<void%> in "
8457 "declaration specifiers"));
8458 else if (specs->typespec_word == cts_bool)
8460 ("both %<short%> and %<_Bool%> in "
8461 "declaration specifiers"));
8462 else if (specs->typespec_word == cts_char)
8464 ("both %<short%> and %<char%> in "
8465 "declaration specifiers"));
8466 else if (specs->typespec_word == cts_float)
8468 ("both %<short%> and %<float%> in "
8469 "declaration specifiers"));
8470 else if (specs->typespec_word == cts_double)
8472 ("both %<short%> and %<double%> in "
8473 "declaration specifiers"));
8474 else if (specs->typespec_word == cts_dfloat32)
8476 ("both %<short%> and %<_Decimal32%> in "
8477 "declaration specifiers"));
8478 else if (specs->typespec_word == cts_dfloat64)
8480 ("both %<short%> and %<_Decimal64%> in "
8481 "declaration specifiers"));
8482 else if (specs->typespec_word == cts_dfloat128)
8484 ("both %<short%> and %<_Decimal128%> in "
8485 "declaration specifiers"));
8487 specs->short_p = true;
8490 dupe = specs->signed_p;
8491 if (specs->unsigned_p)
8493 ("both %<signed%> and %<unsigned%> in "
8494 "declaration specifiers"));
8495 else if (specs->typespec_word == cts_void)
8497 ("both %<signed%> and %<void%> in "
8498 "declaration specifiers"));
8499 else if (specs->typespec_word == cts_bool)
8501 ("both %<signed%> and %<_Bool%> in "
8502 "declaration specifiers"));
8503 else if (specs->typespec_word == cts_float)
8505 ("both %<signed%> and %<float%> in "
8506 "declaration specifiers"));
8507 else if (specs->typespec_word == cts_double)
8509 ("both %<signed%> and %<double%> in "
8510 "declaration specifiers"));
8511 else if (specs->typespec_word == cts_dfloat32)
8513 ("both %<signed%> and %<_Decimal32%> in "
8514 "declaration specifiers"));
8515 else if (specs->typespec_word == cts_dfloat64)
8517 ("both %<signed%> and %<_Decimal64%> in "
8518 "declaration specifiers"));
8519 else if (specs->typespec_word == cts_dfloat128)
8521 ("both %<signed%> and %<_Decimal128%> in "
8522 "declaration specifiers"));
8524 specs->signed_p = true;
8527 dupe = specs->unsigned_p;
8528 if (specs->signed_p)
8530 ("both %<signed%> and %<unsigned%> in "
8531 "declaration specifiers"));
8532 else if (specs->typespec_word == cts_void)
8534 ("both %<unsigned%> and %<void%> in "
8535 "declaration specifiers"));
8536 else if (specs->typespec_word == cts_bool)
8538 ("both %<unsigned%> and %<_Bool%> in "
8539 "declaration specifiers"));
8540 else if (specs->typespec_word == cts_float)
8542 ("both %<unsigned%> and %<float%> in "
8543 "declaration specifiers"));
8544 else if (specs->typespec_word == cts_double)
8546 ("both %<unsigned%> and %<double%> in "
8547 "declaration specifiers"));
8548 else if (specs->typespec_word == cts_dfloat32)
8550 ("both %<unsigned%> and %<_Decimal32%> in "
8551 "declaration specifiers"));
8552 else if (specs->typespec_word == cts_dfloat64)
8554 ("both %<unsigned%> and %<_Decimal64%> in "
8555 "declaration specifiers"));
8556 else if (specs->typespec_word == cts_dfloat128)
8558 ("both %<unsigned%> and %<_Decimal128%> in "
8559 "declaration specifiers"));
8561 specs->unsigned_p = true;
8564 dupe = specs->complex_p;
8565 if (!flag_isoc99 && !in_system_header)
8566 pedwarn (loc, OPT_pedantic,
8567 "ISO C90 does not support complex types");
8568 if (specs->typespec_word == cts_void)
8570 ("both %<complex%> and %<void%> in "
8571 "declaration specifiers"));
8572 else if (specs->typespec_word == cts_bool)
8574 ("both %<complex%> and %<_Bool%> in "
8575 "declaration specifiers"));
8576 else if (specs->typespec_word == cts_dfloat32)
8578 ("both %<complex%> and %<_Decimal32%> in "
8579 "declaration specifiers"));
8580 else if (specs->typespec_word == cts_dfloat64)
8582 ("both %<complex%> and %<_Decimal64%> in "
8583 "declaration specifiers"));
8584 else if (specs->typespec_word == cts_dfloat128)
8586 ("both %<complex%> and %<_Decimal128%> in "
8587 "declaration specifiers"));
8588 else if (specs->typespec_word == cts_fract)
8590 ("both %<complex%> and %<_Fract%> in "
8591 "declaration specifiers"));
8592 else if (specs->typespec_word == cts_accum)
8594 ("both %<complex%> and %<_Accum%> in "
8595 "declaration specifiers"));
8596 else if (specs->saturating_p)
8598 ("both %<complex%> and %<_Sat%> in "
8599 "declaration specifiers"));
8601 specs->complex_p = true;
8604 dupe = specs->saturating_p;
8605 pedwarn (loc, OPT_pedantic,
8606 "ISO C does not support saturating types");
8607 if (specs->typespec_word == cts_void)
8609 ("both %<_Sat%> and %<void%> in "
8610 "declaration specifiers"));
8611 else if (specs->typespec_word == cts_bool)
8613 ("both %<_Sat%> and %<_Bool%> in "
8614 "declaration specifiers"));
8615 else if (specs->typespec_word == cts_char)
8617 ("both %<_Sat%> and %<char%> in "
8618 "declaration specifiers"));
8619 else if (specs->typespec_word == cts_int)
8621 ("both %<_Sat%> and %<int%> in "
8622 "declaration specifiers"));
8623 else if (specs->typespec_word == cts_float)
8625 ("both %<_Sat%> and %<float%> in "
8626 "declaration specifiers"));
8627 else if (specs->typespec_word == cts_double)
8629 ("both %<_Sat%> and %<double%> in "
8630 "declaration specifiers"));
8631 else if (specs->typespec_word == cts_dfloat32)
8633 ("both %<_Sat%> and %<_Decimal32%> in "
8634 "declaration specifiers"));
8635 else if (specs->typespec_word == cts_dfloat64)
8637 ("both %<_Sat%> and %<_Decimal64%> in "
8638 "declaration specifiers"));
8639 else if (specs->typespec_word == cts_dfloat128)
8641 ("both %<_Sat%> and %<_Decimal128%> in "
8642 "declaration specifiers"));
8643 else if (specs->complex_p)
8645 ("both %<_Sat%> and %<complex%> in "
8646 "declaration specifiers"));
8648 specs->saturating_p = true;
8655 error_at (loc, "duplicate %qE", type);
8661 /* "void", "_Bool", "char", "int", "float", "double", "_Decimal32",
8662 "_Decimal64", "_Decimal128", "_Fract" or "_Accum". */
8663 if (specs->typespec_word != cts_none)
8666 "two or more data types in declaration specifiers");
8674 ("both %<long%> and %<void%> in "
8675 "declaration specifiers"));
8676 else if (specs->short_p)
8678 ("both %<short%> and %<void%> in "
8679 "declaration specifiers"));
8680 else if (specs->signed_p)
8682 ("both %<signed%> and %<void%> in "
8683 "declaration specifiers"));
8684 else if (specs->unsigned_p)
8686 ("both %<unsigned%> and %<void%> in "
8687 "declaration specifiers"));
8688 else if (specs->complex_p)
8690 ("both %<complex%> and %<void%> in "
8691 "declaration specifiers"));
8692 else if (specs->saturating_p)
8694 ("both %<_Sat%> and %<void%> in "
8695 "declaration specifiers"));
8697 specs->typespec_word = cts_void;
8702 ("both %<long%> and %<_Bool%> in "
8703 "declaration specifiers"));
8704 else if (specs->short_p)
8706 ("both %<short%> and %<_Bool%> in "
8707 "declaration specifiers"));
8708 else if (specs->signed_p)
8710 ("both %<signed%> and %<_Bool%> in "
8711 "declaration specifiers"));
8712 else if (specs->unsigned_p)
8714 ("both %<unsigned%> and %<_Bool%> in "
8715 "declaration specifiers"));
8716 else if (specs->complex_p)
8718 ("both %<complex%> and %<_Bool%> in "
8719 "declaration specifiers"));
8720 else if (specs->saturating_p)
8722 ("both %<_Sat%> and %<_Bool%> in "
8723 "declaration specifiers"));
8725 specs->typespec_word = cts_bool;
8730 ("both %<long%> and %<char%> in "
8731 "declaration specifiers"));
8732 else if (specs->short_p)
8734 ("both %<short%> and %<char%> in "
8735 "declaration specifiers"));
8736 else if (specs->saturating_p)
8738 ("both %<_Sat%> and %<char%> in "
8739 "declaration specifiers"));
8741 specs->typespec_word = cts_char;
8744 if (specs->saturating_p)
8746 ("both %<_Sat%> and %<int%> in "
8747 "declaration specifiers"));
8749 specs->typespec_word = cts_int;
8754 ("both %<long%> and %<float%> in "
8755 "declaration specifiers"));
8756 else if (specs->short_p)
8758 ("both %<short%> and %<float%> in "
8759 "declaration specifiers"));
8760 else if (specs->signed_p)
8762 ("both %<signed%> and %<float%> in "
8763 "declaration specifiers"));
8764 else if (specs->unsigned_p)
8766 ("both %<unsigned%> and %<float%> in "
8767 "declaration specifiers"));
8768 else if (specs->saturating_p)
8770 ("both %<_Sat%> and %<float%> in "
8771 "declaration specifiers"));
8773 specs->typespec_word = cts_float;
8776 if (specs->long_long_p)
8778 ("both %<long long%> and %<double%> in "
8779 "declaration specifiers"));
8780 else if (specs->short_p)
8782 ("both %<short%> and %<double%> in "
8783 "declaration specifiers"));
8784 else if (specs->signed_p)
8786 ("both %<signed%> and %<double%> in "
8787 "declaration specifiers"));
8788 else if (specs->unsigned_p)
8790 ("both %<unsigned%> and %<double%> in "
8791 "declaration specifiers"));
8792 else if (specs->saturating_p)
8794 ("both %<_Sat%> and %<double%> in "
8795 "declaration specifiers"));
8797 specs->typespec_word = cts_double;
8804 if (i == RID_DFLOAT32)
8806 else if (i == RID_DFLOAT64)
8809 str = "_Decimal128";
8810 if (specs->long_long_p)
8812 ("both %<long long%> and %<%s%> in "
8813 "declaration specifiers"),
8817 ("both %<long%> and %<%s%> in "
8818 "declaration specifiers"),
8820 else if (specs->short_p)
8822 ("both %<short%> and %<%s%> in "
8823 "declaration specifiers"),
8825 else if (specs->signed_p)
8827 ("both %<signed%> and %<%s%> in "
8828 "declaration specifiers"),
8830 else if (specs->unsigned_p)
8832 ("both %<unsigned%> and %<%s%> in "
8833 "declaration specifiers"),
8835 else if (specs->complex_p)
8837 ("both %<complex%> and %<%s%> in "
8838 "declaration specifiers"),
8840 else if (specs->saturating_p)
8842 ("both %<_Sat%> and %<%s%> in "
8843 "declaration specifiers"),
8845 else if (i == RID_DFLOAT32)
8846 specs->typespec_word = cts_dfloat32;
8847 else if (i == RID_DFLOAT64)
8848 specs->typespec_word = cts_dfloat64;
8850 specs->typespec_word = cts_dfloat128;
8852 if (!targetm.decimal_float_supported_p ())
8854 ("decimal floating point not supported "
8855 "for this target"));
8856 pedwarn (loc, OPT_pedantic,
8857 "ISO C does not support decimal floating point");
8867 if (specs->complex_p)
8869 ("both %<complex%> and %<%s%> in "
8870 "declaration specifiers"),
8872 else if (i == RID_FRACT)
8873 specs->typespec_word = cts_fract;
8875 specs->typespec_word = cts_accum;
8877 if (!targetm.fixed_point_supported_p ())
8879 "fixed-point types not supported for this target");
8880 pedwarn (loc, OPT_pedantic,
8881 "ISO C does not support fixed-point types");
8884 /* ObjC reserved word "id", handled below. */
8890 /* Now we have a typedef (a TYPE_DECL node), an identifier (some
8891 form of ObjC type, cases such as "int" and "long" being handled
8892 above), a TYPE (struct, union, enum and typeof specifiers) or an
8893 ERROR_MARK. In none of these cases may there have previously
8894 been any type specifiers. */
8895 if (specs->type || specs->typespec_word != cts_none
8896 || specs->long_p || specs->short_p || specs->signed_p
8897 || specs->unsigned_p || specs->complex_p)
8898 error_at (loc, "two or more data types in declaration specifiers");
8899 else if (TREE_CODE (type) == TYPE_DECL)
8901 if (TREE_TYPE (type) == error_mark_node)
8902 ; /* Allow the type to default to int to avoid cascading errors. */
8905 specs->type = TREE_TYPE (type);
8906 specs->decl_attr = DECL_ATTRIBUTES (type);
8907 specs->typedef_p = true;
8908 specs->explicit_signed_p = C_TYPEDEF_EXPLICITLY_SIGNED (type);
8910 /* If this typedef name is defined in a struct, then a C++
8911 lookup would return a different value. */
8913 && I_SYMBOL_BINDING (DECL_NAME (type))->in_struct)
8914 warning_at (loc, OPT_Wc___compat,
8915 "C++ lookup of %qD would return a field, not a type",
8918 /* If we are parsing a struct, record that a struct field
8920 if (warn_cxx_compat && struct_parse_info != NULL)
8921 VEC_safe_push (tree, heap, struct_parse_info->typedefs_seen, type);
8924 else if (TREE_CODE (type) == IDENTIFIER_NODE)
8926 tree t = lookup_name (type);
8927 if (!t || TREE_CODE (t) != TYPE_DECL)
8928 error_at (loc, "%qE fails to be a typedef or built in type", type);
8929 else if (TREE_TYPE (t) == error_mark_node)
8932 specs->type = TREE_TYPE (t);
8934 else if (TREE_CODE (type) != ERROR_MARK)
8936 if (spec.kind == ctsk_tagdef || spec.kind == ctsk_tagfirstref)
8937 specs->tag_defined_p = true;
8938 if (spec.kind == ctsk_typeof)
8940 specs->typedef_p = true;
8944 specs->expr = build2 (COMPOUND_EXPR, TREE_TYPE (spec.expr),
8945 specs->expr, spec.expr);
8947 specs->expr = spec.expr;
8948 specs->expr_const_operands &= spec.expr_const_operands;
8957 /* Add the storage class specifier or function specifier SCSPEC to the
8958 declaration specifiers SPECS, returning SPECS. */
8960 struct c_declspecs *
8961 declspecs_add_scspec (struct c_declspecs *specs, tree scspec)
8964 enum c_storage_class n = csc_none;
8966 specs->declspecs_seen_p = true;
8967 gcc_assert (TREE_CODE (scspec) == IDENTIFIER_NODE
8968 && C_IS_RESERVED_WORD (scspec));
8969 i = C_RID_CODE (scspec);
8970 if (specs->non_sc_seen_p)
8971 warning (OPT_Wold_style_declaration,
8972 "%qE is not at beginning of declaration", scspec);
8976 /* C99 permits duplicate inline. Although of doubtful utility,
8977 it seems simplest to permit it in gnu89 mode as well, as
8978 there is also little utility in maintaining this as a
8979 difference between gnu89 and C99 inline. */
8981 specs->inline_p = true;
8984 dupe = specs->thread_p;
8985 if (specs->storage_class == csc_auto)
8986 error ("%<__thread%> used with %<auto%>");
8987 else if (specs->storage_class == csc_register)
8988 error ("%<__thread%> used with %<register%>");
8989 else if (specs->storage_class == csc_typedef)
8990 error ("%<__thread%> used with %<typedef%>");
8992 specs->thread_p = true;
8999 /* Diagnose "__thread extern". */
9000 if (specs->thread_p)
9001 error ("%<__thread%> before %<extern%>");
9008 /* Diagnose "__thread static". */
9009 if (specs->thread_p)
9010 error ("%<__thread%> before %<static%>");
9018 if (n != csc_none && n == specs->storage_class)
9021 error ("duplicate %qE", scspec);
9024 if (specs->storage_class != csc_none && n != specs->storage_class)
9026 error ("multiple storage classes in declaration specifiers");
9030 specs->storage_class = n;
9031 if (n != csc_extern && n != csc_static && specs->thread_p)
9033 error ("%<__thread%> used with %qE", scspec);
9034 specs->thread_p = false;
9041 /* Add the attributes ATTRS to the declaration specifiers SPECS,
9044 struct c_declspecs *
9045 declspecs_add_attrs (struct c_declspecs *specs, tree attrs)
9047 specs->attrs = chainon (attrs, specs->attrs);
9048 specs->declspecs_seen_p = true;
9052 /* Combine "long", "short", "signed", "unsigned" and "_Complex" type
9053 specifiers with any other type specifier to determine the resulting
9054 type. This is where ISO C checks on complex types are made, since
9055 "_Complex long" is a prefix of the valid ISO C type "_Complex long
9058 struct c_declspecs *
9059 finish_declspecs (struct c_declspecs *specs)
9061 /* If a type was specified as a whole, we have no modifiers and are
9063 if (specs->type != NULL_TREE)
9065 gcc_assert (!specs->long_p && !specs->long_long_p && !specs->short_p
9066 && !specs->signed_p && !specs->unsigned_p
9067 && !specs->complex_p);
9071 /* If none of "void", "_Bool", "char", "int", "float" or "double"
9072 has been specified, treat it as "int" unless "_Complex" is
9073 present and there are no other specifiers. If we just have
9074 "_Complex", it is equivalent to "_Complex double", but e.g.
9075 "_Complex short" is equivalent to "_Complex short int". */
9076 if (specs->typespec_word == cts_none)
9078 if (specs->saturating_p)
9080 error ("%<_Sat%> is used without %<_Fract%> or %<_Accum%>");
9081 if (!targetm.fixed_point_supported_p ())
9082 error ("fixed-point types not supported for this target");
9083 specs->typespec_word = cts_fract;
9085 else if (specs->long_p || specs->short_p
9086 || specs->signed_p || specs->unsigned_p)
9088 specs->typespec_word = cts_int;
9090 else if (specs->complex_p)
9092 specs->typespec_word = cts_double;
9093 pedwarn (input_location, OPT_pedantic,
9094 "ISO C does not support plain %<complex%> meaning "
9095 "%<double complex%>");
9099 specs->typespec_word = cts_int;
9100 specs->default_int_p = true;
9101 /* We don't diagnose this here because grokdeclarator will
9102 give more specific diagnostics according to whether it is
9103 a function definition. */
9107 /* If "signed" was specified, record this to distinguish "int" and
9108 "signed int" in the case of a bit-field with
9109 -funsigned-bitfields. */
9110 specs->explicit_signed_p = specs->signed_p;
9112 /* Now compute the actual type. */
9113 switch (specs->typespec_word)
9116 gcc_assert (!specs->long_p && !specs->short_p
9117 && !specs->signed_p && !specs->unsigned_p
9118 && !specs->complex_p);
9119 specs->type = void_type_node;
9122 gcc_assert (!specs->long_p && !specs->short_p
9123 && !specs->signed_p && !specs->unsigned_p
9124 && !specs->complex_p);
9125 specs->type = boolean_type_node;
9128 gcc_assert (!specs->long_p && !specs->short_p);
9129 gcc_assert (!(specs->signed_p && specs->unsigned_p));
9130 if (specs->signed_p)
9131 specs->type = signed_char_type_node;
9132 else if (specs->unsigned_p)
9133 specs->type = unsigned_char_type_node;
9135 specs->type = char_type_node;
9136 if (specs->complex_p)
9138 pedwarn (input_location, OPT_pedantic,
9139 "ISO C does not support complex integer types");
9140 specs->type = build_complex_type (specs->type);
9144 gcc_assert (!(specs->long_p && specs->short_p));
9145 gcc_assert (!(specs->signed_p && specs->unsigned_p));
9146 if (specs->long_long_p)
9147 specs->type = (specs->unsigned_p
9148 ? long_long_unsigned_type_node
9149 : long_long_integer_type_node);
9150 else if (specs->long_p)
9151 specs->type = (specs->unsigned_p
9152 ? long_unsigned_type_node
9153 : long_integer_type_node);
9154 else if (specs->short_p)
9155 specs->type = (specs->unsigned_p
9156 ? short_unsigned_type_node
9157 : short_integer_type_node);
9159 specs->type = (specs->unsigned_p
9160 ? unsigned_type_node
9161 : integer_type_node);
9162 if (specs->complex_p)
9164 pedwarn (input_location, OPT_pedantic,
9165 "ISO C does not support complex integer types");
9166 specs->type = build_complex_type (specs->type);
9170 gcc_assert (!specs->long_p && !specs->short_p
9171 && !specs->signed_p && !specs->unsigned_p);
9172 specs->type = (specs->complex_p
9173 ? complex_float_type_node
9177 gcc_assert (!specs->long_long_p && !specs->short_p
9178 && !specs->signed_p && !specs->unsigned_p);
9181 specs->type = (specs->complex_p
9182 ? complex_long_double_type_node
9183 : long_double_type_node);
9187 specs->type = (specs->complex_p
9188 ? complex_double_type_node
9189 : double_type_node);
9195 gcc_assert (!specs->long_p && !specs->long_long_p && !specs->short_p
9196 && !specs->signed_p && !specs->unsigned_p && !specs->complex_p);
9197 if (specs->typespec_word == cts_dfloat32)
9198 specs->type = dfloat32_type_node;
9199 else if (specs->typespec_word == cts_dfloat64)
9200 specs->type = dfloat64_type_node;
9202 specs->type = dfloat128_type_node;
9205 gcc_assert (!specs->complex_p);
9206 if (!targetm.fixed_point_supported_p ())
9207 specs->type = integer_type_node;
9208 else if (specs->saturating_p)
9210 if (specs->long_long_p)
9211 specs->type = specs->unsigned_p
9212 ? sat_unsigned_long_long_fract_type_node
9213 : sat_long_long_fract_type_node;
9214 else if (specs->long_p)
9215 specs->type = specs->unsigned_p
9216 ? sat_unsigned_long_fract_type_node
9217 : sat_long_fract_type_node;
9218 else if (specs->short_p)
9219 specs->type = specs->unsigned_p
9220 ? sat_unsigned_short_fract_type_node
9221 : sat_short_fract_type_node;
9223 specs->type = specs->unsigned_p
9224 ? sat_unsigned_fract_type_node
9225 : sat_fract_type_node;
9229 if (specs->long_long_p)
9230 specs->type = specs->unsigned_p
9231 ? unsigned_long_long_fract_type_node
9232 : long_long_fract_type_node;
9233 else if (specs->long_p)
9234 specs->type = specs->unsigned_p
9235 ? unsigned_long_fract_type_node
9236 : long_fract_type_node;
9237 else if (specs->short_p)
9238 specs->type = specs->unsigned_p
9239 ? unsigned_short_fract_type_node
9240 : short_fract_type_node;
9242 specs->type = specs->unsigned_p
9243 ? unsigned_fract_type_node
9248 gcc_assert (!specs->complex_p);
9249 if (!targetm.fixed_point_supported_p ())
9250 specs->type = integer_type_node;
9251 else if (specs->saturating_p)
9253 if (specs->long_long_p)
9254 specs->type = specs->unsigned_p
9255 ? sat_unsigned_long_long_accum_type_node
9256 : sat_long_long_accum_type_node;
9257 else if (specs->long_p)
9258 specs->type = specs->unsigned_p
9259 ? sat_unsigned_long_accum_type_node
9260 : sat_long_accum_type_node;
9261 else if (specs->short_p)
9262 specs->type = specs->unsigned_p
9263 ? sat_unsigned_short_accum_type_node
9264 : sat_short_accum_type_node;
9266 specs->type = specs->unsigned_p
9267 ? sat_unsigned_accum_type_node
9268 : sat_accum_type_node;
9272 if (specs->long_long_p)
9273 specs->type = specs->unsigned_p
9274 ? unsigned_long_long_accum_type_node
9275 : long_long_accum_type_node;
9276 else if (specs->long_p)
9277 specs->type = specs->unsigned_p
9278 ? unsigned_long_accum_type_node
9279 : long_accum_type_node;
9280 else if (specs->short_p)
9281 specs->type = specs->unsigned_p
9282 ? unsigned_short_accum_type_node
9283 : short_accum_type_node;
9285 specs->type = specs->unsigned_p
9286 ? unsigned_accum_type_node
9297 /* A subroutine of c_write_global_declarations. Perform final processing
9298 on one file scope's declarations (or the external scope's declarations),
9302 c_write_global_declarations_1 (tree globals)
9307 /* Process the decls in the order they were written. */
9308 for (decl = globals; decl; decl = TREE_CHAIN (decl))
9310 /* Check for used but undefined static functions using the C
9311 standard's definition of "used", and set TREE_NO_WARNING so
9312 that check_global_declarations doesn't repeat the check. */
9313 if (TREE_CODE (decl) == FUNCTION_DECL
9314 && DECL_INITIAL (decl) == 0
9315 && DECL_EXTERNAL (decl)
9316 && !TREE_PUBLIC (decl)
9317 && C_DECL_USED (decl))
9319 pedwarn (input_location, 0, "%q+F used but never defined", decl);
9320 TREE_NO_WARNING (decl) = 1;
9323 wrapup_global_declaration_1 (decl);
9329 for (decl = globals; decl; decl = TREE_CHAIN (decl))
9330 reconsider |= wrapup_global_declaration_2 (decl);
9334 for (decl = globals; decl; decl = TREE_CHAIN (decl))
9335 check_global_declaration_1 (decl);
9338 /* A subroutine of c_write_global_declarations Emit debug information for each
9339 of the declarations in GLOBALS. */
9342 c_write_global_declarations_2 (tree globals)
9346 for (decl = globals; decl ; decl = TREE_CHAIN (decl))
9347 debug_hooks->global_decl (decl);
9350 /* Preserve the external declarations scope across a garbage collect. */
9351 static GTY(()) tree ext_block;
9354 c_write_global_declarations (void)
9358 /* We don't want to do this if generating a PCH. */
9362 /* Don't waste time on further processing if -fsyntax-only.
9363 Continue for warning and errors issued during lowering though. */
9364 if (flag_syntax_only)
9367 /* Close the external scope. */
9368 ext_block = pop_scope ();
9370 gcc_assert (!current_scope);
9374 tree tmp = BLOCK_VARS (ext_block);
9376 FILE * stream = dump_begin (TDI_tu, &flags);
9379 dump_node (tmp, flags & ~TDF_SLIM, stream);
9380 dump_end (TDI_tu, stream);
9384 /* Process all file scopes in this compilation, and the external_scope,
9385 through wrapup_global_declarations and check_global_declarations. */
9386 for (t = all_translation_units; t; t = TREE_CHAIN (t))
9387 c_write_global_declarations_1 (BLOCK_VARS (DECL_INITIAL (t)));
9388 c_write_global_declarations_1 (BLOCK_VARS (ext_block));
9390 /* We're done parsing; proceed to optimize and emit assembly.
9391 FIXME: shouldn't be the front end's responsibility to call this. */
9392 cgraph_finalize_compilation_unit ();
9394 /* After cgraph has had a chance to emit everything that's going to
9395 be emitted, output debug information for globals. */
9396 if (errorcount == 0 && sorrycount == 0)
9398 timevar_push (TV_SYMOUT);
9399 for (t = all_translation_units; t; t = TREE_CHAIN (t))
9400 c_write_global_declarations_2 (BLOCK_VARS (DECL_INITIAL (t)));
9401 c_write_global_declarations_2 (BLOCK_VARS (ext_block));
9402 timevar_pop (TV_SYMOUT);
9408 #include "gt-c-decl.h"