1 /* Process declarations and variables for C compiler.
2 Copyright (C) 1988-2015 Free Software Foundation, Inc.
4 This file is part of GCC.
6 GCC is free software; you can redistribute it and/or modify it under
7 the terms of the GNU General Public License as published by the Free
8 Software Foundation; either version 3, or (at your option) any later
11 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
12 WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
16 You should have received a copy of the GNU General Public License
17 along with GCC; see the file COPYING3. If not see
18 <http://www.gnu.org/licenses/>. */
20 /* Process declarations and symbol lookup for C front end.
21 Also constructs types; the standard scalar types at initialization,
22 and structure, union, array and enum types when they are declared. */
24 /* ??? not all decl nodes are given the most useful possible
25 line numbers. For example, the CONST_DECLs for enum values. */
29 #include "coretypes.h"
38 #include "double-int.h"
42 #include "fold-const.h"
43 #include "print-tree.h"
44 #include "stor-layout.h"
47 #include "stringpool.h"
48 #include "tree-inline.h"
54 #include "hard-reg-set.h"
64 #include "c-family/c-common.h"
65 #include "c-family/c-objc.h"
66 #include "c-family/c-pragma.h"
67 #include "c-family/c-ubsan.h"
69 #include "langhooks.h"
70 #include "tree-iterator.h"
71 #include "diagnostic-core.h"
75 #include "plugin-api.h"
78 #include "hash-table.h"
79 #include "langhooks-def.h"
81 #include "c-family/c-ada-spec.h"
85 /* In grokdeclarator, distinguish syntactic contexts of declarators. */
87 { NORMAL, /* Ordinary declaration */
88 FUNCDEF, /* Function definition */
89 PARM, /* Declaration of parm before function body */
90 FIELD, /* Declaration inside struct or union */
91 TYPENAME}; /* Typename (inside cast or sizeof) */
93 /* States indicating how grokdeclarator() should handle declspecs marked
94 with __attribute__((deprecated)). An object declared as
95 __attribute__((deprecated)) suppresses warnings of uses of other
98 enum deprecated_states {
104 /* Nonzero if we have seen an invalid cross reference
105 to a struct, union, or enum, but not yet printed the message. */
106 tree pending_invalid_xref;
108 /* File and line to appear in the eventual error message. */
109 location_t pending_invalid_xref_location;
111 /* The file and line that the prototype came from if this is an
112 old-style definition; used for diagnostics in
113 store_parm_decls_oldstyle. */
115 static location_t current_function_prototype_locus;
117 /* Whether this prototype was built-in. */
119 static bool current_function_prototype_built_in;
121 /* The argument type information of this prototype. */
123 static tree current_function_prototype_arg_types;
125 /* The argument information structure for the function currently being
128 static struct c_arg_info *current_function_arg_info;
130 /* The obstack on which parser and related data structures, which are
131 not live beyond their top-level declaration or definition, are
133 struct obstack parser_obstack;
135 /* The current statement tree. */
137 static GTY(()) struct stmt_tree_s c_stmt_tree;
139 /* State saving variables. */
143 /* A list of decls to be made automatically visible in each file scope. */
144 static GTY(()) tree visible_builtins;
146 /* Set to 0 at beginning of a function definition, set to 1 if
147 a return statement that specifies a return value is seen. */
149 int current_function_returns_value;
151 /* Set to 0 at beginning of a function definition, set to 1 if
152 a return statement with no argument is seen. */
154 int current_function_returns_null;
156 /* Set to 0 at beginning of a function definition, set to 1 if
157 a call to a noreturn function is seen. */
159 int current_function_returns_abnormally;
161 /* Set to nonzero by `grokdeclarator' for a function
162 whose return type is defaulted, if warnings for this are desired. */
164 static int warn_about_return_type;
166 /* Nonzero when the current toplevel function contains a declaration
167 of a nested function which is never defined. */
169 static bool undef_nested_function;
171 /* If non-zero, implicit "omp declare target" attribute is added into the
173 int current_omp_declare_target_attribute;
175 /* Each c_binding structure describes one binding of an identifier to
176 a decl. All the decls in a scope - irrespective of namespace - are
177 chained together by the ->prev field, which (as the name implies)
178 runs in reverse order. All the decls in a given namespace bound to
179 a given identifier are chained by the ->shadowed field, which runs
180 from inner to outer scopes.
182 The ->decl field usually points to a DECL node, but there are two
183 exceptions. In the namespace of type tags, the bound entity is a
184 RECORD_TYPE, UNION_TYPE, or ENUMERAL_TYPE node. If an undeclared
185 identifier is encountered, it is bound to error_mark_node to
186 suppress further errors about that identifier in the current
189 The ->u.type field stores the type of the declaration in this scope;
190 if NULL, the type is the type of the ->decl field. This is only of
191 relevance for objects with external or internal linkage which may
192 be redeclared in inner scopes, forming composite types that only
193 persist for the duration of those scopes. In the external scope,
194 this stores the composite of all the types declared for this
195 object, visible or not. The ->inner_comp field (used only at file
196 scope) stores whether an incomplete array type at file scope was
197 completed at an inner scope to an array size other than 1.
199 The ->u.label field is used for labels. It points to a structure
200 which stores additional information used for warnings.
202 The depth field is copied from the scope structure that holds this
203 decl. It is used to preserve the proper ordering of the ->shadowed
204 field (see bind()) and also for a handful of special-case checks.
205 Finally, the invisible bit is true for a decl which should be
206 ignored for purposes of normal name lookup, and the nested bit is
207 true for a decl that's been bound a second time in an inner scope;
208 in all such cases, the binding in the outer scope will have its
209 invisible bit true. */
211 struct GTY((chain_next ("%h.prev"))) c_binding {
212 union GTY(()) { /* first so GTY desc can use decl */
213 tree GTY((tag ("0"))) type; /* the type in this scope */
214 struct c_label_vars * GTY((tag ("1"))) label; /* for warnings */
215 } GTY((desc ("TREE_CODE (%0.decl) == LABEL_DECL"))) u;
216 tree decl; /* the decl bound */
217 tree id; /* the identifier it's bound to */
218 struct c_binding *prev; /* the previous decl in this scope */
219 struct c_binding *shadowed; /* the innermost decl shadowed by this one */
220 unsigned int depth : 28; /* depth of this scope */
221 BOOL_BITFIELD invisible : 1; /* normal lookup should ignore this binding */
222 BOOL_BITFIELD nested : 1; /* do not set DECL_CONTEXT when popping */
223 BOOL_BITFIELD inner_comp : 1; /* incomplete array completed in inner scope */
224 BOOL_BITFIELD in_struct : 1; /* currently defined as struct field */
225 location_t locus; /* location for nested bindings */
227 #define B_IN_SCOPE(b1, b2) ((b1)->depth == (b2)->depth)
228 #define B_IN_CURRENT_SCOPE(b) ((b)->depth == current_scope->depth)
229 #define B_IN_FILE_SCOPE(b) ((b)->depth == 1 /*file_scope->depth*/)
230 #define B_IN_EXTERNAL_SCOPE(b) ((b)->depth == 0 /*external_scope->depth*/)
232 /* Each C symbol points to three linked lists of c_binding structures.
233 These describe the values of the identifier in the three different
234 namespaces defined by the language. */
236 struct GTY(()) lang_identifier {
237 struct c_common_identifier common_id;
238 struct c_binding *symbol_binding; /* vars, funcs, constants, typedefs */
239 struct c_binding *tag_binding; /* struct/union/enum tags */
240 struct c_binding *label_binding; /* labels */
243 /* Validate c-lang.c's assumptions. */
244 extern char C_SIZEOF_STRUCT_LANG_IDENTIFIER_isnt_accurate
245 [(sizeof(struct lang_identifier) == C_SIZEOF_STRUCT_LANG_IDENTIFIER) ? 1 : -1];
247 /* The binding oracle; see c-tree.h. */
248 void (*c_binding_oracle) (enum c_oracle_request, tree identifier);
250 /* This flag is set on an identifier if we have previously asked the
251 binding oracle for this identifier's symbol binding. */
252 #define I_SYMBOL_CHECKED(node) \
253 (TREE_LANG_FLAG_4 (IDENTIFIER_NODE_CHECK (node)))
255 static inline struct c_binding* *
256 i_symbol_binding (tree node)
258 struct lang_identifier *lid
259 = (struct lang_identifier *) IDENTIFIER_NODE_CHECK (node);
261 if (lid->symbol_binding == NULL
262 && c_binding_oracle != NULL
263 && !I_SYMBOL_CHECKED (node))
265 /* Set the "checked" flag first, to avoid infinite recursion
266 when the binding oracle calls back into gcc. */
267 I_SYMBOL_CHECKED (node) = 1;
268 c_binding_oracle (C_ORACLE_SYMBOL, node);
271 return &lid->symbol_binding;
274 #define I_SYMBOL_BINDING(node) (*i_symbol_binding (node))
276 #define I_SYMBOL_DECL(node) \
277 (I_SYMBOL_BINDING(node) ? I_SYMBOL_BINDING(node)->decl : 0)
279 /* This flag is set on an identifier if we have previously asked the
280 binding oracle for this identifier's tag binding. */
281 #define I_TAG_CHECKED(node) \
282 (TREE_LANG_FLAG_5 (IDENTIFIER_NODE_CHECK (node)))
284 static inline struct c_binding **
285 i_tag_binding (tree node)
287 struct lang_identifier *lid
288 = (struct lang_identifier *) IDENTIFIER_NODE_CHECK (node);
290 if (lid->tag_binding == NULL
291 && c_binding_oracle != NULL
292 && !I_TAG_CHECKED (node))
294 /* Set the "checked" flag first, to avoid infinite recursion
295 when the binding oracle calls back into gcc. */
296 I_TAG_CHECKED (node) = 1;
297 c_binding_oracle (C_ORACLE_TAG, node);
300 return &lid->tag_binding;
303 #define I_TAG_BINDING(node) (*i_tag_binding (node))
305 #define I_TAG_DECL(node) \
306 (I_TAG_BINDING(node) ? I_TAG_BINDING(node)->decl : 0)
308 /* This flag is set on an identifier if we have previously asked the
309 binding oracle for this identifier's label binding. */
310 #define I_LABEL_CHECKED(node) \
311 (TREE_LANG_FLAG_6 (IDENTIFIER_NODE_CHECK (node)))
313 static inline struct c_binding **
314 i_label_binding (tree node)
316 struct lang_identifier *lid
317 = (struct lang_identifier *) IDENTIFIER_NODE_CHECK (node);
319 if (lid->label_binding == NULL
320 && c_binding_oracle != NULL
321 && !I_LABEL_CHECKED (node))
323 /* Set the "checked" flag first, to avoid infinite recursion
324 when the binding oracle calls back into gcc. */
325 I_LABEL_CHECKED (node) = 1;
326 c_binding_oracle (C_ORACLE_LABEL, node);
329 return &lid->label_binding;
332 #define I_LABEL_BINDING(node) (*i_label_binding (node))
334 #define I_LABEL_DECL(node) \
335 (I_LABEL_BINDING(node) ? I_LABEL_BINDING(node)->decl : 0)
337 /* The resulting tree type. */
339 union GTY((desc ("TREE_CODE (&%h.generic) == IDENTIFIER_NODE"),
340 chain_next ("(union lang_tree_node *) c_tree_chain_next (&%h.generic)"))) lang_tree_node
342 union tree_node GTY ((tag ("0"),
343 desc ("tree_node_structure (&%h)")))
345 struct lang_identifier GTY ((tag ("1"))) identifier;
348 /* Track bindings and other things that matter for goto warnings. For
349 efficiency, we do not gather all the decls at the point of
350 definition. Instead, we point into the bindings structure. As
351 scopes are popped, we update these structures and gather the decls
352 that matter at that time. */
354 struct GTY(()) c_spot_bindings {
355 /* The currently open scope which holds bindings defined when the
356 label was defined or the goto statement was found. */
357 struct c_scope *scope;
358 /* The bindings in the scope field which were defined at the point
359 of the label or goto. This lets us look at older or newer
360 bindings in the scope, as appropriate. */
361 struct c_binding *bindings_in_scope;
362 /* The number of statement expressions that have started since this
363 label or goto statement was defined. This is zero if we are at
364 the same statement expression level. It is positive if we are in
365 a statement expression started since this spot. It is negative
366 if this spot was in a statement expression and we have left
369 /* Whether we started in a statement expression but are no longer in
370 it. This is set to true if stmt_exprs ever goes negative. */
374 /* This structure is used to keep track of bindings seen when a goto
375 statement is defined. This is only used if we see the goto
376 statement before we see the label. */
378 struct GTY(()) c_goto_bindings {
379 /* The location of the goto statement. */
381 /* The bindings of the goto statement. */
382 struct c_spot_bindings goto_bindings;
385 typedef struct c_goto_bindings *c_goto_bindings_p;
387 /* The additional information we keep track of for a label binding.
388 These fields are updated as scopes are popped. */
390 struct GTY(()) c_label_vars {
391 /* The shadowed c_label_vars, when one label shadows another (which
392 can only happen using a __label__ declaration). */
393 struct c_label_vars *shadowed;
394 /* The bindings when the label was defined. */
395 struct c_spot_bindings label_bindings;
396 /* A list of decls that we care about: decls about which we should
397 warn if a goto branches to this label from later in the function.
398 Decls are added to this list as scopes are popped. We only add
399 the decls that matter. */
400 vec<tree, va_gc> *decls_in_scope;
401 /* A list of goto statements to this label. This is only used for
402 goto statements seen before the label was defined, so that we can
403 issue appropriate warnings for them. */
404 vec<c_goto_bindings_p, va_gc> *gotos;
407 /* Each c_scope structure describes the complete contents of one
408 scope. Four scopes are distinguished specially: the innermost or
409 current scope, the innermost function scope, the file scope (always
410 the second to outermost) and the outermost or external scope.
412 Most declarations are recorded in the current scope.
414 All normal label declarations are recorded in the innermost
415 function scope, as are bindings of undeclared identifiers to
416 error_mark_node. (GCC permits nested functions as an extension,
417 hence the 'innermost' qualifier.) Explicitly declared labels
418 (using the __label__ extension) appear in the current scope.
420 Being in the file scope (current_scope == file_scope) causes
421 special behavior in several places below. Also, under some
422 conditions the Objective-C front end records declarations in the
423 file scope even though that isn't the current scope.
425 All declarations with external linkage are recorded in the external
426 scope, even if they aren't visible there; this models the fact that
427 such declarations are visible to the entire program, and (with a
428 bit of cleverness, see pushdecl) allows diagnosis of some violations
429 of C99 6.2.2p7 and 6.2.7p2:
431 If, within the same translation unit, the same identifier appears
432 with both internal and external linkage, the behavior is
435 All declarations that refer to the same object or function shall
436 have compatible type; otherwise, the behavior is undefined.
438 Initially only the built-in declarations, which describe compiler
439 intrinsic functions plus a subset of the standard library, are in
442 The order of the blocks list matters, and it is frequently appended
443 to. To avoid having to walk all the way to the end of the list on
444 each insertion, or reverse the list later, we maintain a pointer to
445 the last list entry. (FIXME: It should be feasible to use a reversed
448 The bindings list is strictly in reverse order of declarations;
449 pop_scope relies on this. */
452 struct GTY((chain_next ("%h.outer"))) c_scope {
453 /* The scope containing this one. */
454 struct c_scope *outer;
456 /* The next outermost function scope. */
457 struct c_scope *outer_function;
459 /* All bindings in this scope. */
460 struct c_binding *bindings;
462 /* For each scope (except the global one), a chain of BLOCK nodes
463 for all the scopes that were entered and exited one level down. */
467 /* The depth of this scope. Used to keep the ->shadowed chain of
468 bindings sorted innermost to outermost. */
469 unsigned int depth : 28;
471 /* True if we are currently filling this scope with parameter
473 BOOL_BITFIELD parm_flag : 1;
475 /* True if we saw [*] in this scope. Used to give an error messages
476 if these appears in a function definition. */
477 BOOL_BITFIELD had_vla_unspec : 1;
479 /* True if we already complained about forward parameter decls
480 in this scope. This prevents double warnings on
481 foo (int a; int b; ...) */
482 BOOL_BITFIELD warned_forward_parm_decls : 1;
484 /* True if this is the outermost block scope of a function body.
485 This scope contains the parameters, the local variables declared
486 in the outermost block, and all the labels (except those in
487 nested functions, or declared at block scope with __label__). */
488 BOOL_BITFIELD function_body : 1;
490 /* True means make a BLOCK for this scope no matter what. */
491 BOOL_BITFIELD keep : 1;
493 /* True means that an unsuffixed float constant is _Decimal64. */
494 BOOL_BITFIELD float_const_decimal64 : 1;
496 /* True if this scope has any label bindings. This is used to speed
497 up searching for labels when popping scopes, particularly since
498 labels are normally only found at function scope. */
499 BOOL_BITFIELD has_label_bindings : 1;
501 /* True if we should issue a warning if a goto statement crosses any
502 of the bindings. We still need to check the list of bindings to
503 find the specific ones we need to warn about. This is true if
504 decl_jump_unsafe would return true for any of the bindings. This
505 is used to avoid looping over all the bindings unnecessarily. */
506 BOOL_BITFIELD has_jump_unsafe_decl : 1;
509 /* The scope currently in effect. */
511 static GTY(()) struct c_scope *current_scope;
513 /* The innermost function scope. Ordinary (not explicitly declared)
514 labels, bindings to error_mark_node, and the lazily-created
515 bindings of __func__ and its friends get this scope. */
517 static GTY(()) struct c_scope *current_function_scope;
519 /* The C file scope. This is reset for each input translation unit. */
521 static GTY(()) struct c_scope *file_scope;
523 /* The outermost scope. This is used for all declarations with
524 external linkage, and only these, hence the name. */
526 static GTY(()) struct c_scope *external_scope;
528 /* A chain of c_scope structures awaiting reuse. */
530 static GTY((deletable)) struct c_scope *scope_freelist;
532 /* A chain of c_binding structures awaiting reuse. */
534 static GTY((deletable)) struct c_binding *binding_freelist;
536 /* Append VAR to LIST in scope SCOPE. */
537 #define SCOPE_LIST_APPEND(scope, list, decl) do { \
538 struct c_scope *s_ = (scope); \
540 if (s_->list##_last) \
541 BLOCK_CHAIN (s_->list##_last) = d_; \
544 s_->list##_last = d_; \
547 /* Concatenate FROM in scope FSCOPE onto TO in scope TSCOPE. */
548 #define SCOPE_LIST_CONCAT(tscope, to, fscope, from) do { \
549 struct c_scope *t_ = (tscope); \
550 struct c_scope *f_ = (fscope); \
552 BLOCK_CHAIN (t_->to##_last) = f_->from; \
555 t_->to##_last = f_->from##_last; \
558 /* A c_inline_static structure stores details of a static identifier
559 referenced in a definition of a function that may be an inline
560 definition if no subsequent declaration of that function uses
561 "extern" or does not use "inline". */
563 struct GTY((chain_next ("%h.next"))) c_inline_static {
564 /* The location for a diagnostic. */
567 /* The function that may be an inline definition. */
570 /* The object or function referenced. */
573 /* What sort of reference this is. */
574 enum c_inline_static_type type;
576 /* The next such structure or NULL. */
577 struct c_inline_static *next;
580 /* List of static identifiers used or referenced in functions that may
581 be inline definitions. */
582 static GTY(()) struct c_inline_static *c_inline_statics;
584 /* True means unconditionally make a BLOCK for the next scope pushed. */
586 static bool keep_next_level_flag;
588 /* True means the next call to push_scope will be the outermost scope
589 of a function body, so do not push a new scope, merely cease
590 expecting parameter decls. */
592 static bool next_is_function_body;
594 /* A vector of pointers to c_binding structures. */
596 typedef struct c_binding *c_binding_ptr;
598 /* Information that we keep for a struct or union while it is being
601 struct c_struct_parse_info
603 /* If warn_cxx_compat, a list of types defined within this
605 vec<tree> struct_types;
606 /* If warn_cxx_compat, a list of field names which have bindings,
607 and which are defined in this struct, but which are not defined
608 in any enclosing struct. This is used to clear the in_struct
609 field of the c_bindings structure. */
610 vec<c_binding_ptr> fields;
611 /* If warn_cxx_compat, a list of typedef names used when defining
612 fields in this struct. */
613 vec<tree> typedefs_seen;
616 /* Information for the struct or union currently being parsed, or
617 NULL if not parsing a struct or union. */
618 static struct c_struct_parse_info *struct_parse_info;
620 /* Forward declarations. */
621 static tree lookup_name_in_scope (tree, struct c_scope *);
622 static tree c_make_fname_decl (location_t, tree, int);
623 static tree grokdeclarator (const struct c_declarator *,
624 struct c_declspecs *,
625 enum decl_context, bool, tree *, tree *, tree *,
626 bool *, enum deprecated_states);
627 static tree grokparms (struct c_arg_info *, bool);
628 static void layout_array_type (tree);
629 static void warn_defaults_to (location_t, int, const char *, ...)
630 ATTRIBUTE_GCC_DIAG(3,4);
632 /* T is a statement. Add it to the statement-tree. This is the
633 C/ObjC version--C++ has a slightly different version of this
639 enum tree_code code = TREE_CODE (t);
641 if (CAN_HAVE_LOCATION_P (t) && code != LABEL_EXPR)
643 if (!EXPR_HAS_LOCATION (t))
644 SET_EXPR_LOCATION (t, input_location);
647 if (code == LABEL_EXPR || code == CASE_LABEL_EXPR)
648 STATEMENT_LIST_HAS_LABEL (cur_stmt_list) = 1;
650 /* Add T to the statement-tree. Non-side-effect statements need to be
651 recorded during statement expressions. */
652 if (!building_stmt_list_p ())
654 append_to_statement_list_force (t, &cur_stmt_list);
659 /* Build a pointer type using the default pointer mode. */
662 c_build_pointer_type (tree to_type)
664 addr_space_t as = to_type == error_mark_node? ADDR_SPACE_GENERIC
665 : TYPE_ADDR_SPACE (to_type);
666 machine_mode pointer_mode;
668 if (as != ADDR_SPACE_GENERIC || c_default_pointer_mode == VOIDmode)
669 pointer_mode = targetm.addr_space.pointer_mode (as);
671 pointer_mode = c_default_pointer_mode;
672 return build_pointer_type_for_mode (to_type, pointer_mode, false);
676 /* Return true if we will want to say something if a goto statement
680 decl_jump_unsafe (tree decl)
682 if (error_operand_p (decl))
685 /* Always warn about crossing variably modified types. */
686 if ((TREE_CODE (decl) == VAR_DECL || TREE_CODE (decl) == TYPE_DECL)
687 && variably_modified_type_p (TREE_TYPE (decl), NULL_TREE))
690 /* Otherwise, only warn if -Wgoto-misses-init and this is an
691 initialized automatic decl. */
692 if (warn_jump_misses_init
693 && TREE_CODE (decl) == VAR_DECL
694 && !TREE_STATIC (decl)
695 && DECL_INITIAL (decl) != NULL_TREE)
703 c_print_identifier (FILE *file, tree node, int indent)
705 void (*save) (enum c_oracle_request, tree identifier);
707 /* Temporarily hide any binding oracle. Without this, calls to
708 debug_tree from the debugger will end up calling into the oracle,
709 making for a confusing debug session. As the oracle isn't needed
710 here for normal operation, it's simplest to suppress it. */
711 save = c_binding_oracle;
712 c_binding_oracle = NULL;
714 print_node (file, "symbol", I_SYMBOL_DECL (node), indent + 4);
715 print_node (file, "tag", I_TAG_DECL (node), indent + 4);
716 print_node (file, "label", I_LABEL_DECL (node), indent + 4);
717 if (C_IS_RESERVED_WORD (node) && C_RID_CODE (node) != RID_CXX_COMPAT_WARN)
719 tree rid = ridpointers[C_RID_CODE (node)];
720 indent_to (file, indent + 4);
721 fprintf (file, "rid " HOST_PTR_PRINTF " \"%s\"",
722 (void *) rid, IDENTIFIER_POINTER (rid));
725 c_binding_oracle = save;
728 /* Establish a binding between NAME, an IDENTIFIER_NODE, and DECL,
729 which may be any of several kinds of DECL or TYPE or error_mark_node,
730 in the scope SCOPE. */
732 bind (tree name, tree decl, struct c_scope *scope, bool invisible,
733 bool nested, location_t locus)
735 struct c_binding *b, **here;
737 if (binding_freelist)
739 b = binding_freelist;
740 binding_freelist = b->prev;
743 b = ggc_alloc<c_binding> ();
748 b->depth = scope->depth;
749 b->invisible = invisible;
757 b->prev = scope->bindings;
760 if (decl_jump_unsafe (decl))
761 scope->has_jump_unsafe_decl = 1;
766 switch (TREE_CODE (decl))
768 case LABEL_DECL: here = &I_LABEL_BINDING (name); break;
771 case RECORD_TYPE: here = &I_TAG_BINDING (name); break;
777 case ERROR_MARK: here = &I_SYMBOL_BINDING (name); break;
783 /* Locate the appropriate place in the chain of shadowed decls
784 to insert this binding. Normally, scope == current_scope and
785 this does nothing. */
786 while (*here && (*here)->depth > scope->depth)
787 here = &(*here)->shadowed;
793 /* Clear the binding structure B, stick it on the binding_freelist,
794 and return the former value of b->prev. This is used by pop_scope
795 and get_parm_info to iterate destructively over all the bindings
796 from a given scope. */
797 static struct c_binding *
798 free_binding_and_advance (struct c_binding *b)
800 struct c_binding *prev = b->prev;
802 memset (b, 0, sizeof (struct c_binding));
803 b->prev = binding_freelist;
804 binding_freelist = b;
809 /* Bind a label. Like bind, but skip fields which aren't used for
810 labels, and add the LABEL_VARS value. */
812 bind_label (tree name, tree label, struct c_scope *scope,
813 struct c_label_vars *label_vars)
817 bind (name, label, scope, /*invisible=*/false, /*nested=*/false,
820 scope->has_label_bindings = true;
823 gcc_assert (b->decl == label);
824 label_vars->shadowed = b->u.label;
825 b->u.label = label_vars;
828 /* Hook called at end of compilation to assume 1 elt
829 for a file-scope tentative array defn that wasn't complete before. */
832 c_finish_incomplete_decl (tree decl)
834 if (TREE_CODE (decl) == VAR_DECL)
836 tree type = TREE_TYPE (decl);
837 if (type != error_mark_node
838 && TREE_CODE (type) == ARRAY_TYPE
839 && !DECL_EXTERNAL (decl)
840 && TYPE_DOMAIN (type) == 0)
842 warning_at (DECL_SOURCE_LOCATION (decl),
843 0, "array %q+D assumed to have one element", decl);
845 complete_array_type (&TREE_TYPE (decl), NULL_TREE, true);
847 relayout_decl (decl);
852 /* Record that inline function FUNC contains a reference (location
853 LOC) to static DECL (file-scope or function-local according to
857 record_inline_static (location_t loc, tree func, tree decl,
858 enum c_inline_static_type type)
860 c_inline_static *csi = ggc_alloc<c_inline_static> ();
862 csi->function = func;
863 csi->static_decl = decl;
865 csi->next = c_inline_statics;
866 c_inline_statics = csi;
869 /* Check for references to static declarations in inline functions at
870 the end of the translation unit and diagnose them if the functions
871 are still inline definitions. */
874 check_inline_statics (void)
876 struct c_inline_static *csi;
877 for (csi = c_inline_statics; csi; csi = csi->next)
879 if (DECL_EXTERNAL (csi->function))
883 pedwarn (csi->location, 0,
884 "%qD is static but used in inline function %qD "
885 "which is not static", csi->static_decl, csi->function);
888 pedwarn (csi->location, 0,
889 "%q+D is static but declared in inline function %qD "
890 "which is not static", csi->static_decl, csi->function);
896 c_inline_statics = NULL;
899 /* Fill in a c_spot_bindings structure. If DEFINING is true, set it
900 for the current state, otherwise set it to uninitialized. */
903 set_spot_bindings (struct c_spot_bindings *p, bool defining)
907 p->scope = current_scope;
908 p->bindings_in_scope = current_scope->bindings;
913 p->bindings_in_scope = NULL;
916 p->left_stmt_expr = false;
919 /* Update spot bindings P as we pop out of SCOPE. Return true if we
920 should push decls for a label. */
923 update_spot_bindings (struct c_scope *scope, struct c_spot_bindings *p)
925 if (p->scope != scope)
927 /* This label or goto is defined in some other scope, or it is a
928 label which is not yet defined. There is nothing to
933 /* Adjust the spot bindings to refer to the bindings already defined
934 in the enclosing scope. */
935 p->scope = scope->outer;
936 p->bindings_in_scope = p->scope->bindings;
941 /* The Objective-C front-end often needs to determine the current scope. */
944 objc_get_current_scope (void)
946 return current_scope;
949 /* The following function is used only by Objective-C. It needs to live here
950 because it accesses the innards of c_scope. */
953 objc_mark_locals_volatile (void *enclosing_blk)
955 struct c_scope *scope;
958 for (scope = current_scope;
959 scope && scope != enclosing_blk;
960 scope = scope->outer)
962 for (b = scope->bindings; b; b = b->prev)
963 objc_volatilize_decl (b->decl);
965 /* Do not climb up past the current function. */
966 if (scope->function_body)
971 /* Return true if we are in the global binding level. */
974 global_bindings_p (void)
976 return current_scope == file_scope;
980 keep_next_level (void)
982 keep_next_level_flag = true;
985 /* Set the flag for the FLOAT_CONST_DECIMAL64 pragma being ON. */
988 set_float_const_decimal64 (void)
990 current_scope->float_const_decimal64 = true;
993 /* Clear the flag for the FLOAT_CONST_DECIMAL64 pragma. */
996 clear_float_const_decimal64 (void)
998 current_scope->float_const_decimal64 = false;
1001 /* Return nonzero if an unsuffixed float constant is _Decimal64. */
1004 float_const_decimal64_p (void)
1006 return current_scope->float_const_decimal64;
1009 /* Identify this scope as currently being filled with parameters. */
1012 declare_parm_level (void)
1014 current_scope->parm_flag = true;
1020 if (next_is_function_body)
1022 /* This is the transition from the parameters to the top level
1023 of the function body. These are the same scope
1024 (C99 6.2.1p4,6) so we do not push another scope structure.
1025 next_is_function_body is set only by store_parm_decls, which
1026 in turn is called when and only when we are about to
1027 encounter the opening curly brace for the function body.
1029 The outermost block of a function always gets a BLOCK node,
1030 because the debugging output routines expect that each
1031 function has at least one BLOCK. */
1032 current_scope->parm_flag = false;
1033 current_scope->function_body = true;
1034 current_scope->keep = true;
1035 current_scope->outer_function = current_function_scope;
1036 current_function_scope = current_scope;
1038 keep_next_level_flag = false;
1039 next_is_function_body = false;
1041 /* The FLOAT_CONST_DECIMAL64 pragma applies to nested scopes. */
1042 if (current_scope->outer)
1043 current_scope->float_const_decimal64
1044 = current_scope->outer->float_const_decimal64;
1046 current_scope->float_const_decimal64 = false;
1050 struct c_scope *scope;
1053 scope = scope_freelist;
1054 scope_freelist = scope->outer;
1057 scope = ggc_cleared_alloc<c_scope> ();
1059 /* The FLOAT_CONST_DECIMAL64 pragma applies to nested scopes. */
1061 scope->float_const_decimal64 = current_scope->float_const_decimal64;
1063 scope->float_const_decimal64 = false;
1065 scope->keep = keep_next_level_flag;
1066 scope->outer = current_scope;
1067 scope->depth = current_scope ? (current_scope->depth + 1) : 0;
1069 /* Check for scope depth overflow. Unlikely (2^28 == 268,435,456) but
1071 if (current_scope && scope->depth == 0)
1074 sorry ("GCC supports only %u nested scopes", scope->depth);
1077 current_scope = scope;
1078 keep_next_level_flag = false;
1082 /* This is called when we are leaving SCOPE. For each label defined
1083 in SCOPE, add any appropriate decls to its decls_in_scope fields.
1084 These are the decls whose initialization will be skipped by a goto
1085 later in the function. */
1088 update_label_decls (struct c_scope *scope)
1095 if (s->has_label_bindings)
1097 struct c_binding *b;
1099 for (b = s->bindings; b != NULL; b = b->prev)
1101 struct c_label_vars *label_vars;
1102 struct c_binding *b1;
1105 struct c_goto_bindings *g;
1107 if (TREE_CODE (b->decl) != LABEL_DECL)
1109 label_vars = b->u.label;
1111 b1 = label_vars->label_bindings.bindings_in_scope;
1112 if (label_vars->label_bindings.scope == NULL)
1115 hjud = label_vars->label_bindings.scope->has_jump_unsafe_decl;
1116 if (update_spot_bindings (scope, &label_vars->label_bindings))
1118 /* This label is defined in this scope. */
1121 for (; b1 != NULL; b1 = b1->prev)
1123 /* A goto from later in the function to this
1124 label will never see the initialization
1125 of B1, if any. Save it to issue a
1126 warning if needed. */
1127 if (decl_jump_unsafe (b1->decl))
1128 vec_safe_push(label_vars->decls_in_scope, b1->decl);
1133 /* Update the bindings of any goto statements associated
1135 FOR_EACH_VEC_SAFE_ELT (label_vars->gotos, ix, g)
1136 update_spot_bindings (scope, &g->goto_bindings);
1140 /* Don't search beyond the current function. */
1141 if (s == current_function_scope)
1148 /* Set the TYPE_CONTEXT of all of TYPE's variants to CONTEXT. */
1151 set_type_context (tree type, tree context)
1153 for (type = TYPE_MAIN_VARIANT (type); type;
1154 type = TYPE_NEXT_VARIANT (type))
1155 TYPE_CONTEXT (type) = context;
1158 /* Exit a scope. Restore the state of the identifier-decl mappings
1159 that were in effect when this scope was entered. Return a BLOCK
1160 node containing all the DECLs in this scope that are of interest
1161 to debug info generation. */
1166 struct c_scope *scope = current_scope;
1167 tree block, context, p;
1168 struct c_binding *b;
1170 bool functionbody = scope->function_body;
1171 bool keep = functionbody || scope->keep || scope->bindings;
1173 update_label_decls (scope);
1175 /* If appropriate, create a BLOCK to record the decls for the life
1176 of this function. */
1180 block = make_node (BLOCK);
1181 BLOCK_SUBBLOCKS (block) = scope->blocks;
1182 TREE_USED (block) = 1;
1184 /* In each subblock, record that this is its superior. */
1185 for (p = scope->blocks; p; p = BLOCK_CHAIN (p))
1186 BLOCK_SUPERCONTEXT (p) = block;
1188 BLOCK_VARS (block) = 0;
1191 /* The TYPE_CONTEXTs for all of the tagged types belonging to this
1192 scope must be set so that they point to the appropriate
1193 construct, i.e. either to the current FUNCTION_DECL node, or
1194 else to the BLOCK node we just constructed.
1196 Note that for tagged types whose scope is just the formal
1197 parameter list for some function type specification, we can't
1198 properly set their TYPE_CONTEXTs here, because we don't have a
1199 pointer to the appropriate FUNCTION_TYPE node readily available
1200 to us. For those cases, the TYPE_CONTEXTs of the relevant tagged
1201 type nodes get set in `grokdeclarator' as soon as we have created
1202 the FUNCTION_TYPE node which will represent the "scope" for these
1203 "parameter list local" tagged types. */
1204 if (scope->function_body)
1205 context = current_function_decl;
1206 else if (scope == file_scope)
1208 tree file_decl = build_translation_unit_decl (NULL_TREE);
1209 context = file_decl;
1210 debug_hooks->register_main_translation_unit (file_decl);
1215 /* Clear all bindings in this scope. */
1216 for (b = scope->bindings; b; b = free_binding_and_advance (b))
1219 switch (TREE_CODE (p))
1222 /* Warnings for unused labels, errors for undefined labels. */
1223 if (TREE_USED (p) && !DECL_INITIAL (p))
1225 error ("label %q+D used but not defined", p);
1226 DECL_INITIAL (p) = error_mark_node;
1229 warn_for_unused_label (p);
1231 /* Labels go in BLOCK_VARS. */
1232 DECL_CHAIN (p) = BLOCK_VARS (block);
1233 BLOCK_VARS (block) = p;
1234 gcc_assert (I_LABEL_BINDING (b->id) == b);
1235 I_LABEL_BINDING (b->id) = b->shadowed;
1237 /* Also pop back to the shadowed label_vars. */
1238 release_tree_vector (b->u.label->decls_in_scope);
1239 b->u.label = b->u.label->shadowed;
1245 set_type_context (p, context);
1247 /* Types may not have tag-names, in which case the type
1248 appears in the bindings list with b->id NULL. */
1251 gcc_assert (I_TAG_BINDING (b->id) == b);
1252 I_TAG_BINDING (b->id) = b->shadowed;
1257 /* Propagate TREE_ADDRESSABLE from nested functions to their
1258 containing functions. */
1259 if (!TREE_ASM_WRITTEN (p)
1260 && DECL_INITIAL (p) != 0
1261 && TREE_ADDRESSABLE (p)
1262 && DECL_ABSTRACT_ORIGIN (p) != 0
1263 && DECL_ABSTRACT_ORIGIN (p) != p)
1264 TREE_ADDRESSABLE (DECL_ABSTRACT_ORIGIN (p)) = 1;
1265 if (!DECL_EXTERNAL (p)
1266 && !DECL_INITIAL (p)
1267 && scope != file_scope
1268 && scope != external_scope)
1270 error ("nested function %q+D declared but never defined", p);
1271 undef_nested_function = true;
1273 else if (DECL_DECLARED_INLINE_P (p)
1275 && !DECL_INITIAL (p))
1277 /* C99 6.7.4p6: "a function with external linkage... declared
1278 with an inline function specifier ... shall also be defined
1279 in the same translation unit." */
1280 if (!flag_gnu89_inline
1281 && !lookup_attribute ("gnu_inline", DECL_ATTRIBUTES (p))
1282 && scope != external_scope)
1283 pedwarn (input_location, 0,
1284 "inline function %q+D declared but never defined", p);
1285 DECL_EXTERNAL (p) = 1;
1291 /* Warnings for unused variables. */
1292 if ((!TREE_USED (p) || !DECL_READ_P (p))
1293 && !TREE_NO_WARNING (p)
1294 && !DECL_IN_SYSTEM_HEADER (p)
1296 && !DECL_ARTIFICIAL (p)
1297 && scope != file_scope
1298 && scope != external_scope)
1301 warning (OPT_Wunused_variable, "unused variable %q+D", p);
1302 else if (DECL_CONTEXT (p) == current_function_decl)
1303 warning_at (DECL_SOURCE_LOCATION (p),
1304 OPT_Wunused_but_set_variable,
1305 "variable %qD set but not used", p);
1310 error ("type of array %q+D completed incompatibly with"
1311 " implicit initialization", p);
1318 /* All of these go in BLOCK_VARS, but only if this is the
1319 binding in the home scope. */
1322 DECL_CHAIN (p) = BLOCK_VARS (block);
1323 BLOCK_VARS (block) = p;
1325 else if (VAR_OR_FUNCTION_DECL_P (p) && scope != file_scope)
1327 /* For block local externs add a special
1328 DECL_EXTERNAL decl for debug info generation. */
1329 tree extp = copy_node (p);
1331 DECL_EXTERNAL (extp) = 1;
1332 TREE_STATIC (extp) = 0;
1333 TREE_PUBLIC (extp) = 1;
1334 DECL_INITIAL (extp) = NULL_TREE;
1335 DECL_LANG_SPECIFIC (extp) = NULL;
1336 DECL_CONTEXT (extp) = current_function_decl;
1337 if (TREE_CODE (p) == FUNCTION_DECL)
1339 DECL_RESULT (extp) = NULL_TREE;
1340 DECL_SAVED_TREE (extp) = NULL_TREE;
1341 DECL_STRUCT_FUNCTION (extp) = NULL;
1343 if (b->locus != UNKNOWN_LOCATION)
1344 DECL_SOURCE_LOCATION (extp) = b->locus;
1345 DECL_CHAIN (extp) = BLOCK_VARS (block);
1346 BLOCK_VARS (block) = extp;
1348 /* If this is the file scope set DECL_CONTEXT of each decl to
1349 the TRANSLATION_UNIT_DECL. This makes same_translation_unit_p
1351 if (scope == file_scope)
1353 DECL_CONTEXT (p) = context;
1354 if (TREE_CODE (p) == TYPE_DECL
1355 && TREE_TYPE (p) != error_mark_node)
1356 set_type_context (TREE_TYPE (p), context);
1360 /* Parameters go in DECL_ARGUMENTS, not BLOCK_VARS, and have
1361 already been put there by store_parm_decls. Unused-
1362 parameter warnings are handled by function.c.
1363 error_mark_node obviously does not go in BLOCK_VARS and
1364 does not get unused-variable warnings. */
1367 /* It is possible for a decl not to have a name. We get
1368 here with b->id NULL in this case. */
1371 gcc_assert (I_SYMBOL_BINDING (b->id) == b);
1372 I_SYMBOL_BINDING (b->id) = b->shadowed;
1373 if (b->shadowed && b->shadowed->u.type)
1374 TREE_TYPE (b->shadowed->decl) = b->shadowed->u.type;
1384 /* Dispose of the block that we just made inside some higher level. */
1385 if ((scope->function_body || scope == file_scope) && context)
1387 DECL_INITIAL (context) = block;
1388 BLOCK_SUPERCONTEXT (block) = context;
1390 else if (scope->outer)
1393 SCOPE_LIST_APPEND (scope->outer, blocks, block);
1394 /* If we did not make a block for the scope just exited, any
1395 blocks made for inner scopes must be carried forward so they
1396 will later become subblocks of something else. */
1397 else if (scope->blocks)
1398 SCOPE_LIST_CONCAT (scope->outer, blocks, scope, blocks);
1401 /* Pop the current scope, and free the structure for reuse. */
1402 current_scope = scope->outer;
1403 if (scope->function_body)
1404 current_function_scope = scope->outer_function;
1406 memset (scope, 0, sizeof (struct c_scope));
1407 scope->outer = scope_freelist;
1408 scope_freelist = scope;
1414 push_file_scope (void)
1422 file_scope = current_scope;
1424 start_fname_decls ();
1426 for (decl = visible_builtins; decl; decl = DECL_CHAIN (decl))
1427 bind (DECL_NAME (decl), decl, file_scope,
1428 /*invisible=*/false, /*nested=*/true, DECL_SOURCE_LOCATION (decl));
1432 pop_file_scope (void)
1434 /* In case there were missing closebraces, get us back to the global
1436 while (current_scope != file_scope)
1439 /* __FUNCTION__ is defined at file scope (""). This
1440 call may not be necessary as my tests indicate it
1441 still works without it. */
1442 finish_fname_decls ();
1444 check_inline_statics ();
1446 /* This is the point to write out a PCH if we're doing that.
1447 In that case we do not want to do anything else. */
1450 c_common_write_pch ();
1454 /* Pop off the file scope and close this translation unit. */
1458 maybe_apply_pending_pragma_weaks ();
1461 /* Adjust the bindings for the start of a statement expression. */
1464 c_bindings_start_stmt_expr (struct c_spot_bindings* switch_bindings)
1466 struct c_scope *scope;
1468 for (scope = current_scope; scope != NULL; scope = scope->outer)
1470 struct c_binding *b;
1472 if (!scope->has_label_bindings)
1475 for (b = scope->bindings; b != NULL; b = b->prev)
1477 struct c_label_vars *label_vars;
1479 struct c_goto_bindings *g;
1481 if (TREE_CODE (b->decl) != LABEL_DECL)
1483 label_vars = b->u.label;
1484 ++label_vars->label_bindings.stmt_exprs;
1485 FOR_EACH_VEC_SAFE_ELT (label_vars->gotos, ix, g)
1486 ++g->goto_bindings.stmt_exprs;
1490 if (switch_bindings != NULL)
1491 ++switch_bindings->stmt_exprs;
1494 /* Adjust the bindings for the end of a statement expression. */
1497 c_bindings_end_stmt_expr (struct c_spot_bindings *switch_bindings)
1499 struct c_scope *scope;
1501 for (scope = current_scope; scope != NULL; scope = scope->outer)
1503 struct c_binding *b;
1505 if (!scope->has_label_bindings)
1508 for (b = scope->bindings; b != NULL; b = b->prev)
1510 struct c_label_vars *label_vars;
1512 struct c_goto_bindings *g;
1514 if (TREE_CODE (b->decl) != LABEL_DECL)
1516 label_vars = b->u.label;
1517 --label_vars->label_bindings.stmt_exprs;
1518 if (label_vars->label_bindings.stmt_exprs < 0)
1520 label_vars->label_bindings.left_stmt_expr = true;
1521 label_vars->label_bindings.stmt_exprs = 0;
1523 FOR_EACH_VEC_SAFE_ELT (label_vars->gotos, ix, g)
1525 --g->goto_bindings.stmt_exprs;
1526 if (g->goto_bindings.stmt_exprs < 0)
1528 g->goto_bindings.left_stmt_expr = true;
1529 g->goto_bindings.stmt_exprs = 0;
1535 if (switch_bindings != NULL)
1537 --switch_bindings->stmt_exprs;
1538 gcc_assert (switch_bindings->stmt_exprs >= 0);
1542 /* Push a definition or a declaration of struct, union or enum tag "name".
1543 "type" should be the type node.
1544 We assume that the tag "name" is not already defined, and has a location
1547 Note that the definition may really be just a forward reference.
1548 In that case, the TYPE_SIZE will be zero. */
1551 pushtag (location_t loc, tree name, tree type)
1553 /* Record the identifier as the type's name if it has none. */
1554 if (name && !TYPE_NAME (type))
1555 TYPE_NAME (type) = name;
1556 bind (name, type, current_scope, /*invisible=*/false, /*nested=*/false, loc);
1558 /* Create a fake NULL-named TYPE_DECL node whose TREE_TYPE will be the
1559 tagged type we just added to the current scope. This fake
1560 NULL-named TYPE_DECL node helps dwarfout.c to know when it needs
1561 to output a representation of a tagged type, and it also gives
1562 us a convenient place to record the "scope start" address for the
1565 TYPE_STUB_DECL (type) = pushdecl (build_decl (loc,
1566 TYPE_DECL, NULL_TREE, type));
1568 /* An approximation for now, so we can tell this is a function-scope tag.
1569 This will be updated in pop_scope. */
1570 TYPE_CONTEXT (type) = DECL_CONTEXT (TYPE_STUB_DECL (type));
1572 if (warn_cxx_compat && name != NULL_TREE)
1574 struct c_binding *b = I_SYMBOL_BINDING (name);
1577 && b->decl != NULL_TREE
1578 && TREE_CODE (b->decl) == TYPE_DECL
1579 && (B_IN_CURRENT_SCOPE (b)
1580 || (current_scope == file_scope && B_IN_EXTERNAL_SCOPE (b)))
1581 && (TYPE_MAIN_VARIANT (TREE_TYPE (b->decl))
1582 != TYPE_MAIN_VARIANT (type)))
1584 warning_at (loc, OPT_Wc___compat,
1585 ("using %qD as both a typedef and a tag is "
1588 if (b->locus != UNKNOWN_LOCATION)
1589 inform (b->locus, "originally defined here");
1594 /* An exported interface to pushtag. This is used by the gdb plugin's
1595 binding oracle to introduce a new tag binding. */
1598 c_pushtag (location_t loc, tree name, tree type)
1600 pushtag (loc, name, type);
1603 /* An exported interface to bind a declaration. LOC is the location
1604 to use. DECL is the declaration to bind. The decl's name is used
1605 to determine how it is bound. If DECL is a VAR_DECL, then
1606 IS_GLOBAL determines whether the decl is put into the global (file
1607 and external) scope or the current function's scope; if DECL is not
1608 a VAR_DECL then it is always put into the file scope. */
1611 c_bind (location_t loc, tree decl, bool is_global)
1613 struct c_scope *scope;
1614 bool nested = false;
1616 if (TREE_CODE (decl) != VAR_DECL || current_function_scope == NULL)
1618 /* Types and functions are always considered to be global. */
1620 DECL_EXTERNAL (decl) = 1;
1621 TREE_PUBLIC (decl) = 1;
1625 /* Also bind it into the external scope. */
1626 bind (DECL_NAME (decl), decl, external_scope, true, false, loc);
1629 DECL_EXTERNAL (decl) = 1;
1630 TREE_PUBLIC (decl) = 1;
1634 DECL_CONTEXT (decl) = current_function_decl;
1635 TREE_PUBLIC (decl) = 0;
1636 scope = current_function_scope;
1639 bind (DECL_NAME (decl), decl, scope, false, nested, loc);
1642 /* Subroutine of compare_decls. Allow harmless mismatches in return
1643 and argument types provided that the type modes match. This function
1644 return a unified type given a suitable match, and 0 otherwise. */
1647 match_builtin_function_types (tree newtype, tree oldtype)
1649 tree newrettype, oldrettype;
1650 tree newargs, oldargs;
1651 tree trytype, tryargs;
1653 /* Accept the return type of the new declaration if same modes. */
1654 oldrettype = TREE_TYPE (oldtype);
1655 newrettype = TREE_TYPE (newtype);
1657 if (TYPE_MODE (oldrettype) != TYPE_MODE (newrettype))
1660 oldargs = TYPE_ARG_TYPES (oldtype);
1661 newargs = TYPE_ARG_TYPES (newtype);
1664 while (oldargs || newargs)
1668 || !TREE_VALUE (oldargs)
1669 || !TREE_VALUE (newargs)
1670 || TYPE_MODE (TREE_VALUE (oldargs))
1671 != TYPE_MODE (TREE_VALUE (newargs)))
1674 oldargs = TREE_CHAIN (oldargs);
1675 newargs = TREE_CHAIN (newargs);
1678 trytype = build_function_type (newrettype, tryargs);
1679 return build_type_attribute_variant (trytype, TYPE_ATTRIBUTES (oldtype));
1682 /* Subroutine of diagnose_mismatched_decls. Check for function type
1683 mismatch involving an empty arglist vs a nonempty one and give clearer
1686 diagnose_arglist_conflict (tree newdecl, tree olddecl,
1687 tree newtype, tree oldtype)
1691 if (TREE_CODE (olddecl) != FUNCTION_DECL
1692 || !comptypes (TREE_TYPE (oldtype), TREE_TYPE (newtype))
1693 || !((!prototype_p (oldtype) && DECL_INITIAL (olddecl) == 0)
1694 || (!prototype_p (newtype) && DECL_INITIAL (newdecl) == 0)))
1697 t = TYPE_ARG_TYPES (oldtype);
1699 t = TYPE_ARG_TYPES (newtype);
1700 for (; t; t = TREE_CHAIN (t))
1702 tree type = TREE_VALUE (t);
1704 if (TREE_CHAIN (t) == 0
1705 && TYPE_MAIN_VARIANT (type) != void_type_node)
1707 inform (input_location, "a parameter list with an ellipsis can%'t match "
1708 "an empty parameter name list declaration");
1712 if (c_type_promotes_to (type) != type)
1714 inform (input_location, "an argument type that has a default promotion can%'t match "
1715 "an empty parameter name list declaration");
1721 /* Another subroutine of diagnose_mismatched_decls. OLDDECL is an
1722 old-style function definition, NEWDECL is a prototype declaration.
1723 Diagnose inconsistencies in the argument list. Returns TRUE if
1724 the prototype is compatible, FALSE if not. */
1726 validate_proto_after_old_defn (tree newdecl, tree newtype, tree oldtype)
1728 tree newargs, oldargs;
1731 #define END_OF_ARGLIST(t) ((t) == void_type_node)
1733 oldargs = TYPE_ACTUAL_ARG_TYPES (oldtype);
1734 newargs = TYPE_ARG_TYPES (newtype);
1739 tree oldargtype = TREE_VALUE (oldargs);
1740 tree newargtype = TREE_VALUE (newargs);
1742 if (oldargtype == error_mark_node || newargtype == error_mark_node)
1745 oldargtype = (TYPE_ATOMIC (oldargtype)
1746 ? c_build_qualified_type (TYPE_MAIN_VARIANT (oldargtype),
1748 : TYPE_MAIN_VARIANT (oldargtype));
1749 newargtype = (TYPE_ATOMIC (newargtype)
1750 ? c_build_qualified_type (TYPE_MAIN_VARIANT (newargtype),
1752 : TYPE_MAIN_VARIANT (newargtype));
1754 if (END_OF_ARGLIST (oldargtype) && END_OF_ARGLIST (newargtype))
1757 /* Reaching the end of just one list means the two decls don't
1758 agree on the number of arguments. */
1759 if (END_OF_ARGLIST (oldargtype))
1761 error ("prototype for %q+D declares more arguments "
1762 "than previous old-style definition", newdecl);
1765 else if (END_OF_ARGLIST (newargtype))
1767 error ("prototype for %q+D declares fewer arguments "
1768 "than previous old-style definition", newdecl);
1772 /* Type for passing arg must be consistent with that declared
1774 else if (!comptypes (oldargtype, newargtype))
1776 error ("prototype for %q+D declares argument %d"
1777 " with incompatible type",
1782 oldargs = TREE_CHAIN (oldargs);
1783 newargs = TREE_CHAIN (newargs);
1787 /* If we get here, no errors were found, but do issue a warning
1788 for this poor-style construct. */
1789 warning (0, "prototype for %q+D follows non-prototype definition",
1792 #undef END_OF_ARGLIST
1795 /* Subroutine of diagnose_mismatched_decls. Report the location of DECL,
1796 first in a pair of mismatched declarations, using the diagnostic
1799 locate_old_decl (tree decl)
1801 if (TREE_CODE (decl) == FUNCTION_DECL && DECL_BUILT_IN (decl)
1802 && !C_DECL_DECLARED_BUILTIN (decl))
1804 else if (DECL_INITIAL (decl))
1805 inform (input_location, "previous definition of %q+D was here", decl);
1806 else if (C_DECL_IMPLICIT (decl))
1807 inform (input_location, "previous implicit declaration of %q+D was here", decl);
1809 inform (input_location, "previous declaration of %q+D was here", decl);
1812 /* Subroutine of duplicate_decls. Compare NEWDECL to OLDDECL.
1813 Returns true if the caller should proceed to merge the two, false
1814 if OLDDECL should simply be discarded. As a side effect, issues
1815 all necessary diagnostics for invalid or poor-style combinations.
1816 If it returns true, writes the types of NEWDECL and OLDDECL to
1817 *NEWTYPEP and *OLDTYPEP - these may have been adjusted from
1818 TREE_TYPE (NEWDECL, OLDDECL) respectively. */
1821 diagnose_mismatched_decls (tree newdecl, tree olddecl,
1822 tree *newtypep, tree *oldtypep)
1824 tree newtype, oldtype;
1825 bool pedwarned = false;
1826 bool warned = false;
1829 #define DECL_EXTERN_INLINE(DECL) (DECL_DECLARED_INLINE_P (DECL) \
1830 && DECL_EXTERNAL (DECL))
1832 /* If we have error_mark_node for either decl or type, just discard
1833 the previous decl - we're in an error cascade already. */
1834 if (olddecl == error_mark_node || newdecl == error_mark_node)
1836 *oldtypep = oldtype = TREE_TYPE (olddecl);
1837 *newtypep = newtype = TREE_TYPE (newdecl);
1838 if (oldtype == error_mark_node || newtype == error_mark_node)
1841 /* Two different categories of symbol altogether. This is an error
1842 unless OLDDECL is a builtin. OLDDECL will be discarded in any case. */
1843 if (TREE_CODE (olddecl) != TREE_CODE (newdecl))
1845 if (!(TREE_CODE (olddecl) == FUNCTION_DECL
1846 && DECL_BUILT_IN (olddecl)
1847 && !C_DECL_DECLARED_BUILTIN (olddecl)))
1849 error ("%q+D redeclared as different kind of symbol", newdecl);
1850 locate_old_decl (olddecl);
1852 else if (TREE_PUBLIC (newdecl))
1853 warning (0, "built-in function %q+D declared as non-function",
1856 warning (OPT_Wshadow, "declaration of %q+D shadows "
1857 "a built-in function", newdecl);
1861 /* Enumerators have no linkage, so may only be declared once in a
1863 if (TREE_CODE (olddecl) == CONST_DECL)
1865 error ("redeclaration of enumerator %q+D", newdecl);
1866 locate_old_decl (olddecl);
1870 if (!comptypes (oldtype, newtype))
1872 if (TREE_CODE (olddecl) == FUNCTION_DECL
1873 && DECL_BUILT_IN (olddecl) && !C_DECL_DECLARED_BUILTIN (olddecl))
1875 /* Accept harmless mismatch in function types.
1876 This is for the ffs and fprintf builtins. */
1877 tree trytype = match_builtin_function_types (newtype, oldtype);
1879 if (trytype && comptypes (newtype, trytype))
1880 *oldtypep = oldtype = trytype;
1883 /* If types don't match for a built-in, throw away the
1884 built-in. No point in calling locate_old_decl here, it
1885 won't print anything. */
1886 warning (0, "conflicting types for built-in function %q+D",
1891 else if (TREE_CODE (olddecl) == FUNCTION_DECL
1892 && DECL_IS_BUILTIN (olddecl))
1894 /* A conflicting function declaration for a predeclared
1895 function that isn't actually built in. Objective C uses
1896 these. The new declaration silently overrides everything
1897 but the volatility (i.e. noreturn) indication. See also
1898 below. FIXME: Make Objective C use normal builtins. */
1899 TREE_THIS_VOLATILE (newdecl) |= TREE_THIS_VOLATILE (olddecl);
1902 /* Permit void foo (...) to match int foo (...) if the latter is
1903 the definition and implicit int was used. See
1904 c-torture/compile/920625-2.c. */
1905 else if (TREE_CODE (newdecl) == FUNCTION_DECL && DECL_INITIAL (newdecl)
1906 && TYPE_MAIN_VARIANT (TREE_TYPE (oldtype)) == void_type_node
1907 && TYPE_MAIN_VARIANT (TREE_TYPE (newtype)) == integer_type_node
1908 && C_FUNCTION_IMPLICIT_INT (newdecl) && !DECL_INITIAL (olddecl))
1910 pedwarned = pedwarn (input_location, 0,
1911 "conflicting types for %q+D", newdecl);
1912 /* Make sure we keep void as the return type. */
1913 TREE_TYPE (newdecl) = *newtypep = newtype = oldtype;
1914 C_FUNCTION_IMPLICIT_INT (newdecl) = 0;
1916 /* Permit void foo (...) to match an earlier call to foo (...) with
1917 no declared type (thus, implicitly int). */
1918 else if (TREE_CODE (newdecl) == FUNCTION_DECL
1919 && TYPE_MAIN_VARIANT (TREE_TYPE (newtype)) == void_type_node
1920 && TYPE_MAIN_VARIANT (TREE_TYPE (oldtype)) == integer_type_node
1921 && C_DECL_IMPLICIT (olddecl) && !DECL_INITIAL (olddecl))
1923 pedwarned = pedwarn (input_location, 0,
1924 "conflicting types for %q+D", newdecl);
1925 /* Make sure we keep void as the return type. */
1926 TREE_TYPE (olddecl) = *oldtypep = oldtype = newtype;
1930 int new_quals = TYPE_QUALS (newtype);
1931 int old_quals = TYPE_QUALS (oldtype);
1933 if (new_quals != old_quals)
1935 addr_space_t new_addr = DECODE_QUAL_ADDR_SPACE (new_quals);
1936 addr_space_t old_addr = DECODE_QUAL_ADDR_SPACE (old_quals);
1937 if (new_addr != old_addr)
1939 if (ADDR_SPACE_GENERIC_P (new_addr))
1940 error ("conflicting named address spaces (generic vs %s) "
1942 c_addr_space_name (old_addr), newdecl);
1943 else if (ADDR_SPACE_GENERIC_P (old_addr))
1944 error ("conflicting named address spaces (%s vs generic) "
1946 c_addr_space_name (new_addr), newdecl);
1948 error ("conflicting named address spaces (%s vs %s) "
1950 c_addr_space_name (new_addr),
1951 c_addr_space_name (old_addr),
1955 if (CLEAR_QUAL_ADDR_SPACE (new_quals)
1956 != CLEAR_QUAL_ADDR_SPACE (old_quals))
1957 error ("conflicting type qualifiers for %q+D", newdecl);
1960 error ("conflicting types for %q+D", newdecl);
1961 diagnose_arglist_conflict (newdecl, olddecl, newtype, oldtype);
1962 locate_old_decl (olddecl);
1967 /* Redeclaration of a type is a constraint violation (6.7.2.3p1),
1968 but silently ignore the redeclaration if either is in a system
1969 header. (Conflicting redeclarations were handled above.) This
1970 is allowed for C11 if the types are the same, not just
1972 if (TREE_CODE (newdecl) == TYPE_DECL)
1974 bool types_different = false;
1975 int comptypes_result;
1978 = comptypes_check_different_types (oldtype, newtype, &types_different);
1980 if (comptypes_result != 1 || types_different)
1982 error ("redefinition of typedef %q+D with different type", newdecl);
1983 locate_old_decl (olddecl);
1987 if (DECL_IN_SYSTEM_HEADER (newdecl)
1988 || DECL_IN_SYSTEM_HEADER (olddecl)
1989 || TREE_NO_WARNING (newdecl)
1990 || TREE_NO_WARNING (olddecl))
1991 return true; /* Allow OLDDECL to continue in use. */
1993 if (variably_modified_type_p (newtype, NULL))
1995 error ("redefinition of typedef %q+D with variably modified type",
1997 locate_old_decl (olddecl);
1999 else if (pedwarn_c99 (input_location, OPT_Wpedantic,
2000 "redefinition of typedef %q+D", newdecl))
2001 locate_old_decl (olddecl);
2006 /* Function declarations can either be 'static' or 'extern' (no
2007 qualifier is equivalent to 'extern' - C99 6.2.2p5) and therefore
2008 can never conflict with each other on account of linkage
2009 (6.2.2p4). Multiple definitions are not allowed (6.9p3,5) but
2010 gnu89 mode permits two definitions if one is 'extern inline' and
2011 one is not. The non- extern-inline definition supersedes the
2012 extern-inline definition. */
2014 else if (TREE_CODE (newdecl) == FUNCTION_DECL)
2016 /* If you declare a built-in function name as static, or
2017 define the built-in with an old-style definition (so we
2018 can't validate the argument list) the built-in definition is
2019 overridden, but optionally warn this was a bad choice of name. */
2020 if (DECL_BUILT_IN (olddecl)
2021 && !C_DECL_DECLARED_BUILTIN (olddecl)
2022 && (!TREE_PUBLIC (newdecl)
2023 || (DECL_INITIAL (newdecl)
2024 && !prototype_p (TREE_TYPE (newdecl)))))
2026 warning (OPT_Wshadow, "declaration of %q+D shadows "
2027 "a built-in function", newdecl);
2028 /* Discard the old built-in function. */
2032 if (DECL_INITIAL (newdecl))
2034 if (DECL_INITIAL (olddecl))
2036 /* If both decls are in the same TU and the new declaration
2037 isn't overriding an extern inline reject the new decl.
2038 In c99, no overriding is allowed in the same translation
2040 if ((!DECL_EXTERN_INLINE (olddecl)
2041 || DECL_EXTERN_INLINE (newdecl)
2042 || (!flag_gnu89_inline
2043 && (!DECL_DECLARED_INLINE_P (olddecl)
2044 || !lookup_attribute ("gnu_inline",
2045 DECL_ATTRIBUTES (olddecl)))
2046 && (!DECL_DECLARED_INLINE_P (newdecl)
2047 || !lookup_attribute ("gnu_inline",
2048 DECL_ATTRIBUTES (newdecl))))
2050 && same_translation_unit_p (newdecl, olddecl))
2052 error ("redefinition of %q+D", newdecl);
2053 locate_old_decl (olddecl);
2058 /* If we have a prototype after an old-style function definition,
2059 the argument types must be checked specially. */
2060 else if (DECL_INITIAL (olddecl)
2061 && !prototype_p (oldtype) && prototype_p (newtype)
2062 && TYPE_ACTUAL_ARG_TYPES (oldtype)
2063 && !validate_proto_after_old_defn (newdecl, newtype, oldtype))
2065 locate_old_decl (olddecl);
2068 /* A non-static declaration (even an "extern") followed by a
2069 static declaration is undefined behavior per C99 6.2.2p3-5,7.
2070 The same is true for a static forward declaration at block
2071 scope followed by a non-static declaration/definition at file
2072 scope. Static followed by non-static at the same scope is
2073 not undefined behavior, and is the most convenient way to get
2074 some effects (see e.g. what unwind-dw2-fde-glibc.c does to
2075 the definition of _Unwind_Find_FDE in unwind-dw2-fde.c), but
2076 we do diagnose it if -Wtraditional. */
2077 if (TREE_PUBLIC (olddecl) && !TREE_PUBLIC (newdecl))
2079 /* Two exceptions to the rule. If olddecl is an extern
2080 inline, or a predeclared function that isn't actually
2081 built in, newdecl silently overrides olddecl. The latter
2082 occur only in Objective C; see also above. (FIXME: Make
2083 Objective C use normal builtins.) */
2084 if (!DECL_IS_BUILTIN (olddecl)
2085 && !DECL_EXTERN_INLINE (olddecl))
2087 error ("static declaration of %q+D follows "
2088 "non-static declaration", newdecl);
2089 locate_old_decl (olddecl);
2093 else if (TREE_PUBLIC (newdecl) && !TREE_PUBLIC (olddecl))
2095 if (DECL_CONTEXT (olddecl))
2097 error ("non-static declaration of %q+D follows "
2098 "static declaration", newdecl);
2099 locate_old_decl (olddecl);
2102 else if (warn_traditional)
2104 warned |= warning (OPT_Wtraditional,
2105 "non-static declaration of %q+D "
2106 "follows static declaration", newdecl);
2110 /* Make sure gnu_inline attribute is either not present, or
2111 present on all inline decls. */
2112 if (DECL_DECLARED_INLINE_P (olddecl)
2113 && DECL_DECLARED_INLINE_P (newdecl))
2115 bool newa = lookup_attribute ("gnu_inline",
2116 DECL_ATTRIBUTES (newdecl)) != NULL;
2117 bool olda = lookup_attribute ("gnu_inline",
2118 DECL_ATTRIBUTES (olddecl)) != NULL;
2121 error_at (input_location, "%<gnu_inline%> attribute present on %q+D",
2122 newa ? newdecl : olddecl);
2123 error_at (DECL_SOURCE_LOCATION (newa ? olddecl : newdecl),
2128 else if (TREE_CODE (newdecl) == VAR_DECL)
2130 /* Only variables can be thread-local, and all declarations must
2131 agree on this property. */
2132 if (C_DECL_THREADPRIVATE_P (olddecl) && !DECL_THREAD_LOCAL_P (newdecl))
2134 /* Nothing to check. Since OLDDECL is marked threadprivate
2135 and NEWDECL does not have a thread-local attribute, we
2136 will merge the threadprivate attribute into NEWDECL. */
2139 else if (DECL_THREAD_LOCAL_P (newdecl) != DECL_THREAD_LOCAL_P (olddecl))
2141 if (DECL_THREAD_LOCAL_P (newdecl))
2142 error ("thread-local declaration of %q+D follows "
2143 "non-thread-local declaration", newdecl);
2145 error ("non-thread-local declaration of %q+D follows "
2146 "thread-local declaration", newdecl);
2148 locate_old_decl (olddecl);
2152 /* Multiple initialized definitions are not allowed (6.9p3,5). */
2153 if (DECL_INITIAL (newdecl) && DECL_INITIAL (olddecl))
2155 error ("redefinition of %q+D", newdecl);
2156 locate_old_decl (olddecl);
2160 /* Objects declared at file scope: if the first declaration had
2161 external linkage (even if it was an external reference) the
2162 second must have external linkage as well, or the behavior is
2163 undefined. If the first declaration had internal linkage, then
2164 the second must too, or else be an external reference (in which
2165 case the composite declaration still has internal linkage).
2166 As for function declarations, we warn about the static-then-
2167 extern case only for -Wtraditional. See generally 6.2.2p3-5,7. */
2168 if (DECL_FILE_SCOPE_P (newdecl)
2169 && TREE_PUBLIC (newdecl) != TREE_PUBLIC (olddecl))
2171 if (DECL_EXTERNAL (newdecl))
2173 if (!DECL_FILE_SCOPE_P (olddecl))
2175 error ("extern declaration of %q+D follows "
2176 "declaration with no linkage", newdecl);
2177 locate_old_decl (olddecl);
2180 else if (warn_traditional)
2182 warned |= warning (OPT_Wtraditional,
2183 "non-static declaration of %q+D "
2184 "follows static declaration", newdecl);
2189 if (TREE_PUBLIC (newdecl))
2190 error ("non-static declaration of %q+D follows "
2191 "static declaration", newdecl);
2193 error ("static declaration of %q+D follows "
2194 "non-static declaration", newdecl);
2196 locate_old_decl (olddecl);
2200 /* Two objects with the same name declared at the same block
2201 scope must both be external references (6.7p3). */
2202 else if (!DECL_FILE_SCOPE_P (newdecl))
2204 if (DECL_EXTERNAL (newdecl))
2206 /* Extern with initializer at block scope, which will
2207 already have received an error. */
2209 else if (DECL_EXTERNAL (olddecl))
2211 error ("declaration of %q+D with no linkage follows "
2212 "extern declaration", newdecl);
2213 locate_old_decl (olddecl);
2217 error ("redeclaration of %q+D with no linkage", newdecl);
2218 locate_old_decl (olddecl);
2224 /* C++ does not permit a decl to appear multiple times at file
2227 && DECL_FILE_SCOPE_P (newdecl)
2228 && !DECL_EXTERNAL (newdecl)
2229 && !DECL_EXTERNAL (olddecl))
2230 warned |= warning_at (DECL_SOURCE_LOCATION (newdecl),
2232 ("duplicate declaration of %qD is "
2238 /* All decls must agree on a visibility. */
2239 if (CODE_CONTAINS_STRUCT (TREE_CODE (newdecl), TS_DECL_WITH_VIS)
2240 && DECL_VISIBILITY_SPECIFIED (newdecl) && DECL_VISIBILITY_SPECIFIED (olddecl)
2241 && DECL_VISIBILITY (newdecl) != DECL_VISIBILITY (olddecl))
2243 warned |= warning (0, "redeclaration of %q+D with different visibility "
2244 "(old visibility preserved)", newdecl);
2247 if (TREE_CODE (newdecl) == FUNCTION_DECL)
2249 /* Diagnose inline __attribute__ ((noinline)) which is silly. */
2250 if (DECL_DECLARED_INLINE_P (newdecl)
2251 && lookup_attribute ("noinline", DECL_ATTRIBUTES (olddecl)))
2252 warned |= warning (OPT_Wattributes,
2253 "inline declaration of %qD follows "
2254 "declaration with attribute noinline", newdecl);
2255 else if (DECL_DECLARED_INLINE_P (olddecl)
2256 && lookup_attribute ("noinline", DECL_ATTRIBUTES (newdecl)))
2257 warned |= warning (OPT_Wattributes,
2258 "declaration of %q+D with attribute "
2259 "noinline follows inline declaration ", newdecl);
2260 else if (lookup_attribute ("noinline", DECL_ATTRIBUTES (newdecl))
2261 && lookup_attribute ("always_inline", DECL_ATTRIBUTES (olddecl)))
2262 warned |= warning (OPT_Wattributes,
2263 "declaration of %q+D with attribute "
2264 "%qs follows declaration with attribute %qs",
2265 newdecl, "noinline", "always_inline");
2266 else if (lookup_attribute ("always_inline", DECL_ATTRIBUTES (newdecl))
2267 && lookup_attribute ("noinline", DECL_ATTRIBUTES (olddecl)))
2268 warned |= warning (OPT_Wattributes,
2269 "declaration of %q+D with attribute "
2270 "%qs follows declaration with attribute %qs",
2271 newdecl, "always_inline", "noinline");
2272 else if (lookup_attribute ("cold", DECL_ATTRIBUTES (newdecl))
2273 && lookup_attribute ("hot", DECL_ATTRIBUTES (olddecl)))
2274 warned |= warning (OPT_Wattributes,
2275 "declaration of %q+D with attribute %qs follows "
2276 "declaration with attribute %qs", newdecl, "cold",
2278 else if (lookup_attribute ("hot", DECL_ATTRIBUTES (newdecl))
2279 && lookup_attribute ("cold", DECL_ATTRIBUTES (olddecl)))
2280 warned |= warning (OPT_Wattributes,
2281 "declaration of %q+D with attribute %qs follows "
2282 "declaration with attribute %qs", newdecl, "hot",
2285 else /* PARM_DECL, VAR_DECL */
2287 /* Redeclaration of a parameter is a constraint violation (this is
2288 not explicitly stated, but follows from C99 6.7p3 [no more than
2289 one declaration of the same identifier with no linkage in the
2290 same scope, except type tags] and 6.2.2p6 [parameters have no
2291 linkage]). We must check for a forward parameter declaration,
2292 indicated by TREE_ASM_WRITTEN on the old declaration - this is
2293 an extension, the mandatory diagnostic for which is handled by
2294 mark_forward_parm_decls. */
2296 if (TREE_CODE (newdecl) == PARM_DECL
2297 && (!TREE_ASM_WRITTEN (olddecl) || TREE_ASM_WRITTEN (newdecl)))
2299 error ("redefinition of parameter %q+D", newdecl);
2300 locate_old_decl (olddecl);
2305 /* Optional warning for completely redundant decls. */
2306 if (!warned && !pedwarned
2307 && warn_redundant_decls
2308 /* Don't warn about a function declaration followed by a
2310 && !(TREE_CODE (newdecl) == FUNCTION_DECL
2311 && DECL_INITIAL (newdecl) && !DECL_INITIAL (olddecl))
2312 /* Don't warn about redundant redeclarations of builtins. */
2313 && !(TREE_CODE (newdecl) == FUNCTION_DECL
2314 && !DECL_BUILT_IN (newdecl)
2315 && DECL_BUILT_IN (olddecl)
2316 && !C_DECL_DECLARED_BUILTIN (olddecl))
2317 /* Don't warn about an extern followed by a definition. */
2318 && !(DECL_EXTERNAL (olddecl) && !DECL_EXTERNAL (newdecl))
2319 /* Don't warn about forward parameter decls. */
2320 && !(TREE_CODE (newdecl) == PARM_DECL
2321 && TREE_ASM_WRITTEN (olddecl) && !TREE_ASM_WRITTEN (newdecl))
2322 /* Don't warn about a variable definition following a declaration. */
2323 && !(TREE_CODE (newdecl) == VAR_DECL
2324 && DECL_INITIAL (newdecl) && !DECL_INITIAL (olddecl)))
2326 warned = warning (OPT_Wredundant_decls, "redundant redeclaration of %q+D",
2330 /* Report location of previous decl/defn. */
2331 if (warned || pedwarned)
2332 locate_old_decl (olddecl);
2334 #undef DECL_EXTERN_INLINE
2339 /* Subroutine of duplicate_decls. NEWDECL has been found to be
2340 consistent with OLDDECL, but carries new information. Merge the
2341 new information into OLDDECL. This function issues no
2345 merge_decls (tree newdecl, tree olddecl, tree newtype, tree oldtype)
2347 bool new_is_definition = (TREE_CODE (newdecl) == FUNCTION_DECL
2348 && DECL_INITIAL (newdecl) != 0);
2349 bool new_is_prototype = (TREE_CODE (newdecl) == FUNCTION_DECL
2350 && prototype_p (TREE_TYPE (newdecl)));
2351 bool old_is_prototype = (TREE_CODE (olddecl) == FUNCTION_DECL
2352 && prototype_p (TREE_TYPE (olddecl)));
2354 /* For real parm decl following a forward decl, rechain the old decl
2355 in its new location and clear TREE_ASM_WRITTEN (it's not a
2356 forward decl anymore). */
2357 if (TREE_CODE (newdecl) == PARM_DECL
2358 && TREE_ASM_WRITTEN (olddecl) && !TREE_ASM_WRITTEN (newdecl))
2360 struct c_binding *b, **here;
2362 for (here = ¤t_scope->bindings; *here; here = &(*here)->prev)
2363 if ((*here)->decl == olddecl)
2370 b->prev = current_scope->bindings;
2371 current_scope->bindings = b;
2373 TREE_ASM_WRITTEN (olddecl) = 0;
2376 DECL_ATTRIBUTES (newdecl)
2377 = targetm.merge_decl_attributes (olddecl, newdecl);
2379 /* For typedefs use the old type, as the new type's DECL_NAME points
2380 at newdecl, which will be ggc_freed. */
2381 if (TREE_CODE (newdecl) == TYPE_DECL)
2383 /* But NEWTYPE might have an attribute, honor that. */
2387 if (TYPE_USER_ALIGN (tem))
2389 if (TYPE_ALIGN (tem) > TYPE_ALIGN (newtype))
2390 TYPE_ALIGN (newtype) = TYPE_ALIGN (tem);
2391 TYPE_USER_ALIGN (newtype) = true;
2394 /* And remove the new type from the variants list. */
2395 if (TYPE_NAME (TREE_TYPE (newdecl)) == newdecl)
2397 tree remove = TREE_TYPE (newdecl);
2398 for (tree t = TYPE_MAIN_VARIANT (remove); ;
2399 t = TYPE_NEXT_VARIANT (t))
2400 if (TYPE_NEXT_VARIANT (t) == remove)
2402 TYPE_NEXT_VARIANT (t) = TYPE_NEXT_VARIANT (remove);
2408 /* Merge the data types specified in the two decls. */
2410 = TREE_TYPE (olddecl)
2411 = composite_type (newtype, oldtype);
2413 /* Lay the type out, unless already done. */
2414 if (!comptypes (oldtype, TREE_TYPE (newdecl)))
2416 if (TREE_TYPE (newdecl) != error_mark_node)
2417 layout_type (TREE_TYPE (newdecl));
2418 if (TREE_CODE (newdecl) != FUNCTION_DECL
2419 && TREE_CODE (newdecl) != TYPE_DECL
2420 && TREE_CODE (newdecl) != CONST_DECL)
2421 layout_decl (newdecl, 0);
2425 /* Since the type is OLDDECL's, make OLDDECL's size go with. */
2426 DECL_SIZE (newdecl) = DECL_SIZE (olddecl);
2427 DECL_SIZE_UNIT (newdecl) = DECL_SIZE_UNIT (olddecl);
2428 DECL_MODE (newdecl) = DECL_MODE (olddecl);
2429 if (DECL_ALIGN (olddecl) > DECL_ALIGN (newdecl))
2431 DECL_ALIGN (newdecl) = DECL_ALIGN (olddecl);
2432 DECL_USER_ALIGN (newdecl) |= DECL_USER_ALIGN (olddecl);
2436 /* Keep the old rtl since we can safely use it. */
2437 if (HAS_RTL_P (olddecl))
2438 COPY_DECL_RTL (olddecl, newdecl);
2440 /* Merge the type qualifiers. */
2441 if (TREE_READONLY (newdecl))
2442 TREE_READONLY (olddecl) = 1;
2444 if (TREE_THIS_VOLATILE (newdecl))
2445 TREE_THIS_VOLATILE (olddecl) = 1;
2447 /* Merge deprecatedness. */
2448 if (TREE_DEPRECATED (newdecl))
2449 TREE_DEPRECATED (olddecl) = 1;
2451 /* If a decl is in a system header and the other isn't, keep the one on the
2452 system header. Otherwise, keep source location of definition rather than
2453 declaration and of prototype rather than non-prototype unless that
2454 prototype is built-in. */
2455 if (CODE_CONTAINS_STRUCT (TREE_CODE (olddecl), TS_DECL_WITH_VIS)
2456 && DECL_IN_SYSTEM_HEADER (olddecl)
2457 && !DECL_IN_SYSTEM_HEADER (newdecl) )
2458 DECL_SOURCE_LOCATION (newdecl) = DECL_SOURCE_LOCATION (olddecl);
2459 else if (CODE_CONTAINS_STRUCT (TREE_CODE (olddecl), TS_DECL_WITH_VIS)
2460 && DECL_IN_SYSTEM_HEADER (newdecl)
2461 && !DECL_IN_SYSTEM_HEADER (olddecl))
2462 DECL_SOURCE_LOCATION (olddecl) = DECL_SOURCE_LOCATION (newdecl);
2463 else if ((DECL_INITIAL (newdecl) == 0 && DECL_INITIAL (olddecl) != 0)
2464 || (old_is_prototype && !new_is_prototype
2465 && !C_DECL_BUILTIN_PROTOTYPE (olddecl)))
2466 DECL_SOURCE_LOCATION (newdecl) = DECL_SOURCE_LOCATION (olddecl);
2468 /* Merge the initialization information. */
2469 if (DECL_INITIAL (newdecl) == 0)
2470 DECL_INITIAL (newdecl) = DECL_INITIAL (olddecl);
2472 /* Merge the threadprivate attribute. */
2473 if (TREE_CODE (olddecl) == VAR_DECL && C_DECL_THREADPRIVATE_P (olddecl))
2474 C_DECL_THREADPRIVATE_P (newdecl) = 1;
2476 if (CODE_CONTAINS_STRUCT (TREE_CODE (olddecl), TS_DECL_WITH_VIS))
2478 /* Copy the assembler name.
2479 Currently, it can only be defined in the prototype. */
2480 COPY_DECL_ASSEMBLER_NAME (olddecl, newdecl);
2482 /* Use visibility of whichever declaration had it specified */
2483 if (DECL_VISIBILITY_SPECIFIED (olddecl))
2485 DECL_VISIBILITY (newdecl) = DECL_VISIBILITY (olddecl);
2486 DECL_VISIBILITY_SPECIFIED (newdecl) = 1;
2489 if (TREE_CODE (newdecl) == FUNCTION_DECL)
2491 DECL_STATIC_CONSTRUCTOR(newdecl) |= DECL_STATIC_CONSTRUCTOR(olddecl);
2492 DECL_STATIC_DESTRUCTOR (newdecl) |= DECL_STATIC_DESTRUCTOR (olddecl);
2493 DECL_NO_LIMIT_STACK (newdecl) |= DECL_NO_LIMIT_STACK (olddecl);
2494 DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (newdecl)
2495 |= DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (olddecl);
2496 TREE_THIS_VOLATILE (newdecl) |= TREE_THIS_VOLATILE (olddecl);
2497 DECL_IS_MALLOC (newdecl) |= DECL_IS_MALLOC (olddecl);
2498 DECL_IS_OPERATOR_NEW (newdecl) |= DECL_IS_OPERATOR_NEW (olddecl);
2499 TREE_READONLY (newdecl) |= TREE_READONLY (olddecl);
2500 DECL_PURE_P (newdecl) |= DECL_PURE_P (olddecl);
2501 DECL_IS_NOVOPS (newdecl) |= DECL_IS_NOVOPS (olddecl);
2504 /* Merge the storage class information. */
2505 merge_weak (newdecl, olddecl);
2507 /* For functions, static overrides non-static. */
2508 if (TREE_CODE (newdecl) == FUNCTION_DECL)
2510 TREE_PUBLIC (newdecl) &= TREE_PUBLIC (olddecl);
2511 /* This is since we don't automatically
2512 copy the attributes of NEWDECL into OLDDECL. */
2513 TREE_PUBLIC (olddecl) = TREE_PUBLIC (newdecl);
2514 /* If this clears `static', clear it in the identifier too. */
2515 if (!TREE_PUBLIC (olddecl))
2516 TREE_PUBLIC (DECL_NAME (olddecl)) = 0;
2520 /* In c99, 'extern' declaration before (or after) 'inline' means this
2521 function is not DECL_EXTERNAL, unless 'gnu_inline' attribute
2523 if (TREE_CODE (newdecl) == FUNCTION_DECL
2524 && !flag_gnu89_inline
2525 && (DECL_DECLARED_INLINE_P (newdecl)
2526 || DECL_DECLARED_INLINE_P (olddecl))
2527 && (!DECL_DECLARED_INLINE_P (newdecl)
2528 || !DECL_DECLARED_INLINE_P (olddecl)
2529 || !DECL_EXTERNAL (olddecl))
2530 && DECL_EXTERNAL (newdecl)
2531 && !lookup_attribute ("gnu_inline", DECL_ATTRIBUTES (newdecl))
2532 && !current_function_decl)
2533 DECL_EXTERNAL (newdecl) = 0;
2535 /* An inline definition following a static declaration is not
2537 if (new_is_definition
2538 && (DECL_DECLARED_INLINE_P (newdecl)
2539 || DECL_DECLARED_INLINE_P (olddecl))
2540 && !TREE_PUBLIC (olddecl))
2541 DECL_EXTERNAL (newdecl) = 0;
2543 if (DECL_EXTERNAL (newdecl))
2545 TREE_STATIC (newdecl) = TREE_STATIC (olddecl);
2546 DECL_EXTERNAL (newdecl) = DECL_EXTERNAL (olddecl);
2548 /* An extern decl does not override previous storage class. */
2549 TREE_PUBLIC (newdecl) = TREE_PUBLIC (olddecl);
2550 if (!DECL_EXTERNAL (newdecl))
2552 DECL_CONTEXT (newdecl) = DECL_CONTEXT (olddecl);
2553 DECL_COMMON (newdecl) = DECL_COMMON (olddecl);
2558 TREE_STATIC (olddecl) = TREE_STATIC (newdecl);
2559 TREE_PUBLIC (olddecl) = TREE_PUBLIC (newdecl);
2562 if (TREE_CODE (newdecl) == FUNCTION_DECL)
2564 /* If we're redefining a function previously defined as extern
2565 inline, make sure we emit debug info for the inline before we
2566 throw it away, in case it was inlined into a function that
2567 hasn't been written out yet. */
2568 if (new_is_definition && DECL_INITIAL (olddecl))
2569 /* The new defn must not be inline. */
2570 DECL_UNINLINABLE (newdecl) = 1;
2573 /* If either decl says `inline', this fn is inline, unless
2574 its definition was passed already. */
2575 if (DECL_DECLARED_INLINE_P (newdecl)
2576 || DECL_DECLARED_INLINE_P (olddecl))
2577 DECL_DECLARED_INLINE_P (newdecl) = 1;
2579 DECL_UNINLINABLE (newdecl) = DECL_UNINLINABLE (olddecl)
2580 = (DECL_UNINLINABLE (newdecl) || DECL_UNINLINABLE (olddecl));
2582 DECL_DISREGARD_INLINE_LIMITS (newdecl)
2583 = DECL_DISREGARD_INLINE_LIMITS (olddecl)
2584 = (DECL_DISREGARD_INLINE_LIMITS (newdecl)
2585 || DECL_DISREGARD_INLINE_LIMITS (olddecl));
2588 if (DECL_BUILT_IN (olddecl))
2590 /* If redeclaring a builtin function, it stays built in.
2591 But it gets tagged as having been declared. */
2592 DECL_BUILT_IN_CLASS (newdecl) = DECL_BUILT_IN_CLASS (olddecl);
2593 DECL_FUNCTION_CODE (newdecl) = DECL_FUNCTION_CODE (olddecl);
2594 C_DECL_DECLARED_BUILTIN (newdecl) = 1;
2595 if (new_is_prototype)
2597 C_DECL_BUILTIN_PROTOTYPE (newdecl) = 0;
2598 if (DECL_BUILT_IN_CLASS (newdecl) == BUILT_IN_NORMAL)
2600 enum built_in_function fncode = DECL_FUNCTION_CODE (newdecl);
2603 /* If a compatible prototype of these builtin functions
2604 is seen, assume the runtime implements it with the
2605 expected semantics. */
2606 case BUILT_IN_STPCPY:
2607 if (builtin_decl_explicit_p (fncode))
2608 set_builtin_decl_implicit_p (fncode, true);
2611 if (builtin_decl_explicit_p (fncode))
2612 set_builtin_decl_declared_p (fncode, true);
2618 C_DECL_BUILTIN_PROTOTYPE (newdecl)
2619 = C_DECL_BUILTIN_PROTOTYPE (olddecl);
2622 /* Preserve function specific target and optimization options */
2623 if (DECL_FUNCTION_SPECIFIC_TARGET (olddecl)
2624 && !DECL_FUNCTION_SPECIFIC_TARGET (newdecl))
2625 DECL_FUNCTION_SPECIFIC_TARGET (newdecl)
2626 = DECL_FUNCTION_SPECIFIC_TARGET (olddecl);
2628 if (DECL_FUNCTION_SPECIFIC_OPTIMIZATION (olddecl)
2629 && !DECL_FUNCTION_SPECIFIC_OPTIMIZATION (newdecl))
2630 DECL_FUNCTION_SPECIFIC_OPTIMIZATION (newdecl)
2631 = DECL_FUNCTION_SPECIFIC_OPTIMIZATION (olddecl);
2633 /* Also preserve various other info from the definition. */
2634 if (!new_is_definition)
2637 DECL_RESULT (newdecl) = DECL_RESULT (olddecl);
2638 DECL_INITIAL (newdecl) = DECL_INITIAL (olddecl);
2639 DECL_STRUCT_FUNCTION (newdecl) = DECL_STRUCT_FUNCTION (olddecl);
2640 DECL_SAVED_TREE (newdecl) = DECL_SAVED_TREE (olddecl);
2641 DECL_ARGUMENTS (newdecl) = copy_list (DECL_ARGUMENTS (olddecl));
2642 for (t = DECL_ARGUMENTS (newdecl); t ; t = DECL_CHAIN (t))
2643 DECL_CONTEXT (t) = newdecl;
2645 /* See if we've got a function to instantiate from. */
2646 if (DECL_SAVED_TREE (olddecl))
2647 DECL_ABSTRACT_ORIGIN (newdecl)
2648 = DECL_ABSTRACT_ORIGIN (olddecl);
2652 /* Merge the USED information. */
2653 if (TREE_USED (olddecl))
2654 TREE_USED (newdecl) = 1;
2655 else if (TREE_USED (newdecl))
2656 TREE_USED (olddecl) = 1;
2657 if (TREE_CODE (olddecl) == VAR_DECL || TREE_CODE (olddecl) == PARM_DECL)
2658 DECL_READ_P (newdecl) |= DECL_READ_P (olddecl);
2659 if (DECL_PRESERVE_P (olddecl))
2660 DECL_PRESERVE_P (newdecl) = 1;
2661 else if (DECL_PRESERVE_P (newdecl))
2662 DECL_PRESERVE_P (olddecl) = 1;
2664 /* Copy most of the decl-specific fields of NEWDECL into OLDDECL.
2665 But preserve OLDDECL's DECL_UID, DECL_CONTEXT and
2666 DECL_ARGUMENTS (if appropriate). */
2668 unsigned olddecl_uid = DECL_UID (olddecl);
2669 tree olddecl_context = DECL_CONTEXT (olddecl);
2670 tree olddecl_arguments = NULL;
2671 if (TREE_CODE (olddecl) == FUNCTION_DECL)
2672 olddecl_arguments = DECL_ARGUMENTS (olddecl);
2674 memcpy ((char *) olddecl + sizeof (struct tree_common),
2675 (char *) newdecl + sizeof (struct tree_common),
2676 sizeof (struct tree_decl_common) - sizeof (struct tree_common));
2677 DECL_USER_ALIGN (olddecl) = DECL_USER_ALIGN (newdecl);
2678 switch (TREE_CODE (olddecl))
2683 struct symtab_node *snode = olddecl->decl_with_vis.symtab_node;
2685 memcpy ((char *) olddecl + sizeof (struct tree_decl_common),
2686 (char *) newdecl + sizeof (struct tree_decl_common),
2687 tree_code_size (TREE_CODE (olddecl)) - sizeof (struct tree_decl_common));
2688 olddecl->decl_with_vis.symtab_node = snode;
2690 if ((DECL_EXTERNAL (olddecl)
2691 || TREE_PUBLIC (olddecl)
2692 || TREE_STATIC (olddecl))
2693 && DECL_SECTION_NAME (newdecl) != NULL)
2694 set_decl_section_name (olddecl, DECL_SECTION_NAME (newdecl));
2696 /* This isn't quite correct for something like
2697 int __thread x attribute ((tls_model ("local-exec")));
2698 extern int __thread x;
2699 as we'll lose the "local-exec" model. */
2700 if (TREE_CODE (olddecl) == VAR_DECL
2701 && DECL_THREAD_LOCAL_P (newdecl))
2702 set_decl_tls_model (olddecl, DECL_TLS_MODEL (newdecl));
2712 memcpy ((char *) olddecl + sizeof (struct tree_decl_common),
2713 (char *) newdecl + sizeof (struct tree_decl_common),
2714 tree_code_size (TREE_CODE (olddecl)) - sizeof (struct tree_decl_common));
2719 memcpy ((char *) olddecl + sizeof (struct tree_decl_common),
2720 (char *) newdecl + sizeof (struct tree_decl_common),
2721 sizeof (struct tree_decl_non_common) - sizeof (struct tree_decl_common));
2723 DECL_UID (olddecl) = olddecl_uid;
2724 DECL_CONTEXT (olddecl) = olddecl_context;
2725 if (TREE_CODE (olddecl) == FUNCTION_DECL)
2726 DECL_ARGUMENTS (olddecl) = olddecl_arguments;
2729 /* If OLDDECL had its DECL_RTL instantiated, re-invoke make_decl_rtl
2730 so that encode_section_info has a chance to look at the new decl
2731 flags and attributes. */
2732 if (DECL_RTL_SET_P (olddecl)
2733 && (TREE_CODE (olddecl) == FUNCTION_DECL
2734 || (TREE_CODE (olddecl) == VAR_DECL
2735 && TREE_STATIC (olddecl))))
2736 make_decl_rtl (olddecl);
2739 /* Handle when a new declaration NEWDECL has the same name as an old
2740 one OLDDECL in the same binding contour. Prints an error message
2743 If safely possible, alter OLDDECL to look like NEWDECL, and return
2744 true. Otherwise, return false. */
2747 duplicate_decls (tree newdecl, tree olddecl)
2749 tree newtype = NULL, oldtype = NULL;
2751 if (!diagnose_mismatched_decls (newdecl, olddecl, &newtype, &oldtype))
2753 /* Avoid `unused variable' and other warnings for OLDDECL. */
2754 TREE_NO_WARNING (olddecl) = 1;
2758 merge_decls (newdecl, olddecl, newtype, oldtype);
2760 /* The NEWDECL will no longer be needed.
2762 Before releasing the node, be sure to remove function from symbol
2763 table that might have been inserted there to record comdat group.
2764 Be sure to however do not free DECL_STRUCT_FUNCTION because this
2765 structure is shared in between NEWDECL and OLDECL. */
2766 if (TREE_CODE (newdecl) == FUNCTION_DECL)
2767 DECL_STRUCT_FUNCTION (newdecl) = NULL;
2768 if (TREE_CODE (newdecl) == FUNCTION_DECL
2769 || TREE_CODE (newdecl) == VAR_DECL)
2771 struct symtab_node *snode = symtab_node::get (newdecl);
2780 /* Check whether decl-node NEW_DECL shadows an existing declaration. */
2782 warn_if_shadowing (tree new_decl)
2784 struct c_binding *b;
2786 /* Shadow warnings wanted? */
2788 /* No shadow warnings for internally generated vars. */
2789 || DECL_IS_BUILTIN (new_decl)
2790 /* No shadow warnings for vars made for inlining. */
2791 || DECL_FROM_INLINE (new_decl))
2794 /* Is anything being shadowed? Invisible decls do not count. */
2795 for (b = I_SYMBOL_BINDING (DECL_NAME (new_decl)); b; b = b->shadowed)
2796 if (b->decl && b->decl != new_decl && !b->invisible
2797 && (b->decl == error_mark_node
2798 || diagnostic_report_warnings_p (global_dc,
2799 DECL_SOURCE_LOCATION (b->decl))))
2801 tree old_decl = b->decl;
2802 bool warned = false;
2804 if (old_decl == error_mark_node)
2806 warning (OPT_Wshadow, "declaration of %q+D shadows previous "
2807 "non-variable", new_decl);
2810 else if (TREE_CODE (old_decl) == PARM_DECL)
2811 warned = warning (OPT_Wshadow,
2812 "declaration of %q+D shadows a parameter",
2814 else if (DECL_FILE_SCOPE_P (old_decl))
2816 /* Do not warn if a variable shadows a function, unless
2817 the variable is a function or a pointer-to-function. */
2818 if (TREE_CODE (old_decl) == FUNCTION_DECL
2819 && TREE_CODE (new_decl) != FUNCTION_DECL
2820 && !FUNCTION_POINTER_TYPE_P (TREE_TYPE (new_decl)))
2823 warned = warning_at (DECL_SOURCE_LOCATION (new_decl), OPT_Wshadow,
2824 "declaration of %qD shadows a global "
2828 else if (TREE_CODE (old_decl) == FUNCTION_DECL
2829 && DECL_BUILT_IN (old_decl))
2831 warning (OPT_Wshadow, "declaration of %q+D shadows "
2832 "a built-in function", new_decl);
2836 warned = warning (OPT_Wshadow, "declaration of %q+D shadows a "
2837 "previous local", new_decl);
2840 inform (DECL_SOURCE_LOCATION (old_decl),
2841 "shadowed declaration is here");
2847 /* Record a decl-node X as belonging to the current lexical scope.
2848 Check for errors (such as an incompatible declaration for the same
2849 name already seen in the same scope).
2851 Returns either X or an old decl for the same name.
2852 If an old decl is returned, it may have been smashed
2853 to agree with what X says. */
2858 tree name = DECL_NAME (x);
2859 struct c_scope *scope = current_scope;
2860 struct c_binding *b;
2861 bool nested = false;
2862 location_t locus = DECL_SOURCE_LOCATION (x);
2864 /* Must set DECL_CONTEXT for everything not at file scope or
2865 DECL_FILE_SCOPE_P won't work. Local externs don't count
2866 unless they have initializers (which generate code). */
2867 if (current_function_decl
2868 && ((TREE_CODE (x) != FUNCTION_DECL && TREE_CODE (x) != VAR_DECL)
2869 || DECL_INITIAL (x) || !DECL_EXTERNAL (x)))
2870 DECL_CONTEXT (x) = current_function_decl;
2872 /* Anonymous decls are just inserted in the scope. */
2875 bind (name, x, scope, /*invisible=*/false, /*nested=*/false,
2880 /* First, see if there is another declaration with the same name in
2881 the current scope. If there is, duplicate_decls may do all the
2882 work for us. If duplicate_decls returns false, that indicates
2883 two incompatible decls in the same scope; we are to silently
2884 replace the old one (duplicate_decls has issued all appropriate
2885 diagnostics). In particular, we should not consider possible
2886 duplicates in the external scope, or shadowing. */
2887 b = I_SYMBOL_BINDING (name);
2888 if (b && B_IN_SCOPE (b, scope))
2890 struct c_binding *b_ext, *b_use;
2891 tree type = TREE_TYPE (x);
2892 tree visdecl = b->decl;
2893 tree vistype = TREE_TYPE (visdecl);
2894 if (TREE_CODE (TREE_TYPE (x)) == ARRAY_TYPE
2895 && COMPLETE_TYPE_P (TREE_TYPE (x)))
2896 b->inner_comp = false;
2899 /* If this is an external linkage declaration, we should check
2900 for compatibility with the type in the external scope before
2901 setting the type at this scope based on the visible
2902 information only. */
2903 if (TREE_PUBLIC (x) && TREE_PUBLIC (visdecl))
2905 while (b_ext && !B_IN_EXTERNAL_SCOPE (b_ext))
2906 b_ext = b_ext->shadowed;
2911 TREE_TYPE (b_use->decl) = b_use->u.type;
2914 if (duplicate_decls (x, b_use->decl))
2918 /* Save the updated type in the external scope and
2919 restore the proper type for this scope. */
2921 if (comptypes (vistype, type))
2922 thistype = composite_type (vistype, type);
2924 thistype = TREE_TYPE (b_use->decl);
2925 b_use->u.type = TREE_TYPE (b_use->decl);
2926 if (TREE_CODE (b_use->decl) == FUNCTION_DECL
2927 && DECL_BUILT_IN (b_use->decl))
2929 = build_type_attribute_variant (thistype,
2932 TREE_TYPE (b_use->decl) = thistype;
2937 goto skip_external_and_shadow_checks;
2940 /* All declarations with external linkage, and all external
2941 references, go in the external scope, no matter what scope is
2942 current. However, the binding in that scope is ignored for
2943 purposes of normal name lookup. A separate binding structure is
2944 created in the requested scope; this governs the normal
2945 visibility of the symbol.
2947 The binding in the externals scope is used exclusively for
2948 detecting duplicate declarations of the same object, no matter
2949 what scope they are in; this is what we do here. (C99 6.2.7p2:
2950 All declarations that refer to the same object or function shall
2951 have compatible type; otherwise, the behavior is undefined.) */
2952 if (DECL_EXTERNAL (x) || scope == file_scope)
2954 tree type = TREE_TYPE (x);
2957 bool type_saved = false;
2958 if (b && !B_IN_EXTERNAL_SCOPE (b)
2959 && (TREE_CODE (b->decl) == FUNCTION_DECL
2960 || TREE_CODE (b->decl) == VAR_DECL)
2961 && DECL_FILE_SCOPE_P (b->decl))
2964 vistype = TREE_TYPE (visdecl);
2966 if (scope != file_scope
2967 && !DECL_IN_SYSTEM_HEADER (x))
2968 warning (OPT_Wnested_externs, "nested extern declaration of %qD", x);
2970 while (b && !B_IN_EXTERNAL_SCOPE (b))
2972 /* If this decl might be modified, save its type. This is
2973 done here rather than when the decl is first bound
2974 because the type may change after first binding, through
2975 being completed or through attributes being added. If we
2976 encounter multiple such decls, only the first should have
2977 its type saved; the others will already have had their
2978 proper types saved and the types will not have changed as
2979 their scopes will not have been re-entered. */
2980 if (DECL_P (b->decl) && DECL_FILE_SCOPE_P (b->decl) && !type_saved)
2982 b->u.type = TREE_TYPE (b->decl);
2985 if (B_IN_FILE_SCOPE (b)
2986 && TREE_CODE (b->decl) == VAR_DECL
2987 && TREE_STATIC (b->decl)
2988 && TREE_CODE (TREE_TYPE (b->decl)) == ARRAY_TYPE
2989 && !TYPE_DOMAIN (TREE_TYPE (b->decl))
2990 && TREE_CODE (type) == ARRAY_TYPE
2991 && TYPE_DOMAIN (type)
2992 && TYPE_MAX_VALUE (TYPE_DOMAIN (type))
2993 && !integer_zerop (TYPE_MAX_VALUE (TYPE_DOMAIN (type))))
2995 /* Array type completed in inner scope, which should be
2996 diagnosed if the completion does not have size 1 and
2997 it does not get completed in the file scope. */
2998 b->inner_comp = true;
3003 /* If a matching external declaration has been found, set its
3004 type to the composite of all the types of that declaration.
3005 After the consistency checks, it will be reset to the
3006 composite of the visible types only. */
3007 if (b && (TREE_PUBLIC (x) || same_translation_unit_p (x, b->decl))
3009 TREE_TYPE (b->decl) = b->u.type;
3011 /* The point of the same_translation_unit_p check here is,
3012 we want to detect a duplicate decl for a construct like
3013 foo() { extern bar(); } ... static bar(); but not if
3014 they are in different translation units. In any case,
3015 the static does not go in the externals scope. */
3017 && (TREE_PUBLIC (x) || same_translation_unit_p (x, b->decl))
3018 && duplicate_decls (x, b->decl))
3023 if (comptypes (vistype, type))
3024 thistype = composite_type (vistype, type);
3026 thistype = TREE_TYPE (b->decl);
3030 b->u.type = TREE_TYPE (b->decl);
3031 if (TREE_CODE (b->decl) == FUNCTION_DECL && DECL_BUILT_IN (b->decl))
3033 = build_type_attribute_variant (thistype,
3034 TYPE_ATTRIBUTES (b->u.type));
3035 TREE_TYPE (b->decl) = thistype;
3036 bind (name, b->decl, scope, /*invisible=*/false, /*nested=*/true,
3040 else if (TREE_PUBLIC (x))
3042 if (visdecl && !b && duplicate_decls (x, visdecl))
3044 /* An external declaration at block scope referring to a
3045 visible entity with internal linkage. The composite
3046 type will already be correct for this scope, so we
3047 just need to fall through to make the declaration in
3054 bind (name, x, external_scope, /*invisible=*/true,
3055 /*nested=*/false, locus);
3061 if (TREE_CODE (x) != PARM_DECL)
3062 warn_if_shadowing (x);
3064 skip_external_and_shadow_checks:
3065 if (TREE_CODE (x) == TYPE_DECL)
3067 /* So this is a typedef, set its underlying type. */
3068 set_underlying_type (x);
3070 /* If X is a typedef defined in the current function, record it
3071 for the purpose of implementing the -Wunused-local-typedefs
3073 record_locally_defined_typedef (x);
3076 bind (name, x, scope, /*invisible=*/false, nested, locus);
3078 /* If x's type is incomplete because it's based on a
3079 structure or union which has not yet been fully declared,
3080 attach it to that structure or union type, so we can go
3081 back and complete the variable declaration later, if the
3082 structure or union gets fully declared.
3084 If the input is erroneous, we can have error_mark in the type
3085 slot (e.g. "f(void a, ...)") - that doesn't count as an
3087 if (TREE_TYPE (x) != error_mark_node
3088 && !COMPLETE_TYPE_P (TREE_TYPE (x)))
3090 tree element = TREE_TYPE (x);
3092 while (TREE_CODE (element) == ARRAY_TYPE)
3093 element = TREE_TYPE (element);
3094 element = TYPE_MAIN_VARIANT (element);
3096 if ((TREE_CODE (element) == RECORD_TYPE
3097 || TREE_CODE (element) == UNION_TYPE)
3098 && (TREE_CODE (x) != TYPE_DECL
3099 || TREE_CODE (TREE_TYPE (x)) == ARRAY_TYPE)
3100 && !COMPLETE_TYPE_P (element))
3101 C_TYPE_INCOMPLETE_VARS (element)
3102 = tree_cons (NULL_TREE, x, C_TYPE_INCOMPLETE_VARS (element));
3107 /* Record X as belonging to file scope.
3108 This is used only internally by the Objective-C front end,
3109 and is limited to its needs. duplicate_decls is not called;
3110 if there is any preexisting decl for this identifier, it is an ICE. */
3113 pushdecl_top_level (tree x)
3116 bool nested = false;
3117 gcc_assert (TREE_CODE (x) == VAR_DECL || TREE_CODE (x) == CONST_DECL);
3119 name = DECL_NAME (x);
3121 gcc_assert (TREE_CODE (x) == CONST_DECL || !I_SYMBOL_BINDING (name));
3123 if (TREE_PUBLIC (x))
3125 bind (name, x, external_scope, /*invisible=*/true, /*nested=*/false,
3130 bind (name, x, file_scope, /*invisible=*/false, nested, UNKNOWN_LOCATION);
3136 implicit_decl_warning (location_t loc, tree id, tree olddecl)
3138 if (warn_implicit_function_declaration)
3143 warned = pedwarn (loc, OPT_Wimplicit_function_declaration,
3144 "implicit declaration of function %qE", id);
3146 warned = warning_at (loc, OPT_Wimplicit_function_declaration,
3147 G_("implicit declaration of function %qE"), id);
3148 if (olddecl && warned)
3149 locate_old_decl (olddecl);
3153 /* This function represents mapping of a function code FCODE
3154 to its respective header. */
3157 header_for_builtin_fn (enum built_in_function fcode)
3161 CASE_FLT_FN (BUILT_IN_ACOS):
3162 CASE_FLT_FN (BUILT_IN_ACOSH):
3163 CASE_FLT_FN (BUILT_IN_ASIN):
3164 CASE_FLT_FN (BUILT_IN_ASINH):
3165 CASE_FLT_FN (BUILT_IN_ATAN):
3166 CASE_FLT_FN (BUILT_IN_ATANH):
3167 CASE_FLT_FN (BUILT_IN_ATAN2):
3168 CASE_FLT_FN (BUILT_IN_CBRT):
3169 CASE_FLT_FN (BUILT_IN_CEIL):
3170 CASE_FLT_FN (BUILT_IN_COPYSIGN):
3171 CASE_FLT_FN (BUILT_IN_COS):
3172 CASE_FLT_FN (BUILT_IN_COSH):
3173 CASE_FLT_FN (BUILT_IN_ERF):
3174 CASE_FLT_FN (BUILT_IN_ERFC):
3175 CASE_FLT_FN (BUILT_IN_EXP):
3176 CASE_FLT_FN (BUILT_IN_EXP2):
3177 CASE_FLT_FN (BUILT_IN_EXPM1):
3178 CASE_FLT_FN (BUILT_IN_FABS):
3179 CASE_FLT_FN (BUILT_IN_FDIM):
3180 CASE_FLT_FN (BUILT_IN_FLOOR):
3181 CASE_FLT_FN (BUILT_IN_FMA):
3182 CASE_FLT_FN (BUILT_IN_FMAX):
3183 CASE_FLT_FN (BUILT_IN_FMIN):
3184 CASE_FLT_FN (BUILT_IN_FMOD):
3185 CASE_FLT_FN (BUILT_IN_FREXP):
3186 CASE_FLT_FN (BUILT_IN_HYPOT):
3187 CASE_FLT_FN (BUILT_IN_ILOGB):
3188 CASE_FLT_FN (BUILT_IN_LDEXP):
3189 CASE_FLT_FN (BUILT_IN_LGAMMA):
3190 CASE_FLT_FN (BUILT_IN_LLRINT):
3191 CASE_FLT_FN (BUILT_IN_LLROUND):
3192 CASE_FLT_FN (BUILT_IN_LOG):
3193 CASE_FLT_FN (BUILT_IN_LOG10):
3194 CASE_FLT_FN (BUILT_IN_LOG1P):
3195 CASE_FLT_FN (BUILT_IN_LOG2):
3196 CASE_FLT_FN (BUILT_IN_LOGB):
3197 CASE_FLT_FN (BUILT_IN_LRINT):
3198 CASE_FLT_FN (BUILT_IN_LROUND):
3199 CASE_FLT_FN (BUILT_IN_MODF):
3200 CASE_FLT_FN (BUILT_IN_NAN):
3201 CASE_FLT_FN (BUILT_IN_NEARBYINT):
3202 CASE_FLT_FN (BUILT_IN_NEXTAFTER):
3203 CASE_FLT_FN (BUILT_IN_NEXTTOWARD):
3204 CASE_FLT_FN (BUILT_IN_POW):
3205 CASE_FLT_FN (BUILT_IN_REMAINDER):
3206 CASE_FLT_FN (BUILT_IN_REMQUO):
3207 CASE_FLT_FN (BUILT_IN_RINT):
3208 CASE_FLT_FN (BUILT_IN_ROUND):
3209 CASE_FLT_FN (BUILT_IN_SCALBLN):
3210 CASE_FLT_FN (BUILT_IN_SCALBN):
3211 CASE_FLT_FN (BUILT_IN_SIN):
3212 CASE_FLT_FN (BUILT_IN_SINH):
3213 CASE_FLT_FN (BUILT_IN_SINCOS):
3214 CASE_FLT_FN (BUILT_IN_SQRT):
3215 CASE_FLT_FN (BUILT_IN_TAN):
3216 CASE_FLT_FN (BUILT_IN_TANH):
3217 CASE_FLT_FN (BUILT_IN_TGAMMA):
3218 CASE_FLT_FN (BUILT_IN_TRUNC):
3219 case BUILT_IN_ISINF:
3220 case BUILT_IN_ISNAN:
3222 CASE_FLT_FN (BUILT_IN_CABS):
3223 CASE_FLT_FN (BUILT_IN_CACOS):
3224 CASE_FLT_FN (BUILT_IN_CACOSH):
3225 CASE_FLT_FN (BUILT_IN_CARG):
3226 CASE_FLT_FN (BUILT_IN_CASIN):
3227 CASE_FLT_FN (BUILT_IN_CASINH):
3228 CASE_FLT_FN (BUILT_IN_CATAN):
3229 CASE_FLT_FN (BUILT_IN_CATANH):
3230 CASE_FLT_FN (BUILT_IN_CCOS):
3231 CASE_FLT_FN (BUILT_IN_CCOSH):
3232 CASE_FLT_FN (BUILT_IN_CEXP):
3233 CASE_FLT_FN (BUILT_IN_CIMAG):
3234 CASE_FLT_FN (BUILT_IN_CLOG):
3235 CASE_FLT_FN (BUILT_IN_CONJ):
3236 CASE_FLT_FN (BUILT_IN_CPOW):
3237 CASE_FLT_FN (BUILT_IN_CPROJ):
3238 CASE_FLT_FN (BUILT_IN_CREAL):
3239 CASE_FLT_FN (BUILT_IN_CSIN):
3240 CASE_FLT_FN (BUILT_IN_CSINH):
3241 CASE_FLT_FN (BUILT_IN_CSQRT):
3242 CASE_FLT_FN (BUILT_IN_CTAN):
3243 CASE_FLT_FN (BUILT_IN_CTANH):
3244 return "<complex.h>";
3245 case BUILT_IN_MEMCHR:
3246 case BUILT_IN_MEMCMP:
3247 case BUILT_IN_MEMCPY:
3248 case BUILT_IN_MEMMOVE:
3249 case BUILT_IN_MEMSET:
3250 case BUILT_IN_STRCAT:
3251 case BUILT_IN_STRCHR:
3252 case BUILT_IN_STRCMP:
3253 case BUILT_IN_STRCPY:
3254 case BUILT_IN_STRCSPN:
3255 case BUILT_IN_STRLEN:
3256 case BUILT_IN_STRNCAT:
3257 case BUILT_IN_STRNCMP:
3258 case BUILT_IN_STRNCPY:
3259 case BUILT_IN_STRPBRK:
3260 case BUILT_IN_STRRCHR:
3261 case BUILT_IN_STRSPN:
3262 case BUILT_IN_STRSTR:
3263 return "<string.h>";
3264 case BUILT_IN_FPRINTF:
3266 case BUILT_IN_FPUTC:
3267 case BUILT_IN_FPUTS:
3268 case BUILT_IN_FSCANF:
3269 case BUILT_IN_FWRITE:
3270 case BUILT_IN_PRINTF:
3271 case BUILT_IN_PUTCHAR:
3273 case BUILT_IN_SCANF:
3274 case BUILT_IN_SNPRINTF:
3275 case BUILT_IN_SPRINTF:
3276 case BUILT_IN_SSCANF:
3277 case BUILT_IN_VFPRINTF:
3278 case BUILT_IN_VFSCANF:
3279 case BUILT_IN_VPRINTF:
3280 case BUILT_IN_VSCANF:
3281 case BUILT_IN_VSNPRINTF:
3282 case BUILT_IN_VSPRINTF:
3283 case BUILT_IN_VSSCANF:
3285 case BUILT_IN_ISALNUM:
3286 case BUILT_IN_ISALPHA:
3287 case BUILT_IN_ISBLANK:
3288 case BUILT_IN_ISCNTRL:
3289 case BUILT_IN_ISDIGIT:
3290 case BUILT_IN_ISGRAPH:
3291 case BUILT_IN_ISLOWER:
3292 case BUILT_IN_ISPRINT:
3293 case BUILT_IN_ISPUNCT:
3294 case BUILT_IN_ISSPACE:
3295 case BUILT_IN_ISUPPER:
3296 case BUILT_IN_ISXDIGIT:
3297 case BUILT_IN_TOLOWER:
3298 case BUILT_IN_TOUPPER:
3300 case BUILT_IN_ISWALNUM:
3301 case BUILT_IN_ISWALPHA:
3302 case BUILT_IN_ISWBLANK:
3303 case BUILT_IN_ISWCNTRL:
3304 case BUILT_IN_ISWDIGIT:
3305 case BUILT_IN_ISWGRAPH:
3306 case BUILT_IN_ISWLOWER:
3307 case BUILT_IN_ISWPRINT:
3308 case BUILT_IN_ISWPUNCT:
3309 case BUILT_IN_ISWSPACE:
3310 case BUILT_IN_ISWUPPER:
3311 case BUILT_IN_ISWXDIGIT:
3312 case BUILT_IN_TOWLOWER:
3313 case BUILT_IN_TOWUPPER:
3314 return "<wctype.h>";
3315 case BUILT_IN_ABORT:
3317 case BUILT_IN_CALLOC:
3321 case BUILT_IN_LLABS:
3322 case BUILT_IN_MALLOC:
3323 case BUILT_IN_REALLOC:
3324 case BUILT_IN__EXIT2:
3325 case BUILT_IN_ALIGNED_ALLOC:
3326 return "<stdlib.h>";
3327 case BUILT_IN_IMAXABS:
3328 return "<inttypes.h>";
3329 case BUILT_IN_STRFTIME:
3336 /* Generate an implicit declaration for identifier FUNCTIONID at LOC as a
3337 function of type int (). */
3340 implicitly_declare (location_t loc, tree functionid)
3342 struct c_binding *b;
3346 for (b = I_SYMBOL_BINDING (functionid); b; b = b->shadowed)
3348 if (B_IN_SCOPE (b, external_scope))
3357 if (decl == error_mark_node)
3360 /* FIXME: Objective-C has weird not-really-builtin functions
3361 which are supposed to be visible automatically. They wind up
3362 in the external scope because they're pushed before the file
3363 scope gets created. Catch this here and rebind them into the
3365 if (!DECL_BUILT_IN (decl) && DECL_IS_BUILTIN (decl))
3367 bind (functionid, decl, file_scope,
3368 /*invisible=*/false, /*nested=*/true,
3369 DECL_SOURCE_LOCATION (decl));
3374 tree newtype = default_function_type;
3376 TREE_TYPE (decl) = b->u.type;
3377 /* Implicit declaration of a function already declared
3378 (somehow) in a different scope, or as a built-in.
3379 If this is the first time this has happened, warn;
3380 then recycle the old declaration but with the new type. */
3381 if (!C_DECL_IMPLICIT (decl))
3383 implicit_decl_warning (loc, functionid, decl);
3384 C_DECL_IMPLICIT (decl) = 1;
3386 if (DECL_BUILT_IN (decl))
3388 newtype = build_type_attribute_variant (newtype,
3390 (TREE_TYPE (decl)));
3391 if (!comptypes (newtype, TREE_TYPE (decl)))
3393 bool warned = warning_at (loc, 0, "incompatible implicit "
3394 "declaration of built-in "
3395 "function %qD", decl);
3396 /* See if we can hint which header to include. */
3398 = header_for_builtin_fn (DECL_FUNCTION_CODE (decl));
3399 if (header != NULL && warned)
3400 inform (loc, "include %qs or provide a declaration of %qD",
3402 newtype = TREE_TYPE (decl);
3407 if (!comptypes (newtype, TREE_TYPE (decl)))
3409 error_at (loc, "incompatible implicit declaration of "
3410 "function %qD", decl);
3411 locate_old_decl (decl);
3414 b->u.type = TREE_TYPE (decl);
3415 TREE_TYPE (decl) = newtype;
3416 bind (functionid, decl, current_scope,
3417 /*invisible=*/false, /*nested=*/true,
3418 DECL_SOURCE_LOCATION (decl));
3423 /* Not seen before. */
3424 decl = build_decl (loc, FUNCTION_DECL, functionid, default_function_type);
3425 DECL_EXTERNAL (decl) = 1;
3426 TREE_PUBLIC (decl) = 1;
3427 C_DECL_IMPLICIT (decl) = 1;
3428 implicit_decl_warning (loc, functionid, 0);
3429 asmspec_tree = maybe_apply_renaming_pragma (decl, /*asmname=*/NULL);
3431 set_user_assembler_name (decl, TREE_STRING_POINTER (asmspec_tree));
3433 /* C89 says implicit declarations are in the innermost block.
3434 So we record the decl in the standard fashion. */
3435 decl = pushdecl (decl);
3437 /* No need to call objc_check_decl here - it's a function type. */
3438 rest_of_decl_compilation (decl, 0, 0);
3440 /* Write a record describing this implicit function declaration
3441 to the prototypes file (if requested). */
3442 gen_aux_info_record (decl, 0, 1, 0);
3444 /* Possibly apply some default attributes to this implicit declaration. */
3445 decl_attributes (&decl, NULL_TREE, 0);
3450 /* Issue an error message for a reference to an undeclared variable
3451 ID, including a reference to a builtin outside of function-call
3452 context. Establish a binding of the identifier to error_mark_node
3453 in an appropriate scope, which will suppress further errors for the
3454 same identifier. The error message should be given location LOC. */
3456 undeclared_variable (location_t loc, tree id)
3458 static bool already = false;
3459 struct c_scope *scope;
3461 if (current_function_decl == 0)
3463 error_at (loc, "%qE undeclared here (not in a function)", id);
3464 scope = current_scope;
3468 if (!objc_diagnose_private_ivar (id))
3469 error_at (loc, "%qE undeclared (first use in this function)", id);
3472 inform (loc, "each undeclared identifier is reported only"
3473 " once for each function it appears in");
3477 /* If we are parsing old-style parameter decls, current_function_decl
3478 will be nonnull but current_function_scope will be null. */
3479 scope = current_function_scope ? current_function_scope : current_scope;
3481 bind (id, error_mark_node, scope, /*invisible=*/false, /*nested=*/false,
3485 /* Subroutine of lookup_label, declare_label, define_label: construct a
3486 LABEL_DECL with all the proper frills. Also create a struct
3487 c_label_vars initialized for the current scope. */
3490 make_label (location_t location, tree name, bool defining,
3491 struct c_label_vars **p_label_vars)
3493 tree label = build_decl (location, LABEL_DECL, name, void_type_node);
3494 DECL_CONTEXT (label) = current_function_decl;
3495 DECL_MODE (label) = VOIDmode;
3497 c_label_vars *label_vars = ggc_alloc<c_label_vars> ();
3498 label_vars->shadowed = NULL;
3499 set_spot_bindings (&label_vars->label_bindings, defining);
3500 label_vars->decls_in_scope = make_tree_vector ();
3501 label_vars->gotos = NULL;
3502 *p_label_vars = label_vars;
3507 /* Get the LABEL_DECL corresponding to identifier NAME as a label.
3508 Create one if none exists so far for the current function.
3509 This is called when a label is used in a goto expression or
3510 has its address taken. */
3513 lookup_label (tree name)
3516 struct c_label_vars *label_vars;
3518 if (current_function_scope == 0)
3520 error ("label %qE referenced outside of any function", name);
3524 /* Use a label already defined or ref'd with this name, but not if
3525 it is inherited from a containing function and wasn't declared
3527 label = I_LABEL_DECL (name);
3528 if (label && (DECL_CONTEXT (label) == current_function_decl
3529 || C_DECLARED_LABEL_FLAG (label)))
3531 /* If the label has only been declared, update its apparent
3532 location to point here, for better diagnostics if it
3533 turns out not to have been defined. */
3534 if (DECL_INITIAL (label) == NULL_TREE)
3535 DECL_SOURCE_LOCATION (label) = input_location;
3539 /* No label binding for that identifier; make one. */
3540 label = make_label (input_location, name, false, &label_vars);
3542 /* Ordinary labels go in the current function scope. */
3543 bind_label (name, label, current_function_scope, label_vars);
3548 /* Issue a warning about DECL for a goto statement at GOTO_LOC going
3552 warn_about_goto (location_t goto_loc, tree label, tree decl)
3554 if (variably_modified_type_p (TREE_TYPE (decl), NULL_TREE))
3556 "jump into scope of identifier with variably modified type");
3558 warning_at (goto_loc, OPT_Wjump_misses_init,
3559 "jump skips variable initialization");
3560 inform (DECL_SOURCE_LOCATION (label), "label %qD defined here", label);
3561 inform (DECL_SOURCE_LOCATION (decl), "%qD declared here", decl);
3564 /* Look up a label because of a goto statement. This is like
3565 lookup_label, but also issues any appropriate warnings. */
3568 lookup_label_for_goto (location_t loc, tree name)
3571 struct c_label_vars *label_vars;
3575 label = lookup_label (name);
3576 if (label == NULL_TREE)
3579 /* If we are jumping to a different function, we can't issue any
3581 if (DECL_CONTEXT (label) != current_function_decl)
3583 gcc_assert (C_DECLARED_LABEL_FLAG (label));
3587 label_vars = I_LABEL_BINDING (name)->u.label;
3589 /* If the label has not yet been defined, then push this goto on a
3590 list for possible later warnings. */
3591 if (label_vars->label_bindings.scope == NULL)
3593 c_goto_bindings *g = ggc_alloc<c_goto_bindings> ();
3596 set_spot_bindings (&g->goto_bindings, true);
3597 vec_safe_push (label_vars->gotos, g);
3601 /* If there are any decls in label_vars->decls_in_scope, then this
3602 goto has missed the declaration of the decl. This happens for a
3608 Issue a warning or error. */
3609 FOR_EACH_VEC_SAFE_ELT (label_vars->decls_in_scope, ix, decl)
3610 warn_about_goto (loc, label, decl);
3612 if (label_vars->label_bindings.left_stmt_expr)
3614 error_at (loc, "jump into statement expression");
3615 inform (DECL_SOURCE_LOCATION (label), "label %qD defined here", label);
3621 /* Make a label named NAME in the current function, shadowing silently
3622 any that may be inherited from containing functions or containing
3623 scopes. This is called for __label__ declarations. */
3626 declare_label (tree name)
3628 struct c_binding *b = I_LABEL_BINDING (name);
3630 struct c_label_vars *label_vars;
3632 /* Check to make sure that the label hasn't already been declared
3634 if (b && B_IN_CURRENT_SCOPE (b))
3636 error ("duplicate label declaration %qE", name);
3637 locate_old_decl (b->decl);
3639 /* Just use the previous declaration. */
3643 label = make_label (input_location, name, false, &label_vars);
3644 C_DECLARED_LABEL_FLAG (label) = 1;
3646 /* Declared labels go in the current scope. */
3647 bind_label (name, label, current_scope, label_vars);
3652 /* When we define a label, issue any appropriate warnings if there are
3653 any gotos earlier in the function which jump to this label. */
3656 check_earlier_gotos (tree label, struct c_label_vars* label_vars)
3659 struct c_goto_bindings *g;
3661 FOR_EACH_VEC_SAFE_ELT (label_vars->gotos, ix, g)
3663 struct c_binding *b;
3664 struct c_scope *scope;
3666 /* We have a goto to this label. The goto is going forward. In
3667 g->scope, the goto is going to skip any binding which was
3668 defined after g->bindings_in_scope. */
3669 if (g->goto_bindings.scope->has_jump_unsafe_decl)
3671 for (b = g->goto_bindings.scope->bindings;
3672 b != g->goto_bindings.bindings_in_scope;
3675 if (decl_jump_unsafe (b->decl))
3676 warn_about_goto (g->loc, label, b->decl);
3680 /* We also need to warn about decls defined in any scopes
3681 between the scope of the label and the scope of the goto. */
3682 for (scope = label_vars->label_bindings.scope;
3683 scope != g->goto_bindings.scope;
3684 scope = scope->outer)
3686 gcc_assert (scope != NULL);
3687 if (scope->has_jump_unsafe_decl)
3689 if (scope == label_vars->label_bindings.scope)
3690 b = label_vars->label_bindings.bindings_in_scope;
3692 b = scope->bindings;
3693 for (; b != NULL; b = b->prev)
3695 if (decl_jump_unsafe (b->decl))
3696 warn_about_goto (g->loc, label, b->decl);
3701 if (g->goto_bindings.stmt_exprs > 0)
3703 error_at (g->loc, "jump into statement expression");
3704 inform (DECL_SOURCE_LOCATION (label), "label %qD defined here",
3709 /* Now that the label is defined, we will issue warnings about
3710 subsequent gotos to this label when we see them. */
3711 vec_safe_truncate (label_vars->gotos, 0);
3712 label_vars->gotos = NULL;
3715 /* Define a label, specifying the location in the source file.
3716 Return the LABEL_DECL node for the label, if the definition is valid.
3717 Otherwise return 0. */
3720 define_label (location_t location, tree name)
3722 /* Find any preexisting label with this name. It is an error
3723 if that label has already been defined in this function, or
3724 if there is a containing function with a declared label with
3726 tree label = I_LABEL_DECL (name);
3729 && ((DECL_CONTEXT (label) == current_function_decl
3730 && DECL_INITIAL (label) != 0)
3731 || (DECL_CONTEXT (label) != current_function_decl
3732 && C_DECLARED_LABEL_FLAG (label))))
3734 error_at (location, "duplicate label %qD", label);
3735 locate_old_decl (label);
3738 else if (label && DECL_CONTEXT (label) == current_function_decl)
3740 struct c_label_vars *label_vars = I_LABEL_BINDING (name)->u.label;
3742 /* The label has been used or declared already in this function,
3743 but not defined. Update its location to point to this
3745 DECL_SOURCE_LOCATION (label) = location;
3746 set_spot_bindings (&label_vars->label_bindings, true);
3748 /* Issue warnings as required about any goto statements from
3749 earlier in the function. */
3750 check_earlier_gotos (label, label_vars);
3754 struct c_label_vars *label_vars;
3756 /* No label binding for that identifier; make one. */
3757 label = make_label (location, name, true, &label_vars);
3759 /* Ordinary labels go in the current function scope. */
3760 bind_label (name, label, current_function_scope, label_vars);
3763 if (!in_system_header_at (input_location) && lookup_name (name))
3764 warning_at (location, OPT_Wtraditional,
3765 "traditional C lacks a separate namespace "
3766 "for labels, identifier %qE conflicts", name);
3768 /* Mark label as having been defined. */
3769 DECL_INITIAL (label) = error_mark_node;
3773 /* Get the bindings for a new switch statement. This is used to issue
3774 warnings as appropriate for jumps from the switch to case or
3777 struct c_spot_bindings *
3778 c_get_switch_bindings (void)
3780 struct c_spot_bindings *switch_bindings;
3782 switch_bindings = XNEW (struct c_spot_bindings);
3783 set_spot_bindings (switch_bindings, true);
3784 return switch_bindings;
3788 c_release_switch_bindings (struct c_spot_bindings *bindings)
3790 gcc_assert (bindings->stmt_exprs == 0 && !bindings->left_stmt_expr);
3794 /* This is called at the point of a case or default label to issue
3795 warnings about decls as needed. It returns true if it found an
3796 error, not just a warning. */
3799 c_check_switch_jump_warnings (struct c_spot_bindings *switch_bindings,
3800 location_t switch_loc, location_t case_loc)
3803 struct c_scope *scope;
3806 for (scope = current_scope;
3807 scope != switch_bindings->scope;
3808 scope = scope->outer)
3810 struct c_binding *b;
3812 gcc_assert (scope != NULL);
3814 if (!scope->has_jump_unsafe_decl)
3817 for (b = scope->bindings; b != NULL; b = b->prev)
3819 if (decl_jump_unsafe (b->decl))
3821 if (variably_modified_type_p (TREE_TYPE (b->decl), NULL_TREE))
3825 ("switch jumps into scope of identifier with "
3826 "variably modified type"));
3829 warning_at (case_loc, OPT_Wjump_misses_init,
3830 "switch jumps over variable initialization");
3831 inform (switch_loc, "switch starts here");
3832 inform (DECL_SOURCE_LOCATION (b->decl), "%qD declared here",
3838 if (switch_bindings->stmt_exprs > 0)
3841 error_at (case_loc, "switch jumps into statement expression");
3842 inform (switch_loc, "switch starts here");
3848 /* Given NAME, an IDENTIFIER_NODE,
3849 return the structure (or union or enum) definition for that name.
3850 If THISLEVEL_ONLY is nonzero, searches only the current_scope.
3851 CODE says which kind of type the caller wants;
3852 it is RECORD_TYPE or UNION_TYPE or ENUMERAL_TYPE.
3853 If PLOC is not NULL and this returns non-null, it sets *PLOC to the
3854 location where the tag was defined.
3855 If the wrong kind of type is found, an error is reported. */
3858 lookup_tag (enum tree_code code, tree name, int thislevel_only,
3861 struct c_binding *b = I_TAG_BINDING (name);
3867 /* We only care about whether it's in this level if
3868 thislevel_only was set or it might be a type clash. */
3869 if (thislevel_only || TREE_CODE (b->decl) != code)
3871 /* For our purposes, a tag in the external scope is the same as
3872 a tag in the file scope. (Primarily relevant to Objective-C
3873 and its builtin structure tags, which get pushed before the
3874 file scope is created.) */
3875 if (B_IN_CURRENT_SCOPE (b)
3876 || (current_scope == file_scope && B_IN_EXTERNAL_SCOPE (b)))
3880 if (thislevel_only && !thislevel)
3883 if (TREE_CODE (b->decl) != code)
3885 /* Definition isn't the kind we were looking for. */
3886 pending_invalid_xref = name;
3887 pending_invalid_xref_location = input_location;
3889 /* If in the same binding level as a declaration as a tag
3890 of a different type, this must not be allowed to
3891 shadow that tag, so give the error immediately.
3892 (For example, "struct foo; union foo;" is invalid.) */
3894 pending_xref_error ();
3903 /* Print an error message now
3904 for a recent invalid struct, union or enum cross reference.
3905 We don't print them immediately because they are not invalid
3906 when used in the `struct foo;' construct for shadowing. */
3909 pending_xref_error (void)
3911 if (pending_invalid_xref != 0)
3912 error_at (pending_invalid_xref_location, "%qE defined as wrong kind of tag",
3913 pending_invalid_xref);
3914 pending_invalid_xref = 0;
3918 /* Look up NAME in the current scope and its superiors
3919 in the namespace of variables, functions and typedefs.
3920 Return a ..._DECL node of some kind representing its definition,
3921 or return 0 if it is undefined. */
3924 lookup_name (tree name)
3926 struct c_binding *b = I_SYMBOL_BINDING (name);
3927 if (b && !b->invisible)
3929 maybe_record_typedef_use (b->decl);
3935 /* Similar to `lookup_name' but look only at the indicated scope. */
3938 lookup_name_in_scope (tree name, struct c_scope *scope)
3940 struct c_binding *b;
3942 for (b = I_SYMBOL_BINDING (name); b; b = b->shadowed)
3943 if (B_IN_SCOPE (b, scope))
3948 /* Create the predefined scalar types of C,
3949 and some nodes representing standard constants (0, 1, (void *) 0).
3950 Initialize the global scope.
3951 Make definitions for built-in primitive functions. */
3954 c_init_decl_processing (void)
3956 location_t save_loc = input_location;
3958 /* Initialize reserved words for parser. */
3961 current_function_decl = 0;
3963 gcc_obstack_init (&parser_obstack);
3965 /* Make the externals scope. */
3967 external_scope = current_scope;
3969 /* Declarations from c_common_nodes_and_builtins must not be associated
3970 with this input file, lest we get differences between using and not
3971 using preprocessed headers. */
3972 input_location = BUILTINS_LOCATION;
3974 c_common_nodes_and_builtins ();
3976 /* In C, comparisons and TRUTH_* expressions have type int. */
3977 truthvalue_type_node = integer_type_node;
3978 truthvalue_true_node = integer_one_node;
3979 truthvalue_false_node = integer_zero_node;
3981 /* Even in C99, which has a real boolean type. */
3982 pushdecl (build_decl (UNKNOWN_LOCATION, TYPE_DECL, get_identifier ("_Bool"),
3983 boolean_type_node));
3985 input_location = save_loc;
3987 make_fname_decl = c_make_fname_decl;
3988 start_fname_decls ();
3991 /* Create the VAR_DECL at LOC for __FUNCTION__ etc. ID is the name to
3992 give the decl, NAME is the initialization string and TYPE_DEP
3993 indicates whether NAME depended on the type of the function. As we
3994 don't yet implement delayed emission of static data, we mark the
3995 decl as emitted so it is not placed in the output. Anything using
3996 it must therefore pull out the STRING_CST initializer directly.
4000 c_make_fname_decl (location_t loc, tree id, int type_dep)
4002 const char *name = fname_as_string (type_dep);
4003 tree decl, type, init;
4004 size_t length = strlen (name);
4006 type = build_array_type (char_type_node,
4007 build_index_type (size_int (length)));
4008 type = c_build_qualified_type (type, TYPE_QUAL_CONST);
4010 decl = build_decl (loc, VAR_DECL, id, type);
4012 TREE_STATIC (decl) = 1;
4013 TREE_READONLY (decl) = 1;
4014 DECL_ARTIFICIAL (decl) = 1;
4016 init = build_string (length + 1, name);
4017 free (CONST_CAST (char *, name));
4018 TREE_TYPE (init) = type;
4019 DECL_INITIAL (decl) = init;
4021 TREE_USED (decl) = 1;
4023 if (current_function_decl
4024 /* For invalid programs like this:
4027 const char* p = __FUNCTION__;
4029 the __FUNCTION__ is believed to appear in K&R style function
4030 parameter declarator. In that case we still don't have
4032 && (!seen_error () || current_function_scope))
4034 DECL_CONTEXT (decl) = current_function_decl;
4035 bind (id, decl, current_function_scope,
4036 /*invisible=*/false, /*nested=*/false, UNKNOWN_LOCATION);
4039 finish_decl (decl, loc, init, NULL_TREE, NULL_TREE);
4045 c_builtin_function (tree decl)
4047 tree type = TREE_TYPE (decl);
4048 tree id = DECL_NAME (decl);
4050 const char *name = IDENTIFIER_POINTER (id);
4051 C_DECL_BUILTIN_PROTOTYPE (decl) = prototype_p (type);
4053 /* Should never be called on a symbol with a preexisting meaning. */
4054 gcc_assert (!I_SYMBOL_BINDING (id));
4056 bind (id, decl, external_scope, /*invisible=*/true, /*nested=*/false,
4059 /* Builtins in the implementation namespace are made visible without
4060 needing to be explicitly declared. See push_file_scope. */
4061 if (name[0] == '_' && (name[1] == '_' || ISUPPER (name[1])))
4063 DECL_CHAIN (decl) = visible_builtins;
4064 visible_builtins = decl;
4071 c_builtin_function_ext_scope (tree decl)
4073 tree type = TREE_TYPE (decl);
4074 tree id = DECL_NAME (decl);
4076 const char *name = IDENTIFIER_POINTER (id);
4077 C_DECL_BUILTIN_PROTOTYPE (decl) = prototype_p (type);
4080 bind (id, decl, external_scope, /*invisible=*/false, /*nested=*/false,
4083 /* Builtins in the implementation namespace are made visible without
4084 needing to be explicitly declared. See push_file_scope. */
4085 if (name[0] == '_' && (name[1] == '_' || ISUPPER (name[1])))
4087 DECL_CHAIN (decl) = visible_builtins;
4088 visible_builtins = decl;
4094 /* Called when a declaration is seen that contains no names to declare.
4095 If its type is a reference to a structure, union or enum inherited
4096 from a containing scope, shadow that tag name for the current scope
4097 with a forward reference.
4098 If its type defines a new named structure or union
4099 or defines an enum, it is valid but we need not do anything here.
4100 Otherwise, it is an error. */
4103 shadow_tag (const struct c_declspecs *declspecs)
4105 shadow_tag_warned (declspecs, 0);
4108 /* WARNED is 1 if we have done a pedwarn, 2 if we have done a warning,
4111 shadow_tag_warned (const struct c_declspecs *declspecs, int warned)
4113 bool found_tag = false;
4115 if (declspecs->type && !declspecs->default_int_p && !declspecs->typedef_p)
4117 tree value = declspecs->type;
4118 enum tree_code code = TREE_CODE (value);
4120 if (code == RECORD_TYPE || code == UNION_TYPE || code == ENUMERAL_TYPE)
4121 /* Used to test also that TYPE_SIZE (value) != 0.
4122 That caused warning for `struct foo;' at top level in the file. */
4124 tree name = TYPE_NAME (value);
4129 if (declspecs->restrict_p)
4131 error ("invalid use of %<restrict%>");
4137 if (warned != 1 && code != ENUMERAL_TYPE)
4138 /* Empty unnamed enum OK */
4140 pedwarn (input_location, 0,
4141 "unnamed struct/union that defines no instances");
4145 else if (declspecs->typespec_kind != ctsk_tagdef
4146 && declspecs->typespec_kind != ctsk_tagfirstref
4147 && declspecs->storage_class != csc_none)
4150 pedwarn (input_location, 0,
4151 "empty declaration with storage class specifier "
4152 "does not redeclare tag");
4154 pending_xref_error ();
4156 else if (declspecs->typespec_kind != ctsk_tagdef
4157 && declspecs->typespec_kind != ctsk_tagfirstref
4158 && (declspecs->const_p
4159 || declspecs->volatile_p
4160 || declspecs->atomic_p
4161 || declspecs->restrict_p
4162 || declspecs->address_space))
4165 pedwarn (input_location, 0,
4166 "empty declaration with type qualifier "
4167 "does not redeclare tag");
4169 pending_xref_error ();
4171 else if (declspecs->typespec_kind != ctsk_tagdef
4172 && declspecs->typespec_kind != ctsk_tagfirstref
4173 && declspecs->alignas_p)
4176 pedwarn (input_location, 0,
4177 "empty declaration with %<_Alignas%> "
4178 "does not redeclare tag");
4180 pending_xref_error ();
4184 pending_invalid_xref = 0;
4185 t = lookup_tag (code, name, 1, NULL);
4189 t = make_node (code);
4190 pushtag (input_location, name, t);
4196 if (warned != 1 && !in_system_header_at (input_location))
4198 pedwarn (input_location, 0,
4199 "useless type name in empty declaration");
4204 else if (warned != 1 && !in_system_header_at (input_location)
4205 && declspecs->typedef_p)
4207 pedwarn (input_location, 0, "useless type name in empty declaration");
4211 pending_invalid_xref = 0;
4213 if (declspecs->inline_p)
4215 error ("%<inline%> in empty declaration");
4219 if (declspecs->noreturn_p)
4221 error ("%<_Noreturn%> in empty declaration");
4225 if (current_scope == file_scope && declspecs->storage_class == csc_auto)
4227 error ("%<auto%> in file-scope empty declaration");
4231 if (current_scope == file_scope && declspecs->storage_class == csc_register)
4233 error ("%<register%> in file-scope empty declaration");
4237 if (!warned && !in_system_header_at (input_location)
4238 && declspecs->storage_class != csc_none)
4240 warning (0, "useless storage class specifier in empty declaration");
4244 if (!warned && !in_system_header_at (input_location) && declspecs->thread_p)
4246 warning (0, "useless %qs in empty declaration",
4247 declspecs->thread_gnu_p ? "__thread" : "_Thread_local");
4252 && !in_system_header_at (input_location)
4253 && (declspecs->const_p
4254 || declspecs->volatile_p
4255 || declspecs->atomic_p
4256 || declspecs->restrict_p
4257 || declspecs->address_space))
4259 warning (0, "useless type qualifier in empty declaration");
4263 if (!warned && !in_system_header_at (input_location)
4264 && declspecs->alignas_p)
4266 warning (0, "useless %<_Alignas%> in empty declaration");
4273 pedwarn (input_location, 0, "empty declaration");
4278 /* Return the qualifiers from SPECS as a bitwise OR of TYPE_QUAL_*
4279 bits. SPECS represents declaration specifiers that the grammar
4280 only permits to contain type qualifiers and attributes. */
4283 quals_from_declspecs (const struct c_declspecs *specs)
4285 int quals = ((specs->const_p ? TYPE_QUAL_CONST : 0)
4286 | (specs->volatile_p ? TYPE_QUAL_VOLATILE : 0)
4287 | (specs->restrict_p ? TYPE_QUAL_RESTRICT : 0)
4288 | (specs->atomic_p ? TYPE_QUAL_ATOMIC : 0)
4289 | (ENCODE_QUAL_ADDR_SPACE (specs->address_space)));
4290 gcc_assert (!specs->type
4291 && !specs->decl_attr
4292 && specs->typespec_word == cts_none
4293 && specs->storage_class == csc_none
4294 && !specs->typedef_p
4295 && !specs->explicit_signed_p
4296 && !specs->deprecated_p
4298 && !specs->long_long_p
4301 && !specs->unsigned_p
4302 && !specs->complex_p
4304 && !specs->noreturn_p
4305 && !specs->thread_p);
4309 /* Construct an array declarator. LOC is the location of the
4310 beginning of the array (usually the opening brace). EXPR is the
4311 expression inside [], or NULL_TREE. QUALS are the type qualifiers
4312 inside the [] (to be applied to the pointer to which a parameter
4313 array is converted). STATIC_P is true if "static" is inside the
4314 [], false otherwise. VLA_UNSPEC_P is true if the array is [*], a
4315 VLA of unspecified length which is nevertheless a complete type,
4316 false otherwise. The field for the contained declarator is left to
4317 be filled in by set_array_declarator_inner. */
4319 struct c_declarator *
4320 build_array_declarator (location_t loc,
4321 tree expr, struct c_declspecs *quals, bool static_p,
4324 struct c_declarator *declarator = XOBNEW (&parser_obstack,
4325 struct c_declarator);
4326 declarator->id_loc = loc;
4327 declarator->kind = cdk_array;
4328 declarator->declarator = 0;
4329 declarator->u.array.dimen = expr;
4332 declarator->u.array.attrs = quals->attrs;
4333 declarator->u.array.quals = quals_from_declspecs (quals);
4337 declarator->u.array.attrs = NULL_TREE;
4338 declarator->u.array.quals = 0;
4340 declarator->u.array.static_p = static_p;
4341 declarator->u.array.vla_unspec_p = vla_unspec_p;
4342 if (static_p || quals != NULL)
4343 pedwarn_c90 (loc, OPT_Wpedantic,
4344 "ISO C90 does not support %<static%> or type "
4345 "qualifiers in parameter array declarators");
4347 pedwarn_c90 (loc, OPT_Wpedantic,
4348 "ISO C90 does not support %<[*]%> array declarators");
4351 if (!current_scope->parm_flag)
4354 error_at (loc, "%<[*]%> not allowed in other than "
4355 "function prototype scope");
4356 declarator->u.array.vla_unspec_p = false;
4359 current_scope->had_vla_unspec = true;
4364 /* Set the contained declarator of an array declarator. DECL is the
4365 declarator, as constructed by build_array_declarator; INNER is what
4366 appears on the left of the []. */
4368 struct c_declarator *
4369 set_array_declarator_inner (struct c_declarator *decl,
4370 struct c_declarator *inner)
4372 decl->declarator = inner;
4376 /* INIT is a constructor that forms DECL's initializer. If the final
4377 element initializes a flexible array field, add the size of that
4378 initializer to DECL's size. */
4381 add_flexible_array_elts_to_size (tree decl, tree init)
4385 if (vec_safe_is_empty (CONSTRUCTOR_ELTS (init)))
4388 elt = CONSTRUCTOR_ELTS (init)->last ().value;
4389 type = TREE_TYPE (elt);
4390 if (TREE_CODE (type) == ARRAY_TYPE
4391 && TYPE_SIZE (type) == NULL_TREE
4392 && TYPE_DOMAIN (type) != NULL_TREE
4393 && TYPE_MAX_VALUE (TYPE_DOMAIN (type)) == NULL_TREE)
4395 complete_array_type (&type, elt, false);
4397 = size_binop (PLUS_EXPR, DECL_SIZE (decl), TYPE_SIZE (type));
4398 DECL_SIZE_UNIT (decl)
4399 = size_binop (PLUS_EXPR, DECL_SIZE_UNIT (decl), TYPE_SIZE_UNIT (type));
4403 /* Decode a "typename", such as "int **", returning a ..._TYPE node.
4404 Set *EXPR, if EXPR not NULL, to any expression to be evaluated
4405 before the type name, and set *EXPR_CONST_OPERANDS, if
4406 EXPR_CONST_OPERANDS not NULL, to indicate whether the type name may
4407 appear in a constant expression. */
4410 groktypename (struct c_type_name *type_name, tree *expr,
4411 bool *expr_const_operands)
4414 tree attrs = type_name->specs->attrs;
4416 type_name->specs->attrs = NULL_TREE;
4418 type = grokdeclarator (type_name->declarator, type_name->specs, TYPENAME,
4419 false, NULL, &attrs, expr, expr_const_operands,
4422 /* Apply attributes. */
4423 decl_attributes (&type, attrs, 0);
4428 /* Wrapper for decl_attributes that adds some implicit attributes
4429 to VAR_DECLs or FUNCTION_DECLs. */
4432 c_decl_attributes (tree *node, tree attributes, int flags)
4434 /* Add implicit "omp declare target" attribute if requested. */
4435 if (current_omp_declare_target_attribute
4436 && ((TREE_CODE (*node) == VAR_DECL
4437 && (TREE_STATIC (*node) || DECL_EXTERNAL (*node)))
4438 || TREE_CODE (*node) == FUNCTION_DECL))
4440 if (TREE_CODE (*node) == VAR_DECL
4441 && ((DECL_CONTEXT (*node)
4442 && TREE_CODE (DECL_CONTEXT (*node)) == FUNCTION_DECL)
4443 || (current_function_decl && !DECL_EXTERNAL (*node))))
4444 error ("%q+D in block scope inside of declare target directive",
4446 else if (TREE_CODE (*node) == VAR_DECL
4447 && !lang_hooks.types.omp_mappable_type (TREE_TYPE (*node)))
4448 error ("%q+D in declare target directive does not have mappable type",
4451 attributes = tree_cons (get_identifier ("omp declare target"),
4452 NULL_TREE, attributes);
4454 return decl_attributes (node, attributes, flags);
4458 /* Decode a declarator in an ordinary declaration or data definition.
4459 This is called as soon as the type information and variable name
4460 have been parsed, before parsing the initializer if any.
4461 Here we create the ..._DECL node, fill in its type,
4462 and put it on the list of decls for the current context.
4463 The ..._DECL node is returned as the value.
4465 Exception: for arrays where the length is not specified,
4466 the type is left null, to be filled in by `finish_decl'.
4468 Function definitions do not come here; they go to start_function
4469 instead. However, external and forward declarations of functions
4470 do go through here. Structure field declarations are done by
4471 grokfield and not through here. */
4474 start_decl (struct c_declarator *declarator, struct c_declspecs *declspecs,
4475 bool initialized, tree attributes)
4479 tree expr = NULL_TREE;
4480 enum deprecated_states deprecated_state = DEPRECATED_NORMAL;
4482 /* An object declared as __attribute__((deprecated)) suppresses
4483 warnings of uses of other deprecated items. */
4484 if (lookup_attribute ("deprecated", attributes))
4485 deprecated_state = DEPRECATED_SUPPRESS;
4487 decl = grokdeclarator (declarator, declspecs,
4488 NORMAL, initialized, NULL, &attributes, &expr, NULL,
4490 if (!decl || decl == error_mark_node)
4494 add_stmt (fold_convert (void_type_node, expr));
4496 if (TREE_CODE (decl) != FUNCTION_DECL && MAIN_NAME_P (DECL_NAME (decl)))
4497 warning (OPT_Wmain, "%q+D is usually a function", decl);
4500 /* Is it valid for this decl to have an initializer at all?
4501 If not, set INITIALIZED to zero, which will indirectly
4502 tell 'finish_decl' to ignore the initializer once it is parsed. */
4503 switch (TREE_CODE (decl))
4506 error ("typedef %qD is initialized (use __typeof__ instead)", decl);
4511 error ("function %qD is initialized like a variable", decl);
4516 /* DECL_INITIAL in a PARM_DECL is really DECL_ARG_TYPE. */
4517 error ("parameter %qD is initialized", decl);
4522 /* Don't allow initializations for incomplete types except for
4523 arrays which might be completed by the initialization. */
4525 /* This can happen if the array size is an undefined macro.
4526 We already gave a warning, so we don't need another one. */
4527 if (TREE_TYPE (decl) == error_mark_node)
4529 else if (COMPLETE_TYPE_P (TREE_TYPE (decl)))
4531 /* A complete type is ok if size is fixed. */
4533 if (TREE_CODE (TYPE_SIZE (TREE_TYPE (decl))) != INTEGER_CST
4534 || C_DECL_VARIABLE_SIZE (decl))
4536 error ("variable-sized object may not be initialized");
4540 else if (TREE_CODE (TREE_TYPE (decl)) != ARRAY_TYPE)
4542 error ("variable %qD has initializer but incomplete type", decl);
4545 else if (C_DECL_VARIABLE_SIZE (decl))
4547 /* Although C99 is unclear about whether incomplete arrays
4548 of VLAs themselves count as VLAs, it does not make
4549 sense to permit them to be initialized given that
4550 ordinary VLAs may not be initialized. */
4551 error ("variable-sized object may not be initialized");
4558 if (current_scope == file_scope)
4559 TREE_STATIC (decl) = 1;
4561 /* Tell 'pushdecl' this is an initialized decl
4562 even though we don't yet have the initializer expression.
4563 Also tell 'finish_decl' it may store the real initializer. */
4564 DECL_INITIAL (decl) = error_mark_node;
4567 /* If this is a function declaration, write a record describing it to the
4568 prototypes file (if requested). */
4570 if (TREE_CODE (decl) == FUNCTION_DECL)
4571 gen_aux_info_record (decl, 0, 0, prototype_p (TREE_TYPE (decl)));
4573 /* ANSI specifies that a tentative definition which is not merged with
4574 a non-tentative definition behaves exactly like a definition with an
4575 initializer equal to zero. (Section 3.7.2)
4577 -fno-common gives strict ANSI behavior, though this tends to break
4578 a large body of code that grew up without this rule.
4580 Thread-local variables are never common, since there's no entrenched
4581 body of code to break, and it allows more efficient variable references
4582 in the presence of dynamic linking. */
4584 if (TREE_CODE (decl) == VAR_DECL
4586 && TREE_PUBLIC (decl)
4587 && !DECL_THREAD_LOCAL_P (decl)
4589 DECL_COMMON (decl) = 1;
4591 /* Set attributes here so if duplicate decl, will have proper attributes. */
4592 c_decl_attributes (&decl, attributes, 0);
4594 /* Handle gnu_inline attribute. */
4595 if (declspecs->inline_p
4596 && !flag_gnu89_inline
4597 && TREE_CODE (decl) == FUNCTION_DECL
4598 && (lookup_attribute ("gnu_inline", DECL_ATTRIBUTES (decl))
4599 || current_function_decl))
4601 if (declspecs->storage_class == csc_auto && current_scope != file_scope)
4603 else if (declspecs->storage_class != csc_static)
4604 DECL_EXTERNAL (decl) = !DECL_EXTERNAL (decl);
4607 if (TREE_CODE (decl) == FUNCTION_DECL
4608 && targetm.calls.promote_prototypes (TREE_TYPE (decl)))
4610 struct c_declarator *ce = declarator;
4612 if (ce->kind == cdk_pointer)
4613 ce = declarator->declarator;
4614 if (ce->kind == cdk_function)
4616 tree args = ce->u.arg_info->parms;
4617 for (; args; args = DECL_CHAIN (args))
4619 tree type = TREE_TYPE (args);
4620 if (type && INTEGRAL_TYPE_P (type)
4621 && TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node))
4622 DECL_ARG_TYPE (args) = c_type_promotes_to (type);
4627 if (TREE_CODE (decl) == FUNCTION_DECL
4628 && DECL_DECLARED_INLINE_P (decl)
4629 && DECL_UNINLINABLE (decl)
4630 && lookup_attribute ("noinline", DECL_ATTRIBUTES (decl)))
4631 warning (OPT_Wattributes, "inline function %q+D given attribute noinline",
4634 /* C99 6.7.4p3: An inline definition of a function with external
4635 linkage shall not contain a definition of a modifiable object
4636 with static storage duration... */
4637 if (TREE_CODE (decl) == VAR_DECL
4638 && current_scope != file_scope
4639 && TREE_STATIC (decl)
4640 && !TREE_READONLY (decl)
4641 && DECL_DECLARED_INLINE_P (current_function_decl)
4642 && DECL_EXTERNAL (current_function_decl))
4643 record_inline_static (input_location, current_function_decl,
4644 decl, csi_modifiable);
4646 if (c_dialect_objc ()
4647 && (TREE_CODE (decl) == VAR_DECL
4648 || TREE_CODE (decl) == FUNCTION_DECL))
4649 objc_check_global_decl (decl);
4651 /* Add this decl to the current scope.
4652 TEM may equal DECL or it may be a previous decl of the same name. */
4653 tem = pushdecl (decl);
4655 if (initialized && DECL_EXTERNAL (tem))
4657 DECL_EXTERNAL (tem) = 0;
4658 TREE_STATIC (tem) = 1;
4664 /* Subroutine of finish_decl. TYPE is the type of an uninitialized object
4665 DECL or the non-array element type if DECL is an uninitialized array.
4666 If that type has a const member, diagnose this. */
4669 diagnose_uninitialized_cst_member (tree decl, tree type)
4672 for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
4675 if (TREE_CODE (field) != FIELD_DECL)
4677 field_type = strip_array_types (TREE_TYPE (field));
4679 if (TYPE_QUALS (field_type) & TYPE_QUAL_CONST)
4681 warning_at (DECL_SOURCE_LOCATION (decl), OPT_Wc___compat,
4682 "uninitialized const member in %qT is invalid in C++",
4683 strip_array_types (TREE_TYPE (decl)));
4684 inform (DECL_SOURCE_LOCATION (field), "%qD should be initialized", field);
4687 if (TREE_CODE (field_type) == RECORD_TYPE
4688 || TREE_CODE (field_type) == UNION_TYPE)
4689 diagnose_uninitialized_cst_member (decl, field_type);
4693 /* Finish processing of a declaration;
4694 install its initial value.
4695 If ORIGTYPE is not NULL_TREE, it is the original type of INIT.
4696 If the length of an array type is not known before,
4697 it must be determined now, from the initial value, or it is an error.
4699 INIT_LOC is the location of the initial value. */
4702 finish_decl (tree decl, location_t init_loc, tree init,
4703 tree origtype, tree asmspec_tree)
4706 bool was_incomplete = (DECL_SIZE (decl) == 0);
4707 const char *asmspec = 0;
4709 /* If a name was specified, get the string. */
4710 if ((TREE_CODE (decl) == FUNCTION_DECL || TREE_CODE (decl) == VAR_DECL)
4711 && DECL_FILE_SCOPE_P (decl))
4712 asmspec_tree = maybe_apply_renaming_pragma (decl, asmspec_tree);
4714 asmspec = TREE_STRING_POINTER (asmspec_tree);
4716 if (TREE_CODE (decl) == VAR_DECL
4717 && TREE_STATIC (decl)
4718 && global_bindings_p ())
4719 /* So decl is a global variable. Record the types it uses
4720 so that we can decide later to emit debug info for them. */
4721 record_types_used_by_current_var_decl (decl);
4723 /* If `start_decl' didn't like having an initialization, ignore it now. */
4724 if (init != 0 && DECL_INITIAL (decl) == 0)
4727 /* Don't crash if parm is initialized. */
4728 if (TREE_CODE (decl) == PARM_DECL)
4732 store_init_value (init_loc, decl, init, origtype);
4734 if (c_dialect_objc () && (TREE_CODE (decl) == VAR_DECL
4735 || TREE_CODE (decl) == FUNCTION_DECL
4736 || TREE_CODE (decl) == FIELD_DECL))
4737 objc_check_decl (decl);
4739 type = TREE_TYPE (decl);
4741 /* Deduce size of array from initialization, if not already known. */
4742 if (TREE_CODE (type) == ARRAY_TYPE
4743 && TYPE_DOMAIN (type) == 0
4744 && TREE_CODE (decl) != TYPE_DECL)
4747 = (TREE_STATIC (decl)
4748 /* Even if pedantic, an external linkage array
4749 may have incomplete type at first. */
4750 ? pedantic && !TREE_PUBLIC (decl)
4751 : !DECL_EXTERNAL (decl));
4753 = complete_array_type (&TREE_TYPE (decl), DECL_INITIAL (decl),
4756 /* Get the completed type made by complete_array_type. */
4757 type = TREE_TYPE (decl);
4762 error ("initializer fails to determine size of %q+D", decl);
4767 error ("array size missing in %q+D", decl);
4768 /* If a `static' var's size isn't known,
4769 make it extern as well as static, so it does not get
4771 If it is not `static', then do not mark extern;
4772 finish_incomplete_decl will give it a default size
4773 and it will get allocated. */
4774 else if (!pedantic && TREE_STATIC (decl) && !TREE_PUBLIC (decl))
4775 DECL_EXTERNAL (decl) = 1;
4779 error ("zero or negative size array %q+D", decl);
4783 /* For global variables, update the copy of the type that
4784 exists in the binding. */
4785 if (TREE_PUBLIC (decl))
4787 struct c_binding *b_ext = I_SYMBOL_BINDING (DECL_NAME (decl));
4788 while (b_ext && !B_IN_EXTERNAL_SCOPE (b_ext))
4789 b_ext = b_ext->shadowed;
4792 if (b_ext->u.type && comptypes (b_ext->u.type, type))
4793 b_ext->u.type = composite_type (b_ext->u.type, type);
4795 b_ext->u.type = type;
4804 if (DECL_INITIAL (decl))
4805 TREE_TYPE (DECL_INITIAL (decl)) = type;
4807 relayout_decl (decl);
4810 if (TREE_CODE (decl) == VAR_DECL)
4812 if (init && TREE_CODE (init) == CONSTRUCTOR)
4813 add_flexible_array_elts_to_size (decl, init);
4815 if (DECL_SIZE (decl) == 0 && TREE_TYPE (decl) != error_mark_node
4816 && COMPLETE_TYPE_P (TREE_TYPE (decl)))
4817 layout_decl (decl, 0);
4819 if (DECL_SIZE (decl) == 0
4820 /* Don't give an error if we already gave one earlier. */
4821 && TREE_TYPE (decl) != error_mark_node
4822 && (TREE_STATIC (decl)
4823 /* A static variable with an incomplete type
4824 is an error if it is initialized.
4825 Also if it is not file scope.
4826 Otherwise, let it through, but if it is not `extern'
4827 then it may cause an error message later. */
4828 ? (DECL_INITIAL (decl) != 0
4829 || !DECL_FILE_SCOPE_P (decl))
4830 /* An automatic variable with an incomplete type
4832 : !DECL_EXTERNAL (decl)))
4834 error ("storage size of %q+D isn%'t known", decl);
4835 TREE_TYPE (decl) = error_mark_node;
4838 if ((DECL_EXTERNAL (decl) || TREE_STATIC (decl))
4839 && DECL_SIZE (decl) != 0)
4841 if (TREE_CODE (DECL_SIZE (decl)) == INTEGER_CST)
4842 constant_expression_warning (DECL_SIZE (decl));
4845 error ("storage size of %q+D isn%'t constant", decl);
4846 TREE_TYPE (decl) = error_mark_node;
4850 if (TREE_USED (type))
4852 TREE_USED (decl) = 1;
4853 DECL_READ_P (decl) = 1;
4857 /* If this is a function and an assembler name is specified, reset DECL_RTL
4858 so we can give it its new name. Also, update builtin_decl if it
4859 was a normal built-in. */
4860 if (TREE_CODE (decl) == FUNCTION_DECL && asmspec)
4862 if (DECL_BUILT_IN_CLASS (decl) == BUILT_IN_NORMAL)
4863 set_builtin_user_assembler_name (decl, asmspec);
4864 set_user_assembler_name (decl, asmspec);
4867 /* If #pragma weak was used, mark the decl weak now. */
4868 maybe_apply_pragma_weak (decl);
4870 /* Output the assembler code and/or RTL code for variables and functions,
4871 unless the type is an undefined structure or union.
4872 If not, it will get done when the type is completed. */
4874 if (TREE_CODE (decl) == VAR_DECL || TREE_CODE (decl) == FUNCTION_DECL)
4876 /* Determine the ELF visibility. */
4877 if (TREE_PUBLIC (decl))
4878 c_determine_visibility (decl);
4880 /* This is a no-op in c-lang.c or something real in objc-act.c. */
4881 if (c_dialect_objc ())
4882 objc_check_decl (decl);
4886 /* If this is not a static variable, issue a warning.
4887 It doesn't make any sense to give an ASMSPEC for an
4888 ordinary, non-register local variable. Historically,
4889 GCC has accepted -- but ignored -- the ASMSPEC in
4891 if (!DECL_FILE_SCOPE_P (decl)
4892 && TREE_CODE (decl) == VAR_DECL
4893 && !C_DECL_REGISTER (decl)
4894 && !TREE_STATIC (decl))
4895 warning (0, "ignoring asm-specifier for non-static local "
4896 "variable %q+D", decl);
4898 set_user_assembler_name (decl, asmspec);
4901 if (DECL_FILE_SCOPE_P (decl))
4903 if (DECL_INITIAL (decl) == NULL_TREE
4904 || DECL_INITIAL (decl) == error_mark_node)
4905 /* Don't output anything
4906 when a tentative file-scope definition is seen.
4907 But at end of compilation, do output code for them. */
4908 DECL_DEFER_OUTPUT (decl) = 1;
4909 if (asmspec && C_DECL_REGISTER (decl))
4910 DECL_HARD_REGISTER (decl) = 1;
4911 rest_of_decl_compilation (decl, true, 0);
4915 /* In conjunction with an ASMSPEC, the `register'
4916 keyword indicates that we should place the variable
4917 in a particular register. */
4918 if (asmspec && C_DECL_REGISTER (decl))
4920 DECL_HARD_REGISTER (decl) = 1;
4921 /* This cannot be done for a structure with volatile
4922 fields, on which DECL_REGISTER will have been
4924 if (!DECL_REGISTER (decl))
4925 error ("cannot put object with volatile field into register");
4928 if (TREE_CODE (decl) != FUNCTION_DECL)
4930 /* If we're building a variable sized type, and we might be
4931 reachable other than via the top of the current binding
4932 level, then create a new BIND_EXPR so that we deallocate
4933 the object at the right time. */
4934 /* Note that DECL_SIZE can be null due to errors. */
4935 if (DECL_SIZE (decl)
4936 && !TREE_CONSTANT (DECL_SIZE (decl))
4937 && STATEMENT_LIST_HAS_LABEL (cur_stmt_list))
4940 bind = build3 (BIND_EXPR, void_type_node, NULL, NULL, NULL);
4941 TREE_SIDE_EFFECTS (bind) = 1;
4943 BIND_EXPR_BODY (bind) = push_stmt_list ();
4945 add_stmt (build_stmt (DECL_SOURCE_LOCATION (decl),
4951 if (!DECL_FILE_SCOPE_P (decl))
4953 /* Recompute the RTL of a local array now
4954 if it used to be an incomplete type. */
4956 && !TREE_STATIC (decl) && !DECL_EXTERNAL (decl))
4958 /* If we used it already as memory, it must stay in memory. */
4959 TREE_ADDRESSABLE (decl) = TREE_USED (decl);
4960 /* If it's still incomplete now, no init will save it. */
4961 if (DECL_SIZE (decl) == 0)
4962 DECL_INITIAL (decl) = 0;
4967 if (TREE_CODE (decl) == TYPE_DECL)
4969 if (!DECL_FILE_SCOPE_P (decl)
4970 && variably_modified_type_p (TREE_TYPE (decl), NULL_TREE))
4971 add_stmt (build_stmt (DECL_SOURCE_LOCATION (decl), DECL_EXPR, decl));
4973 rest_of_decl_compilation (decl, DECL_FILE_SCOPE_P (decl), 0);
4976 /* Install a cleanup (aka destructor) if one was given. */
4977 if (TREE_CODE (decl) == VAR_DECL && !TREE_STATIC (decl))
4979 tree attr = lookup_attribute ("cleanup", DECL_ATTRIBUTES (decl));
4982 tree cleanup_id = TREE_VALUE (TREE_VALUE (attr));
4983 tree cleanup_decl = lookup_name (cleanup_id);
4985 vec<tree, va_gc> *v;
4987 /* Build "cleanup(&decl)" for the destructor. */
4988 cleanup = build_unary_op (input_location, ADDR_EXPR, decl, 0);
4990 v->quick_push (cleanup);
4991 cleanup = c_build_function_call_vec (DECL_SOURCE_LOCATION (decl),
4992 vNULL, cleanup_decl, v, NULL);
4995 /* Don't warn about decl unused; the cleanup uses it. */
4996 TREE_USED (decl) = 1;
4997 TREE_USED (cleanup_decl) = 1;
4998 DECL_READ_P (decl) = 1;
5000 push_cleanup (decl, cleanup, false);
5005 && TREE_CODE (decl) == VAR_DECL
5006 && !DECL_EXTERNAL (decl)
5007 && DECL_INITIAL (decl) == NULL_TREE)
5009 type = strip_array_types (type);
5010 if (TREE_READONLY (decl))
5011 warning_at (DECL_SOURCE_LOCATION (decl), OPT_Wc___compat,
5012 "uninitialized const %qD is invalid in C++", decl);
5013 else if ((TREE_CODE (type) == RECORD_TYPE
5014 || TREE_CODE (type) == UNION_TYPE)
5015 && C_TYPE_FIELDS_READONLY (type))
5016 diagnose_uninitialized_cst_member (decl, type);
5019 invoke_plugin_callbacks (PLUGIN_FINISH_DECL, decl);
5022 /* Given a parsed parameter declaration, decode it into a PARM_DECL.
5023 EXPR is NULL or a pointer to an expression that needs to be
5024 evaluated for the side effects of array size expressions in the
5028 grokparm (const struct c_parm *parm, tree *expr)
5030 tree attrs = parm->attrs;
5031 tree decl = grokdeclarator (parm->declarator, parm->specs, PARM, false,
5032 NULL, &attrs, expr, NULL, DEPRECATED_NORMAL);
5034 decl_attributes (&decl, attrs, 0);
5039 /* Given a parsed parameter declaration, decode it into a PARM_DECL
5040 and push that on the current scope. EXPR is a pointer to an
5041 expression that needs to be evaluated for the side effects of array
5042 size expressions in the parameters. */
5045 push_parm_decl (const struct c_parm *parm, tree *expr)
5047 tree attrs = parm->attrs;
5050 decl = grokdeclarator (parm->declarator, parm->specs, PARM, false, NULL,
5051 &attrs, expr, NULL, DEPRECATED_NORMAL);
5052 decl_attributes (&decl, attrs, 0);
5054 decl = pushdecl (decl);
5056 finish_decl (decl, input_location, NULL_TREE, NULL_TREE, NULL_TREE);
5059 /* Mark all the parameter declarations to date as forward decls.
5060 Also diagnose use of this extension. */
5063 mark_forward_parm_decls (void)
5065 struct c_binding *b;
5067 if (pedantic && !current_scope->warned_forward_parm_decls)
5069 pedwarn (input_location, OPT_Wpedantic,
5070 "ISO C forbids forward parameter declarations");
5071 current_scope->warned_forward_parm_decls = true;
5074 for (b = current_scope->bindings; b; b = b->prev)
5075 if (TREE_CODE (b->decl) == PARM_DECL)
5076 TREE_ASM_WRITTEN (b->decl) = 1;
5079 /* Build a COMPOUND_LITERAL_EXPR. TYPE is the type given in the compound
5080 literal, which may be an incomplete array type completed by the
5081 initializer; INIT is a CONSTRUCTOR at LOC that initializes the compound
5082 literal. NON_CONST is true if the initializers contain something
5083 that cannot occur in a constant expression. */
5086 build_compound_literal (location_t loc, tree type, tree init, bool non_const)
5088 /* We do not use start_decl here because we have a type, not a declarator;
5089 and do not use finish_decl because the decl should be stored inside
5090 the COMPOUND_LITERAL_EXPR rather than added elsewhere as a DECL_EXPR. */
5095 if (type == error_mark_node
5096 || init == error_mark_node)
5097 return error_mark_node;
5099 decl = build_decl (loc, VAR_DECL, NULL_TREE, type);
5100 DECL_EXTERNAL (decl) = 0;
5101 TREE_PUBLIC (decl) = 0;
5102 TREE_STATIC (decl) = (current_scope == file_scope);
5103 DECL_CONTEXT (decl) = current_function_decl;
5104 TREE_USED (decl) = 1;
5105 DECL_READ_P (decl) = 1;
5106 TREE_TYPE (decl) = type;
5107 TREE_READONLY (decl) = (TYPE_READONLY (type)
5108 || (TREE_CODE (type) == ARRAY_TYPE
5109 && TYPE_READONLY (TREE_TYPE (type))));
5110 store_init_value (loc, decl, init, NULL_TREE);
5112 if (TREE_CODE (type) == ARRAY_TYPE && !COMPLETE_TYPE_P (type))
5114 int failure = complete_array_type (&TREE_TYPE (decl),
5115 DECL_INITIAL (decl), true);
5116 /* If complete_array_type returns 3, it means that the
5117 initial value of the compound literal is empty. Allow it. */
5118 gcc_assert (failure == 0 || failure == 3);
5120 type = TREE_TYPE (decl);
5121 TREE_TYPE (DECL_INITIAL (decl)) = type;
5124 if (type == error_mark_node || !COMPLETE_TYPE_P (type))
5126 c_incomplete_type_error (NULL_TREE, type);
5127 return error_mark_node;
5130 stmt = build_stmt (DECL_SOURCE_LOCATION (decl), DECL_EXPR, decl);
5131 complit = build1 (COMPOUND_LITERAL_EXPR, type, stmt);
5132 TREE_SIDE_EFFECTS (complit) = 1;
5134 layout_decl (decl, 0);
5136 if (TREE_STATIC (decl))
5138 /* This decl needs a name for the assembler output. */
5139 set_compound_literal_name (decl);
5140 DECL_DEFER_OUTPUT (decl) = 1;
5141 DECL_COMDAT (decl) = 1;
5142 DECL_ARTIFICIAL (decl) = 1;
5143 DECL_IGNORED_P (decl) = 1;
5145 rest_of_decl_compilation (decl, 1, 0);
5150 complit = build2 (C_MAYBE_CONST_EXPR, type, NULL, complit);
5151 C_MAYBE_CONST_EXPR_NON_CONST (complit) = 1;
5157 /* Check the type of a compound literal. Here we just check that it
5158 is valid for C++. */
5161 check_compound_literal_type (location_t loc, struct c_type_name *type_name)
5164 && (type_name->specs->typespec_kind == ctsk_tagdef
5165 || type_name->specs->typespec_kind == ctsk_tagfirstref))
5166 warning_at (loc, OPT_Wc___compat,
5167 "defining a type in a compound literal is invalid in C++");
5170 /* Determine whether TYPE is a structure with a flexible array member,
5171 or a union containing such a structure (possibly recursively). */
5174 flexible_array_type_p (tree type)
5177 switch (TREE_CODE (type))
5180 x = TYPE_FIELDS (type);
5183 while (DECL_CHAIN (x) != NULL_TREE)
5185 if (TREE_CODE (TREE_TYPE (x)) == ARRAY_TYPE
5186 && TYPE_SIZE (TREE_TYPE (x)) == NULL_TREE
5187 && TYPE_DOMAIN (TREE_TYPE (x)) != NULL_TREE
5188 && TYPE_MAX_VALUE (TYPE_DOMAIN (TREE_TYPE (x))) == NULL_TREE)
5192 for (x = TYPE_FIELDS (type); x != NULL_TREE; x = DECL_CHAIN (x))
5194 if (flexible_array_type_p (TREE_TYPE (x)))
5203 /* Performs sanity checks on the TYPE and WIDTH of the bit-field NAME,
5204 replacing with appropriate values if they are invalid. */
5206 check_bitfield_type_and_width (tree *type, tree *width, tree orig_name)
5209 unsigned int max_width;
5210 unsigned HOST_WIDE_INT w;
5211 const char *name = (orig_name
5212 ? identifier_to_locale (IDENTIFIER_POINTER (orig_name))
5213 : _("<anonymous>"));
5215 /* Detect and ignore out of range field width and process valid
5217 if (!INTEGRAL_TYPE_P (TREE_TYPE (*width)))
5219 error ("bit-field %qs width not an integer constant", name);
5220 *width = integer_one_node;
5224 if (TREE_CODE (*width) != INTEGER_CST)
5226 *width = c_fully_fold (*width, false, NULL);
5227 if (TREE_CODE (*width) == INTEGER_CST)
5228 pedwarn (input_location, OPT_Wpedantic,
5229 "bit-field %qs width not an integer constant expression",
5232 if (TREE_CODE (*width) != INTEGER_CST)
5234 error ("bit-field %qs width not an integer constant", name);
5235 *width = integer_one_node;
5237 constant_expression_warning (*width);
5238 if (tree_int_cst_sgn (*width) < 0)
5240 error ("negative width in bit-field %qs", name);
5241 *width = integer_one_node;
5243 else if (integer_zerop (*width) && orig_name)
5245 error ("zero width for bit-field %qs", name);
5246 *width = integer_one_node;
5250 /* Detect invalid bit-field type. */
5251 if (TREE_CODE (*type) != INTEGER_TYPE
5252 && TREE_CODE (*type) != BOOLEAN_TYPE
5253 && TREE_CODE (*type) != ENUMERAL_TYPE)
5255 error ("bit-field %qs has invalid type", name);
5256 *type = unsigned_type_node;
5259 type_mv = TYPE_MAIN_VARIANT (*type);
5260 if (!in_system_header_at (input_location)
5261 && type_mv != integer_type_node
5262 && type_mv != unsigned_type_node
5263 && type_mv != boolean_type_node)
5264 pedwarn_c90 (input_location, OPT_Wpedantic,
5265 "type of bit-field %qs is a GCC extension", name);
5267 max_width = TYPE_PRECISION (*type);
5269 if (0 < compare_tree_int (*width, max_width))
5271 error ("width of %qs exceeds its type", name);
5273 *width = build_int_cst (integer_type_node, w);
5276 w = tree_to_uhwi (*width);
5278 if (TREE_CODE (*type) == ENUMERAL_TYPE)
5280 struct lang_type *lt = TYPE_LANG_SPECIFIC (*type);
5282 || w < tree_int_cst_min_precision (lt->enum_min, TYPE_SIGN (*type))
5283 || w < tree_int_cst_min_precision (lt->enum_max, TYPE_SIGN (*type)))
5284 warning (0, "%qs is narrower than values of its type", name);
5290 /* Print warning about variable length array if necessary. */
5293 warn_variable_length_array (tree name, tree size)
5295 if (TREE_CONSTANT (size))
5298 pedwarn_c90 (input_location, OPT_Wvla,
5299 "ISO C90 forbids array %qE whose size "
5300 "can%'t be evaluated", name);
5302 pedwarn_c90 (input_location, OPT_Wvla, "ISO C90 forbids array "
5303 "whose size can%'t be evaluated");
5308 pedwarn_c90 (input_location, OPT_Wvla,
5309 "ISO C90 forbids variable length array %qE", name);
5311 pedwarn_c90 (input_location, OPT_Wvla, "ISO C90 forbids variable "
5316 /* Print warning about defaulting to int if necessary. */
5319 warn_defaults_to (location_t location, int opt, const char *gmsgid, ...)
5321 diagnostic_info diagnostic;
5324 va_start (ap, gmsgid);
5325 diagnostic_set_info (&diagnostic, gmsgid, &ap, location,
5326 flag_isoc99 ? DK_PEDWARN : DK_WARNING);
5327 diagnostic.option_index = opt;
5328 report_diagnostic (&diagnostic);
5332 /* Given declspecs and a declarator,
5333 determine the name and type of the object declared
5334 and construct a ..._DECL node for it.
5335 (In one case we can return a ..._TYPE node instead.
5336 For invalid input we sometimes return 0.)
5338 DECLSPECS is a c_declspecs structure for the declaration specifiers.
5340 DECL_CONTEXT says which syntactic context this declaration is in:
5341 NORMAL for most contexts. Make a VAR_DECL or FUNCTION_DECL or TYPE_DECL.
5342 FUNCDEF for a function definition. Like NORMAL but a few different
5343 error messages in each case. Return value may be zero meaning
5344 this definition is too screwy to try to parse.
5345 PARM for a parameter declaration (either within a function prototype
5346 or before a function body). Make a PARM_DECL, or return void_type_node.
5347 TYPENAME if for a typename (in a cast or sizeof).
5348 Don't make a DECL node; just return the ..._TYPE node.
5349 FIELD for a struct or union field; make a FIELD_DECL.
5350 INITIALIZED is true if the decl has an initializer.
5351 WIDTH is non-NULL for bit-fields, and is a pointer to an INTEGER_CST node
5352 representing the width of the bit-field.
5353 DECL_ATTRS points to the list of attributes that should be added to this
5354 decl. Any nested attributes that belong on the decl itself will be
5356 If EXPR is not NULL, any expressions that need to be evaluated as
5357 part of evaluating variably modified types will be stored in *EXPR.
5358 If EXPR_CONST_OPERANDS is not NULL, *EXPR_CONST_OPERANDS will be
5359 set to indicate whether operands in *EXPR can be used in constant
5361 DEPRECATED_STATE is a deprecated_states value indicating whether
5362 deprecation warnings should be suppressed.
5364 In the TYPENAME case, DECLARATOR is really an absolute declarator.
5365 It may also be so in the PARM case, for a prototype where the
5366 argument type is specified but not the name.
5368 This function is where the complicated C meanings of `static'
5369 and `extern' are interpreted. */
5372 grokdeclarator (const struct c_declarator *declarator,
5373 struct c_declspecs *declspecs,
5374 enum decl_context decl_context, bool initialized, tree *width,
5375 tree *decl_attrs, tree *expr, bool *expr_const_operands,
5376 enum deprecated_states deprecated_state)
5378 tree type = declspecs->type;
5379 bool threadp = declspecs->thread_p;
5380 enum c_storage_class storage_class = declspecs->storage_class;
5385 int type_quals = TYPE_UNQUALIFIED;
5386 tree name = NULL_TREE;
5387 bool funcdef_flag = false;
5388 bool funcdef_syntax = false;
5389 bool size_varies = false;
5390 tree decl_attr = declspecs->decl_attr;
5391 int array_ptr_quals = TYPE_UNQUALIFIED;
5392 tree array_ptr_attrs = NULL_TREE;
5393 int array_parm_static = 0;
5394 bool array_parm_vla_unspec_p = false;
5395 tree returned_attrs = NULL_TREE;
5396 bool bitfield = width != NULL;
5398 tree orig_qual_type = NULL;
5399 size_t orig_qual_indirect = 0;
5400 struct c_arg_info *arg_info = 0;
5401 addr_space_t as1, as2, address_space;
5402 location_t loc = UNKNOWN_LOCATION;
5405 bool expr_const_operands_dummy;
5406 enum c_declarator_kind first_non_attr_kind;
5407 unsigned int alignas_align = 0;
5409 if (TREE_CODE (type) == ERROR_MARK)
5410 return error_mark_node;
5413 if (expr_const_operands == NULL)
5414 expr_const_operands = &expr_const_operands_dummy;
5416 *expr = declspecs->expr;
5417 *expr_const_operands = declspecs->expr_const_operands;
5419 if (decl_context == FUNCDEF)
5420 funcdef_flag = true, decl_context = NORMAL;
5422 /* Look inside a declarator for the name being declared
5423 and get it as an IDENTIFIER_NODE, for an error message. */
5425 const struct c_declarator *decl = declarator;
5427 first_non_attr_kind = cdk_attrs;
5437 funcdef_syntax = (decl->kind == cdk_function);
5438 if (first_non_attr_kind == cdk_attrs)
5439 first_non_attr_kind = decl->kind;
5440 decl = decl->declarator;
5444 decl = decl->declarator;
5451 if (first_non_attr_kind == cdk_attrs)
5452 first_non_attr_kind = decl->kind;
5461 gcc_assert (decl_context == PARM
5462 || decl_context == TYPENAME
5463 || (decl_context == FIELD
5464 && declarator->kind == cdk_id));
5465 gcc_assert (!initialized);
5469 /* A function definition's declarator must have the form of
5470 a function declarator. */
5472 if (funcdef_flag && !funcdef_syntax)
5475 /* If this looks like a function definition, make it one,
5476 even if it occurs where parms are expected.
5477 Then store_parm_decls will reject it and not use it as a parm. */
5478 if (decl_context == NORMAL && !funcdef_flag && current_scope->parm_flag)
5479 decl_context = PARM;
5481 if (declspecs->deprecated_p && deprecated_state != DEPRECATED_SUPPRESS)
5482 warn_deprecated_use (declspecs->type, declspecs->decl_attr);
5484 if ((decl_context == NORMAL || decl_context == FIELD)
5485 && current_scope == file_scope
5486 && variably_modified_type_p (type, NULL_TREE))
5489 error_at (loc, "variably modified %qE at file scope", name);
5491 error_at (loc, "variably modified field at file scope");
5492 type = integer_type_node;
5495 size_varies = C_TYPE_VARIABLE_SIZE (type) != 0;
5497 /* Diagnose defaulting to "int". */
5499 if (declspecs->default_int_p && !in_system_header_at (input_location))
5501 /* Issue a warning if this is an ISO C 99 program or if
5502 -Wreturn-type and this is a function, or if -Wimplicit;
5503 prefer the former warning since it is more explicit. */
5504 if ((warn_implicit_int || warn_return_type || flag_isoc99)
5506 warn_about_return_type = 1;
5510 warn_defaults_to (loc, OPT_Wimplicit_int,
5511 "type defaults to %<int%> in declaration "
5514 warn_defaults_to (loc, OPT_Wimplicit_int,
5515 "type defaults to %<int%> in type name");
5519 /* Adjust the type if a bit-field is being declared,
5520 -funsigned-bitfields applied and the type is not explicitly
5522 if (bitfield && !flag_signed_bitfields && !declspecs->explicit_signed_p
5523 && TREE_CODE (type) == INTEGER_TYPE)
5524 type = unsigned_type_for (type);
5526 /* Figure out the type qualifiers for the declaration. There are
5527 two ways a declaration can become qualified. One is something
5528 like `const int i' where the `const' is explicit. Another is
5529 something like `typedef const int CI; CI i' where the type of the
5530 declaration contains the `const'. A third possibility is that
5531 there is a type qualifier on the element type of a typedefed
5532 array type, in which case we should extract that qualifier so
5533 that c_apply_type_quals_to_decl receives the full list of
5534 qualifiers to work with (C90 is not entirely clear about whether
5535 duplicate qualifiers should be diagnosed in this case, but it
5536 seems most appropriate to do so). */
5537 element_type = strip_array_types (type);
5538 constp = declspecs->const_p + TYPE_READONLY (element_type);
5539 restrictp = declspecs->restrict_p + TYPE_RESTRICT (element_type);
5540 volatilep = declspecs->volatile_p + TYPE_VOLATILE (element_type);
5541 atomicp = declspecs->atomic_p + TYPE_ATOMIC (element_type);
5542 as1 = declspecs->address_space;
5543 as2 = TYPE_ADDR_SPACE (element_type);
5544 address_space = ADDR_SPACE_GENERIC_P (as1)? as2 : as1;
5547 pedwarn_c90 (loc, OPT_Wpedantic, "duplicate %<const%>");
5549 pedwarn_c90 (loc, OPT_Wpedantic, "duplicate %<restrict%>");
5551 pedwarn_c90 (loc, OPT_Wpedantic, "duplicate %<volatile%>");
5553 pedwarn_c90 (loc, OPT_Wpedantic, "duplicate %<_Atomic%>");
5555 if (!ADDR_SPACE_GENERIC_P (as1) && !ADDR_SPACE_GENERIC_P (as2) && as1 != as2)
5556 error_at (loc, "conflicting named address spaces (%s vs %s)",
5557 c_addr_space_name (as1), c_addr_space_name (as2));
5559 if ((TREE_CODE (type) == ARRAY_TYPE
5560 || first_non_attr_kind == cdk_array)
5561 && TYPE_QUALS (element_type))
5563 orig_qual_type = type;
5564 type = TYPE_MAIN_VARIANT (type);
5566 type_quals = ((constp ? TYPE_QUAL_CONST : 0)
5567 | (restrictp ? TYPE_QUAL_RESTRICT : 0)
5568 | (volatilep ? TYPE_QUAL_VOLATILE : 0)
5569 | (atomicp ? TYPE_QUAL_ATOMIC : 0)
5570 | ENCODE_QUAL_ADDR_SPACE (address_space));
5571 if (type_quals != TYPE_QUALS (element_type))
5572 orig_qual_type = NULL_TREE;
5574 /* Applying the _Atomic qualifier to an array type (through the use
5575 of typedefs or typeof) must be detected here. If the qualifier
5576 is introduced later, any appearance of applying it to an array is
5577 actually applying it to an element of that array. */
5578 if (atomicp && TREE_CODE (type) == ARRAY_TYPE)
5579 error_at (loc, "%<_Atomic%>-qualified array type");
5581 /* Warn about storage classes that are invalid for certain
5582 kinds of declarations (parameters, typenames, etc.). */
5586 || storage_class == csc_auto
5587 || storage_class == csc_register
5588 || storage_class == csc_typedef))
5590 if (storage_class == csc_auto)
5592 (current_scope == file_scope) ? 0 : OPT_Wpedantic,
5593 "function definition declared %<auto%>");
5594 if (storage_class == csc_register)
5595 error_at (loc, "function definition declared %<register%>");
5596 if (storage_class == csc_typedef)
5597 error_at (loc, "function definition declared %<typedef%>");
5599 error_at (loc, "function definition declared %qs",
5600 declspecs->thread_gnu_p ? "__thread" : "_Thread_local");
5602 if (storage_class == csc_auto
5603 || storage_class == csc_register
5604 || storage_class == csc_typedef)
5605 storage_class = csc_none;
5607 else if (decl_context != NORMAL && (storage_class != csc_none || threadp))
5609 if (decl_context == PARM && storage_class == csc_register)
5613 switch (decl_context)
5617 error_at (loc, "storage class specified for structure "
5620 error_at (loc, "storage class specified for structure field");
5624 error_at (loc, "storage class specified for parameter %qE",
5627 error_at (loc, "storage class specified for unnamed parameter");
5630 error_at (loc, "storage class specified for typename");
5633 storage_class = csc_none;
5637 else if (storage_class == csc_extern
5641 /* 'extern' with initialization is invalid if not at file scope. */
5642 if (current_scope == file_scope)
5644 /* It is fine to have 'extern const' when compiling at C
5645 and C++ intersection. */
5646 if (!(warn_cxx_compat && constp))
5647 warning_at (loc, 0, "%qE initialized and declared %<extern%>",
5651 error_at (loc, "%qE has both %<extern%> and initializer", name);
5653 else if (current_scope == file_scope)
5655 if (storage_class == csc_auto)
5656 error_at (loc, "file-scope declaration of %qE specifies %<auto%>",
5658 if (pedantic && storage_class == csc_register)
5659 pedwarn (input_location, OPT_Wpedantic,
5660 "file-scope declaration of %qE specifies %<register%>", name);
5664 if (storage_class == csc_extern && funcdef_flag)
5665 error_at (loc, "nested function %qE declared %<extern%>", name);
5666 else if (threadp && storage_class == csc_none)
5668 error_at (loc, "function-scope %qE implicitly auto and declared "
5670 declspecs->thread_gnu_p ? "__thread" : "_Thread_local");
5675 /* Now figure out the structure of the declarator proper.
5676 Descend through it, creating more complex types, until we reach
5677 the declared identifier (or NULL_TREE, in an absolute declarator).
5678 At each stage we maintain an unqualified version of the type
5679 together with any qualifiers that should be applied to it with
5680 c_build_qualified_type; this way, array types including
5681 multidimensional array types are first built up in unqualified
5682 form and then the qualified form is created with
5683 TYPE_MAIN_VARIANT pointing to the unqualified form. */
5685 while (declarator && declarator->kind != cdk_id)
5687 if (type == error_mark_node)
5689 declarator = declarator->declarator;
5693 /* Each level of DECLARATOR is either a cdk_array (for ...[..]),
5694 a cdk_pointer (for *...),
5695 a cdk_function (for ...(...)),
5696 a cdk_attrs (for nested attributes),
5697 or a cdk_id (for the name being declared
5698 or the place in an absolute declarator
5699 where the name was omitted).
5700 For the last case, we have just exited the loop.
5702 At this point, TYPE is the type of elements of an array,
5703 or for a function to return, or for a pointer to point to.
5704 After this sequence of ifs, TYPE is the type of the
5705 array or function or pointer, and DECLARATOR has had its
5706 outermost layer removed. */
5708 if (array_ptr_quals != TYPE_UNQUALIFIED
5709 || array_ptr_attrs != NULL_TREE
5710 || array_parm_static)
5712 /* Only the innermost declarator (making a parameter be of
5713 array type which is converted to pointer type)
5714 may have static or type qualifiers. */
5715 error_at (loc, "static or type qualifiers in non-parameter array declarator");
5716 array_ptr_quals = TYPE_UNQUALIFIED;
5717 array_ptr_attrs = NULL_TREE;
5718 array_parm_static = 0;
5721 switch (declarator->kind)
5725 /* A declarator with embedded attributes. */
5726 tree attrs = declarator->u.attrs;
5727 const struct c_declarator *inner_decl;
5729 declarator = declarator->declarator;
5730 inner_decl = declarator;
5731 while (inner_decl->kind == cdk_attrs)
5732 inner_decl = inner_decl->declarator;
5733 if (inner_decl->kind == cdk_id)
5734 attr_flags |= (int) ATTR_FLAG_DECL_NEXT;
5735 else if (inner_decl->kind == cdk_function)
5736 attr_flags |= (int) ATTR_FLAG_FUNCTION_NEXT;
5737 else if (inner_decl->kind == cdk_array)
5738 attr_flags |= (int) ATTR_FLAG_ARRAY_NEXT;
5739 returned_attrs = decl_attributes (&type,
5740 chainon (returned_attrs, attrs),
5746 tree itype = NULL_TREE;
5747 tree size = declarator->u.array.dimen;
5748 /* The index is a signed object `sizetype' bits wide. */
5749 tree index_type = c_common_signed_type (sizetype);
5751 array_ptr_quals = declarator->u.array.quals;
5752 array_ptr_attrs = declarator->u.array.attrs;
5753 array_parm_static = declarator->u.array.static_p;
5754 array_parm_vla_unspec_p = declarator->u.array.vla_unspec_p;
5756 declarator = declarator->declarator;
5758 /* Check for some types that there cannot be arrays of. */
5760 if (VOID_TYPE_P (type))
5763 error_at (loc, "declaration of %qE as array of voids", name);
5765 error_at (loc, "declaration of type name as array of voids");
5766 type = error_mark_node;
5769 if (TREE_CODE (type) == FUNCTION_TYPE)
5772 error_at (loc, "declaration of %qE as array of functions",
5775 error_at (loc, "declaration of type name as array of "
5777 type = error_mark_node;
5780 if (pedantic && !in_system_header_at (input_location)
5781 && flexible_array_type_p (type))
5782 pedwarn (loc, OPT_Wpedantic,
5783 "invalid use of structure with flexible array member");
5785 if (size == error_mark_node)
5786 type = error_mark_node;
5788 if (type == error_mark_node)
5791 /* If size was specified, set ITYPE to a range-type for
5792 that size. Otherwise, ITYPE remains null. finish_decl
5793 may figure it out from an initial value. */
5797 bool size_maybe_const = true;
5798 bool size_int_const = (TREE_CODE (size) == INTEGER_CST
5799 && !TREE_OVERFLOW (size));
5800 bool this_size_varies = false;
5802 /* Strip NON_LVALUE_EXPRs since we aren't using as an
5804 STRIP_TYPE_NOPS (size);
5806 if (!INTEGRAL_TYPE_P (TREE_TYPE (size)))
5809 error_at (loc, "size of array %qE has non-integer type",
5813 "size of unnamed array has non-integer type");
5814 size = integer_one_node;
5817 size = c_fully_fold (size, false, &size_maybe_const);
5819 if (pedantic && size_maybe_const && integer_zerop (size))
5822 pedwarn (loc, OPT_Wpedantic,
5823 "ISO C forbids zero-size array %qE", name);
5825 pedwarn (loc, OPT_Wpedantic,
5826 "ISO C forbids zero-size array");
5829 if (TREE_CODE (size) == INTEGER_CST && size_maybe_const)
5831 constant_expression_warning (size);
5832 if (tree_int_cst_sgn (size) < 0)
5835 error_at (loc, "size of array %qE is negative", name);
5837 error_at (loc, "size of unnamed array is negative");
5838 size = integer_one_node;
5840 /* Handle a size folded to an integer constant but
5841 not an integer constant expression. */
5842 if (!size_int_const)
5844 /* If this is a file scope declaration of an
5845 ordinary identifier, this is invalid code;
5846 diagnosing it here and not subsequently
5847 treating the type as variable-length avoids
5848 more confusing diagnostics later. */
5849 if ((decl_context == NORMAL || decl_context == FIELD)
5850 && current_scope == file_scope)
5851 pedwarn (input_location, 0,
5852 "variably modified %qE at file scope",
5855 this_size_varies = size_varies = true;
5856 warn_variable_length_array (name, size);
5859 else if ((decl_context == NORMAL || decl_context == FIELD)
5860 && current_scope == file_scope)
5862 error_at (loc, "variably modified %qE at file scope", name);
5863 size = integer_one_node;
5867 /* Make sure the array size remains visibly
5868 nonconstant even if it is (eg) a const variable
5869 with known value. */
5870 this_size_varies = size_varies = true;
5871 warn_variable_length_array (name, size);
5872 if (flag_sanitize & SANITIZE_VLA
5873 && decl_context == NORMAL
5874 && do_ubsan_in_current_function ())
5876 /* Evaluate the array size only once. */
5877 size = c_save_expr (size);
5878 size = c_fully_fold (size, false, NULL);
5879 size = fold_build2 (COMPOUND_EXPR, TREE_TYPE (size),
5880 ubsan_instrument_vla (loc, size),
5885 if (integer_zerop (size) && !this_size_varies)
5887 /* A zero-length array cannot be represented with
5888 an unsigned index type, which is what we'll
5889 get with build_index_type. Create an
5890 open-ended range instead. */
5891 itype = build_range_type (sizetype, size, NULL_TREE);
5895 /* Arrange for the SAVE_EXPR on the inside of the
5896 MINUS_EXPR, which allows the -1 to get folded
5897 with the +1 that happens when building TYPE_SIZE. */
5899 size = save_expr (size);
5900 if (this_size_varies && TREE_CODE (size) == INTEGER_CST)
5901 size = build2 (COMPOUND_EXPR, TREE_TYPE (size),
5902 integer_zero_node, size);
5904 /* Compute the maximum valid index, that is, size
5905 - 1. Do the calculation in index_type, so that
5906 if it is a variable the computations will be
5907 done in the proper mode. */
5908 itype = fold_build2_loc (loc, MINUS_EXPR, index_type,
5909 convert (index_type, size),
5910 convert (index_type,
5913 /* The above overflows when size does not fit
5915 ??? While a size of INT_MAX+1 technically shouldn't
5916 cause an overflow (because we subtract 1), handling
5917 this case seems like an unnecessary complication. */
5918 if (TREE_CODE (size) == INTEGER_CST
5919 && !int_fits_type_p (size, index_type))
5922 error_at (loc, "size of array %qE is too large",
5925 error_at (loc, "size of unnamed array is too large");
5926 type = error_mark_node;
5930 itype = build_index_type (itype);
5932 if (this_size_varies)
5935 *expr = build2 (COMPOUND_EXPR, TREE_TYPE (size),
5939 *expr_const_operands &= size_maybe_const;
5942 else if (decl_context == FIELD)
5944 bool flexible_array_member = false;
5945 if (array_parm_vla_unspec_p)
5946 /* Field names can in fact have function prototype
5947 scope so [*] is disallowed here through making
5948 the field variably modified, not through being
5949 something other than a declaration with function
5954 const struct c_declarator *t = declarator;
5955 while (t->kind == cdk_attrs)
5957 flexible_array_member = (t->kind == cdk_id);
5959 if (flexible_array_member
5960 && !in_system_header_at (input_location))
5961 pedwarn_c90 (loc, OPT_Wpedantic, "ISO C90 does not "
5962 "support flexible array members");
5964 /* ISO C99 Flexible array members are effectively
5965 identical to GCC's zero-length array extension. */
5966 if (flexible_array_member || array_parm_vla_unspec_p)
5967 itype = build_range_type (sizetype, size_zero_node,
5970 else if (decl_context == PARM)
5972 if (array_parm_vla_unspec_p)
5974 itype = build_range_type (sizetype, size_zero_node, NULL_TREE);
5978 else if (decl_context == TYPENAME)
5980 if (array_parm_vla_unspec_p)
5983 warning (0, "%<[*]%> not in a declaration");
5984 /* We use this to avoid messing up with incomplete
5985 array types of the same type, that would
5986 otherwise be modified below. */
5987 itype = build_range_type (sizetype, size_zero_node,
5993 /* Complain about arrays of incomplete types. */
5994 if (!COMPLETE_TYPE_P (type))
5996 error_at (loc, "array type has incomplete element type %qT",
5998 type = error_mark_node;
6001 /* When itype is NULL, a shared incomplete array type is
6002 returned for all array of a given type. Elsewhere we
6003 make sure we don't complete that type before copying
6004 it, but here we want to make sure we don't ever
6005 modify the shared type, so we gcc_assert (itype)
6008 addr_space_t as = DECODE_QUAL_ADDR_SPACE (type_quals);
6009 if (!ADDR_SPACE_GENERIC_P (as) && as != TYPE_ADDR_SPACE (type))
6010 type = build_qualified_type (type,
6011 ENCODE_QUAL_ADDR_SPACE (as));
6013 type = build_array_type (type, itype);
6016 if (type != error_mark_node)
6020 /* It is ok to modify type here even if itype is
6021 NULL: if size_varies, we're in a
6022 multi-dimensional array and the inner type has
6023 variable size, so the enclosing shared array type
6025 if (size && TREE_CODE (size) == INTEGER_CST)
6027 = build_distinct_type_copy (TYPE_MAIN_VARIANT (type));
6028 C_TYPE_VARIABLE_SIZE (type) = 1;
6031 /* The GCC extension for zero-length arrays differs from
6032 ISO flexible array members in that sizeof yields
6034 if (size && integer_zerop (size))
6037 type = build_distinct_type_copy (TYPE_MAIN_VARIANT (type));
6038 TYPE_SIZE (type) = bitsize_zero_node;
6039 TYPE_SIZE_UNIT (type) = size_zero_node;
6040 SET_TYPE_STRUCTURAL_EQUALITY (type);
6042 if (array_parm_vla_unspec_p)
6045 /* The type is complete. C99 6.7.5.2p4 */
6046 type = build_distinct_type_copy (TYPE_MAIN_VARIANT (type));
6047 TYPE_SIZE (type) = bitsize_zero_node;
6048 TYPE_SIZE_UNIT (type) = size_zero_node;
6049 SET_TYPE_STRUCTURAL_EQUALITY (type);
6053 if (decl_context != PARM
6054 && (array_ptr_quals != TYPE_UNQUALIFIED
6055 || array_ptr_attrs != NULL_TREE
6056 || array_parm_static))
6058 error_at (loc, "static or type qualifiers in non-parameter array declarator");
6059 array_ptr_quals = TYPE_UNQUALIFIED;
6060 array_ptr_attrs = NULL_TREE;
6061 array_parm_static = 0;
6063 orig_qual_indirect++;
6068 /* Say it's a definition only for the declarator closest
6069 to the identifier, apart possibly from some
6071 bool really_funcdef = false;
6073 orig_qual_type = NULL_TREE;
6076 const struct c_declarator *t = declarator->declarator;
6077 while (t->kind == cdk_attrs)
6079 really_funcdef = (t->kind == cdk_id);
6082 /* Declaring a function type. Make sure we have a valid
6083 type for the function to return. */
6084 if (type == error_mark_node)
6087 size_varies = false;
6089 /* Warn about some types functions can't return. */
6090 if (TREE_CODE (type) == FUNCTION_TYPE)
6093 error_at (loc, "%qE declared as function returning a "
6096 error_at (loc, "type name declared as function "
6097 "returning a function");
6098 type = integer_type_node;
6100 if (TREE_CODE (type) == ARRAY_TYPE)
6103 error_at (loc, "%qE declared as function returning an array",
6106 error_at (loc, "type name declared as function returning "
6108 type = integer_type_node;
6110 errmsg = targetm.invalid_return_type (type);
6114 type = integer_type_node;
6117 /* Construct the function type and go to the next
6118 inner layer of declarator. */
6119 arg_info = declarator->u.arg_info;
6120 arg_types = grokparms (arg_info, really_funcdef);
6122 /* Type qualifiers before the return type of the function
6123 qualify the return type, not the function type. */
6126 /* Type qualifiers on a function return type are
6127 normally permitted by the standard but have no
6128 effect, so give a warning at -Wreturn-type.
6129 Qualifiers on a void return type are banned on
6130 function definitions in ISO C; GCC used to used
6131 them for noreturn functions. */
6132 if (VOID_TYPE_P (type) && really_funcdef)
6134 "function definition has qualified void return type");
6136 warning_at (loc, OPT_Wignored_qualifiers,
6137 "type qualifiers ignored on function return type");
6139 type = c_build_qualified_type (type, type_quals);
6141 type_quals = TYPE_UNQUALIFIED;
6143 type = build_function_type (type, arg_types);
6144 declarator = declarator->declarator;
6146 /* Set the TYPE_CONTEXTs for each tagged type which is local to
6147 the formal parameter list of this FUNCTION_TYPE to point to
6148 the FUNCTION_TYPE node itself. */
6153 FOR_EACH_VEC_SAFE_ELT_REVERSE (arg_info->tags, ix, tag)
6154 TYPE_CONTEXT (tag->type) = type;
6160 /* Merge any constancy or volatility into the target type
6162 if ((type_quals & TYPE_QUAL_ATOMIC)
6163 && TREE_CODE (type) == FUNCTION_TYPE)
6166 "%<_Atomic%>-qualified function type");
6167 type_quals &= ~TYPE_QUAL_ATOMIC;
6169 else if (pedantic && TREE_CODE (type) == FUNCTION_TYPE
6171 pedwarn (loc, OPT_Wpedantic,
6172 "ISO C forbids qualified function types");
6174 type = c_build_qualified_type (type, type_quals, orig_qual_type,
6175 orig_qual_indirect);
6176 orig_qual_type = NULL_TREE;
6177 size_varies = false;
6179 /* When the pointed-to type involves components of variable size,
6180 care must be taken to ensure that the size evaluation code is
6181 emitted early enough to dominate all the possible later uses
6182 and late enough for the variables on which it depends to have
6185 This is expected to happen automatically when the pointed-to
6186 type has a name/declaration of it's own, but special attention
6187 is required if the type is anonymous.
6189 We handle the NORMAL and FIELD contexts here by attaching an
6190 artificial TYPE_DECL to such pointed-to type. This forces the
6191 sizes evaluation at a safe point and ensures it is not deferred
6192 until e.g. within a deeper conditional context.
6194 We expect nothing to be needed here for PARM or TYPENAME.
6195 Pushing a TYPE_DECL at this point for TYPENAME would actually
6196 be incorrect, as we might be in the middle of an expression
6197 with side effects on the pointed-to type size "arguments" prior
6198 to the pointer declaration point and the fake TYPE_DECL in the
6199 enclosing context would force the size evaluation prior to the
6202 if (!TYPE_NAME (type)
6203 && (decl_context == NORMAL || decl_context == FIELD)
6204 && variably_modified_type_p (type, NULL_TREE))
6206 tree decl = build_decl (loc, TYPE_DECL, NULL_TREE, type);
6207 DECL_ARTIFICIAL (decl) = 1;
6209 finish_decl (decl, loc, NULL_TREE, NULL_TREE, NULL_TREE);
6210 TYPE_NAME (type) = decl;
6213 type = c_build_pointer_type (type);
6215 /* Process type qualifiers (such as const or volatile)
6216 that were given inside the `*'. */
6217 type_quals = declarator->u.pointer_quals;
6219 declarator = declarator->declarator;
6226 *decl_attrs = chainon (returned_attrs, *decl_attrs);
6228 /* Now TYPE has the actual type, apart from any qualifiers in
6231 /* Warn about address space used for things other than static memory or
6233 address_space = DECODE_QUAL_ADDR_SPACE (type_quals);
6234 if (!ADDR_SPACE_GENERIC_P (address_space))
6236 if (decl_context == NORMAL)
6238 switch (storage_class)
6241 error ("%qs combined with %<auto%> qualifier for %qE",
6242 c_addr_space_name (address_space), name);
6245 error ("%qs combined with %<register%> qualifier for %qE",
6246 c_addr_space_name (address_space), name);
6249 if (current_function_scope)
6251 error ("%qs specified for auto variable %qE",
6252 c_addr_space_name (address_space), name);
6264 else if (decl_context == PARM && TREE_CODE (type) != ARRAY_TYPE)
6267 error ("%qs specified for parameter %qE",
6268 c_addr_space_name (address_space), name);
6270 error ("%qs specified for unnamed parameter",
6271 c_addr_space_name (address_space));
6273 else if (decl_context == FIELD)
6276 error ("%qs specified for structure field %qE",
6277 c_addr_space_name (address_space), name);
6279 error ("%qs specified for structure field",
6280 c_addr_space_name (address_space));
6284 /* Check the type and width of a bit-field. */
6287 check_bitfield_type_and_width (&type, width, name);
6288 /* C11 makes it implementation-defined (6.7.2.1#5) whether
6289 atomic types are permitted for bit-fields; we have no code to
6290 make bit-field accesses atomic, so disallow them. */
6291 if (type_quals & TYPE_QUAL_ATOMIC)
6294 error ("bit-field %qE has atomic type", name);
6296 error ("bit-field has atomic type");
6297 type_quals &= ~TYPE_QUAL_ATOMIC;
6301 /* Reject invalid uses of _Alignas. */
6302 if (declspecs->alignas_p)
6304 if (storage_class == csc_typedef)
6305 error_at (loc, "alignment specified for typedef %qE", name);
6306 else if (storage_class == csc_register)
6307 error_at (loc, "alignment specified for %<register%> object %qE",
6309 else if (decl_context == PARM)
6312 error_at (loc, "alignment specified for parameter %qE", name);
6314 error_at (loc, "alignment specified for unnamed parameter");
6319 error_at (loc, "alignment specified for bit-field %qE", name);
6321 error_at (loc, "alignment specified for unnamed bit-field");
6323 else if (TREE_CODE (type) == FUNCTION_TYPE)
6324 error_at (loc, "alignment specified for function %qE", name);
6325 else if (declspecs->align_log != -1)
6327 alignas_align = 1U << declspecs->align_log;
6328 if (alignas_align < min_align_of_type (type))
6331 error_at (loc, "%<_Alignas%> specifiers cannot reduce "
6332 "alignment of %qE", name);
6334 error_at (loc, "%<_Alignas%> specifiers cannot reduce "
6335 "alignment of unnamed field");
6341 /* Did array size calculations overflow or does the array cover more
6342 than half of the address-space? */
6343 if (TREE_CODE (type) == ARRAY_TYPE
6344 && COMPLETE_TYPE_P (type)
6345 && TREE_CODE (TYPE_SIZE_UNIT (type)) == INTEGER_CST
6346 && ! valid_constant_size_p (TYPE_SIZE_UNIT (type)))
6349 error_at (loc, "size of array %qE is too large", name);
6351 error_at (loc, "size of unnamed array is too large");
6352 /* If we proceed with the array type as it is, we'll eventually
6353 crash in tree_to_[su]hwi(). */
6354 type = error_mark_node;
6357 /* If this is declaring a typedef name, return a TYPE_DECL. */
6359 if (storage_class == csc_typedef)
6362 if ((type_quals & TYPE_QUAL_ATOMIC)
6363 && TREE_CODE (type) == FUNCTION_TYPE)
6366 "%<_Atomic%>-qualified function type");
6367 type_quals &= ~TYPE_QUAL_ATOMIC;
6369 else if (pedantic && TREE_CODE (type) == FUNCTION_TYPE
6371 pedwarn (loc, OPT_Wpedantic,
6372 "ISO C forbids qualified function types");
6374 type = c_build_qualified_type (type, type_quals, orig_qual_type,
6375 orig_qual_indirect);
6376 decl = build_decl (declarator->id_loc,
6377 TYPE_DECL, declarator->u.id, type);
6378 if (declspecs->explicit_signed_p)
6379 C_TYPEDEF_EXPLICITLY_SIGNED (decl) = 1;
6380 if (declspecs->inline_p)
6381 pedwarn (loc, 0,"typedef %q+D declared %<inline%>", decl);
6382 if (declspecs->noreturn_p)
6383 pedwarn (loc, 0,"typedef %q+D declared %<_Noreturn%>", decl);
6385 if (warn_cxx_compat && declarator->u.id != NULL_TREE)
6387 struct c_binding *b = I_TAG_BINDING (declarator->u.id);
6390 && b->decl != NULL_TREE
6391 && (B_IN_CURRENT_SCOPE (b)
6392 || (current_scope == file_scope && B_IN_EXTERNAL_SCOPE (b)))
6393 && TYPE_MAIN_VARIANT (b->decl) != TYPE_MAIN_VARIANT (type))
6395 warning_at (declarator->id_loc, OPT_Wc___compat,
6396 ("using %qD as both a typedef and a tag is "
6399 if (b->locus != UNKNOWN_LOCATION)
6400 inform (b->locus, "originally defined here");
6407 /* If this is a type name (such as, in a cast or sizeof),
6408 compute the type and return it now. */
6410 if (decl_context == TYPENAME)
6412 /* Note that the grammar rejects storage classes in typenames
6414 gcc_assert (storage_class == csc_none && !threadp
6415 && !declspecs->inline_p && !declspecs->noreturn_p);
6416 if ((type_quals & TYPE_QUAL_ATOMIC)
6417 && TREE_CODE (type) == FUNCTION_TYPE)
6420 "%<_Atomic%>-qualified function type");
6421 type_quals &= ~TYPE_QUAL_ATOMIC;
6423 else if (pedantic && TREE_CODE (type) == FUNCTION_TYPE
6425 pedwarn (loc, OPT_Wpedantic,
6426 "ISO C forbids const or volatile function types");
6428 type = c_build_qualified_type (type, type_quals, orig_qual_type,
6429 orig_qual_indirect);
6433 if (pedantic && decl_context == FIELD
6434 && variably_modified_type_p (type, NULL_TREE))
6437 pedwarn (loc, OPT_Wpedantic, "a member of a structure or union cannot "
6438 "have a variably modified type");
6441 /* Aside from typedefs and type names (handle above),
6442 `void' at top level (not within pointer)
6443 is allowed only in public variables.
6444 We don't complain about parms either, but that is because
6445 a better error message can be made later. */
6447 if (VOID_TYPE_P (type) && decl_context != PARM
6448 && !((decl_context != FIELD && TREE_CODE (type) != FUNCTION_TYPE)
6449 && (storage_class == csc_extern
6450 || (current_scope == file_scope
6451 && !(storage_class == csc_static
6452 || storage_class == csc_register)))))
6454 error_at (loc, "variable or field %qE declared void", name);
6455 type = integer_type_node;
6458 /* Now create the decl, which may be a VAR_DECL, a PARM_DECL
6459 or a FUNCTION_DECL, depending on DECL_CONTEXT and TYPE. */
6464 if (decl_context == PARM)
6467 bool array_parameter_p = false;
6469 /* A parameter declared as an array of T is really a pointer to T.
6470 One declared as a function is really a pointer to a function. */
6472 if (TREE_CODE (type) == ARRAY_TYPE)
6474 /* Transfer const-ness of array into that of type pointed to. */
6475 type = TREE_TYPE (type);
6476 if (orig_qual_type != NULL_TREE)
6478 if (orig_qual_indirect == 0)
6479 orig_qual_type = TREE_TYPE (orig_qual_type);
6481 orig_qual_indirect--;
6484 type = c_build_qualified_type (type, type_quals, orig_qual_type,
6485 orig_qual_indirect);
6486 type = c_build_pointer_type (type);
6487 type_quals = array_ptr_quals;
6489 type = c_build_qualified_type (type, type_quals);
6491 /* We don't yet implement attributes in this context. */
6492 if (array_ptr_attrs != NULL_TREE)
6493 warning_at (loc, OPT_Wattributes,
6494 "attributes in parameter array declarator ignored");
6496 size_varies = false;
6497 array_parameter_p = true;
6499 else if (TREE_CODE (type) == FUNCTION_TYPE)
6501 if (type_quals & TYPE_QUAL_ATOMIC)
6504 "%<_Atomic%>-qualified function type");
6505 type_quals &= ~TYPE_QUAL_ATOMIC;
6507 else if (type_quals)
6508 pedwarn (loc, OPT_Wpedantic,
6509 "ISO C forbids qualified function types");
6511 type = c_build_qualified_type (type, type_quals);
6512 type = c_build_pointer_type (type);
6513 type_quals = TYPE_UNQUALIFIED;
6515 else if (type_quals)
6516 type = c_build_qualified_type (type, type_quals);
6518 decl = build_decl (declarator->id_loc,
6519 PARM_DECL, declarator->u.id, type);
6521 C_DECL_VARIABLE_SIZE (decl) = 1;
6522 C_ARRAY_PARAMETER (decl) = array_parameter_p;
6524 /* Compute the type actually passed in the parmlist,
6525 for the case where there is no prototype.
6526 (For example, shorts and chars are passed as ints.)
6527 When there is a prototype, this is overridden later. */
6529 if (type == error_mark_node)
6530 promoted_type = type;
6532 promoted_type = c_type_promotes_to (type);
6534 DECL_ARG_TYPE (decl) = promoted_type;
6535 if (declspecs->inline_p)
6536 pedwarn (loc, 0, "parameter %q+D declared %<inline%>", decl);
6537 if (declspecs->noreturn_p)
6538 pedwarn (loc, 0, "parameter %q+D declared %<_Noreturn%>", decl);
6540 else if (decl_context == FIELD)
6542 /* Note that the grammar rejects storage classes in typenames
6544 gcc_assert (storage_class == csc_none && !threadp
6545 && !declspecs->inline_p && !declspecs->noreturn_p);
6547 /* Structure field. It may not be a function. */
6549 if (TREE_CODE (type) == FUNCTION_TYPE)
6551 error_at (loc, "field %qE declared as a function", name);
6552 type = build_pointer_type (type);
6554 else if (TREE_CODE (type) != ERROR_MARK
6555 && !COMPLETE_OR_UNBOUND_ARRAY_TYPE_P (type))
6558 error_at (loc, "field %qE has incomplete type", name);
6560 error_at (loc, "unnamed field has incomplete type");
6561 type = error_mark_node;
6563 else if (TREE_CODE (type) == ARRAY_TYPE
6564 && TYPE_DOMAIN (type) == NULL_TREE)
6566 /* We have a flexible array member through a typedef.
6567 Set suitable range. Whether this is a correct position
6568 for a flexible array member will be determined elsewhere. */
6569 if (!in_system_header_at (input_location))
6570 pedwarn_c90 (loc, OPT_Wpedantic, "ISO C90 does not "
6571 "support flexible array members");
6572 type = build_distinct_type_copy (TYPE_MAIN_VARIANT (type));
6573 TYPE_DOMAIN (type) = build_range_type (sizetype, size_zero_node,
6576 type = c_build_qualified_type (type, type_quals, orig_qual_type,
6577 orig_qual_indirect);
6578 decl = build_decl (declarator->id_loc,
6579 FIELD_DECL, declarator->u.id, type);
6580 DECL_NONADDRESSABLE_P (decl) = bitfield;
6581 if (bitfield && !declarator->u.id)
6582 TREE_NO_WARNING (decl) = 1;
6585 C_DECL_VARIABLE_SIZE (decl) = 1;
6587 else if (TREE_CODE (type) == FUNCTION_TYPE)
6589 if (storage_class == csc_register || threadp)
6591 error_at (loc, "invalid storage class for function %qE", name);
6593 else if (current_scope != file_scope)
6595 /* Function declaration not at file scope. Storage
6596 classes other than `extern' are not allowed, C99
6597 6.7.1p5, and `extern' makes no difference. However,
6598 GCC allows 'auto', perhaps with 'inline', to support
6599 nested functions. */
6600 if (storage_class == csc_auto)
6601 pedwarn (loc, OPT_Wpedantic,
6602 "invalid storage class for function %qE", name);
6603 else if (storage_class == csc_static)
6605 error_at (loc, "invalid storage class for function %qE", name);
6607 storage_class = declspecs->storage_class = csc_none;
6613 decl = build_decl (declarator->id_loc,
6614 FUNCTION_DECL, declarator->u.id, type);
6615 decl = build_decl_attribute_variant (decl, decl_attr);
6617 if (type_quals & TYPE_QUAL_ATOMIC)
6620 "%<_Atomic%>-qualified function type");
6621 type_quals &= ~TYPE_QUAL_ATOMIC;
6623 else if (pedantic && type_quals && !DECL_IN_SYSTEM_HEADER (decl))
6624 pedwarn (loc, OPT_Wpedantic,
6625 "ISO C forbids qualified function types");
6627 /* Every function declaration is an external reference
6628 (DECL_EXTERNAL) except for those which are not at file
6629 scope and are explicitly declared "auto". This is
6630 forbidden by standard C (C99 6.7.1p5) and is interpreted by
6631 GCC to signify a forward declaration of a nested function. */
6632 if (storage_class == csc_auto && current_scope != file_scope)
6633 DECL_EXTERNAL (decl) = 0;
6634 /* In C99, a function which is declared 'inline' with 'extern'
6635 is not an external reference (which is confusing). It
6636 means that the later definition of the function must be output
6637 in this file, C99 6.7.4p6. In GNU C89, a function declared
6638 'extern inline' is an external reference. */
6639 else if (declspecs->inline_p && storage_class != csc_static)
6640 DECL_EXTERNAL (decl) = ((storage_class == csc_extern)
6641 == flag_gnu89_inline);
6643 DECL_EXTERNAL (decl) = !initialized;
6645 /* Record absence of global scope for `static' or `auto'. */
6647 = !(storage_class == csc_static || storage_class == csc_auto);
6649 /* For a function definition, record the argument information
6650 block where store_parm_decls will look for it. */
6652 current_function_arg_info = arg_info;
6654 if (declspecs->default_int_p)
6655 C_FUNCTION_IMPLICIT_INT (decl) = 1;
6657 /* Record presence of `inline' and `_Noreturn', if it is
6659 if (flag_hosted && MAIN_NAME_P (declarator->u.id))
6661 if (declspecs->inline_p)
6662 pedwarn (loc, 0, "cannot inline function %<main%>");
6663 if (declspecs->noreturn_p)
6664 pedwarn (loc, 0, "%<main%> declared %<_Noreturn%>");
6668 if (declspecs->inline_p)
6669 /* Record that the function is declared `inline'. */
6670 DECL_DECLARED_INLINE_P (decl) = 1;
6671 if (declspecs->noreturn_p)
6674 pedwarn_c99 (loc, OPT_Wpedantic,
6675 "ISO C99 does not support %<_Noreturn%>");
6677 pedwarn_c99 (loc, OPT_Wpedantic,
6678 "ISO C90 does not support %<_Noreturn%>");
6679 TREE_THIS_VOLATILE (decl) = 1;
6685 /* It's a variable. */
6686 /* An uninitialized decl with `extern' is a reference. */
6687 int extern_ref = !initialized && storage_class == csc_extern;
6689 type = c_build_qualified_type (type, type_quals, orig_qual_type,
6690 orig_qual_indirect);
6692 /* C99 6.2.2p7: It is invalid (compile-time undefined
6693 behavior) to create an 'extern' declaration for a
6694 variable if there is a global declaration that is
6695 'static' and the global declaration is not visible.
6696 (If the static declaration _is_ currently visible,
6697 the 'extern' declaration is taken to refer to that decl.) */
6698 if (extern_ref && current_scope != file_scope)
6700 tree global_decl = identifier_global_value (declarator->u.id);
6701 tree visible_decl = lookup_name (declarator->u.id);
6704 && global_decl != visible_decl
6705 && TREE_CODE (global_decl) == VAR_DECL
6706 && !TREE_PUBLIC (global_decl))
6707 error_at (loc, "variable previously declared %<static%> "
6708 "redeclared %<extern%>");
6711 decl = build_decl (declarator->id_loc,
6712 VAR_DECL, declarator->u.id, type);
6714 C_DECL_VARIABLE_SIZE (decl) = 1;
6716 if (declspecs->inline_p)
6717 pedwarn (loc, 0, "variable %q+D declared %<inline%>", decl);
6718 if (declspecs->noreturn_p)
6719 pedwarn (loc, 0, "variable %q+D declared %<_Noreturn%>", decl);
6721 /* At file scope, an initialized extern declaration may follow
6722 a static declaration. In that case, DECL_EXTERNAL will be
6723 reset later in start_decl. */
6724 DECL_EXTERNAL (decl) = (storage_class == csc_extern);
6726 /* At file scope, the presence of a `static' or `register' storage
6727 class specifier, or the absence of all storage class specifiers
6728 makes this declaration a definition (perhaps tentative). Also,
6729 the absence of `static' makes it public. */
6730 if (current_scope == file_scope)
6732 TREE_PUBLIC (decl) = storage_class != csc_static;
6733 TREE_STATIC (decl) = !extern_ref;
6735 /* Not at file scope, only `static' makes a static definition. */
6738 TREE_STATIC (decl) = (storage_class == csc_static);
6739 TREE_PUBLIC (decl) = extern_ref;
6743 set_decl_tls_model (decl, decl_default_tls_model (decl));
6746 if ((storage_class == csc_extern
6747 || (storage_class == csc_none
6748 && TREE_CODE (type) == FUNCTION_TYPE
6750 && variably_modified_type_p (type, NULL_TREE))
6753 if (TREE_CODE (type) == FUNCTION_TYPE)
6754 error_at (loc, "non-nested function with variably modified type");
6756 error_at (loc, "object with variably modified type must have "
6760 /* Record `register' declaration for warnings on &
6761 and in case doing stupid register allocation. */
6763 if (storage_class == csc_register)
6765 C_DECL_REGISTER (decl) = 1;
6766 DECL_REGISTER (decl) = 1;
6769 /* Record constancy and volatility. */
6770 c_apply_type_quals_to_decl (type_quals, decl);
6772 /* Apply _Alignas specifiers. */
6775 DECL_ALIGN (decl) = alignas_align * BITS_PER_UNIT;
6776 DECL_USER_ALIGN (decl) = 1;
6779 /* If a type has volatile components, it should be stored in memory.
6780 Otherwise, the fact that those components are volatile
6781 will be ignored, and would even crash the compiler.
6782 Of course, this only makes sense on VAR,PARM, and RESULT decl's. */
6783 if (C_TYPE_FIELDS_VOLATILE (TREE_TYPE (decl))
6784 && (TREE_CODE (decl) == VAR_DECL || TREE_CODE (decl) == PARM_DECL
6785 || TREE_CODE (decl) == RESULT_DECL))
6787 /* It is not an error for a structure with volatile fields to
6788 be declared register, but reset DECL_REGISTER since it
6789 cannot actually go in a register. */
6790 int was_reg = C_DECL_REGISTER (decl);
6791 C_DECL_REGISTER (decl) = 0;
6792 DECL_REGISTER (decl) = 0;
6793 c_mark_addressable (decl);
6794 C_DECL_REGISTER (decl) = was_reg;
6797 /* This is the earliest point at which we might know the assembler
6798 name of a variable. Thus, if it's known before this, die horribly. */
6799 gcc_assert (!DECL_ASSEMBLER_NAME_SET_P (decl));
6802 && TREE_CODE (decl) == VAR_DECL
6803 && TREE_PUBLIC (decl)
6804 && TREE_STATIC (decl)
6805 && (TREE_CODE (TREE_TYPE (decl)) == RECORD_TYPE
6806 || TREE_CODE (TREE_TYPE (decl)) == UNION_TYPE
6807 || TREE_CODE (TREE_TYPE (decl)) == ENUMERAL_TYPE)
6808 && TYPE_NAME (TREE_TYPE (decl)) == NULL_TREE)
6809 warning_at (DECL_SOURCE_LOCATION (decl), OPT_Wc___compat,
6810 ("non-local variable %qD with anonymous type is "
6811 "questionable in C++"),
6818 /* Decode the parameter-list info for a function type or function definition.
6819 The argument is the value returned by `get_parm_info' (or made in c-parse.c
6820 if there is an identifier list instead of a parameter decl list).
6821 These two functions are separate because when a function returns
6822 or receives functions then each is called multiple times but the order
6823 of calls is different. The last call to `grokparms' is always the one
6824 that contains the formal parameter names of a function definition.
6826 Return a list of arg types to use in the FUNCTION_TYPE for this function.
6828 FUNCDEF_FLAG is true for a function definition, false for
6829 a mere declaration. A nonempty identifier-list gets an error message
6830 when FUNCDEF_FLAG is false. */
6833 grokparms (struct c_arg_info *arg_info, bool funcdef_flag)
6835 tree arg_types = arg_info->types;
6837 if (funcdef_flag && arg_info->had_vla_unspec)
6839 /* A function definition isn't function prototype scope C99 6.2.1p4. */
6841 error ("%<[*]%> not allowed in other than function prototype scope");
6844 if (arg_types == 0 && !funcdef_flag
6845 && !in_system_header_at (input_location))
6846 warning (OPT_Wstrict_prototypes,
6847 "function declaration isn%'t a prototype");
6849 if (arg_types == error_mark_node)
6850 return 0; /* don't set TYPE_ARG_TYPES in this case */
6852 else if (arg_types && TREE_CODE (TREE_VALUE (arg_types)) == IDENTIFIER_NODE)
6856 pedwarn (input_location, 0, "parameter names (without types) in function declaration");
6857 arg_info->parms = NULL_TREE;
6860 arg_info->parms = arg_info->types;
6862 arg_info->types = 0;
6867 tree parm, type, typelt;
6868 unsigned int parmno;
6871 /* If there is a parameter of incomplete type in a definition,
6872 this is an error. In a declaration this is valid, and a
6873 struct or union type may be completed later, before any calls
6874 or definition of the function. In the case where the tag was
6875 first declared within the parameter list, a warning has
6876 already been given. If a parameter has void type, then
6877 however the function cannot be defined or called, so
6880 for (parm = arg_info->parms, typelt = arg_types, parmno = 1;
6882 parm = DECL_CHAIN (parm), typelt = TREE_CHAIN (typelt), parmno++)
6884 type = TREE_VALUE (typelt);
6885 if (type == error_mark_node)
6888 if (!COMPLETE_TYPE_P (type))
6892 if (DECL_NAME (parm))
6893 error_at (input_location,
6894 "parameter %u (%q+D) has incomplete type",
6897 error_at (DECL_SOURCE_LOCATION (parm),
6898 "parameter %u has incomplete type",
6901 TREE_VALUE (typelt) = error_mark_node;
6902 TREE_TYPE (parm) = error_mark_node;
6903 arg_types = NULL_TREE;
6905 else if (VOID_TYPE_P (type))
6907 if (DECL_NAME (parm))
6908 warning_at (input_location, 0,
6909 "parameter %u (%q+D) has void type",
6912 warning_at (DECL_SOURCE_LOCATION (parm), 0,
6913 "parameter %u has void type",
6918 errmsg = targetm.invalid_parameter_type (type);
6922 TREE_VALUE (typelt) = error_mark_node;
6923 TREE_TYPE (parm) = error_mark_node;
6924 arg_types = NULL_TREE;
6927 if (DECL_NAME (parm) && TREE_USED (parm))
6928 warn_if_shadowing (parm);
6934 /* Allocate and initialize a c_arg_info structure from the parser's
6938 build_arg_info (void)
6940 struct c_arg_info *ret = XOBNEW (&parser_obstack, struct c_arg_info);
6941 ret->parms = NULL_TREE;
6943 ret->types = NULL_TREE;
6944 ret->others = NULL_TREE;
6945 ret->pending_sizes = NULL;
6946 ret->had_vla_unspec = 0;
6950 /* Take apart the current scope and return a c_arg_info structure with
6951 info on a parameter list just parsed.
6953 This structure is later fed to 'grokparms' and 'store_parm_decls'.
6955 ELLIPSIS being true means the argument list ended in '...' so don't
6956 append a sentinel (void_list_node) to the end of the type-list.
6958 EXPR is NULL or an expression that needs to be evaluated for the
6959 side effects of array size expressions in the parameters. */
6962 get_parm_info (bool ellipsis, tree expr)
6964 struct c_binding *b = current_scope->bindings;
6965 struct c_arg_info *arg_info = build_arg_info ();
6968 vec<c_arg_tag, va_gc> *tags = NULL;
6972 static bool explained_incomplete_types = false;
6973 bool gave_void_only_once_err = false;
6975 arg_info->had_vla_unspec = current_scope->had_vla_unspec;
6977 /* The bindings in this scope must not get put into a block.
6978 We will take care of deleting the binding nodes. */
6979 current_scope->bindings = 0;
6981 /* This function is only called if there was *something* on the
6985 /* A parameter list consisting solely of 'void' indicates that the
6986 function takes no arguments. But if the 'void' is qualified
6987 (by 'const' or 'volatile'), or has a storage class specifier
6988 ('register'), then the behavior is undefined; issue an error.
6989 Typedefs for 'void' are OK (see DR#157). */
6990 if (b->prev == 0 /* one binding */
6991 && TREE_CODE (b->decl) == PARM_DECL /* which is a parameter */
6992 && !DECL_NAME (b->decl) /* anonymous */
6993 && VOID_TYPE_P (TREE_TYPE (b->decl))) /* of void type */
6995 if (TYPE_QUALS (TREE_TYPE (b->decl)) != TYPE_UNQUALIFIED
6996 || C_DECL_REGISTER (b->decl))
6997 error ("%<void%> as only parameter may not be qualified");
6999 /* There cannot be an ellipsis. */
7001 error ("%<void%> must be the only parameter");
7003 arg_info->types = void_list_node;
7008 types = void_list_node;
7010 /* Break up the bindings list into parms, tags, types, and others;
7011 apply sanity checks; purge the name-to-decl bindings. */
7014 tree decl = b->decl;
7015 tree type = TREE_TYPE (decl);
7017 const char *keyword;
7019 switch (TREE_CODE (decl))
7024 gcc_assert (I_SYMBOL_BINDING (b->id) == b);
7025 I_SYMBOL_BINDING (b->id) = b->shadowed;
7028 /* Check for forward decls that never got their actual decl. */
7029 if (TREE_ASM_WRITTEN (decl))
7030 error ("parameter %q+D has just a forward declaration", decl);
7031 /* Check for (..., void, ...) and issue an error. */
7032 else if (VOID_TYPE_P (type) && !DECL_NAME (decl))
7034 if (!gave_void_only_once_err)
7036 error ("%<void%> must be the only parameter");
7037 gave_void_only_once_err = true;
7042 /* Valid parameter, add it to the list. */
7043 DECL_CHAIN (decl) = parms;
7046 /* Since there is a prototype, args are passed in their
7047 declared types. The back end may override this later. */
7048 DECL_ARG_TYPE (decl) = type;
7049 types = tree_cons (0, type, types);
7053 case ENUMERAL_TYPE: keyword = "enum"; goto tag;
7054 case UNION_TYPE: keyword = "union"; goto tag;
7055 case RECORD_TYPE: keyword = "struct"; goto tag;
7057 /* Types may not have tag-names, in which case the type
7058 appears in the bindings list with b->id NULL. */
7061 gcc_assert (I_TAG_BINDING (b->id) == b);
7062 I_TAG_BINDING (b->id) = b->shadowed;
7065 /* Warn about any struct, union or enum tags defined in a
7066 parameter list. The scope of such types is limited to
7067 the parameter list, which is rarely if ever desirable
7068 (it's impossible to call such a function with type-
7069 correct arguments). An anonymous union parm type is
7070 meaningful as a GNU extension, so don't warn for that. */
7071 if (TREE_CODE (decl) != UNION_TYPE || b->id != 0)
7074 /* The %s will be one of 'struct', 'union', or 'enum'. */
7075 warning (0, "%<%s %E%> declared inside parameter list",
7078 /* The %s will be one of 'struct', 'union', or 'enum'. */
7079 warning (0, "anonymous %s declared inside parameter list",
7082 if (!explained_incomplete_types)
7084 warning (0, "its scope is only this definition or declaration,"
7085 " which is probably not what you want");
7086 explained_incomplete_types = true;
7092 vec_safe_push (tags, tag);
7098 /* CONST_DECLs appear here when we have an embedded enum,
7099 and TYPE_DECLs appear here when we have an embedded struct
7100 or union. No warnings for this - we already warned about the
7101 type itself. FUNCTION_DECLs appear when there is an implicit
7102 function declaration in the parameter list. */
7104 /* When we reinsert this decl in the function body, we need
7105 to reconstruct whether it was marked as nested. */
7106 gcc_assert (TREE_CODE (decl) == FUNCTION_DECL
7109 DECL_CHAIN (decl) = others;
7114 /* error_mark_node appears here when we have an undeclared
7115 variable. Just throw it away. */
7118 gcc_assert (I_SYMBOL_BINDING (b->id) == b);
7119 I_SYMBOL_BINDING (b->id) = b->shadowed;
7123 /* Other things that might be encountered. */
7130 b = free_binding_and_advance (b);
7133 arg_info->parms = parms;
7134 arg_info->tags = tags;
7135 arg_info->types = types;
7136 arg_info->others = others;
7137 arg_info->pending_sizes = expr;
7141 /* Get the struct, enum or union (CODE says which) with tag NAME.
7142 Define the tag as a forward-reference with location LOC if it is
7143 not defined. Return a c_typespec structure for the type
7147 parser_xref_tag (location_t loc, enum tree_code code, tree name)
7149 struct c_typespec ret;
7153 ret.expr = NULL_TREE;
7154 ret.expr_const_operands = true;
7156 /* If a cross reference is requested, look up the type
7157 already defined for this tag and return it. */
7159 ref = lookup_tag (code, name, 0, &refloc);
7160 /* If this is the right type of tag, return what we found.
7161 (This reference will be shadowed by shadow_tag later if appropriate.)
7162 If this is the wrong type of tag, do not return it. If it was the
7163 wrong type in the same scope, we will have had an error
7164 message already; if in a different scope and declaring
7165 a name, pending_xref_error will give an error message; but if in a
7166 different scope and not declaring a name, this tag should
7167 shadow the previous declaration of a different type of tag, and
7168 this would not work properly if we return the reference found.
7169 (For example, with "struct foo" in an outer scope, "union foo;"
7170 must shadow that tag with a new one of union type.) */
7171 ret.kind = (ref ? ctsk_tagref : ctsk_tagfirstref);
7172 if (ref && TREE_CODE (ref) == code)
7174 if (C_TYPE_DEFINED_IN_STRUCT (ref)
7175 && loc != UNKNOWN_LOCATION
7181 warning_at (loc, OPT_Wc___compat,
7182 ("enum type defined in struct or union "
7183 "is not visible in C++"));
7184 inform (refloc, "enum type defined here");
7187 warning_at (loc, OPT_Wc___compat,
7188 ("struct defined in struct or union "
7189 "is not visible in C++"));
7190 inform (refloc, "struct defined here");
7193 warning_at (loc, OPT_Wc___compat,
7194 ("union defined in struct or union "
7195 "is not visible in C++"));
7196 inform (refloc, "union defined here");
7207 /* If no such tag is yet defined, create a forward-reference node
7208 and record it as the "definition".
7209 When a real declaration of this type is found,
7210 the forward-reference will be altered into a real type. */
7212 ref = make_node (code);
7213 if (code == ENUMERAL_TYPE)
7215 /* Give the type a default layout like unsigned int
7216 to avoid crashing if it does not get defined. */
7217 SET_TYPE_MODE (ref, TYPE_MODE (unsigned_type_node));
7218 TYPE_ALIGN (ref) = TYPE_ALIGN (unsigned_type_node);
7219 TYPE_USER_ALIGN (ref) = 0;
7220 TYPE_UNSIGNED (ref) = 1;
7221 TYPE_PRECISION (ref) = TYPE_PRECISION (unsigned_type_node);
7222 TYPE_MIN_VALUE (ref) = TYPE_MIN_VALUE (unsigned_type_node);
7223 TYPE_MAX_VALUE (ref) = TYPE_MAX_VALUE (unsigned_type_node);
7226 pushtag (loc, name, ref);
7232 /* Get the struct, enum or union (CODE says which) with tag NAME.
7233 Define the tag as a forward-reference if it is not defined.
7234 Return a tree for the type. */
7237 xref_tag (enum tree_code code, tree name)
7239 return parser_xref_tag (input_location, code, name).spec;
7242 /* Make sure that the tag NAME is defined *in the current scope*
7243 at least as a forward reference.
7244 LOC is the location of the struct's definition.
7245 CODE says which kind of tag NAME ought to be.
7247 This stores the current value of the file static STRUCT_PARSE_INFO
7248 in *ENCLOSING_STRUCT_PARSE_INFO, and points STRUCT_PARSE_INFO at a
7249 new c_struct_parse_info structure. The old value of
7250 STRUCT_PARSE_INFO is restored in finish_struct. */
7253 start_struct (location_t loc, enum tree_code code, tree name,
7254 struct c_struct_parse_info **enclosing_struct_parse_info)
7256 /* If there is already a tag defined at this scope
7257 (as a forward reference), just return it. */
7259 tree ref = NULL_TREE;
7260 location_t refloc = UNKNOWN_LOCATION;
7262 if (name != NULL_TREE)
7263 ref = lookup_tag (code, name, 1, &refloc);
7264 if (ref && TREE_CODE (ref) == code)
7266 if (TYPE_SIZE (ref))
7268 if (code == UNION_TYPE)
7269 error_at (loc, "redefinition of %<union %E%>", name);
7271 error_at (loc, "redefinition of %<struct %E%>", name);
7272 if (refloc != UNKNOWN_LOCATION)
7273 inform (refloc, "originally defined here");
7274 /* Don't create structures using a name already in use. */
7277 else if (C_TYPE_BEING_DEFINED (ref))
7279 if (code == UNION_TYPE)
7280 error_at (loc, "nested redefinition of %<union %E%>", name);
7282 error_at (loc, "nested redefinition of %<struct %E%>", name);
7283 /* Don't bother to report "originally defined here" for a
7284 nested redefinition; the original definition should be
7286 /* Don't create structures that contain themselves. */
7291 /* Otherwise create a forward-reference just so the tag is in scope. */
7293 if (ref == NULL_TREE || TREE_CODE (ref) != code)
7295 ref = make_node (code);
7296 pushtag (loc, name, ref);
7299 C_TYPE_BEING_DEFINED (ref) = 1;
7300 TYPE_PACKED (ref) = flag_pack_struct;
7302 *enclosing_struct_parse_info = struct_parse_info;
7303 struct_parse_info = XNEW (struct c_struct_parse_info);
7304 struct_parse_info->struct_types.create (0);
7305 struct_parse_info->fields.create (0);
7306 struct_parse_info->typedefs_seen.create (0);
7308 /* FIXME: This will issue a warning for a use of a type defined
7309 within a statement expr used within sizeof, et. al. This is not
7310 terribly serious as C++ doesn't permit statement exprs within
7312 if (warn_cxx_compat && (in_sizeof || in_typeof || in_alignof))
7313 warning_at (loc, OPT_Wc___compat,
7314 "defining type in %qs expression is invalid in C++",
7317 : (in_typeof ? "typeof" : "alignof")));
7322 /* Process the specs, declarator and width (NULL if omitted)
7323 of a structure component, returning a FIELD_DECL node.
7324 WIDTH is non-NULL for bit-fields only, and is an INTEGER_CST node.
7325 DECL_ATTRS is as for grokdeclarator.
7327 LOC is the location of the structure component.
7329 This is done during the parsing of the struct declaration.
7330 The FIELD_DECL nodes are chained together and the lot of them
7331 are ultimately passed to `build_struct' to make the RECORD_TYPE node. */
7334 grokfield (location_t loc,
7335 struct c_declarator *declarator, struct c_declspecs *declspecs,
7336 tree width, tree *decl_attrs)
7340 if (declarator->kind == cdk_id && declarator->u.id == NULL_TREE
7341 && width == NULL_TREE)
7343 /* This is an unnamed decl.
7345 If we have something of the form "union { list } ;" then this
7346 is the anonymous union extension. Similarly for struct.
7348 If this is something of the form "struct foo;", then
7349 If MS or Plan 9 extensions are enabled, this is handled as
7350 an anonymous struct.
7351 Otherwise this is a forward declaration of a structure tag.
7353 If this is something of the form "foo;" and foo is a TYPE_DECL, then
7354 If foo names a structure or union without a tag, then this
7355 is an anonymous struct (this is permitted by C11).
7356 If MS or Plan 9 extensions are enabled and foo names a
7357 structure, then again this is an anonymous struct.
7358 Otherwise this is an error.
7360 Oh what a horrid tangled web we weave. I wonder if MS consciously
7361 took this from Plan 9 or if it was an accident of implementation
7362 that took root before someone noticed the bug... */
7364 tree type = declspecs->type;
7365 bool type_ok = (TREE_CODE (type) == RECORD_TYPE
7366 || TREE_CODE (type) == UNION_TYPE);
7370 && (flag_ms_extensions
7371 || flag_plan9_extensions
7372 || !declspecs->typedef_p))
7374 if (flag_ms_extensions || flag_plan9_extensions)
7376 else if (TYPE_NAME (type) == NULL)
7383 pedwarn (loc, 0, "declaration does not declare anything");
7387 pedwarn_c99 (loc, OPT_Wpedantic,
7388 "ISO C99 doesn%'t support unnamed structs/unions");
7390 pedwarn_c99 (loc, OPT_Wpedantic,
7391 "ISO C90 doesn%'t support unnamed structs/unions");
7394 value = grokdeclarator (declarator, declspecs, FIELD, false,
7395 width ? &width : NULL, decl_attrs, NULL, NULL,
7398 finish_decl (value, loc, NULL_TREE, NULL_TREE, NULL_TREE);
7399 DECL_INITIAL (value) = width;
7401 if (warn_cxx_compat && DECL_NAME (value) != NULL_TREE)
7403 /* If we currently have a binding for this field, set the
7404 in_struct field in the binding, so that we warn about lookups
7406 struct c_binding *b = I_SYMBOL_BINDING (DECL_NAME (value));
7409 /* If the in_struct field is not yet set, push it on a list
7410 to be cleared when this struct is finished. */
7413 struct_parse_info->fields.safe_push (b);
7422 /* Subroutine of detect_field_duplicates: return whether X and Y,
7423 which are both fields in the same struct, have duplicate field
7427 is_duplicate_field (tree x, tree y)
7429 if (DECL_NAME (x) != NULL_TREE && DECL_NAME (x) == DECL_NAME (y))
7432 /* When using -fplan9-extensions, an anonymous field whose name is a
7433 typedef can duplicate a field name. */
7434 if (flag_plan9_extensions
7435 && (DECL_NAME (x) == NULL_TREE || DECL_NAME (y) == NULL_TREE))
7437 tree xt, xn, yt, yn;
7440 if (DECL_NAME (x) != NULL_TREE)
7442 else if ((TREE_CODE (xt) == RECORD_TYPE || TREE_CODE (xt) == UNION_TYPE)
7443 && TYPE_NAME (xt) != NULL_TREE
7444 && TREE_CODE (TYPE_NAME (xt)) == TYPE_DECL)
7445 xn = DECL_NAME (TYPE_NAME (xt));
7450 if (DECL_NAME (y) != NULL_TREE)
7452 else if ((TREE_CODE (yt) == RECORD_TYPE || TREE_CODE (yt) == UNION_TYPE)
7453 && TYPE_NAME (yt) != NULL_TREE
7454 && TREE_CODE (TYPE_NAME (yt)) == TYPE_DECL)
7455 yn = DECL_NAME (TYPE_NAME (yt));
7459 if (xn != NULL_TREE && xn == yn)
7466 /* Subroutine of detect_field_duplicates: add the fields of FIELDLIST
7467 to HTAB, giving errors for any duplicates. */
7470 detect_field_duplicates_hash (tree fieldlist,
7471 hash_table<pointer_hash <tree_node> > *htab)
7476 for (x = fieldlist; x ; x = DECL_CHAIN (x))
7477 if ((y = DECL_NAME (x)) != 0)
7479 slot = htab->find_slot (y, INSERT);
7482 error ("duplicate member %q+D", x);
7483 DECL_NAME (x) = NULL_TREE;
7487 else if (TREE_CODE (TREE_TYPE (x)) == RECORD_TYPE
7488 || TREE_CODE (TREE_TYPE (x)) == UNION_TYPE)
7490 detect_field_duplicates_hash (TYPE_FIELDS (TREE_TYPE (x)), htab);
7492 /* When using -fplan9-extensions, an anonymous field whose
7493 name is a typedef can duplicate a field name. */
7494 if (flag_plan9_extensions
7495 && TYPE_NAME (TREE_TYPE (x)) != NULL_TREE
7496 && TREE_CODE (TYPE_NAME (TREE_TYPE (x))) == TYPE_DECL)
7498 tree xn = DECL_NAME (TYPE_NAME (TREE_TYPE (x)));
7499 slot = htab->find_slot (xn, INSERT);
7501 error ("duplicate member %q+D", TYPE_NAME (TREE_TYPE (x)));
7507 /* Generate an error for any duplicate field names in FIELDLIST. Munge
7508 the list such that this does not present a problem later. */
7511 detect_field_duplicates (tree fieldlist)
7516 /* If the struct is the list of instance variables of an Objective-C
7517 class, then we need to check all the instance variables of
7518 superclasses when checking for duplicates (since you can't have
7519 an instance variable in a subclass with the same name as an
7520 instance variable in a superclass). We pass on this job to the
7521 Objective-C compiler. objc_detect_field_duplicates() will return
7522 false if we are not checking the list of instance variables and
7523 the C frontend should proceed with the standard field duplicate
7524 checks. If we are checking the list of instance variables, the
7525 ObjC frontend will do the check, emit the errors if needed, and
7526 then return true. */
7527 if (c_dialect_objc ())
7528 if (objc_detect_field_duplicates (false))
7531 /* First, see if there are more than "a few" fields.
7532 This is trivially true if there are zero or one fields. */
7533 if (!fieldlist || !DECL_CHAIN (fieldlist))
7538 if (DECL_NAME (x) == NULL_TREE
7539 && (TREE_CODE (TREE_TYPE (x)) == RECORD_TYPE
7540 || TREE_CODE (TREE_TYPE (x)) == UNION_TYPE))
7543 } while (timeout > 0 && x);
7545 /* If there were "few" fields and no anonymous structures or unions,
7546 avoid the overhead of allocating a hash table. Instead just do
7547 the nested traversal thing. */
7550 for (x = DECL_CHAIN (fieldlist); x; x = DECL_CHAIN (x))
7551 /* When using -fplan9-extensions, we can have duplicates
7552 between typedef names and fields. */
7554 || (flag_plan9_extensions
7555 && DECL_NAME (x) == NULL_TREE
7556 && (TREE_CODE (TREE_TYPE (x)) == RECORD_TYPE
7557 || TREE_CODE (TREE_TYPE (x)) == UNION_TYPE)
7558 && TYPE_NAME (TREE_TYPE (x)) != NULL_TREE
7559 && TREE_CODE (TYPE_NAME (TREE_TYPE (x))) == TYPE_DECL))
7561 for (y = fieldlist; y != x; y = TREE_CHAIN (y))
7562 if (is_duplicate_field (y, x))
7564 error ("duplicate member %q+D", x);
7565 DECL_NAME (x) = NULL_TREE;
7571 hash_table<pointer_hash <tree_node> > htab (37);
7572 detect_field_duplicates_hash (fieldlist, &htab);
7576 /* Finish up struct info used by -Wc++-compat. */
7579 warn_cxx_compat_finish_struct (tree fieldlist)
7583 struct c_binding *b;
7585 /* Set the C_TYPE_DEFINED_IN_STRUCT flag for each type defined in
7586 the current struct. We do this now at the end of the struct
7587 because the flag is used to issue visibility warnings, and we
7588 only want to issue those warnings if the type is referenced
7589 outside of the struct declaration. */
7590 FOR_EACH_VEC_ELT (struct_parse_info->struct_types, ix, x)
7591 C_TYPE_DEFINED_IN_STRUCT (x) = 1;
7593 /* The TYPEDEFS_SEEN field of STRUCT_PARSE_INFO is a list of
7594 typedefs used when declaring fields in this struct. If the name
7595 of any of the fields is also a typedef name then the struct would
7596 not parse in C++, because the C++ lookup rules say that the
7597 typedef name would be looked up in the context of the struct, and
7598 would thus be the field rather than the typedef. */
7599 if (!struct_parse_info->typedefs_seen.is_empty ()
7600 && fieldlist != NULL_TREE)
7602 /* Use a hash_set<tree> using the name of the typedef. We can use
7603 a hash_set<tree> because identifiers are interned. */
7604 hash_set<tree> tset;
7606 FOR_EACH_VEC_ELT (struct_parse_info->typedefs_seen, ix, x)
7607 tset.add (DECL_NAME (x));
7609 for (x = fieldlist; x != NULL_TREE; x = DECL_CHAIN (x))
7611 if (DECL_NAME (x) != NULL_TREE
7612 && tset.contains (DECL_NAME (x)))
7614 warning_at (DECL_SOURCE_LOCATION (x), OPT_Wc___compat,
7615 ("using %qD as both field and typedef name is "
7618 /* FIXME: It would be nice to report the location where
7619 the typedef name is used. */
7624 /* For each field which has a binding and which was not defined in
7625 an enclosing struct, clear the in_struct field. */
7626 FOR_EACH_VEC_ELT (struct_parse_info->fields, ix, b)
7630 /* Fill in the fields of a RECORD_TYPE or UNION_TYPE node, T.
7631 LOC is the location of the RECORD_TYPE or UNION_TYPE's definition.
7632 FIELDLIST is a chain of FIELD_DECL nodes for the fields.
7633 ATTRIBUTES are attributes to be applied to the structure.
7635 ENCLOSING_STRUCT_PARSE_INFO is the value of STRUCT_PARSE_INFO when
7636 the struct was started. */
7639 finish_struct (location_t loc, tree t, tree fieldlist, tree attributes,
7640 struct c_struct_parse_info *enclosing_struct_parse_info)
7643 bool toplevel = file_scope == current_scope;
7644 int saw_named_field;
7646 /* If this type was previously laid out as a forward reference,
7647 make sure we lay it out again. */
7651 decl_attributes (&t, attributes, (int) ATTR_FLAG_TYPE_IN_PLACE);
7655 for (x = fieldlist; x; x = DECL_CHAIN (x))
7657 if (DECL_NAME (x) != 0)
7660 && (TREE_CODE (TREE_TYPE (x)) == RECORD_TYPE
7661 || TREE_CODE (TREE_TYPE (x)) == UNION_TYPE))
7667 if (TREE_CODE (t) == UNION_TYPE)
7670 pedwarn (loc, OPT_Wpedantic, "union has no named members");
7672 pedwarn (loc, OPT_Wpedantic, "union has no members");
7677 pedwarn (loc, OPT_Wpedantic, "struct has no named members");
7679 pedwarn (loc, OPT_Wpedantic, "struct has no members");
7684 /* Install struct as DECL_CONTEXT of each field decl.
7685 Also process specified field sizes, found in the DECL_INITIAL,
7686 storing 0 there after the type has been changed to precision equal
7687 to its width, rather than the precision of the specified standard
7688 type. (Correct layout requires the original type to have been preserved
7691 saw_named_field = 0;
7692 for (x = fieldlist; x; x = DECL_CHAIN (x))
7694 if (TREE_TYPE (x) == error_mark_node)
7697 DECL_CONTEXT (x) = t;
7699 /* If any field is const, the structure type is pseudo-const. */
7700 if (TREE_READONLY (x))
7701 C_TYPE_FIELDS_READONLY (t) = 1;
7704 /* A field that is pseudo-const makes the structure likewise. */
7705 tree t1 = strip_array_types (TREE_TYPE (x));
7706 if ((TREE_CODE (t1) == RECORD_TYPE || TREE_CODE (t1) == UNION_TYPE)
7707 && C_TYPE_FIELDS_READONLY (t1))
7708 C_TYPE_FIELDS_READONLY (t) = 1;
7711 /* Any field that is volatile means variables of this type must be
7712 treated in some ways as volatile. */
7713 if (TREE_THIS_VOLATILE (x))
7714 C_TYPE_FIELDS_VOLATILE (t) = 1;
7716 /* Any field of nominal variable size implies structure is too. */
7717 if (C_DECL_VARIABLE_SIZE (x))
7718 C_TYPE_VARIABLE_SIZE (t) = 1;
7720 if (DECL_INITIAL (x))
7722 unsigned HOST_WIDE_INT width = tree_to_uhwi (DECL_INITIAL (x));
7723 DECL_SIZE (x) = bitsize_int (width);
7724 DECL_BIT_FIELD (x) = 1;
7725 SET_DECL_C_BIT_FIELD (x);
7729 && (DECL_BIT_FIELD (x)
7730 || TYPE_ALIGN (TREE_TYPE (x)) > BITS_PER_UNIT))
7731 DECL_PACKED (x) = 1;
7733 /* Detect flexible array member in an invalid context. */
7734 if (TREE_CODE (TREE_TYPE (x)) == ARRAY_TYPE
7735 && TYPE_SIZE (TREE_TYPE (x)) == NULL_TREE
7736 && TYPE_DOMAIN (TREE_TYPE (x)) != NULL_TREE
7737 && TYPE_MAX_VALUE (TYPE_DOMAIN (TREE_TYPE (x))) == NULL_TREE)
7739 if (TREE_CODE (t) == UNION_TYPE)
7741 error_at (DECL_SOURCE_LOCATION (x),
7742 "flexible array member in union");
7743 TREE_TYPE (x) = error_mark_node;
7745 else if (DECL_CHAIN (x) != NULL_TREE)
7747 error_at (DECL_SOURCE_LOCATION (x),
7748 "flexible array member not at end of struct");
7749 TREE_TYPE (x) = error_mark_node;
7751 else if (!saw_named_field)
7753 error_at (DECL_SOURCE_LOCATION (x),
7754 "flexible array member in otherwise empty struct");
7755 TREE_TYPE (x) = error_mark_node;
7759 if (pedantic && TREE_CODE (t) == RECORD_TYPE
7760 && flexible_array_type_p (TREE_TYPE (x)))
7761 pedwarn (DECL_SOURCE_LOCATION (x), OPT_Wpedantic,
7762 "invalid use of structure with flexible array member");
7765 || TREE_CODE (TREE_TYPE (x)) == RECORD_TYPE
7766 || TREE_CODE (TREE_TYPE (x)) == UNION_TYPE)
7767 saw_named_field = 1;
7770 detect_field_duplicates (fieldlist);
7772 /* Now we have the nearly final fieldlist. Record it,
7773 then lay out the structure or union (including the fields). */
7775 TYPE_FIELDS (t) = fieldlist;
7779 if (TYPE_SIZE_UNIT (t)
7780 && TREE_CODE (TYPE_SIZE_UNIT (t)) == INTEGER_CST
7781 && !TREE_OVERFLOW (TYPE_SIZE_UNIT (t))
7782 && !valid_constant_size_p (TYPE_SIZE_UNIT (t)))
7783 error ("type %qT is too large", t);
7785 /* Give bit-fields their proper types. */
7787 tree *fieldlistp = &fieldlist;
7789 if (TREE_CODE (*fieldlistp) == FIELD_DECL && DECL_INITIAL (*fieldlistp)
7790 && TREE_TYPE (*fieldlistp) != error_mark_node)
7792 unsigned HOST_WIDE_INT width
7793 = tree_to_uhwi (DECL_INITIAL (*fieldlistp));
7794 tree type = TREE_TYPE (*fieldlistp);
7795 if (width != TYPE_PRECISION (type))
7797 TREE_TYPE (*fieldlistp)
7798 = c_build_bitfield_integer_type (width, TYPE_UNSIGNED (type));
7799 DECL_MODE (*fieldlistp) = TYPE_MODE (TREE_TYPE (*fieldlistp));
7801 DECL_INITIAL (*fieldlistp) = 0;
7804 fieldlistp = &DECL_CHAIN (*fieldlistp);
7807 /* Now we have the truly final field list.
7808 Store it in this type and in the variants. */
7810 TYPE_FIELDS (t) = fieldlist;
7812 /* If there are lots of fields, sort so we can look through them fast.
7813 We arbitrarily consider 16 or more elts to be "a lot". */
7818 for (x = fieldlist; x; x = DECL_CHAIN (x))
7820 if (len > 15 || DECL_NAME (x) == NULL)
7828 struct lang_type *space;
7829 struct sorted_fields_type *space2;
7831 len += list_length (x);
7833 /* Use the same allocation policy here that make_node uses, to
7834 ensure that this lives as long as the rest of the struct decl.
7835 All decls in an inline function need to be saved. */
7837 space = ggc_cleared_alloc<struct lang_type> ();
7838 space2 = (sorted_fields_type *) ggc_internal_alloc
7839 (sizeof (struct sorted_fields_type) + len * sizeof (tree));
7843 field_array = &space2->elts[0];
7844 for (x = fieldlist; x; x = DECL_CHAIN (x))
7846 field_array[len++] = x;
7848 /* If there is anonymous struct or union, break out of the loop. */
7849 if (DECL_NAME (x) == NULL)
7852 /* Found no anonymous struct/union. Add the TYPE_LANG_SPECIFIC. */
7855 TYPE_LANG_SPECIFIC (t) = space;
7856 TYPE_LANG_SPECIFIC (t)->s->len = len;
7857 field_array = TYPE_LANG_SPECIFIC (t)->s->elts;
7858 qsort (field_array, len, sizeof (tree), field_decl_cmp);
7863 for (x = TYPE_MAIN_VARIANT (t); x; x = TYPE_NEXT_VARIANT (x))
7865 TYPE_FIELDS (x) = TYPE_FIELDS (t);
7866 TYPE_LANG_SPECIFIC (x) = TYPE_LANG_SPECIFIC (t);
7867 C_TYPE_FIELDS_READONLY (x) = C_TYPE_FIELDS_READONLY (t);
7868 C_TYPE_FIELDS_VOLATILE (x) = C_TYPE_FIELDS_VOLATILE (t);
7869 C_TYPE_VARIABLE_SIZE (x) = C_TYPE_VARIABLE_SIZE (t);
7872 /* If this was supposed to be a transparent union, but we can't
7873 make it one, warn and turn off the flag. */
7874 if (TREE_CODE (t) == UNION_TYPE
7875 && TYPE_TRANSPARENT_AGGR (t)
7876 && (!TYPE_FIELDS (t) || TYPE_MODE (t) != DECL_MODE (TYPE_FIELDS (t))))
7878 TYPE_TRANSPARENT_AGGR (t) = 0;
7879 warning_at (loc, 0, "union cannot be made transparent");
7882 /* If this structure or union completes the type of any previous
7883 variable declaration, lay it out and output its rtl. */
7884 for (x = C_TYPE_INCOMPLETE_VARS (TYPE_MAIN_VARIANT (t));
7888 tree decl = TREE_VALUE (x);
7889 if (TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE)
7890 layout_array_type (TREE_TYPE (decl));
7891 if (TREE_CODE (decl) != TYPE_DECL)
7893 layout_decl (decl, 0);
7894 if (c_dialect_objc ())
7895 objc_check_decl (decl);
7896 rest_of_decl_compilation (decl, toplevel, 0);
7899 C_TYPE_INCOMPLETE_VARS (TYPE_MAIN_VARIANT (t)) = 0;
7901 /* Update type location to the one of the definition, instead of e.g.
7902 a forward declaration. */
7903 if (TYPE_STUB_DECL (t))
7904 DECL_SOURCE_LOCATION (TYPE_STUB_DECL (t)) = loc;
7906 /* Finish debugging output for this type. */
7907 rest_of_type_compilation (t, toplevel);
7909 /* If we're inside a function proper, i.e. not file-scope and not still
7910 parsing parameters, then arrange for the size of a variable sized type
7912 if (building_stmt_list_p () && variably_modified_type_p (t, NULL_TREE))
7913 add_stmt (build_stmt (loc,
7914 DECL_EXPR, build_decl (loc, TYPE_DECL, NULL, t)));
7916 if (warn_cxx_compat)
7917 warn_cxx_compat_finish_struct (fieldlist);
7919 struct_parse_info->struct_types.release ();
7920 struct_parse_info->fields.release ();
7921 struct_parse_info->typedefs_seen.release ();
7922 XDELETE (struct_parse_info);
7924 struct_parse_info = enclosing_struct_parse_info;
7926 /* If this struct is defined inside a struct, add it to
7929 && struct_parse_info != NULL
7930 && !in_sizeof && !in_typeof && !in_alignof)
7931 struct_parse_info->struct_types.safe_push (t);
7936 /* Lay out the type T, and its element type, and so on. */
7939 layout_array_type (tree t)
7941 if (TREE_CODE (TREE_TYPE (t)) == ARRAY_TYPE)
7942 layout_array_type (TREE_TYPE (t));
7946 /* Begin compiling the definition of an enumeration type.
7947 NAME is its name (or null if anonymous).
7948 LOC is the enum's location.
7949 Returns the type object, as yet incomplete.
7950 Also records info about it so that build_enumerator
7951 may be used to declare the individual values as they are read. */
7954 start_enum (location_t loc, struct c_enum_contents *the_enum, tree name)
7956 tree enumtype = NULL_TREE;
7957 location_t enumloc = UNKNOWN_LOCATION;
7959 /* If this is the real definition for a previous forward reference,
7960 fill in the contents in the same object that used to be the
7961 forward reference. */
7963 if (name != NULL_TREE)
7964 enumtype = lookup_tag (ENUMERAL_TYPE, name, 1, &enumloc);
7966 if (enumtype == 0 || TREE_CODE (enumtype) != ENUMERAL_TYPE)
7968 enumtype = make_node (ENUMERAL_TYPE);
7969 pushtag (loc, name, enumtype);
7972 if (C_TYPE_BEING_DEFINED (enumtype))
7973 error_at (loc, "nested redefinition of %<enum %E%>", name);
7975 C_TYPE_BEING_DEFINED (enumtype) = 1;
7977 if (TYPE_VALUES (enumtype) != 0)
7979 /* This enum is a named one that has been declared already. */
7980 error_at (loc, "redeclaration of %<enum %E%>", name);
7981 if (enumloc != UNKNOWN_LOCATION)
7982 inform (enumloc, "originally defined here");
7984 /* Completely replace its old definition.
7985 The old enumerators remain defined, however. */
7986 TYPE_VALUES (enumtype) = 0;
7989 the_enum->enum_next_value = integer_zero_node;
7990 the_enum->enum_overflow = 0;
7992 if (flag_short_enums)
7993 TYPE_PACKED (enumtype) = 1;
7995 /* FIXME: This will issue a warning for a use of a type defined
7996 within sizeof in a statement expr. This is not terribly serious
7997 as C++ doesn't permit statement exprs within sizeof anyhow. */
7998 if (warn_cxx_compat && (in_sizeof || in_typeof || in_alignof))
7999 warning_at (loc, OPT_Wc___compat,
8000 "defining type in %qs expression is invalid in C++",
8003 : (in_typeof ? "typeof" : "alignof")));
8008 /* After processing and defining all the values of an enumeration type,
8009 install their decls in the enumeration type and finish it off.
8010 ENUMTYPE is the type object, VALUES a list of decl-value pairs,
8011 and ATTRIBUTES are the specified attributes.
8012 Returns ENUMTYPE. */
8015 finish_enum (tree enumtype, tree values, tree attributes)
8018 tree minnode = 0, maxnode = 0;
8021 bool toplevel = (file_scope == current_scope);
8022 struct lang_type *lt;
8024 decl_attributes (&enumtype, attributes, (int) ATTR_FLAG_TYPE_IN_PLACE);
8026 /* Calculate the maximum value of any enumerator in this type. */
8028 if (values == error_mark_node)
8029 minnode = maxnode = integer_zero_node;
8032 minnode = maxnode = TREE_VALUE (values);
8033 for (pair = TREE_CHAIN (values); pair; pair = TREE_CHAIN (pair))
8035 tree value = TREE_VALUE (pair);
8036 if (tree_int_cst_lt (maxnode, value))
8038 if (tree_int_cst_lt (value, minnode))
8043 /* Construct the final type of this enumeration. It is the same
8044 as one of the integral types - the narrowest one that fits, except
8045 that normally we only go as narrow as int - and signed iff any of
8046 the values are negative. */
8047 sign = (tree_int_cst_sgn (minnode) >= 0) ? UNSIGNED : SIGNED;
8048 precision = MAX (tree_int_cst_min_precision (minnode, sign),
8049 tree_int_cst_min_precision (maxnode, sign));
8051 /* If the precision of the type was specified with an attribute and it
8052 was too small, give an error. Otherwise, use it. */
8053 if (TYPE_PRECISION (enumtype))
8055 if (precision > TYPE_PRECISION (enumtype))
8057 TYPE_PRECISION (enumtype) = 0;
8058 error ("specified mode too small for enumeral values");
8061 precision = TYPE_PRECISION (enumtype);
8064 if (TYPE_PACKED (enumtype)
8065 || precision > TYPE_PRECISION (integer_type_node)
8066 || TYPE_PRECISION (enumtype))
8068 tem = c_common_type_for_size (precision, sign == UNSIGNED ? 1 : 0);
8071 warning (0, "enumeration values exceed range of largest integer");
8072 tem = long_long_integer_type_node;
8076 tem = sign == UNSIGNED ? unsigned_type_node : integer_type_node;
8078 TYPE_MIN_VALUE (enumtype) = TYPE_MIN_VALUE (tem);
8079 TYPE_MAX_VALUE (enumtype) = TYPE_MAX_VALUE (tem);
8080 TYPE_UNSIGNED (enumtype) = TYPE_UNSIGNED (tem);
8081 TYPE_SIZE (enumtype) = 0;
8082 TYPE_PRECISION (enumtype) = TYPE_PRECISION (tem);
8084 layout_type (enumtype);
8086 if (values != error_mark_node)
8088 /* Change the type of the enumerators to be the enum type. We
8089 need to do this irrespective of the size of the enum, for
8090 proper type checking. Replace the DECL_INITIALs of the
8091 enumerators, and the value slots of the list, with copies
8092 that have the enum type; they cannot be modified in place
8093 because they may be shared (e.g. integer_zero_node) Finally,
8094 change the purpose slots to point to the names of the decls. */
8095 for (pair = values; pair; pair = TREE_CHAIN (pair))
8097 tree enu = TREE_PURPOSE (pair);
8098 tree ini = DECL_INITIAL (enu);
8100 TREE_TYPE (enu) = enumtype;
8102 /* The ISO C Standard mandates enumerators to have type int,
8103 even though the underlying type of an enum type is
8104 unspecified. However, GCC allows enumerators of any
8105 integer type as an extensions. build_enumerator()
8106 converts any enumerators that fit in an int to type int,
8107 to avoid promotions to unsigned types when comparing
8108 integers with enumerators that fit in the int range.
8109 When -pedantic is given, build_enumerator() would have
8110 already warned about those that don't fit. Here we
8111 convert the rest to the enumerator type. */
8112 if (TREE_TYPE (ini) != integer_type_node)
8113 ini = convert (enumtype, ini);
8115 DECL_INITIAL (enu) = ini;
8116 TREE_PURPOSE (pair) = DECL_NAME (enu);
8117 TREE_VALUE (pair) = ini;
8120 TYPE_VALUES (enumtype) = values;
8123 /* Record the min/max values so that we can warn about bit-field
8124 enumerations that are too small for the values. */
8125 lt = ggc_cleared_alloc<struct lang_type> ();
8126 lt->enum_min = minnode;
8127 lt->enum_max = maxnode;
8128 TYPE_LANG_SPECIFIC (enumtype) = lt;
8130 /* Fix up all variant types of this enum type. */
8131 for (tem = TYPE_MAIN_VARIANT (enumtype); tem; tem = TYPE_NEXT_VARIANT (tem))
8133 if (tem == enumtype)
8135 TYPE_VALUES (tem) = TYPE_VALUES (enumtype);
8136 TYPE_MIN_VALUE (tem) = TYPE_MIN_VALUE (enumtype);
8137 TYPE_MAX_VALUE (tem) = TYPE_MAX_VALUE (enumtype);
8138 TYPE_SIZE (tem) = TYPE_SIZE (enumtype);
8139 TYPE_SIZE_UNIT (tem) = TYPE_SIZE_UNIT (enumtype);
8140 SET_TYPE_MODE (tem, TYPE_MODE (enumtype));
8141 TYPE_PRECISION (tem) = TYPE_PRECISION (enumtype);
8142 TYPE_ALIGN (tem) = TYPE_ALIGN (enumtype);
8143 TYPE_USER_ALIGN (tem) = TYPE_USER_ALIGN (enumtype);
8144 TYPE_UNSIGNED (tem) = TYPE_UNSIGNED (enumtype);
8145 TYPE_LANG_SPECIFIC (tem) = TYPE_LANG_SPECIFIC (enumtype);
8148 /* Finish debugging output for this type. */
8149 rest_of_type_compilation (enumtype, toplevel);
8151 /* If this enum is defined inside a struct, add it to
8154 && struct_parse_info != NULL
8155 && !in_sizeof && !in_typeof && !in_alignof)
8156 struct_parse_info->struct_types.safe_push (enumtype);
8161 /* Build and install a CONST_DECL for one value of the
8162 current enumeration type (one that was begun with start_enum).
8163 DECL_LOC is the location of the enumerator.
8164 LOC is the location of the '=' operator if any, DECL_LOC otherwise.
8165 Return a tree-list containing the CONST_DECL and its value.
8166 Assignment of sequential values by default is handled here. */
8169 build_enumerator (location_t decl_loc, location_t loc,
8170 struct c_enum_contents *the_enum, tree name, tree value)
8174 /* Validate and default VALUE. */
8178 /* Don't issue more errors for error_mark_node (i.e. an
8179 undeclared identifier) - just ignore the value expression. */
8180 if (value == error_mark_node)
8182 else if (!INTEGRAL_TYPE_P (TREE_TYPE (value)))
8184 error_at (loc, "enumerator value for %qE is not an integer constant",
8190 if (TREE_CODE (value) != INTEGER_CST)
8192 value = c_fully_fold (value, false, NULL);
8193 if (TREE_CODE (value) == INTEGER_CST)
8194 pedwarn (loc, OPT_Wpedantic,
8195 "enumerator value for %qE is not an integer "
8196 "constant expression", name);
8198 if (TREE_CODE (value) != INTEGER_CST)
8200 error ("enumerator value for %qE is not an integer constant",
8206 value = default_conversion (value);
8207 constant_expression_warning (value);
8212 /* Default based on previous value. */
8213 /* It should no longer be possible to have NON_LVALUE_EXPR
8217 value = the_enum->enum_next_value;
8218 if (the_enum->enum_overflow)
8219 error_at (loc, "overflow in enumeration values");
8221 /* Even though the underlying type of an enum is unspecified, the
8222 type of enumeration constants is explicitly defined as int
8223 (6.4.4.3/2 in the C99 Standard). GCC allows any integer type as
8225 else if (!int_fits_type_p (value, integer_type_node))
8226 pedwarn (loc, OPT_Wpedantic,
8227 "ISO C restricts enumerator values to range of %<int%>");
8229 /* The ISO C Standard mandates enumerators to have type int, even
8230 though the underlying type of an enum type is unspecified.
8231 However, GCC allows enumerators of any integer type as an
8232 extensions. Here we convert any enumerators that fit in an int
8233 to type int, to avoid promotions to unsigned types when comparing
8234 integers with enumerators that fit in the int range. When
8235 -pedantic is given, we would have already warned about those that
8236 don't fit. We have to do this here rather than in finish_enum
8237 because this value may be used to define more enumerators. */
8238 if (int_fits_type_p (value, integer_type_node))
8239 value = convert (integer_type_node, value);
8241 /* Set basis for default for next value. */
8242 the_enum->enum_next_value
8243 = build_binary_op (EXPR_LOC_OR_LOC (value, input_location),
8244 PLUS_EXPR, value, integer_one_node, 0);
8245 the_enum->enum_overflow = tree_int_cst_lt (the_enum->enum_next_value, value);
8247 /* Now create a declaration for the enum value name. */
8249 type = TREE_TYPE (value);
8250 type = c_common_type_for_size (MAX (TYPE_PRECISION (type),
8251 TYPE_PRECISION (integer_type_node)),
8252 (TYPE_PRECISION (type)
8253 >= TYPE_PRECISION (integer_type_node)
8254 && TYPE_UNSIGNED (type)));
8256 decl = build_decl (decl_loc, CONST_DECL, name, type);
8257 DECL_INITIAL (decl) = convert (type, value);
8260 return tree_cons (decl, value, NULL_TREE);
8264 /* Create the FUNCTION_DECL for a function definition.
8265 DECLSPECS, DECLARATOR and ATTRIBUTES are the parts of
8266 the declaration; they describe the function's name and the type it returns,
8267 but twisted together in a fashion that parallels the syntax of C.
8269 This function creates a binding context for the function body
8270 as well as setting up the FUNCTION_DECL in current_function_decl.
8272 Returns 1 on success. If the DECLARATOR is not suitable for a function
8273 (it defines a datum instead), we return 0, which tells
8274 yyparse to report a parse error. */
8277 start_function (struct c_declspecs *declspecs, struct c_declarator *declarator,
8280 tree decl1, old_decl;
8281 tree restype, resdecl;
8284 current_function_returns_value = 0; /* Assume, until we see it does. */
8285 current_function_returns_null = 0;
8286 current_function_returns_abnormally = 0;
8287 warn_about_return_type = 0;
8288 c_switch_stack = NULL;
8290 /* Indicate no valid break/continue context by setting these variables
8291 to some non-null, non-label value. We'll notice and emit the proper
8292 error message in c_finish_bc_stmt. */
8293 c_break_label = c_cont_label = size_zero_node;
8295 decl1 = grokdeclarator (declarator, declspecs, FUNCDEF, true, NULL,
8296 &attributes, NULL, NULL, DEPRECATED_NORMAL);
8298 /* If the declarator is not suitable for a function definition,
8299 cause a syntax error. */
8301 || TREE_CODE (decl1) != FUNCTION_DECL)
8304 loc = DECL_SOURCE_LOCATION (decl1);
8306 c_decl_attributes (&decl1, attributes, 0);
8308 if (DECL_DECLARED_INLINE_P (decl1)
8309 && DECL_UNINLINABLE (decl1)
8310 && lookup_attribute ("noinline", DECL_ATTRIBUTES (decl1)))
8311 warning_at (loc, OPT_Wattributes,
8312 "inline function %qD given attribute noinline",
8315 /* Handle gnu_inline attribute. */
8316 if (declspecs->inline_p
8317 && !flag_gnu89_inline
8318 && TREE_CODE (decl1) == FUNCTION_DECL
8319 && (lookup_attribute ("gnu_inline", DECL_ATTRIBUTES (decl1))
8320 || current_function_decl))
8322 if (declspecs->storage_class != csc_static)
8323 DECL_EXTERNAL (decl1) = !DECL_EXTERNAL (decl1);
8326 announce_function (decl1);
8328 if (!COMPLETE_OR_VOID_TYPE_P (TREE_TYPE (TREE_TYPE (decl1))))
8330 error_at (loc, "return type is an incomplete type");
8331 /* Make it return void instead. */
8333 = build_function_type (void_type_node,
8334 TYPE_ARG_TYPES (TREE_TYPE (decl1)));
8337 if (warn_about_return_type)
8338 warn_defaults_to (loc, flag_isoc99 ? OPT_Wimplicit_int
8339 : (warn_return_type ? OPT_Wreturn_type
8340 : OPT_Wimplicit_int),
8341 "return type defaults to %<int%>");
8343 /* Make the init_value nonzero so pushdecl knows this is not tentative.
8344 error_mark_node is replaced below (in pop_scope) with the BLOCK. */
8345 DECL_INITIAL (decl1) = error_mark_node;
8347 /* A nested function is not global. */
8348 if (current_function_decl != 0)
8349 TREE_PUBLIC (decl1) = 0;
8351 /* If this definition isn't a prototype and we had a prototype declaration
8352 before, copy the arg type info from that prototype. */
8353 old_decl = lookup_name_in_scope (DECL_NAME (decl1), current_scope);
8354 if (old_decl && TREE_CODE (old_decl) != FUNCTION_DECL)
8356 current_function_prototype_locus = UNKNOWN_LOCATION;
8357 current_function_prototype_built_in = false;
8358 current_function_prototype_arg_types = NULL_TREE;
8359 if (!prototype_p (TREE_TYPE (decl1)))
8361 if (old_decl != 0 && TREE_CODE (TREE_TYPE (old_decl)) == FUNCTION_TYPE
8362 && comptypes (TREE_TYPE (TREE_TYPE (decl1)),
8363 TREE_TYPE (TREE_TYPE (old_decl))))
8365 TREE_TYPE (decl1) = composite_type (TREE_TYPE (old_decl),
8367 current_function_prototype_locus = DECL_SOURCE_LOCATION (old_decl);
8368 current_function_prototype_built_in
8369 = C_DECL_BUILTIN_PROTOTYPE (old_decl);
8370 current_function_prototype_arg_types
8371 = TYPE_ARG_TYPES (TREE_TYPE (decl1));
8373 if (TREE_PUBLIC (decl1))
8375 /* If there is an external prototype declaration of this
8376 function, record its location but do not copy information
8377 to this decl. This may be an invisible declaration
8378 (built-in or in a scope which has finished) or simply
8379 have more refined argument types than any declaration
8381 struct c_binding *b;
8382 for (b = I_SYMBOL_BINDING (DECL_NAME (decl1)); b; b = b->shadowed)
8383 if (B_IN_SCOPE (b, external_scope))
8387 tree ext_decl, ext_type;
8389 ext_type = b->u.type ? b->u.type : TREE_TYPE (ext_decl);
8390 if (TREE_CODE (ext_type) == FUNCTION_TYPE
8391 && comptypes (TREE_TYPE (TREE_TYPE (decl1)),
8392 TREE_TYPE (ext_type)))
8394 current_function_prototype_locus
8395 = DECL_SOURCE_LOCATION (ext_decl);
8396 current_function_prototype_built_in
8397 = C_DECL_BUILTIN_PROTOTYPE (ext_decl);
8398 current_function_prototype_arg_types
8399 = TYPE_ARG_TYPES (ext_type);
8405 /* Optionally warn of old-fashioned def with no previous prototype. */
8406 if (warn_strict_prototypes
8407 && old_decl != error_mark_node
8408 && !prototype_p (TREE_TYPE (decl1))
8409 && C_DECL_ISNT_PROTOTYPE (old_decl))
8410 warning_at (loc, OPT_Wstrict_prototypes,
8411 "function declaration isn%'t a prototype");
8412 /* Optionally warn of any global def with no previous prototype. */
8413 else if (warn_missing_prototypes
8414 && old_decl != error_mark_node
8415 && TREE_PUBLIC (decl1)
8416 && !MAIN_NAME_P (DECL_NAME (decl1))
8417 && C_DECL_ISNT_PROTOTYPE (old_decl)
8418 && !DECL_DECLARED_INLINE_P (decl1))
8419 warning_at (loc, OPT_Wmissing_prototypes,
8420 "no previous prototype for %qD", decl1);
8421 /* Optionally warn of any def with no previous prototype
8422 if the function has already been used. */
8423 else if (warn_missing_prototypes
8425 && old_decl != error_mark_node
8426 && TREE_USED (old_decl)
8427 && !prototype_p (TREE_TYPE (old_decl)))
8428 warning_at (loc, OPT_Wmissing_prototypes,
8429 "%qD was used with no prototype before its definition", decl1);
8430 /* Optionally warn of any global def with no previous declaration. */
8431 else if (warn_missing_declarations
8432 && TREE_PUBLIC (decl1)
8434 && !MAIN_NAME_P (DECL_NAME (decl1))
8435 && !DECL_DECLARED_INLINE_P (decl1))
8436 warning_at (loc, OPT_Wmissing_declarations,
8437 "no previous declaration for %qD",
8439 /* Optionally warn of any def with no previous declaration
8440 if the function has already been used. */
8441 else if (warn_missing_declarations
8443 && old_decl != error_mark_node
8444 && TREE_USED (old_decl)
8445 && C_DECL_IMPLICIT (old_decl))
8446 warning_at (loc, OPT_Wmissing_declarations,
8447 "%qD was used with no declaration before its definition", decl1);
8449 /* This function exists in static storage.
8450 (This does not mean `static' in the C sense!) */
8451 TREE_STATIC (decl1) = 1;
8453 /* This is the earliest point at which we might know the assembler
8454 name of the function. Thus, if it's set before this, die horribly. */
8455 gcc_assert (!DECL_ASSEMBLER_NAME_SET_P (decl1));
8457 /* If #pragma weak was used, mark the decl weak now. */
8458 if (current_scope == file_scope)
8459 maybe_apply_pragma_weak (decl1);
8461 /* Warn for unlikely, improbable, or stupid declarations of `main'. */
8462 if (warn_main && MAIN_NAME_P (DECL_NAME (decl1)))
8464 if (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (decl1)))
8465 != integer_type_node)
8466 pedwarn (loc, OPT_Wmain, "return type of %qD is not %<int%>", decl1);
8467 else if (TYPE_ATOMIC (TREE_TYPE (TREE_TYPE (decl1))))
8468 pedwarn (loc, OPT_Wmain, "%<_Atomic%>-qualified return type of %qD",
8471 check_main_parameter_types (decl1);
8473 if (!TREE_PUBLIC (decl1))
8474 pedwarn (loc, OPT_Wmain,
8475 "%qD is normally a non-static function", decl1);
8478 /* Record the decl so that the function name is defined.
8479 If we already have a decl for this name, and it is a FUNCTION_DECL,
8480 use the old decl. */
8482 current_function_decl = pushdecl (decl1);
8485 declare_parm_level ();
8487 restype = TREE_TYPE (TREE_TYPE (current_function_decl));
8488 resdecl = build_decl (loc, RESULT_DECL, NULL_TREE, restype);
8489 DECL_ARTIFICIAL (resdecl) = 1;
8490 DECL_IGNORED_P (resdecl) = 1;
8491 DECL_RESULT (current_function_decl) = resdecl;
8493 start_fname_decls ();
8498 /* Subroutine of store_parm_decls which handles new-style function
8499 definitions (prototype format). The parms already have decls, so we
8500 need only record them as in effect and complain if any redundant
8501 old-style parm decls were written. */
8503 store_parm_decls_newstyle (tree fndecl, const struct c_arg_info *arg_info)
8509 if (current_scope->bindings)
8511 error_at (DECL_SOURCE_LOCATION (fndecl),
8512 "old-style parameter declarations in prototyped "
8513 "function definition");
8515 /* Get rid of the old-style declarations. */
8519 /* Don't issue this warning for nested functions, and don't issue this
8520 warning if we got here because ARG_INFO_TYPES was error_mark_node
8521 (this happens when a function definition has just an ellipsis in
8522 its parameter list). */
8523 else if (!in_system_header_at (input_location)
8524 && !current_function_scope
8525 && arg_info->types != error_mark_node)
8526 warning_at (DECL_SOURCE_LOCATION (fndecl), OPT_Wtraditional,
8527 "traditional C rejects ISO C style function definitions");
8529 /* Now make all the parameter declarations visible in the function body.
8530 We can bypass most of the grunt work of pushdecl. */
8531 for (decl = arg_info->parms; decl; decl = DECL_CHAIN (decl))
8533 DECL_CONTEXT (decl) = current_function_decl;
8534 if (DECL_NAME (decl))
8536 bind (DECL_NAME (decl), decl, current_scope,
8537 /*invisible=*/false, /*nested=*/false,
8539 if (!TREE_USED (decl))
8540 warn_if_shadowing (decl);
8543 error_at (DECL_SOURCE_LOCATION (decl), "parameter name omitted");
8546 /* Record the parameter list in the function declaration. */
8547 DECL_ARGUMENTS (fndecl) = arg_info->parms;
8549 /* Now make all the ancillary declarations visible, likewise. */
8550 for (decl = arg_info->others; decl; decl = DECL_CHAIN (decl))
8552 DECL_CONTEXT (decl) = current_function_decl;
8553 if (DECL_NAME (decl))
8554 bind (DECL_NAME (decl), decl, current_scope,
8555 /*invisible=*/false,
8556 /*nested=*/(TREE_CODE (decl) == FUNCTION_DECL),
8560 /* And all the tag declarations. */
8561 FOR_EACH_VEC_SAFE_ELT_REVERSE (arg_info->tags, ix, tag)
8563 bind (tag->id, tag->type, current_scope,
8564 /*invisible=*/false, /*nested=*/false, UNKNOWN_LOCATION);
8567 /* Subroutine of store_parm_decls which handles old-style function
8568 definitions (separate parameter list and declarations). */
8571 store_parm_decls_oldstyle (tree fndecl, const struct c_arg_info *arg_info)
8573 struct c_binding *b;
8574 tree parm, decl, last;
8575 tree parmids = arg_info->parms;
8576 hash_set<tree> seen_args;
8578 if (!in_system_header_at (input_location))
8579 warning_at (DECL_SOURCE_LOCATION (fndecl),
8580 OPT_Wold_style_definition, "old-style function definition");
8582 /* Match each formal parameter name with its declaration. Save each
8583 decl in the appropriate TREE_PURPOSE slot of the parmids chain. */
8584 for (parm = parmids; parm; parm = TREE_CHAIN (parm))
8586 if (TREE_VALUE (parm) == 0)
8588 error_at (DECL_SOURCE_LOCATION (fndecl),
8589 "parameter name missing from parameter list");
8590 TREE_PURPOSE (parm) = 0;
8594 b = I_SYMBOL_BINDING (TREE_VALUE (parm));
8595 if (b && B_IN_CURRENT_SCOPE (b))
8598 /* Skip erroneous parameters. */
8599 if (decl == error_mark_node)
8601 /* If we got something other than a PARM_DECL it is an error. */
8602 if (TREE_CODE (decl) != PARM_DECL)
8603 error_at (DECL_SOURCE_LOCATION (decl),
8604 "%qD declared as a non-parameter", decl);
8605 /* If the declaration is already marked, we have a duplicate
8606 name. Complain and ignore the duplicate. */
8607 else if (seen_args.contains (decl))
8609 error_at (DECL_SOURCE_LOCATION (decl),
8610 "multiple parameters named %qD", decl);
8611 TREE_PURPOSE (parm) = 0;
8614 /* If the declaration says "void", complain and turn it into
8616 else if (VOID_TYPE_P (TREE_TYPE (decl)))
8618 error_at (DECL_SOURCE_LOCATION (decl),
8619 "parameter %qD declared with void type", decl);
8620 TREE_TYPE (decl) = integer_type_node;
8621 DECL_ARG_TYPE (decl) = integer_type_node;
8622 layout_decl (decl, 0);
8624 warn_if_shadowing (decl);
8626 /* If no declaration found, default to int. */
8629 /* FIXME diagnostics: This should be the location of the argument,
8630 not the FNDECL. E.g., for an old-style declaration
8632 int f10(v) { blah; }
8634 We should use the location of the V, not the F10.
8635 Unfortunately, the V is an IDENTIFIER_NODE which has no
8636 location. In the future we need locations for c_arg_info
8639 See gcc.dg/Wshadow-3.c for an example of this problem. */
8640 decl = build_decl (DECL_SOURCE_LOCATION (fndecl),
8641 PARM_DECL, TREE_VALUE (parm), integer_type_node);
8642 DECL_ARG_TYPE (decl) = TREE_TYPE (decl);
8644 warn_if_shadowing (decl);
8647 pedwarn (DECL_SOURCE_LOCATION (decl),
8648 OPT_Wimplicit_int, "type of %qD defaults to %<int%>",
8651 warning_at (DECL_SOURCE_LOCATION (decl),
8652 OPT_Wmissing_parameter_type,
8653 "type of %qD defaults to %<int%>", decl);
8656 TREE_PURPOSE (parm) = decl;
8657 seen_args.add (decl);
8660 /* Now examine the parms chain for incomplete declarations
8661 and declarations with no corresponding names. */
8663 for (b = current_scope->bindings; b; b = b->prev)
8666 if (TREE_CODE (parm) != PARM_DECL)
8669 if (TREE_TYPE (parm) != error_mark_node
8670 && !COMPLETE_TYPE_P (TREE_TYPE (parm)))
8672 error_at (DECL_SOURCE_LOCATION (parm),
8673 "parameter %qD has incomplete type", parm);
8674 TREE_TYPE (parm) = error_mark_node;
8677 if (!seen_args.contains (parm))
8679 error_at (DECL_SOURCE_LOCATION (parm),
8680 "declaration for parameter %qD but no such parameter",
8683 /* Pretend the parameter was not missing.
8684 This gets us to a standard state and minimizes
8685 further error messages. */
8686 parmids = chainon (parmids, tree_cons (parm, 0, 0));
8690 /* Chain the declarations together in the order of the list of
8691 names. Store that chain in the function decl, replacing the
8692 list of names. Update the current scope to match. */
8693 DECL_ARGUMENTS (fndecl) = 0;
8695 for (parm = parmids; parm; parm = TREE_CHAIN (parm))
8696 if (TREE_PURPOSE (parm))
8698 if (parm && TREE_PURPOSE (parm))
8700 last = TREE_PURPOSE (parm);
8701 DECL_ARGUMENTS (fndecl) = last;
8703 for (parm = TREE_CHAIN (parm); parm; parm = TREE_CHAIN (parm))
8704 if (TREE_PURPOSE (parm))
8706 DECL_CHAIN (last) = TREE_PURPOSE (parm);
8707 last = TREE_PURPOSE (parm);
8709 DECL_CHAIN (last) = 0;
8712 /* If there was a previous prototype,
8713 set the DECL_ARG_TYPE of each argument according to
8714 the type previously specified, and report any mismatches. */
8716 if (current_function_prototype_arg_types)
8719 for (parm = DECL_ARGUMENTS (fndecl),
8720 type = current_function_prototype_arg_types;
8721 parm || (type && TREE_VALUE (type) != error_mark_node
8722 && (TYPE_MAIN_VARIANT (TREE_VALUE (type)) != void_type_node));
8723 parm = DECL_CHAIN (parm), type = TREE_CHAIN (type))
8725 if (parm == 0 || type == 0
8726 || TYPE_MAIN_VARIANT (TREE_VALUE (type)) == void_type_node)
8728 if (current_function_prototype_built_in)
8729 warning_at (DECL_SOURCE_LOCATION (fndecl),
8730 0, "number of arguments doesn%'t match "
8731 "built-in prototype");
8734 /* FIXME diagnostics: This should be the location of
8735 FNDECL, but there is bug when a prototype is
8736 declared inside function context, but defined
8737 outside of it (e.g., gcc.dg/pr15698-2.c). In
8738 which case FNDECL gets the location of the
8739 prototype, not the definition. */
8740 error_at (input_location,
8741 "number of arguments doesn%'t match prototype");
8743 error_at (current_function_prototype_locus,
8744 "prototype declaration");
8748 /* Type for passing arg must be consistent with that
8749 declared for the arg. ISO C says we take the unqualified
8750 type for parameters declared with qualified type. */
8751 if (TREE_TYPE (parm) != error_mark_node
8752 && TREE_TYPE (type) != error_mark_node
8753 && ((TYPE_ATOMIC (DECL_ARG_TYPE (parm))
8754 != TYPE_ATOMIC (TREE_VALUE (type)))
8755 || !comptypes (TYPE_MAIN_VARIANT (DECL_ARG_TYPE (parm)),
8756 TYPE_MAIN_VARIANT (TREE_VALUE (type)))))
8758 if ((TYPE_ATOMIC (DECL_ARG_TYPE (parm))
8759 == TYPE_ATOMIC (TREE_VALUE (type)))
8760 && (TYPE_MAIN_VARIANT (TREE_TYPE (parm))
8761 == TYPE_MAIN_VARIANT (TREE_VALUE (type))))
8763 /* Adjust argument to match prototype. E.g. a previous
8764 `int foo(float);' prototype causes
8765 `int foo(x) float x; {...}' to be treated like
8766 `int foo(float x) {...}'. This is particularly
8767 useful for argument types like uid_t. */
8768 DECL_ARG_TYPE (parm) = TREE_TYPE (parm);
8770 if (targetm.calls.promote_prototypes (TREE_TYPE (current_function_decl))
8771 && INTEGRAL_TYPE_P (TREE_TYPE (parm))
8772 && TYPE_PRECISION (TREE_TYPE (parm))
8773 < TYPE_PRECISION (integer_type_node))
8774 DECL_ARG_TYPE (parm)
8775 = c_type_promotes_to (TREE_TYPE (parm));
8777 /* ??? Is it possible to get here with a
8778 built-in prototype or will it always have
8779 been diagnosed as conflicting with an
8780 old-style definition and discarded? */
8781 if (current_function_prototype_built_in)
8782 warning_at (DECL_SOURCE_LOCATION (parm),
8783 OPT_Wpedantic, "promoted argument %qD "
8784 "doesn%'t match built-in prototype", parm);
8787 pedwarn (DECL_SOURCE_LOCATION (parm),
8788 OPT_Wpedantic, "promoted argument %qD "
8789 "doesn%'t match prototype", parm);
8790 pedwarn (current_function_prototype_locus, OPT_Wpedantic,
8791 "prototype declaration");
8796 if (current_function_prototype_built_in)
8797 warning_at (DECL_SOURCE_LOCATION (parm),
8798 0, "argument %qD doesn%'t match "
8799 "built-in prototype", parm);
8802 error_at (DECL_SOURCE_LOCATION (parm),
8803 "argument %qD doesn%'t match prototype", parm);
8804 error_at (current_function_prototype_locus,
8805 "prototype declaration");
8810 TYPE_ACTUAL_ARG_TYPES (TREE_TYPE (fndecl)) = 0;
8813 /* Otherwise, create a prototype that would match. */
8817 tree actual = 0, last = 0, type;
8819 for (parm = DECL_ARGUMENTS (fndecl); parm; parm = DECL_CHAIN (parm))
8821 type = tree_cons (NULL_TREE, DECL_ARG_TYPE (parm), NULL_TREE);
8823 TREE_CHAIN (last) = type;
8828 type = tree_cons (NULL_TREE, void_type_node, NULL_TREE);
8830 TREE_CHAIN (last) = type;
8834 /* We are going to assign a new value for the TYPE_ACTUAL_ARG_TYPES
8835 of the type of this function, but we need to avoid having this
8836 affect the types of other similarly-typed functions, so we must
8837 first force the generation of an identical (but separate) type
8838 node for the relevant function type. The new node we create
8839 will be a variant of the main variant of the original function
8842 TREE_TYPE (fndecl) = build_variant_type_copy (TREE_TYPE (fndecl));
8844 TYPE_ACTUAL_ARG_TYPES (TREE_TYPE (fndecl)) = actual;
8848 /* Store parameter declarations passed in ARG_INFO into the current
8849 function declaration. */
8852 store_parm_decls_from (struct c_arg_info *arg_info)
8854 current_function_arg_info = arg_info;
8855 store_parm_decls ();
8858 /* Store the parameter declarations into the current function declaration.
8859 This is called after parsing the parameter declarations, before
8860 digesting the body of the function.
8862 For an old-style definition, construct a prototype out of the old-style
8863 parameter declarations and inject it into the function's type. */
8866 store_parm_decls (void)
8868 tree fndecl = current_function_decl;
8871 /* The argument information block for FNDECL. */
8872 struct c_arg_info *arg_info = current_function_arg_info;
8873 current_function_arg_info = 0;
8875 /* True if this definition is written with a prototype. Note:
8876 despite C99 6.7.5.3p14, we can *not* treat an empty argument
8877 list in a function definition as equivalent to (void) -- an
8878 empty argument list specifies the function has no parameters,
8879 but only (void) sets up a prototype for future calls. */
8880 proto = arg_info->types != 0;
8883 store_parm_decls_newstyle (fndecl, arg_info);
8885 store_parm_decls_oldstyle (fndecl, arg_info);
8887 /* The next call to push_scope will be a function body. */
8889 next_is_function_body = true;
8891 /* Write a record describing this function definition to the prototypes
8892 file (if requested). */
8894 gen_aux_info_record (fndecl, 1, 0, proto);
8896 /* Initialize the RTL code for the function. */
8897 allocate_struct_function (fndecl, false);
8899 if (warn_unused_local_typedefs)
8900 cfun->language = ggc_cleared_alloc<language_function> ();
8902 /* Begin the statement tree for this function. */
8903 DECL_SAVED_TREE (fndecl) = push_stmt_list ();
8905 /* ??? Insert the contents of the pending sizes list into the function
8906 to be evaluated. The only reason left to have this is
8907 void foo(int n, int array[n++])
8908 because we throw away the array type in favor of a pointer type, and
8909 thus won't naturally see the SAVE_EXPR containing the increment. All
8910 other pending sizes would be handled by gimplify_parameters. */
8911 if (arg_info->pending_sizes)
8912 add_stmt (arg_info->pending_sizes);
8915 /* Store PARM_DECLs in PARMS into scope temporarily. Used for
8916 c_finish_omp_declare_simd for function prototypes. No diagnostics
8920 temp_store_parm_decls (tree fndecl, tree parms)
8923 for (tree p = parms; p; p = DECL_CHAIN (p))
8925 DECL_CONTEXT (p) = fndecl;
8927 bind (DECL_NAME (p), p, current_scope,
8928 /*invisible=*/false, /*nested=*/false,
8933 /* Undo what temp_store_parm_decls did. */
8936 temp_pop_parm_decls (void)
8938 /* Clear all bindings in this temporary scope, so that
8939 pop_scope doesn't create a BLOCK. */
8940 struct c_binding *b = current_scope->bindings;
8941 current_scope->bindings = NULL;
8942 for (; b; b = free_binding_and_advance (b))
8944 gcc_assert (TREE_CODE (b->decl) == PARM_DECL
8945 || b->decl == error_mark_node);
8946 gcc_assert (I_SYMBOL_BINDING (b->id) == b);
8947 I_SYMBOL_BINDING (b->id) = b->shadowed;
8948 if (b->shadowed && b->shadowed->u.type)
8949 TREE_TYPE (b->shadowed->decl) = b->shadowed->u.type;
8955 /* Finish up a function declaration and compile that function
8956 all the way to assembler language output. Then free the storage
8957 for the function definition.
8959 This is called after parsing the body of the function definition. */
8962 finish_function (void)
8964 tree fndecl = current_function_decl;
8966 if (c_dialect_objc ())
8967 objc_finish_function ();
8969 if (TREE_CODE (fndecl) == FUNCTION_DECL
8970 && targetm.calls.promote_prototypes (TREE_TYPE (fndecl)))
8972 tree args = DECL_ARGUMENTS (fndecl);
8973 for (; args; args = DECL_CHAIN (args))
8975 tree type = TREE_TYPE (args);
8976 if (INTEGRAL_TYPE_P (type)
8977 && TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node))
8978 DECL_ARG_TYPE (args) = c_type_promotes_to (type);
8982 if (DECL_INITIAL (fndecl) && DECL_INITIAL (fndecl) != error_mark_node)
8983 BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl)) = fndecl;
8985 /* Must mark the RESULT_DECL as being in this function. */
8987 if (DECL_RESULT (fndecl) && DECL_RESULT (fndecl) != error_mark_node)
8988 DECL_CONTEXT (DECL_RESULT (fndecl)) = fndecl;
8990 if (MAIN_NAME_P (DECL_NAME (fndecl)) && flag_hosted
8991 && TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (fndecl)))
8992 == integer_type_node && flag_isoc99)
8994 /* Hack. We don't want the middle-end to warn that this return
8995 is unreachable, so we mark its location as special. Using
8996 UNKNOWN_LOCATION has the problem that it gets clobbered in
8997 annotate_one_with_locus. A cleaner solution might be to
8998 ensure ! should_carry_locus_p (stmt), but that needs a flag.
9000 c_finish_return (BUILTINS_LOCATION, integer_zero_node, NULL_TREE);
9003 /* Tie off the statement tree for this function. */
9004 DECL_SAVED_TREE (fndecl) = pop_stmt_list (DECL_SAVED_TREE (fndecl));
9006 /* If the function has _Cilk_spawn in front of a function call inside it
9007 i.e. it is a spawning function, then add the appropriate Cilk plus
9008 functions inside. */
9009 if (fn_contains_cilk_spawn_p (cfun))
9010 cfun->cilk_frame_decl = insert_cilk_frame (fndecl);
9012 finish_fname_decls ();
9014 /* Complain if there's just no return statement. */
9015 if (warn_return_type
9016 && TREE_CODE (TREE_TYPE (TREE_TYPE (fndecl))) != VOID_TYPE
9017 && !current_function_returns_value && !current_function_returns_null
9018 /* Don't complain if we are no-return. */
9019 && !current_function_returns_abnormally
9020 /* Don't complain if we are declared noreturn. */
9021 && !TREE_THIS_VOLATILE (fndecl)
9022 /* Don't warn for main(). */
9023 && !MAIN_NAME_P (DECL_NAME (fndecl))
9024 /* Or if they didn't actually specify a return type. */
9025 && !C_FUNCTION_IMPLICIT_INT (fndecl)
9026 /* Normally, with -Wreturn-type, flow will complain, but we might
9027 optimize out static functions. */
9028 && !TREE_PUBLIC (fndecl))
9030 warning (OPT_Wreturn_type,
9031 "no return statement in function returning non-void");
9032 TREE_NO_WARNING (fndecl) = 1;
9035 /* Complain about parameters that are only set, but never otherwise used. */
9036 if (warn_unused_but_set_parameter)
9040 for (decl = DECL_ARGUMENTS (fndecl);
9042 decl = DECL_CHAIN (decl))
9043 if (TREE_USED (decl)
9044 && TREE_CODE (decl) == PARM_DECL
9045 && !DECL_READ_P (decl)
9047 && !DECL_ARTIFICIAL (decl)
9048 && !TREE_NO_WARNING (decl))
9049 warning_at (DECL_SOURCE_LOCATION (decl),
9050 OPT_Wunused_but_set_parameter,
9051 "parameter %qD set but not used", decl);
9054 /* Complain about locally defined typedefs that are not used in this
9056 maybe_warn_unused_local_typedefs ();
9058 /* Store the end of the function, so that we get good line number
9059 info for the epilogue. */
9060 cfun->function_end_locus = input_location;
9062 /* Finalize the ELF visibility for the function. */
9063 c_determine_visibility (fndecl);
9065 /* For GNU C extern inline functions disregard inline limits. */
9066 if (DECL_EXTERNAL (fndecl)
9067 && DECL_DECLARED_INLINE_P (fndecl))
9068 DECL_DISREGARD_INLINE_LIMITS (fndecl) = 1;
9070 /* Genericize before inlining. Delay genericizing nested functions
9071 until their parent function is genericized. Since finalizing
9072 requires GENERIC, delay that as well. */
9074 if (DECL_INITIAL (fndecl) && DECL_INITIAL (fndecl) != error_mark_node
9075 && !undef_nested_function)
9077 if (!decl_function_context (fndecl))
9079 invoke_plugin_callbacks (PLUGIN_PRE_GENERICIZE, fndecl);
9080 c_genericize (fndecl);
9082 /* ??? Objc emits functions after finalizing the compilation unit.
9083 This should be cleaned up later and this conditional removed. */
9084 if (symtab->global_info_ready)
9086 cgraph_node::add_new_function (fndecl, false);
9089 cgraph_node::finalize_function (fndecl, false);
9093 /* Register this function with cgraph just far enough to get it
9094 added to our parent's nested function list. Handy, since the
9095 C front end doesn't have such a list. */
9096 (void) cgraph_node::get_create (fndecl);
9100 if (!decl_function_context (fndecl))
9101 undef_nested_function = false;
9103 if (cfun->language != NULL)
9105 ggc_free (cfun->language);
9106 cfun->language = NULL;
9109 /* We're leaving the context of this function, so zap cfun.
9110 It's still in DECL_STRUCT_FUNCTION, and we'll restore it in
9111 tree_rest_of_compilation. */
9113 current_function_decl = NULL;
9116 /* Check the declarations given in a for-loop for satisfying the C99
9117 constraints. If exactly one such decl is found, return it. LOC is
9118 the location of the opening parenthesis of the for loop. The last
9119 parameter allows you to control the "for loop initial declarations
9120 are only allowed in C99 mode". Normally, you should pass
9121 flag_isoc99 as that parameter. But in some cases (Objective-C
9122 foreach loop, for example) we want to run the checks in this
9123 function even if not in C99 mode, so we allow the caller to turn
9124 off the error about not being in C99 mode.
9128 check_for_loop_decls (location_t loc, bool turn_off_iso_c99_error)
9130 struct c_binding *b;
9131 tree one_decl = NULL_TREE;
9134 if (!turn_off_iso_c99_error)
9136 static bool hint = true;
9137 /* If we get here, declarations have been used in a for loop without
9138 the C99 for loop scope. This doesn't make much sense, so don't
9140 error_at (loc, "%<for%> loop initial declarations "
9141 "are only allowed in C99 or C11 mode");
9145 "use option -std=c99, -std=gnu99, -std=c11 or -std=gnu11 "
9146 "to compile your code");
9151 /* C99 subclause 6.8.5 paragraph 3:
9153 [#3] The declaration part of a for statement shall only
9154 declare identifiers for objects having storage class auto or
9157 It isn't clear whether, in this sentence, "identifiers" binds to
9158 "shall only declare" or to "objects" - that is, whether all identifiers
9159 declared must be identifiers for objects, or whether the restriction
9160 only applies to those that are. (A question on this in comp.std.c
9161 in November 2000 received no answer.) We implement the strictest
9162 interpretation, to avoid creating an extension which later causes
9165 for (b = current_scope->bindings; b; b = b->prev)
9168 tree decl = b->decl;
9173 switch (TREE_CODE (decl))
9177 location_t decl_loc = DECL_SOURCE_LOCATION (decl);
9178 if (TREE_STATIC (decl))
9180 "declaration of static variable %qD in %<for%> loop "
9181 "initial declaration", decl);
9182 else if (DECL_EXTERNAL (decl))
9184 "declaration of %<extern%> variable %qD in %<for%> loop "
9185 "initial declaration", decl);
9191 "%<struct %E%> declared in %<for%> loop initial "
9196 "%<union %E%> declared in %<for%> loop initial declaration",
9200 error_at (loc, "%<enum %E%> declared in %<for%> loop "
9201 "initial declaration", id);
9204 error_at (loc, "declaration of non-variable "
9205 "%qD in %<for%> loop initial declaration", decl);
9212 return n_decls == 1 ? one_decl : NULL_TREE;
9215 /* Save and reinitialize the variables
9216 used during compilation of a C function. */
9219 c_push_function_context (void)
9221 struct language_function *p = cfun->language;
9222 /* cfun->language might have been already allocated by the use of
9223 -Wunused-local-typedefs. In that case, just re-use it. */
9225 cfun->language = p = ggc_cleared_alloc<language_function> ();
9227 p->base.x_stmt_tree = c_stmt_tree;
9228 c_stmt_tree.x_cur_stmt_list = vec_safe_copy (c_stmt_tree.x_cur_stmt_list);
9229 p->x_break_label = c_break_label;
9230 p->x_cont_label = c_cont_label;
9231 p->x_switch_stack = c_switch_stack;
9232 p->arg_info = current_function_arg_info;
9233 p->returns_value = current_function_returns_value;
9234 p->returns_null = current_function_returns_null;
9235 p->returns_abnormally = current_function_returns_abnormally;
9236 p->warn_about_return_type = warn_about_return_type;
9238 push_function_context ();
9241 /* Restore the variables used during compilation of a C function. */
9244 c_pop_function_context (void)
9246 struct language_function *p;
9248 pop_function_context ();
9251 /* When -Wunused-local-typedefs is in effect, cfun->languages is
9252 used to store data throughout the life time of the current cfun,
9253 So don't deallocate it. */
9254 if (!warn_unused_local_typedefs)
9255 cfun->language = NULL;
9257 if (DECL_STRUCT_FUNCTION (current_function_decl) == 0
9258 && DECL_SAVED_TREE (current_function_decl) == NULL_TREE)
9260 /* Stop pointing to the local nodes about to be freed. */
9261 /* But DECL_INITIAL must remain nonzero so we know this
9262 was an actual function definition. */
9263 DECL_INITIAL (current_function_decl) = error_mark_node;
9264 DECL_ARGUMENTS (current_function_decl) = 0;
9267 c_stmt_tree = p->base.x_stmt_tree;
9268 p->base.x_stmt_tree.x_cur_stmt_list = NULL;
9269 c_break_label = p->x_break_label;
9270 c_cont_label = p->x_cont_label;
9271 c_switch_stack = p->x_switch_stack;
9272 current_function_arg_info = p->arg_info;
9273 current_function_returns_value = p->returns_value;
9274 current_function_returns_null = p->returns_null;
9275 current_function_returns_abnormally = p->returns_abnormally;
9276 warn_about_return_type = p->warn_about_return_type;
9279 /* The functions below are required for functionality of doing
9280 function at once processing in the C front end. Currently these
9281 functions are not called from anywhere in the C front end, but as
9282 these changes continue, that will change. */
9284 /* Returns the stmt_tree (if any) to which statements are currently
9285 being added. If there is no active statement-tree, NULL is
9289 current_stmt_tree (void)
9291 return &c_stmt_tree;
9294 /* Return the global value of T as a symbol. */
9297 identifier_global_value (tree t)
9299 struct c_binding *b;
9301 for (b = I_SYMBOL_BINDING (t); b; b = b->shadowed)
9302 if (B_IN_FILE_SCOPE (b) || B_IN_EXTERNAL_SCOPE (b))
9308 /* In C, the only C-linkage public declaration is at file scope. */
9311 c_linkage_bindings (tree name)
9313 return identifier_global_value (name);
9316 /* Record a builtin type for C. If NAME is non-NULL, it is the name used;
9317 otherwise the name is found in ridpointers from RID_INDEX. */
9320 record_builtin_type (enum rid rid_index, const char *name, tree type)
9324 id = ridpointers[(int) rid_index];
9326 id = get_identifier (name);
9327 decl = build_decl (UNKNOWN_LOCATION, TYPE_DECL, id, type);
9329 if (debug_hooks->type_decl)
9330 debug_hooks->type_decl (decl, false);
9333 /* Build the void_list_node (void_type_node having been created). */
9335 build_void_list_node (void)
9337 tree t = build_tree_list (NULL_TREE, void_type_node);
9341 /* Return a c_parm structure with the given SPECS, ATTRS and DECLARATOR. */
9344 build_c_parm (struct c_declspecs *specs, tree attrs,
9345 struct c_declarator *declarator)
9347 struct c_parm *ret = XOBNEW (&parser_obstack, struct c_parm);
9350 ret->declarator = declarator;
9354 /* Return a declarator with nested attributes. TARGET is the inner
9355 declarator to which these attributes apply. ATTRS are the
9358 struct c_declarator *
9359 build_attrs_declarator (tree attrs, struct c_declarator *target)
9361 struct c_declarator *ret = XOBNEW (&parser_obstack, struct c_declarator);
9362 ret->kind = cdk_attrs;
9363 ret->declarator = target;
9364 ret->u.attrs = attrs;
9368 /* Return a declarator for a function with arguments specified by ARGS
9369 and return type specified by TARGET. */
9371 struct c_declarator *
9372 build_function_declarator (struct c_arg_info *args,
9373 struct c_declarator *target)
9375 struct c_declarator *ret = XOBNEW (&parser_obstack, struct c_declarator);
9376 ret->kind = cdk_function;
9377 ret->declarator = target;
9378 ret->u.arg_info = args;
9382 /* Return a declarator for the identifier IDENT (which may be
9383 NULL_TREE for an abstract declarator). */
9385 struct c_declarator *
9386 build_id_declarator (tree ident)
9388 struct c_declarator *ret = XOBNEW (&parser_obstack, struct c_declarator);
9390 ret->declarator = 0;
9392 /* Default value - may get reset to a more precise location. */
9393 ret->id_loc = input_location;
9397 /* Return something to represent absolute declarators containing a *.
9398 TARGET is the absolute declarator that the * contains.
9399 TYPE_QUALS_ATTRS is a structure for type qualifiers and attributes
9400 to apply to the pointer type. */
9402 struct c_declarator *
9403 make_pointer_declarator (struct c_declspecs *type_quals_attrs,
9404 struct c_declarator *target)
9408 struct c_declarator *itarget = target;
9409 struct c_declarator *ret = XOBNEW (&parser_obstack, struct c_declarator);
9410 if (type_quals_attrs)
9412 attrs = type_quals_attrs->attrs;
9413 quals = quals_from_declspecs (type_quals_attrs);
9414 if (attrs != NULL_TREE)
9415 itarget = build_attrs_declarator (attrs, target);
9417 ret->kind = cdk_pointer;
9418 ret->declarator = itarget;
9419 ret->u.pointer_quals = quals;
9423 /* Return a pointer to a structure for an empty list of declaration
9426 struct c_declspecs *
9427 build_null_declspecs (void)
9429 struct c_declspecs *ret = XOBNEW (&parser_obstack, struct c_declspecs);
9430 memset (&ret->locations, 0, cdw_number_of_elements);
9435 ret->align_log = -1;
9436 ret->typespec_word = cts_none;
9437 ret->storage_class = csc_none;
9438 ret->expr_const_operands = true;
9439 ret->declspecs_seen_p = false;
9440 ret->typespec_kind = ctsk_none;
9441 ret->non_sc_seen_p = false;
9442 ret->typedef_p = false;
9443 ret->explicit_signed_p = false;
9444 ret->deprecated_p = false;
9445 ret->default_int_p = false;
9446 ret->long_p = false;
9447 ret->long_long_p = false;
9448 ret->short_p = false;
9449 ret->signed_p = false;
9450 ret->unsigned_p = false;
9451 ret->complex_p = false;
9452 ret->inline_p = false;
9453 ret->noreturn_p = false;
9454 ret->thread_p = false;
9455 ret->thread_gnu_p = false;
9456 ret->const_p = false;
9457 ret->volatile_p = false;
9458 ret->atomic_p = false;
9459 ret->restrict_p = false;
9460 ret->saturating_p = false;
9461 ret->alignas_p = false;
9462 ret->address_space = ADDR_SPACE_GENERIC;
9466 /* Add the address space ADDRSPACE to the declaration specifiers
9467 SPECS, returning SPECS. */
9469 struct c_declspecs *
9470 declspecs_add_addrspace (source_location location,
9471 struct c_declspecs *specs, addr_space_t as)
9473 specs->non_sc_seen_p = true;
9474 specs->declspecs_seen_p = true;
9476 if (!ADDR_SPACE_GENERIC_P (specs->address_space)
9477 && specs->address_space != as)
9478 error ("incompatible address space qualifiers %qs and %qs",
9479 c_addr_space_name (as),
9480 c_addr_space_name (specs->address_space));
9483 specs->address_space = as;
9484 specs->locations[cdw_address_space] = location;
9489 /* Add the type qualifier QUAL to the declaration specifiers SPECS,
9492 struct c_declspecs *
9493 declspecs_add_qual (source_location loc,
9494 struct c_declspecs *specs, tree qual)
9498 specs->non_sc_seen_p = true;
9499 specs->declspecs_seen_p = true;
9500 gcc_assert (TREE_CODE (qual) == IDENTIFIER_NODE
9501 && C_IS_RESERVED_WORD (qual));
9502 i = C_RID_CODE (qual);
9506 dupe = specs->const_p;
9507 specs->const_p = true;
9508 specs->locations[cdw_const] = loc;
9511 dupe = specs->volatile_p;
9512 specs->volatile_p = true;
9513 specs->locations[cdw_volatile] = loc;
9516 dupe = specs->restrict_p;
9517 specs->restrict_p = true;
9518 specs->locations[cdw_restrict] = loc;
9521 dupe = specs->atomic_p;
9522 specs->atomic_p = true;
9528 pedwarn_c90 (loc, OPT_Wpedantic, "duplicate %qE", qual);
9532 /* Add the type specifier TYPE to the declaration specifiers SPECS,
9535 struct c_declspecs *
9536 declspecs_add_type (location_t loc, struct c_declspecs *specs,
9537 struct c_typespec spec)
9539 tree type = spec.spec;
9540 specs->non_sc_seen_p = true;
9541 specs->declspecs_seen_p = true;
9542 specs->typespec_kind = spec.kind;
9543 if (TREE_DEPRECATED (type))
9544 specs->deprecated_p = true;
9546 /* Handle type specifier keywords. */
9547 if (TREE_CODE (type) == IDENTIFIER_NODE
9548 && C_IS_RESERVED_WORD (type)
9549 && C_RID_CODE (type) != RID_CXX_COMPAT_WARN)
9551 enum rid i = C_RID_CODE (type);
9554 error_at (loc, "two or more data types in declaration specifiers");
9557 if ((int) i <= (int) RID_LAST_MODIFIER)
9559 /* "long", "short", "signed", "unsigned", "_Complex" or "_Sat". */
9564 if (specs->long_long_p)
9566 error_at (loc, "%<long long long%> is too long for GCC");
9571 if (specs->typespec_word == cts_double)
9574 ("both %<long long%> and %<double%> in "
9575 "declaration specifiers"));
9578 pedwarn_c90 (loc, OPT_Wlong_long,
9579 "ISO C90 does not support %<long long%>");
9580 specs->long_long_p = 1;
9581 specs->locations[cdw_long_long] = loc;
9586 ("both %<long%> and %<short%> in "
9587 "declaration specifiers"));
9588 else if (specs->typespec_word == cts_auto_type)
9590 ("both %<long%> and %<__auto_type%> in "
9591 "declaration specifiers"));
9592 else if (specs->typespec_word == cts_void)
9594 ("both %<long%> and %<void%> in "
9595 "declaration specifiers"));
9596 else if (specs->typespec_word == cts_int_n)
9598 ("both %<long%> and %<__int%d%> in "
9599 "declaration specifiers"),
9600 int_n_data[specs->int_n_idx].bitsize);
9601 else if (specs->typespec_word == cts_bool)
9603 ("both %<long%> and %<_Bool%> in "
9604 "declaration specifiers"));
9605 else if (specs->typespec_word == cts_char)
9607 ("both %<long%> and %<char%> in "
9608 "declaration specifiers"));
9609 else if (specs->typespec_word == cts_float)
9611 ("both %<long%> and %<float%> in "
9612 "declaration specifiers"));
9613 else if (specs->typespec_word == cts_dfloat32)
9615 ("both %<long%> and %<_Decimal32%> in "
9616 "declaration specifiers"));
9617 else if (specs->typespec_word == cts_dfloat64)
9619 ("both %<long%> and %<_Decimal64%> in "
9620 "declaration specifiers"));
9621 else if (specs->typespec_word == cts_dfloat128)
9623 ("both %<long%> and %<_Decimal128%> in "
9624 "declaration specifiers"));
9627 specs->long_p = true;
9628 specs->locations[cdw_long] = loc;
9632 dupe = specs->short_p;
9635 ("both %<long%> and %<short%> in "
9636 "declaration specifiers"));
9637 else if (specs->typespec_word == cts_auto_type)
9639 ("both %<short%> and %<__auto_type%> in "
9640 "declaration specifiers"));
9641 else if (specs->typespec_word == cts_void)
9643 ("both %<short%> and %<void%> in "
9644 "declaration specifiers"));
9645 else if (specs->typespec_word == cts_int_n)
9647 ("both %<short%> and %<__int%d%> in "
9648 "declaration specifiers"),
9649 int_n_data[specs->int_n_idx].bitsize);
9650 else if (specs->typespec_word == cts_bool)
9652 ("both %<short%> and %<_Bool%> in "
9653 "declaration specifiers"));
9654 else if (specs->typespec_word == cts_char)
9656 ("both %<short%> and %<char%> in "
9657 "declaration specifiers"));
9658 else if (specs->typespec_word == cts_float)
9660 ("both %<short%> and %<float%> in "
9661 "declaration specifiers"));
9662 else if (specs->typespec_word == cts_double)
9664 ("both %<short%> and %<double%> in "
9665 "declaration specifiers"));
9666 else if (specs->typespec_word == cts_dfloat32)
9668 ("both %<short%> and %<_Decimal32%> in "
9669 "declaration specifiers"));
9670 else if (specs->typespec_word == cts_dfloat64)
9672 ("both %<short%> and %<_Decimal64%> in "
9673 "declaration specifiers"));
9674 else if (specs->typespec_word == cts_dfloat128)
9676 ("both %<short%> and %<_Decimal128%> in "
9677 "declaration specifiers"));
9680 specs->short_p = true;
9681 specs->locations[cdw_short] = loc;
9685 dupe = specs->signed_p;
9686 if (specs->unsigned_p)
9688 ("both %<signed%> and %<unsigned%> in "
9689 "declaration specifiers"));
9690 else if (specs->typespec_word == cts_auto_type)
9692 ("both %<signed%> and %<__auto_type%> in "
9693 "declaration specifiers"));
9694 else if (specs->typespec_word == cts_void)
9696 ("both %<signed%> and %<void%> in "
9697 "declaration specifiers"));
9698 else if (specs->typespec_word == cts_bool)
9700 ("both %<signed%> and %<_Bool%> in "
9701 "declaration specifiers"));
9702 else if (specs->typespec_word == cts_float)
9704 ("both %<signed%> and %<float%> in "
9705 "declaration specifiers"));
9706 else if (specs->typespec_word == cts_double)
9708 ("both %<signed%> and %<double%> in "
9709 "declaration specifiers"));
9710 else if (specs->typespec_word == cts_dfloat32)
9712 ("both %<signed%> and %<_Decimal32%> in "
9713 "declaration specifiers"));
9714 else if (specs->typespec_word == cts_dfloat64)
9716 ("both %<signed%> and %<_Decimal64%> in "
9717 "declaration specifiers"));
9718 else if (specs->typespec_word == cts_dfloat128)
9720 ("both %<signed%> and %<_Decimal128%> in "
9721 "declaration specifiers"));
9724 specs->signed_p = true;
9725 specs->locations[cdw_signed] = loc;
9729 dupe = specs->unsigned_p;
9730 if (specs->signed_p)
9732 ("both %<signed%> and %<unsigned%> in "
9733 "declaration specifiers"));
9734 else if (specs->typespec_word == cts_auto_type)
9736 ("both %<unsigned%> and %<__auto_type%> in "
9737 "declaration specifiers"));
9738 else if (specs->typespec_word == cts_void)
9740 ("both %<unsigned%> and %<void%> in "
9741 "declaration specifiers"));
9742 else if (specs->typespec_word == cts_bool)
9744 ("both %<unsigned%> and %<_Bool%> in "
9745 "declaration specifiers"));
9746 else if (specs->typespec_word == cts_float)
9748 ("both %<unsigned%> and %<float%> in "
9749 "declaration specifiers"));
9750 else if (specs->typespec_word == cts_double)
9752 ("both %<unsigned%> and %<double%> in "
9753 "declaration specifiers"));
9754 else if (specs->typespec_word == cts_dfloat32)
9756 ("both %<unsigned%> and %<_Decimal32%> in "
9757 "declaration specifiers"));
9758 else if (specs->typespec_word == cts_dfloat64)
9760 ("both %<unsigned%> and %<_Decimal64%> in "
9761 "declaration specifiers"));
9762 else if (specs->typespec_word == cts_dfloat128)
9764 ("both %<unsigned%> and %<_Decimal128%> in "
9765 "declaration specifiers"));
9768 specs->unsigned_p = true;
9769 specs->locations[cdw_unsigned] = loc;
9773 dupe = specs->complex_p;
9774 if (!in_system_header_at (loc))
9775 pedwarn_c90 (loc, OPT_Wpedantic,
9776 "ISO C90 does not support complex types");
9777 if (specs->typespec_word == cts_auto_type)
9779 ("both %<complex%> and %<__auto_type%> in "
9780 "declaration specifiers"));
9781 else if (specs->typespec_word == cts_void)
9783 ("both %<complex%> and %<void%> in "
9784 "declaration specifiers"));
9785 else if (specs->typespec_word == cts_bool)
9787 ("both %<complex%> and %<_Bool%> in "
9788 "declaration specifiers"));
9789 else if (specs->typespec_word == cts_dfloat32)
9791 ("both %<complex%> and %<_Decimal32%> in "
9792 "declaration specifiers"));
9793 else if (specs->typespec_word == cts_dfloat64)
9795 ("both %<complex%> and %<_Decimal64%> in "
9796 "declaration specifiers"));
9797 else if (specs->typespec_word == cts_dfloat128)
9799 ("both %<complex%> and %<_Decimal128%> in "
9800 "declaration specifiers"));
9801 else if (specs->typespec_word == cts_fract)
9803 ("both %<complex%> and %<_Fract%> in "
9804 "declaration specifiers"));
9805 else if (specs->typespec_word == cts_accum)
9807 ("both %<complex%> and %<_Accum%> in "
9808 "declaration specifiers"));
9809 else if (specs->saturating_p)
9811 ("both %<complex%> and %<_Sat%> in "
9812 "declaration specifiers"));
9815 specs->complex_p = true;
9816 specs->locations[cdw_complex] = loc;
9820 dupe = specs->saturating_p;
9821 pedwarn (loc, OPT_Wpedantic,
9822 "ISO C does not support saturating types");
9823 if (specs->typespec_word == cts_int_n)
9826 ("both %<_Sat%> and %<__int%d%> in "
9827 "declaration specifiers"),
9828 int_n_data[specs->int_n_idx].bitsize);
9830 else if (specs->typespec_word == cts_auto_type)
9832 ("both %<_Sat%> and %<__auto_type%> in "
9833 "declaration specifiers"));
9834 else if (specs->typespec_word == cts_void)
9836 ("both %<_Sat%> and %<void%> in "
9837 "declaration specifiers"));
9838 else if (specs->typespec_word == cts_bool)
9840 ("both %<_Sat%> and %<_Bool%> in "
9841 "declaration specifiers"));
9842 else if (specs->typespec_word == cts_char)
9844 ("both %<_Sat%> and %<char%> in "
9845 "declaration specifiers"));
9846 else if (specs->typespec_word == cts_int)
9848 ("both %<_Sat%> and %<int%> in "
9849 "declaration specifiers"));
9850 else if (specs->typespec_word == cts_float)
9852 ("both %<_Sat%> and %<float%> in "
9853 "declaration specifiers"));
9854 else if (specs->typespec_word == cts_double)
9856 ("both %<_Sat%> and %<double%> in "
9857 "declaration specifiers"));
9858 else if (specs->typespec_word == cts_dfloat32)
9860 ("both %<_Sat%> and %<_Decimal32%> in "
9861 "declaration specifiers"));
9862 else if (specs->typespec_word == cts_dfloat64)
9864 ("both %<_Sat%> and %<_Decimal64%> in "
9865 "declaration specifiers"));
9866 else if (specs->typespec_word == cts_dfloat128)
9868 ("both %<_Sat%> and %<_Decimal128%> in "
9869 "declaration specifiers"));
9870 else if (specs->complex_p)
9872 ("both %<_Sat%> and %<complex%> in "
9873 "declaration specifiers"));
9876 specs->saturating_p = true;
9877 specs->locations[cdw_saturating] = loc;
9885 error_at (loc, "duplicate %qE", type);
9891 /* "void", "_Bool", "char", "int", "float", "double", "_Decimal32",
9892 "__intN", "_Decimal64", "_Decimal128", "_Fract", "_Accum" or
9894 if (specs->typespec_word != cts_none)
9897 "two or more data types in declaration specifiers");
9905 ("both %<long%> and %<__auto_type%> in "
9906 "declaration specifiers"));
9907 else if (specs->short_p)
9909 ("both %<short%> and %<__auto_type%> in "
9910 "declaration specifiers"));
9911 else if (specs->signed_p)
9913 ("both %<signed%> and %<__auto_type%> in "
9914 "declaration specifiers"));
9915 else if (specs->unsigned_p)
9917 ("both %<unsigned%> and %<__auto_type%> in "
9918 "declaration specifiers"));
9919 else if (specs->complex_p)
9921 ("both %<complex%> and %<__auto_type%> in "
9922 "declaration specifiers"));
9923 else if (specs->saturating_p)
9925 ("both %<_Sat%> and %<__auto_type%> in "
9926 "declaration specifiers"));
9929 specs->typespec_word = cts_auto_type;
9930 specs->locations[cdw_typespec] = loc;
9937 specs->int_n_idx = i - RID_INT_N_0;
9938 if (!in_system_header_at (input_location))
9939 pedwarn (loc, OPT_Wpedantic,
9940 "ISO C does not support %<__int%d%> types",
9941 int_n_data[specs->int_n_idx].bitsize);
9945 ("both %<__int%d%> and %<long%> in "
9946 "declaration specifiers"),
9947 int_n_data[specs->int_n_idx].bitsize);
9948 else if (specs->saturating_p)
9950 ("both %<_Sat%> and %<__int%d%> in "
9951 "declaration specifiers"),
9952 int_n_data[specs->int_n_idx].bitsize);
9953 else if (specs->short_p)
9955 ("both %<__int%d%> and %<short%> in "
9956 "declaration specifiers"),
9957 int_n_data[specs->int_n_idx].bitsize);
9958 else if (! int_n_enabled_p [specs->int_n_idx])
9960 "%<__int%d%> is not supported on this target",
9961 int_n_data[specs->int_n_idx].bitsize);
9964 specs->typespec_word = cts_int_n;
9965 specs->locations[cdw_typespec] = loc;
9971 ("both %<long%> and %<void%> in "
9972 "declaration specifiers"));
9973 else if (specs->short_p)
9975 ("both %<short%> and %<void%> in "
9976 "declaration specifiers"));
9977 else if (specs->signed_p)
9979 ("both %<signed%> and %<void%> in "
9980 "declaration specifiers"));
9981 else if (specs->unsigned_p)
9983 ("both %<unsigned%> and %<void%> in "
9984 "declaration specifiers"));
9985 else if (specs->complex_p)
9987 ("both %<complex%> and %<void%> in "
9988 "declaration specifiers"));
9989 else if (specs->saturating_p)
9991 ("both %<_Sat%> and %<void%> in "
9992 "declaration specifiers"));
9995 specs->typespec_word = cts_void;
9996 specs->locations[cdw_typespec] = loc;
10000 if (!in_system_header_at (loc))
10001 pedwarn_c90 (loc, OPT_Wpedantic,
10002 "ISO C90 does not support boolean types");
10005 ("both %<long%> and %<_Bool%> in "
10006 "declaration specifiers"));
10007 else if (specs->short_p)
10009 ("both %<short%> and %<_Bool%> in "
10010 "declaration specifiers"));
10011 else if (specs->signed_p)
10013 ("both %<signed%> and %<_Bool%> in "
10014 "declaration specifiers"));
10015 else if (specs->unsigned_p)
10017 ("both %<unsigned%> and %<_Bool%> in "
10018 "declaration specifiers"));
10019 else if (specs->complex_p)
10021 ("both %<complex%> and %<_Bool%> in "
10022 "declaration specifiers"));
10023 else if (specs->saturating_p)
10025 ("both %<_Sat%> and %<_Bool%> in "
10026 "declaration specifiers"));
10029 specs->typespec_word = cts_bool;
10030 specs->locations[cdw_typespec] = loc;
10036 ("both %<long%> and %<char%> in "
10037 "declaration specifiers"));
10038 else if (specs->short_p)
10040 ("both %<short%> and %<char%> in "
10041 "declaration specifiers"));
10042 else if (specs->saturating_p)
10044 ("both %<_Sat%> and %<char%> in "
10045 "declaration specifiers"));
10048 specs->typespec_word = cts_char;
10049 specs->locations[cdw_typespec] = loc;
10053 if (specs->saturating_p)
10055 ("both %<_Sat%> and %<int%> in "
10056 "declaration specifiers"));
10059 specs->typespec_word = cts_int;
10060 specs->locations[cdw_typespec] = loc;
10066 ("both %<long%> and %<float%> in "
10067 "declaration specifiers"));
10068 else if (specs->short_p)
10070 ("both %<short%> and %<float%> in "
10071 "declaration specifiers"));
10072 else if (specs->signed_p)
10074 ("both %<signed%> and %<float%> in "
10075 "declaration specifiers"));
10076 else if (specs->unsigned_p)
10078 ("both %<unsigned%> and %<float%> in "
10079 "declaration specifiers"));
10080 else if (specs->saturating_p)
10082 ("both %<_Sat%> and %<float%> in "
10083 "declaration specifiers"));
10086 specs->typespec_word = cts_float;
10087 specs->locations[cdw_typespec] = loc;
10091 if (specs->long_long_p)
10093 ("both %<long long%> and %<double%> in "
10094 "declaration specifiers"));
10095 else if (specs->short_p)
10097 ("both %<short%> and %<double%> in "
10098 "declaration specifiers"));
10099 else if (specs->signed_p)
10101 ("both %<signed%> and %<double%> in "
10102 "declaration specifiers"));
10103 else if (specs->unsigned_p)
10105 ("both %<unsigned%> and %<double%> in "
10106 "declaration specifiers"));
10107 else if (specs->saturating_p)
10109 ("both %<_Sat%> and %<double%> in "
10110 "declaration specifiers"));
10113 specs->typespec_word = cts_double;
10114 specs->locations[cdw_typespec] = loc;
10119 case RID_DFLOAT128:
10122 if (i == RID_DFLOAT32)
10123 str = "_Decimal32";
10124 else if (i == RID_DFLOAT64)
10125 str = "_Decimal64";
10127 str = "_Decimal128";
10128 if (specs->long_long_p)
10130 ("both %<long long%> and %<%s%> in "
10131 "declaration specifiers"),
10135 ("both %<long%> and %<%s%> in "
10136 "declaration specifiers"),
10138 else if (specs->short_p)
10140 ("both %<short%> and %<%s%> in "
10141 "declaration specifiers"),
10143 else if (specs->signed_p)
10145 ("both %<signed%> and %<%s%> in "
10146 "declaration specifiers"),
10148 else if (specs->unsigned_p)
10150 ("both %<unsigned%> and %<%s%> in "
10151 "declaration specifiers"),
10153 else if (specs->complex_p)
10155 ("both %<complex%> and %<%s%> in "
10156 "declaration specifiers"),
10158 else if (specs->saturating_p)
10160 ("both %<_Sat%> and %<%s%> in "
10161 "declaration specifiers"),
10163 else if (i == RID_DFLOAT32)
10164 specs->typespec_word = cts_dfloat32;
10165 else if (i == RID_DFLOAT64)
10166 specs->typespec_word = cts_dfloat64;
10168 specs->typespec_word = cts_dfloat128;
10169 specs->locations[cdw_typespec] = loc;
10171 if (!targetm.decimal_float_supported_p ())
10173 ("decimal floating point not supported "
10174 "for this target"));
10175 pedwarn (loc, OPT_Wpedantic,
10176 "ISO C does not support decimal floating point");
10182 if (i == RID_FRACT)
10186 if (specs->complex_p)
10188 ("both %<complex%> and %<%s%> in "
10189 "declaration specifiers"),
10191 else if (i == RID_FRACT)
10192 specs->typespec_word = cts_fract;
10194 specs->typespec_word = cts_accum;
10195 specs->locations[cdw_typespec] = loc;
10197 if (!targetm.fixed_point_supported_p ())
10199 "fixed-point types not supported for this target");
10200 pedwarn (loc, OPT_Wpedantic,
10201 "ISO C does not support fixed-point types");
10204 /* ObjC reserved word "id", handled below. */
10210 /* Now we have a typedef (a TYPE_DECL node), an identifier (some
10211 form of ObjC type, cases such as "int" and "long" being handled
10212 above), a TYPE (struct, union, enum and typeof specifiers) or an
10213 ERROR_MARK. In none of these cases may there have previously
10214 been any type specifiers. */
10215 if (specs->type || specs->typespec_word != cts_none
10216 || specs->long_p || specs->short_p || specs->signed_p
10217 || specs->unsigned_p || specs->complex_p)
10218 error_at (loc, "two or more data types in declaration specifiers");
10219 else if (TREE_CODE (type) == TYPE_DECL)
10221 if (TREE_TYPE (type) == error_mark_node)
10222 ; /* Allow the type to default to int to avoid cascading errors. */
10225 specs->type = TREE_TYPE (type);
10226 specs->decl_attr = DECL_ATTRIBUTES (type);
10227 specs->typedef_p = true;
10228 specs->explicit_signed_p = C_TYPEDEF_EXPLICITLY_SIGNED (type);
10229 specs->locations[cdw_typedef] = loc;
10231 /* If this typedef name is defined in a struct, then a C++
10232 lookup would return a different value. */
10233 if (warn_cxx_compat
10234 && I_SYMBOL_BINDING (DECL_NAME (type))->in_struct)
10235 warning_at (loc, OPT_Wc___compat,
10236 "C++ lookup of %qD would return a field, not a type",
10239 /* If we are parsing a struct, record that a struct field
10241 if (warn_cxx_compat && struct_parse_info != NULL)
10242 struct_parse_info->typedefs_seen.safe_push (type);
10245 else if (TREE_CODE (type) == IDENTIFIER_NODE)
10247 tree t = lookup_name (type);
10248 if (!t || TREE_CODE (t) != TYPE_DECL)
10249 error_at (loc, "%qE fails to be a typedef or built in type", type);
10250 else if (TREE_TYPE (t) == error_mark_node)
10254 specs->type = TREE_TYPE (t);
10255 specs->locations[cdw_typespec] = loc;
10260 if (TREE_CODE (type) != ERROR_MARK && spec.kind == ctsk_typeof)
10262 specs->typedef_p = true;
10263 specs->locations[cdw_typedef] = loc;
10267 specs->expr = build2 (COMPOUND_EXPR, TREE_TYPE (spec.expr),
10268 specs->expr, spec.expr);
10270 specs->expr = spec.expr;
10271 specs->expr_const_operands &= spec.expr_const_operands;
10274 specs->type = type;
10280 /* Add the storage class specifier or function specifier SCSPEC to the
10281 declaration specifiers SPECS, returning SPECS. */
10283 struct c_declspecs *
10284 declspecs_add_scspec (source_location loc,
10285 struct c_declspecs *specs,
10289 enum c_storage_class n = csc_none;
10291 specs->declspecs_seen_p = true;
10292 gcc_assert (TREE_CODE (scspec) == IDENTIFIER_NODE
10293 && C_IS_RESERVED_WORD (scspec));
10294 i = C_RID_CODE (scspec);
10295 if (specs->non_sc_seen_p)
10296 warning (OPT_Wold_style_declaration,
10297 "%qE is not at beginning of declaration", scspec);
10301 /* C99 permits duplicate inline. Although of doubtful utility,
10302 it seems simplest to permit it in gnu89 mode as well, as
10303 there is also little utility in maintaining this as a
10304 difference between gnu89 and C99 inline. */
10306 specs->inline_p = true;
10307 specs->locations[cdw_inline] = loc;
10310 /* Duplicate _Noreturn is permitted. */
10312 specs->noreturn_p = true;
10313 specs->locations[cdw_noreturn] = loc;
10316 dupe = specs->thread_p;
10317 if (specs->storage_class == csc_auto)
10318 error ("%qE used with %<auto%>", scspec);
10319 else if (specs->storage_class == csc_register)
10320 error ("%qE used with %<register%>", scspec);
10321 else if (specs->storage_class == csc_typedef)
10322 error ("%qE used with %<typedef%>", scspec);
10325 specs->thread_p = true;
10326 specs->thread_gnu_p = (strcmp (IDENTIFIER_POINTER (scspec),
10328 /* A diagnostic is not required for the use of this
10329 identifier in the implementation namespace; only diagnose
10330 it for the C11 spelling because of existing code using
10331 the other spelling. */
10332 if (!specs->thread_gnu_p)
10335 pedwarn_c99 (loc, OPT_Wpedantic,
10336 "ISO C99 does not support %qE", scspec);
10338 pedwarn_c99 (loc, OPT_Wpedantic,
10339 "ISO C90 does not support %qE", scspec);
10341 specs->locations[cdw_thread] = loc;
10349 /* Diagnose "__thread extern". */
10350 if (specs->thread_p && specs->thread_gnu_p)
10351 error ("%<__thread%> before %<extern%>");
10358 /* Diagnose "__thread static". */
10359 if (specs->thread_p && specs->thread_gnu_p)
10360 error ("%<__thread%> before %<static%>");
10366 gcc_unreachable ();
10368 if (n != csc_none && n == specs->storage_class)
10372 if (i == RID_THREAD)
10373 error ("duplicate %<_Thread_local%> or %<__thread%>");
10375 error ("duplicate %qE", scspec);
10379 if (specs->storage_class != csc_none && n != specs->storage_class)
10381 error ("multiple storage classes in declaration specifiers");
10385 specs->storage_class = n;
10386 specs->locations[cdw_storage_class] = loc;
10387 if (n != csc_extern && n != csc_static && specs->thread_p)
10389 error ("%qs used with %qE",
10390 specs->thread_gnu_p ? "__thread" : "_Thread_local",
10392 specs->thread_p = false;
10399 /* Add the attributes ATTRS to the declaration specifiers SPECS,
10400 returning SPECS. */
10402 struct c_declspecs *
10403 declspecs_add_attrs (source_location loc, struct c_declspecs *specs, tree attrs)
10405 specs->attrs = chainon (attrs, specs->attrs);
10406 specs->locations[cdw_attributes] = loc;
10407 specs->declspecs_seen_p = true;
10411 /* Add an _Alignas specifier (expression ALIGN, or type whose
10412 alignment is ALIGN) to the declaration specifiers SPECS, returning
10414 struct c_declspecs *
10415 declspecs_add_alignas (source_location loc,
10416 struct c_declspecs *specs, tree align)
10419 specs->alignas_p = true;
10420 specs->locations[cdw_alignas] = loc;
10421 if (align == error_mark_node)
10423 align_log = check_user_alignment (align, true);
10424 if (align_log > specs->align_log)
10425 specs->align_log = align_log;
10429 /* Combine "long", "short", "signed", "unsigned" and "_Complex" type
10430 specifiers with any other type specifier to determine the resulting
10431 type. This is where ISO C checks on complex types are made, since
10432 "_Complex long" is a prefix of the valid ISO C type "_Complex long
10435 struct c_declspecs *
10436 finish_declspecs (struct c_declspecs *specs)
10438 /* If a type was specified as a whole, we have no modifiers and are
10440 if (specs->type != NULL_TREE)
10442 gcc_assert (!specs->long_p && !specs->long_long_p && !specs->short_p
10443 && !specs->signed_p && !specs->unsigned_p
10444 && !specs->complex_p);
10446 /* Set a dummy type. */
10447 if (TREE_CODE (specs->type) == ERROR_MARK)
10448 specs->type = integer_type_node;
10452 /* If none of "void", "_Bool", "char", "int", "float" or "double"
10453 has been specified, treat it as "int" unless "_Complex" is
10454 present and there are no other specifiers. If we just have
10455 "_Complex", it is equivalent to "_Complex double", but e.g.
10456 "_Complex short" is equivalent to "_Complex short int". */
10457 if (specs->typespec_word == cts_none)
10459 if (specs->saturating_p)
10461 error_at (specs->locations[cdw_saturating],
10462 "%<_Sat%> is used without %<_Fract%> or %<_Accum%>");
10463 if (!targetm.fixed_point_supported_p ())
10464 error_at (specs->locations[cdw_saturating],
10465 "fixed-point types not supported for this target");
10466 specs->typespec_word = cts_fract;
10468 else if (specs->long_p || specs->short_p
10469 || specs->signed_p || specs->unsigned_p)
10471 specs->typespec_word = cts_int;
10473 else if (specs->complex_p)
10475 specs->typespec_word = cts_double;
10476 pedwarn (specs->locations[cdw_complex], OPT_Wpedantic,
10477 "ISO C does not support plain %<complex%> meaning "
10478 "%<double complex%>");
10482 specs->typespec_word = cts_int;
10483 specs->default_int_p = true;
10484 /* We don't diagnose this here because grokdeclarator will
10485 give more specific diagnostics according to whether it is
10486 a function definition. */
10490 /* If "signed" was specified, record this to distinguish "int" and
10491 "signed int" in the case of a bit-field with
10492 -funsigned-bitfields. */
10493 specs->explicit_signed_p = specs->signed_p;
10495 /* Now compute the actual type. */
10496 switch (specs->typespec_word)
10498 case cts_auto_type:
10499 gcc_assert (!specs->long_p && !specs->short_p
10500 && !specs->signed_p && !specs->unsigned_p
10501 && !specs->complex_p);
10502 /* Type to be filled in later. */
10505 gcc_assert (!specs->long_p && !specs->short_p
10506 && !specs->signed_p && !specs->unsigned_p
10507 && !specs->complex_p);
10508 specs->type = void_type_node;
10511 gcc_assert (!specs->long_p && !specs->short_p
10512 && !specs->signed_p && !specs->unsigned_p
10513 && !specs->complex_p);
10514 specs->type = boolean_type_node;
10517 gcc_assert (!specs->long_p && !specs->short_p);
10518 gcc_assert (!(specs->signed_p && specs->unsigned_p));
10519 if (specs->signed_p)
10520 specs->type = signed_char_type_node;
10521 else if (specs->unsigned_p)
10522 specs->type = unsigned_char_type_node;
10524 specs->type = char_type_node;
10525 if (specs->complex_p)
10527 pedwarn (specs->locations[cdw_complex], OPT_Wpedantic,
10528 "ISO C does not support complex integer types");
10529 specs->type = build_complex_type (specs->type);
10533 gcc_assert (!specs->long_p && !specs->short_p && !specs->long_long_p);
10534 gcc_assert (!(specs->signed_p && specs->unsigned_p));
10535 specs->type = (specs->unsigned_p
10536 ? int_n_trees[specs->int_n_idx].unsigned_type
10537 : int_n_trees[specs->int_n_idx].signed_type);
10538 if (specs->complex_p)
10540 pedwarn (specs->locations[cdw_complex], OPT_Wpedantic,
10541 "ISO C does not support complex integer types");
10542 specs->type = build_complex_type (specs->type);
10546 gcc_assert (!(specs->long_p && specs->short_p));
10547 gcc_assert (!(specs->signed_p && specs->unsigned_p));
10548 if (specs->long_long_p)
10549 specs->type = (specs->unsigned_p
10550 ? long_long_unsigned_type_node
10551 : long_long_integer_type_node);
10552 else if (specs->long_p)
10553 specs->type = (specs->unsigned_p
10554 ? long_unsigned_type_node
10555 : long_integer_type_node);
10556 else if (specs->short_p)
10557 specs->type = (specs->unsigned_p
10558 ? short_unsigned_type_node
10559 : short_integer_type_node);
10561 specs->type = (specs->unsigned_p
10562 ? unsigned_type_node
10563 : integer_type_node);
10564 if (specs->complex_p)
10566 pedwarn (specs->locations[cdw_complex], OPT_Wpedantic,
10567 "ISO C does not support complex integer types");
10568 specs->type = build_complex_type (specs->type);
10572 gcc_assert (!specs->long_p && !specs->short_p
10573 && !specs->signed_p && !specs->unsigned_p);
10574 specs->type = (specs->complex_p
10575 ? complex_float_type_node
10576 : float_type_node);
10579 gcc_assert (!specs->long_long_p && !specs->short_p
10580 && !specs->signed_p && !specs->unsigned_p);
10583 specs->type = (specs->complex_p
10584 ? complex_long_double_type_node
10585 : long_double_type_node);
10589 specs->type = (specs->complex_p
10590 ? complex_double_type_node
10591 : double_type_node);
10596 case cts_dfloat128:
10597 gcc_assert (!specs->long_p && !specs->long_long_p && !specs->short_p
10598 && !specs->signed_p && !specs->unsigned_p && !specs->complex_p);
10599 if (specs->typespec_word == cts_dfloat32)
10600 specs->type = dfloat32_type_node;
10601 else if (specs->typespec_word == cts_dfloat64)
10602 specs->type = dfloat64_type_node;
10604 specs->type = dfloat128_type_node;
10607 gcc_assert (!specs->complex_p);
10608 if (!targetm.fixed_point_supported_p ())
10609 specs->type = integer_type_node;
10610 else if (specs->saturating_p)
10612 if (specs->long_long_p)
10613 specs->type = specs->unsigned_p
10614 ? sat_unsigned_long_long_fract_type_node
10615 : sat_long_long_fract_type_node;
10616 else if (specs->long_p)
10617 specs->type = specs->unsigned_p
10618 ? sat_unsigned_long_fract_type_node
10619 : sat_long_fract_type_node;
10620 else if (specs->short_p)
10621 specs->type = specs->unsigned_p
10622 ? sat_unsigned_short_fract_type_node
10623 : sat_short_fract_type_node;
10625 specs->type = specs->unsigned_p
10626 ? sat_unsigned_fract_type_node
10627 : sat_fract_type_node;
10631 if (specs->long_long_p)
10632 specs->type = specs->unsigned_p
10633 ? unsigned_long_long_fract_type_node
10634 : long_long_fract_type_node;
10635 else if (specs->long_p)
10636 specs->type = specs->unsigned_p
10637 ? unsigned_long_fract_type_node
10638 : long_fract_type_node;
10639 else if (specs->short_p)
10640 specs->type = specs->unsigned_p
10641 ? unsigned_short_fract_type_node
10642 : short_fract_type_node;
10644 specs->type = specs->unsigned_p
10645 ? unsigned_fract_type_node
10650 gcc_assert (!specs->complex_p);
10651 if (!targetm.fixed_point_supported_p ())
10652 specs->type = integer_type_node;
10653 else if (specs->saturating_p)
10655 if (specs->long_long_p)
10656 specs->type = specs->unsigned_p
10657 ? sat_unsigned_long_long_accum_type_node
10658 : sat_long_long_accum_type_node;
10659 else if (specs->long_p)
10660 specs->type = specs->unsigned_p
10661 ? sat_unsigned_long_accum_type_node
10662 : sat_long_accum_type_node;
10663 else if (specs->short_p)
10664 specs->type = specs->unsigned_p
10665 ? sat_unsigned_short_accum_type_node
10666 : sat_short_accum_type_node;
10668 specs->type = specs->unsigned_p
10669 ? sat_unsigned_accum_type_node
10670 : sat_accum_type_node;
10674 if (specs->long_long_p)
10675 specs->type = specs->unsigned_p
10676 ? unsigned_long_long_accum_type_node
10677 : long_long_accum_type_node;
10678 else if (specs->long_p)
10679 specs->type = specs->unsigned_p
10680 ? unsigned_long_accum_type_node
10681 : long_accum_type_node;
10682 else if (specs->short_p)
10683 specs->type = specs->unsigned_p
10684 ? unsigned_short_accum_type_node
10685 : short_accum_type_node;
10687 specs->type = specs->unsigned_p
10688 ? unsigned_accum_type_node
10693 gcc_unreachable ();
10699 /* A subroutine of c_write_global_declarations. Perform final processing
10700 on one file scope's declarations (or the external scope's declarations),
10704 c_write_global_declarations_1 (tree globals)
10709 /* Process the decls in the order they were written. */
10710 for (decl = globals; decl; decl = DECL_CHAIN (decl))
10712 /* Check for used but undefined static functions using the C
10713 standard's definition of "used", and set TREE_NO_WARNING so
10714 that check_global_declarations doesn't repeat the check. */
10715 if (TREE_CODE (decl) == FUNCTION_DECL
10716 && DECL_INITIAL (decl) == 0
10717 && DECL_EXTERNAL (decl)
10718 && !TREE_PUBLIC (decl)
10719 && C_DECL_USED (decl))
10721 pedwarn (input_location, 0, "%q+F used but never defined", decl);
10722 TREE_NO_WARNING (decl) = 1;
10725 wrapup_global_declaration_1 (decl);
10730 reconsider = false;
10731 for (decl = globals; decl; decl = DECL_CHAIN (decl))
10732 reconsider |= wrapup_global_declaration_2 (decl);
10734 while (reconsider);
10736 for (decl = globals; decl; decl = DECL_CHAIN (decl))
10737 check_global_declaration_1 (decl);
10740 /* A subroutine of c_write_global_declarations Emit debug information for each
10741 of the declarations in GLOBALS. */
10744 c_write_global_declarations_2 (tree globals)
10748 for (decl = globals; decl ; decl = DECL_CHAIN (decl))
10749 debug_hooks->global_decl (decl);
10752 /* Callback to collect a source_ref from a DECL. */
10755 collect_source_ref_cb (tree decl)
10757 if (!DECL_IS_BUILTIN (decl))
10758 collect_source_ref (LOCATION_FILE (decl_sloc (decl, false)));
10761 /* Preserve the external declarations scope across a garbage collect. */
10762 static GTY(()) tree ext_block;
10764 /* Collect all references relevant to SOURCE_FILE. */
10767 collect_all_refs (const char *source_file)
10772 FOR_EACH_VEC_ELT (*all_translation_units, i, t)
10773 collect_ada_nodes (BLOCK_VARS (DECL_INITIAL (t)), source_file);
10775 collect_ada_nodes (BLOCK_VARS (ext_block), source_file);
10778 /* Iterate over all global declarations and call CALLBACK. */
10781 for_each_global_decl (void (*callback) (tree decl))
10788 FOR_EACH_VEC_ELT (*all_translation_units, i, t)
10790 decls = DECL_INITIAL (t);
10791 for (decl = BLOCK_VARS (decls); decl; decl = TREE_CHAIN (decl))
10795 for (decl = BLOCK_VARS (ext_block); decl; decl = TREE_CHAIN (decl))
10800 c_write_global_declarations (void)
10805 /* We don't want to do this if generating a PCH. */
10809 timevar_start (TV_PHASE_DEFERRED);
10811 /* Do the Objective-C stuff. This is where all the Objective-C
10812 module stuff gets generated (symtab, class/protocol/selector
10814 if (c_dialect_objc ())
10815 objc_write_global_declarations ();
10817 /* Close the external scope. */
10818 ext_block = pop_scope ();
10819 external_scope = 0;
10820 gcc_assert (!current_scope);
10822 /* Handle -fdump-ada-spec[-slim]. */
10823 if (flag_dump_ada_spec || flag_dump_ada_spec_slim)
10825 /* Build a table of files to generate specs for */
10826 if (flag_dump_ada_spec_slim)
10827 collect_source_ref (main_input_filename);
10829 for_each_global_decl (collect_source_ref_cb);
10831 dump_ada_specs (collect_all_refs, NULL);
10836 tree tmp = BLOCK_VARS (ext_block);
10838 FILE * stream = dump_begin (TDI_tu, &flags);
10841 dump_node (tmp, flags & ~TDF_SLIM, stream);
10842 dump_end (TDI_tu, stream);
10846 /* Process all file scopes in this compilation, and the external_scope,
10847 through wrapup_global_declarations and check_global_declarations. */
10848 FOR_EACH_VEC_ELT (*all_translation_units, i, t)
10849 c_write_global_declarations_1 (BLOCK_VARS (DECL_INITIAL (t)));
10850 c_write_global_declarations_1 (BLOCK_VARS (ext_block));
10852 timevar_stop (TV_PHASE_DEFERRED);
10853 timevar_start (TV_PHASE_OPT_GEN);
10855 /* We're done parsing; proceed to optimize and emit assembly.
10856 FIXME: shouldn't be the front end's responsibility to call this. */
10857 symtab->finalize_compilation_unit ();
10859 timevar_stop (TV_PHASE_OPT_GEN);
10860 timevar_start (TV_PHASE_DBGINFO);
10862 /* After cgraph has had a chance to emit everything that's going to
10863 be emitted, output debug information for globals. */
10864 if (!seen_error ())
10866 timevar_push (TV_SYMOUT);
10867 FOR_EACH_VEC_ELT (*all_translation_units, i, t)
10868 c_write_global_declarations_2 (BLOCK_VARS (DECL_INITIAL (t)));
10869 c_write_global_declarations_2 (BLOCK_VARS (ext_block));
10870 timevar_pop (TV_SYMOUT);
10874 timevar_stop (TV_PHASE_DBGINFO);
10877 /* Register reserved keyword WORD as qualifier for address space AS. */
10880 c_register_addr_space (const char *word, addr_space_t as)
10882 int rid = RID_FIRST_ADDR_SPACE + as;
10885 /* Address space qualifiers are only supported
10886 in C with GNU extensions enabled. */
10887 if (c_dialect_objc () || flag_no_asm)
10890 id = get_identifier (word);
10891 C_SET_RID_CODE (id, rid);
10892 C_IS_RESERVED_WORD (id) = 1;
10893 ridpointers [rid] = id;
10896 /* Return identifier to look up for omp declare reduction. */
10899 c_omp_reduction_id (enum tree_code reduction_code, tree reduction_id)
10901 const char *p = NULL;
10902 switch (reduction_code)
10904 case PLUS_EXPR: p = "+"; break;
10905 case MULT_EXPR: p = "*"; break;
10906 case MINUS_EXPR: p = "-"; break;
10907 case BIT_AND_EXPR: p = "&"; break;
10908 case BIT_XOR_EXPR: p = "^"; break;
10909 case BIT_IOR_EXPR: p = "|"; break;
10910 case TRUTH_ANDIF_EXPR: p = "&&"; break;
10911 case TRUTH_ORIF_EXPR: p = "||"; break;
10912 case MIN_EXPR: p = "min"; break;
10913 case MAX_EXPR: p = "max"; break;
10920 if (TREE_CODE (reduction_id) != IDENTIFIER_NODE)
10921 return error_mark_node;
10922 p = IDENTIFIER_POINTER (reduction_id);
10925 const char prefix[] = "omp declare reduction ";
10926 size_t lenp = sizeof (prefix);
10927 size_t len = strlen (p);
10928 char *name = XALLOCAVEC (char, lenp + len);
10929 memcpy (name, prefix, lenp - 1);
10930 memcpy (name + lenp - 1, p, len + 1);
10931 return get_identifier (name);
10934 /* Lookup REDUCTION_ID in the current scope, or create an artificial
10935 VAR_DECL, bind it into the current scope and return it. */
10938 c_omp_reduction_decl (tree reduction_id)
10940 struct c_binding *b = I_SYMBOL_BINDING (reduction_id);
10941 if (b != NULL && B_IN_CURRENT_SCOPE (b))
10944 tree decl = build_decl (BUILTINS_LOCATION, VAR_DECL,
10945 reduction_id, integer_type_node);
10946 DECL_ARTIFICIAL (decl) = 1;
10947 DECL_EXTERNAL (decl) = 1;
10948 TREE_STATIC (decl) = 1;
10949 TREE_PUBLIC (decl) = 0;
10950 bind (reduction_id, decl, current_scope, true, false, BUILTINS_LOCATION);
10954 /* Lookup REDUCTION_ID in the first scope where it has entry for TYPE. */
10957 c_omp_reduction_lookup (tree reduction_id, tree type)
10959 struct c_binding *b = I_SYMBOL_BINDING (reduction_id);
10963 for (t = DECL_INITIAL (b->decl); t; t = TREE_CHAIN (t))
10964 if (comptypes (TREE_PURPOSE (t), type))
10965 return TREE_VALUE (t);
10968 return error_mark_node;
10971 /* Helper function called via walk_tree, to diagnose invalid
10972 #pragma omp declare reduction combiners or initializers. */
10975 c_check_omp_declare_reduction_r (tree *tp, int *, void *data)
10977 tree *vars = (tree *) data;
10978 if (SSA_VAR_P (*tp)
10979 && !DECL_ARTIFICIAL (*tp)
10983 location_t loc = DECL_SOURCE_LOCATION (vars[0]);
10984 if (strcmp (IDENTIFIER_POINTER (DECL_NAME (vars[0])), "omp_out") == 0)
10985 error_at (loc, "%<#pragma omp declare reduction%> combiner refers to "
10986 "variable %qD which is not %<omp_out%> nor %<omp_in%>",
10989 error_at (loc, "%<#pragma omp declare reduction%> initializer refers "
10990 "to variable %qD which is not %<omp_priv%> nor "
10998 #include "gt-c-c-decl.h"