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;
4841 DECL_TLS_MODEL (decl) = decl_default_tls_model (decl);
4844 if (storage_class == csc_extern
4845 && variably_modified_type_p (type, NULL_TREE))
4848 error ("object with variably modified type must have no linkage");
4851 /* Record `register' declaration for warnings on &
4852 and in case doing stupid register allocation. */
4854 if (storage_class == csc_register)
4856 C_DECL_REGISTER (decl) = 1;
4857 DECL_REGISTER (decl) = 1;
4860 /* Record constancy and volatility. */
4861 c_apply_type_quals_to_decl (type_quals, decl);
4863 /* If a type has volatile components, it should be stored in memory.
4864 Otherwise, the fact that those components are volatile
4865 will be ignored, and would even crash the compiler.
4866 Of course, this only makes sense on VAR,PARM, and RESULT decl's. */
4867 if (C_TYPE_FIELDS_VOLATILE (TREE_TYPE (decl))
4868 && (TREE_CODE (decl) == VAR_DECL || TREE_CODE (decl) == PARM_DECL
4869 || TREE_CODE (decl) == RESULT_DECL))
4871 /* It is not an error for a structure with volatile fields to
4872 be declared register, but reset DECL_REGISTER since it
4873 cannot actually go in a register. */
4874 int was_reg = C_DECL_REGISTER (decl);
4875 C_DECL_REGISTER (decl) = 0;
4876 DECL_REGISTER (decl) = 0;
4877 c_mark_addressable (decl);
4878 C_DECL_REGISTER (decl) = was_reg;
4881 /* This is the earliest point at which we might know the assembler
4882 name of a variable. Thus, if it's known before this, die horribly. */
4883 gcc_assert (!DECL_ASSEMBLER_NAME_SET_P (decl));
4885 decl_attributes (&decl, returned_attrs, 0);
4891 /* Decode the parameter-list info for a function type or function definition.
4892 The argument is the value returned by `get_parm_info' (or made in c-parse.c
4893 if there is an identifier list instead of a parameter decl list).
4894 These two functions are separate because when a function returns
4895 or receives functions then each is called multiple times but the order
4896 of calls is different. The last call to `grokparms' is always the one
4897 that contains the formal parameter names of a function definition.
4899 Return a list of arg types to use in the FUNCTION_TYPE for this function.
4901 FUNCDEF_FLAG is true for a function definition, false for
4902 a mere declaration. A nonempty identifier-list gets an error message
4903 when FUNCDEF_FLAG is false. */
4906 grokparms (struct c_arg_info *arg_info, bool funcdef_flag)
4908 tree arg_types = arg_info->types;
4910 if (funcdef_flag && arg_info->had_vla_unspec)
4912 /* A function definition isn't function prototype scope C99 6.2.1p4. */
4914 error ("%<[*]%> not allowed in other than function prototype scope");
4917 if (arg_types == 0 && !funcdef_flag && !in_system_header)
4918 warning (OPT_Wstrict_prototypes,
4919 "function declaration isn%'t a prototype");
4921 if (arg_types == error_mark_node)
4922 return 0; /* don't set TYPE_ARG_TYPES in this case */
4924 else if (arg_types && TREE_CODE (TREE_VALUE (arg_types)) == IDENTIFIER_NODE)
4927 pedwarn ("parameter names (without types) in function declaration");
4929 arg_info->parms = arg_info->types;
4930 arg_info->types = 0;
4935 tree parm, type, typelt;
4936 unsigned int parmno;
4938 /* If there is a parameter of incomplete type in a definition,
4939 this is an error. In a declaration this is valid, and a
4940 struct or union type may be completed later, before any calls
4941 or definition of the function. In the case where the tag was
4942 first declared within the parameter list, a warning has
4943 already been given. If a parameter has void type, then
4944 however the function cannot be defined or called, so
4947 for (parm = arg_info->parms, typelt = arg_types, parmno = 1;
4949 parm = TREE_CHAIN (parm), typelt = TREE_CHAIN (typelt), parmno++)
4951 type = TREE_VALUE (typelt);
4952 if (type == error_mark_node)
4955 if (!COMPLETE_TYPE_P (type))
4959 if (DECL_NAME (parm))
4960 error ("parameter %u (%q+D) has incomplete type",
4963 error ("%Jparameter %u has incomplete type",
4966 TREE_VALUE (typelt) = error_mark_node;
4967 TREE_TYPE (parm) = error_mark_node;
4969 else if (VOID_TYPE_P (type))
4971 if (DECL_NAME (parm))
4972 warning (0, "parameter %u (%q+D) has void type",
4975 warning (0, "%Jparameter %u has void type",
4980 if (DECL_NAME (parm) && TREE_USED (parm))
4981 warn_if_shadowing (parm);
4987 /* Take apart the current scope and return a c_arg_info structure with
4988 info on a parameter list just parsed.
4990 This structure is later fed to 'grokparms' and 'store_parm_decls'.
4992 ELLIPSIS being true means the argument list ended in '...' so don't
4993 append a sentinel (void_list_node) to the end of the type-list. */
4996 get_parm_info (bool ellipsis)
4998 struct c_binding *b = current_scope->bindings;
4999 struct c_arg_info *arg_info = XOBNEW (&parser_obstack,
5006 static bool explained_incomplete_types = false;
5007 bool gave_void_only_once_err = false;
5009 arg_info->parms = 0;
5011 arg_info->types = 0;
5012 arg_info->others = 0;
5013 arg_info->pending_sizes = 0;
5014 arg_info->had_vla_unspec = current_scope->had_vla_unspec;
5016 /* The bindings in this scope must not get put into a block.
5017 We will take care of deleting the binding nodes. */
5018 current_scope->bindings = 0;
5020 /* This function is only called if there was *something* on the
5024 /* A parameter list consisting solely of 'void' indicates that the
5025 function takes no arguments. But if the 'void' is qualified
5026 (by 'const' or 'volatile'), or has a storage class specifier
5027 ('register'), then the behavior is undefined; issue an error.
5028 Typedefs for 'void' are OK (see DR#157). */
5029 if (b->prev == 0 /* one binding */
5030 && TREE_CODE (b->decl) == PARM_DECL /* which is a parameter */
5031 && !DECL_NAME (b->decl) /* anonymous */
5032 && VOID_TYPE_P (TREE_TYPE (b->decl))) /* of void type */
5034 if (TREE_THIS_VOLATILE (b->decl)
5035 || TREE_READONLY (b->decl)
5036 || C_DECL_REGISTER (b->decl))
5037 error ("%<void%> as only parameter may not be qualified");
5039 /* There cannot be an ellipsis. */
5041 error ("%<void%> must be the only parameter");
5043 arg_info->types = void_list_node;
5048 types = void_list_node;
5050 /* Break up the bindings list into parms, tags, types, and others;
5051 apply sanity checks; purge the name-to-decl bindings. */
5054 tree decl = b->decl;
5055 tree type = TREE_TYPE (decl);
5056 const char *keyword;
5058 switch (TREE_CODE (decl))
5063 gcc_assert (I_SYMBOL_BINDING (b->id) == b);
5064 I_SYMBOL_BINDING (b->id) = b->shadowed;
5067 /* Check for forward decls that never got their actual decl. */
5068 if (TREE_ASM_WRITTEN (decl))
5069 error ("parameter %q+D has just a forward declaration", decl);
5070 /* Check for (..., void, ...) and issue an error. */
5071 else if (VOID_TYPE_P (type) && !DECL_NAME (decl))
5073 if (!gave_void_only_once_err)
5075 error ("%<void%> must be the only parameter");
5076 gave_void_only_once_err = true;
5081 /* Valid parameter, add it to the list. */
5082 TREE_CHAIN (decl) = parms;
5085 /* Since there is a prototype, args are passed in their
5086 declared types. The back end may override this later. */
5087 DECL_ARG_TYPE (decl) = type;
5088 types = tree_cons (0, type, types);
5092 case ENUMERAL_TYPE: keyword = "enum"; goto tag;
5093 case UNION_TYPE: keyword = "union"; goto tag;
5094 case RECORD_TYPE: keyword = "struct"; goto tag;
5096 /* Types may not have tag-names, in which case the type
5097 appears in the bindings list with b->id NULL. */
5100 gcc_assert (I_TAG_BINDING (b->id) == b);
5101 I_TAG_BINDING (b->id) = b->shadowed;
5104 /* Warn about any struct, union or enum tags defined in a
5105 parameter list. The scope of such types is limited to
5106 the parameter list, which is rarely if ever desirable
5107 (it's impossible to call such a function with type-
5108 correct arguments). An anonymous union parm type is
5109 meaningful as a GNU extension, so don't warn for that. */
5110 if (TREE_CODE (decl) != UNION_TYPE || b->id != 0)
5113 /* The %s will be one of 'struct', 'union', or 'enum'. */
5114 warning (0, "%<%s %E%> declared inside parameter list",
5117 /* The %s will be one of 'struct', 'union', or 'enum'. */
5118 warning (0, "anonymous %s declared inside parameter list",
5121 if (!explained_incomplete_types)
5123 warning (0, "its scope is only this definition or declaration,"
5124 " which is probably not what you want");
5125 explained_incomplete_types = true;
5129 tags = tree_cons (b->id, decl, tags);
5135 /* CONST_DECLs appear here when we have an embedded enum,
5136 and TYPE_DECLs appear here when we have an embedded struct
5137 or union. No warnings for this - we already warned about the
5138 type itself. FUNCTION_DECLs appear when there is an implicit
5139 function declaration in the parameter list. */
5141 TREE_CHAIN (decl) = others;
5146 /* error_mark_node appears here when we have an undeclared
5147 variable. Just throw it away. */
5150 gcc_assert (I_SYMBOL_BINDING (b->id) == b);
5151 I_SYMBOL_BINDING (b->id) = b->shadowed;
5155 /* Other things that might be encountered. */
5162 b = free_binding_and_advance (b);
5165 arg_info->parms = parms;
5166 arg_info->tags = tags;
5167 arg_info->types = types;
5168 arg_info->others = others;
5169 arg_info->pending_sizes = get_pending_sizes ();
5173 /* Get the struct, enum or union (CODE says which) with tag NAME.
5174 Define the tag as a forward-reference if it is not defined.
5175 Return a c_typespec structure for the type specifier. */
5178 parser_xref_tag (enum tree_code code, tree name)
5180 struct c_typespec ret;
5181 /* If a cross reference is requested, look up the type
5182 already defined for this tag and return it. */
5184 tree ref = lookup_tag (code, name, 0);
5185 /* If this is the right type of tag, return what we found.
5186 (This reference will be shadowed by shadow_tag later if appropriate.)
5187 If this is the wrong type of tag, do not return it. If it was the
5188 wrong type in the same scope, we will have had an error
5189 message already; if in a different scope and declaring
5190 a name, pending_xref_error will give an error message; but if in a
5191 different scope and not declaring a name, this tag should
5192 shadow the previous declaration of a different type of tag, and
5193 this would not work properly if we return the reference found.
5194 (For example, with "struct foo" in an outer scope, "union foo;"
5195 must shadow that tag with a new one of union type.) */
5196 ret.kind = (ref ? ctsk_tagref : ctsk_tagfirstref);
5197 if (ref && TREE_CODE (ref) == code)
5203 /* If no such tag is yet defined, create a forward-reference node
5204 and record it as the "definition".
5205 When a real declaration of this type is found,
5206 the forward-reference will be altered into a real type. */
5208 ref = make_node (code);
5209 if (code == ENUMERAL_TYPE)
5211 /* Give the type a default layout like unsigned int
5212 to avoid crashing if it does not get defined. */
5213 TYPE_MODE (ref) = TYPE_MODE (unsigned_type_node);
5214 TYPE_ALIGN (ref) = TYPE_ALIGN (unsigned_type_node);
5215 TYPE_USER_ALIGN (ref) = 0;
5216 TYPE_UNSIGNED (ref) = 1;
5217 TYPE_PRECISION (ref) = TYPE_PRECISION (unsigned_type_node);
5218 TYPE_MIN_VALUE (ref) = TYPE_MIN_VALUE (unsigned_type_node);
5219 TYPE_MAX_VALUE (ref) = TYPE_MAX_VALUE (unsigned_type_node);
5222 pushtag (name, ref);
5228 /* Get the struct, enum or union (CODE says which) with tag NAME.
5229 Define the tag as a forward-reference if it is not defined.
5230 Return a tree for the type. */
5233 xref_tag (enum tree_code code, tree name)
5235 return parser_xref_tag (code, name).spec;
5238 /* Make sure that the tag NAME is defined *in the current scope*
5239 at least as a forward reference.
5240 CODE says which kind of tag NAME ought to be. */
5243 start_struct (enum tree_code code, tree name)
5245 /* If there is already a tag defined at this scope
5246 (as a forward reference), just return it. */
5251 ref = lookup_tag (code, name, 1);
5252 if (ref && TREE_CODE (ref) == code)
5254 if (TYPE_SIZE (ref))
5256 if (code == UNION_TYPE)
5257 error ("redefinition of %<union %E%>", name);
5259 error ("redefinition of %<struct %E%>", name);
5261 else if (C_TYPE_BEING_DEFINED (ref))
5263 if (code == UNION_TYPE)
5264 error ("nested redefinition of %<union %E%>", name);
5266 error ("nested redefinition of %<struct %E%>", name);
5271 /* Otherwise create a forward-reference just so the tag is in scope. */
5273 ref = make_node (code);
5274 pushtag (name, ref);
5277 C_TYPE_BEING_DEFINED (ref) = 1;
5278 TYPE_PACKED (ref) = flag_pack_struct;
5282 /* Process the specs, declarator and width (NULL if omitted)
5283 of a structure component, returning a FIELD_DECL node.
5284 WIDTH is non-NULL for bit-fields only, and is an INTEGER_CST node.
5286 This is done during the parsing of the struct declaration.
5287 The FIELD_DECL nodes are chained together and the lot of them
5288 are ultimately passed to `build_struct' to make the RECORD_TYPE node. */
5291 grokfield (struct c_declarator *declarator, struct c_declspecs *declspecs,
5296 if (declarator->kind == cdk_id && declarator->u.id == NULL_TREE
5297 && width == NULL_TREE)
5299 /* This is an unnamed decl.
5301 If we have something of the form "union { list } ;" then this
5302 is the anonymous union extension. Similarly for struct.
5304 If this is something of the form "struct foo;", then
5305 If MS extensions are enabled, this is handled as an
5307 Otherwise this is a forward declaration of a structure tag.
5309 If this is something of the form "foo;" and foo is a TYPE_DECL, then
5310 If MS extensions are enabled and foo names a structure, then
5311 again this is an anonymous struct.
5312 Otherwise this is an error.
5314 Oh what a horrid tangled web we weave. I wonder if MS consciously
5315 took this from Plan 9 or if it was an accident of implementation
5316 that took root before someone noticed the bug... */
5318 tree type = declspecs->type;
5319 bool type_ok = (TREE_CODE (type) == RECORD_TYPE
5320 || TREE_CODE (type) == UNION_TYPE);
5324 && (flag_ms_extensions || !declspecs->typedef_p))
5326 if (flag_ms_extensions)
5330 else if (TYPE_NAME (type) == NULL)
5337 pedwarn ("declaration does not declare anything");
5341 pedwarn ("ISO C doesn%'t support unnamed structs/unions");
5344 value = grokdeclarator (declarator, declspecs, FIELD, false,
5345 width ? &width : NULL);
5347 finish_decl (value, NULL_TREE, NULL_TREE);
5348 DECL_INITIAL (value) = width;
5353 /* Generate an error for any duplicate field names in FIELDLIST. Munge
5354 the list such that this does not present a problem later. */
5357 detect_field_duplicates (tree fieldlist)
5362 /* First, see if there are more than "a few" fields.
5363 This is trivially true if there are zero or one fields. */
5366 x = TREE_CHAIN (fieldlist);
5372 } while (timeout > 0 && x);
5374 /* If there were "few" fields, avoid the overhead of allocating
5375 a hash table. Instead just do the nested traversal thing. */
5378 for (x = TREE_CHAIN (fieldlist); x ; x = TREE_CHAIN (x))
5381 for (y = fieldlist; y != x; y = TREE_CHAIN (y))
5382 if (DECL_NAME (y) == DECL_NAME (x))
5384 error ("duplicate member %q+D", x);
5385 DECL_NAME (x) = NULL_TREE;
5391 htab_t htab = htab_create (37, htab_hash_pointer, htab_eq_pointer, NULL);
5394 for (x = fieldlist; x ; x = TREE_CHAIN (x))
5395 if ((y = DECL_NAME (x)) != 0)
5397 slot = htab_find_slot (htab, y, INSERT);
5400 error ("duplicate member %q+D", x);
5401 DECL_NAME (x) = NULL_TREE;
5410 /* Fill in the fields of a RECORD_TYPE or UNION_TYPE node, T.
5411 FIELDLIST is a chain of FIELD_DECL nodes for the fields.
5412 ATTRIBUTES are attributes to be applied to the structure. */
5415 finish_struct (tree t, tree fieldlist, tree attributes)
5418 bool toplevel = file_scope == current_scope;
5419 int saw_named_field;
5421 /* If this type was previously laid out as a forward reference,
5422 make sure we lay it out again. */
5426 decl_attributes (&t, attributes, (int) ATTR_FLAG_TYPE_IN_PLACE);
5430 for (x = fieldlist; x; x = TREE_CHAIN (x))
5431 if (DECL_NAME (x) != 0)
5436 if (TREE_CODE (t) == UNION_TYPE)
5439 pedwarn ("union has no named members");
5441 pedwarn ("union has no members");
5446 pedwarn ("struct has no named members");
5448 pedwarn ("struct has no members");
5453 /* Install struct as DECL_CONTEXT of each field decl.
5454 Also process specified field sizes, found in the DECL_INITIAL,
5455 storing 0 there after the type has been changed to precision equal
5456 to its width, rather than the precision of the specified standard
5457 type. (Correct layout requires the original type to have been preserved
5460 saw_named_field = 0;
5461 for (x = fieldlist; x; x = TREE_CHAIN (x))
5463 if (TREE_TYPE (x) == error_mark_node)
5466 DECL_CONTEXT (x) = t;
5468 if (TYPE_PACKED (t) && TYPE_ALIGN (TREE_TYPE (x)) > BITS_PER_UNIT)
5469 DECL_PACKED (x) = 1;
5471 /* If any field is const, the structure type is pseudo-const. */
5472 if (TREE_READONLY (x))
5473 C_TYPE_FIELDS_READONLY (t) = 1;
5476 /* A field that is pseudo-const makes the structure likewise. */
5477 tree t1 = TREE_TYPE (x);
5478 while (TREE_CODE (t1) == ARRAY_TYPE)
5479 t1 = TREE_TYPE (t1);
5480 if ((TREE_CODE (t1) == RECORD_TYPE || TREE_CODE (t1) == UNION_TYPE)
5481 && C_TYPE_FIELDS_READONLY (t1))
5482 C_TYPE_FIELDS_READONLY (t) = 1;
5485 /* Any field that is volatile means variables of this type must be
5486 treated in some ways as volatile. */
5487 if (TREE_THIS_VOLATILE (x))
5488 C_TYPE_FIELDS_VOLATILE (t) = 1;
5490 /* Any field of nominal variable size implies structure is too. */
5491 if (C_DECL_VARIABLE_SIZE (x))
5492 C_TYPE_VARIABLE_SIZE (t) = 1;
5494 if (DECL_INITIAL (x))
5496 unsigned HOST_WIDE_INT width = tree_low_cst (DECL_INITIAL (x), 1);
5497 DECL_SIZE (x) = bitsize_int (width);
5498 DECL_BIT_FIELD (x) = 1;
5499 SET_DECL_C_BIT_FIELD (x);
5502 /* Detect flexible array member in an invalid context. */
5503 if (TREE_CODE (TREE_TYPE (x)) == ARRAY_TYPE
5504 && TYPE_SIZE (TREE_TYPE (x)) == NULL_TREE
5505 && TYPE_DOMAIN (TREE_TYPE (x)) != NULL_TREE
5506 && TYPE_MAX_VALUE (TYPE_DOMAIN (TREE_TYPE (x))) == NULL_TREE)
5508 if (TREE_CODE (t) == UNION_TYPE)
5510 error ("%Jflexible array member in union", x);
5511 TREE_TYPE (x) = error_mark_node;
5513 else if (TREE_CHAIN (x) != NULL_TREE)
5515 error ("%Jflexible array member not at end of struct", x);
5516 TREE_TYPE (x) = error_mark_node;
5518 else if (!saw_named_field)
5520 error ("%Jflexible array member in otherwise empty struct", x);
5521 TREE_TYPE (x) = error_mark_node;
5525 if (pedantic && !in_system_header && TREE_CODE (t) == RECORD_TYPE
5526 && flexible_array_type_p (TREE_TYPE (x)))
5527 pedwarn ("%Jinvalid use of structure with flexible array member", x);
5530 saw_named_field = 1;
5533 detect_field_duplicates (fieldlist);
5535 /* Now we have the nearly final fieldlist. Record it,
5536 then lay out the structure or union (including the fields). */
5538 TYPE_FIELDS (t) = fieldlist;
5542 /* Give bit-fields their proper types. */
5544 tree *fieldlistp = &fieldlist;
5546 if (TREE_CODE (*fieldlistp) == FIELD_DECL && DECL_INITIAL (*fieldlistp)
5547 && TREE_TYPE (*fieldlistp) != error_mark_node)
5549 unsigned HOST_WIDE_INT width
5550 = tree_low_cst (DECL_INITIAL (*fieldlistp), 1);
5551 tree type = TREE_TYPE (*fieldlistp);
5552 if (width != TYPE_PRECISION (type))
5554 TREE_TYPE (*fieldlistp)
5555 = c_build_bitfield_integer_type (width, TYPE_UNSIGNED (type));
5556 DECL_MODE (*fieldlistp) = TYPE_MODE (TREE_TYPE (*fieldlistp));
5558 DECL_INITIAL (*fieldlistp) = 0;
5561 fieldlistp = &TREE_CHAIN (*fieldlistp);
5564 /* Now we have the truly final field list.
5565 Store it in this type and in the variants. */
5567 TYPE_FIELDS (t) = fieldlist;
5569 /* If there are lots of fields, sort so we can look through them fast.
5570 We arbitrarily consider 16 or more elts to be "a lot". */
5575 for (x = fieldlist; x; x = TREE_CHAIN (x))
5577 if (len > 15 || DECL_NAME (x) == NULL)
5585 struct lang_type *space;
5586 struct sorted_fields_type *space2;
5588 len += list_length (x);
5590 /* Use the same allocation policy here that make_node uses, to
5591 ensure that this lives as long as the rest of the struct decl.
5592 All decls in an inline function need to be saved. */
5594 space = GGC_CNEW (struct lang_type);
5595 space2 = GGC_NEWVAR (struct sorted_fields_type,
5596 sizeof (struct sorted_fields_type) + len * sizeof (tree));
5600 field_array = &space2->elts[0];
5601 for (x = fieldlist; x; x = TREE_CHAIN (x))
5603 field_array[len++] = x;
5605 /* If there is anonymous struct or union, break out of the loop. */
5606 if (DECL_NAME (x) == NULL)
5609 /* Found no anonymous struct/union. Add the TYPE_LANG_SPECIFIC. */
5612 TYPE_LANG_SPECIFIC (t) = space;
5613 TYPE_LANG_SPECIFIC (t)->s->len = len;
5614 field_array = TYPE_LANG_SPECIFIC (t)->s->elts;
5615 qsort (field_array, len, sizeof (tree), field_decl_cmp);
5620 for (x = TYPE_MAIN_VARIANT (t); x; x = TYPE_NEXT_VARIANT (x))
5622 TYPE_FIELDS (x) = TYPE_FIELDS (t);
5623 TYPE_LANG_SPECIFIC (x) = TYPE_LANG_SPECIFIC (t);
5624 C_TYPE_FIELDS_READONLY (x) = C_TYPE_FIELDS_READONLY (t);
5625 C_TYPE_FIELDS_VOLATILE (x) = C_TYPE_FIELDS_VOLATILE (t);
5626 C_TYPE_VARIABLE_SIZE (x) = C_TYPE_VARIABLE_SIZE (t);
5629 /* If this was supposed to be a transparent union, but we can't
5630 make it one, warn and turn off the flag. */
5631 if (TREE_CODE (t) == UNION_TYPE
5632 && TYPE_TRANSPARENT_UNION (t)
5633 && (!TYPE_FIELDS (t) || TYPE_MODE (t) != DECL_MODE (TYPE_FIELDS (t))))
5635 TYPE_TRANSPARENT_UNION (t) = 0;
5636 warning (0, "union cannot be made transparent");
5639 /* If this structure or union completes the type of any previous
5640 variable declaration, lay it out and output its rtl. */
5641 for (x = C_TYPE_INCOMPLETE_VARS (TYPE_MAIN_VARIANT (t));
5645 tree decl = TREE_VALUE (x);
5646 if (TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE)
5647 layout_array_type (TREE_TYPE (decl));
5648 if (TREE_CODE (decl) != TYPE_DECL)
5650 layout_decl (decl, 0);
5651 if (c_dialect_objc ())
5652 objc_check_decl (decl);
5653 rest_of_decl_compilation (decl, toplevel, 0);
5658 C_TYPE_INCOMPLETE_VARS (TYPE_MAIN_VARIANT (t)) = 0;
5660 /* Finish debugging output for this type. */
5661 rest_of_type_compilation (t, toplevel);
5663 /* If we're inside a function proper, i.e. not file-scope and not still
5664 parsing parameters, then arrange for the size of a variable sized type
5666 if (cur_stmt_list && variably_modified_type_p (t, NULL_TREE))
5667 add_stmt (build_stmt (DECL_EXPR, build_decl (TYPE_DECL, NULL, t)));
5672 /* Lay out the type T, and its element type, and so on. */
5675 layout_array_type (tree t)
5677 if (TREE_CODE (TREE_TYPE (t)) == ARRAY_TYPE)
5678 layout_array_type (TREE_TYPE (t));
5682 /* Begin compiling the definition of an enumeration type.
5683 NAME is its name (or null if anonymous).
5684 Returns the type object, as yet incomplete.
5685 Also records info about it so that build_enumerator
5686 may be used to declare the individual values as they are read. */
5689 start_enum (tree name)
5693 /* If this is the real definition for a previous forward reference,
5694 fill in the contents in the same object that used to be the
5695 forward reference. */
5698 enumtype = lookup_tag (ENUMERAL_TYPE, name, 1);
5700 if (enumtype == 0 || TREE_CODE (enumtype) != ENUMERAL_TYPE)
5702 enumtype = make_node (ENUMERAL_TYPE);
5703 pushtag (name, enumtype);
5706 if (C_TYPE_BEING_DEFINED (enumtype))
5707 error ("nested redefinition of %<enum %E%>", name);
5709 C_TYPE_BEING_DEFINED (enumtype) = 1;
5711 if (TYPE_VALUES (enumtype) != 0)
5713 /* This enum is a named one that has been declared already. */
5714 error ("redeclaration of %<enum %E%>", name);
5716 /* Completely replace its old definition.
5717 The old enumerators remain defined, however. */
5718 TYPE_VALUES (enumtype) = 0;
5721 enum_next_value = integer_zero_node;
5724 if (flag_short_enums)
5725 TYPE_PACKED (enumtype) = 1;
5730 /* After processing and defining all the values of an enumeration type,
5731 install their decls in the enumeration type and finish it off.
5732 ENUMTYPE is the type object, VALUES a list of decl-value pairs,
5733 and ATTRIBUTES are the specified attributes.
5734 Returns ENUMTYPE. */
5737 finish_enum (tree enumtype, tree values, tree attributes)
5740 tree minnode = 0, maxnode = 0;
5741 int precision, unsign;
5742 bool toplevel = (file_scope == current_scope);
5743 struct lang_type *lt;
5745 decl_attributes (&enumtype, attributes, (int) ATTR_FLAG_TYPE_IN_PLACE);
5747 /* Calculate the maximum value of any enumerator in this type. */
5749 if (values == error_mark_node)
5750 minnode = maxnode = integer_zero_node;
5753 minnode = maxnode = TREE_VALUE (values);
5754 for (pair = TREE_CHAIN (values); pair; pair = TREE_CHAIN (pair))
5756 tree value = TREE_VALUE (pair);
5757 if (tree_int_cst_lt (maxnode, value))
5759 if (tree_int_cst_lt (value, minnode))
5764 /* Construct the final type of this enumeration. It is the same
5765 as one of the integral types - the narrowest one that fits, except
5766 that normally we only go as narrow as int - and signed iff any of
5767 the values are negative. */
5768 unsign = (tree_int_cst_sgn (minnode) >= 0);
5769 precision = MAX (min_precision (minnode, unsign),
5770 min_precision (maxnode, unsign));
5772 if (TYPE_PACKED (enumtype) || precision > TYPE_PRECISION (integer_type_node))
5774 tem = c_common_type_for_size (precision, unsign);
5777 warning (0, "enumeration values exceed range of largest integer");
5778 tem = long_long_integer_type_node;
5782 tem = unsign ? unsigned_type_node : integer_type_node;
5784 TYPE_MIN_VALUE (enumtype) = TYPE_MIN_VALUE (tem);
5785 TYPE_MAX_VALUE (enumtype) = TYPE_MAX_VALUE (tem);
5786 TYPE_UNSIGNED (enumtype) = TYPE_UNSIGNED (tem);
5787 TYPE_SIZE (enumtype) = 0;
5789 /* If the precision of the type was specific with an attribute and it
5790 was too small, give an error. Otherwise, use it. */
5791 if (TYPE_PRECISION (enumtype))
5793 if (precision > TYPE_PRECISION (enumtype))
5794 error ("specified mode too small for enumeral values");
5797 TYPE_PRECISION (enumtype) = TYPE_PRECISION (tem);
5799 layout_type (enumtype);
5801 if (values != error_mark_node)
5803 /* Change the type of the enumerators to be the enum type. We
5804 need to do this irrespective of the size of the enum, for
5805 proper type checking. Replace the DECL_INITIALs of the
5806 enumerators, and the value slots of the list, with copies
5807 that have the enum type; they cannot be modified in place
5808 because they may be shared (e.g. integer_zero_node) Finally,
5809 change the purpose slots to point to the names of the decls. */
5810 for (pair = values; pair; pair = TREE_CHAIN (pair))
5812 tree enu = TREE_PURPOSE (pair);
5813 tree ini = DECL_INITIAL (enu);
5815 TREE_TYPE (enu) = enumtype;
5817 /* The ISO C Standard mandates enumerators to have type int,
5818 even though the underlying type of an enum type is
5819 unspecified. Here we convert any enumerators that fit in
5820 an int to type int, to avoid promotions to unsigned types
5821 when comparing integers with enumerators that fit in the
5822 int range. When -pedantic is given, build_enumerator()
5823 would have already taken care of those that don't fit. */
5824 if (int_fits_type_p (ini, integer_type_node))
5825 tem = integer_type_node;
5828 ini = convert (tem, ini);
5830 DECL_INITIAL (enu) = ini;
5831 TREE_PURPOSE (pair) = DECL_NAME (enu);
5832 TREE_VALUE (pair) = ini;
5835 TYPE_VALUES (enumtype) = values;
5838 /* Record the min/max values so that we can warn about bit-field
5839 enumerations that are too small for the values. */
5840 lt = GGC_CNEW (struct lang_type);
5841 lt->enum_min = minnode;
5842 lt->enum_max = maxnode;
5843 TYPE_LANG_SPECIFIC (enumtype) = lt;
5845 /* Fix up all variant types of this enum type. */
5846 for (tem = TYPE_MAIN_VARIANT (enumtype); tem; tem = TYPE_NEXT_VARIANT (tem))
5848 if (tem == enumtype)
5850 TYPE_VALUES (tem) = TYPE_VALUES (enumtype);
5851 TYPE_MIN_VALUE (tem) = TYPE_MIN_VALUE (enumtype);
5852 TYPE_MAX_VALUE (tem) = TYPE_MAX_VALUE (enumtype);
5853 TYPE_SIZE (tem) = TYPE_SIZE (enumtype);
5854 TYPE_SIZE_UNIT (tem) = TYPE_SIZE_UNIT (enumtype);
5855 TYPE_MODE (tem) = TYPE_MODE (enumtype);
5856 TYPE_PRECISION (tem) = TYPE_PRECISION (enumtype);
5857 TYPE_ALIGN (tem) = TYPE_ALIGN (enumtype);
5858 TYPE_USER_ALIGN (tem) = TYPE_USER_ALIGN (enumtype);
5859 TYPE_UNSIGNED (tem) = TYPE_UNSIGNED (enumtype);
5860 TYPE_LANG_SPECIFIC (tem) = TYPE_LANG_SPECIFIC (enumtype);
5863 /* Finish debugging output for this type. */
5864 rest_of_type_compilation (enumtype, toplevel);
5869 /* Build and install a CONST_DECL for one value of the
5870 current enumeration type (one that was begun with start_enum).
5871 Return a tree-list containing the CONST_DECL and its value.
5872 Assignment of sequential values by default is handled here. */
5875 build_enumerator (tree name, tree value)
5879 /* Validate and default VALUE. */
5883 /* Don't issue more errors for error_mark_node (i.e. an
5884 undeclared identifier) - just ignore the value expression. */
5885 if (value == error_mark_node)
5887 else if (!INTEGRAL_TYPE_P (TREE_TYPE (value))
5888 || TREE_CODE (value) != INTEGER_CST)
5890 error ("enumerator value for %qE is not an integer constant", name);
5895 value = default_conversion (value);
5896 constant_expression_warning (value);
5900 /* Default based on previous value. */
5901 /* It should no longer be possible to have NON_LVALUE_EXPR
5905 value = enum_next_value;
5907 error ("overflow in enumeration values");
5910 if (pedantic && !int_fits_type_p (value, integer_type_node))
5912 pedwarn ("ISO C restricts enumerator values to range of %<int%>");
5913 /* XXX This causes -pedantic to change the meaning of the program.
5914 Remove? -zw 2004-03-15 */
5915 value = convert (integer_type_node, value);
5918 /* Set basis for default for next value. */
5919 enum_next_value = build_binary_op (PLUS_EXPR, value, integer_one_node, 0);
5920 enum_overflow = tree_int_cst_lt (enum_next_value, value);
5922 /* Now create a declaration for the enum value name. */
5924 type = TREE_TYPE (value);
5925 type = c_common_type_for_size (MAX (TYPE_PRECISION (type),
5926 TYPE_PRECISION (integer_type_node)),
5927 (TYPE_PRECISION (type)
5928 >= TYPE_PRECISION (integer_type_node)
5929 && TYPE_UNSIGNED (type)));
5931 decl = build_decl (CONST_DECL, name, type);
5932 DECL_INITIAL (decl) = convert (type, value);
5935 return tree_cons (decl, value, NULL_TREE);
5939 /* Create the FUNCTION_DECL for a function definition.
5940 DECLSPECS, DECLARATOR and ATTRIBUTES are the parts of
5941 the declaration; they describe the function's name and the type it returns,
5942 but twisted together in a fashion that parallels the syntax of C.
5944 This function creates a binding context for the function body
5945 as well as setting up the FUNCTION_DECL in current_function_decl.
5947 Returns 1 on success. If the DECLARATOR is not suitable for a function
5948 (it defines a datum instead), we return 0, which tells
5949 yyparse to report a parse error. */
5952 start_function (struct c_declspecs *declspecs, struct c_declarator *declarator,
5955 tree decl1, old_decl;
5956 tree restype, resdecl;
5957 struct c_label_context_se *nstack_se;
5958 struct c_label_context_vm *nstack_vm;
5960 current_function_returns_value = 0; /* Assume, until we see it does. */
5961 current_function_returns_null = 0;
5962 current_function_returns_abnormally = 0;
5963 warn_about_return_type = 0;
5964 current_extern_inline = 0;
5965 c_switch_stack = NULL;
5967 nstack_se = XOBNEW (&parser_obstack, struct c_label_context_se);
5968 nstack_se->labels_def = NULL;
5969 nstack_se->labels_used = NULL;
5970 nstack_se->next = label_context_stack_se;
5971 label_context_stack_se = nstack_se;
5973 nstack_vm = XOBNEW (&parser_obstack, struct c_label_context_vm);
5974 nstack_vm->labels_def = NULL;
5975 nstack_vm->labels_used = NULL;
5976 nstack_vm->scope = 0;
5977 nstack_vm->next = label_context_stack_vm;
5978 label_context_stack_vm = nstack_vm;
5980 /* Indicate no valid break/continue context by setting these variables
5981 to some non-null, non-label value. We'll notice and emit the proper
5982 error message in c_finish_bc_stmt. */
5983 c_break_label = c_cont_label = size_zero_node;
5985 decl1 = grokdeclarator (declarator, declspecs, FUNCDEF, true, NULL);
5987 /* If the declarator is not suitable for a function definition,
5988 cause a syntax error. */
5991 label_context_stack_se = label_context_stack_se->next;
5992 label_context_stack_vm = label_context_stack_vm->next;
5996 decl_attributes (&decl1, attributes, 0);
5998 if (DECL_DECLARED_INLINE_P (decl1)
5999 && DECL_UNINLINABLE (decl1)
6000 && lookup_attribute ("noinline", DECL_ATTRIBUTES (decl1)))
6001 warning (OPT_Wattributes, "inline function %q+D given attribute noinline",
6004 announce_function (decl1);
6006 if (!COMPLETE_OR_VOID_TYPE_P (TREE_TYPE (TREE_TYPE (decl1))))
6008 error ("return type is an incomplete type");
6009 /* Make it return void instead. */
6011 = build_function_type (void_type_node,
6012 TYPE_ARG_TYPES (TREE_TYPE (decl1)));
6015 if (warn_about_return_type)
6016 pedwarn_c99 ("return type defaults to %<int%>");
6018 /* Make the init_value nonzero so pushdecl knows this is not tentative.
6019 error_mark_node is replaced below (in pop_scope) with the BLOCK. */
6020 DECL_INITIAL (decl1) = error_mark_node;
6022 /* If this definition isn't a prototype and we had a prototype declaration
6023 before, copy the arg type info from that prototype. */
6024 old_decl = lookup_name_in_scope (DECL_NAME (decl1), current_scope);
6025 if (old_decl && TREE_CODE (old_decl) != FUNCTION_DECL)
6027 current_function_prototype_locus = UNKNOWN_LOCATION;
6028 current_function_prototype_built_in = false;
6029 current_function_prototype_arg_types = NULL_TREE;
6030 if (TYPE_ARG_TYPES (TREE_TYPE (decl1)) == 0)
6032 if (old_decl != 0 && TREE_CODE (TREE_TYPE (old_decl)) == FUNCTION_TYPE
6033 && comptypes (TREE_TYPE (TREE_TYPE (decl1)),
6034 TREE_TYPE (TREE_TYPE (old_decl))))
6036 TREE_TYPE (decl1) = composite_type (TREE_TYPE (old_decl),
6038 current_function_prototype_locus = DECL_SOURCE_LOCATION (old_decl);
6039 current_function_prototype_built_in
6040 = C_DECL_BUILTIN_PROTOTYPE (old_decl);
6041 current_function_prototype_arg_types
6042 = TYPE_ARG_TYPES (TREE_TYPE (decl1));
6044 if (TREE_PUBLIC (decl1))
6046 /* If there is an external prototype declaration of this
6047 function, record its location but do not copy information
6048 to this decl. This may be an invisible declaration
6049 (built-in or in a scope which has finished) or simply
6050 have more refined argument types than any declaration
6052 struct c_binding *b;
6053 for (b = I_SYMBOL_BINDING (DECL_NAME (decl1)); b; b = b->shadowed)
6054 if (B_IN_SCOPE (b, external_scope))
6058 tree ext_decl, ext_type;
6060 ext_type = b->type ? b->type : TREE_TYPE (ext_decl);
6061 if (TREE_CODE (ext_type) == FUNCTION_TYPE
6062 && comptypes (TREE_TYPE (TREE_TYPE (decl1)),
6063 TREE_TYPE (ext_type)))
6065 current_function_prototype_locus
6066 = DECL_SOURCE_LOCATION (ext_decl);
6067 current_function_prototype_built_in
6068 = C_DECL_BUILTIN_PROTOTYPE (ext_decl);
6069 current_function_prototype_arg_types
6070 = TYPE_ARG_TYPES (ext_type);
6076 /* Optionally warn of old-fashioned def with no previous prototype. */
6077 if (warn_strict_prototypes
6078 && old_decl != error_mark_node
6079 && TYPE_ARG_TYPES (TREE_TYPE (decl1)) == 0
6080 && C_DECL_ISNT_PROTOTYPE (old_decl))
6081 warning (OPT_Wstrict_prototypes,
6082 "function declaration isn%'t a prototype");
6083 /* Optionally warn of any global def with no previous prototype. */
6084 else if (warn_missing_prototypes
6085 && old_decl != error_mark_node
6086 && TREE_PUBLIC (decl1)
6087 && !MAIN_NAME_P (DECL_NAME (decl1))
6088 && C_DECL_ISNT_PROTOTYPE (old_decl))
6089 warning (OPT_Wmissing_prototypes, "no previous prototype for %q+D", decl1);
6090 /* Optionally warn of any def with no previous prototype
6091 if the function has already been used. */
6092 else if (warn_missing_prototypes
6094 && old_decl != error_mark_node
6095 && TREE_USED (old_decl)
6096 && TYPE_ARG_TYPES (TREE_TYPE (old_decl)) == 0)
6097 warning (OPT_Wmissing_prototypes,
6098 "%q+D was used with no prototype before its definition", decl1);
6099 /* Optionally warn of any global def with no previous declaration. */
6100 else if (warn_missing_declarations
6101 && TREE_PUBLIC (decl1)
6103 && !MAIN_NAME_P (DECL_NAME (decl1)))
6104 warning (OPT_Wmissing_declarations, "no previous declaration for %q+D",
6106 /* Optionally warn of any def with no previous declaration
6107 if the function has already been used. */
6108 else if (warn_missing_declarations
6110 && old_decl != error_mark_node
6111 && TREE_USED (old_decl)
6112 && C_DECL_IMPLICIT (old_decl))
6113 warning (OPT_Wmissing_declarations,
6114 "%q+D was used with no declaration before its definition", decl1);
6116 /* This is a definition, not a reference.
6117 So normally clear DECL_EXTERNAL.
6118 However, `extern inline' acts like a declaration
6119 except for defining how to inline. So set DECL_EXTERNAL in that case. */
6120 DECL_EXTERNAL (decl1) = current_extern_inline;
6122 /* This function exists in static storage.
6123 (This does not mean `static' in the C sense!) */
6124 TREE_STATIC (decl1) = 1;
6126 /* A nested function is not global. */
6127 if (current_function_decl != 0)
6128 TREE_PUBLIC (decl1) = 0;
6130 /* This is the earliest point at which we might know the assembler
6131 name of the function. Thus, if it's set before this, die horribly. */
6132 gcc_assert (!DECL_ASSEMBLER_NAME_SET_P (decl1));
6134 /* If #pragma weak was used, mark the decl weak now. */
6135 if (current_scope == file_scope)
6136 maybe_apply_pragma_weak (decl1);
6138 /* Warn for unlikely, improbable, or stupid declarations of `main'. */
6139 if (warn_main > 0 && MAIN_NAME_P (DECL_NAME (decl1)))
6144 if (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (decl1)))
6145 != integer_type_node)
6146 pedwarn ("return type of %q+D is not %<int%>", decl1);
6148 for (args = TYPE_ARG_TYPES (TREE_TYPE (decl1)); args;
6149 args = TREE_CHAIN (args))
6151 tree type = args ? TREE_VALUE (args) : 0;
6153 if (type == void_type_node)
6160 if (TYPE_MAIN_VARIANT (type) != integer_type_node)
6161 pedwarn ("first argument of %q+D should be %<int%>", decl1);
6165 if (TREE_CODE (type) != POINTER_TYPE
6166 || TREE_CODE (TREE_TYPE (type)) != POINTER_TYPE
6167 || (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (type)))
6169 pedwarn ("second argument of %q+D should be %<char **%>",
6174 if (TREE_CODE (type) != POINTER_TYPE
6175 || TREE_CODE (TREE_TYPE (type)) != POINTER_TYPE
6176 || (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (type)))
6178 pedwarn ("third argument of %q+D should probably be "
6179 "%<char **%>", decl1);
6184 /* It is intentional that this message does not mention the third
6185 argument because it's only mentioned in an appendix of the
6187 if (argct > 0 && (argct < 2 || argct > 3))
6188 pedwarn ("%q+D takes only zero or two arguments", decl1);
6190 if (!TREE_PUBLIC (decl1))
6191 pedwarn ("%q+D is normally a non-static function", decl1);
6194 /* Record the decl so that the function name is defined.
6195 If we already have a decl for this name, and it is a FUNCTION_DECL,
6196 use the old decl. */
6198 current_function_decl = pushdecl (decl1);
6201 declare_parm_level ();
6203 restype = TREE_TYPE (TREE_TYPE (current_function_decl));
6204 /* Promote the value to int before returning it. */
6205 if (c_promoting_integer_type_p (restype))
6207 /* It retains unsignedness if not really getting wider. */
6208 if (TYPE_UNSIGNED (restype)
6209 && (TYPE_PRECISION (restype)
6210 == TYPE_PRECISION (integer_type_node)))
6211 restype = unsigned_type_node;
6213 restype = integer_type_node;
6216 resdecl = build_decl (RESULT_DECL, NULL_TREE, restype);
6217 DECL_ARTIFICIAL (resdecl) = 1;
6218 DECL_IGNORED_P (resdecl) = 1;
6219 DECL_RESULT (current_function_decl) = resdecl;
6221 start_fname_decls ();
6226 /* Subroutine of store_parm_decls which handles new-style function
6227 definitions (prototype format). The parms already have decls, so we
6228 need only record them as in effect and complain if any redundant
6229 old-style parm decls were written. */
6231 store_parm_decls_newstyle (tree fndecl, const struct c_arg_info *arg_info)
6235 if (current_scope->bindings)
6237 error ("%Jold-style parameter declarations in prototyped "
6238 "function definition", fndecl);
6240 /* Get rid of the old-style declarations. */
6244 /* Don't issue this warning for nested functions, and don't issue this
6245 warning if we got here because ARG_INFO_TYPES was error_mark_node
6246 (this happens when a function definition has just an ellipsis in
6247 its parameter list). */
6248 else if (!in_system_header && !current_function_scope
6249 && arg_info->types != error_mark_node)
6250 warning (OPT_Wtraditional,
6251 "%Jtraditional C rejects ISO C style function definitions",
6254 /* Now make all the parameter declarations visible in the function body.
6255 We can bypass most of the grunt work of pushdecl. */
6256 for (decl = arg_info->parms; decl; decl = TREE_CHAIN (decl))
6258 DECL_CONTEXT (decl) = current_function_decl;
6259 if (DECL_NAME (decl))
6261 bind (DECL_NAME (decl), decl, current_scope,
6262 /*invisible=*/false, /*nested=*/false);
6263 if (!TREE_USED (decl))
6264 warn_if_shadowing (decl);
6267 error ("%Jparameter name omitted", decl);
6270 /* Record the parameter list in the function declaration. */
6271 DECL_ARGUMENTS (fndecl) = arg_info->parms;
6273 /* Now make all the ancillary declarations visible, likewise. */
6274 for (decl = arg_info->others; decl; decl = TREE_CHAIN (decl))
6276 DECL_CONTEXT (decl) = current_function_decl;
6277 if (DECL_NAME (decl))
6278 bind (DECL_NAME (decl), decl, current_scope,
6279 /*invisible=*/false, /*nested=*/false);
6282 /* And all the tag declarations. */
6283 for (decl = arg_info->tags; decl; decl = TREE_CHAIN (decl))
6284 if (TREE_PURPOSE (decl))
6285 bind (TREE_PURPOSE (decl), TREE_VALUE (decl), current_scope,
6286 /*invisible=*/false, /*nested=*/false);
6289 /* Subroutine of store_parm_decls which handles old-style function
6290 definitions (separate parameter list and declarations). */
6293 store_parm_decls_oldstyle (tree fndecl, const struct c_arg_info *arg_info)
6295 struct c_binding *b;
6296 tree parm, decl, last;
6297 tree parmids = arg_info->parms;
6298 struct pointer_set_t *seen_args = pointer_set_create ();
6300 if (!in_system_header)
6301 warning (OPT_Wold_style_definition, "%Jold-style function definition",
6304 /* Match each formal parameter name with its declaration. Save each
6305 decl in the appropriate TREE_PURPOSE slot of the parmids chain. */
6306 for (parm = parmids; parm; parm = TREE_CHAIN (parm))
6308 if (TREE_VALUE (parm) == 0)
6310 error ("%Jparameter name missing from parameter list", fndecl);
6311 TREE_PURPOSE (parm) = 0;
6315 b = I_SYMBOL_BINDING (TREE_VALUE (parm));
6316 if (b && B_IN_CURRENT_SCOPE (b))
6319 /* If we got something other than a PARM_DECL it is an error. */
6320 if (TREE_CODE (decl) != PARM_DECL)
6321 error ("%q+D declared as a non-parameter", decl);
6322 /* If the declaration is already marked, we have a duplicate
6323 name. Complain and ignore the duplicate. */
6324 else if (pointer_set_contains (seen_args, decl))
6326 error ("multiple parameters named %q+D", decl);
6327 TREE_PURPOSE (parm) = 0;
6330 /* If the declaration says "void", complain and turn it into
6332 else if (VOID_TYPE_P (TREE_TYPE (decl)))
6334 error ("parameter %q+D declared with void type", decl);
6335 TREE_TYPE (decl) = integer_type_node;
6336 DECL_ARG_TYPE (decl) = integer_type_node;
6337 layout_decl (decl, 0);
6339 warn_if_shadowing (decl);
6341 /* If no declaration found, default to int. */
6344 decl = build_decl (PARM_DECL, TREE_VALUE (parm), integer_type_node);
6345 DECL_ARG_TYPE (decl) = TREE_TYPE (decl);
6346 DECL_SOURCE_LOCATION (decl) = DECL_SOURCE_LOCATION (fndecl);
6348 warn_if_shadowing (decl);
6351 pedwarn ("type of %q+D defaults to %<int%>", decl);
6352 else if (extra_warnings)
6353 warning (OPT_Wextra, "type of %q+D defaults to %<int%>", decl);
6356 TREE_PURPOSE (parm) = decl;
6357 pointer_set_insert (seen_args, decl);
6360 /* Now examine the parms chain for incomplete declarations
6361 and declarations with no corresponding names. */
6363 for (b = current_scope->bindings; b; b = b->prev)
6366 if (TREE_CODE (parm) != PARM_DECL)
6369 if (TREE_TYPE (parm) != error_mark_node
6370 && !COMPLETE_TYPE_P (TREE_TYPE (parm)))
6372 error ("parameter %q+D has incomplete type", parm);
6373 TREE_TYPE (parm) = error_mark_node;
6376 if (!pointer_set_contains (seen_args, parm))
6378 error ("declaration for parameter %q+D but no such parameter", parm);
6380 /* Pretend the parameter was not missing.
6381 This gets us to a standard state and minimizes
6382 further error messages. */
6383 parmids = chainon (parmids, tree_cons (parm, 0, 0));
6387 /* Chain the declarations together in the order of the list of
6388 names. Store that chain in the function decl, replacing the
6389 list of names. Update the current scope to match. */
6390 DECL_ARGUMENTS (fndecl) = 0;
6392 for (parm = parmids; parm; parm = TREE_CHAIN (parm))
6393 if (TREE_PURPOSE (parm))
6395 if (parm && TREE_PURPOSE (parm))
6397 last = TREE_PURPOSE (parm);
6398 DECL_ARGUMENTS (fndecl) = last;
6400 for (parm = TREE_CHAIN (parm); parm; parm = TREE_CHAIN (parm))
6401 if (TREE_PURPOSE (parm))
6403 TREE_CHAIN (last) = TREE_PURPOSE (parm);
6404 last = TREE_PURPOSE (parm);
6406 TREE_CHAIN (last) = 0;
6409 pointer_set_destroy (seen_args);
6411 /* If there was a previous prototype,
6412 set the DECL_ARG_TYPE of each argument according to
6413 the type previously specified, and report any mismatches. */
6415 if (current_function_prototype_arg_types)
6418 for (parm = DECL_ARGUMENTS (fndecl),
6419 type = current_function_prototype_arg_types;
6420 parm || (type && (TYPE_MAIN_VARIANT (TREE_VALUE (type))
6421 != void_type_node));
6422 parm = TREE_CHAIN (parm), type = TREE_CHAIN (type))
6424 if (parm == 0 || type == 0
6425 || TYPE_MAIN_VARIANT (TREE_VALUE (type)) == void_type_node)
6427 if (current_function_prototype_built_in)
6428 warning (0, "number of arguments doesn%'t match "
6429 "built-in prototype");
6432 error ("number of arguments doesn%'t match prototype");
6433 error ("%Hprototype declaration",
6434 ¤t_function_prototype_locus);
6438 /* Type for passing arg must be consistent with that
6439 declared for the arg. ISO C says we take the unqualified
6440 type for parameters declared with qualified type. */
6441 if (!comptypes (TYPE_MAIN_VARIANT (DECL_ARG_TYPE (parm)),
6442 TYPE_MAIN_VARIANT (TREE_VALUE (type))))
6444 if (TYPE_MAIN_VARIANT (TREE_TYPE (parm))
6445 == TYPE_MAIN_VARIANT (TREE_VALUE (type)))
6447 /* Adjust argument to match prototype. E.g. a previous
6448 `int foo(float);' prototype causes
6449 `int foo(x) float x; {...}' to be treated like
6450 `int foo(float x) {...}'. This is particularly
6451 useful for argument types like uid_t. */
6452 DECL_ARG_TYPE (parm) = TREE_TYPE (parm);
6454 if (targetm.calls.promote_prototypes (TREE_TYPE (current_function_decl))
6455 && INTEGRAL_TYPE_P (TREE_TYPE (parm))
6456 && TYPE_PRECISION (TREE_TYPE (parm))
6457 < TYPE_PRECISION (integer_type_node))
6458 DECL_ARG_TYPE (parm) = integer_type_node;
6462 /* ??? Is it possible to get here with a
6463 built-in prototype or will it always have
6464 been diagnosed as conflicting with an
6465 old-style definition and discarded? */
6466 if (current_function_prototype_built_in)
6467 warning (0, "promoted argument %qD "
6468 "doesn%'t match built-in prototype", parm);
6471 pedwarn ("promoted argument %qD "
6472 "doesn%'t match prototype", parm);
6473 pedwarn ("%Hprototype declaration",
6474 ¤t_function_prototype_locus);
6480 if (current_function_prototype_built_in)
6481 warning (0, "argument %qD doesn%'t match "
6482 "built-in prototype", parm);
6485 error ("argument %qD doesn%'t match prototype", parm);
6486 error ("%Hprototype declaration",
6487 ¤t_function_prototype_locus);
6492 TYPE_ACTUAL_ARG_TYPES (TREE_TYPE (fndecl)) = 0;
6495 /* Otherwise, create a prototype that would match. */
6499 tree actual = 0, last = 0, type;
6501 for (parm = DECL_ARGUMENTS (fndecl); parm; parm = TREE_CHAIN (parm))
6503 type = tree_cons (NULL_TREE, DECL_ARG_TYPE (parm), NULL_TREE);
6505 TREE_CHAIN (last) = type;
6510 type = tree_cons (NULL_TREE, void_type_node, NULL_TREE);
6512 TREE_CHAIN (last) = type;
6516 /* We are going to assign a new value for the TYPE_ACTUAL_ARG_TYPES
6517 of the type of this function, but we need to avoid having this
6518 affect the types of other similarly-typed functions, so we must
6519 first force the generation of an identical (but separate) type
6520 node for the relevant function type. The new node we create
6521 will be a variant of the main variant of the original function
6524 TREE_TYPE (fndecl) = build_variant_type_copy (TREE_TYPE (fndecl));
6526 TYPE_ACTUAL_ARG_TYPES (TREE_TYPE (fndecl)) = actual;
6530 /* Store parameter declarations passed in ARG_INFO into the current
6531 function declaration. */
6534 store_parm_decls_from (struct c_arg_info *arg_info)
6536 current_function_arg_info = arg_info;
6537 store_parm_decls ();
6540 /* Store the parameter declarations into the current function declaration.
6541 This is called after parsing the parameter declarations, before
6542 digesting the body of the function.
6544 For an old-style definition, construct a prototype out of the old-style
6545 parameter declarations and inject it into the function's type. */
6548 store_parm_decls (void)
6550 tree fndecl = current_function_decl;
6553 /* The argument information block for FNDECL. */
6554 struct c_arg_info *arg_info = current_function_arg_info;
6555 current_function_arg_info = 0;
6557 /* True if this definition is written with a prototype. Note:
6558 despite C99 6.7.5.3p14, we can *not* treat an empty argument
6559 list in a function definition as equivalent to (void) -- an
6560 empty argument list specifies the function has no parameters,
6561 but only (void) sets up a prototype for future calls. */
6562 proto = arg_info->types != 0;
6565 store_parm_decls_newstyle (fndecl, arg_info);
6567 store_parm_decls_oldstyle (fndecl, arg_info);
6569 /* The next call to push_scope will be a function body. */
6571 next_is_function_body = true;
6573 /* Write a record describing this function definition to the prototypes
6574 file (if requested). */
6576 gen_aux_info_record (fndecl, 1, 0, proto);
6578 /* Initialize the RTL code for the function. */
6579 allocate_struct_function (fndecl);
6581 /* Begin the statement tree for this function. */
6582 DECL_SAVED_TREE (fndecl) = push_stmt_list ();
6584 /* ??? Insert the contents of the pending sizes list into the function
6585 to be evaluated. The only reason left to have this is
6586 void foo(int n, int array[n++])
6587 because we throw away the array type in favor of a pointer type, and
6588 thus won't naturally see the SAVE_EXPR containing the increment. All
6589 other pending sizes would be handled by gimplify_parameters. */
6592 for (t = nreverse (get_pending_sizes ()); t ; t = TREE_CHAIN (t))
6593 add_stmt (TREE_VALUE (t));
6596 /* Even though we're inside a function body, we still don't want to
6597 call expand_expr to calculate the size of a variable-sized array.
6598 We haven't necessarily assigned RTL to all variables yet, so it's
6599 not safe to try to expand expressions involving them. */
6600 cfun->x_dont_save_pending_sizes_p = 1;
6603 /* Emit diagnostics that require gimple input for detection. Operate on
6604 FNDECL and all its nested functions. */
6607 c_gimple_diagnostics_recursively (tree fndecl)
6609 struct cgraph_node *cgn;
6611 /* Handle attribute((warn_unused_result)). Relies on gimple input. */
6612 c_warn_unused_result (&DECL_SAVED_TREE (fndecl));
6614 /* Notice when OpenMP structured block constraints are violated. */
6616 diagnose_omp_structured_block_errors (fndecl);
6618 /* Finalize all nested functions now. */
6619 cgn = cgraph_node (fndecl);
6620 for (cgn = cgn->nested; cgn ; cgn = cgn->next_nested)
6621 c_gimple_diagnostics_recursively (cgn->decl);
6624 /* Finish up a function declaration and compile that function
6625 all the way to assembler language output. The free the storage
6626 for the function definition.
6628 This is called after parsing the body of the function definition. */
6631 finish_function (void)
6633 tree fndecl = current_function_decl;
6635 label_context_stack_se = label_context_stack_se->next;
6636 label_context_stack_vm = label_context_stack_vm->next;
6638 if (TREE_CODE (fndecl) == FUNCTION_DECL
6639 && targetm.calls.promote_prototypes (TREE_TYPE (fndecl)))
6641 tree args = DECL_ARGUMENTS (fndecl);
6642 for (; args; args = TREE_CHAIN (args))
6644 tree type = TREE_TYPE (args);
6645 if (INTEGRAL_TYPE_P (type)
6646 && TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node))
6647 DECL_ARG_TYPE (args) = integer_type_node;
6651 if (DECL_INITIAL (fndecl) && DECL_INITIAL (fndecl) != error_mark_node)
6652 BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl)) = fndecl;
6654 /* Must mark the RESULT_DECL as being in this function. */
6656 if (DECL_RESULT (fndecl) && DECL_RESULT (fndecl) != error_mark_node)
6657 DECL_CONTEXT (DECL_RESULT (fndecl)) = fndecl;
6659 if (MAIN_NAME_P (DECL_NAME (fndecl)) && flag_hosted)
6661 if (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (fndecl)))
6662 != integer_type_node)
6664 /* If warn_main is 1 (-Wmain) or 2 (-Wall), we have already warned.
6665 If warn_main is -1 (-Wno-main) we don't want to be warned. */
6667 pedwarn ("return type of %q+D is not %<int%>", fndecl);
6673 tree stmt = c_finish_return (integer_zero_node);
6674 #ifdef USE_MAPPED_LOCATION
6675 /* Hack. We don't want the middle-end to warn that this return
6676 is unreachable, so we mark its location as special. Using
6677 UNKNOWN_LOCATION has the problem that it gets clobbered in
6678 annotate_one_with_locus. A cleaner solution might be to
6679 ensure ! should_carry_locus_p (stmt), but that needs a flag.
6681 SET_EXPR_LOCATION (stmt, BUILTINS_LOCATION);
6683 /* Hack. We don't want the middle-end to warn that this
6684 return is unreachable, so put the statement on the
6686 annotate_with_file_line (stmt, input_filename, 0);
6692 /* Tie off the statement tree for this function. */
6693 DECL_SAVED_TREE (fndecl) = pop_stmt_list (DECL_SAVED_TREE (fndecl));
6695 finish_fname_decls ();
6697 /* Complain if there's just no return statement. */
6698 if (warn_return_type
6699 && TREE_CODE (TREE_TYPE (TREE_TYPE (fndecl))) != VOID_TYPE
6700 && !current_function_returns_value && !current_function_returns_null
6701 /* Don't complain if we are no-return. */
6702 && !current_function_returns_abnormally
6703 /* Don't warn for main(). */
6704 && !MAIN_NAME_P (DECL_NAME (fndecl))
6705 /* Or if they didn't actually specify a return type. */
6706 && !C_FUNCTION_IMPLICIT_INT (fndecl)
6707 /* Normally, with -Wreturn-type, flow will complain. Unless we're an
6708 inline function, as we might never be compiled separately. */
6709 && DECL_INLINE (fndecl))
6711 warning (OPT_Wreturn_type,
6712 "no return statement in function returning non-void");
6713 TREE_NO_WARNING (fndecl) = 1;
6716 /* With just -Wextra, complain only if function returns both with
6717 and without a value. */
6719 && current_function_returns_value
6720 && current_function_returns_null)
6721 warning (OPT_Wextra, "this function may return with or without a value");
6723 /* Store the end of the function, so that we get good line number
6724 info for the epilogue. */
6725 cfun->function_end_locus = input_location;
6727 /* If we don't have ctors/dtors sections, and this is a static
6728 constructor or destructor, it must be recorded now. */
6729 if (DECL_STATIC_CONSTRUCTOR (fndecl)
6730 && !targetm.have_ctors_dtors)
6731 static_ctors = tree_cons (NULL_TREE, fndecl, static_ctors);
6732 if (DECL_STATIC_DESTRUCTOR (fndecl)
6733 && !targetm.have_ctors_dtors)
6734 static_dtors = tree_cons (NULL_TREE, fndecl, static_dtors);
6736 /* Finalize the ELF visibility for the function. */
6737 c_determine_visibility (fndecl);
6739 /* Genericize before inlining. Delay genericizing nested functions
6740 until their parent function is genericized. Since finalizing
6741 requires GENERIC, delay that as well. */
6743 if (DECL_INITIAL (fndecl) && DECL_INITIAL (fndecl) != error_mark_node
6744 && !undef_nested_function)
6746 if (!decl_function_context (fndecl))
6748 c_genericize (fndecl);
6749 c_gimple_diagnostics_recursively (fndecl);
6751 /* ??? Objc emits functions after finalizing the compilation unit.
6752 This should be cleaned up later and this conditional removed. */
6753 if (cgraph_global_info_ready)
6755 c_expand_body (fndecl);
6759 cgraph_finalize_function (fndecl, false);
6763 /* Register this function with cgraph just far enough to get it
6764 added to our parent's nested function list. Handy, since the
6765 C front end doesn't have such a list. */
6766 (void) cgraph_node (fndecl);
6770 if (!decl_function_context (fndecl))
6771 undef_nested_function = false;
6773 /* We're leaving the context of this function, so zap cfun.
6774 It's still in DECL_STRUCT_FUNCTION, and we'll restore it in
6775 tree_rest_of_compilation. */
6777 current_function_decl = NULL;
6780 /* Generate the RTL for the body of FNDECL. */
6783 c_expand_body (tree fndecl)
6786 if (!DECL_INITIAL (fndecl)
6787 || DECL_INITIAL (fndecl) == error_mark_node)
6790 tree_rest_of_compilation (fndecl);
6792 if (DECL_STATIC_CONSTRUCTOR (fndecl)
6793 && targetm.have_ctors_dtors)
6794 targetm.asm_out.constructor (XEXP (DECL_RTL (fndecl), 0),
6795 DEFAULT_INIT_PRIORITY);
6796 if (DECL_STATIC_DESTRUCTOR (fndecl)
6797 && targetm.have_ctors_dtors)
6798 targetm.asm_out.destructor (XEXP (DECL_RTL (fndecl), 0),
6799 DEFAULT_INIT_PRIORITY);
6802 /* Check the declarations given in a for-loop for satisfying the C99
6803 constraints. If exactly one such decl is found, return it. */
6806 check_for_loop_decls (void)
6808 struct c_binding *b;
6809 tree one_decl = NULL_TREE;
6815 /* If we get here, declarations have been used in a for loop without
6816 the C99 for loop scope. This doesn't make much sense, so don't
6818 error ("%<for%> loop initial declaration used outside C99 mode");
6821 /* C99 subclause 6.8.5 paragraph 3:
6823 [#3] The declaration part of a for statement shall only
6824 declare identifiers for objects having storage class auto or
6827 It isn't clear whether, in this sentence, "identifiers" binds to
6828 "shall only declare" or to "objects" - that is, whether all identifiers
6829 declared must be identifiers for objects, or whether the restriction
6830 only applies to those that are. (A question on this in comp.std.c
6831 in November 2000 received no answer.) We implement the strictest
6832 interpretation, to avoid creating an extension which later causes
6835 for (b = current_scope->bindings; b; b = b->prev)
6838 tree decl = b->decl;
6843 switch (TREE_CODE (decl))
6846 if (TREE_STATIC (decl))
6847 error ("declaration of static variable %q+D in %<for%> loop "
6848 "initial declaration", decl);
6849 else if (DECL_EXTERNAL (decl))
6850 error ("declaration of %<extern%> variable %q+D in %<for%> loop "
6851 "initial declaration", decl);
6855 error ("%<struct %E%> declared in %<for%> loop initial declaration",
6859 error ("%<union %E%> declared in %<for%> loop initial declaration",
6863 error ("%<enum %E%> declared in %<for%> loop initial declaration",
6867 error ("declaration of non-variable %q+D in %<for%> loop "
6868 "initial declaration", decl);
6875 return n_decls == 1 ? one_decl : NULL_TREE;
6878 /* Save and reinitialize the variables
6879 used during compilation of a C function. */
6882 c_push_function_context (struct function *f)
6884 struct language_function *p;
6885 p = GGC_NEW (struct language_function);
6888 p->base.x_stmt_tree = c_stmt_tree;
6889 p->x_break_label = c_break_label;
6890 p->x_cont_label = c_cont_label;
6891 p->x_switch_stack = c_switch_stack;
6892 p->arg_info = current_function_arg_info;
6893 p->returns_value = current_function_returns_value;
6894 p->returns_null = current_function_returns_null;
6895 p->returns_abnormally = current_function_returns_abnormally;
6896 p->warn_about_return_type = warn_about_return_type;
6897 p->extern_inline = current_extern_inline;
6900 /* Restore the variables used during compilation of a C function. */
6903 c_pop_function_context (struct function *f)
6905 struct language_function *p = f->language;
6907 if (DECL_STRUCT_FUNCTION (current_function_decl) == 0
6908 && DECL_SAVED_TREE (current_function_decl) == NULL_TREE)
6910 /* Stop pointing to the local nodes about to be freed. */
6911 /* But DECL_INITIAL must remain nonzero so we know this
6912 was an actual function definition. */
6913 DECL_INITIAL (current_function_decl) = error_mark_node;
6914 DECL_ARGUMENTS (current_function_decl) = 0;
6917 c_stmt_tree = p->base.x_stmt_tree;
6918 c_break_label = p->x_break_label;
6919 c_cont_label = p->x_cont_label;
6920 c_switch_stack = p->x_switch_stack;
6921 current_function_arg_info = p->arg_info;
6922 current_function_returns_value = p->returns_value;
6923 current_function_returns_null = p->returns_null;
6924 current_function_returns_abnormally = p->returns_abnormally;
6925 warn_about_return_type = p->warn_about_return_type;
6926 current_extern_inline = p->extern_inline;
6931 /* Copy the DECL_LANG_SPECIFIC data associated with DECL. */
6934 c_dup_lang_specific_decl (tree decl)
6936 struct lang_decl *ld;
6938 if (!DECL_LANG_SPECIFIC (decl))
6941 ld = GGC_NEW (struct lang_decl);
6942 memcpy (ld, DECL_LANG_SPECIFIC (decl), sizeof (struct lang_decl));
6943 DECL_LANG_SPECIFIC (decl) = ld;
6946 /* The functions below are required for functionality of doing
6947 function at once processing in the C front end. Currently these
6948 functions are not called from anywhere in the C front end, but as
6949 these changes continue, that will change. */
6951 /* Returns the stmt_tree (if any) to which statements are currently
6952 being added. If there is no active statement-tree, NULL is
6956 current_stmt_tree (void)
6958 return &c_stmt_tree;
6961 /* Nonzero if TYPE is an anonymous union or struct type. Always 0 in
6965 anon_aggr_type_p (tree ARG_UNUSED (node))
6970 /* Return the global value of T as a symbol. */
6973 identifier_global_value (tree t)
6975 struct c_binding *b;
6977 for (b = I_SYMBOL_BINDING (t); b; b = b->shadowed)
6978 if (B_IN_FILE_SCOPE (b) || B_IN_EXTERNAL_SCOPE (b))
6984 /* Record a builtin type for C. If NAME is non-NULL, it is the name used;
6985 otherwise the name is found in ridpointers from RID_INDEX. */
6988 record_builtin_type (enum rid rid_index, const char *name, tree type)
6992 id = ridpointers[(int) rid_index];
6994 id = get_identifier (name);
6995 decl = build_decl (TYPE_DECL, id, type);
6997 if (debug_hooks->type_decl)
6998 debug_hooks->type_decl (decl, false);
7001 /* Build the void_list_node (void_type_node having been created). */
7003 build_void_list_node (void)
7005 tree t = build_tree_list (NULL_TREE, void_type_node);
7009 /* Return a c_parm structure with the given SPECS, ATTRS and DECLARATOR. */
7012 build_c_parm (struct c_declspecs *specs, tree attrs,
7013 struct c_declarator *declarator)
7015 struct c_parm *ret = XOBNEW (&parser_obstack, struct c_parm);
7018 ret->declarator = declarator;
7022 /* Return a declarator with nested attributes. TARGET is the inner
7023 declarator to which these attributes apply. ATTRS are the
7026 struct c_declarator *
7027 build_attrs_declarator (tree attrs, struct c_declarator *target)
7029 struct c_declarator *ret = XOBNEW (&parser_obstack, struct c_declarator);
7030 ret->kind = cdk_attrs;
7031 ret->declarator = target;
7032 ret->u.attrs = attrs;
7036 /* Return a declarator for a function with arguments specified by ARGS
7037 and return type specified by TARGET. */
7039 struct c_declarator *
7040 build_function_declarator (struct c_arg_info *args,
7041 struct c_declarator *target)
7043 struct c_declarator *ret = XOBNEW (&parser_obstack, struct c_declarator);
7044 ret->kind = cdk_function;
7045 ret->declarator = target;
7046 ret->u.arg_info = args;
7050 /* Return a declarator for the identifier IDENT (which may be
7051 NULL_TREE for an abstract declarator). */
7053 struct c_declarator *
7054 build_id_declarator (tree ident)
7056 struct c_declarator *ret = XOBNEW (&parser_obstack, struct c_declarator);
7058 ret->declarator = 0;
7060 /* Default value - may get reset to a more precise location. */
7061 ret->id_loc = input_location;
7065 /* Return something to represent absolute declarators containing a *.
7066 TARGET is the absolute declarator that the * contains.
7067 TYPE_QUALS_ATTRS is a structure for type qualifiers and attributes
7068 to apply to the pointer type. */
7070 struct c_declarator *
7071 make_pointer_declarator (struct c_declspecs *type_quals_attrs,
7072 struct c_declarator *target)
7076 struct c_declarator *itarget = target;
7077 struct c_declarator *ret = XOBNEW (&parser_obstack, struct c_declarator);
7078 if (type_quals_attrs)
7080 attrs = type_quals_attrs->attrs;
7081 quals = quals_from_declspecs (type_quals_attrs);
7082 if (attrs != NULL_TREE)
7083 itarget = build_attrs_declarator (attrs, target);
7085 ret->kind = cdk_pointer;
7086 ret->declarator = itarget;
7087 ret->u.pointer_quals = quals;
7091 /* Return a pointer to a structure for an empty list of declaration
7094 struct c_declspecs *
7095 build_null_declspecs (void)
7097 struct c_declspecs *ret = XOBNEW (&parser_obstack, struct c_declspecs);
7101 ret->typespec_word = cts_none;
7102 ret->storage_class = csc_none;
7103 ret->declspecs_seen_p = false;
7104 ret->type_seen_p = false;
7105 ret->non_sc_seen_p = false;
7106 ret->typedef_p = false;
7107 ret->tag_defined_p = false;
7108 ret->explicit_signed_p = false;
7109 ret->deprecated_p = false;
7110 ret->default_int_p = false;
7111 ret->long_p = false;
7112 ret->long_long_p = false;
7113 ret->short_p = false;
7114 ret->signed_p = false;
7115 ret->unsigned_p = false;
7116 ret->complex_p = false;
7117 ret->inline_p = false;
7118 ret->thread_p = false;
7119 ret->const_p = false;
7120 ret->volatile_p = false;
7121 ret->restrict_p = false;
7125 /* Add the type qualifier QUAL to the declaration specifiers SPECS,
7128 struct c_declspecs *
7129 declspecs_add_qual (struct c_declspecs *specs, tree qual)
7133 specs->non_sc_seen_p = true;
7134 specs->declspecs_seen_p = true;
7135 gcc_assert (TREE_CODE (qual) == IDENTIFIER_NODE
7136 && C_IS_RESERVED_WORD (qual));
7137 i = C_RID_CODE (qual);
7141 dupe = specs->const_p;
7142 specs->const_p = true;
7145 dupe = specs->volatile_p;
7146 specs->volatile_p = true;
7149 dupe = specs->restrict_p;
7150 specs->restrict_p = true;
7155 if (dupe && pedantic && !flag_isoc99)
7156 pedwarn ("duplicate %qE", qual);
7160 /* Add the type specifier TYPE to the declaration specifiers SPECS,
7163 struct c_declspecs *
7164 declspecs_add_type (struct c_declspecs *specs, struct c_typespec spec)
7166 tree type = spec.spec;
7167 specs->non_sc_seen_p = true;
7168 specs->declspecs_seen_p = true;
7169 specs->type_seen_p = true;
7170 if (TREE_DEPRECATED (type))
7171 specs->deprecated_p = true;
7173 /* Handle type specifier keywords. */
7174 if (TREE_CODE (type) == IDENTIFIER_NODE && C_IS_RESERVED_WORD (type))
7176 enum rid i = C_RID_CODE (type);
7179 error ("two or more data types in declaration specifiers");
7182 if ((int) i <= (int) RID_LAST_MODIFIER)
7184 /* "long", "short", "signed", "unsigned" or "_Complex". */
7189 if (specs->long_long_p)
7191 error ("%<long long long%> is too long for GCC");
7196 if (specs->typespec_word == cts_double)
7198 error ("both %<long long%> and %<double%> in "
7199 "declaration specifiers");
7202 if (pedantic && !flag_isoc99 && !in_system_header
7204 pedwarn ("ISO C90 does not support %<long long%>");
7205 specs->long_long_p = 1;
7209 error ("both %<long%> and %<short%> in "
7210 "declaration specifiers");
7211 else if (specs->typespec_word == cts_void)
7212 error ("both %<long%> and %<void%> in "
7213 "declaration specifiers");
7214 else if (specs->typespec_word == cts_bool)
7215 error ("both %<long%> and %<_Bool%> in "
7216 "declaration specifiers");
7217 else if (specs->typespec_word == cts_char)
7218 error ("both %<long%> and %<char%> in "
7219 "declaration specifiers");
7220 else if (specs->typespec_word == cts_float)
7221 error ("both %<long%> and %<float%> in "
7222 "declaration specifiers");
7223 else if (specs->typespec_word == cts_dfloat32)
7224 error ("both %<long%> and %<_Decimal32%> in "
7225 "declaration specifiers");
7226 else if (specs->typespec_word == cts_dfloat64)
7227 error ("both %<long%> and %<_Decimal64%> in "
7228 "declaration specifiers");
7229 else if (specs->typespec_word == cts_dfloat128)
7230 error ("both %<long%> and %<_Decimal128%> in "
7231 "declaration specifiers");
7233 specs->long_p = true;
7236 dupe = specs->short_p;
7238 error ("both %<long%> and %<short%> in "
7239 "declaration specifiers");
7240 else if (specs->typespec_word == cts_void)
7241 error ("both %<short%> and %<void%> in "
7242 "declaration specifiers");
7243 else if (specs->typespec_word == cts_bool)
7244 error ("both %<short%> and %<_Bool%> in "
7245 "declaration specifiers");
7246 else if (specs->typespec_word == cts_char)
7247 error ("both %<short%> and %<char%> in "
7248 "declaration specifiers");
7249 else if (specs->typespec_word == cts_float)
7250 error ("both %<short%> and %<float%> in "
7251 "declaration specifiers");
7252 else if (specs->typespec_word == cts_double)
7253 error ("both %<short%> and %<double%> in "
7254 "declaration specifiers");
7255 else if (specs->typespec_word == cts_dfloat32)
7256 error ("both %<short%> and %<_Decimal32%> in "
7257 "declaration specifiers");
7258 else if (specs->typespec_word == cts_dfloat64)
7259 error ("both %<short%> and %<_Decimal64%> in "
7260 "declaration specifiers");
7261 else if (specs->typespec_word == cts_dfloat128)
7262 error ("both %<short%> and %<_Decimal128%> in "
7263 "declaration specifiers");
7265 specs->short_p = true;
7268 dupe = specs->signed_p;
7269 if (specs->unsigned_p)
7270 error ("both %<signed%> and %<unsigned%> in "
7271 "declaration specifiers");
7272 else if (specs->typespec_word == cts_void)
7273 error ("both %<signed%> and %<void%> in "
7274 "declaration specifiers");
7275 else if (specs->typespec_word == cts_bool)
7276 error ("both %<signed%> and %<_Bool%> in "
7277 "declaration specifiers");
7278 else if (specs->typespec_word == cts_float)
7279 error ("both %<signed%> and %<float%> in "
7280 "declaration specifiers");
7281 else if (specs->typespec_word == cts_double)
7282 error ("both %<signed%> and %<double%> in "
7283 "declaration specifiers");
7284 else if (specs->typespec_word == cts_dfloat32)
7285 error ("both %<signed%> and %<_Decimal32%> in "
7286 "declaration specifiers");
7287 else if (specs->typespec_word == cts_dfloat64)
7288 error ("both %<signed%> and %<_Decimal64%> in "
7289 "declaration specifiers");
7290 else if (specs->typespec_word == cts_dfloat128)
7291 error ("both %<signed%> and %<_Decimal128%> in "
7292 "declaration specifiers");
7294 specs->signed_p = true;
7297 dupe = specs->unsigned_p;
7298 if (specs->signed_p)
7299 error ("both %<signed%> and %<unsigned%> in "
7300 "declaration specifiers");
7301 else if (specs->typespec_word == cts_void)
7302 error ("both %<unsigned%> and %<void%> in "
7303 "declaration specifiers");
7304 else if (specs->typespec_word == cts_bool)
7305 error ("both %<unsigned%> and %<_Bool%> in "
7306 "declaration specifiers");
7307 else if (specs->typespec_word == cts_float)
7308 error ("both %<unsigned%> and %<float%> in "
7309 "declaration specifiers");
7310 else if (specs->typespec_word == cts_double)
7311 error ("both %<unsigned%> and %<double%> in "
7312 "declaration specifiers");
7313 else if (specs->typespec_word == cts_dfloat32)
7314 error ("both %<unsigned%> and %<_Decimal32%> in "
7315 "declaration specifiers");
7316 else if (specs->typespec_word == cts_dfloat64)
7317 error ("both %<unsigned%> and %<_Decimal64%> in "
7318 "declaration specifiers");
7319 else if (specs->typespec_word == cts_dfloat128)
7320 error ("both %<unsigned%> and %<_Decimal128%> in "
7321 "declaration specifiers");
7323 specs->unsigned_p = true;
7326 dupe = specs->complex_p;
7327 if (pedantic && !flag_isoc99 && !in_system_header)
7328 pedwarn ("ISO C90 does not support complex types");
7329 if (specs->typespec_word == cts_void)
7330 error ("both %<complex%> and %<void%> in "
7331 "declaration specifiers");
7332 else if (specs->typespec_word == cts_bool)
7333 error ("both %<complex%> and %<_Bool%> in "
7334 "declaration specifiers");
7335 else if (specs->typespec_word == cts_dfloat32)
7336 error ("both %<complex%> and %<_Decimal32%> in "
7337 "declaration specifiers");
7338 else if (specs->typespec_word == cts_dfloat64)
7339 error ("both %<complex%> and %<_Decimal64%> in "
7340 "declaration specifiers");
7341 else if (specs->typespec_word == cts_dfloat128)
7342 error ("both %<complex%> and %<_Decimal128%> in "
7343 "declaration specifiers");
7345 specs->complex_p = true;
7352 error ("duplicate %qE", type);
7358 /* "void", "_Bool", "char", "int", "float" or "double". */
7359 if (specs->typespec_word != cts_none)
7361 error ("two or more data types in declaration specifiers");
7368 error ("both %<long%> and %<void%> in "
7369 "declaration specifiers");
7370 else if (specs->short_p)
7371 error ("both %<short%> and %<void%> in "
7372 "declaration specifiers");
7373 else if (specs->signed_p)
7374 error ("both %<signed%> and %<void%> in "
7375 "declaration specifiers");
7376 else if (specs->unsigned_p)
7377 error ("both %<unsigned%> and %<void%> in "
7378 "declaration specifiers");
7379 else if (specs->complex_p)
7380 error ("both %<complex%> and %<void%> in "
7381 "declaration specifiers");
7383 specs->typespec_word = cts_void;
7387 error ("both %<long%> and %<_Bool%> in "
7388 "declaration specifiers");
7389 else if (specs->short_p)
7390 error ("both %<short%> and %<_Bool%> in "
7391 "declaration specifiers");
7392 else if (specs->signed_p)
7393 error ("both %<signed%> and %<_Bool%> in "
7394 "declaration specifiers");
7395 else if (specs->unsigned_p)
7396 error ("both %<unsigned%> and %<_Bool%> in "
7397 "declaration specifiers");
7398 else if (specs->complex_p)
7399 error ("both %<complex%> and %<_Bool%> in "
7400 "declaration specifiers");
7402 specs->typespec_word = cts_bool;
7406 error ("both %<long%> and %<char%> in "
7407 "declaration specifiers");
7408 else if (specs->short_p)
7409 error ("both %<short%> and %<char%> in "
7410 "declaration specifiers");
7412 specs->typespec_word = cts_char;
7415 specs->typespec_word = cts_int;
7419 error ("both %<long%> and %<float%> in "
7420 "declaration specifiers");
7421 else if (specs->short_p)
7422 error ("both %<short%> and %<float%> in "
7423 "declaration specifiers");
7424 else if (specs->signed_p)
7425 error ("both %<signed%> and %<float%> in "
7426 "declaration specifiers");
7427 else if (specs->unsigned_p)
7428 error ("both %<unsigned%> and %<float%> in "
7429 "declaration specifiers");
7431 specs->typespec_word = cts_float;
7434 if (specs->long_long_p)
7435 error ("both %<long long%> and %<double%> in "
7436 "declaration specifiers");
7437 else if (specs->short_p)
7438 error ("both %<short%> and %<double%> in "
7439 "declaration specifiers");
7440 else if (specs->signed_p)
7441 error ("both %<signed%> and %<double%> in "
7442 "declaration specifiers");
7443 else if (specs->unsigned_p)
7444 error ("both %<unsigned%> and %<double%> in "
7445 "declaration specifiers");
7447 specs->typespec_word = cts_double;
7454 if (i == RID_DFLOAT32)
7456 else if (i == RID_DFLOAT64)
7459 str = "_Decimal128";
7460 if (specs->long_long_p)
7461 error ("both %<long long%> and %<%s%> in "
7462 "declaration specifiers", str);
7464 error ("both %<long%> and %<%s%> in "
7465 "declaration specifiers", str);
7466 else if (specs->short_p)
7467 error ("both %<short%> and %<%s%> in "
7468 "declaration specifiers", str);
7469 else if (specs->signed_p)
7470 error ("both %<signed%> and %<%s%> in "
7471 "declaration specifiers", str);
7472 else if (specs->unsigned_p)
7473 error ("both %<unsigned%> and %<%s%> in "
7474 "declaration specifiers", str);
7475 else if (specs->complex_p)
7476 error ("both %<complex%> and %<%s%> in "
7477 "declaration specifiers", str);
7478 else if (i == RID_DFLOAT32)
7479 specs->typespec_word = cts_dfloat32;
7480 else if (i == RID_DFLOAT64)
7481 specs->typespec_word = cts_dfloat64;
7483 specs->typespec_word = cts_dfloat128;
7485 if (!targetm.decimal_float_supported_p ())
7486 error ("decimal floating point not supported for this target");
7488 pedwarn ("ISO C does not support decimal floating point");
7491 /* ObjC reserved word "id", handled below. */
7497 /* Now we have a typedef (a TYPE_DECL node), an identifier (some
7498 form of ObjC type, cases such as "int" and "long" being handled
7499 above), a TYPE (struct, union, enum and typeof specifiers) or an
7500 ERROR_MARK. In none of these cases may there have previously
7501 been any type specifiers. */
7502 if (specs->type || specs->typespec_word != cts_none
7503 || specs->long_p || specs->short_p || specs->signed_p
7504 || specs->unsigned_p || specs->complex_p)
7505 error ("two or more data types in declaration specifiers");
7506 else if (TREE_CODE (type) == TYPE_DECL)
7508 if (TREE_TYPE (type) == error_mark_node)
7509 ; /* Allow the type to default to int to avoid cascading errors. */
7512 specs->type = TREE_TYPE (type);
7513 specs->decl_attr = DECL_ATTRIBUTES (type);
7514 specs->typedef_p = true;
7515 specs->explicit_signed_p = C_TYPEDEF_EXPLICITLY_SIGNED (type);
7518 else if (TREE_CODE (type) == IDENTIFIER_NODE)
7520 tree t = lookup_name (type);
7521 if (!t || TREE_CODE (t) != TYPE_DECL)
7522 error ("%qE fails to be a typedef or built in type", type);
7523 else if (TREE_TYPE (t) == error_mark_node)
7526 specs->type = TREE_TYPE (t);
7528 else if (TREE_CODE (type) != ERROR_MARK)
7530 if (spec.kind == ctsk_tagdef || spec.kind == ctsk_tagfirstref)
7531 specs->tag_defined_p = true;
7532 if (spec.kind == ctsk_typeof)
7533 specs->typedef_p = true;
7540 /* Add the storage class specifier or function specifier SCSPEC to the
7541 declaration specifiers SPECS, returning SPECS. */
7543 struct c_declspecs *
7544 declspecs_add_scspec (struct c_declspecs *specs, tree scspec)
7547 enum c_storage_class n = csc_none;
7549 specs->declspecs_seen_p = true;
7550 gcc_assert (TREE_CODE (scspec) == IDENTIFIER_NODE
7551 && C_IS_RESERVED_WORD (scspec));
7552 i = C_RID_CODE (scspec);
7553 if (extra_warnings && specs->non_sc_seen_p)
7554 warning (OPT_Wextra, "%qE is not at beginning of declaration", scspec);
7558 /* C99 permits duplicate inline. Although of doubtful utility,
7559 it seems simplest to permit it in gnu89 mode as well, as
7560 there is also little utility in maintaining this as a
7561 difference between gnu89 and C99 inline. */
7563 specs->inline_p = true;
7566 dupe = specs->thread_p;
7567 if (specs->storage_class == csc_auto)
7568 error ("%<__thread%> used with %<auto%>");
7569 else if (specs->storage_class == csc_register)
7570 error ("%<__thread%> used with %<register%>");
7571 else if (specs->storage_class == csc_typedef)
7572 error ("%<__thread%> used with %<typedef%>");
7574 specs->thread_p = true;
7581 /* Diagnose "__thread extern". */
7582 if (specs->thread_p)
7583 error ("%<__thread%> before %<extern%>");
7590 /* Diagnose "__thread static". */
7591 if (specs->thread_p)
7592 error ("%<__thread%> before %<static%>");
7600 if (n != csc_none && n == specs->storage_class)
7603 error ("duplicate %qE", scspec);
7606 if (specs->storage_class != csc_none && n != specs->storage_class)
7608 error ("multiple storage classes in declaration specifiers");
7612 specs->storage_class = n;
7613 if (n != csc_extern && n != csc_static && specs->thread_p)
7615 error ("%<__thread%> used with %qE", scspec);
7616 specs->thread_p = false;
7623 /* Add the attributes ATTRS to the declaration specifiers SPECS,
7626 struct c_declspecs *
7627 declspecs_add_attrs (struct c_declspecs *specs, tree attrs)
7629 specs->attrs = chainon (attrs, specs->attrs);
7630 specs->declspecs_seen_p = true;
7634 /* Combine "long", "short", "signed", "unsigned" and "_Complex" type
7635 specifiers with any other type specifier to determine the resulting
7636 type. This is where ISO C checks on complex types are made, since
7637 "_Complex long" is a prefix of the valid ISO C type "_Complex long
7640 struct c_declspecs *
7641 finish_declspecs (struct c_declspecs *specs)
7643 /* If a type was specified as a whole, we have no modifiers and are
7645 if (specs->type != NULL_TREE)
7647 gcc_assert (!specs->long_p && !specs->long_long_p && !specs->short_p
7648 && !specs->signed_p && !specs->unsigned_p
7649 && !specs->complex_p);
7653 /* If none of "void", "_Bool", "char", "int", "float" or "double"
7654 has been specified, treat it as "int" unless "_Complex" is
7655 present and there are no other specifiers. If we just have
7656 "_Complex", it is equivalent to "_Complex double", but e.g.
7657 "_Complex short" is equivalent to "_Complex short int". */
7658 if (specs->typespec_word == cts_none)
7660 if (specs->long_p || specs->short_p
7661 || specs->signed_p || specs->unsigned_p)
7663 specs->typespec_word = cts_int;
7665 else if (specs->complex_p)
7667 specs->typespec_word = cts_double;
7669 pedwarn ("ISO C does not support plain %<complex%> meaning "
7670 "%<double complex%>");
7674 specs->typespec_word = cts_int;
7675 specs->default_int_p = true;
7676 /* We don't diagnose this here because grokdeclarator will
7677 give more specific diagnostics according to whether it is
7678 a function definition. */
7682 /* If "signed" was specified, record this to distinguish "int" and
7683 "signed int" in the case of a bit-field with
7684 -funsigned-bitfields. */
7685 specs->explicit_signed_p = specs->signed_p;
7687 /* Now compute the actual type. */
7688 switch (specs->typespec_word)
7691 gcc_assert (!specs->long_p && !specs->short_p
7692 && !specs->signed_p && !specs->unsigned_p
7693 && !specs->complex_p);
7694 specs->type = void_type_node;
7697 gcc_assert (!specs->long_p && !specs->short_p
7698 && !specs->signed_p && !specs->unsigned_p
7699 && !specs->complex_p);
7700 specs->type = boolean_type_node;
7703 gcc_assert (!specs->long_p && !specs->short_p);
7704 gcc_assert (!(specs->signed_p && specs->unsigned_p));
7705 if (specs->signed_p)
7706 specs->type = signed_char_type_node;
7707 else if (specs->unsigned_p)
7708 specs->type = unsigned_char_type_node;
7710 specs->type = char_type_node;
7711 if (specs->complex_p)
7714 pedwarn ("ISO C does not support complex integer types");
7715 specs->type = build_complex_type (specs->type);
7719 gcc_assert (!(specs->long_p && specs->short_p));
7720 gcc_assert (!(specs->signed_p && specs->unsigned_p));
7721 if (specs->long_long_p)
7722 specs->type = (specs->unsigned_p
7723 ? long_long_unsigned_type_node
7724 : long_long_integer_type_node);
7725 else if (specs->long_p)
7726 specs->type = (specs->unsigned_p
7727 ? long_unsigned_type_node
7728 : long_integer_type_node);
7729 else if (specs->short_p)
7730 specs->type = (specs->unsigned_p
7731 ? short_unsigned_type_node
7732 : short_integer_type_node);
7734 specs->type = (specs->unsigned_p
7735 ? unsigned_type_node
7736 : integer_type_node);
7737 if (specs->complex_p)
7740 pedwarn ("ISO C does not support complex integer types");
7741 specs->type = build_complex_type (specs->type);
7745 gcc_assert (!specs->long_p && !specs->short_p
7746 && !specs->signed_p && !specs->unsigned_p);
7747 specs->type = (specs->complex_p
7748 ? complex_float_type_node
7752 gcc_assert (!specs->long_long_p && !specs->short_p
7753 && !specs->signed_p && !specs->unsigned_p);
7756 specs->type = (specs->complex_p
7757 ? complex_long_double_type_node
7758 : long_double_type_node);
7762 specs->type = (specs->complex_p
7763 ? complex_double_type_node
7764 : double_type_node);
7770 gcc_assert (!specs->long_p && !specs->long_long_p && !specs->short_p
7771 && !specs->signed_p && !specs->unsigned_p && !specs->complex_p);
7772 if (specs->typespec_word == cts_dfloat32)
7773 specs->type = dfloat32_type_node;
7774 else if (specs->typespec_word == cts_dfloat64)
7775 specs->type = dfloat64_type_node;
7777 specs->type = dfloat128_type_node;
7786 /* Synthesize a function which calls all the global ctors or global
7787 dtors in this file. This is only used for targets which do not
7788 support .ctors/.dtors sections. FIXME: Migrate into cgraph. */
7790 build_cdtor (int method_type, tree cdtors)
7797 for (; cdtors; cdtors = TREE_CHAIN (cdtors))
7798 append_to_statement_list (build_function_call (TREE_VALUE (cdtors), 0),
7801 cgraph_build_static_cdtor (method_type, body, DEFAULT_INIT_PRIORITY);
7804 /* A subroutine of c_write_global_declarations. Perform final processing
7805 on one file scope's declarations (or the external scope's declarations),
7809 c_write_global_declarations_1 (tree globals)
7814 /* Process the decls in the order they were written. */
7815 for (decl = globals; decl; decl = TREE_CHAIN (decl))
7817 /* Check for used but undefined static functions using the C
7818 standard's definition of "used", and set TREE_NO_WARNING so
7819 that check_global_declarations doesn't repeat the check. */
7820 if (TREE_CODE (decl) == FUNCTION_DECL
7821 && DECL_INITIAL (decl) == 0
7822 && DECL_EXTERNAL (decl)
7823 && !TREE_PUBLIC (decl)
7824 && C_DECL_USED (decl))
7826 pedwarn ("%q+F used but never defined", decl);
7827 TREE_NO_WARNING (decl) = 1;
7830 wrapup_global_declaration_1 (decl);
7836 for (decl = globals; decl; decl = TREE_CHAIN (decl))
7837 reconsider |= wrapup_global_declaration_2 (decl);
7841 for (decl = globals; decl; decl = TREE_CHAIN (decl))
7842 check_global_declaration_1 (decl);
7845 /* A subroutine of c_write_global_declarations Emit debug information for each
7846 of the declarations in GLOBALS. */
7849 c_write_global_declarations_2 (tree globals)
7853 for (decl = globals; decl ; decl = TREE_CHAIN (decl))
7854 debug_hooks->global_decl (decl);
7857 /* Preserve the external declarations scope across a garbage collect. */
7858 static GTY(()) tree ext_block;
7861 c_write_global_declarations (void)
7865 /* We don't want to do this if generating a PCH. */
7869 /* Don't waste time on further processing if -fsyntax-only or we've
7870 encountered errors. */
7871 if (flag_syntax_only || errorcount || sorrycount || cpp_errors (parse_in))
7874 /* Close the external scope. */
7875 ext_block = pop_scope ();
7877 gcc_assert (!current_scope);
7881 tree tmp = BLOCK_VARS (ext_block);
7883 FILE * stream = dump_begin (TDI_tu, &flags);
7886 dump_node (tmp, flags & ~TDF_SLIM, stream);
7887 dump_end (TDI_tu, stream);
7891 /* Process all file scopes in this compilation, and the external_scope,
7892 through wrapup_global_declarations and check_global_declarations. */
7893 for (t = all_translation_units; t; t = TREE_CHAIN (t))
7894 c_write_global_declarations_1 (BLOCK_VARS (DECL_INITIAL (t)));
7895 c_write_global_declarations_1 (BLOCK_VARS (ext_block));
7897 /* Generate functions to call static constructors and destructors
7898 for targets that do not support .ctors/.dtors sections. These
7899 functions have magic names which are detected by collect2. */
7900 build_cdtor ('I', static_ctors); static_ctors = 0;
7901 build_cdtor ('D', static_dtors); static_dtors = 0;
7903 /* We're done parsing; proceed to optimize and emit assembly.
7904 FIXME: shouldn't be the front end's responsibility to call this. */
7907 /* After cgraph has had a chance to emit everything that's going to
7908 be emitted, output debug information for globals. */
7909 if (errorcount == 0 && sorrycount == 0)
7911 timevar_push (TV_SYMOUT);
7912 for (t = all_translation_units; t; t = TREE_CHAIN (t))
7913 c_write_global_declarations_2 (BLOCK_VARS (DECL_INITIAL (t)));
7914 c_write_global_declarations_2 (BLOCK_VARS (ext_block));
7915 timevar_pop (TV_SYMOUT);
7921 #include "gt-c-decl.h"