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 Free Software Foundation, Inc.
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify it under
8 the terms of the GNU General Public License as published by the Free
9 Software Foundation; either version 2, or (at your option) any later
12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING. If not, write to the Free
19 Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
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"
55 #include "tree-gimple.h"
56 #include "diagnostic.h"
57 #include "tree-dump.h"
62 #include "langhooks-def.h"
63 #include "pointer-set.h"
65 /* In grokdeclarator, distinguish syntactic contexts of declarators. */
67 { NORMAL, /* Ordinary declaration */
68 FUNCDEF, /* Function definition */
69 PARM, /* Declaration of parm before function body */
70 FIELD, /* Declaration inside struct or union */
71 TYPENAME}; /* Typename (inside cast or sizeof) */
74 /* Nonzero if we have seen an invalid cross reference
75 to a struct, union, or enum, but not yet printed the message. */
76 tree pending_invalid_xref;
78 /* File and line to appear in the eventual error message. */
79 location_t pending_invalid_xref_location;
81 /* True means we've initialized exception handling. */
82 bool c_eh_initialized_p;
84 /* While defining an enum type, this is 1 plus the last enumerator
85 constant value. Note that will do not have to save this or `enum_overflow'
86 around nested function definition since such a definition could only
87 occur in an enum value expression and we don't use these variables in
90 static tree enum_next_value;
92 /* Nonzero means that there was overflow computing enum_next_value. */
94 static int enum_overflow;
96 /* The file and line that the prototype came from if this is an
97 old-style definition; used for diagnostics in
98 store_parm_decls_oldstyle. */
100 static location_t current_function_prototype_locus;
102 /* Whether this prototype was built-in. */
104 static bool current_function_prototype_built_in;
106 /* The argument type information of this prototype. */
108 static tree current_function_prototype_arg_types;
110 /* The argument information structure for the function currently being
113 static struct c_arg_info *current_function_arg_info;
115 /* The obstack on which parser and related data structures, which are
116 not live beyond their top-level declaration or definition, are
118 struct obstack parser_obstack;
120 /* The current statement tree. */
122 static GTY(()) struct stmt_tree_s c_stmt_tree;
124 /* State saving variables. */
128 /* Linked list of TRANSLATION_UNIT_DECLS for the translation units
129 included in this invocation. Note that the current translation
130 unit is not included in this list. */
132 static GTY(()) tree all_translation_units;
134 /* A list of decls to be made automatically visible in each file scope. */
135 static GTY(()) tree visible_builtins;
137 /* Set to 0 at beginning of a function definition, set to 1 if
138 a return statement that specifies a return value is seen. */
140 int current_function_returns_value;
142 /* Set to 0 at beginning of a function definition, set to 1 if
143 a return statement with no argument is seen. */
145 int current_function_returns_null;
147 /* Set to 0 at beginning of a function definition, set to 1 if
148 a call to a noreturn function is seen. */
150 int current_function_returns_abnormally;
152 /* Set to nonzero by `grokdeclarator' for a function
153 whose return type is defaulted, if warnings for this are desired. */
155 static int warn_about_return_type;
157 /* Nonzero when starting a function declared `extern inline'. */
159 static int current_extern_inline;
161 /* Nonzero when the current toplevel function contains a declaration
162 of a nested function which is never defined. */
164 static bool undef_nested_function;
166 /* True means global_bindings_p should return false even if the scope stack
167 says we are in file scope. */
168 bool c_override_global_bindings_to_false;
171 /* Each c_binding structure describes one binding of an identifier to
172 a decl. All the decls in a scope - irrespective of namespace - are
173 chained together by the ->prev field, which (as the name implies)
174 runs in reverse order. All the decls in a given namespace bound to
175 a given identifier are chained by the ->shadowed field, which runs
176 from inner to outer scopes.
178 The ->decl field usually points to a DECL node, but there are two
179 exceptions. In the namespace of type tags, the bound entity is a
180 RECORD_TYPE, UNION_TYPE, or ENUMERAL_TYPE node. If an undeclared
181 identifier is encountered, it is bound to error_mark_node to
182 suppress further errors about that identifier in the current
185 The ->type field stores the type of the declaration in this scope;
186 if NULL, the type is the type of the ->decl field. This is only of
187 relevance for objects with external or internal linkage which may
188 be redeclared in inner scopes, forming composite types that only
189 persist for the duration of those scopes. In the external scope,
190 this stores the composite of all the types declared for this
191 object, visible or not. The ->inner_comp field (used only at file
192 scope) stores whether an incomplete array type at file scope was
193 completed at an inner scope to an array size other than 1.
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 c_binding GTY((chain_next ("%h.prev")))
206 tree decl; /* the decl bound */
207 tree type; /* the type in this scope */
208 tree id; /* the identifier it's bound to */
209 struct c_binding *prev; /* the previous decl in this scope */
210 struct c_binding *shadowed; /* the innermost decl shadowed by this one */
211 unsigned int depth : 28; /* depth of this scope */
212 BOOL_BITFIELD invisible : 1; /* normal lookup should ignore this binding */
213 BOOL_BITFIELD nested : 1; /* do not set DECL_CONTEXT when popping */
214 BOOL_BITFIELD inner_comp : 1; /* incomplete array completed in inner scope */
217 #define B_IN_SCOPE(b1, b2) ((b1)->depth == (b2)->depth)
218 #define B_IN_CURRENT_SCOPE(b) ((b)->depth == current_scope->depth)
219 #define B_IN_FILE_SCOPE(b) ((b)->depth == 1 /*file_scope->depth*/)
220 #define B_IN_EXTERNAL_SCOPE(b) ((b)->depth == 0 /*external_scope->depth*/)
222 #define I_SYMBOL_BINDING(node) \
223 (((struct lang_identifier *) IDENTIFIER_NODE_CHECK(node))->symbol_binding)
224 #define I_SYMBOL_DECL(node) \
225 (I_SYMBOL_BINDING(node) ? I_SYMBOL_BINDING(node)->decl : 0)
227 #define I_TAG_BINDING(node) \
228 (((struct lang_identifier *) IDENTIFIER_NODE_CHECK(node))->tag_binding)
229 #define I_TAG_DECL(node) \
230 (I_TAG_BINDING(node) ? I_TAG_BINDING(node)->decl : 0)
232 #define I_LABEL_BINDING(node) \
233 (((struct lang_identifier *) IDENTIFIER_NODE_CHECK(node))->label_binding)
234 #define I_LABEL_DECL(node) \
235 (I_LABEL_BINDING(node) ? I_LABEL_BINDING(node)->decl : 0)
237 /* Each C symbol points to three linked lists of c_binding structures.
238 These describe the values of the identifier in the three different
239 namespaces defined by the language. */
241 struct lang_identifier GTY(())
243 struct c_common_identifier common_id;
244 struct c_binding *symbol_binding; /* vars, funcs, constants, typedefs */
245 struct c_binding *tag_binding; /* struct/union/enum tags */
246 struct c_binding *label_binding; /* labels */
249 /* Validate c-lang.c's assumptions. */
250 extern char C_SIZEOF_STRUCT_LANG_IDENTIFIER_isnt_accurate
251 [(sizeof(struct lang_identifier) == C_SIZEOF_STRUCT_LANG_IDENTIFIER) ? 1 : -1];
253 /* The resulting tree type. */
256 GTY((desc ("TREE_CODE (&%h.generic) == IDENTIFIER_NODE"),
257 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)")))
259 union tree_node GTY ((tag ("0"),
260 desc ("tree_node_structure (&%h)")))
262 struct lang_identifier GTY ((tag ("1"))) identifier;
265 /* Each c_scope structure describes the complete contents of one
266 scope. Four scopes are distinguished specially: the innermost or
267 current scope, the innermost function scope, the file scope (always
268 the second to outermost) and the outermost or external scope.
270 Most declarations are recorded in the current scope.
272 All normal label declarations are recorded in the innermost
273 function scope, as are bindings of undeclared identifiers to
274 error_mark_node. (GCC permits nested functions as an extension,
275 hence the 'innermost' qualifier.) Explicitly declared labels
276 (using the __label__ extension) appear in the current scope.
278 Being in the file scope (current_scope == file_scope) causes
279 special behavior in several places below. Also, under some
280 conditions the Objective-C front end records declarations in the
281 file scope even though that isn't the current scope.
283 All declarations with external linkage are recorded in the external
284 scope, even if they aren't visible there; this models the fact that
285 such declarations are visible to the entire program, and (with a
286 bit of cleverness, see pushdecl) allows diagnosis of some violations
287 of C99 6.2.2p7 and 6.2.7p2:
289 If, within the same translation unit, the same identifier appears
290 with both internal and external linkage, the behavior is
293 All declarations that refer to the same object or function shall
294 have compatible type; otherwise, the behavior is undefined.
296 Initially only the built-in declarations, which describe compiler
297 intrinsic functions plus a subset of the standard library, are in
300 The order of the blocks list matters, and it is frequently appended
301 to. To avoid having to walk all the way to the end of the list on
302 each insertion, or reverse the list later, we maintain a pointer to
303 the last list entry. (FIXME: It should be feasible to use a reversed
306 The bindings list is strictly in reverse order of declarations;
307 pop_scope relies on this. */
310 struct c_scope GTY((chain_next ("%h.outer")))
312 /* The scope containing this one. */
313 struct c_scope *outer;
315 /* The next outermost function scope. */
316 struct c_scope *outer_function;
318 /* All bindings in this scope. */
319 struct c_binding *bindings;
321 /* For each scope (except the global one), a chain of BLOCK nodes
322 for all the scopes that were entered and exited one level down. */
326 /* The depth of this scope. Used to keep the ->shadowed chain of
327 bindings sorted innermost to outermost. */
328 unsigned int depth : 28;
330 /* True if we are currently filling this scope with parameter
332 BOOL_BITFIELD parm_flag : 1;
334 /* True if we saw [*] in this scope. Used to give an error messages
335 if these appears in a function definition. */
336 BOOL_BITFIELD had_vla_unspec : 1;
338 /* True if we already complained about forward parameter decls
339 in this scope. This prevents double warnings on
340 foo (int a; int b; ...) */
341 BOOL_BITFIELD warned_forward_parm_decls : 1;
343 /* True if this is the outermost block scope of a function body.
344 This scope contains the parameters, the local variables declared
345 in the outermost block, and all the labels (except those in
346 nested functions, or declared at block scope with __label__). */
347 BOOL_BITFIELD function_body : 1;
349 /* True means make a BLOCK for this scope no matter what. */
350 BOOL_BITFIELD keep : 1;
353 /* The scope currently in effect. */
355 static GTY(()) struct c_scope *current_scope;
357 /* The innermost function scope. Ordinary (not explicitly declared)
358 labels, bindings to error_mark_node, and the lazily-created
359 bindings of __func__ and its friends get this scope. */
361 static GTY(()) struct c_scope *current_function_scope;
363 /* The C file scope. This is reset for each input translation unit. */
365 static GTY(()) struct c_scope *file_scope;
367 /* The outermost scope. This is used for all declarations with
368 external linkage, and only these, hence the name. */
370 static GTY(()) struct c_scope *external_scope;
372 /* A chain of c_scope structures awaiting reuse. */
374 static GTY((deletable)) struct c_scope *scope_freelist;
376 /* A chain of c_binding structures awaiting reuse. */
378 static GTY((deletable)) struct c_binding *binding_freelist;
380 /* Append VAR to LIST in scope SCOPE. */
381 #define SCOPE_LIST_APPEND(scope, list, decl) do { \
382 struct c_scope *s_ = (scope); \
384 if (s_->list##_last) \
385 TREE_CHAIN (s_->list##_last) = d_; \
388 s_->list##_last = d_; \
391 /* Concatenate FROM in scope FSCOPE onto TO in scope TSCOPE. */
392 #define SCOPE_LIST_CONCAT(tscope, to, fscope, from) do { \
393 struct c_scope *t_ = (tscope); \
394 struct c_scope *f_ = (fscope); \
396 TREE_CHAIN (t_->to##_last) = f_->from; \
399 t_->to##_last = f_->from##_last; \
402 /* True means unconditionally make a BLOCK for the next scope pushed. */
404 static bool keep_next_level_flag;
406 /* True means the next call to push_scope will be the outermost scope
407 of a function body, so do not push a new scope, merely cease
408 expecting parameter decls. */
410 static bool next_is_function_body;
412 /* Functions called automatically at the beginning and end of execution. */
414 static GTY(()) tree static_ctors;
415 static GTY(()) tree static_dtors;
417 /* Forward declarations. */
418 static tree lookup_name_in_scope (tree, struct c_scope *);
419 static tree c_make_fname_decl (tree, int);
420 static tree grokdeclarator (const struct c_declarator *,
421 struct c_declspecs *,
422 enum decl_context, bool, tree *);
423 static tree grokparms (struct c_arg_info *, bool);
424 static void layout_array_type (tree);
426 /* T is a statement. Add it to the statement-tree. This is the
427 C/ObjC version--C++ has a slightly different version of this
433 enum tree_code code = TREE_CODE (t);
435 if (EXPR_P (t) && code != LABEL_EXPR)
437 if (!EXPR_HAS_LOCATION (t))
438 SET_EXPR_LOCATION (t, input_location);
441 if (code == LABEL_EXPR || code == CASE_LABEL_EXPR)
442 STATEMENT_LIST_HAS_LABEL (cur_stmt_list) = 1;
444 /* Add T to the statement-tree. Non-side-effect statements need to be
445 recorded during statement expressions. */
446 append_to_statement_list_force (t, &cur_stmt_list);
451 /* States indicating how grokdeclarator() should handle declspecs marked
452 with __attribute__((deprecated)). An object declared as
453 __attribute__((deprecated)) suppresses warnings of uses of other
456 enum deprecated_states {
461 static enum deprecated_states deprecated_state = DEPRECATED_NORMAL;
464 c_print_identifier (FILE *file, tree node, int indent)
466 print_node (file, "symbol", I_SYMBOL_DECL (node), indent + 4);
467 print_node (file, "tag", I_TAG_DECL (node), indent + 4);
468 print_node (file, "label", I_LABEL_DECL (node), indent + 4);
469 if (C_IS_RESERVED_WORD (node))
471 tree rid = ridpointers[C_RID_CODE (node)];
472 indent_to (file, indent + 4);
473 fprintf (file, "rid %p \"%s\"",
474 (void *) rid, IDENTIFIER_POINTER (rid));
478 /* Establish a binding between NAME, an IDENTIFIER_NODE, and DECL,
479 which may be any of several kinds of DECL or TYPE or error_mark_node,
480 in the scope SCOPE. */
482 bind (tree name, tree decl, struct c_scope *scope, bool invisible, bool nested)
484 struct c_binding *b, **here;
486 if (binding_freelist)
488 b = binding_freelist;
489 binding_freelist = b->prev;
492 b = GGC_NEW (struct c_binding);
497 b->depth = scope->depth;
498 b->invisible = invisible;
504 b->prev = scope->bindings;
510 switch (TREE_CODE (decl))
512 case LABEL_DECL: here = &I_LABEL_BINDING (name); break;
515 case RECORD_TYPE: here = &I_TAG_BINDING (name); break;
521 case ERROR_MARK: here = &I_SYMBOL_BINDING (name); break;
527 /* Locate the appropriate place in the chain of shadowed decls
528 to insert this binding. Normally, scope == current_scope and
529 this does nothing. */
530 while (*here && (*here)->depth > scope->depth)
531 here = &(*here)->shadowed;
537 /* Clear the binding structure B, stick it on the binding_freelist,
538 and return the former value of b->prev. This is used by pop_scope
539 and get_parm_info to iterate destructively over all the bindings
540 from a given scope. */
541 static struct c_binding *
542 free_binding_and_advance (struct c_binding *b)
544 struct c_binding *prev = b->prev;
546 memset (b, 0, sizeof (struct c_binding));
547 b->prev = binding_freelist;
548 binding_freelist = b;
554 /* Hook called at end of compilation to assume 1 elt
555 for a file-scope tentative array defn that wasn't complete before. */
558 c_finish_incomplete_decl (tree decl)
560 if (TREE_CODE (decl) == VAR_DECL)
562 tree type = TREE_TYPE (decl);
563 if (type != error_mark_node
564 && TREE_CODE (type) == ARRAY_TYPE
565 && !DECL_EXTERNAL (decl)
566 && TYPE_DOMAIN (type) == 0)
568 warning (0, "array %q+D assumed to have one element", decl);
570 complete_array_type (&TREE_TYPE (decl), NULL_TREE, true);
572 layout_decl (decl, 0);
577 /* The Objective-C front-end often needs to determine the current scope. */
580 objc_get_current_scope (void)
582 return current_scope;
585 /* The following function is used only by Objective-C. It needs to live here
586 because it accesses the innards of c_scope. */
589 objc_mark_locals_volatile (void *enclosing_blk)
591 struct c_scope *scope;
594 for (scope = current_scope;
595 scope && scope != enclosing_blk;
596 scope = scope->outer)
598 for (b = scope->bindings; b; b = b->prev)
599 objc_volatilize_decl (b->decl);
601 /* Do not climb up past the current function. */
602 if (scope->function_body)
607 /* Nonzero if we are currently in file scope. */
610 global_bindings_p (void)
612 return current_scope == file_scope && !c_override_global_bindings_to_false;
616 keep_next_level (void)
618 keep_next_level_flag = true;
621 /* Identify this scope as currently being filled with parameters. */
624 declare_parm_level (void)
626 current_scope->parm_flag = true;
632 if (next_is_function_body)
634 /* This is the transition from the parameters to the top level
635 of the function body. These are the same scope
636 (C99 6.2.1p4,6) so we do not push another scope structure.
637 next_is_function_body is set only by store_parm_decls, which
638 in turn is called when and only when we are about to
639 encounter the opening curly brace for the function body.
641 The outermost block of a function always gets a BLOCK node,
642 because the debugging output routines expect that each
643 function has at least one BLOCK. */
644 current_scope->parm_flag = false;
645 current_scope->function_body = true;
646 current_scope->keep = true;
647 current_scope->outer_function = current_function_scope;
648 current_function_scope = current_scope;
650 keep_next_level_flag = false;
651 next_is_function_body = false;
655 struct c_scope *scope;
658 scope = scope_freelist;
659 scope_freelist = scope->outer;
662 scope = GGC_CNEW (struct c_scope);
664 scope->keep = keep_next_level_flag;
665 scope->outer = current_scope;
666 scope->depth = current_scope ? (current_scope->depth + 1) : 0;
668 /* Check for scope depth overflow. Unlikely (2^28 == 268,435,456) but
670 if (current_scope && scope->depth == 0)
673 sorry ("GCC supports only %u nested scopes", scope->depth);
676 current_scope = scope;
677 keep_next_level_flag = false;
681 /* Set the TYPE_CONTEXT of all of TYPE's variants to CONTEXT. */
684 set_type_context (tree type, tree context)
686 for (type = TYPE_MAIN_VARIANT (type); type;
687 type = TYPE_NEXT_VARIANT (type))
688 TYPE_CONTEXT (type) = context;
691 /* Exit a scope. Restore the state of the identifier-decl mappings
692 that were in effect when this scope was entered. Return a BLOCK
693 node containing all the DECLs in this scope that are of interest
694 to debug info generation. */
699 struct c_scope *scope = current_scope;
700 tree block, context, p;
703 bool functionbody = scope->function_body;
704 bool keep = functionbody || scope->keep || scope->bindings;
706 c_end_vm_scope (scope->depth);
708 /* If appropriate, create a BLOCK to record the decls for the life
713 block = make_node (BLOCK);
714 BLOCK_SUBBLOCKS (block) = scope->blocks;
715 TREE_USED (block) = 1;
717 /* In each subblock, record that this is its superior. */
718 for (p = scope->blocks; p; p = TREE_CHAIN (p))
719 BLOCK_SUPERCONTEXT (p) = block;
721 BLOCK_VARS (block) = 0;
724 /* The TYPE_CONTEXTs for all of the tagged types belonging to this
725 scope must be set so that they point to the appropriate
726 construct, i.e. either to the current FUNCTION_DECL node, or
727 else to the BLOCK node we just constructed.
729 Note that for tagged types whose scope is just the formal
730 parameter list for some function type specification, we can't
731 properly set their TYPE_CONTEXTs here, because we don't have a
732 pointer to the appropriate FUNCTION_TYPE node readily available
733 to us. For those cases, the TYPE_CONTEXTs of the relevant tagged
734 type nodes get set in `grokdeclarator' as soon as we have created
735 the FUNCTION_TYPE node which will represent the "scope" for these
736 "parameter list local" tagged types. */
737 if (scope->function_body)
738 context = current_function_decl;
739 else if (scope == file_scope)
741 tree file_decl = build_decl (TRANSLATION_UNIT_DECL, 0, 0);
742 TREE_CHAIN (file_decl) = all_translation_units;
743 all_translation_units = file_decl;
749 /* Clear all bindings in this scope. */
750 for (b = scope->bindings; b; b = free_binding_and_advance (b))
753 switch (TREE_CODE (p))
756 /* Warnings for unused labels, errors for undefined labels. */
757 if (TREE_USED (p) && !DECL_INITIAL (p))
759 error ("label %q+D used but not defined", p);
760 DECL_INITIAL (p) = error_mark_node;
762 else if (!TREE_USED (p) && warn_unused_label)
764 if (DECL_INITIAL (p))
765 warning (0, "label %q+D defined but not used", p);
767 warning (0, "label %q+D declared but not defined", p);
769 /* Labels go in BLOCK_VARS. */
770 TREE_CHAIN (p) = BLOCK_VARS (block);
771 BLOCK_VARS (block) = p;
772 gcc_assert (I_LABEL_BINDING (b->id) == b);
773 I_LABEL_BINDING (b->id) = b->shadowed;
779 set_type_context (p, context);
781 /* Types may not have tag-names, in which case the type
782 appears in the bindings list with b->id NULL. */
785 gcc_assert (I_TAG_BINDING (b->id) == b);
786 I_TAG_BINDING (b->id) = b->shadowed;
791 /* Propagate TREE_ADDRESSABLE from nested functions to their
792 containing functions. */
793 if (!TREE_ASM_WRITTEN (p)
794 && DECL_INITIAL (p) != 0
795 && TREE_ADDRESSABLE (p)
796 && DECL_ABSTRACT_ORIGIN (p) != 0
797 && DECL_ABSTRACT_ORIGIN (p) != p)
798 TREE_ADDRESSABLE (DECL_ABSTRACT_ORIGIN (p)) = 1;
799 if (!DECL_EXTERNAL (p)
800 && DECL_INITIAL (p) == 0)
802 error ("nested function %q+D declared but never defined", p);
803 undef_nested_function = true;
808 /* Warnings for unused variables. */
810 && !TREE_NO_WARNING (p)
811 && !DECL_IN_SYSTEM_HEADER (p)
813 && !DECL_ARTIFICIAL (p)
814 && scope != file_scope
815 && scope != external_scope)
816 warning (OPT_Wunused_variable, "unused variable %q+D", p);
820 error ("type of array %q+D completed incompatibly with"
821 " implicit initialization", p);
828 /* All of these go in BLOCK_VARS, but only if this is the
829 binding in the home scope. */
832 TREE_CHAIN (p) = BLOCK_VARS (block);
833 BLOCK_VARS (block) = p;
835 /* If this is the file scope, and we are processing more
836 than one translation unit in this compilation, set
837 DECL_CONTEXT of each decl to the TRANSLATION_UNIT_DECL.
838 This makes same_translation_unit_p work, and causes
839 static declarations to be given disambiguating suffixes. */
840 if (scope == file_scope && num_in_fnames > 1)
842 DECL_CONTEXT (p) = context;
843 if (TREE_CODE (p) == TYPE_DECL)
844 set_type_context (TREE_TYPE (p), context);
848 /* Parameters go in DECL_ARGUMENTS, not BLOCK_VARS, and have
849 already been put there by store_parm_decls. Unused-
850 parameter warnings are handled by function.c.
851 error_mark_node obviously does not go in BLOCK_VARS and
852 does not get unused-variable warnings. */
855 /* It is possible for a decl not to have a name. We get
856 here with b->id NULL in this case. */
859 gcc_assert (I_SYMBOL_BINDING (b->id) == b);
860 I_SYMBOL_BINDING (b->id) = b->shadowed;
861 if (b->shadowed && b->shadowed->type)
862 TREE_TYPE (b->shadowed->decl) = b->shadowed->type;
872 /* Dispose of the block that we just made inside some higher level. */
873 if ((scope->function_body || scope == file_scope) && context)
875 DECL_INITIAL (context) = block;
876 BLOCK_SUPERCONTEXT (block) = context;
878 else if (scope->outer)
881 SCOPE_LIST_APPEND (scope->outer, blocks, block);
882 /* If we did not make a block for the scope just exited, any
883 blocks made for inner scopes must be carried forward so they
884 will later become subblocks of something else. */
885 else if (scope->blocks)
886 SCOPE_LIST_CONCAT (scope->outer, blocks, scope, blocks);
889 /* Pop the current scope, and free the structure for reuse. */
890 current_scope = scope->outer;
891 if (scope->function_body)
892 current_function_scope = scope->outer_function;
894 memset (scope, 0, sizeof (struct c_scope));
895 scope->outer = scope_freelist;
896 scope_freelist = scope;
902 push_file_scope (void)
910 file_scope = current_scope;
912 start_fname_decls ();
914 for (decl = visible_builtins; decl; decl = TREE_CHAIN (decl))
915 bind (DECL_NAME (decl), decl, file_scope,
916 /*invisible=*/false, /*nested=*/true);
920 pop_file_scope (void)
922 /* In case there were missing closebraces, get us back to the global
924 while (current_scope != file_scope)
927 /* __FUNCTION__ is defined at file scope (""). This
928 call may not be necessary as my tests indicate it
929 still works without it. */
930 finish_fname_decls ();
932 /* This is the point to write out a PCH if we're doing that.
933 In that case we do not want to do anything else. */
936 c_common_write_pch ();
940 /* Pop off the file scope and close this translation unit. */
944 maybe_apply_pending_pragma_weaks ();
945 cgraph_finalize_compilation_unit ();
948 /* Insert BLOCK at the end of the list of subblocks of the current
949 scope. This is used when a BIND_EXPR is expanded, to handle the
950 BLOCK node inside the BIND_EXPR. */
953 insert_block (tree block)
955 TREE_USED (block) = 1;
956 SCOPE_LIST_APPEND (current_scope, blocks, block);
959 /* Push a definition or a declaration of struct, union or enum tag "name".
960 "type" should be the type node.
961 We assume that the tag "name" is not already defined.
963 Note that the definition may really be just a forward reference.
964 In that case, the TYPE_SIZE will be zero. */
967 pushtag (tree name, tree type)
969 /* Record the identifier as the type's name if it has none. */
970 if (name && !TYPE_NAME (type))
971 TYPE_NAME (type) = name;
972 bind (name, type, current_scope, /*invisible=*/false, /*nested=*/false);
974 /* Create a fake NULL-named TYPE_DECL node whose TREE_TYPE will be the
975 tagged type we just added to the current scope. This fake
976 NULL-named TYPE_DECL node helps dwarfout.c to know when it needs
977 to output a representation of a tagged type, and it also gives
978 us a convenient place to record the "scope start" address for the
981 TYPE_STUB_DECL (type) = pushdecl (build_decl (TYPE_DECL, NULL_TREE, type));
983 /* An approximation for now, so we can tell this is a function-scope tag.
984 This will be updated in pop_scope. */
985 TYPE_CONTEXT (type) = DECL_CONTEXT (TYPE_STUB_DECL (type));
988 /* Subroutine of compare_decls. Allow harmless mismatches in return
989 and argument types provided that the type modes match. This function
990 return a unified type given a suitable match, and 0 otherwise. */
993 match_builtin_function_types (tree newtype, tree oldtype)
995 tree newrettype, oldrettype;
996 tree newargs, oldargs;
997 tree trytype, tryargs;
999 /* Accept the return type of the new declaration if same modes. */
1000 oldrettype = TREE_TYPE (oldtype);
1001 newrettype = TREE_TYPE (newtype);
1003 if (TYPE_MODE (oldrettype) != TYPE_MODE (newrettype))
1006 oldargs = TYPE_ARG_TYPES (oldtype);
1007 newargs = TYPE_ARG_TYPES (newtype);
1010 while (oldargs || newargs)
1014 || !TREE_VALUE (oldargs)
1015 || !TREE_VALUE (newargs)
1016 || TYPE_MODE (TREE_VALUE (oldargs))
1017 != TYPE_MODE (TREE_VALUE (newargs)))
1020 oldargs = TREE_CHAIN (oldargs);
1021 newargs = TREE_CHAIN (newargs);
1024 trytype = build_function_type (newrettype, tryargs);
1025 return build_type_attribute_variant (trytype, TYPE_ATTRIBUTES (oldtype));
1028 /* Subroutine of diagnose_mismatched_decls. Check for function type
1029 mismatch involving an empty arglist vs a nonempty one and give clearer
1032 diagnose_arglist_conflict (tree newdecl, tree olddecl,
1033 tree newtype, tree oldtype)
1037 if (TREE_CODE (olddecl) != FUNCTION_DECL
1038 || !comptypes (TREE_TYPE (oldtype), TREE_TYPE (newtype))
1039 || !((TYPE_ARG_TYPES (oldtype) == 0 && DECL_INITIAL (olddecl) == 0)
1041 (TYPE_ARG_TYPES (newtype) == 0 && DECL_INITIAL (newdecl) == 0)))
1044 t = TYPE_ARG_TYPES (oldtype);
1046 t = TYPE_ARG_TYPES (newtype);
1047 for (; t; t = TREE_CHAIN (t))
1049 tree type = TREE_VALUE (t);
1051 if (TREE_CHAIN (t) == 0
1052 && TYPE_MAIN_VARIANT (type) != void_type_node)
1054 inform ("a parameter list with an ellipsis can%'t match "
1055 "an empty parameter name list declaration");
1059 if (c_type_promotes_to (type) != type)
1061 inform ("an argument type that has a default promotion can%'t match "
1062 "an empty parameter name list declaration");
1068 /* Another subroutine of diagnose_mismatched_decls. OLDDECL is an
1069 old-style function definition, NEWDECL is a prototype declaration.
1070 Diagnose inconsistencies in the argument list. Returns TRUE if
1071 the prototype is compatible, FALSE if not. */
1073 validate_proto_after_old_defn (tree newdecl, tree newtype, tree oldtype)
1075 tree newargs, oldargs;
1078 #define END_OF_ARGLIST(t) ((t) == void_type_node)
1080 oldargs = TYPE_ACTUAL_ARG_TYPES (oldtype);
1081 newargs = TYPE_ARG_TYPES (newtype);
1086 tree oldargtype = TREE_VALUE (oldargs);
1087 tree newargtype = TREE_VALUE (newargs);
1089 if (oldargtype == error_mark_node || newargtype == error_mark_node)
1092 oldargtype = TYPE_MAIN_VARIANT (oldargtype);
1093 newargtype = TYPE_MAIN_VARIANT (newargtype);
1095 if (END_OF_ARGLIST (oldargtype) && END_OF_ARGLIST (newargtype))
1098 /* Reaching the end of just one list means the two decls don't
1099 agree on the number of arguments. */
1100 if (END_OF_ARGLIST (oldargtype))
1102 error ("prototype for %q+D declares more arguments "
1103 "than previous old-style definition", newdecl);
1106 else if (END_OF_ARGLIST (newargtype))
1108 error ("prototype for %q+D declares fewer arguments "
1109 "than previous old-style definition", newdecl);
1113 /* Type for passing arg must be consistent with that declared
1115 else if (!comptypes (oldargtype, newargtype))
1117 error ("prototype for %q+D declares argument %d"
1118 " with incompatible type",
1123 oldargs = TREE_CHAIN (oldargs);
1124 newargs = TREE_CHAIN (newargs);
1128 /* If we get here, no errors were found, but do issue a warning
1129 for this poor-style construct. */
1130 warning (0, "prototype for %q+D follows non-prototype definition",
1133 #undef END_OF_ARGLIST
1136 /* Subroutine of diagnose_mismatched_decls. Report the location of DECL,
1137 first in a pair of mismatched declarations, using the diagnostic
1140 locate_old_decl (tree decl, void (*diag)(const char *, ...) ATTRIBUTE_GCC_CDIAG(1,2))
1142 if (TREE_CODE (decl) == FUNCTION_DECL && DECL_BUILT_IN (decl))
1144 else if (DECL_INITIAL (decl))
1145 diag (G_("previous definition of %q+D was here"), decl);
1146 else if (C_DECL_IMPLICIT (decl))
1147 diag (G_("previous implicit declaration of %q+D was here"), decl);
1149 diag (G_("previous declaration of %q+D was here"), decl);
1152 /* Subroutine of duplicate_decls. Compare NEWDECL to OLDDECL.
1153 Returns true if the caller should proceed to merge the two, false
1154 if OLDDECL should simply be discarded. As a side effect, issues
1155 all necessary diagnostics for invalid or poor-style combinations.
1156 If it returns true, writes the types of NEWDECL and OLDDECL to
1157 *NEWTYPEP and *OLDTYPEP - these may have been adjusted from
1158 TREE_TYPE (NEWDECL, OLDDECL) respectively. */
1161 diagnose_mismatched_decls (tree newdecl, tree olddecl,
1162 tree *newtypep, tree *oldtypep)
1164 tree newtype, oldtype;
1165 bool pedwarned = false;
1166 bool warned = false;
1169 #define DECL_EXTERN_INLINE(DECL) (DECL_DECLARED_INLINE_P (DECL) \
1170 && DECL_EXTERNAL (DECL))
1172 /* If we have error_mark_node for either decl or type, just discard
1173 the previous decl - we're in an error cascade already. */
1174 if (olddecl == error_mark_node || newdecl == error_mark_node)
1176 *oldtypep = oldtype = TREE_TYPE (olddecl);
1177 *newtypep = newtype = TREE_TYPE (newdecl);
1178 if (oldtype == error_mark_node || newtype == error_mark_node)
1181 /* Two different categories of symbol altogether. This is an error
1182 unless OLDDECL is a builtin. OLDDECL will be discarded in any case. */
1183 if (TREE_CODE (olddecl) != TREE_CODE (newdecl))
1185 if (!(TREE_CODE (olddecl) == FUNCTION_DECL
1186 && DECL_BUILT_IN (olddecl)
1187 && !C_DECL_DECLARED_BUILTIN (olddecl)))
1189 error ("%q+D redeclared as different kind of symbol", newdecl);
1190 locate_old_decl (olddecl, error);
1192 else if (TREE_PUBLIC (newdecl))
1193 warning (0, "built-in function %q+D declared as non-function",
1196 warning (OPT_Wshadow, "declaration of %q+D shadows "
1197 "a built-in function", newdecl);
1201 /* Enumerators have no linkage, so may only be declared once in a
1203 if (TREE_CODE (olddecl) == CONST_DECL)
1205 error ("redeclaration of enumerator %q+D", newdecl);
1206 locate_old_decl (olddecl, error);
1210 if (!comptypes (oldtype, newtype))
1212 if (TREE_CODE (olddecl) == FUNCTION_DECL
1213 && DECL_BUILT_IN (olddecl) && !C_DECL_DECLARED_BUILTIN (olddecl))
1215 /* Accept harmless mismatch in function types.
1216 This is for the ffs and fprintf builtins. */
1217 tree trytype = match_builtin_function_types (newtype, oldtype);
1219 if (trytype && comptypes (newtype, trytype))
1220 *oldtypep = oldtype = trytype;
1223 /* If types don't match for a built-in, throw away the
1224 built-in. No point in calling locate_old_decl here, it
1225 won't print anything. */
1226 warning (0, "conflicting types for built-in function %q+D",
1231 else if (TREE_CODE (olddecl) == FUNCTION_DECL
1232 && DECL_IS_BUILTIN (olddecl))
1234 /* A conflicting function declaration for a predeclared
1235 function that isn't actually built in. Objective C uses
1236 these. The new declaration silently overrides everything
1237 but the volatility (i.e. noreturn) indication. See also
1238 below. FIXME: Make Objective C use normal builtins. */
1239 TREE_THIS_VOLATILE (newdecl) |= TREE_THIS_VOLATILE (olddecl);
1242 /* Permit void foo (...) to match int foo (...) if the latter is
1243 the definition and implicit int was used. See
1244 c-torture/compile/920625-2.c. */
1245 else if (TREE_CODE (newdecl) == FUNCTION_DECL && DECL_INITIAL (newdecl)
1246 && TYPE_MAIN_VARIANT (TREE_TYPE (oldtype)) == void_type_node
1247 && TYPE_MAIN_VARIANT (TREE_TYPE (newtype)) == integer_type_node
1248 && C_FUNCTION_IMPLICIT_INT (newdecl) && !DECL_INITIAL (olddecl))
1250 pedwarn ("conflicting types for %q+D", newdecl);
1251 /* Make sure we keep void as the return type. */
1252 TREE_TYPE (newdecl) = *newtypep = newtype = oldtype;
1253 C_FUNCTION_IMPLICIT_INT (newdecl) = 0;
1256 /* Permit void foo (...) to match an earlier call to foo (...) with
1257 no declared type (thus, implicitly int). */
1258 else if (TREE_CODE (newdecl) == FUNCTION_DECL
1259 && TYPE_MAIN_VARIANT (TREE_TYPE (newtype)) == void_type_node
1260 && TYPE_MAIN_VARIANT (TREE_TYPE (oldtype)) == integer_type_node
1261 && C_DECL_IMPLICIT (olddecl) && !DECL_INITIAL (olddecl))
1263 pedwarn ("conflicting types for %q+D", newdecl);
1264 /* Make sure we keep void as the return type. */
1265 TREE_TYPE (olddecl) = *oldtypep = oldtype = newtype;
1270 if (TYPE_QUALS (newtype) != TYPE_QUALS (oldtype))
1271 error ("conflicting type qualifiers for %q+D", newdecl);
1273 error ("conflicting types for %q+D", newdecl);
1274 diagnose_arglist_conflict (newdecl, olddecl, newtype, oldtype);
1275 locate_old_decl (olddecl, error);
1280 /* Redeclaration of a type is a constraint violation (6.7.2.3p1),
1281 but silently ignore the redeclaration if either is in a system
1282 header. (Conflicting redeclarations were handled above.) */
1283 if (TREE_CODE (newdecl) == TYPE_DECL)
1285 if (DECL_IN_SYSTEM_HEADER (newdecl) || DECL_IN_SYSTEM_HEADER (olddecl))
1286 return true; /* Allow OLDDECL to continue in use. */
1288 error ("redefinition of typedef %q+D", newdecl);
1289 locate_old_decl (olddecl, error);
1293 /* Function declarations can either be 'static' or 'extern' (no
1294 qualifier is equivalent to 'extern' - C99 6.2.2p5) and therefore
1295 can never conflict with each other on account of linkage (6.2.2p4).
1296 Multiple definitions are not allowed (6.9p3,5) but GCC permits
1297 two definitions if one is 'extern inline' and one is not. The non-
1298 extern-inline definition supersedes the extern-inline definition. */
1300 else if (TREE_CODE (newdecl) == FUNCTION_DECL)
1302 /* If you declare a built-in function name as static, or
1303 define the built-in with an old-style definition (so we
1304 can't validate the argument list) the built-in definition is
1305 overridden, but optionally warn this was a bad choice of name. */
1306 if (DECL_BUILT_IN (olddecl)
1307 && !C_DECL_DECLARED_BUILTIN (olddecl)
1308 && (!TREE_PUBLIC (newdecl)
1309 || (DECL_INITIAL (newdecl)
1310 && !TYPE_ARG_TYPES (TREE_TYPE (newdecl)))))
1312 warning (OPT_Wshadow, "declaration of %q+D shadows "
1313 "a built-in function", newdecl);
1314 /* Discard the old built-in function. */
1318 if (DECL_INITIAL (newdecl))
1320 if (DECL_INITIAL (olddecl))
1322 /* If both decls are in the same TU and the new declaration
1323 isn't overriding an extern inline reject the new decl.
1324 When we handle c99 style inline rules we'll want to reject
1327 DECL_EXTERN_INLINE (olddecl)
1328 && !DECL_EXTERN_INLINE (newdecl)
1330 if they're in the same translation unit. Until we implement
1331 the full semantics we accept the construct. */
1332 if (!(DECL_EXTERN_INLINE (olddecl)
1333 && !DECL_EXTERN_INLINE (newdecl))
1334 && same_translation_unit_p (newdecl, olddecl))
1336 error ("redefinition of %q+D", newdecl);
1337 locate_old_decl (olddecl, error);
1342 /* If we have a prototype after an old-style function definition,
1343 the argument types must be checked specially. */
1344 else if (DECL_INITIAL (olddecl)
1345 && !TYPE_ARG_TYPES (oldtype) && TYPE_ARG_TYPES (newtype)
1346 && TYPE_ACTUAL_ARG_TYPES (oldtype)
1347 && !validate_proto_after_old_defn (newdecl, newtype, oldtype))
1349 locate_old_decl (olddecl, error);
1352 /* A non-static declaration (even an "extern") followed by a
1353 static declaration is undefined behavior per C99 6.2.2p3-5,7.
1354 The same is true for a static forward declaration at block
1355 scope followed by a non-static declaration/definition at file
1356 scope. Static followed by non-static at the same scope is
1357 not undefined behavior, and is the most convenient way to get
1358 some effects (see e.g. what unwind-dw2-fde-glibc.c does to
1359 the definition of _Unwind_Find_FDE in unwind-dw2-fde.c), but
1360 we do diagnose it if -Wtraditional. */
1361 if (TREE_PUBLIC (olddecl) && !TREE_PUBLIC (newdecl))
1363 /* Two exceptions to the rule. If olddecl is an extern
1364 inline, or a predeclared function that isn't actually
1365 built in, newdecl silently overrides olddecl. The latter
1366 occur only in Objective C; see also above. (FIXME: Make
1367 Objective C use normal builtins.) */
1368 if (!DECL_IS_BUILTIN (olddecl)
1369 && !DECL_EXTERN_INLINE (olddecl))
1371 error ("static declaration of %q+D follows "
1372 "non-static declaration", newdecl);
1373 locate_old_decl (olddecl, error);
1377 else if (TREE_PUBLIC (newdecl) && !TREE_PUBLIC (olddecl))
1379 if (DECL_CONTEXT (olddecl))
1381 error ("non-static declaration of %q+D follows "
1382 "static declaration", newdecl);
1383 locate_old_decl (olddecl, error);
1386 else if (warn_traditional)
1388 warning (OPT_Wtraditional, "non-static declaration of %q+D "
1389 "follows static declaration", newdecl);
1394 else if (TREE_CODE (newdecl) == VAR_DECL)
1396 /* Only variables can be thread-local, and all declarations must
1397 agree on this property. */
1398 if (C_DECL_THREADPRIVATE_P (olddecl) && !DECL_THREAD_LOCAL_P (newdecl))
1400 /* Nothing to check. Since OLDDECL is marked threadprivate
1401 and NEWDECL does not have a thread-local attribute, we
1402 will merge the threadprivate attribute into NEWDECL. */
1405 else if (DECL_THREAD_LOCAL_P (newdecl) != DECL_THREAD_LOCAL_P (olddecl))
1407 if (DECL_THREAD_LOCAL_P (newdecl))
1408 error ("thread-local declaration of %q+D follows "
1409 "non-thread-local declaration", newdecl);
1411 error ("non-thread-local declaration of %q+D follows "
1412 "thread-local declaration", newdecl);
1414 locate_old_decl (olddecl, error);
1418 /* Multiple initialized definitions are not allowed (6.9p3,5). */
1419 if (DECL_INITIAL (newdecl) && DECL_INITIAL (olddecl))
1421 error ("redefinition of %q+D", newdecl);
1422 locate_old_decl (olddecl, error);
1426 /* Objects declared at file scope: if the first declaration had
1427 external linkage (even if it was an external reference) the
1428 second must have external linkage as well, or the behavior is
1429 undefined. If the first declaration had internal linkage, then
1430 the second must too, or else be an external reference (in which
1431 case the composite declaration still has internal linkage).
1432 As for function declarations, we warn about the static-then-
1433 extern case only for -Wtraditional. See generally 6.2.2p3-5,7. */
1434 if (DECL_FILE_SCOPE_P (newdecl)
1435 && TREE_PUBLIC (newdecl) != TREE_PUBLIC (olddecl))
1437 if (DECL_EXTERNAL (newdecl))
1439 if (!DECL_FILE_SCOPE_P (olddecl))
1441 error ("extern declaration of %q+D follows "
1442 "declaration with no linkage", newdecl);
1443 locate_old_decl (olddecl, error);
1446 else if (warn_traditional)
1448 warning (OPT_Wtraditional, "non-static declaration of %q+D "
1449 "follows static declaration", newdecl);
1455 if (TREE_PUBLIC (newdecl))
1456 error ("non-static declaration of %q+D follows "
1457 "static declaration", newdecl);
1459 error ("static declaration of %q+D follows "
1460 "non-static declaration", newdecl);
1462 locate_old_decl (olddecl, error);
1466 /* Two objects with the same name declared at the same block
1467 scope must both be external references (6.7p3). */
1468 else if (!DECL_FILE_SCOPE_P (newdecl))
1470 if (DECL_EXTERNAL (newdecl))
1472 /* Extern with initializer at block scope, which will
1473 already have received an error. */
1475 else if (DECL_EXTERNAL (olddecl))
1477 error ("declaration of %q+D with no linkage follows "
1478 "extern declaration", newdecl);
1479 locate_old_decl (olddecl, error);
1483 error ("redeclaration of %q+D with no linkage", newdecl);
1484 locate_old_decl (olddecl, error);
1492 /* All decls must agree on a visibility. */
1493 if (CODE_CONTAINS_STRUCT (TREE_CODE (newdecl), TS_DECL_WITH_VIS)
1494 && DECL_VISIBILITY_SPECIFIED (newdecl) && DECL_VISIBILITY_SPECIFIED (olddecl)
1495 && DECL_VISIBILITY (newdecl) != DECL_VISIBILITY (olddecl))
1497 warning (0, "redeclaration of %q+D with different visibility "
1498 "(old visibility preserved)", newdecl);
1502 if (TREE_CODE (newdecl) == FUNCTION_DECL)
1504 /* Diagnose inline __attribute__ ((noinline)) which is silly. */
1505 if (DECL_DECLARED_INLINE_P (newdecl)
1506 && lookup_attribute ("noinline", DECL_ATTRIBUTES (olddecl)))
1508 warning (OPT_Wattributes, "inline declaration of %qD follows "
1509 "declaration with attribute noinline", newdecl);
1512 else if (DECL_DECLARED_INLINE_P (olddecl)
1513 && lookup_attribute ("noinline", DECL_ATTRIBUTES (newdecl)))
1515 warning (OPT_Wattributes, "declaration of %q+D with attribute "
1516 "noinline follows inline declaration ", newdecl);
1520 /* Inline declaration after use or definition.
1521 ??? Should we still warn about this now we have unit-at-a-time
1522 mode and can get it right?
1523 Definitely don't complain if the decls are in different translation
1525 if (DECL_DECLARED_INLINE_P (newdecl) && !DECL_DECLARED_INLINE_P (olddecl)
1526 && same_translation_unit_p (olddecl, newdecl))
1528 if (TREE_USED (olddecl))
1530 warning (0, "%q+D declared inline after being called", olddecl);
1533 else if (DECL_INITIAL (olddecl))
1535 warning (0, "%q+D declared inline after its definition", olddecl);
1540 else /* PARM_DECL, VAR_DECL */
1542 /* Redeclaration of a parameter is a constraint violation (this is
1543 not explicitly stated, but follows from C99 6.7p3 [no more than
1544 one declaration of the same identifier with no linkage in the
1545 same scope, except type tags] and 6.2.2p6 [parameters have no
1546 linkage]). We must check for a forward parameter declaration,
1547 indicated by TREE_ASM_WRITTEN on the old declaration - this is
1548 an extension, the mandatory diagnostic for which is handled by
1549 mark_forward_parm_decls. */
1551 if (TREE_CODE (newdecl) == PARM_DECL
1552 && (!TREE_ASM_WRITTEN (olddecl) || TREE_ASM_WRITTEN (newdecl)))
1554 error ("redefinition of parameter %q+D", newdecl);
1555 locate_old_decl (olddecl, error);
1560 /* Optional warning for completely redundant decls. */
1561 if (!warned && !pedwarned
1562 && warn_redundant_decls
1563 /* Don't warn about a function declaration followed by a
1565 && !(TREE_CODE (newdecl) == FUNCTION_DECL
1566 && DECL_INITIAL (newdecl) && !DECL_INITIAL (olddecl))
1567 /* Don't warn about redundant redeclarations of builtins. */
1568 && !(TREE_CODE (newdecl) == FUNCTION_DECL
1569 && !DECL_BUILT_IN (newdecl)
1570 && DECL_BUILT_IN (olddecl)
1571 && !C_DECL_DECLARED_BUILTIN (olddecl))
1572 /* Don't warn about an extern followed by a definition. */
1573 && !(DECL_EXTERNAL (olddecl) && !DECL_EXTERNAL (newdecl))
1574 /* Don't warn about forward parameter decls. */
1575 && !(TREE_CODE (newdecl) == PARM_DECL
1576 && TREE_ASM_WRITTEN (olddecl) && !TREE_ASM_WRITTEN (newdecl))
1577 /* Don't warn about a variable definition following a declaration. */
1578 && !(TREE_CODE (newdecl) == VAR_DECL
1579 && DECL_INITIAL (newdecl) && !DECL_INITIAL (olddecl)))
1581 warning (OPT_Wredundant_decls, "redundant redeclaration of %q+D",
1586 /* Report location of previous decl/defn in a consistent manner. */
1587 if (warned || pedwarned)
1588 locate_old_decl (olddecl, pedwarned ? pedwarn : warning0);
1590 #undef DECL_EXTERN_INLINE
1595 /* Subroutine of duplicate_decls. NEWDECL has been found to be
1596 consistent with OLDDECL, but carries new information. Merge the
1597 new information into OLDDECL. This function issues no
1601 merge_decls (tree newdecl, tree olddecl, tree newtype, tree oldtype)
1603 int new_is_definition = (TREE_CODE (newdecl) == FUNCTION_DECL
1604 && DECL_INITIAL (newdecl) != 0);
1605 int new_is_prototype = (TREE_CODE (newdecl) == FUNCTION_DECL
1606 && TYPE_ARG_TYPES (TREE_TYPE (newdecl)) != 0);
1607 int old_is_prototype = (TREE_CODE (olddecl) == FUNCTION_DECL
1608 && TYPE_ARG_TYPES (TREE_TYPE (olddecl)) != 0);
1610 /* For real parm decl following a forward decl, rechain the old decl
1611 in its new location and clear TREE_ASM_WRITTEN (it's not a
1612 forward decl anymore). */
1613 if (TREE_CODE (newdecl) == PARM_DECL
1614 && TREE_ASM_WRITTEN (olddecl) && !TREE_ASM_WRITTEN (newdecl))
1616 struct c_binding *b, **here;
1618 for (here = ¤t_scope->bindings; *here; here = &(*here)->prev)
1619 if ((*here)->decl == olddecl)
1626 b->prev = current_scope->bindings;
1627 current_scope->bindings = b;
1629 TREE_ASM_WRITTEN (olddecl) = 0;
1632 DECL_ATTRIBUTES (newdecl)
1633 = targetm.merge_decl_attributes (olddecl, newdecl);
1635 /* Merge the data types specified in the two decls. */
1637 = TREE_TYPE (olddecl)
1638 = composite_type (newtype, oldtype);
1640 /* Lay the type out, unless already done. */
1641 if (!comptypes (oldtype, TREE_TYPE (newdecl)))
1643 if (TREE_TYPE (newdecl) != error_mark_node)
1644 layout_type (TREE_TYPE (newdecl));
1645 if (TREE_CODE (newdecl) != FUNCTION_DECL
1646 && TREE_CODE (newdecl) != TYPE_DECL
1647 && TREE_CODE (newdecl) != CONST_DECL)
1648 layout_decl (newdecl, 0);
1652 /* Since the type is OLDDECL's, make OLDDECL's size go with. */
1653 DECL_SIZE (newdecl) = DECL_SIZE (olddecl);
1654 DECL_SIZE_UNIT (newdecl) = DECL_SIZE_UNIT (olddecl);
1655 DECL_MODE (newdecl) = DECL_MODE (olddecl);
1656 if (TREE_CODE (olddecl) != FUNCTION_DECL)
1657 if (DECL_ALIGN (olddecl) > DECL_ALIGN (newdecl))
1659 DECL_ALIGN (newdecl) = DECL_ALIGN (olddecl);
1660 DECL_USER_ALIGN (newdecl) |= DECL_ALIGN (olddecl);
1665 /* Merge the type qualifiers. */
1666 if (TREE_READONLY (newdecl))
1667 TREE_READONLY (olddecl) = 1;
1669 if (TREE_THIS_VOLATILE (newdecl))
1671 TREE_THIS_VOLATILE (olddecl) = 1;
1672 if (TREE_CODE (newdecl) == VAR_DECL)
1673 make_var_volatile (newdecl);
1676 /* Merge deprecatedness. */
1677 if (TREE_DEPRECATED (newdecl))
1678 TREE_DEPRECATED (olddecl) = 1;
1680 /* Keep source location of definition rather than declaration and of
1681 prototype rather than non-prototype unless that prototype is
1683 if ((DECL_INITIAL (newdecl) == 0 && DECL_INITIAL (olddecl) != 0)
1684 || (old_is_prototype && !new_is_prototype
1685 && !C_DECL_BUILTIN_PROTOTYPE (olddecl)))
1686 DECL_SOURCE_LOCATION (newdecl) = DECL_SOURCE_LOCATION (olddecl);
1688 /* Merge the initialization information. */
1689 if (DECL_INITIAL (newdecl) == 0)
1690 DECL_INITIAL (newdecl) = DECL_INITIAL (olddecl);
1692 /* Merge the threadprivate attribute. */
1693 if (TREE_CODE (olddecl) == VAR_DECL && C_DECL_THREADPRIVATE_P (olddecl))
1695 DECL_TLS_MODEL (newdecl) = DECL_TLS_MODEL (olddecl);
1696 C_DECL_THREADPRIVATE_P (newdecl) = 1;
1699 if (CODE_CONTAINS_STRUCT (TREE_CODE (olddecl), TS_DECL_WITH_VIS))
1701 /* Merge the unused-warning information. */
1702 if (DECL_IN_SYSTEM_HEADER (olddecl))
1703 DECL_IN_SYSTEM_HEADER (newdecl) = 1;
1704 else if (DECL_IN_SYSTEM_HEADER (newdecl))
1705 DECL_IN_SYSTEM_HEADER (olddecl) = 1;
1707 /* Merge the section attribute.
1708 We want to issue an error if the sections conflict but that
1709 must be done later in decl_attributes since we are called
1710 before attributes are assigned. */
1711 if (DECL_SECTION_NAME (newdecl) == NULL_TREE)
1712 DECL_SECTION_NAME (newdecl) = DECL_SECTION_NAME (olddecl);
1714 /* Copy the assembler name.
1715 Currently, it can only be defined in the prototype. */
1716 COPY_DECL_ASSEMBLER_NAME (olddecl, newdecl);
1718 /* Use visibility of whichever declaration had it specified */
1719 if (DECL_VISIBILITY_SPECIFIED (olddecl))
1721 DECL_VISIBILITY (newdecl) = DECL_VISIBILITY (olddecl);
1722 DECL_VISIBILITY_SPECIFIED (newdecl) = 1;
1725 if (TREE_CODE (newdecl) == FUNCTION_DECL)
1727 DECL_STATIC_CONSTRUCTOR(newdecl) |= DECL_STATIC_CONSTRUCTOR(olddecl);
1728 DECL_STATIC_DESTRUCTOR (newdecl) |= DECL_STATIC_DESTRUCTOR (olddecl);
1729 DECL_NO_LIMIT_STACK (newdecl) |= DECL_NO_LIMIT_STACK (olddecl);
1730 DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (newdecl)
1731 |= DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (olddecl);
1732 TREE_THIS_VOLATILE (newdecl) |= TREE_THIS_VOLATILE (olddecl);
1733 TREE_READONLY (newdecl) |= TREE_READONLY (olddecl);
1734 DECL_IS_MALLOC (newdecl) |= DECL_IS_MALLOC (olddecl);
1735 DECL_IS_PURE (newdecl) |= DECL_IS_PURE (olddecl);
1736 DECL_IS_NOVOPS (newdecl) |= DECL_IS_NOVOPS (olddecl);
1739 /* Merge the storage class information. */
1740 merge_weak (newdecl, olddecl);
1742 /* For functions, static overrides non-static. */
1743 if (TREE_CODE (newdecl) == FUNCTION_DECL)
1745 TREE_PUBLIC (newdecl) &= TREE_PUBLIC (olddecl);
1746 /* This is since we don't automatically
1747 copy the attributes of NEWDECL into OLDDECL. */
1748 TREE_PUBLIC (olddecl) = TREE_PUBLIC (newdecl);
1749 /* If this clears `static', clear it in the identifier too. */
1750 if (!TREE_PUBLIC (olddecl))
1751 TREE_PUBLIC (DECL_NAME (olddecl)) = 0;
1755 if (DECL_EXTERNAL (newdecl))
1757 TREE_STATIC (newdecl) = TREE_STATIC (olddecl);
1758 DECL_EXTERNAL (newdecl) = DECL_EXTERNAL (olddecl);
1760 /* An extern decl does not override previous storage class. */
1761 TREE_PUBLIC (newdecl) = TREE_PUBLIC (olddecl);
1762 if (!DECL_EXTERNAL (newdecl))
1764 DECL_CONTEXT (newdecl) = DECL_CONTEXT (olddecl);
1765 DECL_COMMON (newdecl) = DECL_COMMON (olddecl);
1770 TREE_STATIC (olddecl) = TREE_STATIC (newdecl);
1771 TREE_PUBLIC (olddecl) = TREE_PUBLIC (newdecl);
1774 if (TREE_CODE (newdecl) == FUNCTION_DECL)
1776 /* If we're redefining a function previously defined as extern
1777 inline, make sure we emit debug info for the inline before we
1778 throw it away, in case it was inlined into a function that
1779 hasn't been written out yet. */
1780 if (new_is_definition && DECL_INITIAL (olddecl))
1782 if (TREE_USED (olddecl)
1783 /* In unit-at-a-time mode we never inline re-defined extern
1784 inline functions. */
1785 && !flag_unit_at_a_time
1786 && cgraph_function_possibly_inlined_p (olddecl))
1787 (*debug_hooks->outlining_inline_function) (olddecl);
1789 /* The new defn must not be inline. */
1790 DECL_INLINE (newdecl) = 0;
1791 DECL_UNINLINABLE (newdecl) = 1;
1795 /* If either decl says `inline', this fn is inline, unless
1796 its definition was passed already. */
1797 if (DECL_DECLARED_INLINE_P (newdecl)
1798 || DECL_DECLARED_INLINE_P (olddecl))
1799 DECL_DECLARED_INLINE_P (newdecl) = 1;
1801 DECL_UNINLINABLE (newdecl) = DECL_UNINLINABLE (olddecl)
1802 = (DECL_UNINLINABLE (newdecl) || DECL_UNINLINABLE (olddecl));
1805 if (DECL_BUILT_IN (olddecl))
1807 /* If redeclaring a builtin function, it stays built in.
1808 But it gets tagged as having been declared. */
1809 DECL_BUILT_IN_CLASS (newdecl) = DECL_BUILT_IN_CLASS (olddecl);
1810 DECL_FUNCTION_CODE (newdecl) = DECL_FUNCTION_CODE (olddecl);
1811 C_DECL_DECLARED_BUILTIN (newdecl) = 1;
1812 if (new_is_prototype)
1813 C_DECL_BUILTIN_PROTOTYPE (newdecl) = 0;
1815 C_DECL_BUILTIN_PROTOTYPE (newdecl)
1816 = C_DECL_BUILTIN_PROTOTYPE (olddecl);
1819 /* Also preserve various other info from the definition. */
1820 if (!new_is_definition)
1822 DECL_RESULT (newdecl) = DECL_RESULT (olddecl);
1823 DECL_INITIAL (newdecl) = DECL_INITIAL (olddecl);
1824 DECL_STRUCT_FUNCTION (newdecl) = DECL_STRUCT_FUNCTION (olddecl);
1825 DECL_SAVED_TREE (newdecl) = DECL_SAVED_TREE (olddecl);
1826 DECL_ARGUMENTS (newdecl) = DECL_ARGUMENTS (olddecl);
1828 /* Set DECL_INLINE on the declaration if we've got a body
1829 from which to instantiate. */
1830 if (DECL_INLINE (olddecl) && !DECL_UNINLINABLE (newdecl))
1832 DECL_INLINE (newdecl) = 1;
1833 DECL_ABSTRACT_ORIGIN (newdecl)
1834 = DECL_ABSTRACT_ORIGIN (olddecl);
1839 /* If a previous declaration said inline, mark the
1840 definition as inlinable. */
1841 if (DECL_DECLARED_INLINE_P (newdecl)
1842 && !DECL_UNINLINABLE (newdecl))
1843 DECL_INLINE (newdecl) = 1;
1847 /* Copy most of the decl-specific fields of NEWDECL into OLDDECL.
1848 But preserve OLDDECL's DECL_UID and DECL_CONTEXT. */
1850 unsigned olddecl_uid = DECL_UID (olddecl);
1851 tree olddecl_context = DECL_CONTEXT (olddecl);
1853 memcpy ((char *) olddecl + sizeof (struct tree_common),
1854 (char *) newdecl + sizeof (struct tree_common),
1855 sizeof (struct tree_decl_common) - sizeof (struct tree_common));
1856 switch (TREE_CODE (olddecl))
1866 memcpy ((char *) olddecl + sizeof (struct tree_decl_common),
1867 (char *) newdecl + sizeof (struct tree_decl_common),
1868 tree_code_size (TREE_CODE (olddecl)) - sizeof (struct tree_decl_common));
1873 memcpy ((char *) olddecl + sizeof (struct tree_decl_common),
1874 (char *) newdecl + sizeof (struct tree_decl_common),
1875 sizeof (struct tree_decl_non_common) - sizeof (struct tree_decl_common));
1877 DECL_UID (olddecl) = olddecl_uid;
1878 DECL_CONTEXT (olddecl) = olddecl_context;
1881 /* If OLDDECL had its DECL_RTL instantiated, re-invoke make_decl_rtl
1882 so that encode_section_info has a chance to look at the new decl
1883 flags and attributes. */
1884 if (DECL_RTL_SET_P (olddecl)
1885 && (TREE_CODE (olddecl) == FUNCTION_DECL
1886 || (TREE_CODE (olddecl) == VAR_DECL
1887 && TREE_STATIC (olddecl))))
1888 make_decl_rtl (olddecl);
1891 /* Handle when a new declaration NEWDECL has the same name as an old
1892 one OLDDECL in the same binding contour. Prints an error message
1895 If safely possible, alter OLDDECL to look like NEWDECL, and return
1896 true. Otherwise, return false. */
1899 duplicate_decls (tree newdecl, tree olddecl)
1901 tree newtype = NULL, oldtype = NULL;
1903 if (!diagnose_mismatched_decls (newdecl, olddecl, &newtype, &oldtype))
1905 /* Avoid `unused variable' and other warnings warnings for OLDDECL. */
1906 TREE_NO_WARNING (olddecl) = 1;
1910 merge_decls (newdecl, olddecl, newtype, oldtype);
1915 /* Check whether decl-node NEW_DECL shadows an existing declaration. */
1917 warn_if_shadowing (tree new_decl)
1919 struct c_binding *b;
1921 /* Shadow warnings wanted? */
1923 /* No shadow warnings for internally generated vars. */
1924 || DECL_IS_BUILTIN (new_decl)
1925 /* No shadow warnings for vars made for inlining. */
1926 || DECL_FROM_INLINE (new_decl))
1929 /* Is anything being shadowed? Invisible decls do not count. */
1930 for (b = I_SYMBOL_BINDING (DECL_NAME (new_decl)); b; b = b->shadowed)
1931 if (b->decl && b->decl != new_decl && !b->invisible)
1933 tree old_decl = b->decl;
1935 if (old_decl == error_mark_node)
1937 warning (OPT_Wshadow, "declaration of %q+D shadows previous "
1938 "non-variable", new_decl);
1941 else if (TREE_CODE (old_decl) == PARM_DECL)
1942 warning (OPT_Wshadow, "declaration of %q+D shadows a parameter",
1944 else if (DECL_FILE_SCOPE_P (old_decl))
1945 warning (OPT_Wshadow, "declaration of %q+D shadows a global "
1946 "declaration", new_decl);
1947 else if (TREE_CODE (old_decl) == FUNCTION_DECL
1948 && DECL_BUILT_IN (old_decl))
1950 warning (OPT_Wshadow, "declaration of %q+D shadows "
1951 "a built-in function", new_decl);
1955 warning (OPT_Wshadow, "declaration of %q+D shadows a previous local",
1958 warning (OPT_Wshadow, "%Jshadowed declaration is here", old_decl);
1965 /* Subroutine of pushdecl.
1967 X is a TYPE_DECL for a typedef statement. Create a brand new
1968 ..._TYPE node (which will be just a variant of the existing
1969 ..._TYPE node with identical properties) and then install X
1970 as the TYPE_NAME of this brand new (duplicate) ..._TYPE node.
1972 The whole point here is to end up with a situation where each
1973 and every ..._TYPE node the compiler creates will be uniquely
1974 associated with AT MOST one node representing a typedef name.
1975 This way, even though the compiler substitutes corresponding
1976 ..._TYPE nodes for TYPE_DECL (i.e. "typedef name") nodes very
1977 early on, later parts of the compiler can always do the reverse
1978 translation and get back the corresponding typedef name. For
1981 typedef struct S MY_TYPE;
1984 Later parts of the compiler might only know that `object' was of
1985 type `struct S' if it were not for code just below. With this
1986 code however, later parts of the compiler see something like:
1988 struct S' == struct S
1989 typedef struct S' MY_TYPE;
1992 And they can then deduce (from the node for type struct S') that
1993 the original object declaration was:
1997 Being able to do this is important for proper support of protoize,
1998 and also for generating precise symbolic debugging information
1999 which takes full account of the programmer's (typedef) vocabulary.
2001 Obviously, we don't want to generate a duplicate ..._TYPE node if
2002 the TYPE_DECL node that we are now processing really represents a
2003 standard built-in type.
2005 Since all standard types are effectively declared at line zero
2006 in the source file, we can easily check to see if we are working
2007 on a standard type by checking the current value of lineno. */
2010 clone_underlying_type (tree x)
2012 if (DECL_IS_BUILTIN (x))
2014 if (TYPE_NAME (TREE_TYPE (x)) == 0)
2015 TYPE_NAME (TREE_TYPE (x)) = x;
2017 else if (TREE_TYPE (x) != error_mark_node
2018 && DECL_ORIGINAL_TYPE (x) == NULL_TREE)
2020 tree tt = TREE_TYPE (x);
2021 DECL_ORIGINAL_TYPE (x) = tt;
2022 tt = build_variant_type_copy (tt);
2024 TREE_USED (tt) = TREE_USED (x);
2029 /* Record a decl-node X as belonging to the current lexical scope.
2030 Check for errors (such as an incompatible declaration for the same
2031 name already seen in the same scope).
2033 Returns either X or an old decl for the same name.
2034 If an old decl is returned, it may have been smashed
2035 to agree with what X says. */
2040 tree name = DECL_NAME (x);
2041 struct c_scope *scope = current_scope;
2042 struct c_binding *b;
2043 bool nested = false;
2045 /* Functions need the lang_decl data. */
2046 if (TREE_CODE (x) == FUNCTION_DECL && !DECL_LANG_SPECIFIC (x))
2047 DECL_LANG_SPECIFIC (x) = GGC_CNEW (struct lang_decl);
2049 /* Must set DECL_CONTEXT for everything not at file scope or
2050 DECL_FILE_SCOPE_P won't work. Local externs don't count
2051 unless they have initializers (which generate code). */
2052 if (current_function_decl
2053 && ((TREE_CODE (x) != FUNCTION_DECL && TREE_CODE (x) != VAR_DECL)
2054 || DECL_INITIAL (x) || !DECL_EXTERNAL (x)))
2055 DECL_CONTEXT (x) = current_function_decl;
2057 /* If this is of variably modified type, prevent jumping into its
2059 if ((TREE_CODE (x) == VAR_DECL || TREE_CODE (x) == TYPE_DECL)
2060 && variably_modified_type_p (TREE_TYPE (x), NULL_TREE))
2061 c_begin_vm_scope (scope->depth);
2063 /* Anonymous decls are just inserted in the scope. */
2066 bind (name, x, scope, /*invisible=*/false, /*nested=*/false);
2070 /* First, see if there is another declaration with the same name in
2071 the current scope. If there is, duplicate_decls may do all the
2072 work for us. If duplicate_decls returns false, that indicates
2073 two incompatible decls in the same scope; we are to silently
2074 replace the old one (duplicate_decls has issued all appropriate
2075 diagnostics). In particular, we should not consider possible
2076 duplicates in the external scope, or shadowing. */
2077 b = I_SYMBOL_BINDING (name);
2078 if (b && B_IN_SCOPE (b, scope))
2080 struct c_binding *b_ext, *b_use;
2081 tree type = TREE_TYPE (x);
2082 tree visdecl = b->decl;
2083 tree vistype = TREE_TYPE (visdecl);
2084 if (TREE_CODE (TREE_TYPE (x)) == ARRAY_TYPE
2085 && COMPLETE_TYPE_P (TREE_TYPE (x)))
2086 b->inner_comp = false;
2089 /* If this is an external linkage declaration, we should check
2090 for compatibility with the type in the external scope before
2091 setting the type at this scope based on the visible
2092 information only. */
2093 if (TREE_PUBLIC (x) && TREE_PUBLIC (visdecl))
2095 while (b_ext && !B_IN_EXTERNAL_SCOPE (b_ext))
2096 b_ext = b_ext->shadowed;
2101 TREE_TYPE (b_use->decl) = b_use->type;
2104 if (duplicate_decls (x, b_use->decl))
2108 /* Save the updated type in the external scope and
2109 restore the proper type for this scope. */
2111 if (comptypes (vistype, type))
2112 thistype = composite_type (vistype, type);
2114 thistype = TREE_TYPE (b_use->decl);
2115 b_use->type = TREE_TYPE (b_use->decl);
2116 if (TREE_CODE (b_use->decl) == FUNCTION_DECL
2117 && DECL_BUILT_IN (b_use->decl))
2119 = build_type_attribute_variant (thistype,
2122 TREE_TYPE (b_use->decl) = thistype;
2127 goto skip_external_and_shadow_checks;
2130 /* All declarations with external linkage, and all external
2131 references, go in the external scope, no matter what scope is
2132 current. However, the binding in that scope is ignored for
2133 purposes of normal name lookup. A separate binding structure is
2134 created in the requested scope; this governs the normal
2135 visibility of the symbol.
2137 The binding in the externals scope is used exclusively for
2138 detecting duplicate declarations of the same object, no matter
2139 what scope they are in; this is what we do here. (C99 6.2.7p2:
2140 All declarations that refer to the same object or function shall
2141 have compatible type; otherwise, the behavior is undefined.) */
2142 if (DECL_EXTERNAL (x) || scope == file_scope)
2144 tree type = TREE_TYPE (x);
2147 bool type_saved = false;
2148 if (b && !B_IN_EXTERNAL_SCOPE (b)
2149 && (TREE_CODE (b->decl) == FUNCTION_DECL
2150 || TREE_CODE (b->decl) == VAR_DECL)
2151 && DECL_FILE_SCOPE_P (b->decl))
2154 vistype = TREE_TYPE (visdecl);
2156 if (scope != file_scope
2157 && !DECL_IN_SYSTEM_HEADER (x))
2158 warning (OPT_Wnested_externs, "nested extern declaration of %qD", x);
2160 while (b && !B_IN_EXTERNAL_SCOPE (b))
2162 /* If this decl might be modified, save its type. This is
2163 done here rather than when the decl is first bound
2164 because the type may change after first binding, through
2165 being completed or through attributes being added. If we
2166 encounter multiple such decls, only the first should have
2167 its type saved; the others will already have had their
2168 proper types saved and the types will not have changed as
2169 their scopes will not have been re-entered. */
2170 if (DECL_P (b->decl) && DECL_FILE_SCOPE_P (b->decl) && !type_saved)
2172 b->type = TREE_TYPE (b->decl);
2175 if (B_IN_FILE_SCOPE (b)
2176 && TREE_CODE (b->decl) == VAR_DECL
2177 && TREE_STATIC (b->decl)
2178 && TREE_CODE (TREE_TYPE (b->decl)) == ARRAY_TYPE
2179 && !TYPE_DOMAIN (TREE_TYPE (b->decl))
2180 && TREE_CODE (type) == ARRAY_TYPE
2181 && TYPE_DOMAIN (type)
2182 && TYPE_MAX_VALUE (TYPE_DOMAIN (type))
2183 && !integer_zerop (TYPE_MAX_VALUE (TYPE_DOMAIN (type))))
2185 /* Array type completed in inner scope, which should be
2186 diagnosed if the completion does not have size 1 and
2187 it does not get completed in the file scope. */
2188 b->inner_comp = true;
2193 /* If a matching external declaration has been found, set its
2194 type to the composite of all the types of that declaration.
2195 After the consistency checks, it will be reset to the
2196 composite of the visible types only. */
2197 if (b && (TREE_PUBLIC (x) || same_translation_unit_p (x, b->decl))
2199 TREE_TYPE (b->decl) = b->type;
2201 /* The point of the same_translation_unit_p check here is,
2202 we want to detect a duplicate decl for a construct like
2203 foo() { extern bar(); } ... static bar(); but not if
2204 they are in different translation units. In any case,
2205 the static does not go in the externals scope. */
2207 && (TREE_PUBLIC (x) || same_translation_unit_p (x, b->decl))
2208 && duplicate_decls (x, b->decl))
2213 if (comptypes (vistype, type))
2214 thistype = composite_type (vistype, type);
2216 thistype = TREE_TYPE (b->decl);
2220 b->type = TREE_TYPE (b->decl);
2221 if (TREE_CODE (b->decl) == FUNCTION_DECL && DECL_BUILT_IN (b->decl))
2223 = build_type_attribute_variant (thistype,
2224 TYPE_ATTRIBUTES (b->type));
2225 TREE_TYPE (b->decl) = thistype;
2226 bind (name, b->decl, scope, /*invisible=*/false, /*nested=*/true);
2229 else if (TREE_PUBLIC (x))
2231 if (visdecl && !b && duplicate_decls (x, visdecl))
2233 /* An external declaration at block scope referring to a
2234 visible entity with internal linkage. The composite
2235 type will already be correct for this scope, so we
2236 just need to fall through to make the declaration in
2243 bind (name, x, external_scope, /*invisible=*/true,
2250 if (TREE_CODE (x) != PARM_DECL)
2251 warn_if_shadowing (x);
2253 skip_external_and_shadow_checks:
2254 if (TREE_CODE (x) == TYPE_DECL)
2255 clone_underlying_type (x);
2257 bind (name, x, scope, /*invisible=*/false, nested);
2259 /* If x's type is incomplete because it's based on a
2260 structure or union which has not yet been fully declared,
2261 attach it to that structure or union type, so we can go
2262 back and complete the variable declaration later, if the
2263 structure or union gets fully declared.
2265 If the input is erroneous, we can have error_mark in the type
2266 slot (e.g. "f(void a, ...)") - that doesn't count as an
2268 if (TREE_TYPE (x) != error_mark_node
2269 && !COMPLETE_TYPE_P (TREE_TYPE (x)))
2271 tree element = TREE_TYPE (x);
2273 while (TREE_CODE (element) == ARRAY_TYPE)
2274 element = TREE_TYPE (element);
2275 element = TYPE_MAIN_VARIANT (element);
2277 if ((TREE_CODE (element) == RECORD_TYPE
2278 || TREE_CODE (element) == UNION_TYPE)
2279 && (TREE_CODE (x) != TYPE_DECL
2280 || TREE_CODE (TREE_TYPE (x)) == ARRAY_TYPE)
2281 && !COMPLETE_TYPE_P (element))
2282 C_TYPE_INCOMPLETE_VARS (element)
2283 = tree_cons (NULL_TREE, x, C_TYPE_INCOMPLETE_VARS (element));
2288 /* Record X as belonging to file scope.
2289 This is used only internally by the Objective-C front end,
2290 and is limited to its needs. duplicate_decls is not called;
2291 if there is any preexisting decl for this identifier, it is an ICE. */
2294 pushdecl_top_level (tree x)
2297 bool nested = false;
2298 gcc_assert (TREE_CODE (x) == VAR_DECL || TREE_CODE (x) == CONST_DECL);
2300 name = DECL_NAME (x);
2302 gcc_assert (TREE_CODE (x) == CONST_DECL || !I_SYMBOL_BINDING (name));
2304 if (TREE_PUBLIC (x))
2306 bind (name, x, external_scope, /*invisible=*/true, /*nested=*/false);
2310 bind (name, x, file_scope, /*invisible=*/false, nested);
2316 implicit_decl_warning (tree id, tree olddecl)
2318 void (*diag) (const char *, ...) ATTRIBUTE_GCC_CDIAG(1,2);
2319 switch (mesg_implicit_function_declaration)
2322 case 1: diag = warning0; break;
2323 case 2: diag = error; break;
2324 default: gcc_unreachable ();
2327 diag (G_("implicit declaration of function %qE"), id);
2329 locate_old_decl (olddecl, diag);
2332 /* Generate an implicit declaration for identifier FUNCTIONID as a
2333 function of type int (). */
2336 implicitly_declare (tree functionid)
2338 struct c_binding *b;
2342 for (b = I_SYMBOL_BINDING (functionid); b; b = b->shadowed)
2344 if (B_IN_SCOPE (b, external_scope))
2353 if (decl == error_mark_node)
2356 /* FIXME: Objective-C has weird not-really-builtin functions
2357 which are supposed to be visible automatically. They wind up
2358 in the external scope because they're pushed before the file
2359 scope gets created. Catch this here and rebind them into the
2361 if (!DECL_BUILT_IN (decl) && DECL_IS_BUILTIN (decl))
2363 bind (functionid, decl, file_scope,
2364 /*invisible=*/false, /*nested=*/true);
2369 tree newtype = default_function_type;
2371 TREE_TYPE (decl) = b->type;
2372 /* Implicit declaration of a function already declared
2373 (somehow) in a different scope, or as a built-in.
2374 If this is the first time this has happened, warn;
2375 then recycle the old declaration but with the new type. */
2376 if (!C_DECL_IMPLICIT (decl))
2378 implicit_decl_warning (functionid, decl);
2379 C_DECL_IMPLICIT (decl) = 1;
2381 if (DECL_BUILT_IN (decl))
2383 newtype = build_type_attribute_variant (newtype,
2385 (TREE_TYPE (decl)));
2386 if (!comptypes (newtype, TREE_TYPE (decl)))
2388 warning (0, "incompatible implicit declaration of built-in"
2389 " function %qD", decl);
2390 newtype = TREE_TYPE (decl);
2395 if (!comptypes (newtype, TREE_TYPE (decl)))
2397 error ("incompatible implicit declaration of function %qD",
2399 locate_old_decl (decl, error);
2402 b->type = TREE_TYPE (decl);
2403 TREE_TYPE (decl) = newtype;
2404 bind (functionid, decl, current_scope,
2405 /*invisible=*/false, /*nested=*/true);
2410 /* Not seen before. */
2411 decl = build_decl (FUNCTION_DECL, functionid, default_function_type);
2412 DECL_EXTERNAL (decl) = 1;
2413 TREE_PUBLIC (decl) = 1;
2414 C_DECL_IMPLICIT (decl) = 1;
2415 implicit_decl_warning (functionid, 0);
2416 asmspec_tree = maybe_apply_renaming_pragma (decl, /*asmname=*/NULL);
2418 set_user_assembler_name (decl, TREE_STRING_POINTER (asmspec_tree));
2420 /* C89 says implicit declarations are in the innermost block.
2421 So we record the decl in the standard fashion. */
2422 decl = pushdecl (decl);
2424 /* No need to call objc_check_decl here - it's a function type. */
2425 rest_of_decl_compilation (decl, 0, 0);
2427 /* Write a record describing this implicit function declaration
2428 to the prototypes file (if requested). */
2429 gen_aux_info_record (decl, 0, 1, 0);
2431 /* Possibly apply some default attributes to this implicit declaration. */
2432 decl_attributes (&decl, NULL_TREE, 0);
2437 /* Issue an error message for a reference to an undeclared variable
2438 ID, including a reference to a builtin outside of function-call
2439 context. Establish a binding of the identifier to error_mark_node
2440 in an appropriate scope, which will suppress further errors for the
2441 same identifier. The error message should be given location LOC. */
2443 undeclared_variable (tree id, location_t loc)
2445 static bool already = false;
2446 struct c_scope *scope;
2448 if (current_function_decl == 0)
2450 error ("%H%qE undeclared here (not in a function)", &loc, id);
2451 scope = current_scope;
2455 error ("%H%qE undeclared (first use in this function)", &loc, id);
2459 error ("%H(Each undeclared identifier is reported only once", &loc);
2460 error ("%Hfor each function it appears in.)", &loc);
2464 /* If we are parsing old-style parameter decls, current_function_decl
2465 will be nonnull but current_function_scope will be null. */
2466 scope = current_function_scope ? current_function_scope : current_scope;
2468 bind (id, error_mark_node, scope, /*invisible=*/false, /*nested=*/false);
2471 /* Subroutine of lookup_label, declare_label, define_label: construct a
2472 LABEL_DECL with all the proper frills. */
2475 make_label (tree name, location_t location)
2477 tree label = build_decl (LABEL_DECL, name, void_type_node);
2479 DECL_CONTEXT (label) = current_function_decl;
2480 DECL_MODE (label) = VOIDmode;
2481 DECL_SOURCE_LOCATION (label) = location;
2486 /* Get the LABEL_DECL corresponding to identifier NAME as a label.
2487 Create one if none exists so far for the current function.
2488 This is called when a label is used in a goto expression or
2489 has its address taken. */
2492 lookup_label (tree name)
2496 if (current_function_decl == 0)
2498 error ("label %qE referenced outside of any function", name);
2502 /* Use a label already defined or ref'd with this name, but not if
2503 it is inherited from a containing function and wasn't declared
2505 label = I_LABEL_DECL (name);
2506 if (label && (DECL_CONTEXT (label) == current_function_decl
2507 || C_DECLARED_LABEL_FLAG (label)))
2509 /* If the label has only been declared, update its apparent
2510 location to point here, for better diagnostics if it
2511 turns out not to have been defined. */
2512 if (!TREE_USED (label))
2513 DECL_SOURCE_LOCATION (label) = input_location;
2517 /* No label binding for that identifier; make one. */
2518 label = make_label (name, input_location);
2520 /* Ordinary labels go in the current function scope. */
2521 bind (name, label, current_function_scope,
2522 /*invisible=*/false, /*nested=*/false);
2526 /* Make a label named NAME in the current function, shadowing silently
2527 any that may be inherited from containing functions or containing
2528 scopes. This is called for __label__ declarations. */
2531 declare_label (tree name)
2533 struct c_binding *b = I_LABEL_BINDING (name);
2536 /* Check to make sure that the label hasn't already been declared
2538 if (b && B_IN_CURRENT_SCOPE (b))
2540 error ("duplicate label declaration %qE", name);
2541 locate_old_decl (b->decl, error);
2543 /* Just use the previous declaration. */
2547 label = make_label (name, input_location);
2548 C_DECLARED_LABEL_FLAG (label) = 1;
2550 /* Declared labels go in the current scope. */
2551 bind (name, label, current_scope,
2552 /*invisible=*/false, /*nested=*/false);
2556 /* Define a label, specifying the location in the source file.
2557 Return the LABEL_DECL node for the label, if the definition is valid.
2558 Otherwise return 0. */
2561 define_label (location_t location, tree name)
2563 /* Find any preexisting label with this name. It is an error
2564 if that label has already been defined in this function, or
2565 if there is a containing function with a declared label with
2567 tree label = I_LABEL_DECL (name);
2568 struct c_label_list *nlist_se, *nlist_vm;
2571 && ((DECL_CONTEXT (label) == current_function_decl
2572 && DECL_INITIAL (label) != 0)
2573 || (DECL_CONTEXT (label) != current_function_decl
2574 && C_DECLARED_LABEL_FLAG (label))))
2576 error ("%Hduplicate label %qD", &location, label);
2577 locate_old_decl (label, error);
2580 else if (label && DECL_CONTEXT (label) == current_function_decl)
2582 /* The label has been used or declared already in this function,
2583 but not defined. Update its location to point to this
2585 if (C_DECL_UNDEFINABLE_STMT_EXPR (label))
2586 error ("%Jjump into statement expression", label);
2587 if (C_DECL_UNDEFINABLE_VM (label))
2588 error ("%Jjump into scope of identifier with variably modified type",
2590 DECL_SOURCE_LOCATION (label) = location;
2594 /* No label binding for that identifier; make one. */
2595 label = make_label (name, location);
2597 /* Ordinary labels go in the current function scope. */
2598 bind (name, label, current_function_scope,
2599 /*invisible=*/false, /*nested=*/false);
2602 if (!in_system_header && lookup_name (name))
2603 warning (OPT_Wtraditional, "%Htraditional C lacks a separate namespace "
2604 "for labels, identifier %qE conflicts", &location, name);
2606 nlist_se = XOBNEW (&parser_obstack, struct c_label_list);
2607 nlist_se->next = label_context_stack_se->labels_def;
2608 nlist_se->label = label;
2609 label_context_stack_se->labels_def = nlist_se;
2611 nlist_vm = XOBNEW (&parser_obstack, struct c_label_list);
2612 nlist_vm->next = label_context_stack_vm->labels_def;
2613 nlist_vm->label = label;
2614 label_context_stack_vm->labels_def = nlist_vm;
2616 /* Mark label as having been defined. */
2617 DECL_INITIAL (label) = error_mark_node;
2621 /* Given NAME, an IDENTIFIER_NODE,
2622 return the structure (or union or enum) definition for that name.
2623 If THISLEVEL_ONLY is nonzero, searches only the current_scope.
2624 CODE says which kind of type the caller wants;
2625 it is RECORD_TYPE or UNION_TYPE or ENUMERAL_TYPE.
2626 If the wrong kind of type is found, an error is reported. */
2629 lookup_tag (enum tree_code code, tree name, int thislevel_only)
2631 struct c_binding *b = I_TAG_BINDING (name);
2637 /* We only care about whether it's in this level if
2638 thislevel_only was set or it might be a type clash. */
2639 if (thislevel_only || TREE_CODE (b->decl) != code)
2641 /* For our purposes, a tag in the external scope is the same as
2642 a tag in the file scope. (Primarily relevant to Objective-C
2643 and its builtin structure tags, which get pushed before the
2644 file scope is created.) */
2645 if (B_IN_CURRENT_SCOPE (b)
2646 || (current_scope == file_scope && B_IN_EXTERNAL_SCOPE (b)))
2650 if (thislevel_only && !thislevel)
2653 if (TREE_CODE (b->decl) != code)
2655 /* Definition isn't the kind we were looking for. */
2656 pending_invalid_xref = name;
2657 pending_invalid_xref_location = input_location;
2659 /* If in the same binding level as a declaration as a tag
2660 of a different type, this must not be allowed to
2661 shadow that tag, so give the error immediately.
2662 (For example, "struct foo; union foo;" is invalid.) */
2664 pending_xref_error ();
2669 /* Print an error message now
2670 for a recent invalid struct, union or enum cross reference.
2671 We don't print them immediately because they are not invalid
2672 when used in the `struct foo;' construct for shadowing. */
2675 pending_xref_error (void)
2677 if (pending_invalid_xref != 0)
2678 error ("%H%qE defined as wrong kind of tag",
2679 &pending_invalid_xref_location, pending_invalid_xref);
2680 pending_invalid_xref = 0;
2684 /* Look up NAME in the current scope and its superiors
2685 in the namespace of variables, functions and typedefs.
2686 Return a ..._DECL node of some kind representing its definition,
2687 or return 0 if it is undefined. */
2690 lookup_name (tree name)
2692 struct c_binding *b = I_SYMBOL_BINDING (name);
2693 if (b && !b->invisible)
2698 /* Similar to `lookup_name' but look only at the indicated scope. */
2701 lookup_name_in_scope (tree name, struct c_scope *scope)
2703 struct c_binding *b;
2705 for (b = I_SYMBOL_BINDING (name); b; b = b->shadowed)
2706 if (B_IN_SCOPE (b, scope))
2711 /* Create the predefined scalar types of C,
2712 and some nodes representing standard constants (0, 1, (void *) 0).
2713 Initialize the global scope.
2714 Make definitions for built-in primitive functions. */
2717 c_init_decl_processing (void)
2719 location_t save_loc = input_location;
2721 /* Initialize reserved words for parser. */
2724 current_function_decl = 0;
2726 gcc_obstack_init (&parser_obstack);
2728 /* Make the externals scope. */
2730 external_scope = current_scope;
2732 /* Declarations from c_common_nodes_and_builtins must not be associated
2733 with this input file, lest we get differences between using and not
2734 using preprocessed headers. */
2735 #ifdef USE_MAPPED_LOCATION
2736 input_location = BUILTINS_LOCATION;
2738 input_location.file = "<built-in>";
2739 input_location.line = 0;
2742 build_common_tree_nodes (flag_signed_char, false);
2744 c_common_nodes_and_builtins ();
2746 /* In C, comparisons and TRUTH_* expressions have type int. */
2747 truthvalue_type_node = integer_type_node;
2748 truthvalue_true_node = integer_one_node;
2749 truthvalue_false_node = integer_zero_node;
2751 /* Even in C99, which has a real boolean type. */
2752 pushdecl (build_decl (TYPE_DECL, get_identifier ("_Bool"),
2753 boolean_type_node));
2755 input_location = save_loc;
2757 pedantic_lvalues = true;
2759 make_fname_decl = c_make_fname_decl;
2760 start_fname_decls ();
2763 /* Create the VAR_DECL for __FUNCTION__ etc. ID is the name to give the
2764 decl, NAME is the initialization string and TYPE_DEP indicates whether
2765 NAME depended on the type of the function. As we don't yet implement
2766 delayed emission of static data, we mark the decl as emitted
2767 so it is not placed in the output. Anything using it must therefore pull
2768 out the STRING_CST initializer directly. FIXME. */
2771 c_make_fname_decl (tree id, int type_dep)
2773 const char *name = fname_as_string (type_dep);
2774 tree decl, type, init;
2775 size_t length = strlen (name);
2777 type = build_array_type (char_type_node,
2778 build_index_type (size_int (length)));
2779 type = c_build_qualified_type (type, TYPE_QUAL_CONST);
2781 decl = build_decl (VAR_DECL, id, type);
2783 TREE_STATIC (decl) = 1;
2784 TREE_READONLY (decl) = 1;
2785 DECL_ARTIFICIAL (decl) = 1;
2787 init = build_string (length + 1, name);
2788 free ((char *) name);
2789 TREE_TYPE (init) = type;
2790 DECL_INITIAL (decl) = init;
2792 TREE_USED (decl) = 1;
2794 if (current_function_decl)
2796 DECL_CONTEXT (decl) = current_function_decl;
2797 bind (id, decl, current_function_scope,
2798 /*invisible=*/false, /*nested=*/false);
2801 finish_decl (decl, init, NULL_TREE);
2806 /* Return a definition for a builtin function named NAME and whose data type
2807 is TYPE. TYPE should be a function type with argument types.
2808 FUNCTION_CODE tells later passes how to compile calls to this function.
2809 See tree.h for its possible values.
2811 If LIBRARY_NAME is nonzero, use that for DECL_ASSEMBLER_NAME,
2812 the name to be called if we can't opencode the function. If
2813 ATTRS is nonzero, use that for the function's attribute list. */
2816 builtin_function (const char *name, tree type, int function_code,
2817 enum built_in_class cl, const char *library_name,
2820 tree id = get_identifier (name);
2821 tree decl = build_decl (FUNCTION_DECL, id, type);
2822 TREE_PUBLIC (decl) = 1;
2823 DECL_EXTERNAL (decl) = 1;
2824 DECL_LANG_SPECIFIC (decl) = GGC_CNEW (struct lang_decl);
2825 DECL_BUILT_IN_CLASS (decl) = cl;
2826 DECL_FUNCTION_CODE (decl) = function_code;
2827 C_DECL_BUILTIN_PROTOTYPE (decl) = (TYPE_ARG_TYPES (type) != 0);
2829 SET_DECL_ASSEMBLER_NAME (decl, get_identifier (library_name));
2831 /* Should never be called on a symbol with a preexisting meaning. */
2832 gcc_assert (!I_SYMBOL_BINDING (id));
2834 bind (id, decl, external_scope, /*invisible=*/true, /*nested=*/false);
2836 /* Builtins in the implementation namespace are made visible without
2837 needing to be explicitly declared. See push_file_scope. */
2838 if (name[0] == '_' && (name[1] == '_' || ISUPPER (name[1])))
2840 TREE_CHAIN (decl) = visible_builtins;
2841 visible_builtins = decl;
2844 /* Possibly apply some default attributes to this built-in function. */
2846 decl_attributes (&decl, attrs, ATTR_FLAG_BUILT_IN);
2848 decl_attributes (&decl, NULL_TREE, 0);
2853 /* Called when a declaration is seen that contains no names to declare.
2854 If its type is a reference to a structure, union or enum inherited
2855 from a containing scope, shadow that tag name for the current scope
2856 with a forward reference.
2857 If its type defines a new named structure or union
2858 or defines an enum, it is valid but we need not do anything here.
2859 Otherwise, it is an error. */
2862 shadow_tag (const struct c_declspecs *declspecs)
2864 shadow_tag_warned (declspecs, 0);
2867 /* WARNED is 1 if we have done a pedwarn, 2 if we have done a warning,
2870 shadow_tag_warned (const struct c_declspecs *declspecs, int warned)
2872 bool found_tag = false;
2874 if (declspecs->type && !declspecs->default_int_p && !declspecs->typedef_p)
2876 tree value = declspecs->type;
2877 enum tree_code code = TREE_CODE (value);
2879 if (code == RECORD_TYPE || code == UNION_TYPE || code == ENUMERAL_TYPE)
2880 /* Used to test also that TYPE_SIZE (value) != 0.
2881 That caused warning for `struct foo;' at top level in the file. */
2883 tree name = TYPE_NAME (value);
2890 if (warned != 1 && code != ENUMERAL_TYPE)
2891 /* Empty unnamed enum OK */
2893 pedwarn ("unnamed struct/union that defines no instances");
2897 else if (!declspecs->tag_defined_p
2898 && declspecs->storage_class != csc_none)
2901 pedwarn ("empty declaration with storage class specifier "
2902 "does not redeclare tag");
2904 pending_xref_error ();
2906 else if (!declspecs->tag_defined_p
2907 && (declspecs->const_p
2908 || declspecs->volatile_p
2909 || declspecs->restrict_p))
2912 pedwarn ("empty declaration with type qualifier "
2913 "does not redeclare tag");
2915 pending_xref_error ();
2919 pending_invalid_xref = 0;
2920 t = lookup_tag (code, name, 1);
2924 t = make_node (code);
2931 if (warned != 1 && !in_system_header)
2933 pedwarn ("useless type name in empty declaration");
2938 else if (warned != 1 && !in_system_header && declspecs->typedef_p)
2940 pedwarn ("useless type name in empty declaration");
2944 pending_invalid_xref = 0;
2946 if (declspecs->inline_p)
2948 error ("%<inline%> in empty declaration");
2952 if (current_scope == file_scope && declspecs->storage_class == csc_auto)
2954 error ("%<auto%> in file-scope empty declaration");
2958 if (current_scope == file_scope && declspecs->storage_class == csc_register)
2960 error ("%<register%> in file-scope empty declaration");
2964 if (!warned && !in_system_header && declspecs->storage_class != csc_none)
2966 warning (0, "useless storage class specifier in empty declaration");
2970 if (!warned && !in_system_header && declspecs->thread_p)
2972 warning (0, "useless %<__thread%> in empty declaration");
2976 if (!warned && !in_system_header && (declspecs->const_p
2977 || declspecs->volatile_p
2978 || declspecs->restrict_p))
2980 warning (0, "useless type qualifier in empty declaration");
2987 pedwarn ("empty declaration");
2992 /* Return the qualifiers from SPECS as a bitwise OR of TYPE_QUAL_*
2993 bits. SPECS represents declaration specifiers that the grammar
2994 only permits to contain type qualifiers and attributes. */
2997 quals_from_declspecs (const struct c_declspecs *specs)
2999 int quals = ((specs->const_p ? TYPE_QUAL_CONST : 0)
3000 | (specs->volatile_p ? TYPE_QUAL_VOLATILE : 0)
3001 | (specs->restrict_p ? TYPE_QUAL_RESTRICT : 0));
3002 gcc_assert (!specs->type
3003 && !specs->decl_attr
3004 && specs->typespec_word == cts_none
3005 && specs->storage_class == csc_none
3006 && !specs->typedef_p
3007 && !specs->explicit_signed_p
3008 && !specs->deprecated_p
3010 && !specs->long_long_p
3013 && !specs->unsigned_p
3014 && !specs->complex_p
3016 && !specs->thread_p);
3020 /* Construct an array declarator. EXPR is the expression inside [],
3021 or NULL_TREE. QUALS are the type qualifiers inside the [] (to be
3022 applied to the pointer to which a parameter array is converted).
3023 STATIC_P is true if "static" is inside the [], false otherwise.
3024 VLA_UNSPEC_P is true if the array is [*], a VLA of unspecified
3025 length which is nevertheless a complete type, false otherwise. The
3026 field for the contained declarator is left to be filled in by
3027 set_array_declarator_inner. */
3029 struct c_declarator *
3030 build_array_declarator (tree expr, struct c_declspecs *quals, bool static_p,
3033 struct c_declarator *declarator = XOBNEW (&parser_obstack,
3034 struct c_declarator);
3035 declarator->kind = cdk_array;
3036 declarator->declarator = 0;
3037 declarator->u.array.dimen = expr;
3040 declarator->u.array.attrs = quals->attrs;
3041 declarator->u.array.quals = quals_from_declspecs (quals);
3045 declarator->u.array.attrs = NULL_TREE;
3046 declarator->u.array.quals = 0;
3048 declarator->u.array.static_p = static_p;
3049 declarator->u.array.vla_unspec_p = vla_unspec_p;
3050 if (pedantic && !flag_isoc99)
3052 if (static_p || quals != NULL)
3053 pedwarn ("ISO C90 does not support %<static%> or type "
3054 "qualifiers in parameter array declarators");
3056 pedwarn ("ISO C90 does not support %<[*]%> array declarators");
3060 if (!current_scope->parm_flag)
3063 error ("%<[*]%> not allowed in other than function prototype scope");
3064 declarator->u.array.vla_unspec_p = false;
3067 current_scope->had_vla_unspec = true;
3072 /* Set the contained declarator of an array declarator. DECL is the
3073 declarator, as constructed by build_array_declarator; INNER is what
3074 appears on the left of the []. ABSTRACT_P is true if it is an
3075 abstract declarator, false otherwise; this is used to reject static
3076 and type qualifiers in abstract declarators, where they are not in
3077 the C99 grammar (subject to possible change in DR#289). */
3079 struct c_declarator *
3080 set_array_declarator_inner (struct c_declarator *decl,
3081 struct c_declarator *inner, bool abstract_p)
3083 decl->declarator = inner;
3084 if (abstract_p && (decl->u.array.quals != TYPE_UNQUALIFIED
3085 || decl->u.array.attrs != NULL_TREE
3086 || decl->u.array.static_p))
3087 error ("static or type qualifiers in abstract declarator");
3091 /* INIT is a constructor that forms DECL's initializer. If the final
3092 element initializes a flexible array field, add the size of that
3093 initializer to DECL's size. */
3096 add_flexible_array_elts_to_size (tree decl, tree init)
3100 if (VEC_empty (constructor_elt, CONSTRUCTOR_ELTS (init)))
3103 elt = VEC_last (constructor_elt, CONSTRUCTOR_ELTS (init))->value;
3104 type = TREE_TYPE (elt);
3105 if (TREE_CODE (type) == ARRAY_TYPE
3106 && TYPE_SIZE (type) == NULL_TREE
3107 && TYPE_DOMAIN (type) != NULL_TREE
3108 && TYPE_MAX_VALUE (TYPE_DOMAIN (type)) == NULL_TREE)
3110 complete_array_type (&type, elt, false);
3112 = size_binop (PLUS_EXPR, DECL_SIZE (decl), TYPE_SIZE (type));
3113 DECL_SIZE_UNIT (decl)
3114 = size_binop (PLUS_EXPR, DECL_SIZE_UNIT (decl), TYPE_SIZE_UNIT (type));
3118 /* Decode a "typename", such as "int **", returning a ..._TYPE node. */
3121 groktypename (struct c_type_name *type_name)
3124 tree attrs = type_name->specs->attrs;
3126 type_name->specs->attrs = NULL_TREE;
3128 type = grokdeclarator (type_name->declarator, type_name->specs, TYPENAME,
3131 /* Apply attributes. */
3132 decl_attributes (&type, attrs, 0);
3137 /* Decode a declarator in an ordinary declaration or data definition.
3138 This is called as soon as the type information and variable name
3139 have been parsed, before parsing the initializer if any.
3140 Here we create the ..._DECL node, fill in its type,
3141 and put it on the list of decls for the current context.
3142 The ..._DECL node is returned as the value.
3144 Exception: for arrays where the length is not specified,
3145 the type is left null, to be filled in by `finish_decl'.
3147 Function definitions do not come here; they go to start_function
3148 instead. However, external and forward declarations of functions
3149 do go through here. Structure field declarations are done by
3150 grokfield and not through here. */
3153 start_decl (struct c_declarator *declarator, struct c_declspecs *declspecs,
3154 bool initialized, tree attributes)
3159 /* An object declared as __attribute__((deprecated)) suppresses
3160 warnings of uses of other deprecated items. */
3161 if (lookup_attribute ("deprecated", attributes))
3162 deprecated_state = DEPRECATED_SUPPRESS;
3164 decl = grokdeclarator (declarator, declspecs,
3165 NORMAL, initialized, NULL);
3169 deprecated_state = DEPRECATED_NORMAL;
3171 if (warn_main > 0 && TREE_CODE (decl) != FUNCTION_DECL
3172 && MAIN_NAME_P (DECL_NAME (decl)))
3173 warning (OPT_Wmain, "%q+D is usually a function", decl);
3176 /* Is it valid for this decl to have an initializer at all?
3177 If not, set INITIALIZED to zero, which will indirectly
3178 tell 'finish_decl' to ignore the initializer once it is parsed. */
3179 switch (TREE_CODE (decl))
3182 error ("typedef %qD is initialized (use __typeof__ instead)", decl);
3187 error ("function %qD is initialized like a variable", decl);
3192 /* DECL_INITIAL in a PARM_DECL is really DECL_ARG_TYPE. */
3193 error ("parameter %qD is initialized", decl);
3198 /* Don't allow initializations for incomplete types except for
3199 arrays which might be completed by the initialization. */
3201 /* This can happen if the array size is an undefined macro.
3202 We already gave a warning, so we don't need another one. */
3203 if (TREE_TYPE (decl) == error_mark_node)
3205 else if (COMPLETE_TYPE_P (TREE_TYPE (decl)))
3207 /* A complete type is ok if size is fixed. */
3209 if (TREE_CODE (TYPE_SIZE (TREE_TYPE (decl))) != INTEGER_CST
3210 || C_DECL_VARIABLE_SIZE (decl))
3212 error ("variable-sized object may not be initialized");
3216 else if (TREE_CODE (TREE_TYPE (decl)) != ARRAY_TYPE)
3218 error ("variable %qD has initializer but incomplete type", decl);
3221 else if (C_DECL_VARIABLE_SIZE (decl))
3223 /* Although C99 is unclear about whether incomplete arrays
3224 of VLAs themselves count as VLAs, it does not make
3225 sense to permit them to be initialized given that
3226 ordinary VLAs may not be initialized. */
3227 error ("variable-sized object may not be initialized");
3234 if (current_scope == file_scope)
3235 TREE_STATIC (decl) = 1;
3237 /* Tell 'pushdecl' this is an initialized decl
3238 even though we don't yet have the initializer expression.
3239 Also tell 'finish_decl' it may store the real initializer. */
3240 DECL_INITIAL (decl) = error_mark_node;
3243 /* If this is a function declaration, write a record describing it to the
3244 prototypes file (if requested). */
3246 if (TREE_CODE (decl) == FUNCTION_DECL)
3247 gen_aux_info_record (decl, 0, 0, TYPE_ARG_TYPES (TREE_TYPE (decl)) != 0);
3249 /* ANSI specifies that a tentative definition which is not merged with
3250 a non-tentative definition behaves exactly like a definition with an
3251 initializer equal to zero. (Section 3.7.2)
3253 -fno-common gives strict ANSI behavior, though this tends to break
3254 a large body of code that grew up without this rule.
3256 Thread-local variables are never common, since there's no entrenched
3257 body of code to break, and it allows more efficient variable references
3258 in the presence of dynamic linking. */
3260 if (TREE_CODE (decl) == VAR_DECL
3262 && TREE_PUBLIC (decl)
3263 && !DECL_THREAD_LOCAL_P (decl)
3265 DECL_COMMON (decl) = 1;
3267 /* Set attributes here so if duplicate decl, will have proper attributes. */
3268 decl_attributes (&decl, attributes, 0);
3270 if (TREE_CODE (decl) == FUNCTION_DECL
3271 && targetm.calls.promote_prototypes (TREE_TYPE (decl)))
3273 struct c_declarator *ce = declarator;
3275 if (ce->kind == cdk_pointer)
3276 ce = declarator->declarator;
3277 if (ce->kind == cdk_function)
3279 tree args = ce->u.arg_info->parms;
3280 for (; args; args = TREE_CHAIN (args))
3282 tree type = TREE_TYPE (args);
3283 if (type && INTEGRAL_TYPE_P (type)
3284 && TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node))
3285 DECL_ARG_TYPE (args) = integer_type_node;
3290 if (TREE_CODE (decl) == FUNCTION_DECL
3291 && DECL_DECLARED_INLINE_P (decl)
3292 && DECL_UNINLINABLE (decl)
3293 && lookup_attribute ("noinline", DECL_ATTRIBUTES (decl)))
3294 warning (OPT_Wattributes, "inline function %q+D given attribute noinline",
3297 /* Add this decl to the current scope.
3298 TEM may equal DECL or it may be a previous decl of the same name. */
3299 tem = pushdecl (decl);
3301 if (initialized && DECL_EXTERNAL (tem))
3303 DECL_EXTERNAL (tem) = 0;
3304 TREE_STATIC (tem) = 1;
3310 /* Finish processing of a declaration;
3311 install its initial value.
3312 If the length of an array type is not known before,
3313 it must be determined now, from the initial value, or it is an error. */
3316 finish_decl (tree decl, tree init, tree asmspec_tree)
3318 tree type = TREE_TYPE (decl);
3319 int was_incomplete = (DECL_SIZE (decl) == 0);
3320 const char *asmspec = 0;
3322 /* If a name was specified, get the string. */
3323 if ((TREE_CODE (decl) == FUNCTION_DECL || TREE_CODE (decl) == VAR_DECL)
3324 && DECL_FILE_SCOPE_P (decl))
3325 asmspec_tree = maybe_apply_renaming_pragma (decl, asmspec_tree);
3327 asmspec = TREE_STRING_POINTER (asmspec_tree);
3329 /* If `start_decl' didn't like having an initialization, ignore it now. */
3330 if (init != 0 && DECL_INITIAL (decl) == 0)
3333 /* Don't crash if parm is initialized. */
3334 if (TREE_CODE (decl) == PARM_DECL)
3338 store_init_value (decl, init);
3340 if (c_dialect_objc () && (TREE_CODE (decl) == VAR_DECL
3341 || TREE_CODE (decl) == FUNCTION_DECL
3342 || TREE_CODE (decl) == FIELD_DECL))
3343 objc_check_decl (decl);
3345 /* Deduce size of array from initialization, if not already known. */
3346 if (TREE_CODE (type) == ARRAY_TYPE
3347 && TYPE_DOMAIN (type) == 0
3348 && TREE_CODE (decl) != TYPE_DECL)
3351 = (TREE_STATIC (decl)
3352 /* Even if pedantic, an external linkage array
3353 may have incomplete type at first. */
3354 ? pedantic && !TREE_PUBLIC (decl)
3355 : !DECL_EXTERNAL (decl));
3357 = complete_array_type (&TREE_TYPE (decl), DECL_INITIAL (decl),
3360 /* Get the completed type made by complete_array_type. */
3361 type = TREE_TYPE (decl);
3366 error ("initializer fails to determine size of %q+D", decl);
3371 error ("array size missing in %q+D", decl);
3372 /* If a `static' var's size isn't known,
3373 make it extern as well as static, so it does not get
3375 If it is not `static', then do not mark extern;
3376 finish_incomplete_decl will give it a default size
3377 and it will get allocated. */
3378 else if (!pedantic && TREE_STATIC (decl) && !TREE_PUBLIC (decl))
3379 DECL_EXTERNAL (decl) = 1;
3383 error ("zero or negative size array %q+D", decl);
3387 /* For global variables, update the copy of the type that
3388 exists in the binding. */
3389 if (TREE_PUBLIC (decl))
3391 struct c_binding *b_ext = I_SYMBOL_BINDING (DECL_NAME (decl));
3392 while (b_ext && !B_IN_EXTERNAL_SCOPE (b_ext))
3393 b_ext = b_ext->shadowed;
3397 b_ext->type = composite_type (b_ext->type, type);
3408 if (DECL_INITIAL (decl))
3409 TREE_TYPE (DECL_INITIAL (decl)) = type;
3411 layout_decl (decl, 0);
3414 if (TREE_CODE (decl) == VAR_DECL)
3416 if (init && TREE_CODE (init) == CONSTRUCTOR)
3417 add_flexible_array_elts_to_size (decl, init);
3419 if (DECL_SIZE (decl) == 0 && TREE_TYPE (decl) != error_mark_node
3420 && COMPLETE_TYPE_P (TREE_TYPE (decl)))
3421 layout_decl (decl, 0);
3423 if (DECL_SIZE (decl) == 0
3424 /* Don't give an error if we already gave one earlier. */
3425 && TREE_TYPE (decl) != error_mark_node
3426 && (TREE_STATIC (decl)
3427 /* A static variable with an incomplete type
3428 is an error if it is initialized.
3429 Also if it is not file scope.
3430 Otherwise, let it through, but if it is not `extern'
3431 then it may cause an error message later. */
3432 ? (DECL_INITIAL (decl) != 0
3433 || !DECL_FILE_SCOPE_P (decl))
3434 /* An automatic variable with an incomplete type
3436 : !DECL_EXTERNAL (decl)))
3438 error ("storage size of %q+D isn%'t known", decl);
3439 TREE_TYPE (decl) = error_mark_node;
3442 if ((DECL_EXTERNAL (decl) || TREE_STATIC (decl))
3443 && DECL_SIZE (decl) != 0)
3445 if (TREE_CODE (DECL_SIZE (decl)) == INTEGER_CST)
3446 constant_expression_warning (DECL_SIZE (decl));
3448 error ("storage size of %q+D isn%'t constant", decl);
3451 if (TREE_USED (type))
3452 TREE_USED (decl) = 1;
3455 /* If this is a function and an assembler name is specified, reset DECL_RTL
3456 so we can give it its new name. Also, update built_in_decls if it
3457 was a normal built-in. */
3458 if (TREE_CODE (decl) == FUNCTION_DECL && asmspec)
3460 if (DECL_BUILT_IN_CLASS (decl) == BUILT_IN_NORMAL)
3461 set_builtin_user_assembler_name (decl, asmspec);
3462 set_user_assembler_name (decl, asmspec);
3465 /* If #pragma weak was used, mark the decl weak now. */
3466 maybe_apply_pragma_weak (decl);
3468 /* Output the assembler code and/or RTL code for variables and functions,
3469 unless the type is an undefined structure or union.
3470 If not, it will get done when the type is completed. */
3472 if (TREE_CODE (decl) == VAR_DECL || TREE_CODE (decl) == FUNCTION_DECL)
3474 /* Determine the ELF visibility. */
3475 if (TREE_PUBLIC (decl))
3476 c_determine_visibility (decl);
3478 /* This is a no-op in c-lang.c or something real in objc-act.c. */
3479 if (c_dialect_objc ())
3480 objc_check_decl (decl);
3484 /* If this is not a static variable, issue a warning.
3485 It doesn't make any sense to give an ASMSPEC for an
3486 ordinary, non-register local variable. Historically,
3487 GCC has accepted -- but ignored -- the ASMSPEC in
3489 if (!DECL_FILE_SCOPE_P (decl)
3490 && TREE_CODE (decl) == VAR_DECL
3491 && !C_DECL_REGISTER (decl)
3492 && !TREE_STATIC (decl))
3493 warning (0, "ignoring asm-specifier for non-static local "
3494 "variable %q+D", decl);
3496 set_user_assembler_name (decl, asmspec);
3499 if (DECL_FILE_SCOPE_P (decl))
3501 if (DECL_INITIAL (decl) == NULL_TREE
3502 || DECL_INITIAL (decl) == error_mark_node)
3503 /* Don't output anything
3504 when a tentative file-scope definition is seen.
3505 But at end of compilation, do output code for them. */
3506 DECL_DEFER_OUTPUT (decl) = 1;
3507 rest_of_decl_compilation (decl, true, 0);
3511 /* In conjunction with an ASMSPEC, the `register'
3512 keyword indicates that we should place the variable
3513 in a particular register. */
3514 if (asmspec && C_DECL_REGISTER (decl))
3516 DECL_HARD_REGISTER (decl) = 1;
3517 /* This cannot be done for a structure with volatile
3518 fields, on which DECL_REGISTER will have been
3520 if (!DECL_REGISTER (decl))
3521 error ("cannot put object with volatile field into register");
3524 if (TREE_CODE (decl) != FUNCTION_DECL)
3526 /* If we're building a variable sized type, and we might be
3527 reachable other than via the top of the current binding
3528 level, then create a new BIND_EXPR so that we deallocate
3529 the object at the right time. */
3530 /* Note that DECL_SIZE can be null due to errors. */
3531 if (DECL_SIZE (decl)
3532 && !TREE_CONSTANT (DECL_SIZE (decl))
3533 && STATEMENT_LIST_HAS_LABEL (cur_stmt_list))
3536 bind = build3 (BIND_EXPR, void_type_node, NULL, NULL, NULL);
3537 TREE_SIDE_EFFECTS (bind) = 1;
3539 BIND_EXPR_BODY (bind) = push_stmt_list ();
3541 add_stmt (build_stmt (DECL_EXPR, decl));
3546 if (!DECL_FILE_SCOPE_P (decl))
3548 /* Recompute the RTL of a local array now
3549 if it used to be an incomplete type. */
3551 && !TREE_STATIC (decl) && !DECL_EXTERNAL (decl))
3553 /* If we used it already as memory, it must stay in memory. */
3554 TREE_ADDRESSABLE (decl) = TREE_USED (decl);
3555 /* If it's still incomplete now, no init will save it. */
3556 if (DECL_SIZE (decl) == 0)
3557 DECL_INITIAL (decl) = 0;
3562 /* If this was marked 'used', be sure it will be output. */
3563 if (!flag_unit_at_a_time && lookup_attribute ("used", DECL_ATTRIBUTES (decl)))
3564 mark_decl_referenced (decl);
3566 if (TREE_CODE (decl) == TYPE_DECL)
3568 if (!DECL_FILE_SCOPE_P (decl)
3569 && variably_modified_type_p (TREE_TYPE (decl), NULL_TREE))
3570 add_stmt (build_stmt (DECL_EXPR, decl));
3572 rest_of_decl_compilation (decl, DECL_FILE_SCOPE_P (decl), 0);
3575 /* At the end of a declaration, throw away any variable type sizes
3576 of types defined inside that declaration. There is no use
3577 computing them in the following function definition. */
3578 if (current_scope == file_scope)
3579 get_pending_sizes ();
3581 /* Install a cleanup (aka destructor) if one was given. */
3582 if (TREE_CODE (decl) == VAR_DECL && !TREE_STATIC (decl))
3584 tree attr = lookup_attribute ("cleanup", DECL_ATTRIBUTES (decl));
3587 tree cleanup_id = TREE_VALUE (TREE_VALUE (attr));
3588 tree cleanup_decl = lookup_name (cleanup_id);
3591 /* Build "cleanup(&decl)" for the destructor. */
3592 cleanup = build_unary_op (ADDR_EXPR, decl, 0);
3593 cleanup = build_tree_list (NULL_TREE, cleanup);
3594 cleanup = build_function_call (cleanup_decl, cleanup);
3596 /* Don't warn about decl unused; the cleanup uses it. */
3597 TREE_USED (decl) = 1;
3598 TREE_USED (cleanup_decl) = 1;
3600 /* Initialize EH, if we've been told to do so. */
3601 if (flag_exceptions && !c_eh_initialized_p)
3603 c_eh_initialized_p = true;
3604 eh_personality_libfunc
3605 = init_one_libfunc (USING_SJLJ_EXCEPTIONS
3606 ? "__gcc_personality_sj0"
3607 : "__gcc_personality_v0");
3608 default_init_unwind_resume_libfunc ();
3609 using_eh_for_cleanups ();
3612 push_cleanup (decl, cleanup, false);
3617 /* Given a parsed parameter declaration, decode it into a PARM_DECL. */
3620 grokparm (const struct c_parm *parm)
3622 tree decl = grokdeclarator (parm->declarator, parm->specs, PARM, false,
3625 decl_attributes (&decl, parm->attrs, 0);
3630 /* Given a parsed parameter declaration, decode it into a PARM_DECL
3631 and push that on the current scope. */
3634 push_parm_decl (const struct c_parm *parm)
3638 decl = grokdeclarator (parm->declarator, parm->specs, PARM, false, NULL);
3639 decl_attributes (&decl, parm->attrs, 0);
3641 decl = pushdecl (decl);
3643 finish_decl (decl, NULL_TREE, NULL_TREE);
3646 /* Mark all the parameter declarations to date as forward decls.
3647 Also diagnose use of this extension. */
3650 mark_forward_parm_decls (void)
3652 struct c_binding *b;
3654 if (pedantic && !current_scope->warned_forward_parm_decls)
3656 pedwarn ("ISO C forbids forward parameter declarations");
3657 current_scope->warned_forward_parm_decls = true;
3660 for (b = current_scope->bindings; b; b = b->prev)
3661 if (TREE_CODE (b->decl) == PARM_DECL)
3662 TREE_ASM_WRITTEN (b->decl) = 1;
3665 /* Build a COMPOUND_LITERAL_EXPR. TYPE is the type given in the compound
3666 literal, which may be an incomplete array type completed by the
3667 initializer; INIT is a CONSTRUCTOR that initializes the compound
3671 build_compound_literal (tree type, tree init)
3673 /* We do not use start_decl here because we have a type, not a declarator;
3674 and do not use finish_decl because the decl should be stored inside
3675 the COMPOUND_LITERAL_EXPR rather than added elsewhere as a DECL_EXPR. */
3680 if (type == error_mark_node)
3681 return error_mark_node;
3683 decl = build_decl (VAR_DECL, NULL_TREE, type);
3684 DECL_EXTERNAL (decl) = 0;
3685 TREE_PUBLIC (decl) = 0;
3686 TREE_STATIC (decl) = (current_scope == file_scope);
3687 DECL_CONTEXT (decl) = current_function_decl;
3688 TREE_USED (decl) = 1;
3689 TREE_TYPE (decl) = type;
3690 TREE_READONLY (decl) = TYPE_READONLY (type);
3691 store_init_value (decl, init);
3693 if (TREE_CODE (type) == ARRAY_TYPE && !COMPLETE_TYPE_P (type))
3695 int failure = complete_array_type (&TREE_TYPE (decl),
3696 DECL_INITIAL (decl), true);
3697 gcc_assert (!failure);
3699 type = TREE_TYPE (decl);
3700 TREE_TYPE (DECL_INITIAL (decl)) = type;
3703 if (type == error_mark_node || !COMPLETE_TYPE_P (type))
3704 return error_mark_node;
3706 stmt = build_stmt (DECL_EXPR, decl);
3707 complit = build1 (COMPOUND_LITERAL_EXPR, type, stmt);
3708 TREE_SIDE_EFFECTS (complit) = 1;
3710 layout_decl (decl, 0);
3712 if (TREE_STATIC (decl))
3714 /* This decl needs a name for the assembler output. */
3715 set_compound_literal_name (decl);
3716 DECL_DEFER_OUTPUT (decl) = 1;
3717 DECL_COMDAT (decl) = 1;
3718 DECL_ARTIFICIAL (decl) = 1;
3719 DECL_IGNORED_P (decl) = 1;
3721 rest_of_decl_compilation (decl, 1, 0);
3727 /* Determine whether TYPE is a structure with a flexible array member,
3728 or a union containing such a structure (possibly recursively). */
3731 flexible_array_type_p (tree type)
3734 switch (TREE_CODE (type))
3737 x = TYPE_FIELDS (type);
3740 while (TREE_CHAIN (x) != NULL_TREE)
3742 if (TREE_CODE (TREE_TYPE (x)) == ARRAY_TYPE
3743 && TYPE_SIZE (TREE_TYPE (x)) == NULL_TREE
3744 && TYPE_DOMAIN (TREE_TYPE (x)) != NULL_TREE
3745 && TYPE_MAX_VALUE (TYPE_DOMAIN (TREE_TYPE (x))) == NULL_TREE)
3749 for (x = TYPE_FIELDS (type); x != NULL_TREE; x = TREE_CHAIN (x))
3751 if (flexible_array_type_p (TREE_TYPE (x)))
3760 /* Performs sanity checks on the TYPE and WIDTH of the bit-field NAME,
3761 replacing with appropriate values if they are invalid. */
3763 check_bitfield_type_and_width (tree *type, tree *width, const char *orig_name)
3766 unsigned int max_width;
3767 unsigned HOST_WIDE_INT w;
3768 const char *name = orig_name ? orig_name: _("<anonymous>");
3770 /* Detect and ignore out of range field width and process valid
3772 if (!INTEGRAL_TYPE_P (TREE_TYPE (*width))
3773 || TREE_CODE (*width) != INTEGER_CST)
3775 error ("bit-field %qs width not an integer constant", name);
3776 *width = integer_one_node;
3780 constant_expression_warning (*width);
3781 if (tree_int_cst_sgn (*width) < 0)
3783 error ("negative width in bit-field %qs", name);
3784 *width = integer_one_node;
3786 else if (integer_zerop (*width) && orig_name)
3788 error ("zero width for bit-field %qs", name);
3789 *width = integer_one_node;
3793 /* Detect invalid bit-field type. */
3794 if (TREE_CODE (*type) != INTEGER_TYPE
3795 && TREE_CODE (*type) != BOOLEAN_TYPE
3796 && TREE_CODE (*type) != ENUMERAL_TYPE)
3798 error ("bit-field %qs has invalid type", name);
3799 *type = unsigned_type_node;
3802 type_mv = TYPE_MAIN_VARIANT (*type);
3804 && !in_system_header
3805 && type_mv != integer_type_node
3806 && type_mv != unsigned_type_node
3807 && type_mv != boolean_type_node)
3808 pedwarn ("type of bit-field %qs is a GCC extension", name);
3810 if (type_mv == boolean_type_node)
3811 max_width = CHAR_TYPE_SIZE;
3813 max_width = TYPE_PRECISION (*type);
3815 if (0 < compare_tree_int (*width, max_width))
3817 error ("width of %qs exceeds its type", name);
3819 *width = build_int_cst (NULL_TREE, w);
3822 w = tree_low_cst (*width, 1);
3824 if (TREE_CODE (*type) == ENUMERAL_TYPE)
3826 struct lang_type *lt = TYPE_LANG_SPECIFIC (*type);
3828 || w < min_precision (lt->enum_min, TYPE_UNSIGNED (*type))
3829 || w < min_precision (lt->enum_max, TYPE_UNSIGNED (*type)))
3830 warning (0, "%qs is narrower than values of its type", name);
3835 /* Given declspecs and a declarator,
3836 determine the name and type of the object declared
3837 and construct a ..._DECL node for it.
3838 (In one case we can return a ..._TYPE node instead.
3839 For invalid input we sometimes return 0.)
3841 DECLSPECS is a c_declspecs structure for the declaration specifiers.
3843 DECL_CONTEXT says which syntactic context this declaration is in:
3844 NORMAL for most contexts. Make a VAR_DECL or FUNCTION_DECL or TYPE_DECL.
3845 FUNCDEF for a function definition. Like NORMAL but a few different
3846 error messages in each case. Return value may be zero meaning
3847 this definition is too screwy to try to parse.
3848 PARM for a parameter declaration (either within a function prototype
3849 or before a function body). Make a PARM_DECL, or return void_type_node.
3850 TYPENAME if for a typename (in a cast or sizeof).
3851 Don't make a DECL node; just return the ..._TYPE node.
3852 FIELD for a struct or union field; make a FIELD_DECL.
3853 INITIALIZED is true if the decl has an initializer.
3854 WIDTH is non-NULL for bit-fields, and is a pointer to an INTEGER_CST node
3855 representing the width of the bit-field.
3857 In the TYPENAME case, DECLARATOR is really an absolute declarator.
3858 It may also be so in the PARM case, for a prototype where the
3859 argument type is specified but not the name.
3861 This function is where the complicated C meanings of `static'
3862 and `extern' are interpreted. */
3865 grokdeclarator (const struct c_declarator *declarator,
3866 struct c_declspecs *declspecs,
3867 enum decl_context decl_context, bool initialized, tree *width)
3869 tree type = declspecs->type;
3870 bool threadp = declspecs->thread_p;
3871 enum c_storage_class storage_class = declspecs->storage_class;
3875 int type_quals = TYPE_UNQUALIFIED;
3876 const char *name, *orig_name;
3877 tree typedef_type = 0;
3878 bool funcdef_flag = false;
3879 bool funcdef_syntax = false;
3880 int size_varies = 0;
3881 tree decl_attr = declspecs->decl_attr;
3882 int array_ptr_quals = TYPE_UNQUALIFIED;
3883 tree array_ptr_attrs = NULL_TREE;
3884 int array_parm_static = 0;
3885 bool array_parm_vla_unspec_p = false;
3886 tree returned_attrs = NULL_TREE;
3887 bool bitfield = width != NULL;
3889 struct c_arg_info *arg_info = 0;
3891 if (decl_context == FUNCDEF)
3892 funcdef_flag = true, decl_context = NORMAL;
3894 /* Look inside a declarator for the name being declared
3895 and get it as a string, for an error message. */
3897 const struct c_declarator *decl = declarator;
3906 funcdef_syntax = (decl->kind == cdk_function);
3907 decl = decl->declarator;
3911 decl = decl->declarator;
3916 name = IDENTIFIER_POINTER (decl->u.id);
3928 /* A function definition's declarator must have the form of
3929 a function declarator. */
3931 if (funcdef_flag && !funcdef_syntax)
3934 /* If this looks like a function definition, make it one,
3935 even if it occurs where parms are expected.
3936 Then store_parm_decls will reject it and not use it as a parm. */
3937 if (decl_context == NORMAL && !funcdef_flag && current_scope->parm_flag)
3938 decl_context = PARM;
3940 if (declspecs->deprecated_p && deprecated_state != DEPRECATED_SUPPRESS)
3941 warn_deprecated_use (declspecs->type);
3943 if ((decl_context == NORMAL || decl_context == FIELD)
3944 && current_scope == file_scope
3945 && variably_modified_type_p (type, NULL_TREE))
3947 error ("variably modified %qs at file scope", name);
3948 type = integer_type_node;
3951 typedef_type = type;
3952 size_varies = C_TYPE_VARIABLE_SIZE (type);
3954 /* Diagnose defaulting to "int". */
3956 if (declspecs->default_int_p && !in_system_header)
3958 /* Issue a warning if this is an ISO C 99 program or if
3959 -Wreturn-type and this is a function, or if -Wimplicit;
3960 prefer the former warning since it is more explicit. */
3961 if ((warn_implicit_int || warn_return_type || flag_isoc99)
3963 warn_about_return_type = 1;
3964 else if (warn_implicit_int || flag_isoc99)
3965 pedwarn_c99 ("type defaults to %<int%> in declaration of %qs", name);
3968 /* Adjust the type if a bit-field is being declared,
3969 -funsigned-bitfields applied and the type is not explicitly
3971 if (bitfield && !flag_signed_bitfields && !declspecs->explicit_signed_p
3972 && TREE_CODE (type) == INTEGER_TYPE)
3973 type = c_common_unsigned_type (type);
3975 /* Figure out the type qualifiers for the declaration. There are
3976 two ways a declaration can become qualified. One is something
3977 like `const int i' where the `const' is explicit. Another is
3978 something like `typedef const int CI; CI i' where the type of the
3979 declaration contains the `const'. A third possibility is that
3980 there is a type qualifier on the element type of a typedefed
3981 array type, in which case we should extract that qualifier so
3982 that c_apply_type_quals_to_decls receives the full list of
3983 qualifiers to work with (C90 is not entirely clear about whether
3984 duplicate qualifiers should be diagnosed in this case, but it
3985 seems most appropriate to do so). */
3986 element_type = strip_array_types (type);
3987 constp = declspecs->const_p + TYPE_READONLY (element_type);
3988 restrictp = declspecs->restrict_p + TYPE_RESTRICT (element_type);
3989 volatilep = declspecs->volatile_p + TYPE_VOLATILE (element_type);
3990 if (pedantic && !flag_isoc99)
3993 pedwarn ("duplicate %<const%>");
3995 pedwarn ("duplicate %<restrict%>");
3997 pedwarn ("duplicate %<volatile%>");
3999 if (!flag_gen_aux_info && (TYPE_QUALS (element_type)))
4000 type = TYPE_MAIN_VARIANT (type);
4001 type_quals = ((constp ? TYPE_QUAL_CONST : 0)
4002 | (restrictp ? TYPE_QUAL_RESTRICT : 0)
4003 | (volatilep ? TYPE_QUAL_VOLATILE : 0));
4005 /* Warn about storage classes that are invalid for certain
4006 kinds of declarations (parameters, typenames, etc.). */
4010 || storage_class == csc_auto
4011 || storage_class == csc_register
4012 || storage_class == csc_typedef))
4014 if (storage_class == csc_auto
4015 && (pedantic || current_scope == file_scope))
4016 pedwarn ("function definition declared %<auto%>");
4017 if (storage_class == csc_register)
4018 error ("function definition declared %<register%>");
4019 if (storage_class == csc_typedef)
4020 error ("function definition declared %<typedef%>");
4022 error ("function definition declared %<__thread%>");
4024 if (storage_class == csc_auto
4025 || storage_class == csc_register
4026 || storage_class == csc_typedef)
4027 storage_class = csc_none;
4029 else if (decl_context != NORMAL && (storage_class != csc_none || threadp))
4031 if (decl_context == PARM && storage_class == csc_register)
4035 switch (decl_context)
4038 error ("storage class specified for structure field %qs",
4042 error ("storage class specified for parameter %qs", name);
4045 error ("storage class specified for typename");
4048 storage_class = csc_none;
4052 else if (storage_class == csc_extern
4056 /* 'extern' with initialization is invalid if not at file scope. */
4057 if (current_scope == file_scope)
4059 /* It is fine to have 'extern const' when compiling at C
4060 and C++ intersection. */
4061 if (!(warn_cxx_compat && constp))
4062 warning (0, "%qs initialized and declared %<extern%>", name);
4065 error ("%qs has both %<extern%> and initializer", name);
4067 else if (current_scope == file_scope)
4069 if (storage_class == csc_auto)
4070 error ("file-scope declaration of %qs specifies %<auto%>", name);
4071 if (pedantic && storage_class == csc_register)
4072 pedwarn ("file-scope declaration of %qs specifies %<register%>", name);
4076 if (storage_class == csc_extern && funcdef_flag)
4077 error ("nested function %qs declared %<extern%>", name);
4078 else if (threadp && storage_class == csc_none)
4080 error ("function-scope %qs implicitly auto and declared "
4087 /* Now figure out the structure of the declarator proper.
4088 Descend through it, creating more complex types, until we reach
4089 the declared identifier (or NULL_TREE, in an absolute declarator).
4090 At each stage we maintain an unqualified version of the type
4091 together with any qualifiers that should be applied to it with
4092 c_build_qualified_type; this way, array types including
4093 multidimensional array types are first built up in unqualified
4094 form and then the qualified form is created with
4095 TYPE_MAIN_VARIANT pointing to the unqualified form. */
4097 while (declarator && declarator->kind != cdk_id)
4099 if (type == error_mark_node)
4101 declarator = declarator->declarator;
4105 /* Each level of DECLARATOR is either a cdk_array (for ...[..]),
4106 a cdk_pointer (for *...),
4107 a cdk_function (for ...(...)),
4108 a cdk_attrs (for nested attributes),
4109 or a cdk_id (for the name being declared
4110 or the place in an absolute declarator
4111 where the name was omitted).
4112 For the last case, we have just exited the loop.
4114 At this point, TYPE is the type of elements of an array,
4115 or for a function to return, or for a pointer to point to.
4116 After this sequence of ifs, TYPE is the type of the
4117 array or function or pointer, and DECLARATOR has had its
4118 outermost layer removed. */
4120 if (array_ptr_quals != TYPE_UNQUALIFIED
4121 || array_ptr_attrs != NULL_TREE
4122 || array_parm_static)
4124 /* Only the innermost declarator (making a parameter be of
4125 array type which is converted to pointer type)
4126 may have static or type qualifiers. */
4127 error ("static or type qualifiers in non-parameter array declarator");
4128 array_ptr_quals = TYPE_UNQUALIFIED;
4129 array_ptr_attrs = NULL_TREE;
4130 array_parm_static = 0;
4133 switch (declarator->kind)
4137 /* A declarator with embedded attributes. */
4138 tree attrs = declarator->u.attrs;
4139 const struct c_declarator *inner_decl;
4141 declarator = declarator->declarator;
4142 inner_decl = declarator;
4143 while (inner_decl->kind == cdk_attrs)
4144 inner_decl = inner_decl->declarator;
4145 if (inner_decl->kind == cdk_id)
4146 attr_flags |= (int) ATTR_FLAG_DECL_NEXT;
4147 else if (inner_decl->kind == cdk_function)
4148 attr_flags |= (int) ATTR_FLAG_FUNCTION_NEXT;
4149 else if (inner_decl->kind == cdk_array)
4150 attr_flags |= (int) ATTR_FLAG_ARRAY_NEXT;
4151 returned_attrs = decl_attributes (&type,
4152 chainon (returned_attrs, attrs),
4158 tree itype = NULL_TREE;
4159 tree size = declarator->u.array.dimen;
4160 /* The index is a signed object `sizetype' bits wide. */
4161 tree index_type = c_common_signed_type (sizetype);
4163 array_ptr_quals = declarator->u.array.quals;
4164 array_ptr_attrs = declarator->u.array.attrs;
4165 array_parm_static = declarator->u.array.static_p;
4166 array_parm_vla_unspec_p = declarator->u.array.vla_unspec_p;
4168 declarator = declarator->declarator;
4170 /* Check for some types that there cannot be arrays of. */
4172 if (VOID_TYPE_P (type))
4174 error ("declaration of %qs as array of voids", name);
4175 type = error_mark_node;
4178 if (TREE_CODE (type) == FUNCTION_TYPE)
4180 error ("declaration of %qs as array of functions", name);
4181 type = error_mark_node;
4184 if (pedantic && !in_system_header && flexible_array_type_p (type))
4185 pedwarn ("invalid use of structure with flexible array member");
4187 if (size == error_mark_node)
4188 type = error_mark_node;
4190 if (type == error_mark_node)
4193 /* If size was specified, set ITYPE to a range-type for
4194 that size. Otherwise, ITYPE remains null. finish_decl
4195 may figure it out from an initial value. */
4199 /* Strip NON_LVALUE_EXPRs since we aren't using as an
4201 STRIP_TYPE_NOPS (size);
4203 if (!INTEGRAL_TYPE_P (TREE_TYPE (size)))
4205 error ("size of array %qs has non-integer type", name);
4206 size = integer_one_node;
4209 if (pedantic && integer_zerop (size))
4210 pedwarn ("ISO C forbids zero-size array %qs", name);
4212 if (TREE_CODE (size) == INTEGER_CST)
4214 constant_expression_warning (size);
4215 if (tree_int_cst_sgn (size) < 0)
4217 error ("size of array %qs is negative", name);
4218 size = integer_one_node;
4221 else if ((decl_context == NORMAL || decl_context == FIELD)
4222 && current_scope == file_scope)
4224 error ("variably modified %qs at file scope", name);
4225 size = integer_one_node;
4229 /* Make sure the array size remains visibly
4230 nonconstant even if it is (eg) a const variable
4231 with known value. */
4234 if (!flag_isoc99 && pedantic)
4236 if (TREE_CONSTANT (size))
4237 pedwarn ("ISO C90 forbids array %qs whose size "
4238 "can%'t be evaluated",
4241 pedwarn ("ISO C90 forbids variable-size array %qs",
4246 if (integer_zerop (size))
4248 /* A zero-length array cannot be represented with
4249 an unsigned index type, which is what we'll
4250 get with build_index_type. Create an
4251 open-ended range instead. */
4252 itype = build_range_type (sizetype, size, NULL_TREE);
4256 /* Arrange for the SAVE_EXPR on the inside of the
4257 MINUS_EXPR, which allows the -1 to get folded
4258 with the +1 that happens when building TYPE_SIZE. */
4260 size = variable_size (size);
4262 /* Compute the maximum valid index, that is, size
4263 - 1. Do the calculation in index_type, so that
4264 if it is a variable the computations will be
4265 done in the proper mode. */
4266 itype = fold_build2 (MINUS_EXPR, index_type,
4267 convert (index_type, size),
4268 convert (index_type,
4271 /* If that overflowed, the array is too big. ???
4272 While a size of INT_MAX+1 technically shouldn't
4273 cause an overflow (because we subtract 1), the
4274 overflow is recorded during the conversion to
4275 index_type, before the subtraction. Handling
4276 this case seems like an unnecessary
4278 if (TREE_CODE (itype) == INTEGER_CST
4279 && TREE_OVERFLOW (itype))
4281 error ("size of array %qs is too large", name);
4282 type = error_mark_node;
4286 itype = build_index_type (itype);
4289 else if (decl_context == FIELD)
4291 if (pedantic && !flag_isoc99 && !in_system_header)
4292 pedwarn ("ISO C90 does not support flexible array members");
4294 /* ISO C99 Flexible array members are effectively
4295 identical to GCC's zero-length array extension. */
4296 itype = build_range_type (sizetype, size_zero_node, NULL_TREE);
4298 else if (decl_context == PARM)
4300 if (array_parm_vla_unspec_p)
4305 error ("%<[*]%> not allowed in other than a declaration");
4308 itype = build_range_type (sizetype, size_zero_node, NULL_TREE);
4312 else if (decl_context == TYPENAME)
4314 if (array_parm_vla_unspec_p)
4316 /* The error is printed elsewhere. We use this to
4317 avoid messing up with incomplete array types of
4318 the same type, that would otherwise be modified
4320 itype = build_range_type (sizetype, size_zero_node,
4325 /* Complain about arrays of incomplete types. */
4326 if (!COMPLETE_TYPE_P (type))
4328 error ("array type has incomplete element type");
4329 type = error_mark_node;
4332 /* When itype is NULL, a shared incomplete array type is
4333 returned for all array of a given type. Elsewhere we
4334 make sure we don't complete that type before copying
4335 it, but here we want to make sure we don't ever
4336 modify the shared type, so we gcc_assert (itype)
4338 type = build_array_type (type, itype);
4340 if (type != error_mark_node)
4344 /* It is ok to modify type here even if itype is
4345 NULL: if size_varies, we're in a
4346 multi-dimensional array and the inner type has
4347 variable size, so the enclosing shared array type
4349 if (size && TREE_CODE (size) == INTEGER_CST)
4351 = build_distinct_type_copy (TYPE_MAIN_VARIANT (type));
4352 C_TYPE_VARIABLE_SIZE (type) = 1;
4355 /* The GCC extension for zero-length arrays differs from
4356 ISO flexible array members in that sizeof yields
4358 if (size && integer_zerop (size))
4361 TYPE_SIZE (type) = bitsize_zero_node;
4362 TYPE_SIZE_UNIT (type) = size_zero_node;
4364 if (array_parm_vla_unspec_p)
4367 /* The type is complete. C99 6.7.5.2p4 */
4368 TYPE_SIZE (type) = bitsize_zero_node;
4369 TYPE_SIZE_UNIT (type) = size_zero_node;
4373 if (decl_context != PARM
4374 && (array_ptr_quals != TYPE_UNQUALIFIED
4375 || array_ptr_attrs != NULL_TREE
4376 || array_parm_static))
4378 error ("static or type qualifiers in non-parameter array declarator");
4379 array_ptr_quals = TYPE_UNQUALIFIED;
4380 array_ptr_attrs = NULL_TREE;
4381 array_parm_static = 0;
4387 /* Say it's a definition only for the declarator closest
4388 to the identifier, apart possibly from some
4390 bool really_funcdef = false;
4394 const struct c_declarator *t = declarator->declarator;
4395 while (t->kind == cdk_attrs)
4397 really_funcdef = (t->kind == cdk_id);
4400 /* Declaring a function type. Make sure we have a valid
4401 type for the function to return. */
4402 if (type == error_mark_node)
4407 /* Warn about some types functions can't return. */
4408 if (TREE_CODE (type) == FUNCTION_TYPE)
4410 error ("%qs declared as function returning a function", name);
4411 type = integer_type_node;
4413 if (TREE_CODE (type) == ARRAY_TYPE)
4415 error ("%qs declared as function returning an array", name);
4416 type = integer_type_node;
4419 /* Construct the function type and go to the next
4420 inner layer of declarator. */
4421 arg_info = declarator->u.arg_info;
4422 arg_types = grokparms (arg_info, really_funcdef);
4424 put_pending_sizes (arg_info->pending_sizes);
4426 /* Type qualifiers before the return type of the function
4427 qualify the return type, not the function type. */
4430 /* Type qualifiers on a function return type are
4431 normally permitted by the standard but have no
4432 effect, so give a warning at -Wreturn-type.
4433 Qualifiers on a void return type are banned on
4434 function definitions in ISO C; GCC used to used
4435 them for noreturn functions. */
4436 if (VOID_TYPE_P (type) && really_funcdef)
4437 pedwarn ("function definition has qualified void return type");
4439 warning (OPT_Wreturn_type,
4440 "type qualifiers ignored on function return type");
4442 type = c_build_qualified_type (type, type_quals);
4444 type_quals = TYPE_UNQUALIFIED;
4446 type = build_function_type (type, arg_types);
4447 declarator = declarator->declarator;
4449 /* Set the TYPE_CONTEXTs for each tagged type which is local to
4450 the formal parameter list of this FUNCTION_TYPE to point to
4451 the FUNCTION_TYPE node itself. */
4455 for (link = arg_info->tags;
4457 link = TREE_CHAIN (link))
4458 TYPE_CONTEXT (TREE_VALUE (link)) = type;
4464 /* Merge any constancy or volatility into the target type
4467 if (pedantic && TREE_CODE (type) == FUNCTION_TYPE
4469 pedwarn ("ISO C forbids qualified function types");
4471 type = c_build_qualified_type (type, type_quals);
4474 /* When the pointed-to type involves components of variable size,
4475 care must be taken to ensure that the size evaluation code is
4476 emitted early enough to dominate all the possible later uses
4477 and late enough for the variables on which it depends to have
4480 This is expected to happen automatically when the pointed-to
4481 type has a name/declaration of it's own, but special attention
4482 is required if the type is anonymous.
4484 We handle the NORMAL and FIELD contexts here by attaching an
4485 artificial TYPE_DECL to such pointed-to type. This forces the
4486 sizes evaluation at a safe point and ensures it is not deferred
4487 until e.g. within a deeper conditional context.
4489 We expect nothing to be needed here for PARM or TYPENAME.
4490 Pushing a TYPE_DECL at this point for TYPENAME would actually
4491 be incorrect, as we might be in the middle of an expression
4492 with side effects on the pointed-to type size "arguments" prior
4493 to the pointer declaration point and the fake TYPE_DECL in the
4494 enclosing context would force the size evaluation prior to the
4497 if (!TYPE_NAME (type)
4498 && (decl_context == NORMAL || decl_context == FIELD)
4499 && variably_modified_type_p (type, NULL_TREE))
4501 tree decl = build_decl (TYPE_DECL, NULL_TREE, type);
4502 DECL_ARTIFICIAL (decl) = 1;
4504 finish_decl (decl, NULL_TREE, NULL_TREE);
4505 TYPE_NAME (type) = decl;
4508 type = build_pointer_type (type);
4510 /* Process type qualifiers (such as const or volatile)
4511 that were given inside the `*'. */
4512 type_quals = declarator->u.pointer_quals;
4514 declarator = declarator->declarator;
4522 /* Now TYPE has the actual type, apart from any qualifiers in
4525 /* Check the type and width of a bit-field. */
4527 check_bitfield_type_and_width (&type, width, orig_name);
4529 /* Did array size calculations overflow? */
4531 if (TREE_CODE (type) == ARRAY_TYPE
4532 && COMPLETE_TYPE_P (type)
4533 && TREE_CODE (TYPE_SIZE_UNIT (type)) == INTEGER_CST
4534 && TREE_OVERFLOW (TYPE_SIZE_UNIT (type)))
4536 error ("size of array %qs is too large", name);
4537 /* If we proceed with the array type as it is, we'll eventually
4538 crash in tree_low_cst(). */
4539 type = error_mark_node;
4542 /* If this is declaring a typedef name, return a TYPE_DECL. */
4544 if (storage_class == csc_typedef)
4547 if (pedantic && TREE_CODE (type) == FUNCTION_TYPE
4549 pedwarn ("ISO C forbids qualified function types");
4551 type = c_build_qualified_type (type, type_quals);
4552 decl = build_decl (TYPE_DECL, declarator->u.id, type);
4553 if (declspecs->explicit_signed_p)
4554 C_TYPEDEF_EXPLICITLY_SIGNED (decl) = 1;
4555 decl_attributes (&decl, returned_attrs, 0);
4556 if (declspecs->inline_p)
4557 pedwarn ("typedef %q+D declared %<inline%>", decl);
4561 /* If this is a type name (such as, in a cast or sizeof),
4562 compute the type and return it now. */
4564 if (decl_context == TYPENAME)
4566 /* Note that the grammar rejects storage classes in typenames
4568 gcc_assert (storage_class == csc_none && !threadp
4569 && !declspecs->inline_p);
4570 if (pedantic && TREE_CODE (type) == FUNCTION_TYPE
4572 pedwarn ("ISO C forbids const or volatile function types");
4574 type = c_build_qualified_type (type, type_quals);
4575 decl_attributes (&type, returned_attrs, 0);
4579 if (pedantic && decl_context == FIELD
4580 && variably_modified_type_p (type, NULL_TREE))
4583 pedwarn ("a member of a structure or union cannot have a variably modified type");
4586 /* Aside from typedefs and type names (handle above),
4587 `void' at top level (not within pointer)
4588 is allowed only in public variables.
4589 We don't complain about parms either, but that is because
4590 a better error message can be made later. */
4592 if (VOID_TYPE_P (type) && decl_context != PARM
4593 && !((decl_context != FIELD && TREE_CODE (type) != FUNCTION_TYPE)
4594 && (storage_class == csc_extern
4595 || (current_scope == file_scope
4596 && !(storage_class == csc_static
4597 || storage_class == csc_register)))))
4599 error ("variable or field %qs declared void", name);
4600 type = integer_type_node;
4603 /* Now create the decl, which may be a VAR_DECL, a PARM_DECL
4604 or a FUNCTION_DECL, depending on DECL_CONTEXT and TYPE. */
4609 if (decl_context == PARM)
4611 tree type_as_written;
4614 /* A parameter declared as an array of T is really a pointer to T.
4615 One declared as a function is really a pointer to a function. */
4617 if (TREE_CODE (type) == ARRAY_TYPE)
4619 /* Transfer const-ness of array into that of type pointed to. */
4620 type = TREE_TYPE (type);
4622 type = c_build_qualified_type (type, type_quals);
4623 type = build_pointer_type (type);
4624 type_quals = array_ptr_quals;
4626 /* We don't yet implement attributes in this context. */
4627 if (array_ptr_attrs != NULL_TREE)
4628 warning (OPT_Wattributes,
4629 "attributes in parameter array declarator ignored");
4633 else if (TREE_CODE (type) == FUNCTION_TYPE)
4635 if (pedantic && type_quals)
4636 pedwarn ("ISO C forbids qualified function types");
4638 type = c_build_qualified_type (type, type_quals);
4639 type = build_pointer_type (type);
4640 type_quals = TYPE_UNQUALIFIED;
4642 else if (type_quals)
4643 type = c_build_qualified_type (type, type_quals);
4645 type_as_written = type;
4647 decl = build_decl (PARM_DECL, declarator->u.id, type);
4649 C_DECL_VARIABLE_SIZE (decl) = 1;
4651 /* Compute the type actually passed in the parmlist,
4652 for the case where there is no prototype.
4653 (For example, shorts and chars are passed as ints.)
4654 When there is a prototype, this is overridden later. */
4656 if (type == error_mark_node)
4657 promoted_type = type;
4659 promoted_type = c_type_promotes_to (type);
4661 DECL_ARG_TYPE (decl) = promoted_type;
4662 if (declspecs->inline_p)
4663 pedwarn ("parameter %q+D declared %<inline%>", decl);
4665 else if (decl_context == FIELD)
4667 /* Note that the grammar rejects storage classes in typenames
4669 gcc_assert (storage_class == csc_none && !threadp
4670 && !declspecs->inline_p);
4672 /* Structure field. It may not be a function. */
4674 if (TREE_CODE (type) == FUNCTION_TYPE)
4676 error ("field %qs declared as a function", name);
4677 type = build_pointer_type (type);
4679 else if (TREE_CODE (type) != ERROR_MARK
4680 && !COMPLETE_OR_UNBOUND_ARRAY_TYPE_P (type))
4682 error ("field %qs has incomplete type", name);
4683 type = error_mark_node;
4685 type = c_build_qualified_type (type, type_quals);
4686 decl = build_decl (FIELD_DECL, declarator->u.id, type);
4687 DECL_NONADDRESSABLE_P (decl) = bitfield;
4690 C_DECL_VARIABLE_SIZE (decl) = 1;
4692 else if (TREE_CODE (type) == FUNCTION_TYPE)
4694 if (storage_class == csc_register || threadp)
4696 error ("invalid storage class for function %qs", name);
4698 else if (current_scope != file_scope)
4700 /* Function declaration not at file scope. Storage
4701 classes other than `extern' are not allowed, C99
4702 6.7.1p5, and `extern' makes no difference. However,
4703 GCC allows 'auto', perhaps with 'inline', to support
4704 nested functions. */
4705 if (storage_class == csc_auto)
4708 pedwarn ("invalid storage class for function %qs", name);
4710 else if (storage_class == csc_static)
4712 error ("invalid storage class for function %qs", name);
4714 storage_class = declspecs->storage_class = csc_none;
4720 decl = build_decl (FUNCTION_DECL, declarator->u.id, type);
4721 decl = build_decl_attribute_variant (decl, decl_attr);
4723 DECL_LANG_SPECIFIC (decl) = GGC_CNEW (struct lang_decl);
4725 if (pedantic && type_quals && !DECL_IN_SYSTEM_HEADER (decl))
4726 pedwarn ("ISO C forbids qualified function types");
4728 /* GNU C interprets a volatile-qualified function type to indicate
4729 that the function does not return. */
4730 if ((type_quals & TYPE_QUAL_VOLATILE)
4731 && !VOID_TYPE_P (TREE_TYPE (TREE_TYPE (decl))))
4732 warning (0, "%<noreturn%> function returns non-void value");
4734 /* Every function declaration is an external reference
4735 (DECL_EXTERNAL) except for those which are not at file
4736 scope and are explicitly declared "auto". This is
4737 forbidden by standard C (C99 6.7.1p5) and is interpreted by
4738 GCC to signify a forward declaration of a nested function. */
4739 if (storage_class == csc_auto && current_scope != file_scope)
4740 DECL_EXTERNAL (decl) = 0;
4742 DECL_EXTERNAL (decl) = 1;
4744 /* Record absence of global scope for `static' or `auto'. */
4746 = !(storage_class == csc_static || storage_class == csc_auto);
4748 /* For a function definition, record the argument information
4749 block where store_parm_decls will look for it. */
4751 current_function_arg_info = arg_info;
4753 if (declspecs->default_int_p)
4754 C_FUNCTION_IMPLICIT_INT (decl) = 1;
4756 /* Record presence of `inline', if it is reasonable. */
4757 if (flag_hosted && MAIN_NAME_P (declarator->u.id))
4759 if (declspecs->inline_p)
4760 pedwarn ("cannot inline function %<main%>");
4762 else if (declspecs->inline_p)
4764 /* Record that the function is declared `inline'. */
4765 DECL_DECLARED_INLINE_P (decl) = 1;
4767 /* Do not mark bare declarations as DECL_INLINE. Doing so
4768 in the presence of multiple declarations can result in
4769 the abstract origin pointing between the declarations,
4770 which will confuse dwarf2out. */
4773 DECL_INLINE (decl) = 1;
4774 if (storage_class == csc_extern)
4775 current_extern_inline = 1;
4778 /* If -finline-functions, assume it can be inlined. This does
4779 two things: let the function be deferred until it is actually
4780 needed, and let dwarf2 know that the function is inlinable. */
4781 else if (flag_inline_trees == 2 && initialized)
4782 DECL_INLINE (decl) = 1;
4786 /* It's a variable. */
4787 /* An uninitialized decl with `extern' is a reference. */
4788 int extern_ref = !initialized && storage_class == csc_extern;
4790 type = c_build_qualified_type (type, type_quals);
4792 /* C99 6.2.2p7: It is invalid (compile-time undefined
4793 behavior) to create an 'extern' declaration for a
4794 variable if there is a global declaration that is
4795 'static' and the global declaration is not visible.
4796 (If the static declaration _is_ currently visible,
4797 the 'extern' declaration is taken to refer to that decl.) */
4798 if (extern_ref && current_scope != file_scope)
4800 tree global_decl = identifier_global_value (declarator->u.id);
4801 tree visible_decl = lookup_name (declarator->u.id);
4804 && global_decl != visible_decl
4805 && TREE_CODE (global_decl) == VAR_DECL
4806 && !TREE_PUBLIC (global_decl))
4807 error ("variable previously declared %<static%> redeclared "
4811 decl = build_decl (VAR_DECL, declarator->u.id, type);
4812 DECL_SOURCE_LOCATION (decl) = declarator->id_loc;
4814 C_DECL_VARIABLE_SIZE (decl) = 1;
4816 if (declspecs->inline_p)
4817 pedwarn ("variable %q+D declared %<inline%>", decl);
4819 /* At file scope, an initialized extern declaration may follow
4820 a static declaration. In that case, DECL_EXTERNAL will be
4821 reset later in start_decl. */
4822 DECL_EXTERNAL (decl) = (storage_class == csc_extern);
4824 /* At file scope, the presence of a `static' or `register' storage
4825 class specifier, or the absence of all storage class specifiers
4826 makes this declaration a definition (perhaps tentative). Also,
4827 the absence of `static' makes it public. */
4828 if (current_scope == file_scope)
4830 TREE_PUBLIC (decl) = storage_class != csc_static;
4831 TREE_STATIC (decl) = !extern_ref;
4833 /* Not at file scope, only `static' makes a static definition. */
4836 TREE_STATIC (decl) = (storage_class == csc_static);
4837 TREE_PUBLIC (decl) = extern_ref;
4842 if (targetm.have_tls)
4843 DECL_TLS_MODEL (decl) = decl_default_tls_model (decl);
4845 /* A mere warning is sure to result in improper semantics
4846 at runtime. Don't bother to allow this to compile. */
4847 error ("thread-local storage not supported for this target");
4851 if (storage_class == csc_extern
4852 && variably_modified_type_p (type, NULL_TREE))
4855 error ("object with variably modified type must have no linkage");
4858 /* Record `register' declaration for warnings on &
4859 and in case doing stupid register allocation. */
4861 if (storage_class == csc_register)
4863 C_DECL_REGISTER (decl) = 1;
4864 DECL_REGISTER (decl) = 1;
4867 /* Record constancy and volatility. */
4868 c_apply_type_quals_to_decl (type_quals, decl);
4870 /* If a type has volatile components, it should be stored in memory.
4871 Otherwise, the fact that those components are volatile
4872 will be ignored, and would even crash the compiler.
4873 Of course, this only makes sense on VAR,PARM, and RESULT decl's. */
4874 if (C_TYPE_FIELDS_VOLATILE (TREE_TYPE (decl))
4875 && (TREE_CODE (decl) == VAR_DECL || TREE_CODE (decl) == PARM_DECL
4876 || TREE_CODE (decl) == RESULT_DECL))
4878 /* It is not an error for a structure with volatile fields to
4879 be declared register, but reset DECL_REGISTER since it
4880 cannot actually go in a register. */
4881 int was_reg = C_DECL_REGISTER (decl);
4882 C_DECL_REGISTER (decl) = 0;
4883 DECL_REGISTER (decl) = 0;
4884 c_mark_addressable (decl);
4885 C_DECL_REGISTER (decl) = was_reg;
4888 /* This is the earliest point at which we might know the assembler
4889 name of a variable. Thus, if it's known before this, die horribly. */
4890 gcc_assert (!DECL_ASSEMBLER_NAME_SET_P (decl));
4892 decl_attributes (&decl, returned_attrs, 0);
4898 /* Decode the parameter-list info for a function type or function definition.
4899 The argument is the value returned by `get_parm_info' (or made in c-parse.c
4900 if there is an identifier list instead of a parameter decl list).
4901 These two functions are separate because when a function returns
4902 or receives functions then each is called multiple times but the order
4903 of calls is different. The last call to `grokparms' is always the one
4904 that contains the formal parameter names of a function definition.
4906 Return a list of arg types to use in the FUNCTION_TYPE for this function.
4908 FUNCDEF_FLAG is true for a function definition, false for
4909 a mere declaration. A nonempty identifier-list gets an error message
4910 when FUNCDEF_FLAG is false. */
4913 grokparms (struct c_arg_info *arg_info, bool funcdef_flag)
4915 tree arg_types = arg_info->types;
4917 if (funcdef_flag && arg_info->had_vla_unspec)
4919 /* A function definition isn't function prototype scope C99 6.2.1p4. */
4921 error ("%<[*]%> not allowed in other than function prototype scope");
4924 if (arg_types == 0 && !funcdef_flag && !in_system_header)
4925 warning (OPT_Wstrict_prototypes,
4926 "function declaration isn%'t a prototype");
4928 if (arg_types == error_mark_node)
4929 return 0; /* don't set TYPE_ARG_TYPES in this case */
4931 else if (arg_types && TREE_CODE (TREE_VALUE (arg_types)) == IDENTIFIER_NODE)
4934 pedwarn ("parameter names (without types) in function declaration");
4936 arg_info->parms = arg_info->types;
4937 arg_info->types = 0;
4942 tree parm, type, typelt;
4943 unsigned int parmno;
4945 /* If there is a parameter of incomplete type in a definition,
4946 this is an error. In a declaration this is valid, and a
4947 struct or union type may be completed later, before any calls
4948 or definition of the function. In the case where the tag was
4949 first declared within the parameter list, a warning has
4950 already been given. If a parameter has void type, then
4951 however the function cannot be defined or called, so
4954 for (parm = arg_info->parms, typelt = arg_types, parmno = 1;
4956 parm = TREE_CHAIN (parm), typelt = TREE_CHAIN (typelt), parmno++)
4958 type = TREE_VALUE (typelt);
4959 if (type == error_mark_node)
4962 if (!COMPLETE_TYPE_P (type))
4966 if (DECL_NAME (parm))
4967 error ("parameter %u (%q+D) has incomplete type",
4970 error ("%Jparameter %u has incomplete type",
4973 TREE_VALUE (typelt) = error_mark_node;
4974 TREE_TYPE (parm) = error_mark_node;
4976 else if (VOID_TYPE_P (type))
4978 if (DECL_NAME (parm))
4979 warning (0, "parameter %u (%q+D) has void type",
4982 warning (0, "%Jparameter %u has void type",
4987 if (DECL_NAME (parm) && TREE_USED (parm))
4988 warn_if_shadowing (parm);
4994 /* Take apart the current scope and return a c_arg_info structure with
4995 info on a parameter list just parsed.
4997 This structure is later fed to 'grokparms' and 'store_parm_decls'.
4999 ELLIPSIS being true means the argument list ended in '...' so don't
5000 append a sentinel (void_list_node) to the end of the type-list. */
5003 get_parm_info (bool ellipsis)
5005 struct c_binding *b = current_scope->bindings;
5006 struct c_arg_info *arg_info = XOBNEW (&parser_obstack,
5013 static bool explained_incomplete_types = false;
5014 bool gave_void_only_once_err = false;
5016 arg_info->parms = 0;
5018 arg_info->types = 0;
5019 arg_info->others = 0;
5020 arg_info->pending_sizes = 0;
5021 arg_info->had_vla_unspec = current_scope->had_vla_unspec;
5023 /* The bindings in this scope must not get put into a block.
5024 We will take care of deleting the binding nodes. */
5025 current_scope->bindings = 0;
5027 /* This function is only called if there was *something* on the
5031 /* A parameter list consisting solely of 'void' indicates that the
5032 function takes no arguments. But if the 'void' is qualified
5033 (by 'const' or 'volatile'), or has a storage class specifier
5034 ('register'), then the behavior is undefined; issue an error.
5035 Typedefs for 'void' are OK (see DR#157). */
5036 if (b->prev == 0 /* one binding */
5037 && TREE_CODE (b->decl) == PARM_DECL /* which is a parameter */
5038 && !DECL_NAME (b->decl) /* anonymous */
5039 && VOID_TYPE_P (TREE_TYPE (b->decl))) /* of void type */
5041 if (TREE_THIS_VOLATILE (b->decl)
5042 || TREE_READONLY (b->decl)
5043 || C_DECL_REGISTER (b->decl))
5044 error ("%<void%> as only parameter may not be qualified");
5046 /* There cannot be an ellipsis. */
5048 error ("%<void%> must be the only parameter");
5050 arg_info->types = void_list_node;
5055 types = void_list_node;
5057 /* Break up the bindings list into parms, tags, types, and others;
5058 apply sanity checks; purge the name-to-decl bindings. */
5061 tree decl = b->decl;
5062 tree type = TREE_TYPE (decl);
5063 const char *keyword;
5065 switch (TREE_CODE (decl))
5070 gcc_assert (I_SYMBOL_BINDING (b->id) == b);
5071 I_SYMBOL_BINDING (b->id) = b->shadowed;
5074 /* Check for forward decls that never got their actual decl. */
5075 if (TREE_ASM_WRITTEN (decl))
5076 error ("parameter %q+D has just a forward declaration", decl);
5077 /* Check for (..., void, ...) and issue an error. */
5078 else if (VOID_TYPE_P (type) && !DECL_NAME (decl))
5080 if (!gave_void_only_once_err)
5082 error ("%<void%> must be the only parameter");
5083 gave_void_only_once_err = true;
5088 /* Valid parameter, add it to the list. */
5089 TREE_CHAIN (decl) = parms;
5092 /* Since there is a prototype, args are passed in their
5093 declared types. The back end may override this later. */
5094 DECL_ARG_TYPE (decl) = type;
5095 types = tree_cons (0, type, types);
5099 case ENUMERAL_TYPE: keyword = "enum"; goto tag;
5100 case UNION_TYPE: keyword = "union"; goto tag;
5101 case RECORD_TYPE: keyword = "struct"; goto tag;
5103 /* Types may not have tag-names, in which case the type
5104 appears in the bindings list with b->id NULL. */
5107 gcc_assert (I_TAG_BINDING (b->id) == b);
5108 I_TAG_BINDING (b->id) = b->shadowed;
5111 /* Warn about any struct, union or enum tags defined in a
5112 parameter list. The scope of such types is limited to
5113 the parameter list, which is rarely if ever desirable
5114 (it's impossible to call such a function with type-
5115 correct arguments). An anonymous union parm type is
5116 meaningful as a GNU extension, so don't warn for that. */
5117 if (TREE_CODE (decl) != UNION_TYPE || b->id != 0)
5120 /* The %s will be one of 'struct', 'union', or 'enum'. */
5121 warning (0, "%<%s %E%> declared inside parameter list",
5124 /* The %s will be one of 'struct', 'union', or 'enum'. */
5125 warning (0, "anonymous %s declared inside parameter list",
5128 if (!explained_incomplete_types)
5130 warning (0, "its scope is only this definition or declaration,"
5131 " which is probably not what you want");
5132 explained_incomplete_types = true;
5136 tags = tree_cons (b->id, decl, tags);
5142 /* CONST_DECLs appear here when we have an embedded enum,
5143 and TYPE_DECLs appear here when we have an embedded struct
5144 or union. No warnings for this - we already warned about the
5145 type itself. FUNCTION_DECLs appear when there is an implicit
5146 function declaration in the parameter list. */
5148 TREE_CHAIN (decl) = others;
5153 /* error_mark_node appears here when we have an undeclared
5154 variable. Just throw it away. */
5157 gcc_assert (I_SYMBOL_BINDING (b->id) == b);
5158 I_SYMBOL_BINDING (b->id) = b->shadowed;
5162 /* Other things that might be encountered. */
5169 b = free_binding_and_advance (b);
5172 arg_info->parms = parms;
5173 arg_info->tags = tags;
5174 arg_info->types = types;
5175 arg_info->others = others;
5176 arg_info->pending_sizes = get_pending_sizes ();
5180 /* Get the struct, enum or union (CODE says which) with tag NAME.
5181 Define the tag as a forward-reference if it is not defined.
5182 Return a c_typespec structure for the type specifier. */
5185 parser_xref_tag (enum tree_code code, tree name)
5187 struct c_typespec ret;
5188 /* If a cross reference is requested, look up the type
5189 already defined for this tag and return it. */
5191 tree ref = lookup_tag (code, name, 0);
5192 /* If this is the right type of tag, return what we found.
5193 (This reference will be shadowed by shadow_tag later if appropriate.)
5194 If this is the wrong type of tag, do not return it. If it was the
5195 wrong type in the same scope, we will have had an error
5196 message already; if in a different scope and declaring
5197 a name, pending_xref_error will give an error message; but if in a
5198 different scope and not declaring a name, this tag should
5199 shadow the previous declaration of a different type of tag, and
5200 this would not work properly if we return the reference found.
5201 (For example, with "struct foo" in an outer scope, "union foo;"
5202 must shadow that tag with a new one of union type.) */
5203 ret.kind = (ref ? ctsk_tagref : ctsk_tagfirstref);
5204 if (ref && TREE_CODE (ref) == code)
5210 /* If no such tag is yet defined, create a forward-reference node
5211 and record it as the "definition".
5212 When a real declaration of this type is found,
5213 the forward-reference will be altered into a real type. */
5215 ref = make_node (code);
5216 if (code == ENUMERAL_TYPE)
5218 /* Give the type a default layout like unsigned int
5219 to avoid crashing if it does not get defined. */
5220 TYPE_MODE (ref) = TYPE_MODE (unsigned_type_node);
5221 TYPE_ALIGN (ref) = TYPE_ALIGN (unsigned_type_node);
5222 TYPE_USER_ALIGN (ref) = 0;
5223 TYPE_UNSIGNED (ref) = 1;
5224 TYPE_PRECISION (ref) = TYPE_PRECISION (unsigned_type_node);
5225 TYPE_MIN_VALUE (ref) = TYPE_MIN_VALUE (unsigned_type_node);
5226 TYPE_MAX_VALUE (ref) = TYPE_MAX_VALUE (unsigned_type_node);
5229 pushtag (name, ref);
5235 /* Get the struct, enum or union (CODE says which) with tag NAME.
5236 Define the tag as a forward-reference if it is not defined.
5237 Return a tree for the type. */
5240 xref_tag (enum tree_code code, tree name)
5242 return parser_xref_tag (code, name).spec;
5245 /* Make sure that the tag NAME is defined *in the current scope*
5246 at least as a forward reference.
5247 CODE says which kind of tag NAME ought to be. */
5250 start_struct (enum tree_code code, tree name)
5252 /* If there is already a tag defined at this scope
5253 (as a forward reference), just return it. */
5258 ref = lookup_tag (code, name, 1);
5259 if (ref && TREE_CODE (ref) == code)
5261 if (TYPE_SIZE (ref))
5263 if (code == UNION_TYPE)
5264 error ("redefinition of %<union %E%>", name);
5266 error ("redefinition of %<struct %E%>", name);
5268 else if (C_TYPE_BEING_DEFINED (ref))
5270 if (code == UNION_TYPE)
5271 error ("nested redefinition of %<union %E%>", name);
5273 error ("nested redefinition of %<struct %E%>", name);
5278 /* Otherwise create a forward-reference just so the tag is in scope. */
5280 ref = make_node (code);
5281 pushtag (name, ref);
5284 C_TYPE_BEING_DEFINED (ref) = 1;
5285 TYPE_PACKED (ref) = flag_pack_struct;
5289 /* Process the specs, declarator and width (NULL if omitted)
5290 of a structure component, returning a FIELD_DECL node.
5291 WIDTH is non-NULL for bit-fields only, and is an INTEGER_CST node.
5293 This is done during the parsing of the struct declaration.
5294 The FIELD_DECL nodes are chained together and the lot of them
5295 are ultimately passed to `build_struct' to make the RECORD_TYPE node. */
5298 grokfield (struct c_declarator *declarator, struct c_declspecs *declspecs,
5303 if (declarator->kind == cdk_id && declarator->u.id == NULL_TREE
5304 && width == NULL_TREE)
5306 /* This is an unnamed decl.
5308 If we have something of the form "union { list } ;" then this
5309 is the anonymous union extension. Similarly for struct.
5311 If this is something of the form "struct foo;", then
5312 If MS extensions are enabled, this is handled as an
5314 Otherwise this is a forward declaration of a structure tag.
5316 If this is something of the form "foo;" and foo is a TYPE_DECL, then
5317 If MS extensions are enabled and foo names a structure, then
5318 again this is an anonymous struct.
5319 Otherwise this is an error.
5321 Oh what a horrid tangled web we weave. I wonder if MS consciously
5322 took this from Plan 9 or if it was an accident of implementation
5323 that took root before someone noticed the bug... */
5325 tree type = declspecs->type;
5326 bool type_ok = (TREE_CODE (type) == RECORD_TYPE
5327 || TREE_CODE (type) == UNION_TYPE);
5331 && (flag_ms_extensions || !declspecs->typedef_p))
5333 if (flag_ms_extensions)
5337 else if (TYPE_NAME (type) == NULL)
5344 pedwarn ("declaration does not declare anything");
5348 pedwarn ("ISO C doesn%'t support unnamed structs/unions");
5351 value = grokdeclarator (declarator, declspecs, FIELD, false,
5352 width ? &width : NULL);
5354 finish_decl (value, NULL_TREE, NULL_TREE);
5355 DECL_INITIAL (value) = width;
5360 /* Generate an error for any duplicate field names in FIELDLIST. Munge
5361 the list such that this does not present a problem later. */
5364 detect_field_duplicates (tree fieldlist)
5369 /* First, see if there are more than "a few" fields.
5370 This is trivially true if there are zero or one fields. */
5373 x = TREE_CHAIN (fieldlist);
5379 } while (timeout > 0 && x);
5381 /* If there were "few" fields, avoid the overhead of allocating
5382 a hash table. Instead just do the nested traversal thing. */
5385 for (x = TREE_CHAIN (fieldlist); x ; x = TREE_CHAIN (x))
5388 for (y = fieldlist; y != x; y = TREE_CHAIN (y))
5389 if (DECL_NAME (y) == DECL_NAME (x))
5391 error ("duplicate member %q+D", x);
5392 DECL_NAME (x) = NULL_TREE;
5398 htab_t htab = htab_create (37, htab_hash_pointer, htab_eq_pointer, NULL);
5401 for (x = fieldlist; x ; x = TREE_CHAIN (x))
5402 if ((y = DECL_NAME (x)) != 0)
5404 slot = htab_find_slot (htab, y, INSERT);
5407 error ("duplicate member %q+D", x);
5408 DECL_NAME (x) = NULL_TREE;
5417 /* Fill in the fields of a RECORD_TYPE or UNION_TYPE node, T.
5418 FIELDLIST is a chain of FIELD_DECL nodes for the fields.
5419 ATTRIBUTES are attributes to be applied to the structure. */
5422 finish_struct (tree t, tree fieldlist, tree attributes)
5425 bool toplevel = file_scope == current_scope;
5426 int saw_named_field;
5428 /* If this type was previously laid out as a forward reference,
5429 make sure we lay it out again. */
5433 decl_attributes (&t, attributes, (int) ATTR_FLAG_TYPE_IN_PLACE);
5437 for (x = fieldlist; x; x = TREE_CHAIN (x))
5438 if (DECL_NAME (x) != 0)
5443 if (TREE_CODE (t) == UNION_TYPE)
5446 pedwarn ("union has no named members");
5448 pedwarn ("union has no members");
5453 pedwarn ("struct has no named members");
5455 pedwarn ("struct has no members");
5460 /* Install struct as DECL_CONTEXT of each field decl.
5461 Also process specified field sizes, found in the DECL_INITIAL,
5462 storing 0 there after the type has been changed to precision equal
5463 to its width, rather than the precision of the specified standard
5464 type. (Correct layout requires the original type to have been preserved
5467 saw_named_field = 0;
5468 for (x = fieldlist; x; x = TREE_CHAIN (x))
5470 if (TREE_TYPE (x) == error_mark_node)
5473 DECL_CONTEXT (x) = t;
5475 if (TYPE_PACKED (t) && TYPE_ALIGN (TREE_TYPE (x)) > BITS_PER_UNIT)
5476 DECL_PACKED (x) = 1;
5478 /* If any field is const, the structure type is pseudo-const. */
5479 if (TREE_READONLY (x))
5480 C_TYPE_FIELDS_READONLY (t) = 1;
5483 /* A field that is pseudo-const makes the structure likewise. */
5484 tree t1 = TREE_TYPE (x);
5485 while (TREE_CODE (t1) == ARRAY_TYPE)
5486 t1 = TREE_TYPE (t1);
5487 if ((TREE_CODE (t1) == RECORD_TYPE || TREE_CODE (t1) == UNION_TYPE)
5488 && C_TYPE_FIELDS_READONLY (t1))
5489 C_TYPE_FIELDS_READONLY (t) = 1;
5492 /* Any field that is volatile means variables of this type must be
5493 treated in some ways as volatile. */
5494 if (TREE_THIS_VOLATILE (x))
5495 C_TYPE_FIELDS_VOLATILE (t) = 1;
5497 /* Any field of nominal variable size implies structure is too. */
5498 if (C_DECL_VARIABLE_SIZE (x))
5499 C_TYPE_VARIABLE_SIZE (t) = 1;
5501 if (DECL_INITIAL (x))
5503 unsigned HOST_WIDE_INT width = tree_low_cst (DECL_INITIAL (x), 1);
5504 DECL_SIZE (x) = bitsize_int (width);
5505 DECL_BIT_FIELD (x) = 1;
5506 SET_DECL_C_BIT_FIELD (x);
5509 /* Detect flexible array member in an invalid context. */
5510 if (TREE_CODE (TREE_TYPE (x)) == ARRAY_TYPE
5511 && TYPE_SIZE (TREE_TYPE (x)) == NULL_TREE
5512 && TYPE_DOMAIN (TREE_TYPE (x)) != NULL_TREE
5513 && TYPE_MAX_VALUE (TYPE_DOMAIN (TREE_TYPE (x))) == NULL_TREE)
5515 if (TREE_CODE (t) == UNION_TYPE)
5517 error ("%Jflexible array member in union", x);
5518 TREE_TYPE (x) = error_mark_node;
5520 else if (TREE_CHAIN (x) != NULL_TREE)
5522 error ("%Jflexible array member not at end of struct", x);
5523 TREE_TYPE (x) = error_mark_node;
5525 else if (!saw_named_field)
5527 error ("%Jflexible array member in otherwise empty struct", x);
5528 TREE_TYPE (x) = error_mark_node;
5532 if (pedantic && !in_system_header && TREE_CODE (t) == RECORD_TYPE
5533 && flexible_array_type_p (TREE_TYPE (x)))
5534 pedwarn ("%Jinvalid use of structure with flexible array member", x);
5537 saw_named_field = 1;
5540 detect_field_duplicates (fieldlist);
5542 /* Now we have the nearly final fieldlist. Record it,
5543 then lay out the structure or union (including the fields). */
5545 TYPE_FIELDS (t) = fieldlist;
5549 /* Give bit-fields their proper types. */
5551 tree *fieldlistp = &fieldlist;
5553 if (TREE_CODE (*fieldlistp) == FIELD_DECL && DECL_INITIAL (*fieldlistp)
5554 && TREE_TYPE (*fieldlistp) != error_mark_node)
5556 unsigned HOST_WIDE_INT width
5557 = tree_low_cst (DECL_INITIAL (*fieldlistp), 1);
5558 tree type = TREE_TYPE (*fieldlistp);
5559 if (width != TYPE_PRECISION (type))
5561 TREE_TYPE (*fieldlistp)
5562 = c_build_bitfield_integer_type (width, TYPE_UNSIGNED (type));
5563 DECL_MODE (*fieldlistp) = TYPE_MODE (TREE_TYPE (*fieldlistp));
5565 DECL_INITIAL (*fieldlistp) = 0;
5568 fieldlistp = &TREE_CHAIN (*fieldlistp);
5571 /* Now we have the truly final field list.
5572 Store it in this type and in the variants. */
5574 TYPE_FIELDS (t) = fieldlist;
5576 /* If there are lots of fields, sort so we can look through them fast.
5577 We arbitrarily consider 16 or more elts to be "a lot". */
5582 for (x = fieldlist; x; x = TREE_CHAIN (x))
5584 if (len > 15 || DECL_NAME (x) == NULL)
5592 struct lang_type *space;
5593 struct sorted_fields_type *space2;
5595 len += list_length (x);
5597 /* Use the same allocation policy here that make_node uses, to
5598 ensure that this lives as long as the rest of the struct decl.
5599 All decls in an inline function need to be saved. */
5601 space = GGC_CNEW (struct lang_type);
5602 space2 = GGC_NEWVAR (struct sorted_fields_type,
5603 sizeof (struct sorted_fields_type) + len * sizeof (tree));
5607 field_array = &space2->elts[0];
5608 for (x = fieldlist; x; x = TREE_CHAIN (x))
5610 field_array[len++] = x;
5612 /* If there is anonymous struct or union, break out of the loop. */
5613 if (DECL_NAME (x) == NULL)
5616 /* Found no anonymous struct/union. Add the TYPE_LANG_SPECIFIC. */
5619 TYPE_LANG_SPECIFIC (t) = space;
5620 TYPE_LANG_SPECIFIC (t)->s->len = len;
5621 field_array = TYPE_LANG_SPECIFIC (t)->s->elts;
5622 qsort (field_array, len, sizeof (tree), field_decl_cmp);
5627 for (x = TYPE_MAIN_VARIANT (t); x; x = TYPE_NEXT_VARIANT (x))
5629 TYPE_FIELDS (x) = TYPE_FIELDS (t);
5630 TYPE_LANG_SPECIFIC (x) = TYPE_LANG_SPECIFIC (t);
5631 C_TYPE_FIELDS_READONLY (x) = C_TYPE_FIELDS_READONLY (t);
5632 C_TYPE_FIELDS_VOLATILE (x) = C_TYPE_FIELDS_VOLATILE (t);
5633 C_TYPE_VARIABLE_SIZE (x) = C_TYPE_VARIABLE_SIZE (t);
5636 /* If this was supposed to be a transparent union, but we can't
5637 make it one, warn and turn off the flag. */
5638 if (TREE_CODE (t) == UNION_TYPE
5639 && TYPE_TRANSPARENT_UNION (t)
5640 && (!TYPE_FIELDS (t) || TYPE_MODE (t) != DECL_MODE (TYPE_FIELDS (t))))
5642 TYPE_TRANSPARENT_UNION (t) = 0;
5643 warning (0, "union cannot be made transparent");
5646 /* If this structure or union completes the type of any previous
5647 variable declaration, lay it out and output its rtl. */
5648 for (x = C_TYPE_INCOMPLETE_VARS (TYPE_MAIN_VARIANT (t));
5652 tree decl = TREE_VALUE (x);
5653 if (TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE)
5654 layout_array_type (TREE_TYPE (decl));
5655 if (TREE_CODE (decl) != TYPE_DECL)
5657 layout_decl (decl, 0);
5658 if (c_dialect_objc ())
5659 objc_check_decl (decl);
5660 rest_of_decl_compilation (decl, toplevel, 0);
5665 C_TYPE_INCOMPLETE_VARS (TYPE_MAIN_VARIANT (t)) = 0;
5667 /* Finish debugging output for this type. */
5668 rest_of_type_compilation (t, toplevel);
5670 /* If we're inside a function proper, i.e. not file-scope and not still
5671 parsing parameters, then arrange for the size of a variable sized type
5673 if (cur_stmt_list && variably_modified_type_p (t, NULL_TREE))
5674 add_stmt (build_stmt (DECL_EXPR, build_decl (TYPE_DECL, NULL, t)));
5679 /* Lay out the type T, and its element type, and so on. */
5682 layout_array_type (tree t)
5684 if (TREE_CODE (TREE_TYPE (t)) == ARRAY_TYPE)
5685 layout_array_type (TREE_TYPE (t));
5689 /* Begin compiling the definition of an enumeration type.
5690 NAME is its name (or null if anonymous).
5691 Returns the type object, as yet incomplete.
5692 Also records info about it so that build_enumerator
5693 may be used to declare the individual values as they are read. */
5696 start_enum (tree name)
5700 /* If this is the real definition for a previous forward reference,
5701 fill in the contents in the same object that used to be the
5702 forward reference. */
5705 enumtype = lookup_tag (ENUMERAL_TYPE, name, 1);
5707 if (enumtype == 0 || TREE_CODE (enumtype) != ENUMERAL_TYPE)
5709 enumtype = make_node (ENUMERAL_TYPE);
5710 pushtag (name, enumtype);
5713 if (C_TYPE_BEING_DEFINED (enumtype))
5714 error ("nested redefinition of %<enum %E%>", name);
5716 C_TYPE_BEING_DEFINED (enumtype) = 1;
5718 if (TYPE_VALUES (enumtype) != 0)
5720 /* This enum is a named one that has been declared already. */
5721 error ("redeclaration of %<enum %E%>", name);
5723 /* Completely replace its old definition.
5724 The old enumerators remain defined, however. */
5725 TYPE_VALUES (enumtype) = 0;
5728 enum_next_value = integer_zero_node;
5731 if (flag_short_enums)
5732 TYPE_PACKED (enumtype) = 1;
5737 /* After processing and defining all the values of an enumeration type,
5738 install their decls in the enumeration type and finish it off.
5739 ENUMTYPE is the type object, VALUES a list of decl-value pairs,
5740 and ATTRIBUTES are the specified attributes.
5741 Returns ENUMTYPE. */
5744 finish_enum (tree enumtype, tree values, tree attributes)
5747 tree minnode = 0, maxnode = 0;
5748 int precision, unsign;
5749 bool toplevel = (file_scope == current_scope);
5750 struct lang_type *lt;
5752 decl_attributes (&enumtype, attributes, (int) ATTR_FLAG_TYPE_IN_PLACE);
5754 /* Calculate the maximum value of any enumerator in this type. */
5756 if (values == error_mark_node)
5757 minnode = maxnode = integer_zero_node;
5760 minnode = maxnode = TREE_VALUE (values);
5761 for (pair = TREE_CHAIN (values); pair; pair = TREE_CHAIN (pair))
5763 tree value = TREE_VALUE (pair);
5764 if (tree_int_cst_lt (maxnode, value))
5766 if (tree_int_cst_lt (value, minnode))
5771 /* Construct the final type of this enumeration. It is the same
5772 as one of the integral types - the narrowest one that fits, except
5773 that normally we only go as narrow as int - and signed iff any of
5774 the values are negative. */
5775 unsign = (tree_int_cst_sgn (minnode) >= 0);
5776 precision = MAX (min_precision (minnode, unsign),
5777 min_precision (maxnode, unsign));
5779 if (TYPE_PACKED (enumtype) || precision > TYPE_PRECISION (integer_type_node))
5781 tem = c_common_type_for_size (precision, unsign);
5784 warning (0, "enumeration values exceed range of largest integer");
5785 tem = long_long_integer_type_node;
5789 tem = unsign ? unsigned_type_node : integer_type_node;
5791 TYPE_MIN_VALUE (enumtype) = TYPE_MIN_VALUE (tem);
5792 TYPE_MAX_VALUE (enumtype) = TYPE_MAX_VALUE (tem);
5793 TYPE_UNSIGNED (enumtype) = TYPE_UNSIGNED (tem);
5794 TYPE_SIZE (enumtype) = 0;
5796 /* If the precision of the type was specific with an attribute and it
5797 was too small, give an error. Otherwise, use it. */
5798 if (TYPE_PRECISION (enumtype))
5800 if (precision > TYPE_PRECISION (enumtype))
5801 error ("specified mode too small for enumeral values");
5804 TYPE_PRECISION (enumtype) = TYPE_PRECISION (tem);
5806 layout_type (enumtype);
5808 if (values != error_mark_node)
5810 /* Change the type of the enumerators to be the enum type. We
5811 need to do this irrespective of the size of the enum, for
5812 proper type checking. Replace the DECL_INITIALs of the
5813 enumerators, and the value slots of the list, with copies
5814 that have the enum type; they cannot be modified in place
5815 because they may be shared (e.g. integer_zero_node) Finally,
5816 change the purpose slots to point to the names of the decls. */
5817 for (pair = values; pair; pair = TREE_CHAIN (pair))
5819 tree enu = TREE_PURPOSE (pair);
5820 tree ini = DECL_INITIAL (enu);
5822 TREE_TYPE (enu) = enumtype;
5824 /* The ISO C Standard mandates enumerators to have type int,
5825 even though the underlying type of an enum type is
5826 unspecified. Here we convert any enumerators that fit in
5827 an int to type int, to avoid promotions to unsigned types
5828 when comparing integers with enumerators that fit in the
5829 int range. When -pedantic is given, build_enumerator()
5830 would have already taken care of those that don't fit. */
5831 if (int_fits_type_p (ini, integer_type_node))
5832 tem = integer_type_node;
5835 ini = convert (tem, ini);
5837 DECL_INITIAL (enu) = ini;
5838 TREE_PURPOSE (pair) = DECL_NAME (enu);
5839 TREE_VALUE (pair) = ini;
5842 TYPE_VALUES (enumtype) = values;
5845 /* Record the min/max values so that we can warn about bit-field
5846 enumerations that are too small for the values. */
5847 lt = GGC_CNEW (struct lang_type);
5848 lt->enum_min = minnode;
5849 lt->enum_max = maxnode;
5850 TYPE_LANG_SPECIFIC (enumtype) = lt;
5852 /* Fix up all variant types of this enum type. */
5853 for (tem = TYPE_MAIN_VARIANT (enumtype); tem; tem = TYPE_NEXT_VARIANT (tem))
5855 if (tem == enumtype)
5857 TYPE_VALUES (tem) = TYPE_VALUES (enumtype);
5858 TYPE_MIN_VALUE (tem) = TYPE_MIN_VALUE (enumtype);
5859 TYPE_MAX_VALUE (tem) = TYPE_MAX_VALUE (enumtype);
5860 TYPE_SIZE (tem) = TYPE_SIZE (enumtype);
5861 TYPE_SIZE_UNIT (tem) = TYPE_SIZE_UNIT (enumtype);
5862 TYPE_MODE (tem) = TYPE_MODE (enumtype);
5863 TYPE_PRECISION (tem) = TYPE_PRECISION (enumtype);
5864 TYPE_ALIGN (tem) = TYPE_ALIGN (enumtype);
5865 TYPE_USER_ALIGN (tem) = TYPE_USER_ALIGN (enumtype);
5866 TYPE_UNSIGNED (tem) = TYPE_UNSIGNED (enumtype);
5867 TYPE_LANG_SPECIFIC (tem) = TYPE_LANG_SPECIFIC (enumtype);
5870 /* Finish debugging output for this type. */
5871 rest_of_type_compilation (enumtype, toplevel);
5876 /* Build and install a CONST_DECL for one value of the
5877 current enumeration type (one that was begun with start_enum).
5878 Return a tree-list containing the CONST_DECL and its value.
5879 Assignment of sequential values by default is handled here. */
5882 build_enumerator (tree name, tree value)
5886 /* Validate and default VALUE. */
5890 /* Don't issue more errors for error_mark_node (i.e. an
5891 undeclared identifier) - just ignore the value expression. */
5892 if (value == error_mark_node)
5894 else if (!INTEGRAL_TYPE_P (TREE_TYPE (value))
5895 || TREE_CODE (value) != INTEGER_CST)
5897 error ("enumerator value for %qE is not an integer constant", name);
5902 value = default_conversion (value);
5903 constant_expression_warning (value);
5907 /* Default based on previous value. */
5908 /* It should no longer be possible to have NON_LVALUE_EXPR
5912 value = enum_next_value;
5914 error ("overflow in enumeration values");
5917 if (pedantic && !int_fits_type_p (value, integer_type_node))
5919 pedwarn ("ISO C restricts enumerator values to range of %<int%>");
5920 /* XXX This causes -pedantic to change the meaning of the program.
5921 Remove? -zw 2004-03-15 */
5922 value = convert (integer_type_node, value);
5925 /* Set basis for default for next value. */
5926 enum_next_value = build_binary_op (PLUS_EXPR, value, integer_one_node, 0);
5927 enum_overflow = tree_int_cst_lt (enum_next_value, value);
5929 /* Now create a declaration for the enum value name. */
5931 type = TREE_TYPE (value);
5932 type = c_common_type_for_size (MAX (TYPE_PRECISION (type),
5933 TYPE_PRECISION (integer_type_node)),
5934 (TYPE_PRECISION (type)
5935 >= TYPE_PRECISION (integer_type_node)
5936 && TYPE_UNSIGNED (type)));
5938 decl = build_decl (CONST_DECL, name, type);
5939 DECL_INITIAL (decl) = convert (type, value);
5942 return tree_cons (decl, value, NULL_TREE);
5946 /* Create the FUNCTION_DECL for a function definition.
5947 DECLSPECS, DECLARATOR and ATTRIBUTES are the parts of
5948 the declaration; they describe the function's name and the type it returns,
5949 but twisted together in a fashion that parallels the syntax of C.
5951 This function creates a binding context for the function body
5952 as well as setting up the FUNCTION_DECL in current_function_decl.
5954 Returns 1 on success. If the DECLARATOR is not suitable for a function
5955 (it defines a datum instead), we return 0, which tells
5956 yyparse to report a parse error. */
5959 start_function (struct c_declspecs *declspecs, struct c_declarator *declarator,
5962 tree decl1, old_decl;
5963 tree restype, resdecl;
5964 struct c_label_context_se *nstack_se;
5965 struct c_label_context_vm *nstack_vm;
5967 current_function_returns_value = 0; /* Assume, until we see it does. */
5968 current_function_returns_null = 0;
5969 current_function_returns_abnormally = 0;
5970 warn_about_return_type = 0;
5971 current_extern_inline = 0;
5972 c_switch_stack = NULL;
5974 nstack_se = XOBNEW (&parser_obstack, struct c_label_context_se);
5975 nstack_se->labels_def = NULL;
5976 nstack_se->labels_used = NULL;
5977 nstack_se->next = label_context_stack_se;
5978 label_context_stack_se = nstack_se;
5980 nstack_vm = XOBNEW (&parser_obstack, struct c_label_context_vm);
5981 nstack_vm->labels_def = NULL;
5982 nstack_vm->labels_used = NULL;
5983 nstack_vm->scope = 0;
5984 nstack_vm->next = label_context_stack_vm;
5985 label_context_stack_vm = nstack_vm;
5987 /* Indicate no valid break/continue context by setting these variables
5988 to some non-null, non-label value. We'll notice and emit the proper
5989 error message in c_finish_bc_stmt. */
5990 c_break_label = c_cont_label = size_zero_node;
5992 decl1 = grokdeclarator (declarator, declspecs, FUNCDEF, true, NULL);
5994 /* If the declarator is not suitable for a function definition,
5995 cause a syntax error. */
5998 label_context_stack_se = label_context_stack_se->next;
5999 label_context_stack_vm = label_context_stack_vm->next;
6003 decl_attributes (&decl1, attributes, 0);
6005 if (DECL_DECLARED_INLINE_P (decl1)
6006 && DECL_UNINLINABLE (decl1)
6007 && lookup_attribute ("noinline", DECL_ATTRIBUTES (decl1)))
6008 warning (OPT_Wattributes, "inline function %q+D given attribute noinline",
6011 announce_function (decl1);
6013 if (!COMPLETE_OR_VOID_TYPE_P (TREE_TYPE (TREE_TYPE (decl1))))
6015 error ("return type is an incomplete type");
6016 /* Make it return void instead. */
6018 = build_function_type (void_type_node,
6019 TYPE_ARG_TYPES (TREE_TYPE (decl1)));
6022 if (warn_about_return_type)
6023 pedwarn_c99 ("return type defaults to %<int%>");
6025 /* Make the init_value nonzero so pushdecl knows this is not tentative.
6026 error_mark_node is replaced below (in pop_scope) with the BLOCK. */
6027 DECL_INITIAL (decl1) = error_mark_node;
6029 /* If this definition isn't a prototype and we had a prototype declaration
6030 before, copy the arg type info from that prototype. */
6031 old_decl = lookup_name_in_scope (DECL_NAME (decl1), current_scope);
6032 if (old_decl && TREE_CODE (old_decl) != FUNCTION_DECL)
6034 current_function_prototype_locus = UNKNOWN_LOCATION;
6035 current_function_prototype_built_in = false;
6036 current_function_prototype_arg_types = NULL_TREE;
6037 if (TYPE_ARG_TYPES (TREE_TYPE (decl1)) == 0)
6039 if (old_decl != 0 && TREE_CODE (TREE_TYPE (old_decl)) == FUNCTION_TYPE
6040 && comptypes (TREE_TYPE (TREE_TYPE (decl1)),
6041 TREE_TYPE (TREE_TYPE (old_decl))))
6043 TREE_TYPE (decl1) = composite_type (TREE_TYPE (old_decl),
6045 current_function_prototype_locus = DECL_SOURCE_LOCATION (old_decl);
6046 current_function_prototype_built_in
6047 = C_DECL_BUILTIN_PROTOTYPE (old_decl);
6048 current_function_prototype_arg_types
6049 = TYPE_ARG_TYPES (TREE_TYPE (decl1));
6051 if (TREE_PUBLIC (decl1))
6053 /* If there is an external prototype declaration of this
6054 function, record its location but do not copy information
6055 to this decl. This may be an invisible declaration
6056 (built-in or in a scope which has finished) or simply
6057 have more refined argument types than any declaration
6059 struct c_binding *b;
6060 for (b = I_SYMBOL_BINDING (DECL_NAME (decl1)); b; b = b->shadowed)
6061 if (B_IN_SCOPE (b, external_scope))
6065 tree ext_decl, ext_type;
6067 ext_type = b->type ? b->type : TREE_TYPE (ext_decl);
6068 if (TREE_CODE (ext_type) == FUNCTION_TYPE
6069 && comptypes (TREE_TYPE (TREE_TYPE (decl1)),
6070 TREE_TYPE (ext_type)))
6072 current_function_prototype_locus
6073 = DECL_SOURCE_LOCATION (ext_decl);
6074 current_function_prototype_built_in
6075 = C_DECL_BUILTIN_PROTOTYPE (ext_decl);
6076 current_function_prototype_arg_types
6077 = TYPE_ARG_TYPES (ext_type);
6083 /* Optionally warn of old-fashioned def with no previous prototype. */
6084 if (warn_strict_prototypes
6085 && old_decl != error_mark_node
6086 && TYPE_ARG_TYPES (TREE_TYPE (decl1)) == 0
6087 && C_DECL_ISNT_PROTOTYPE (old_decl))
6088 warning (OPT_Wstrict_prototypes,
6089 "function declaration isn%'t a prototype");
6090 /* Optionally warn of any global def with no previous prototype. */
6091 else if (warn_missing_prototypes
6092 && old_decl != error_mark_node
6093 && TREE_PUBLIC (decl1)
6094 && !MAIN_NAME_P (DECL_NAME (decl1))
6095 && C_DECL_ISNT_PROTOTYPE (old_decl))
6096 warning (OPT_Wmissing_prototypes, "no previous prototype for %q+D", decl1);
6097 /* Optionally warn of any def with no previous prototype
6098 if the function has already been used. */
6099 else if (warn_missing_prototypes
6101 && old_decl != error_mark_node
6102 && TREE_USED (old_decl)
6103 && TYPE_ARG_TYPES (TREE_TYPE (old_decl)) == 0)
6104 warning (OPT_Wmissing_prototypes,
6105 "%q+D was used with no prototype before its definition", decl1);
6106 /* Optionally warn of any global def with no previous declaration. */
6107 else if (warn_missing_declarations
6108 && TREE_PUBLIC (decl1)
6110 && !MAIN_NAME_P (DECL_NAME (decl1)))
6111 warning (OPT_Wmissing_declarations, "no previous declaration for %q+D",
6113 /* Optionally warn of any def with no previous declaration
6114 if the function has already been used. */
6115 else if (warn_missing_declarations
6117 && old_decl != error_mark_node
6118 && TREE_USED (old_decl)
6119 && C_DECL_IMPLICIT (old_decl))
6120 warning (OPT_Wmissing_declarations,
6121 "%q+D was used with no declaration before its definition", decl1);
6123 /* This is a definition, not a reference.
6124 So normally clear DECL_EXTERNAL.
6125 However, `extern inline' acts like a declaration
6126 except for defining how to inline. So set DECL_EXTERNAL in that case. */
6127 DECL_EXTERNAL (decl1) = current_extern_inline;
6129 /* This function exists in static storage.
6130 (This does not mean `static' in the C sense!) */
6131 TREE_STATIC (decl1) = 1;
6133 /* A nested function is not global. */
6134 if (current_function_decl != 0)
6135 TREE_PUBLIC (decl1) = 0;
6137 /* This is the earliest point at which we might know the assembler
6138 name of the function. Thus, if it's set before this, die horribly. */
6139 gcc_assert (!DECL_ASSEMBLER_NAME_SET_P (decl1));
6141 /* If #pragma weak was used, mark the decl weak now. */
6142 if (current_scope == file_scope)
6143 maybe_apply_pragma_weak (decl1);
6145 /* Warn for unlikely, improbable, or stupid declarations of `main'. */
6146 if (warn_main > 0 && MAIN_NAME_P (DECL_NAME (decl1)))
6151 if (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (decl1)))
6152 != integer_type_node)
6153 pedwarn ("return type of %q+D is not %<int%>", decl1);
6155 for (args = TYPE_ARG_TYPES (TREE_TYPE (decl1)); args;
6156 args = TREE_CHAIN (args))
6158 tree type = args ? TREE_VALUE (args) : 0;
6160 if (type == void_type_node)
6167 if (TYPE_MAIN_VARIANT (type) != integer_type_node)
6168 pedwarn ("first argument of %q+D should be %<int%>", decl1);
6172 if (TREE_CODE (type) != POINTER_TYPE
6173 || TREE_CODE (TREE_TYPE (type)) != POINTER_TYPE
6174 || (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (type)))
6176 pedwarn ("second argument of %q+D should be %<char **%>",
6181 if (TREE_CODE (type) != POINTER_TYPE
6182 || TREE_CODE (TREE_TYPE (type)) != POINTER_TYPE
6183 || (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (type)))
6185 pedwarn ("third argument of %q+D should probably be "
6186 "%<char **%>", decl1);
6191 /* It is intentional that this message does not mention the third
6192 argument because it's only mentioned in an appendix of the
6194 if (argct > 0 && (argct < 2 || argct > 3))
6195 pedwarn ("%q+D takes only zero or two arguments", decl1);
6197 if (!TREE_PUBLIC (decl1))
6198 pedwarn ("%q+D is normally a non-static function", decl1);
6201 /* Record the decl so that the function name is defined.
6202 If we already have a decl for this name, and it is a FUNCTION_DECL,
6203 use the old decl. */
6205 current_function_decl = pushdecl (decl1);
6208 declare_parm_level ();
6210 restype = TREE_TYPE (TREE_TYPE (current_function_decl));
6211 /* Promote the value to int before returning it. */
6212 if (c_promoting_integer_type_p (restype))
6214 /* It retains unsignedness if not really getting wider. */
6215 if (TYPE_UNSIGNED (restype)
6216 && (TYPE_PRECISION (restype)
6217 == TYPE_PRECISION (integer_type_node)))
6218 restype = unsigned_type_node;
6220 restype = integer_type_node;
6223 resdecl = build_decl (RESULT_DECL, NULL_TREE, restype);
6224 DECL_ARTIFICIAL (resdecl) = 1;
6225 DECL_IGNORED_P (resdecl) = 1;
6226 DECL_RESULT (current_function_decl) = resdecl;
6228 start_fname_decls ();
6233 /* Subroutine of store_parm_decls which handles new-style function
6234 definitions (prototype format). The parms already have decls, so we
6235 need only record them as in effect and complain if any redundant
6236 old-style parm decls were written. */
6238 store_parm_decls_newstyle (tree fndecl, const struct c_arg_info *arg_info)
6242 if (current_scope->bindings)
6244 error ("%Jold-style parameter declarations in prototyped "
6245 "function definition", fndecl);
6247 /* Get rid of the old-style declarations. */
6251 /* Don't issue this warning for nested functions, and don't issue this
6252 warning if we got here because ARG_INFO_TYPES was error_mark_node
6253 (this happens when a function definition has just an ellipsis in
6254 its parameter list). */
6255 else if (!in_system_header && !current_function_scope
6256 && arg_info->types != error_mark_node)
6257 warning (OPT_Wtraditional,
6258 "%Jtraditional C rejects ISO C style function definitions",
6261 /* Now make all the parameter declarations visible in the function body.
6262 We can bypass most of the grunt work of pushdecl. */
6263 for (decl = arg_info->parms; decl; decl = TREE_CHAIN (decl))
6265 DECL_CONTEXT (decl) = current_function_decl;
6266 if (DECL_NAME (decl))
6268 bind (DECL_NAME (decl), decl, current_scope,
6269 /*invisible=*/false, /*nested=*/false);
6270 if (!TREE_USED (decl))
6271 warn_if_shadowing (decl);
6274 error ("%Jparameter name omitted", decl);
6277 /* Record the parameter list in the function declaration. */
6278 DECL_ARGUMENTS (fndecl) = arg_info->parms;
6280 /* Now make all the ancillary declarations visible, likewise. */
6281 for (decl = arg_info->others; decl; decl = TREE_CHAIN (decl))
6283 DECL_CONTEXT (decl) = current_function_decl;
6284 if (DECL_NAME (decl))
6285 bind (DECL_NAME (decl), decl, current_scope,
6286 /*invisible=*/false, /*nested=*/false);
6289 /* And all the tag declarations. */
6290 for (decl = arg_info->tags; decl; decl = TREE_CHAIN (decl))
6291 if (TREE_PURPOSE (decl))
6292 bind (TREE_PURPOSE (decl), TREE_VALUE (decl), current_scope,
6293 /*invisible=*/false, /*nested=*/false);
6296 /* Subroutine of store_parm_decls which handles old-style function
6297 definitions (separate parameter list and declarations). */
6300 store_parm_decls_oldstyle (tree fndecl, const struct c_arg_info *arg_info)
6302 struct c_binding *b;
6303 tree parm, decl, last;
6304 tree parmids = arg_info->parms;
6305 struct pointer_set_t *seen_args = pointer_set_create ();
6307 if (!in_system_header)
6308 warning (OPT_Wold_style_definition, "%Jold-style function definition",
6311 /* Match each formal parameter name with its declaration. Save each
6312 decl in the appropriate TREE_PURPOSE slot of the parmids chain. */
6313 for (parm = parmids; parm; parm = TREE_CHAIN (parm))
6315 if (TREE_VALUE (parm) == 0)
6317 error ("%Jparameter name missing from parameter list", fndecl);
6318 TREE_PURPOSE (parm) = 0;
6322 b = I_SYMBOL_BINDING (TREE_VALUE (parm));
6323 if (b && B_IN_CURRENT_SCOPE (b))
6326 /* If we got something other than a PARM_DECL it is an error. */
6327 if (TREE_CODE (decl) != PARM_DECL)
6328 error ("%q+D declared as a non-parameter", decl);
6329 /* If the declaration is already marked, we have a duplicate
6330 name. Complain and ignore the duplicate. */
6331 else if (pointer_set_contains (seen_args, decl))
6333 error ("multiple parameters named %q+D", decl);
6334 TREE_PURPOSE (parm) = 0;
6337 /* If the declaration says "void", complain and turn it into
6339 else if (VOID_TYPE_P (TREE_TYPE (decl)))
6341 error ("parameter %q+D declared with void type", decl);
6342 TREE_TYPE (decl) = integer_type_node;
6343 DECL_ARG_TYPE (decl) = integer_type_node;
6344 layout_decl (decl, 0);
6346 warn_if_shadowing (decl);
6348 /* If no declaration found, default to int. */
6351 decl = build_decl (PARM_DECL, TREE_VALUE (parm), integer_type_node);
6352 DECL_ARG_TYPE (decl) = TREE_TYPE (decl);
6353 DECL_SOURCE_LOCATION (decl) = DECL_SOURCE_LOCATION (fndecl);
6355 warn_if_shadowing (decl);
6358 pedwarn ("type of %q+D defaults to %<int%>", decl);
6359 else if (extra_warnings)
6360 warning (OPT_Wextra, "type of %q+D defaults to %<int%>", decl);
6363 TREE_PURPOSE (parm) = decl;
6364 pointer_set_insert (seen_args, decl);
6367 /* Now examine the parms chain for incomplete declarations
6368 and declarations with no corresponding names. */
6370 for (b = current_scope->bindings; b; b = b->prev)
6373 if (TREE_CODE (parm) != PARM_DECL)
6376 if (TREE_TYPE (parm) != error_mark_node
6377 && !COMPLETE_TYPE_P (TREE_TYPE (parm)))
6379 error ("parameter %q+D has incomplete type", parm);
6380 TREE_TYPE (parm) = error_mark_node;
6383 if (!pointer_set_contains (seen_args, parm))
6385 error ("declaration for parameter %q+D but no such parameter", parm);
6387 /* Pretend the parameter was not missing.
6388 This gets us to a standard state and minimizes
6389 further error messages. */
6390 parmids = chainon (parmids, tree_cons (parm, 0, 0));
6394 /* Chain the declarations together in the order of the list of
6395 names. Store that chain in the function decl, replacing the
6396 list of names. Update the current scope to match. */
6397 DECL_ARGUMENTS (fndecl) = 0;
6399 for (parm = parmids; parm; parm = TREE_CHAIN (parm))
6400 if (TREE_PURPOSE (parm))
6402 if (parm && TREE_PURPOSE (parm))
6404 last = TREE_PURPOSE (parm);
6405 DECL_ARGUMENTS (fndecl) = last;
6407 for (parm = TREE_CHAIN (parm); parm; parm = TREE_CHAIN (parm))
6408 if (TREE_PURPOSE (parm))
6410 TREE_CHAIN (last) = TREE_PURPOSE (parm);
6411 last = TREE_PURPOSE (parm);
6413 TREE_CHAIN (last) = 0;
6416 pointer_set_destroy (seen_args);
6418 /* If there was a previous prototype,
6419 set the DECL_ARG_TYPE of each argument according to
6420 the type previously specified, and report any mismatches. */
6422 if (current_function_prototype_arg_types)
6425 for (parm = DECL_ARGUMENTS (fndecl),
6426 type = current_function_prototype_arg_types;
6427 parm || (type && (TYPE_MAIN_VARIANT (TREE_VALUE (type))
6428 != void_type_node));
6429 parm = TREE_CHAIN (parm), type = TREE_CHAIN (type))
6431 if (parm == 0 || type == 0
6432 || TYPE_MAIN_VARIANT (TREE_VALUE (type)) == void_type_node)
6434 if (current_function_prototype_built_in)
6435 warning (0, "number of arguments doesn%'t match "
6436 "built-in prototype");
6439 error ("number of arguments doesn%'t match prototype");
6440 error ("%Hprototype declaration",
6441 ¤t_function_prototype_locus);
6445 /* Type for passing arg must be consistent with that
6446 declared for the arg. ISO C says we take the unqualified
6447 type for parameters declared with qualified type. */
6448 if (!comptypes (TYPE_MAIN_VARIANT (DECL_ARG_TYPE (parm)),
6449 TYPE_MAIN_VARIANT (TREE_VALUE (type))))
6451 if (TYPE_MAIN_VARIANT (TREE_TYPE (parm))
6452 == TYPE_MAIN_VARIANT (TREE_VALUE (type)))
6454 /* Adjust argument to match prototype. E.g. a previous
6455 `int foo(float);' prototype causes
6456 `int foo(x) float x; {...}' to be treated like
6457 `int foo(float x) {...}'. This is particularly
6458 useful for argument types like uid_t. */
6459 DECL_ARG_TYPE (parm) = TREE_TYPE (parm);
6461 if (targetm.calls.promote_prototypes (TREE_TYPE (current_function_decl))
6462 && INTEGRAL_TYPE_P (TREE_TYPE (parm))
6463 && TYPE_PRECISION (TREE_TYPE (parm))
6464 < TYPE_PRECISION (integer_type_node))
6465 DECL_ARG_TYPE (parm) = integer_type_node;
6469 /* ??? Is it possible to get here with a
6470 built-in prototype or will it always have
6471 been diagnosed as conflicting with an
6472 old-style definition and discarded? */
6473 if (current_function_prototype_built_in)
6474 warning (0, "promoted argument %qD "
6475 "doesn%'t match built-in prototype", parm);
6478 pedwarn ("promoted argument %qD "
6479 "doesn%'t match prototype", parm);
6480 pedwarn ("%Hprototype declaration",
6481 ¤t_function_prototype_locus);
6487 if (current_function_prototype_built_in)
6488 warning (0, "argument %qD doesn%'t match "
6489 "built-in prototype", parm);
6492 error ("argument %qD doesn%'t match prototype", parm);
6493 error ("%Hprototype declaration",
6494 ¤t_function_prototype_locus);
6499 TYPE_ACTUAL_ARG_TYPES (TREE_TYPE (fndecl)) = 0;
6502 /* Otherwise, create a prototype that would match. */
6506 tree actual = 0, last = 0, type;
6508 for (parm = DECL_ARGUMENTS (fndecl); parm; parm = TREE_CHAIN (parm))
6510 type = tree_cons (NULL_TREE, DECL_ARG_TYPE (parm), NULL_TREE);
6512 TREE_CHAIN (last) = type;
6517 type = tree_cons (NULL_TREE, void_type_node, NULL_TREE);
6519 TREE_CHAIN (last) = type;
6523 /* We are going to assign a new value for the TYPE_ACTUAL_ARG_TYPES
6524 of the type of this function, but we need to avoid having this
6525 affect the types of other similarly-typed functions, so we must
6526 first force the generation of an identical (but separate) type
6527 node for the relevant function type. The new node we create
6528 will be a variant of the main variant of the original function
6531 TREE_TYPE (fndecl) = build_variant_type_copy (TREE_TYPE (fndecl));
6533 TYPE_ACTUAL_ARG_TYPES (TREE_TYPE (fndecl)) = actual;
6537 /* Store parameter declarations passed in ARG_INFO into the current
6538 function declaration. */
6541 store_parm_decls_from (struct c_arg_info *arg_info)
6543 current_function_arg_info = arg_info;
6544 store_parm_decls ();
6547 /* Store the parameter declarations into the current function declaration.
6548 This is called after parsing the parameter declarations, before
6549 digesting the body of the function.
6551 For an old-style definition, construct a prototype out of the old-style
6552 parameter declarations and inject it into the function's type. */
6555 store_parm_decls (void)
6557 tree fndecl = current_function_decl;
6560 /* The argument information block for FNDECL. */
6561 struct c_arg_info *arg_info = current_function_arg_info;
6562 current_function_arg_info = 0;
6564 /* True if this definition is written with a prototype. Note:
6565 despite C99 6.7.5.3p14, we can *not* treat an empty argument
6566 list in a function definition as equivalent to (void) -- an
6567 empty argument list specifies the function has no parameters,
6568 but only (void) sets up a prototype for future calls. */
6569 proto = arg_info->types != 0;
6572 store_parm_decls_newstyle (fndecl, arg_info);
6574 store_parm_decls_oldstyle (fndecl, arg_info);
6576 /* The next call to push_scope will be a function body. */
6578 next_is_function_body = true;
6580 /* Write a record describing this function definition to the prototypes
6581 file (if requested). */
6583 gen_aux_info_record (fndecl, 1, 0, proto);
6585 /* Initialize the RTL code for the function. */
6586 allocate_struct_function (fndecl);
6588 /* Begin the statement tree for this function. */
6589 DECL_SAVED_TREE (fndecl) = push_stmt_list ();
6591 /* ??? Insert the contents of the pending sizes list into the function
6592 to be evaluated. The only reason left to have this is
6593 void foo(int n, int array[n++])
6594 because we throw away the array type in favor of a pointer type, and
6595 thus won't naturally see the SAVE_EXPR containing the increment. All
6596 other pending sizes would be handled by gimplify_parameters. */
6599 for (t = nreverse (get_pending_sizes ()); t ; t = TREE_CHAIN (t))
6600 add_stmt (TREE_VALUE (t));
6603 /* Even though we're inside a function body, we still don't want to
6604 call expand_expr to calculate the size of a variable-sized array.
6605 We haven't necessarily assigned RTL to all variables yet, so it's
6606 not safe to try to expand expressions involving them. */
6607 cfun->x_dont_save_pending_sizes_p = 1;
6610 /* Emit diagnostics that require gimple input for detection. Operate on
6611 FNDECL and all its nested functions. */
6614 c_gimple_diagnostics_recursively (tree fndecl)
6616 struct cgraph_node *cgn;
6618 /* Handle attribute((warn_unused_result)). Relies on gimple input. */
6619 c_warn_unused_result (&DECL_SAVED_TREE (fndecl));
6621 /* Notice when OpenMP structured block constraints are violated. */
6623 diagnose_omp_structured_block_errors (fndecl);
6625 /* Finalize all nested functions now. */
6626 cgn = cgraph_node (fndecl);
6627 for (cgn = cgn->nested; cgn ; cgn = cgn->next_nested)
6628 c_gimple_diagnostics_recursively (cgn->decl);
6631 /* Finish up a function declaration and compile that function
6632 all the way to assembler language output. The free the storage
6633 for the function definition.
6635 This is called after parsing the body of the function definition. */
6638 finish_function (void)
6640 tree fndecl = current_function_decl;
6642 label_context_stack_se = label_context_stack_se->next;
6643 label_context_stack_vm = label_context_stack_vm->next;
6645 if (TREE_CODE (fndecl) == FUNCTION_DECL
6646 && targetm.calls.promote_prototypes (TREE_TYPE (fndecl)))
6648 tree args = DECL_ARGUMENTS (fndecl);
6649 for (; args; args = TREE_CHAIN (args))
6651 tree type = TREE_TYPE (args);
6652 if (INTEGRAL_TYPE_P (type)
6653 && TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node))
6654 DECL_ARG_TYPE (args) = integer_type_node;
6658 if (DECL_INITIAL (fndecl) && DECL_INITIAL (fndecl) != error_mark_node)
6659 BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl)) = fndecl;
6661 /* Must mark the RESULT_DECL as being in this function. */
6663 if (DECL_RESULT (fndecl) && DECL_RESULT (fndecl) != error_mark_node)
6664 DECL_CONTEXT (DECL_RESULT (fndecl)) = fndecl;
6666 if (MAIN_NAME_P (DECL_NAME (fndecl)) && flag_hosted)
6668 if (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (fndecl)))
6669 != integer_type_node)
6671 /* If warn_main is 1 (-Wmain) or 2 (-Wall), we have already warned.
6672 If warn_main is -1 (-Wno-main) we don't want to be warned. */
6674 pedwarn ("return type of %q+D is not %<int%>", fndecl);
6680 tree stmt = c_finish_return (integer_zero_node);
6681 #ifdef USE_MAPPED_LOCATION
6682 /* Hack. We don't want the middle-end to warn that this return
6683 is unreachable, so we mark its location as special. Using
6684 UNKNOWN_LOCATION has the problem that it gets clobbered in
6685 annotate_one_with_locus. A cleaner solution might be to
6686 ensure ! should_carry_locus_p (stmt), but that needs a flag.
6688 SET_EXPR_LOCATION (stmt, BUILTINS_LOCATION);
6690 /* Hack. We don't want the middle-end to warn that this
6691 return is unreachable, so put the statement on the
6693 annotate_with_file_line (stmt, input_filename, 0);
6699 /* Tie off the statement tree for this function. */
6700 DECL_SAVED_TREE (fndecl) = pop_stmt_list (DECL_SAVED_TREE (fndecl));
6702 finish_fname_decls ();
6704 /* Complain if there's just no return statement. */
6705 if (warn_return_type
6706 && TREE_CODE (TREE_TYPE (TREE_TYPE (fndecl))) != VOID_TYPE
6707 && !current_function_returns_value && !current_function_returns_null
6708 /* Don't complain if we are no-return. */
6709 && !current_function_returns_abnormally
6710 /* Don't warn for main(). */
6711 && !MAIN_NAME_P (DECL_NAME (fndecl))
6712 /* Or if they didn't actually specify a return type. */
6713 && !C_FUNCTION_IMPLICIT_INT (fndecl)
6714 /* Normally, with -Wreturn-type, flow will complain. Unless we're an
6715 inline function, as we might never be compiled separately. */
6716 && DECL_INLINE (fndecl))
6718 warning (OPT_Wreturn_type,
6719 "no return statement in function returning non-void");
6720 TREE_NO_WARNING (fndecl) = 1;
6723 /* With just -Wextra, complain only if function returns both with
6724 and without a value. */
6726 && current_function_returns_value
6727 && current_function_returns_null)
6728 warning (OPT_Wextra, "this function may return with or without a value");
6730 /* Store the end of the function, so that we get good line number
6731 info for the epilogue. */
6732 cfun->function_end_locus = input_location;
6734 /* If we don't have ctors/dtors sections, and this is a static
6735 constructor or destructor, it must be recorded now. */
6736 if (DECL_STATIC_CONSTRUCTOR (fndecl)
6737 && !targetm.have_ctors_dtors)
6738 static_ctors = tree_cons (NULL_TREE, fndecl, static_ctors);
6739 if (DECL_STATIC_DESTRUCTOR (fndecl)
6740 && !targetm.have_ctors_dtors)
6741 static_dtors = tree_cons (NULL_TREE, fndecl, static_dtors);
6743 /* Finalize the ELF visibility for the function. */
6744 c_determine_visibility (fndecl);
6746 /* Genericize before inlining. Delay genericizing nested functions
6747 until their parent function is genericized. Since finalizing
6748 requires GENERIC, delay that as well. */
6750 if (DECL_INITIAL (fndecl) && DECL_INITIAL (fndecl) != error_mark_node
6751 && !undef_nested_function)
6753 if (!decl_function_context (fndecl))
6755 c_genericize (fndecl);
6756 c_gimple_diagnostics_recursively (fndecl);
6758 /* ??? Objc emits functions after finalizing the compilation unit.
6759 This should be cleaned up later and this conditional removed. */
6760 if (cgraph_global_info_ready)
6762 c_expand_body (fndecl);
6766 cgraph_finalize_function (fndecl, false);
6770 /* Register this function with cgraph just far enough to get it
6771 added to our parent's nested function list. Handy, since the
6772 C front end doesn't have such a list. */
6773 (void) cgraph_node (fndecl);
6777 if (!decl_function_context (fndecl))
6778 undef_nested_function = false;
6780 /* We're leaving the context of this function, so zap cfun.
6781 It's still in DECL_STRUCT_FUNCTION, and we'll restore it in
6782 tree_rest_of_compilation. */
6784 current_function_decl = NULL;
6787 /* Generate the RTL for the body of FNDECL. */
6790 c_expand_body (tree fndecl)
6793 if (!DECL_INITIAL (fndecl)
6794 || DECL_INITIAL (fndecl) == error_mark_node)
6797 tree_rest_of_compilation (fndecl);
6799 if (DECL_STATIC_CONSTRUCTOR (fndecl)
6800 && targetm.have_ctors_dtors)
6801 targetm.asm_out.constructor (XEXP (DECL_RTL (fndecl), 0),
6802 DEFAULT_INIT_PRIORITY);
6803 if (DECL_STATIC_DESTRUCTOR (fndecl)
6804 && targetm.have_ctors_dtors)
6805 targetm.asm_out.destructor (XEXP (DECL_RTL (fndecl), 0),
6806 DEFAULT_INIT_PRIORITY);
6809 /* Check the declarations given in a for-loop for satisfying the C99
6810 constraints. If exactly one such decl is found, return it. */
6813 check_for_loop_decls (void)
6815 struct c_binding *b;
6816 tree one_decl = NULL_TREE;
6822 /* If we get here, declarations have been used in a for loop without
6823 the C99 for loop scope. This doesn't make much sense, so don't
6825 error ("%<for%> loop initial declaration used outside C99 mode");
6828 /* C99 subclause 6.8.5 paragraph 3:
6830 [#3] The declaration part of a for statement shall only
6831 declare identifiers for objects having storage class auto or
6834 It isn't clear whether, in this sentence, "identifiers" binds to
6835 "shall only declare" or to "objects" - that is, whether all identifiers
6836 declared must be identifiers for objects, or whether the restriction
6837 only applies to those that are. (A question on this in comp.std.c
6838 in November 2000 received no answer.) We implement the strictest
6839 interpretation, to avoid creating an extension which later causes
6842 for (b = current_scope->bindings; b; b = b->prev)
6845 tree decl = b->decl;
6850 switch (TREE_CODE (decl))
6853 if (TREE_STATIC (decl))
6854 error ("declaration of static variable %q+D in %<for%> loop "
6855 "initial declaration", decl);
6856 else if (DECL_EXTERNAL (decl))
6857 error ("declaration of %<extern%> variable %q+D in %<for%> loop "
6858 "initial declaration", decl);
6862 error ("%<struct %E%> declared in %<for%> loop initial declaration",
6866 error ("%<union %E%> declared in %<for%> loop initial declaration",
6870 error ("%<enum %E%> declared in %<for%> loop initial declaration",
6874 error ("declaration of non-variable %q+D in %<for%> loop "
6875 "initial declaration", decl);
6882 return n_decls == 1 ? one_decl : NULL_TREE;
6885 /* Save and reinitialize the variables
6886 used during compilation of a C function. */
6889 c_push_function_context (struct function *f)
6891 struct language_function *p;
6892 p = GGC_NEW (struct language_function);
6895 p->base.x_stmt_tree = c_stmt_tree;
6896 p->x_break_label = c_break_label;
6897 p->x_cont_label = c_cont_label;
6898 p->x_switch_stack = c_switch_stack;
6899 p->arg_info = current_function_arg_info;
6900 p->returns_value = current_function_returns_value;
6901 p->returns_null = current_function_returns_null;
6902 p->returns_abnormally = current_function_returns_abnormally;
6903 p->warn_about_return_type = warn_about_return_type;
6904 p->extern_inline = current_extern_inline;
6907 /* Restore the variables used during compilation of a C function. */
6910 c_pop_function_context (struct function *f)
6912 struct language_function *p = f->language;
6914 if (DECL_STRUCT_FUNCTION (current_function_decl) == 0
6915 && DECL_SAVED_TREE (current_function_decl) == NULL_TREE)
6917 /* Stop pointing to the local nodes about to be freed. */
6918 /* But DECL_INITIAL must remain nonzero so we know this
6919 was an actual function definition. */
6920 DECL_INITIAL (current_function_decl) = error_mark_node;
6921 DECL_ARGUMENTS (current_function_decl) = 0;
6924 c_stmt_tree = p->base.x_stmt_tree;
6925 c_break_label = p->x_break_label;
6926 c_cont_label = p->x_cont_label;
6927 c_switch_stack = p->x_switch_stack;
6928 current_function_arg_info = p->arg_info;
6929 current_function_returns_value = p->returns_value;
6930 current_function_returns_null = p->returns_null;
6931 current_function_returns_abnormally = p->returns_abnormally;
6932 warn_about_return_type = p->warn_about_return_type;
6933 current_extern_inline = p->extern_inline;
6938 /* Copy the DECL_LANG_SPECIFIC data associated with DECL. */
6941 c_dup_lang_specific_decl (tree decl)
6943 struct lang_decl *ld;
6945 if (!DECL_LANG_SPECIFIC (decl))
6948 ld = GGC_NEW (struct lang_decl);
6949 memcpy (ld, DECL_LANG_SPECIFIC (decl), sizeof (struct lang_decl));
6950 DECL_LANG_SPECIFIC (decl) = ld;
6953 /* The functions below are required for functionality of doing
6954 function at once processing in the C front end. Currently these
6955 functions are not called from anywhere in the C front end, but as
6956 these changes continue, that will change. */
6958 /* Returns the stmt_tree (if any) to which statements are currently
6959 being added. If there is no active statement-tree, NULL is
6963 current_stmt_tree (void)
6965 return &c_stmt_tree;
6968 /* Nonzero if TYPE is an anonymous union or struct type. Always 0 in
6972 anon_aggr_type_p (tree ARG_UNUSED (node))
6977 /* Return the global value of T as a symbol. */
6980 identifier_global_value (tree t)
6982 struct c_binding *b;
6984 for (b = I_SYMBOL_BINDING (t); b; b = b->shadowed)
6985 if (B_IN_FILE_SCOPE (b) || B_IN_EXTERNAL_SCOPE (b))
6991 /* Record a builtin type for C. If NAME is non-NULL, it is the name used;
6992 otherwise the name is found in ridpointers from RID_INDEX. */
6995 record_builtin_type (enum rid rid_index, const char *name, tree type)
6999 id = ridpointers[(int) rid_index];
7001 id = get_identifier (name);
7002 decl = build_decl (TYPE_DECL, id, type);
7004 if (debug_hooks->type_decl)
7005 debug_hooks->type_decl (decl, false);
7008 /* Build the void_list_node (void_type_node having been created). */
7010 build_void_list_node (void)
7012 tree t = build_tree_list (NULL_TREE, void_type_node);
7016 /* Return a c_parm structure with the given SPECS, ATTRS and DECLARATOR. */
7019 build_c_parm (struct c_declspecs *specs, tree attrs,
7020 struct c_declarator *declarator)
7022 struct c_parm *ret = XOBNEW (&parser_obstack, struct c_parm);
7025 ret->declarator = declarator;
7029 /* Return a declarator with nested attributes. TARGET is the inner
7030 declarator to which these attributes apply. ATTRS are the
7033 struct c_declarator *
7034 build_attrs_declarator (tree attrs, struct c_declarator *target)
7036 struct c_declarator *ret = XOBNEW (&parser_obstack, struct c_declarator);
7037 ret->kind = cdk_attrs;
7038 ret->declarator = target;
7039 ret->u.attrs = attrs;
7043 /* Return a declarator for a function with arguments specified by ARGS
7044 and return type specified by TARGET. */
7046 struct c_declarator *
7047 build_function_declarator (struct c_arg_info *args,
7048 struct c_declarator *target)
7050 struct c_declarator *ret = XOBNEW (&parser_obstack, struct c_declarator);
7051 ret->kind = cdk_function;
7052 ret->declarator = target;
7053 ret->u.arg_info = args;
7057 /* Return a declarator for the identifier IDENT (which may be
7058 NULL_TREE for an abstract declarator). */
7060 struct c_declarator *
7061 build_id_declarator (tree ident)
7063 struct c_declarator *ret = XOBNEW (&parser_obstack, struct c_declarator);
7065 ret->declarator = 0;
7067 /* Default value - may get reset to a more precise location. */
7068 ret->id_loc = input_location;
7072 /* Return something to represent absolute declarators containing a *.
7073 TARGET is the absolute declarator that the * contains.
7074 TYPE_QUALS_ATTRS is a structure for type qualifiers and attributes
7075 to apply to the pointer type. */
7077 struct c_declarator *
7078 make_pointer_declarator (struct c_declspecs *type_quals_attrs,
7079 struct c_declarator *target)
7083 struct c_declarator *itarget = target;
7084 struct c_declarator *ret = XOBNEW (&parser_obstack, struct c_declarator);
7085 if (type_quals_attrs)
7087 attrs = type_quals_attrs->attrs;
7088 quals = quals_from_declspecs (type_quals_attrs);
7089 if (attrs != NULL_TREE)
7090 itarget = build_attrs_declarator (attrs, target);
7092 ret->kind = cdk_pointer;
7093 ret->declarator = itarget;
7094 ret->u.pointer_quals = quals;
7098 /* Return a pointer to a structure for an empty list of declaration
7101 struct c_declspecs *
7102 build_null_declspecs (void)
7104 struct c_declspecs *ret = XOBNEW (&parser_obstack, struct c_declspecs);
7108 ret->typespec_word = cts_none;
7109 ret->storage_class = csc_none;
7110 ret->declspecs_seen_p = false;
7111 ret->type_seen_p = false;
7112 ret->non_sc_seen_p = false;
7113 ret->typedef_p = false;
7114 ret->tag_defined_p = false;
7115 ret->explicit_signed_p = false;
7116 ret->deprecated_p = false;
7117 ret->default_int_p = false;
7118 ret->long_p = false;
7119 ret->long_long_p = false;
7120 ret->short_p = false;
7121 ret->signed_p = false;
7122 ret->unsigned_p = false;
7123 ret->complex_p = false;
7124 ret->inline_p = false;
7125 ret->thread_p = false;
7126 ret->const_p = false;
7127 ret->volatile_p = false;
7128 ret->restrict_p = false;
7132 /* Add the type qualifier QUAL to the declaration specifiers SPECS,
7135 struct c_declspecs *
7136 declspecs_add_qual (struct c_declspecs *specs, tree qual)
7140 specs->non_sc_seen_p = true;
7141 specs->declspecs_seen_p = true;
7142 gcc_assert (TREE_CODE (qual) == IDENTIFIER_NODE
7143 && C_IS_RESERVED_WORD (qual));
7144 i = C_RID_CODE (qual);
7148 dupe = specs->const_p;
7149 specs->const_p = true;
7152 dupe = specs->volatile_p;
7153 specs->volatile_p = true;
7156 dupe = specs->restrict_p;
7157 specs->restrict_p = true;
7162 if (dupe && pedantic && !flag_isoc99)
7163 pedwarn ("duplicate %qE", qual);
7167 /* Add the type specifier TYPE to the declaration specifiers SPECS,
7170 struct c_declspecs *
7171 declspecs_add_type (struct c_declspecs *specs, struct c_typespec spec)
7173 tree type = spec.spec;
7174 specs->non_sc_seen_p = true;
7175 specs->declspecs_seen_p = true;
7176 specs->type_seen_p = true;
7177 if (TREE_DEPRECATED (type))
7178 specs->deprecated_p = true;
7180 /* Handle type specifier keywords. */
7181 if (TREE_CODE (type) == IDENTIFIER_NODE && C_IS_RESERVED_WORD (type))
7183 enum rid i = C_RID_CODE (type);
7186 error ("two or more data types in declaration specifiers");
7189 if ((int) i <= (int) RID_LAST_MODIFIER)
7191 /* "long", "short", "signed", "unsigned" or "_Complex". */
7196 if (specs->long_long_p)
7198 error ("%<long long long%> is too long for GCC");
7203 if (specs->typespec_word == cts_double)
7205 error ("both %<long long%> and %<double%> in "
7206 "declaration specifiers");
7209 if (pedantic && !flag_isoc99 && !in_system_header
7211 pedwarn ("ISO C90 does not support %<long long%>");
7212 specs->long_long_p = 1;
7216 error ("both %<long%> and %<short%> in "
7217 "declaration specifiers");
7218 else if (specs->typespec_word == cts_void)
7219 error ("both %<long%> and %<void%> in "
7220 "declaration specifiers");
7221 else if (specs->typespec_word == cts_bool)
7222 error ("both %<long%> and %<_Bool%> in "
7223 "declaration specifiers");
7224 else if (specs->typespec_word == cts_char)
7225 error ("both %<long%> and %<char%> in "
7226 "declaration specifiers");
7227 else if (specs->typespec_word == cts_float)
7228 error ("both %<long%> and %<float%> in "
7229 "declaration specifiers");
7230 else if (specs->typespec_word == cts_dfloat32)
7231 error ("both %<long%> and %<_Decimal32%> in "
7232 "declaration specifiers");
7233 else if (specs->typespec_word == cts_dfloat64)
7234 error ("both %<long%> and %<_Decimal64%> in "
7235 "declaration specifiers");
7236 else if (specs->typespec_word == cts_dfloat128)
7237 error ("both %<long%> and %<_Decimal128%> in "
7238 "declaration specifiers");
7240 specs->long_p = true;
7243 dupe = specs->short_p;
7245 error ("both %<long%> and %<short%> in "
7246 "declaration specifiers");
7247 else if (specs->typespec_word == cts_void)
7248 error ("both %<short%> and %<void%> in "
7249 "declaration specifiers");
7250 else if (specs->typespec_word == cts_bool)
7251 error ("both %<short%> and %<_Bool%> in "
7252 "declaration specifiers");
7253 else if (specs->typespec_word == cts_char)
7254 error ("both %<short%> and %<char%> in "
7255 "declaration specifiers");
7256 else if (specs->typespec_word == cts_float)
7257 error ("both %<short%> and %<float%> in "
7258 "declaration specifiers");
7259 else if (specs->typespec_word == cts_double)
7260 error ("both %<short%> and %<double%> in "
7261 "declaration specifiers");
7262 else if (specs->typespec_word == cts_dfloat32)
7263 error ("both %<short%> and %<_Decimal32%> in "
7264 "declaration specifiers");
7265 else if (specs->typespec_word == cts_dfloat64)
7266 error ("both %<short%> and %<_Decimal64%> in "
7267 "declaration specifiers");
7268 else if (specs->typespec_word == cts_dfloat128)
7269 error ("both %<short%> and %<_Decimal128%> in "
7270 "declaration specifiers");
7272 specs->short_p = true;
7275 dupe = specs->signed_p;
7276 if (specs->unsigned_p)
7277 error ("both %<signed%> and %<unsigned%> in "
7278 "declaration specifiers");
7279 else if (specs->typespec_word == cts_void)
7280 error ("both %<signed%> and %<void%> in "
7281 "declaration specifiers");
7282 else if (specs->typespec_word == cts_bool)
7283 error ("both %<signed%> and %<_Bool%> in "
7284 "declaration specifiers");
7285 else if (specs->typespec_word == cts_float)
7286 error ("both %<signed%> and %<float%> in "
7287 "declaration specifiers");
7288 else if (specs->typespec_word == cts_double)
7289 error ("both %<signed%> and %<double%> in "
7290 "declaration specifiers");
7291 else if (specs->typespec_word == cts_dfloat32)
7292 error ("both %<signed%> and %<_Decimal32%> in "
7293 "declaration specifiers");
7294 else if (specs->typespec_word == cts_dfloat64)
7295 error ("both %<signed%> and %<_Decimal64%> in "
7296 "declaration specifiers");
7297 else if (specs->typespec_word == cts_dfloat128)
7298 error ("both %<signed%> and %<_Decimal128%> in "
7299 "declaration specifiers");
7301 specs->signed_p = true;
7304 dupe = specs->unsigned_p;
7305 if (specs->signed_p)
7306 error ("both %<signed%> and %<unsigned%> in "
7307 "declaration specifiers");
7308 else if (specs->typespec_word == cts_void)
7309 error ("both %<unsigned%> and %<void%> in "
7310 "declaration specifiers");
7311 else if (specs->typespec_word == cts_bool)
7312 error ("both %<unsigned%> and %<_Bool%> in "
7313 "declaration specifiers");
7314 else if (specs->typespec_word == cts_float)
7315 error ("both %<unsigned%> and %<float%> in "
7316 "declaration specifiers");
7317 else if (specs->typespec_word == cts_double)
7318 error ("both %<unsigned%> and %<double%> in "
7319 "declaration specifiers");
7320 else if (specs->typespec_word == cts_dfloat32)
7321 error ("both %<unsigned%> and %<_Decimal32%> in "
7322 "declaration specifiers");
7323 else if (specs->typespec_word == cts_dfloat64)
7324 error ("both %<unsigned%> and %<_Decimal64%> in "
7325 "declaration specifiers");
7326 else if (specs->typespec_word == cts_dfloat128)
7327 error ("both %<unsigned%> and %<_Decimal128%> in "
7328 "declaration specifiers");
7330 specs->unsigned_p = true;
7333 dupe = specs->complex_p;
7334 if (pedantic && !flag_isoc99 && !in_system_header)
7335 pedwarn ("ISO C90 does not support complex types");
7336 if (specs->typespec_word == cts_void)
7337 error ("both %<complex%> and %<void%> in "
7338 "declaration specifiers");
7339 else if (specs->typespec_word == cts_bool)
7340 error ("both %<complex%> and %<_Bool%> in "
7341 "declaration specifiers");
7342 else if (specs->typespec_word == cts_dfloat32)
7343 error ("both %<complex%> and %<_Decimal32%> in "
7344 "declaration specifiers");
7345 else if (specs->typespec_word == cts_dfloat64)
7346 error ("both %<complex%> and %<_Decimal64%> in "
7347 "declaration specifiers");
7348 else if (specs->typespec_word == cts_dfloat128)
7349 error ("both %<complex%> and %<_Decimal128%> in "
7350 "declaration specifiers");
7352 specs->complex_p = true;
7359 error ("duplicate %qE", type);
7365 /* "void", "_Bool", "char", "int", "float" or "double". */
7366 if (specs->typespec_word != cts_none)
7368 error ("two or more data types in declaration specifiers");
7375 error ("both %<long%> and %<void%> in "
7376 "declaration specifiers");
7377 else if (specs->short_p)
7378 error ("both %<short%> and %<void%> in "
7379 "declaration specifiers");
7380 else if (specs->signed_p)
7381 error ("both %<signed%> and %<void%> in "
7382 "declaration specifiers");
7383 else if (specs->unsigned_p)
7384 error ("both %<unsigned%> and %<void%> in "
7385 "declaration specifiers");
7386 else if (specs->complex_p)
7387 error ("both %<complex%> and %<void%> in "
7388 "declaration specifiers");
7390 specs->typespec_word = cts_void;
7394 error ("both %<long%> and %<_Bool%> in "
7395 "declaration specifiers");
7396 else if (specs->short_p)
7397 error ("both %<short%> and %<_Bool%> in "
7398 "declaration specifiers");
7399 else if (specs->signed_p)
7400 error ("both %<signed%> and %<_Bool%> in "
7401 "declaration specifiers");
7402 else if (specs->unsigned_p)
7403 error ("both %<unsigned%> and %<_Bool%> in "
7404 "declaration specifiers");
7405 else if (specs->complex_p)
7406 error ("both %<complex%> and %<_Bool%> in "
7407 "declaration specifiers");
7409 specs->typespec_word = cts_bool;
7413 error ("both %<long%> and %<char%> in "
7414 "declaration specifiers");
7415 else if (specs->short_p)
7416 error ("both %<short%> and %<char%> in "
7417 "declaration specifiers");
7419 specs->typespec_word = cts_char;
7422 specs->typespec_word = cts_int;
7426 error ("both %<long%> and %<float%> in "
7427 "declaration specifiers");
7428 else if (specs->short_p)
7429 error ("both %<short%> and %<float%> in "
7430 "declaration specifiers");
7431 else if (specs->signed_p)
7432 error ("both %<signed%> and %<float%> in "
7433 "declaration specifiers");
7434 else if (specs->unsigned_p)
7435 error ("both %<unsigned%> and %<float%> in "
7436 "declaration specifiers");
7438 specs->typespec_word = cts_float;
7441 if (specs->long_long_p)
7442 error ("both %<long long%> and %<double%> in "
7443 "declaration specifiers");
7444 else if (specs->short_p)
7445 error ("both %<short%> and %<double%> in "
7446 "declaration specifiers");
7447 else if (specs->signed_p)
7448 error ("both %<signed%> and %<double%> in "
7449 "declaration specifiers");
7450 else if (specs->unsigned_p)
7451 error ("both %<unsigned%> and %<double%> in "
7452 "declaration specifiers");
7454 specs->typespec_word = cts_double;
7461 if (i == RID_DFLOAT32)
7463 else if (i == RID_DFLOAT64)
7466 str = "_Decimal128";
7467 if (specs->long_long_p)
7468 error ("both %<long long%> and %<%s%> in "
7469 "declaration specifiers", str);
7471 error ("both %<long%> and %<%s%> in "
7472 "declaration specifiers", str);
7473 else if (specs->short_p)
7474 error ("both %<short%> and %<%s%> in "
7475 "declaration specifiers", str);
7476 else if (specs->signed_p)
7477 error ("both %<signed%> and %<%s%> in "
7478 "declaration specifiers", str);
7479 else if (specs->unsigned_p)
7480 error ("both %<unsigned%> and %<%s%> in "
7481 "declaration specifiers", str);
7482 else if (specs->complex_p)
7483 error ("both %<complex%> and %<%s%> in "
7484 "declaration specifiers", str);
7485 else if (i == RID_DFLOAT32)
7486 specs->typespec_word = cts_dfloat32;
7487 else if (i == RID_DFLOAT64)
7488 specs->typespec_word = cts_dfloat64;
7490 specs->typespec_word = cts_dfloat128;
7492 if (!targetm.decimal_float_supported_p ())
7493 error ("decimal floating point not supported for this target");
7495 pedwarn ("ISO C does not support decimal floating point");
7498 /* ObjC reserved word "id", handled below. */
7504 /* Now we have a typedef (a TYPE_DECL node), an identifier (some
7505 form of ObjC type, cases such as "int" and "long" being handled
7506 above), a TYPE (struct, union, enum and typeof specifiers) or an
7507 ERROR_MARK. In none of these cases may there have previously
7508 been any type specifiers. */
7509 if (specs->type || specs->typespec_word != cts_none
7510 || specs->long_p || specs->short_p || specs->signed_p
7511 || specs->unsigned_p || specs->complex_p)
7512 error ("two or more data types in declaration specifiers");
7513 else if (TREE_CODE (type) == TYPE_DECL)
7515 if (TREE_TYPE (type) == error_mark_node)
7516 ; /* Allow the type to default to int to avoid cascading errors. */
7519 specs->type = TREE_TYPE (type);
7520 specs->decl_attr = DECL_ATTRIBUTES (type);
7521 specs->typedef_p = true;
7522 specs->explicit_signed_p = C_TYPEDEF_EXPLICITLY_SIGNED (type);
7525 else if (TREE_CODE (type) == IDENTIFIER_NODE)
7527 tree t = lookup_name (type);
7528 if (!t || TREE_CODE (t) != TYPE_DECL)
7529 error ("%qE fails to be a typedef or built in type", type);
7530 else if (TREE_TYPE (t) == error_mark_node)
7533 specs->type = TREE_TYPE (t);
7535 else if (TREE_CODE (type) != ERROR_MARK)
7537 if (spec.kind == ctsk_tagdef || spec.kind == ctsk_tagfirstref)
7538 specs->tag_defined_p = true;
7539 if (spec.kind == ctsk_typeof)
7540 specs->typedef_p = true;
7547 /* Add the storage class specifier or function specifier SCSPEC to the
7548 declaration specifiers SPECS, returning SPECS. */
7550 struct c_declspecs *
7551 declspecs_add_scspec (struct c_declspecs *specs, tree scspec)
7554 enum c_storage_class n = csc_none;
7556 specs->declspecs_seen_p = true;
7557 gcc_assert (TREE_CODE (scspec) == IDENTIFIER_NODE
7558 && C_IS_RESERVED_WORD (scspec));
7559 i = C_RID_CODE (scspec);
7560 if (extra_warnings && specs->non_sc_seen_p)
7561 warning (OPT_Wextra, "%qE is not at beginning of declaration", scspec);
7565 /* C99 permits duplicate inline. Although of doubtful utility,
7566 it seems simplest to permit it in gnu89 mode as well, as
7567 there is also little utility in maintaining this as a
7568 difference between gnu89 and C99 inline. */
7570 specs->inline_p = true;
7573 dupe = specs->thread_p;
7574 if (specs->storage_class == csc_auto)
7575 error ("%<__thread%> used with %<auto%>");
7576 else if (specs->storage_class == csc_register)
7577 error ("%<__thread%> used with %<register%>");
7578 else if (specs->storage_class == csc_typedef)
7579 error ("%<__thread%> used with %<typedef%>");
7581 specs->thread_p = true;
7588 /* Diagnose "__thread extern". */
7589 if (specs->thread_p)
7590 error ("%<__thread%> before %<extern%>");
7597 /* Diagnose "__thread static". */
7598 if (specs->thread_p)
7599 error ("%<__thread%> before %<static%>");
7607 if (n != csc_none && n == specs->storage_class)
7610 error ("duplicate %qE", scspec);
7613 if (specs->storage_class != csc_none && n != specs->storage_class)
7615 error ("multiple storage classes in declaration specifiers");
7619 specs->storage_class = n;
7620 if (n != csc_extern && n != csc_static && specs->thread_p)
7622 error ("%<__thread%> used with %qE", scspec);
7623 specs->thread_p = false;
7630 /* Add the attributes ATTRS to the declaration specifiers SPECS,
7633 struct c_declspecs *
7634 declspecs_add_attrs (struct c_declspecs *specs, tree attrs)
7636 specs->attrs = chainon (attrs, specs->attrs);
7637 specs->declspecs_seen_p = true;
7641 /* Combine "long", "short", "signed", "unsigned" and "_Complex" type
7642 specifiers with any other type specifier to determine the resulting
7643 type. This is where ISO C checks on complex types are made, since
7644 "_Complex long" is a prefix of the valid ISO C type "_Complex long
7647 struct c_declspecs *
7648 finish_declspecs (struct c_declspecs *specs)
7650 /* If a type was specified as a whole, we have no modifiers and are
7652 if (specs->type != NULL_TREE)
7654 gcc_assert (!specs->long_p && !specs->long_long_p && !specs->short_p
7655 && !specs->signed_p && !specs->unsigned_p
7656 && !specs->complex_p);
7660 /* If none of "void", "_Bool", "char", "int", "float" or "double"
7661 has been specified, treat it as "int" unless "_Complex" is
7662 present and there are no other specifiers. If we just have
7663 "_Complex", it is equivalent to "_Complex double", but e.g.
7664 "_Complex short" is equivalent to "_Complex short int". */
7665 if (specs->typespec_word == cts_none)
7667 if (specs->long_p || specs->short_p
7668 || specs->signed_p || specs->unsigned_p)
7670 specs->typespec_word = cts_int;
7672 else if (specs->complex_p)
7674 specs->typespec_word = cts_double;
7676 pedwarn ("ISO C does not support plain %<complex%> meaning "
7677 "%<double complex%>");
7681 specs->typespec_word = cts_int;
7682 specs->default_int_p = true;
7683 /* We don't diagnose this here because grokdeclarator will
7684 give more specific diagnostics according to whether it is
7685 a function definition. */
7689 /* If "signed" was specified, record this to distinguish "int" and
7690 "signed int" in the case of a bit-field with
7691 -funsigned-bitfields. */
7692 specs->explicit_signed_p = specs->signed_p;
7694 /* Now compute the actual type. */
7695 switch (specs->typespec_word)
7698 gcc_assert (!specs->long_p && !specs->short_p
7699 && !specs->signed_p && !specs->unsigned_p
7700 && !specs->complex_p);
7701 specs->type = void_type_node;
7704 gcc_assert (!specs->long_p && !specs->short_p
7705 && !specs->signed_p && !specs->unsigned_p
7706 && !specs->complex_p);
7707 specs->type = boolean_type_node;
7710 gcc_assert (!specs->long_p && !specs->short_p);
7711 gcc_assert (!(specs->signed_p && specs->unsigned_p));
7712 if (specs->signed_p)
7713 specs->type = signed_char_type_node;
7714 else if (specs->unsigned_p)
7715 specs->type = unsigned_char_type_node;
7717 specs->type = char_type_node;
7718 if (specs->complex_p)
7721 pedwarn ("ISO C does not support complex integer types");
7722 specs->type = build_complex_type (specs->type);
7726 gcc_assert (!(specs->long_p && specs->short_p));
7727 gcc_assert (!(specs->signed_p && specs->unsigned_p));
7728 if (specs->long_long_p)
7729 specs->type = (specs->unsigned_p
7730 ? long_long_unsigned_type_node
7731 : long_long_integer_type_node);
7732 else if (specs->long_p)
7733 specs->type = (specs->unsigned_p
7734 ? long_unsigned_type_node
7735 : long_integer_type_node);
7736 else if (specs->short_p)
7737 specs->type = (specs->unsigned_p
7738 ? short_unsigned_type_node
7739 : short_integer_type_node);
7741 specs->type = (specs->unsigned_p
7742 ? unsigned_type_node
7743 : integer_type_node);
7744 if (specs->complex_p)
7747 pedwarn ("ISO C does not support complex integer types");
7748 specs->type = build_complex_type (specs->type);
7752 gcc_assert (!specs->long_p && !specs->short_p
7753 && !specs->signed_p && !specs->unsigned_p);
7754 specs->type = (specs->complex_p
7755 ? complex_float_type_node
7759 gcc_assert (!specs->long_long_p && !specs->short_p
7760 && !specs->signed_p && !specs->unsigned_p);
7763 specs->type = (specs->complex_p
7764 ? complex_long_double_type_node
7765 : long_double_type_node);
7769 specs->type = (specs->complex_p
7770 ? complex_double_type_node
7771 : double_type_node);
7777 gcc_assert (!specs->long_p && !specs->long_long_p && !specs->short_p
7778 && !specs->signed_p && !specs->unsigned_p && !specs->complex_p);
7779 if (specs->typespec_word == cts_dfloat32)
7780 specs->type = dfloat32_type_node;
7781 else if (specs->typespec_word == cts_dfloat64)
7782 specs->type = dfloat64_type_node;
7784 specs->type = dfloat128_type_node;
7793 /* Synthesize a function which calls all the global ctors or global
7794 dtors in this file. This is only used for targets which do not
7795 support .ctors/.dtors sections. FIXME: Migrate into cgraph. */
7797 build_cdtor (int method_type, tree cdtors)
7804 for (; cdtors; cdtors = TREE_CHAIN (cdtors))
7805 append_to_statement_list (build_function_call (TREE_VALUE (cdtors), 0),
7808 cgraph_build_static_cdtor (method_type, body, DEFAULT_INIT_PRIORITY);
7811 /* A subroutine of c_write_global_declarations. Perform final processing
7812 on one file scope's declarations (or the external scope's declarations),
7816 c_write_global_declarations_1 (tree globals)
7821 /* Process the decls in the order they were written. */
7822 for (decl = globals; decl; decl = TREE_CHAIN (decl))
7824 /* Check for used but undefined static functions using the C
7825 standard's definition of "used", and set TREE_NO_WARNING so
7826 that check_global_declarations doesn't repeat the check. */
7827 if (TREE_CODE (decl) == FUNCTION_DECL
7828 && DECL_INITIAL (decl) == 0
7829 && DECL_EXTERNAL (decl)
7830 && !TREE_PUBLIC (decl)
7831 && C_DECL_USED (decl))
7833 pedwarn ("%q+F used but never defined", decl);
7834 TREE_NO_WARNING (decl) = 1;
7837 wrapup_global_declaration_1 (decl);
7843 for (decl = globals; decl; decl = TREE_CHAIN (decl))
7844 reconsider |= wrapup_global_declaration_2 (decl);
7848 for (decl = globals; decl; decl = TREE_CHAIN (decl))
7849 check_global_declaration_1 (decl);
7852 /* A subroutine of c_write_global_declarations Emit debug information for each
7853 of the declarations in GLOBALS. */
7856 c_write_global_declarations_2 (tree globals)
7860 for (decl = globals; decl ; decl = TREE_CHAIN (decl))
7861 debug_hooks->global_decl (decl);
7864 /* Preserve the external declarations scope across a garbage collect. */
7865 static GTY(()) tree ext_block;
7868 c_write_global_declarations (void)
7872 /* We don't want to do this if generating a PCH. */
7876 /* Don't waste time on further processing if -fsyntax-only or we've
7877 encountered errors. */
7878 if (flag_syntax_only || errorcount || sorrycount || cpp_errors (parse_in))
7881 /* Close the external scope. */
7882 ext_block = pop_scope ();
7884 gcc_assert (!current_scope);
7888 tree tmp = BLOCK_VARS (ext_block);
7890 FILE * stream = dump_begin (TDI_tu, &flags);
7893 dump_node (tmp, flags & ~TDF_SLIM, stream);
7894 dump_end (TDI_tu, stream);
7898 /* Process all file scopes in this compilation, and the external_scope,
7899 through wrapup_global_declarations and check_global_declarations. */
7900 for (t = all_translation_units; t; t = TREE_CHAIN (t))
7901 c_write_global_declarations_1 (BLOCK_VARS (DECL_INITIAL (t)));
7902 c_write_global_declarations_1 (BLOCK_VARS (ext_block));
7904 /* Generate functions to call static constructors and destructors
7905 for targets that do not support .ctors/.dtors sections. These
7906 functions have magic names which are detected by collect2. */
7907 build_cdtor ('I', static_ctors); static_ctors = 0;
7908 build_cdtor ('D', static_dtors); static_dtors = 0;
7910 /* We're done parsing; proceed to optimize and emit assembly.
7911 FIXME: shouldn't be the front end's responsibility to call this. */
7914 /* After cgraph has had a chance to emit everything that's going to
7915 be emitted, output debug information for globals. */
7916 if (errorcount == 0 && sorrycount == 0)
7918 timevar_push (TV_SYMOUT);
7919 for (t = all_translation_units; t; t = TREE_CHAIN (t))
7920 c_write_global_declarations_2 (BLOCK_VARS (DECL_INITIAL (t)));
7921 c_write_global_declarations_2 (BLOCK_VARS (ext_block));
7922 timevar_pop (TV_SYMOUT);
7928 #include "gt-c-decl.h"