VOP_FSYNC.9: Missing comma
[dragonfly.git] / contrib / gcc-4.7 / gcc / c-decl.c
1 /* Process declarations and variables for C compiler.
2    Copyright (C) 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
3    2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012
4    Free Software Foundation, Inc.
5
6 This file is part of GCC.
7
8 GCC is free software; you can redistribute it and/or modify it under
9 the terms of the GNU General Public License as published by the Free
10 Software Foundation; either version 3, or (at your option) any later
11 version.
12
13 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
14 WARRANTY; without even the implied warranty of MERCHANTABILITY or
15 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
16 for more details.
17
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING3.  If not see
20 <http://www.gnu.org/licenses/>.  */
21
22 /* Process declarations and symbol lookup for C front end.
23    Also constructs types; the standard scalar types at initialization,
24    and structure, union, array and enum types when they are declared.  */
25
26 /* ??? not all decl nodes are given the most useful possible
27    line numbers.  For example, the CONST_DECLs for enum values.  */
28
29 #include "config.h"
30 #include "system.h"
31 #include "coretypes.h"
32 #include "input.h"
33 #include "tm.h"
34 #include "intl.h"
35 #include "tree.h"
36 #include "tree-inline.h"
37 #include "flags.h"
38 #include "function.h"
39 #include "output.h"
40 #include "c-tree.h"
41 #include "toplev.h"
42 #include "tm_p.h"
43 #include "cpplib.h"
44 #include "target.h"
45 #include "debug.h"
46 #include "opts.h"
47 #include "timevar.h"
48 #include "c-family/c-common.h"
49 #include "c-family/c-objc.h"
50 #include "c-family/c-pragma.h"
51 #include "c-lang.h"
52 #include "langhooks.h"
53 #include "tree-iterator.h"
54 #include "diagnostic-core.h"
55 #include "tree-dump.h"
56 #include "cgraph.h"
57 #include "hashtab.h"
58 #include "langhooks-def.h"
59 #include "pointer-set.h"
60 #include "plugin.h"
61 #include "c-family/c-ada-spec.h"
62
63 /* In grokdeclarator, distinguish syntactic contexts of declarators.  */
64 enum decl_context
65 { NORMAL,                       /* Ordinary declaration */
66   FUNCDEF,                      /* Function definition */
67   PARM,                         /* Declaration of parm before function body */
68   FIELD,                        /* Declaration inside struct or union */
69   TYPENAME};                    /* Typename (inside cast or sizeof)  */
70
71 /* States indicating how grokdeclarator() should handle declspecs marked
72    with __attribute__((deprecated)).  An object declared as
73    __attribute__((deprecated)) suppresses warnings of uses of other
74    deprecated items.  */
75
76 enum deprecated_states {
77   DEPRECATED_NORMAL,
78   DEPRECATED_SUPPRESS
79 };
80
81 \f
82 /* Nonzero if we have seen an invalid cross reference
83    to a struct, union, or enum, but not yet printed the message.  */
84 tree pending_invalid_xref;
85
86 /* File and line to appear in the eventual error message.  */
87 location_t pending_invalid_xref_location;
88
89 /* The file and line that the prototype came from if this is an
90    old-style definition; used for diagnostics in
91    store_parm_decls_oldstyle.  */
92
93 static location_t current_function_prototype_locus;
94
95 /* Whether this prototype was built-in.  */
96
97 static bool current_function_prototype_built_in;
98
99 /* The argument type information of this prototype.  */
100
101 static tree current_function_prototype_arg_types;
102
103 /* The argument information structure for the function currently being
104    defined.  */
105
106 static struct c_arg_info *current_function_arg_info;
107
108 /* The obstack on which parser and related data structures, which are
109    not live beyond their top-level declaration or definition, are
110    allocated.  */
111 struct obstack parser_obstack;
112
113 /* The current statement tree.  */
114
115 static GTY(()) struct stmt_tree_s c_stmt_tree;
116
117 /* State saving variables.  */
118 tree c_break_label;
119 tree c_cont_label;
120
121 /* A list of decls to be made automatically visible in each file scope.  */
122 static GTY(()) tree visible_builtins;
123
124 /* Set to 0 at beginning of a function definition, set to 1 if
125    a return statement that specifies a return value is seen.  */
126
127 int current_function_returns_value;
128
129 /* Set to 0 at beginning of a function definition, set to 1 if
130    a return statement with no argument is seen.  */
131
132 int current_function_returns_null;
133
134 /* Set to 0 at beginning of a function definition, set to 1 if
135    a call to a noreturn function is seen.  */
136
137 int current_function_returns_abnormally;
138
139 /* Set to nonzero by `grokdeclarator' for a function
140    whose return type is defaulted, if warnings for this are desired.  */
141
142 static int warn_about_return_type;
143
144 /* Nonzero when the current toplevel function contains a declaration
145    of a nested function which is never defined.  */
146
147 static bool undef_nested_function;
148
149 \f
150 /* Each c_binding structure describes one binding of an identifier to
151    a decl.  All the decls in a scope - irrespective of namespace - are
152    chained together by the ->prev field, which (as the name implies)
153    runs in reverse order.  All the decls in a given namespace bound to
154    a given identifier are chained by the ->shadowed field, which runs
155    from inner to outer scopes.
156
157    The ->decl field usually points to a DECL node, but there are two
158    exceptions.  In the namespace of type tags, the bound entity is a
159    RECORD_TYPE, UNION_TYPE, or ENUMERAL_TYPE node.  If an undeclared
160    identifier is encountered, it is bound to error_mark_node to
161    suppress further errors about that identifier in the current
162    function.
163
164    The ->u.type field stores the type of the declaration in this scope;
165    if NULL, the type is the type of the ->decl field.  This is only of
166    relevance for objects with external or internal linkage which may
167    be redeclared in inner scopes, forming composite types that only
168    persist for the duration of those scopes.  In the external scope,
169    this stores the composite of all the types declared for this
170    object, visible or not.  The ->inner_comp field (used only at file
171    scope) stores whether an incomplete array type at file scope was
172    completed at an inner scope to an array size other than 1.
173
174    The ->u.label field is used for labels.  It points to a structure
175    which stores additional information used for warnings.
176
177    The depth field is copied from the scope structure that holds this
178    decl.  It is used to preserve the proper ordering of the ->shadowed
179    field (see bind()) and also for a handful of special-case checks.
180    Finally, the invisible bit is true for a decl which should be
181    ignored for purposes of normal name lookup, and the nested bit is
182    true for a decl that's been bound a second time in an inner scope;
183    in all such cases, the binding in the outer scope will have its
184    invisible bit true.  */
185
186 struct GTY((chain_next ("%h.prev"))) c_binding {
187   union GTY(()) {               /* first so GTY desc can use decl */
188     tree GTY((tag ("0"))) type; /* the type in this scope */
189     struct c_label_vars * GTY((tag ("1"))) label; /* for warnings */
190   } GTY((desc ("TREE_CODE (%0.decl) == LABEL_DECL"))) u;
191   tree decl;                    /* the decl bound */
192   tree id;                      /* the identifier it's bound to */
193   struct c_binding *prev;       /* the previous decl in this scope */
194   struct c_binding *shadowed;   /* the innermost decl shadowed by this one */
195   unsigned int depth : 28;      /* depth of this scope */
196   BOOL_BITFIELD invisible : 1;  /* normal lookup should ignore this binding */
197   BOOL_BITFIELD nested : 1;     /* do not set DECL_CONTEXT when popping */
198   BOOL_BITFIELD inner_comp : 1; /* incomplete array completed in inner scope */
199   BOOL_BITFIELD in_struct : 1;  /* currently defined as struct field */
200   location_t locus;             /* location for nested bindings */
201 };
202 #define B_IN_SCOPE(b1, b2) ((b1)->depth == (b2)->depth)
203 #define B_IN_CURRENT_SCOPE(b) ((b)->depth == current_scope->depth)
204 #define B_IN_FILE_SCOPE(b) ((b)->depth == 1 /*file_scope->depth*/)
205 #define B_IN_EXTERNAL_SCOPE(b) ((b)->depth == 0 /*external_scope->depth*/)
206
207 #define I_SYMBOL_BINDING(node) \
208   (((struct lang_identifier *) IDENTIFIER_NODE_CHECK(node))->symbol_binding)
209 #define I_SYMBOL_DECL(node) \
210  (I_SYMBOL_BINDING(node) ? I_SYMBOL_BINDING(node)->decl : 0)
211
212 #define I_TAG_BINDING(node) \
213   (((struct lang_identifier *) IDENTIFIER_NODE_CHECK(node))->tag_binding)
214 #define I_TAG_DECL(node) \
215  (I_TAG_BINDING(node) ? I_TAG_BINDING(node)->decl : 0)
216
217 #define I_LABEL_BINDING(node) \
218   (((struct lang_identifier *) IDENTIFIER_NODE_CHECK(node))->label_binding)
219 #define I_LABEL_DECL(node) \
220  (I_LABEL_BINDING(node) ? I_LABEL_BINDING(node)->decl : 0)
221
222 /* Each C symbol points to three linked lists of c_binding structures.
223    These describe the values of the identifier in the three different
224    namespaces defined by the language.  */
225
226 struct GTY(()) lang_identifier {
227   struct c_common_identifier common_id;
228   struct c_binding *symbol_binding; /* vars, funcs, constants, typedefs */
229   struct c_binding *tag_binding;    /* struct/union/enum tags */
230   struct c_binding *label_binding;  /* labels */
231 };
232
233 /* Validate c-lang.c's assumptions.  */
234 extern char C_SIZEOF_STRUCT_LANG_IDENTIFIER_isnt_accurate
235 [(sizeof(struct lang_identifier) == C_SIZEOF_STRUCT_LANG_IDENTIFIER) ? 1 : -1];
236
237 /* The resulting tree type.  */
238
239 union GTY((desc ("TREE_CODE (&%h.generic) == IDENTIFIER_NODE"),
240        chain_next ("(union lang_tree_node *) c_tree_chain_next (&%h.generic)"))) lang_tree_node
241  {
242   union tree_node GTY ((tag ("0"),
243                         desc ("tree_node_structure (&%h)")))
244     generic;
245   struct lang_identifier GTY ((tag ("1"))) identifier;
246 };
247
248 /* Track bindings and other things that matter for goto warnings.  For
249    efficiency, we do not gather all the decls at the point of
250    definition.  Instead, we point into the bindings structure.  As
251    scopes are popped, we update these structures and gather the decls
252    that matter at that time.  */
253
254 struct GTY(()) c_spot_bindings {
255   /* The currently open scope which holds bindings defined when the
256      label was defined or the goto statement was found.  */
257   struct c_scope *scope;
258   /* The bindings in the scope field which were defined at the point
259      of the label or goto.  This lets us look at older or newer
260      bindings in the scope, as appropriate.  */
261   struct c_binding *bindings_in_scope;
262   /* The number of statement expressions that have started since this
263      label or goto statement was defined.  This is zero if we are at
264      the same statement expression level.  It is positive if we are in
265      a statement expression started since this spot.  It is negative
266      if this spot was in a statement expression and we have left
267      it.  */
268   int stmt_exprs;
269   /* Whether we started in a statement expression but are no longer in
270      it.  This is set to true if stmt_exprs ever goes negative.  */
271   bool left_stmt_expr;
272 };
273
274 /* This structure is used to keep track of bindings seen when a goto
275    statement is defined.  This is only used if we see the goto
276    statement before we see the label.  */
277
278 struct GTY(()) c_goto_bindings {
279   /* The location of the goto statement.  */
280   location_t loc;
281   /* The bindings of the goto statement.  */
282   struct c_spot_bindings goto_bindings;
283 };
284
285 typedef struct c_goto_bindings *c_goto_bindings_p;
286 DEF_VEC_P(c_goto_bindings_p);
287 DEF_VEC_ALLOC_P(c_goto_bindings_p,gc);
288
289 /* The additional information we keep track of for a label binding.
290    These fields are updated as scopes are popped.  */
291
292 struct GTY(()) c_label_vars {
293   /* The shadowed c_label_vars, when one label shadows another (which
294      can only happen using a __label__ declaration).  */
295   struct c_label_vars *shadowed;
296   /* The bindings when the label was defined.  */
297   struct c_spot_bindings label_bindings;
298   /* A list of decls that we care about: decls about which we should
299      warn if a goto branches to this label from later in the function.
300      Decls are added to this list as scopes are popped.  We only add
301      the decls that matter.  */
302   VEC(tree,gc) *decls_in_scope;
303   /* A list of goto statements to this label.  This is only used for
304      goto statements seen before the label was defined, so that we can
305      issue appropriate warnings for them.  */
306   VEC(c_goto_bindings_p,gc) *gotos;
307 };
308
309 /* Each c_scope structure describes the complete contents of one
310    scope.  Four scopes are distinguished specially: the innermost or
311    current scope, the innermost function scope, the file scope (always
312    the second to outermost) and the outermost or external scope.
313
314    Most declarations are recorded in the current scope.
315
316    All normal label declarations are recorded in the innermost
317    function scope, as are bindings of undeclared identifiers to
318    error_mark_node.  (GCC permits nested functions as an extension,
319    hence the 'innermost' qualifier.)  Explicitly declared labels
320    (using the __label__ extension) appear in the current scope.
321
322    Being in the file scope (current_scope == file_scope) causes
323    special behavior in several places below.  Also, under some
324    conditions the Objective-C front end records declarations in the
325    file scope even though that isn't the current scope.
326
327    All declarations with external linkage are recorded in the external
328    scope, even if they aren't visible there; this models the fact that
329    such declarations are visible to the entire program, and (with a
330    bit of cleverness, see pushdecl) allows diagnosis of some violations
331    of C99 6.2.2p7 and 6.2.7p2:
332
333      If, within the same translation unit, the same identifier appears
334      with both internal and external linkage, the behavior is
335      undefined.
336
337      All declarations that refer to the same object or function shall
338      have compatible type; otherwise, the behavior is undefined.
339
340    Initially only the built-in declarations, which describe compiler
341    intrinsic functions plus a subset of the standard library, are in
342    this scope.
343
344    The order of the blocks list matters, and it is frequently appended
345    to.  To avoid having to walk all the way to the end of the list on
346    each insertion, or reverse the list later, we maintain a pointer to
347    the last list entry.  (FIXME: It should be feasible to use a reversed
348    list here.)
349
350    The bindings list is strictly in reverse order of declarations;
351    pop_scope relies on this.  */
352
353
354 struct GTY((chain_next ("%h.outer"))) c_scope {
355   /* The scope containing this one.  */
356   struct c_scope *outer;
357
358   /* The next outermost function scope.  */
359   struct c_scope *outer_function;
360
361   /* All bindings in this scope.  */
362   struct c_binding *bindings;
363
364   /* For each scope (except the global one), a chain of BLOCK nodes
365      for all the scopes that were entered and exited one level down.  */
366   tree blocks;
367   tree blocks_last;
368
369   /* The depth of this scope.  Used to keep the ->shadowed chain of
370      bindings sorted innermost to outermost.  */
371   unsigned int depth : 28;
372
373   /* True if we are currently filling this scope with parameter
374      declarations.  */
375   BOOL_BITFIELD parm_flag : 1;
376
377   /* True if we saw [*] in this scope.  Used to give an error messages
378      if these appears in a function definition.  */
379   BOOL_BITFIELD had_vla_unspec : 1;
380
381   /* True if we already complained about forward parameter decls
382      in this scope.  This prevents double warnings on
383      foo (int a; int b; ...)  */
384   BOOL_BITFIELD warned_forward_parm_decls : 1;
385
386   /* True if this is the outermost block scope of a function body.
387      This scope contains the parameters, the local variables declared
388      in the outermost block, and all the labels (except those in
389      nested functions, or declared at block scope with __label__).  */
390   BOOL_BITFIELD function_body : 1;
391
392   /* True means make a BLOCK for this scope no matter what.  */
393   BOOL_BITFIELD keep : 1;
394
395   /* True means that an unsuffixed float constant is _Decimal64.  */
396   BOOL_BITFIELD float_const_decimal64 : 1;
397
398   /* True if this scope has any label bindings.  This is used to speed
399      up searching for labels when popping scopes, particularly since
400      labels are normally only found at function scope.  */
401   BOOL_BITFIELD has_label_bindings : 1;
402
403   /* True if we should issue a warning if a goto statement crosses any
404      of the bindings.  We still need to check the list of bindings to
405      find the specific ones we need to warn about.  This is true if
406      decl_jump_unsafe would return true for any of the bindings.  This
407      is used to avoid looping over all the bindings unnecessarily.  */
408   BOOL_BITFIELD has_jump_unsafe_decl : 1;
409 };
410
411 /* The scope currently in effect.  */
412
413 static GTY(()) struct c_scope *current_scope;
414
415 /* The innermost function scope.  Ordinary (not explicitly declared)
416    labels, bindings to error_mark_node, and the lazily-created
417    bindings of __func__ and its friends get this scope.  */
418
419 static GTY(()) struct c_scope *current_function_scope;
420
421 /* The C file scope.  This is reset for each input translation unit.  */
422
423 static GTY(()) struct c_scope *file_scope;
424
425 /* The outermost scope.  This is used for all declarations with
426    external linkage, and only these, hence the name.  */
427
428 static GTY(()) struct c_scope *external_scope;
429
430 /* A chain of c_scope structures awaiting reuse.  */
431
432 static GTY((deletable)) struct c_scope *scope_freelist;
433
434 /* A chain of c_binding structures awaiting reuse.  */
435
436 static GTY((deletable)) struct c_binding *binding_freelist;
437
438 /* Append VAR to LIST in scope SCOPE.  */
439 #define SCOPE_LIST_APPEND(scope, list, decl) do {       \
440   struct c_scope *s_ = (scope);                         \
441   tree d_ = (decl);                                     \
442   if (s_->list##_last)                                  \
443     BLOCK_CHAIN (s_->list##_last) = d_;                 \
444   else                                                  \
445     s_->list = d_;                                      \
446   s_->list##_last = d_;                                 \
447 } while (0)
448
449 /* Concatenate FROM in scope FSCOPE onto TO in scope TSCOPE.  */
450 #define SCOPE_LIST_CONCAT(tscope, to, fscope, from) do {        \
451   struct c_scope *t_ = (tscope);                                \
452   struct c_scope *f_ = (fscope);                                \
453   if (t_->to##_last)                                            \
454     BLOCK_CHAIN (t_->to##_last) = f_->from;                     \
455   else                                                          \
456     t_->to = f_->from;                                          \
457   t_->to##_last = f_->from##_last;                              \
458 } while (0)
459
460 /* A c_inline_static structure stores details of a static identifier
461    referenced in a definition of a function that may be an inline
462    definition if no subsequent declaration of that function uses
463    "extern" or does not use "inline".  */
464
465 struct GTY((chain_next ("%h.next"))) c_inline_static {
466   /* The location for a diagnostic.  */
467   location_t location;
468
469   /* The function that may be an inline definition.  */
470   tree function;
471
472   /* The object or function referenced.  */
473   tree static_decl;
474
475   /* What sort of reference this is.  */
476   enum c_inline_static_type type;
477
478   /* The next such structure or NULL.  */
479   struct c_inline_static *next;
480 };
481
482 /* List of static identifiers used or referenced in functions that may
483    be inline definitions.  */
484 static GTY(()) struct c_inline_static *c_inline_statics;
485
486 /* True means unconditionally make a BLOCK for the next scope pushed.  */
487
488 static bool keep_next_level_flag;
489
490 /* True means the next call to push_scope will be the outermost scope
491    of a function body, so do not push a new scope, merely cease
492    expecting parameter decls.  */
493
494 static bool next_is_function_body;
495
496 /* A VEC of pointers to c_binding structures.  */
497
498 typedef struct c_binding *c_binding_ptr;
499 DEF_VEC_P(c_binding_ptr);
500 DEF_VEC_ALLOC_P(c_binding_ptr,heap);
501
502 /* Information that we keep for a struct or union while it is being
503    parsed.  */
504
505 struct c_struct_parse_info
506 {
507   /* If warn_cxx_compat, a list of types defined within this
508      struct.  */
509   VEC(tree,heap) *struct_types;
510   /* If warn_cxx_compat, a list of field names which have bindings,
511      and which are defined in this struct, but which are not defined
512      in any enclosing struct.  This is used to clear the in_struct
513      field of the c_bindings structure.  */
514   VEC(c_binding_ptr,heap) *fields;
515   /* If warn_cxx_compat, a list of typedef names used when defining
516      fields in this struct.  */
517   VEC(tree,heap) *typedefs_seen;
518 };
519
520 /* Information for the struct or union currently being parsed, or
521    NULL if not parsing a struct or union.  */
522 static struct c_struct_parse_info *struct_parse_info;
523
524 /* Forward declarations.  */
525 static tree lookup_name_in_scope (tree, struct c_scope *);
526 static tree c_make_fname_decl (location_t, tree, int);
527 static tree grokdeclarator (const struct c_declarator *,
528                             struct c_declspecs *,
529                             enum decl_context, bool, tree *, tree *, tree *,
530                             bool *, enum deprecated_states);
531 static tree grokparms (struct c_arg_info *, bool);
532 static void layout_array_type (tree);
533 \f
534 /* T is a statement.  Add it to the statement-tree.  This is the
535    C/ObjC version--C++ has a slightly different version of this
536    function.  */
537
538 tree
539 add_stmt (tree t)
540 {
541   enum tree_code code = TREE_CODE (t);
542
543   if (CAN_HAVE_LOCATION_P (t) && code != LABEL_EXPR)
544     {
545       if (!EXPR_HAS_LOCATION (t))
546         SET_EXPR_LOCATION (t, input_location);
547     }
548
549   if (code == LABEL_EXPR || code == CASE_LABEL_EXPR)
550     STATEMENT_LIST_HAS_LABEL (cur_stmt_list) = 1;
551
552   /* Add T to the statement-tree.  Non-side-effect statements need to be
553      recorded during statement expressions.  */
554   if (!building_stmt_list_p ())
555     push_stmt_list ();
556   append_to_statement_list_force (t, &cur_stmt_list);
557
558   return t;
559 }
560 \f
561 /* Return true if we will want to say something if a goto statement
562    crosses DECL.  */
563
564 static bool
565 decl_jump_unsafe (tree decl)
566 {
567   if (error_operand_p (decl))
568     return false;
569
570   /* Always warn about crossing variably modified types.  */
571   if ((TREE_CODE (decl) == VAR_DECL || TREE_CODE (decl) == TYPE_DECL)
572       && variably_modified_type_p (TREE_TYPE (decl), NULL_TREE))
573     return true;
574
575   /* Otherwise, only warn if -Wgoto-misses-init and this is an
576      initialized automatic decl.  */
577   if (warn_jump_misses_init
578       && TREE_CODE (decl) == VAR_DECL
579       && !TREE_STATIC (decl)
580       && DECL_INITIAL (decl) != NULL_TREE)
581     return true;
582
583   return false;
584 }
585 \f
586
587 void
588 c_print_identifier (FILE *file, tree node, int indent)
589 {
590   print_node (file, "symbol", I_SYMBOL_DECL (node), indent + 4);
591   print_node (file, "tag", I_TAG_DECL (node), indent + 4);
592   print_node (file, "label", I_LABEL_DECL (node), indent + 4);
593   if (C_IS_RESERVED_WORD (node) && C_RID_CODE (node) != RID_CXX_COMPAT_WARN)
594     {
595       tree rid = ridpointers[C_RID_CODE (node)];
596       indent_to (file, indent + 4);
597       fprintf (file, "rid " HOST_PTR_PRINTF " \"%s\"",
598                (void *) rid, IDENTIFIER_POINTER (rid));
599     }
600 }
601
602 /* Establish a binding between NAME, an IDENTIFIER_NODE, and DECL,
603    which may be any of several kinds of DECL or TYPE or error_mark_node,
604    in the scope SCOPE.  */
605 static void
606 bind (tree name, tree decl, struct c_scope *scope, bool invisible,
607       bool nested, location_t locus)
608 {
609   struct c_binding *b, **here;
610
611   if (binding_freelist)
612     {
613       b = binding_freelist;
614       binding_freelist = b->prev;
615     }
616   else
617     b = ggc_alloc_c_binding ();
618
619   b->shadowed = 0;
620   b->decl = decl;
621   b->id = name;
622   b->depth = scope->depth;
623   b->invisible = invisible;
624   b->nested = nested;
625   b->inner_comp = 0;
626   b->in_struct = 0;
627   b->locus = locus;
628
629   b->u.type = NULL;
630
631   b->prev = scope->bindings;
632   scope->bindings = b;
633
634   if (decl_jump_unsafe (decl))
635     scope->has_jump_unsafe_decl = 1;
636
637   if (!name)
638     return;
639
640   switch (TREE_CODE (decl))
641     {
642     case LABEL_DECL:     here = &I_LABEL_BINDING (name);   break;
643     case ENUMERAL_TYPE:
644     case UNION_TYPE:
645     case RECORD_TYPE:    here = &I_TAG_BINDING (name);     break;
646     case VAR_DECL:
647     case FUNCTION_DECL:
648     case TYPE_DECL:
649     case CONST_DECL:
650     case PARM_DECL:
651     case ERROR_MARK:     here = &I_SYMBOL_BINDING (name);  break;
652
653     default:
654       gcc_unreachable ();
655     }
656
657   /* Locate the appropriate place in the chain of shadowed decls
658      to insert this binding.  Normally, scope == current_scope and
659      this does nothing.  */
660   while (*here && (*here)->depth > scope->depth)
661     here = &(*here)->shadowed;
662
663   b->shadowed = *here;
664   *here = b;
665 }
666
667 /* Clear the binding structure B, stick it on the binding_freelist,
668    and return the former value of b->prev.  This is used by pop_scope
669    and get_parm_info to iterate destructively over all the bindings
670    from a given scope.  */
671 static struct c_binding *
672 free_binding_and_advance (struct c_binding *b)
673 {
674   struct c_binding *prev = b->prev;
675
676   memset (b, 0, sizeof (struct c_binding));
677   b->prev = binding_freelist;
678   binding_freelist = b;
679
680   return prev;
681 }
682
683 /* Bind a label.  Like bind, but skip fields which aren't used for
684    labels, and add the LABEL_VARS value.  */
685 static void
686 bind_label (tree name, tree label, struct c_scope *scope,
687             struct c_label_vars *label_vars)
688 {
689   struct c_binding *b;
690
691   bind (name, label, scope, /*invisible=*/false, /*nested=*/false,
692         UNKNOWN_LOCATION);
693
694   scope->has_label_bindings = true;
695
696   b = scope->bindings;
697   gcc_assert (b->decl == label);
698   label_vars->shadowed = b->u.label;
699   b->u.label = label_vars;
700 }
701 \f
702 /* Hook called at end of compilation to assume 1 elt
703    for a file-scope tentative array defn that wasn't complete before.  */
704
705 void
706 c_finish_incomplete_decl (tree decl)
707 {
708   if (TREE_CODE (decl) == VAR_DECL)
709     {
710       tree type = TREE_TYPE (decl);
711       if (type != error_mark_node
712           && TREE_CODE (type) == ARRAY_TYPE
713           && !DECL_EXTERNAL (decl)
714           && TYPE_DOMAIN (type) == 0)
715         {
716           warning_at (DECL_SOURCE_LOCATION (decl),
717                       0, "array %q+D assumed to have one element", decl);
718
719           complete_array_type (&TREE_TYPE (decl), NULL_TREE, true);
720
721           relayout_decl (decl);
722         }
723     }
724 }
725 \f
726 /* Record that inline function FUNC contains a reference (location
727    LOC) to static DECL (file-scope or function-local according to
728    TYPE).  */
729
730 void
731 record_inline_static (location_t loc, tree func, tree decl,
732                       enum c_inline_static_type type)
733 {
734   struct c_inline_static *csi = ggc_alloc_c_inline_static ();
735   csi->location = loc;
736   csi->function = func;
737   csi->static_decl = decl;
738   csi->type = type;
739   csi->next = c_inline_statics;
740   c_inline_statics = csi;
741 }
742
743 /* Check for references to static declarations in inline functions at
744    the end of the translation unit and diagnose them if the functions
745    are still inline definitions.  */
746
747 static void
748 check_inline_statics (void)
749 {
750   struct c_inline_static *csi;
751   for (csi = c_inline_statics; csi; csi = csi->next)
752     {
753       if (DECL_EXTERNAL (csi->function))
754         switch (csi->type)
755           {
756           case csi_internal:
757             pedwarn (csi->location, 0,
758                      "%qD is static but used in inline function %qD "
759                      "which is not static", csi->static_decl, csi->function);
760             break;
761           case csi_modifiable:
762             pedwarn (csi->location, 0,
763                      "%q+D is static but declared in inline function %qD "
764                      "which is not static", csi->static_decl, csi->function);
765             break;
766           default:
767             gcc_unreachable ();
768           }
769     }
770   c_inline_statics = NULL;
771 }
772 \f
773 /* Fill in a c_spot_bindings structure.  If DEFINING is true, set it
774    for the current state, otherwise set it to uninitialized.  */
775
776 static void
777 set_spot_bindings (struct c_spot_bindings *p, bool defining)
778 {
779   if (defining)
780     {
781       p->scope = current_scope;
782       p->bindings_in_scope = current_scope->bindings;
783     }
784   else
785     {
786       p->scope = NULL;
787       p->bindings_in_scope = NULL;
788     }
789   p->stmt_exprs = 0;
790   p->left_stmt_expr = false;
791 }
792
793 /* Update spot bindings P as we pop out of SCOPE.  Return true if we
794    should push decls for a label.  */
795
796 static bool
797 update_spot_bindings (struct c_scope *scope, struct c_spot_bindings *p)
798 {
799   if (p->scope != scope)
800     {
801       /* This label or goto is defined in some other scope, or it is a
802          label which is not yet defined.  There is nothing to
803          update.  */
804       return false;
805     }
806
807   /* Adjust the spot bindings to refer to the bindings already defined
808      in the enclosing scope.  */
809   p->scope = scope->outer;
810   p->bindings_in_scope = p->scope->bindings;
811
812   return true;
813 }
814 \f
815 /* The Objective-C front-end often needs to determine the current scope.  */
816
817 void *
818 objc_get_current_scope (void)
819 {
820   return current_scope;
821 }
822
823 /* The following function is used only by Objective-C.  It needs to live here
824    because it accesses the innards of c_scope.  */
825
826 void
827 objc_mark_locals_volatile (void *enclosing_blk)
828 {
829   struct c_scope *scope;
830   struct c_binding *b;
831
832   for (scope = current_scope;
833        scope && scope != enclosing_blk;
834        scope = scope->outer)
835     {
836       for (b = scope->bindings; b; b = b->prev)
837         objc_volatilize_decl (b->decl);
838
839       /* Do not climb up past the current function.  */
840       if (scope->function_body)
841         break;
842     }
843 }
844
845 /* Return true if we are in the global binding level.  */
846
847 bool
848 global_bindings_p (void)
849 {
850   return current_scope == file_scope;
851 }
852
853 void
854 keep_next_level (void)
855 {
856   keep_next_level_flag = true;
857 }
858
859 /* Set the flag for the FLOAT_CONST_DECIMAL64 pragma being ON.  */
860
861 void
862 set_float_const_decimal64 (void)
863 {
864   current_scope->float_const_decimal64 = true;
865 }
866
867 /* Clear the flag for the FLOAT_CONST_DECIMAL64 pragma.  */
868
869 void
870 clear_float_const_decimal64 (void)
871 {
872   current_scope->float_const_decimal64 = false;
873 }
874
875 /* Return nonzero if an unsuffixed float constant is _Decimal64.  */
876
877 bool
878 float_const_decimal64_p (void)
879 {
880   return current_scope->float_const_decimal64;
881 }
882
883 /* Identify this scope as currently being filled with parameters.  */
884
885 void
886 declare_parm_level (void)
887 {
888   current_scope->parm_flag = true;
889 }
890
891 void
892 push_scope (void)
893 {
894   if (next_is_function_body)
895     {
896       /* This is the transition from the parameters to the top level
897          of the function body.  These are the same scope
898          (C99 6.2.1p4,6) so we do not push another scope structure.
899          next_is_function_body is set only by store_parm_decls, which
900          in turn is called when and only when we are about to
901          encounter the opening curly brace for the function body.
902
903          The outermost block of a function always gets a BLOCK node,
904          because the debugging output routines expect that each
905          function has at least one BLOCK.  */
906       current_scope->parm_flag         = false;
907       current_scope->function_body     = true;
908       current_scope->keep              = true;
909       current_scope->outer_function    = current_function_scope;
910       current_function_scope           = current_scope;
911
912       keep_next_level_flag = false;
913       next_is_function_body = false;
914
915       /* The FLOAT_CONST_DECIMAL64 pragma applies to nested scopes.  */
916       if (current_scope->outer)
917         current_scope->float_const_decimal64
918           = current_scope->outer->float_const_decimal64;
919       else
920         current_scope->float_const_decimal64 = false;
921     }
922   else
923     {
924       struct c_scope *scope;
925       if (scope_freelist)
926         {
927           scope = scope_freelist;
928           scope_freelist = scope->outer;
929         }
930       else
931         scope = ggc_alloc_cleared_c_scope ();
932
933       /* The FLOAT_CONST_DECIMAL64 pragma applies to nested scopes.  */
934       if (current_scope)
935         scope->float_const_decimal64 = current_scope->float_const_decimal64;
936       else
937         scope->float_const_decimal64 = false;
938
939       scope->keep          = keep_next_level_flag;
940       scope->outer         = current_scope;
941       scope->depth         = current_scope ? (current_scope->depth + 1) : 0;
942
943       /* Check for scope depth overflow.  Unlikely (2^28 == 268,435,456) but
944          possible.  */
945       if (current_scope && scope->depth == 0)
946         {
947           scope->depth--;
948           sorry ("GCC supports only %u nested scopes", scope->depth);
949         }
950
951       current_scope        = scope;
952       keep_next_level_flag = false;
953     }
954 }
955
956 /* This is called when we are leaving SCOPE.  For each label defined
957    in SCOPE, add any appropriate decls to its decls_in_scope fields.
958    These are the decls whose initialization will be skipped by a goto
959    later in the function.  */
960
961 static void
962 update_label_decls (struct c_scope *scope)
963 {
964   struct c_scope *s;
965
966   s = scope;
967   while (s != NULL)
968     {
969       if (s->has_label_bindings)
970         {
971           struct c_binding *b;
972
973           for (b = s->bindings; b != NULL; b = b->prev)
974             {
975               struct c_label_vars *label_vars;
976               struct c_binding *b1;
977               bool hjud;
978               unsigned int ix;
979               struct c_goto_bindings *g;
980
981               if (TREE_CODE (b->decl) != LABEL_DECL)
982                 continue;
983               label_vars = b->u.label;
984
985               b1 = label_vars->label_bindings.bindings_in_scope;
986               if (label_vars->label_bindings.scope == NULL)
987                 hjud = false;
988               else
989                 hjud = label_vars->label_bindings.scope->has_jump_unsafe_decl;
990               if (update_spot_bindings (scope, &label_vars->label_bindings))
991                 {
992                   /* This label is defined in this scope.  */
993                   if (hjud)
994                     {
995                       for (; b1 != NULL; b1 = b1->prev)
996                         {
997                           /* A goto from later in the function to this
998                              label will never see the initialization
999                              of B1, if any.  Save it to issue a
1000                              warning if needed.  */
1001                           if (decl_jump_unsafe (b1->decl))
1002                             VEC_safe_push (tree, gc,
1003                                            label_vars->decls_in_scope,
1004                                            b1->decl);
1005                         }
1006                     }
1007                 }
1008
1009               /* Update the bindings of any goto statements associated
1010                  with this label.  */
1011               FOR_EACH_VEC_ELT (c_goto_bindings_p, label_vars->gotos, ix, g)
1012                 update_spot_bindings (scope, &g->goto_bindings);
1013             }
1014         }
1015
1016       /* Don't search beyond the current function.  */
1017       if (s == current_function_scope)
1018         break;
1019
1020       s = s->outer;
1021     }
1022 }
1023
1024 /* Set the TYPE_CONTEXT of all of TYPE's variants to CONTEXT.  */
1025
1026 static void
1027 set_type_context (tree type, tree context)
1028 {
1029   for (type = TYPE_MAIN_VARIANT (type); type;
1030        type = TYPE_NEXT_VARIANT (type))
1031     TYPE_CONTEXT (type) = context;
1032 }
1033
1034 /* Exit a scope.  Restore the state of the identifier-decl mappings
1035    that were in effect when this scope was entered.  Return a BLOCK
1036    node containing all the DECLs in this scope that are of interest
1037    to debug info generation.  */
1038
1039 tree
1040 pop_scope (void)
1041 {
1042   struct c_scope *scope = current_scope;
1043   tree block, context, p;
1044   struct c_binding *b;
1045
1046   bool functionbody = scope->function_body;
1047   bool keep = functionbody || scope->keep || scope->bindings;
1048
1049   update_label_decls (scope);
1050
1051   /* If appropriate, create a BLOCK to record the decls for the life
1052      of this function.  */
1053   block = 0;
1054   if (keep)
1055     {
1056       block = make_node (BLOCK);
1057       BLOCK_SUBBLOCKS (block) = scope->blocks;
1058       TREE_USED (block) = 1;
1059
1060       /* In each subblock, record that this is its superior.  */
1061       for (p = scope->blocks; p; p = BLOCK_CHAIN (p))
1062         BLOCK_SUPERCONTEXT (p) = block;
1063
1064       BLOCK_VARS (block) = 0;
1065     }
1066
1067   /* The TYPE_CONTEXTs for all of the tagged types belonging to this
1068      scope must be set so that they point to the appropriate
1069      construct, i.e.  either to the current FUNCTION_DECL node, or
1070      else to the BLOCK node we just constructed.
1071
1072      Note that for tagged types whose scope is just the formal
1073      parameter list for some function type specification, we can't
1074      properly set their TYPE_CONTEXTs here, because we don't have a
1075      pointer to the appropriate FUNCTION_TYPE node readily available
1076      to us.  For those cases, the TYPE_CONTEXTs of the relevant tagged
1077      type nodes get set in `grokdeclarator' as soon as we have created
1078      the FUNCTION_TYPE node which will represent the "scope" for these
1079      "parameter list local" tagged types.  */
1080   if (scope->function_body)
1081     context = current_function_decl;
1082   else if (scope == file_scope)
1083     {
1084       tree file_decl = build_translation_unit_decl (NULL_TREE);
1085       context = file_decl;
1086     }
1087   else
1088     context = block;
1089
1090   /* Clear all bindings in this scope.  */
1091   for (b = scope->bindings; b; b = free_binding_and_advance (b))
1092     {
1093       p = b->decl;
1094       switch (TREE_CODE (p))
1095         {
1096         case LABEL_DECL:
1097           /* Warnings for unused labels, errors for undefined labels.  */
1098           if (TREE_USED (p) && !DECL_INITIAL (p))
1099             {
1100               error ("label %q+D used but not defined", p);
1101               DECL_INITIAL (p) = error_mark_node;
1102             }
1103           else
1104             warn_for_unused_label (p);
1105
1106           /* Labels go in BLOCK_VARS.  */
1107           DECL_CHAIN (p) = BLOCK_VARS (block);
1108           BLOCK_VARS (block) = p;
1109           gcc_assert (I_LABEL_BINDING (b->id) == b);
1110           I_LABEL_BINDING (b->id) = b->shadowed;
1111
1112           /* Also pop back to the shadowed label_vars.  */
1113           release_tree_vector (b->u.label->decls_in_scope);
1114           b->u.label = b->u.label->shadowed;
1115           break;
1116
1117         case ENUMERAL_TYPE:
1118         case UNION_TYPE:
1119         case RECORD_TYPE:
1120           set_type_context (p, context);
1121
1122           /* Types may not have tag-names, in which case the type
1123              appears in the bindings list with b->id NULL.  */
1124           if (b->id)
1125             {
1126               gcc_assert (I_TAG_BINDING (b->id) == b);
1127               I_TAG_BINDING (b->id) = b->shadowed;
1128             }
1129           break;
1130
1131         case FUNCTION_DECL:
1132           /* Propagate TREE_ADDRESSABLE from nested functions to their
1133              containing functions.  */
1134           if (!TREE_ASM_WRITTEN (p)
1135               && DECL_INITIAL (p) != 0
1136               && TREE_ADDRESSABLE (p)
1137               && DECL_ABSTRACT_ORIGIN (p) != 0
1138               && DECL_ABSTRACT_ORIGIN (p) != p)
1139             TREE_ADDRESSABLE (DECL_ABSTRACT_ORIGIN (p)) = 1;
1140           if (!DECL_EXTERNAL (p)
1141               && !DECL_INITIAL (p)
1142               && scope != file_scope
1143               && scope != external_scope)
1144             {
1145               error ("nested function %q+D declared but never defined", p);
1146               undef_nested_function = true;
1147             }
1148           else if (DECL_DECLARED_INLINE_P (p)
1149                    && TREE_PUBLIC (p)
1150                    && !DECL_INITIAL (p))
1151             {
1152               /* C99 6.7.4p6: "a function with external linkage... declared
1153                  with an inline function specifier ... shall also be defined
1154                  in the same translation unit."  */
1155               if (!flag_gnu89_inline)
1156                 pedwarn (input_location, 0,
1157                          "inline function %q+D declared but never defined", p);
1158               DECL_EXTERNAL (p) = 1;
1159             }
1160
1161           goto common_symbol;
1162
1163         case VAR_DECL:
1164           /* Warnings for unused variables.  */
1165           if ((!TREE_USED (p) || !DECL_READ_P (p))
1166               && !TREE_NO_WARNING (p)
1167               && !DECL_IN_SYSTEM_HEADER (p)
1168               && DECL_NAME (p)
1169               && !DECL_ARTIFICIAL (p)
1170               && scope != file_scope
1171               && scope != external_scope)
1172             {
1173               if (!TREE_USED (p))
1174                 warning (OPT_Wunused_variable, "unused variable %q+D", p);
1175               else if (DECL_CONTEXT (p) == current_function_decl)
1176                 warning_at (DECL_SOURCE_LOCATION (p),
1177                             OPT_Wunused_but_set_variable,
1178                             "variable %qD set but not used", p);
1179             }
1180
1181           if (b->inner_comp)
1182             {
1183               error ("type of array %q+D completed incompatibly with"
1184                      " implicit initialization", p);
1185             }
1186
1187           /* Fall through.  */
1188         case TYPE_DECL:
1189         case CONST_DECL:
1190         common_symbol:
1191           /* All of these go in BLOCK_VARS, but only if this is the
1192              binding in the home scope.  */
1193           if (!b->nested)
1194             {
1195               DECL_CHAIN (p) = BLOCK_VARS (block);
1196               BLOCK_VARS (block) = p;
1197             }
1198           else if (VAR_OR_FUNCTION_DECL_P (p) && scope != file_scope)
1199             {
1200               /* For block local externs add a special
1201                  DECL_EXTERNAL decl for debug info generation.  */
1202               tree extp = copy_node (p);
1203
1204               DECL_EXTERNAL (extp) = 1;
1205               TREE_STATIC (extp) = 0;
1206               TREE_PUBLIC (extp) = 1;
1207               DECL_INITIAL (extp) = NULL_TREE;
1208               DECL_LANG_SPECIFIC (extp) = NULL;
1209               DECL_CONTEXT (extp) = current_function_decl;
1210               if (TREE_CODE (p) == FUNCTION_DECL)
1211                 {
1212                   DECL_RESULT (extp) = NULL_TREE;
1213                   DECL_SAVED_TREE (extp) = NULL_TREE;
1214                   DECL_STRUCT_FUNCTION (extp) = NULL;
1215                 }
1216               if (b->locus != UNKNOWN_LOCATION)
1217                 DECL_SOURCE_LOCATION (extp) = b->locus;
1218               DECL_CHAIN (extp) = BLOCK_VARS (block);
1219               BLOCK_VARS (block) = extp;
1220             }
1221           /* If this is the file scope set DECL_CONTEXT of each decl to
1222              the TRANSLATION_UNIT_DECL.  This makes same_translation_unit_p
1223              work.  */
1224           if (scope == file_scope)
1225             {
1226               DECL_CONTEXT (p) = context;
1227               if (TREE_CODE (p) == TYPE_DECL
1228                   && TREE_TYPE (p) != error_mark_node)
1229                 set_type_context (TREE_TYPE (p), context);
1230             }
1231
1232           /* Fall through.  */
1233           /* Parameters go in DECL_ARGUMENTS, not BLOCK_VARS, and have
1234              already been put there by store_parm_decls.  Unused-
1235              parameter warnings are handled by function.c.
1236              error_mark_node obviously does not go in BLOCK_VARS and
1237              does not get unused-variable warnings.  */
1238         case PARM_DECL:
1239         case ERROR_MARK:
1240           /* It is possible for a decl not to have a name.  We get
1241              here with b->id NULL in this case.  */
1242           if (b->id)
1243             {
1244               gcc_assert (I_SYMBOL_BINDING (b->id) == b);
1245               I_SYMBOL_BINDING (b->id) = b->shadowed;
1246               if (b->shadowed && b->shadowed->u.type)
1247                 TREE_TYPE (b->shadowed->decl) = b->shadowed->u.type;
1248             }
1249           break;
1250
1251         default:
1252           gcc_unreachable ();
1253         }
1254     }
1255
1256
1257   /* Dispose of the block that we just made inside some higher level.  */
1258   if ((scope->function_body || scope == file_scope) && context)
1259     {
1260       DECL_INITIAL (context) = block;
1261       BLOCK_SUPERCONTEXT (block) = context;
1262     }
1263   else if (scope->outer)
1264     {
1265       if (block)
1266         SCOPE_LIST_APPEND (scope->outer, blocks, block);
1267       /* If we did not make a block for the scope just exited, any
1268          blocks made for inner scopes must be carried forward so they
1269          will later become subblocks of something else.  */
1270       else if (scope->blocks)
1271         SCOPE_LIST_CONCAT (scope->outer, blocks, scope, blocks);
1272     }
1273
1274   /* Pop the current scope, and free the structure for reuse.  */
1275   current_scope = scope->outer;
1276   if (scope->function_body)
1277     current_function_scope = scope->outer_function;
1278
1279   memset (scope, 0, sizeof (struct c_scope));
1280   scope->outer = scope_freelist;
1281   scope_freelist = scope;
1282
1283   return block;
1284 }
1285
1286 void
1287 push_file_scope (void)
1288 {
1289   tree decl;
1290
1291   if (file_scope)
1292     return;
1293
1294   push_scope ();
1295   file_scope = current_scope;
1296
1297   start_fname_decls ();
1298
1299   for (decl = visible_builtins; decl; decl = DECL_CHAIN (decl))
1300     bind (DECL_NAME (decl), decl, file_scope,
1301           /*invisible=*/false, /*nested=*/true, DECL_SOURCE_LOCATION (decl));
1302 }
1303
1304 void
1305 pop_file_scope (void)
1306 {
1307   /* In case there were missing closebraces, get us back to the global
1308      binding level.  */
1309   while (current_scope != file_scope)
1310     pop_scope ();
1311
1312   /* __FUNCTION__ is defined at file scope ("").  This
1313      call may not be necessary as my tests indicate it
1314      still works without it.  */
1315   finish_fname_decls ();
1316
1317   check_inline_statics ();
1318
1319   /* This is the point to write out a PCH if we're doing that.
1320      In that case we do not want to do anything else.  */
1321   if (pch_file)
1322     {
1323       c_common_write_pch ();
1324       return;
1325     }
1326
1327   /* Pop off the file scope and close this translation unit.  */
1328   pop_scope ();
1329   file_scope = 0;
1330
1331   maybe_apply_pending_pragma_weaks ();
1332 }
1333 \f
1334 /* Adjust the bindings for the start of a statement expression.  */
1335
1336 void
1337 c_bindings_start_stmt_expr (struct c_spot_bindings* switch_bindings)
1338 {
1339   struct c_scope *scope;
1340
1341   for (scope = current_scope; scope != NULL; scope = scope->outer)
1342     {
1343       struct c_binding *b;
1344
1345       if (!scope->has_label_bindings)
1346         continue;
1347
1348       for (b = scope->bindings; b != NULL; b = b->prev)
1349         {
1350           struct c_label_vars *label_vars;
1351           unsigned int ix;
1352           struct c_goto_bindings *g;
1353
1354           if (TREE_CODE (b->decl) != LABEL_DECL)
1355             continue;
1356           label_vars = b->u.label;
1357           ++label_vars->label_bindings.stmt_exprs;
1358           FOR_EACH_VEC_ELT (c_goto_bindings_p, label_vars->gotos, ix, g)
1359             ++g->goto_bindings.stmt_exprs;
1360         }
1361     }
1362
1363   if (switch_bindings != NULL)
1364     ++switch_bindings->stmt_exprs;
1365 }
1366
1367 /* Adjust the bindings for the end of a statement expression.  */
1368
1369 void
1370 c_bindings_end_stmt_expr (struct c_spot_bindings *switch_bindings)
1371 {
1372   struct c_scope *scope;
1373
1374   for (scope = current_scope; scope != NULL; scope = scope->outer)
1375     {
1376       struct c_binding *b;
1377
1378       if (!scope->has_label_bindings)
1379         continue;
1380
1381       for (b = scope->bindings; b != NULL; b = b->prev)
1382         {
1383           struct c_label_vars *label_vars;
1384           unsigned int ix;
1385           struct c_goto_bindings *g;
1386
1387           if (TREE_CODE (b->decl) != LABEL_DECL)
1388             continue;
1389           label_vars = b->u.label;
1390           --label_vars->label_bindings.stmt_exprs;
1391           if (label_vars->label_bindings.stmt_exprs < 0)
1392             {
1393               label_vars->label_bindings.left_stmt_expr = true;
1394               label_vars->label_bindings.stmt_exprs = 0;
1395             }
1396           FOR_EACH_VEC_ELT (c_goto_bindings_p, label_vars->gotos, ix, g)
1397             {
1398               --g->goto_bindings.stmt_exprs;
1399               if (g->goto_bindings.stmt_exprs < 0)
1400                 {
1401                   g->goto_bindings.left_stmt_expr = true;
1402                   g->goto_bindings.stmt_exprs = 0;
1403                 }
1404             }
1405         }
1406     }
1407
1408   if (switch_bindings != NULL)
1409     {
1410       --switch_bindings->stmt_exprs;
1411       gcc_assert (switch_bindings->stmt_exprs >= 0);
1412     }
1413 }
1414 \f
1415 /* Push a definition or a declaration of struct, union or enum tag "name".
1416    "type" should be the type node.
1417    We assume that the tag "name" is not already defined, and has a location
1418    of LOC.
1419
1420    Note that the definition may really be just a forward reference.
1421    In that case, the TYPE_SIZE will be zero.  */
1422
1423 static void
1424 pushtag (location_t loc, tree name, tree type)
1425 {
1426   /* Record the identifier as the type's name if it has none.  */
1427   if (name && !TYPE_NAME (type))
1428     TYPE_NAME (type) = name;
1429   bind (name, type, current_scope, /*invisible=*/false, /*nested=*/false, loc);
1430
1431   /* Create a fake NULL-named TYPE_DECL node whose TREE_TYPE will be the
1432      tagged type we just added to the current scope.  This fake
1433      NULL-named TYPE_DECL node helps dwarfout.c to know when it needs
1434      to output a representation of a tagged type, and it also gives
1435      us a convenient place to record the "scope start" address for the
1436      tagged type.  */
1437
1438   TYPE_STUB_DECL (type) = pushdecl (build_decl (loc,
1439                                                 TYPE_DECL, NULL_TREE, type));
1440
1441   /* An approximation for now, so we can tell this is a function-scope tag.
1442      This will be updated in pop_scope.  */
1443   TYPE_CONTEXT (type) = DECL_CONTEXT (TYPE_STUB_DECL (type));
1444
1445   if (warn_cxx_compat && name != NULL_TREE)
1446     {
1447       struct c_binding *b = I_SYMBOL_BINDING (name);
1448
1449       if (b != NULL
1450           && b->decl != NULL_TREE
1451           && TREE_CODE (b->decl) == TYPE_DECL
1452           && (B_IN_CURRENT_SCOPE (b)
1453               || (current_scope == file_scope && B_IN_EXTERNAL_SCOPE (b)))
1454           && (TYPE_MAIN_VARIANT (TREE_TYPE (b->decl))
1455               != TYPE_MAIN_VARIANT (type)))
1456         {
1457           warning_at (loc, OPT_Wc___compat,
1458                       ("using %qD as both a typedef and a tag is "
1459                        "invalid in C++"),
1460                       b->decl);
1461           if (b->locus != UNKNOWN_LOCATION)
1462             inform (b->locus, "originally defined here");
1463         }
1464     }
1465 }
1466 \f
1467 /* Subroutine of compare_decls.  Allow harmless mismatches in return
1468    and argument types provided that the type modes match.  This function
1469    return a unified type given a suitable match, and 0 otherwise.  */
1470
1471 static tree
1472 match_builtin_function_types (tree newtype, tree oldtype)
1473 {
1474   tree newrettype, oldrettype;
1475   tree newargs, oldargs;
1476   tree trytype, tryargs;
1477
1478   /* Accept the return type of the new declaration if same modes.  */
1479   oldrettype = TREE_TYPE (oldtype);
1480   newrettype = TREE_TYPE (newtype);
1481
1482   if (TYPE_MODE (oldrettype) != TYPE_MODE (newrettype))
1483     return 0;
1484
1485   oldargs = TYPE_ARG_TYPES (oldtype);
1486   newargs = TYPE_ARG_TYPES (newtype);
1487   tryargs = newargs;
1488
1489   while (oldargs || newargs)
1490     {
1491       if (!oldargs
1492           || !newargs
1493           || !TREE_VALUE (oldargs)
1494           || !TREE_VALUE (newargs)
1495           || TYPE_MODE (TREE_VALUE (oldargs))
1496              != TYPE_MODE (TREE_VALUE (newargs)))
1497         return 0;
1498
1499       oldargs = TREE_CHAIN (oldargs);
1500       newargs = TREE_CHAIN (newargs);
1501     }
1502
1503   trytype = build_function_type (newrettype, tryargs);
1504   return build_type_attribute_variant (trytype, TYPE_ATTRIBUTES (oldtype));
1505 }
1506
1507 /* Subroutine of diagnose_mismatched_decls.  Check for function type
1508    mismatch involving an empty arglist vs a nonempty one and give clearer
1509    diagnostics.  */
1510 static void
1511 diagnose_arglist_conflict (tree newdecl, tree olddecl,
1512                            tree newtype, tree oldtype)
1513 {
1514   tree t;
1515
1516   if (TREE_CODE (olddecl) != FUNCTION_DECL
1517       || !comptypes (TREE_TYPE (oldtype), TREE_TYPE (newtype))
1518       || !((!prototype_p (oldtype) && DECL_INITIAL (olddecl) == 0)
1519            || (!prototype_p (newtype) && DECL_INITIAL (newdecl) == 0)))
1520     return;
1521
1522   t = TYPE_ARG_TYPES (oldtype);
1523   if (t == 0)
1524     t = TYPE_ARG_TYPES (newtype);
1525   for (; t; t = TREE_CHAIN (t))
1526     {
1527       tree type = TREE_VALUE (t);
1528
1529       if (TREE_CHAIN (t) == 0
1530           && TYPE_MAIN_VARIANT (type) != void_type_node)
1531         {
1532           inform (input_location, "a parameter list with an ellipsis can%'t match "
1533                   "an empty parameter name list declaration");
1534           break;
1535         }
1536
1537       if (c_type_promotes_to (type) != type)
1538         {
1539           inform (input_location, "an argument type that has a default promotion can%'t match "
1540                   "an empty parameter name list declaration");
1541           break;
1542         }
1543     }
1544 }
1545
1546 /* Another subroutine of diagnose_mismatched_decls.  OLDDECL is an
1547    old-style function definition, NEWDECL is a prototype declaration.
1548    Diagnose inconsistencies in the argument list.  Returns TRUE if
1549    the prototype is compatible, FALSE if not.  */
1550 static bool
1551 validate_proto_after_old_defn (tree newdecl, tree newtype, tree oldtype)
1552 {
1553   tree newargs, oldargs;
1554   int i;
1555
1556 #define END_OF_ARGLIST(t) ((t) == void_type_node)
1557
1558   oldargs = TYPE_ACTUAL_ARG_TYPES (oldtype);
1559   newargs = TYPE_ARG_TYPES (newtype);
1560   i = 1;
1561
1562   for (;;)
1563     {
1564       tree oldargtype = TREE_VALUE (oldargs);
1565       tree newargtype = TREE_VALUE (newargs);
1566
1567       if (oldargtype == error_mark_node || newargtype == error_mark_node)
1568         return false;
1569
1570       oldargtype = TYPE_MAIN_VARIANT (oldargtype);
1571       newargtype = TYPE_MAIN_VARIANT (newargtype);
1572
1573       if (END_OF_ARGLIST (oldargtype) && END_OF_ARGLIST (newargtype))
1574         break;
1575
1576       /* Reaching the end of just one list means the two decls don't
1577          agree on the number of arguments.  */
1578       if (END_OF_ARGLIST (oldargtype))
1579         {
1580           error ("prototype for %q+D declares more arguments "
1581                  "than previous old-style definition", newdecl);
1582           return false;
1583         }
1584       else if (END_OF_ARGLIST (newargtype))
1585         {
1586           error ("prototype for %q+D declares fewer arguments "
1587                  "than previous old-style definition", newdecl);
1588           return false;
1589         }
1590
1591       /* Type for passing arg must be consistent with that declared
1592          for the arg.  */
1593       else if (!comptypes (oldargtype, newargtype))
1594         {
1595           error ("prototype for %q+D declares argument %d"
1596                  " with incompatible type",
1597                  newdecl, i);
1598           return false;
1599         }
1600
1601       oldargs = TREE_CHAIN (oldargs);
1602       newargs = TREE_CHAIN (newargs);
1603       i++;
1604     }
1605
1606   /* If we get here, no errors were found, but do issue a warning
1607      for this poor-style construct.  */
1608   warning (0, "prototype for %q+D follows non-prototype definition",
1609            newdecl);
1610   return true;
1611 #undef END_OF_ARGLIST
1612 }
1613
1614 /* Subroutine of diagnose_mismatched_decls.  Report the location of DECL,
1615    first in a pair of mismatched declarations, using the diagnostic
1616    function DIAG.  */
1617 static void
1618 locate_old_decl (tree decl)
1619 {
1620   if (TREE_CODE (decl) == FUNCTION_DECL && DECL_BUILT_IN (decl))
1621     ;
1622   else if (DECL_INITIAL (decl))
1623     inform (input_location, "previous definition of %q+D was here", decl);
1624   else if (C_DECL_IMPLICIT (decl))
1625     inform (input_location, "previous implicit declaration of %q+D was here", decl);
1626   else
1627     inform (input_location, "previous declaration of %q+D was here", decl);
1628 }
1629
1630 /* Subroutine of duplicate_decls.  Compare NEWDECL to OLDDECL.
1631    Returns true if the caller should proceed to merge the two, false
1632    if OLDDECL should simply be discarded.  As a side effect, issues
1633    all necessary diagnostics for invalid or poor-style combinations.
1634    If it returns true, writes the types of NEWDECL and OLDDECL to
1635    *NEWTYPEP and *OLDTYPEP - these may have been adjusted from
1636    TREE_TYPE (NEWDECL, OLDDECL) respectively.  */
1637
1638 static bool
1639 diagnose_mismatched_decls (tree newdecl, tree olddecl,
1640                            tree *newtypep, tree *oldtypep)
1641 {
1642   tree newtype, oldtype;
1643   bool pedwarned = false;
1644   bool warned = false;
1645   bool retval = true;
1646
1647 #define DECL_EXTERN_INLINE(DECL) (DECL_DECLARED_INLINE_P (DECL)  \
1648                                   && DECL_EXTERNAL (DECL))
1649
1650   /* If we have error_mark_node for either decl or type, just discard
1651      the previous decl - we're in an error cascade already.  */
1652   if (olddecl == error_mark_node || newdecl == error_mark_node)
1653     return false;
1654   *oldtypep = oldtype = TREE_TYPE (olddecl);
1655   *newtypep = newtype = TREE_TYPE (newdecl);
1656   if (oldtype == error_mark_node || newtype == error_mark_node)
1657     return false;
1658
1659   /* Two different categories of symbol altogether.  This is an error
1660      unless OLDDECL is a builtin.  OLDDECL will be discarded in any case.  */
1661   if (TREE_CODE (olddecl) != TREE_CODE (newdecl))
1662     {
1663       if (!(TREE_CODE (olddecl) == FUNCTION_DECL
1664             && DECL_BUILT_IN (olddecl)
1665             && !C_DECL_DECLARED_BUILTIN (olddecl)))
1666         {
1667           error ("%q+D redeclared as different kind of symbol", newdecl);
1668           locate_old_decl (olddecl);
1669         }
1670       else if (TREE_PUBLIC (newdecl))
1671         warning (0, "built-in function %q+D declared as non-function",
1672                  newdecl);
1673       else
1674         warning (OPT_Wshadow, "declaration of %q+D shadows "
1675                  "a built-in function", newdecl);
1676       return false;
1677     }
1678
1679   /* Enumerators have no linkage, so may only be declared once in a
1680      given scope.  */
1681   if (TREE_CODE (olddecl) == CONST_DECL)
1682     {
1683       error ("redeclaration of enumerator %q+D", newdecl);
1684       locate_old_decl (olddecl);
1685       return false;
1686     }
1687
1688   if (!comptypes (oldtype, newtype))
1689     {
1690       if (TREE_CODE (olddecl) == FUNCTION_DECL
1691           && DECL_BUILT_IN (olddecl) && !C_DECL_DECLARED_BUILTIN (olddecl))
1692         {
1693           /* Accept harmless mismatch in function types.
1694              This is for the ffs and fprintf builtins.  */
1695           tree trytype = match_builtin_function_types (newtype, oldtype);
1696
1697           if (trytype && comptypes (newtype, trytype))
1698             *oldtypep = oldtype = trytype;
1699           else
1700             {
1701               /* If types don't match for a built-in, throw away the
1702                  built-in.  No point in calling locate_old_decl here, it
1703                  won't print anything.  */
1704               warning (0, "conflicting types for built-in function %q+D",
1705                        newdecl);
1706               return false;
1707             }
1708         }
1709       else if (TREE_CODE (olddecl) == FUNCTION_DECL
1710                && DECL_IS_BUILTIN (olddecl))
1711         {
1712           /* A conflicting function declaration for a predeclared
1713              function that isn't actually built in.  Objective C uses
1714              these.  The new declaration silently overrides everything
1715              but the volatility (i.e. noreturn) indication.  See also
1716              below.  FIXME: Make Objective C use normal builtins.  */
1717           TREE_THIS_VOLATILE (newdecl) |= TREE_THIS_VOLATILE (olddecl);
1718           return false;
1719         }
1720       /* Permit void foo (...) to match int foo (...) if the latter is
1721          the definition and implicit int was used.  See
1722          c-torture/compile/920625-2.c.  */
1723       else if (TREE_CODE (newdecl) == FUNCTION_DECL && DECL_INITIAL (newdecl)
1724                && TYPE_MAIN_VARIANT (TREE_TYPE (oldtype)) == void_type_node
1725                && TYPE_MAIN_VARIANT (TREE_TYPE (newtype)) == integer_type_node
1726                && C_FUNCTION_IMPLICIT_INT (newdecl) && !DECL_INITIAL (olddecl))
1727         {
1728           pedwarned = pedwarn (input_location, 0,
1729                                "conflicting types for %q+D", newdecl);
1730           /* Make sure we keep void as the return type.  */
1731           TREE_TYPE (newdecl) = *newtypep = newtype = oldtype;
1732           C_FUNCTION_IMPLICIT_INT (newdecl) = 0;
1733         }
1734       /* Permit void foo (...) to match an earlier call to foo (...) with
1735          no declared type (thus, implicitly int).  */
1736       else if (TREE_CODE (newdecl) == FUNCTION_DECL
1737                && TYPE_MAIN_VARIANT (TREE_TYPE (newtype)) == void_type_node
1738                && TYPE_MAIN_VARIANT (TREE_TYPE (oldtype)) == integer_type_node
1739                && C_DECL_IMPLICIT (olddecl) && !DECL_INITIAL (olddecl))
1740         {
1741           pedwarned = pedwarn (input_location, 0,
1742                                "conflicting types for %q+D", newdecl);
1743           /* Make sure we keep void as the return type.  */
1744           TREE_TYPE (olddecl) = *oldtypep = oldtype = newtype;
1745         }
1746       else
1747         {
1748           int new_quals = TYPE_QUALS (newtype);
1749           int old_quals = TYPE_QUALS (oldtype);
1750
1751           if (new_quals != old_quals)
1752             {
1753               addr_space_t new_addr = DECODE_QUAL_ADDR_SPACE (new_quals);
1754               addr_space_t old_addr = DECODE_QUAL_ADDR_SPACE (old_quals);
1755               if (new_addr != old_addr)
1756                 {
1757                   if (ADDR_SPACE_GENERIC_P (new_addr))
1758                     error ("conflicting named address spaces (generic vs %s) "
1759                            "for %q+D",
1760                            c_addr_space_name (old_addr), newdecl);
1761                   else if (ADDR_SPACE_GENERIC_P (old_addr))
1762                     error ("conflicting named address spaces (%s vs generic) "
1763                            "for %q+D",
1764                            c_addr_space_name (new_addr), newdecl);
1765                   else
1766                     error ("conflicting named address spaces (%s vs %s) "
1767                            "for %q+D",
1768                            c_addr_space_name (new_addr),
1769                            c_addr_space_name (old_addr),
1770                            newdecl);
1771                 }
1772
1773               if (CLEAR_QUAL_ADDR_SPACE (new_quals)
1774                   != CLEAR_QUAL_ADDR_SPACE (old_quals))
1775                 error ("conflicting type qualifiers for %q+D", newdecl);
1776             }
1777           else
1778             error ("conflicting types for %q+D", newdecl);
1779           diagnose_arglist_conflict (newdecl, olddecl, newtype, oldtype);
1780           locate_old_decl (olddecl);
1781           return false;
1782         }
1783     }
1784
1785   /* Redeclaration of a type is a constraint violation (6.7.2.3p1),
1786      but silently ignore the redeclaration if either is in a system
1787      header.  (Conflicting redeclarations were handled above.)  This
1788      is allowed for C11 if the types are the same, not just
1789      compatible.  */
1790   if (TREE_CODE (newdecl) == TYPE_DECL)
1791     {
1792       bool types_different = false;
1793       int comptypes_result;
1794
1795       comptypes_result
1796         = comptypes_check_different_types (oldtype, newtype, &types_different);
1797
1798       if (comptypes_result != 1 || types_different)
1799         {
1800           error ("redefinition of typedef %q+D with different type", newdecl);
1801           locate_old_decl (olddecl);
1802           return false;
1803         }
1804
1805       if (DECL_IN_SYSTEM_HEADER (newdecl)
1806           || DECL_IN_SYSTEM_HEADER (olddecl)
1807           || TREE_NO_WARNING (newdecl)
1808           || TREE_NO_WARNING (olddecl))
1809         return true;  /* Allow OLDDECL to continue in use.  */
1810
1811       if (variably_modified_type_p (newtype, NULL))
1812         {
1813           error ("redefinition of typedef %q+D with variably modified type",
1814                  newdecl);
1815           locate_old_decl (olddecl);
1816         }
1817       else if (pedantic && !flag_isoc11)
1818         {
1819           pedwarn (input_location, OPT_pedantic,
1820                    "redefinition of typedef %q+D", newdecl);
1821           locate_old_decl (olddecl);
1822         }
1823
1824       return true;
1825     }
1826
1827   /* Function declarations can either be 'static' or 'extern' (no
1828      qualifier is equivalent to 'extern' - C99 6.2.2p5) and therefore
1829      can never conflict with each other on account of linkage
1830      (6.2.2p4).  Multiple definitions are not allowed (6.9p3,5) but
1831      gnu89 mode permits two definitions if one is 'extern inline' and
1832      one is not.  The non- extern-inline definition supersedes the
1833      extern-inline definition.  */
1834
1835   else if (TREE_CODE (newdecl) == FUNCTION_DECL)
1836     {
1837       /* If you declare a built-in function name as static, or
1838          define the built-in with an old-style definition (so we
1839          can't validate the argument list) the built-in definition is
1840          overridden, but optionally warn this was a bad choice of name.  */
1841       if (DECL_BUILT_IN (olddecl)
1842           && !C_DECL_DECLARED_BUILTIN (olddecl)
1843           && (!TREE_PUBLIC (newdecl)
1844               || (DECL_INITIAL (newdecl)
1845                   && !prototype_p (TREE_TYPE (newdecl)))))
1846         {
1847           warning (OPT_Wshadow, "declaration of %q+D shadows "
1848                    "a built-in function", newdecl);
1849           /* Discard the old built-in function.  */
1850           return false;
1851         }
1852
1853       if (DECL_INITIAL (newdecl))
1854         {
1855           if (DECL_INITIAL (olddecl))
1856             {
1857               /* If both decls are in the same TU and the new declaration
1858                  isn't overriding an extern inline reject the new decl.
1859                  In c99, no overriding is allowed in the same translation
1860                  unit.  */
1861               if ((!DECL_EXTERN_INLINE (olddecl)
1862                    || DECL_EXTERN_INLINE (newdecl)
1863                    || (!flag_gnu89_inline
1864                        && (!DECL_DECLARED_INLINE_P (olddecl)
1865                            || !lookup_attribute ("gnu_inline",
1866                                                  DECL_ATTRIBUTES (olddecl)))
1867                        && (!DECL_DECLARED_INLINE_P (newdecl)
1868                            || !lookup_attribute ("gnu_inline",
1869                                                  DECL_ATTRIBUTES (newdecl))))
1870                   )
1871                   && same_translation_unit_p (newdecl, olddecl))
1872                 {
1873                   error ("redefinition of %q+D", newdecl);
1874                   locate_old_decl (olddecl);
1875                   return false;
1876                 }
1877             }
1878         }
1879       /* If we have a prototype after an old-style function definition,
1880          the argument types must be checked specially.  */
1881       else if (DECL_INITIAL (olddecl)
1882                && !prototype_p (oldtype) && prototype_p (newtype)
1883                && TYPE_ACTUAL_ARG_TYPES (oldtype)
1884                && !validate_proto_after_old_defn (newdecl, newtype, oldtype))
1885         {
1886           locate_old_decl (olddecl);
1887           return false;
1888         }
1889       /* A non-static declaration (even an "extern") followed by a
1890          static declaration is undefined behavior per C99 6.2.2p3-5,7.
1891          The same is true for a static forward declaration at block
1892          scope followed by a non-static declaration/definition at file
1893          scope.  Static followed by non-static at the same scope is
1894          not undefined behavior, and is the most convenient way to get
1895          some effects (see e.g.  what unwind-dw2-fde-glibc.c does to
1896          the definition of _Unwind_Find_FDE in unwind-dw2-fde.c), but
1897          we do diagnose it if -Wtraditional.  */
1898       if (TREE_PUBLIC (olddecl) && !TREE_PUBLIC (newdecl))
1899         {
1900           /* Two exceptions to the rule.  If olddecl is an extern
1901              inline, or a predeclared function that isn't actually
1902              built in, newdecl silently overrides olddecl.  The latter
1903              occur only in Objective C; see also above.  (FIXME: Make
1904              Objective C use normal builtins.)  */
1905           if (!DECL_IS_BUILTIN (olddecl)
1906               && !DECL_EXTERN_INLINE (olddecl))
1907             {
1908               error ("static declaration of %q+D follows "
1909                      "non-static declaration", newdecl);
1910               locate_old_decl (olddecl);
1911             }
1912           return false;
1913         }
1914       else if (TREE_PUBLIC (newdecl) && !TREE_PUBLIC (olddecl))
1915         {
1916           if (DECL_CONTEXT (olddecl))
1917             {
1918               error ("non-static declaration of %q+D follows "
1919                      "static declaration", newdecl);
1920               locate_old_decl (olddecl);
1921               return false;
1922             }
1923           else if (warn_traditional)
1924             {
1925               warned |= warning (OPT_Wtraditional,
1926                                  "non-static declaration of %q+D "
1927                                  "follows static declaration", newdecl);
1928             }
1929         }
1930
1931       /* Make sure gnu_inline attribute is either not present, or
1932          present on all inline decls.  */
1933       if (DECL_DECLARED_INLINE_P (olddecl)
1934           && DECL_DECLARED_INLINE_P (newdecl))
1935         {
1936           bool newa = lookup_attribute ("gnu_inline",
1937                                         DECL_ATTRIBUTES (newdecl)) != NULL;
1938           bool olda = lookup_attribute ("gnu_inline",
1939                                         DECL_ATTRIBUTES (olddecl)) != NULL;
1940           if (newa != olda)
1941             {
1942               error_at (input_location, "%<gnu_inline%> attribute present on %q+D",
1943                         newa ? newdecl : olddecl);
1944               error_at (DECL_SOURCE_LOCATION (newa ? olddecl : newdecl),
1945                         "but not here");
1946             }
1947         }
1948     }
1949   else if (TREE_CODE (newdecl) == VAR_DECL)
1950     {
1951       /* Only variables can be thread-local, and all declarations must
1952          agree on this property.  */
1953       if (C_DECL_THREADPRIVATE_P (olddecl) && !DECL_THREAD_LOCAL_P (newdecl))
1954         {
1955           /* Nothing to check.  Since OLDDECL is marked threadprivate
1956              and NEWDECL does not have a thread-local attribute, we
1957              will merge the threadprivate attribute into NEWDECL.  */
1958           ;
1959         }
1960       else if (DECL_THREAD_LOCAL_P (newdecl) != DECL_THREAD_LOCAL_P (olddecl))
1961         {
1962           if (DECL_THREAD_LOCAL_P (newdecl))
1963             error ("thread-local declaration of %q+D follows "
1964                    "non-thread-local declaration", newdecl);
1965           else
1966             error ("non-thread-local declaration of %q+D follows "
1967                    "thread-local declaration", newdecl);
1968
1969           locate_old_decl (olddecl);
1970           return false;
1971         }
1972
1973       /* Multiple initialized definitions are not allowed (6.9p3,5).  */
1974       if (DECL_INITIAL (newdecl) && DECL_INITIAL (olddecl))
1975         {
1976           error ("redefinition of %q+D", newdecl);
1977           locate_old_decl (olddecl);
1978           return false;
1979         }
1980
1981       /* Objects declared at file scope: if the first declaration had
1982          external linkage (even if it was an external reference) the
1983          second must have external linkage as well, or the behavior is
1984          undefined.  If the first declaration had internal linkage, then
1985          the second must too, or else be an external reference (in which
1986          case the composite declaration still has internal linkage).
1987          As for function declarations, we warn about the static-then-
1988          extern case only for -Wtraditional.  See generally 6.2.2p3-5,7.  */
1989       if (DECL_FILE_SCOPE_P (newdecl)
1990           && TREE_PUBLIC (newdecl) != TREE_PUBLIC (olddecl))
1991         {
1992           if (DECL_EXTERNAL (newdecl))
1993             {
1994               if (!DECL_FILE_SCOPE_P (olddecl))
1995                 {
1996                   error ("extern declaration of %q+D follows "
1997                          "declaration with no linkage", newdecl);
1998                   locate_old_decl (olddecl);
1999                   return false;
2000                 }
2001               else if (warn_traditional)
2002                 {
2003                   warned |= warning (OPT_Wtraditional,
2004                                      "non-static declaration of %q+D "
2005                                      "follows static declaration", newdecl);
2006                 }
2007             }
2008           else
2009             {
2010               if (TREE_PUBLIC (newdecl))
2011                 error ("non-static declaration of %q+D follows "
2012                        "static declaration", newdecl);
2013               else
2014                 error ("static declaration of %q+D follows "
2015                        "non-static declaration", newdecl);
2016
2017               locate_old_decl (olddecl);
2018               return false;
2019             }
2020         }
2021       /* Two objects with the same name declared at the same block
2022          scope must both be external references (6.7p3).  */
2023       else if (!DECL_FILE_SCOPE_P (newdecl))
2024         {
2025           if (DECL_EXTERNAL (newdecl))
2026             {
2027               /* Extern with initializer at block scope, which will
2028                  already have received an error.  */
2029             }
2030           else if (DECL_EXTERNAL (olddecl))
2031             {
2032               error ("declaration of %q+D with no linkage follows "
2033                      "extern declaration", newdecl);
2034               locate_old_decl (olddecl);
2035             }
2036           else
2037             {
2038               error ("redeclaration of %q+D with no linkage", newdecl);
2039               locate_old_decl (olddecl);
2040             }
2041
2042           return false;
2043         }
2044
2045       /* C++ does not permit a decl to appear multiple times at file
2046          scope.  */
2047       if (warn_cxx_compat
2048           && DECL_FILE_SCOPE_P (newdecl)
2049           && !DECL_EXTERNAL (newdecl)
2050           && !DECL_EXTERNAL (olddecl))
2051         warned |= warning_at (DECL_SOURCE_LOCATION (newdecl),
2052                               OPT_Wc___compat,
2053                               ("duplicate declaration of %qD is "
2054                                "invalid in C++"),
2055                               newdecl);
2056     }
2057
2058   /* warnings */
2059   /* All decls must agree on a visibility.  */
2060   if (CODE_CONTAINS_STRUCT (TREE_CODE (newdecl), TS_DECL_WITH_VIS)
2061       && DECL_VISIBILITY_SPECIFIED (newdecl) && DECL_VISIBILITY_SPECIFIED (olddecl)
2062       && DECL_VISIBILITY (newdecl) != DECL_VISIBILITY (olddecl))
2063     {
2064       warned |= warning (0, "redeclaration of %q+D with different visibility "
2065                          "(old visibility preserved)", newdecl);
2066     }
2067
2068   if (TREE_CODE (newdecl) == FUNCTION_DECL)
2069     {
2070       /* Diagnose inline __attribute__ ((noinline)) which is silly.  */
2071       if (DECL_DECLARED_INLINE_P (newdecl)
2072           && lookup_attribute ("noinline", DECL_ATTRIBUTES (olddecl)))
2073         {
2074           warned |= warning (OPT_Wattributes,
2075                              "inline declaration of %qD follows "
2076                              "declaration with attribute noinline", newdecl);
2077         }
2078       else if (DECL_DECLARED_INLINE_P (olddecl)
2079                && lookup_attribute ("noinline", DECL_ATTRIBUTES (newdecl)))
2080         {
2081           warned |= warning (OPT_Wattributes,
2082                              "declaration of %q+D with attribute "
2083                              "noinline follows inline declaration ", newdecl);
2084         }
2085     }
2086   else /* PARM_DECL, VAR_DECL */
2087     {
2088       /* Redeclaration of a parameter is a constraint violation (this is
2089          not explicitly stated, but follows from C99 6.7p3 [no more than
2090          one declaration of the same identifier with no linkage in the
2091          same scope, except type tags] and 6.2.2p6 [parameters have no
2092          linkage]).  We must check for a forward parameter declaration,
2093          indicated by TREE_ASM_WRITTEN on the old declaration - this is
2094          an extension, the mandatory diagnostic for which is handled by
2095          mark_forward_parm_decls.  */
2096
2097       if (TREE_CODE (newdecl) == PARM_DECL
2098           && (!TREE_ASM_WRITTEN (olddecl) || TREE_ASM_WRITTEN (newdecl)))
2099         {
2100           error ("redefinition of parameter %q+D", newdecl);
2101           locate_old_decl (olddecl);
2102           return false;
2103         }
2104     }
2105
2106   /* Optional warning for completely redundant decls.  */
2107   if (!warned && !pedwarned
2108       && warn_redundant_decls
2109       /* Don't warn about a function declaration followed by a
2110          definition.  */
2111       && !(TREE_CODE (newdecl) == FUNCTION_DECL
2112            && DECL_INITIAL (newdecl) && !DECL_INITIAL (olddecl))
2113       /* Don't warn about redundant redeclarations of builtins.  */
2114       && !(TREE_CODE (newdecl) == FUNCTION_DECL
2115            && !DECL_BUILT_IN (newdecl)
2116            && DECL_BUILT_IN (olddecl)
2117            && !C_DECL_DECLARED_BUILTIN (olddecl))
2118       /* Don't warn about an extern followed by a definition.  */
2119       && !(DECL_EXTERNAL (olddecl) && !DECL_EXTERNAL (newdecl))
2120       /* Don't warn about forward parameter decls.  */
2121       && !(TREE_CODE (newdecl) == PARM_DECL
2122            && TREE_ASM_WRITTEN (olddecl) && !TREE_ASM_WRITTEN (newdecl))
2123       /* Don't warn about a variable definition following a declaration.  */
2124       && !(TREE_CODE (newdecl) == VAR_DECL
2125            && DECL_INITIAL (newdecl) && !DECL_INITIAL (olddecl)))
2126     {
2127       warned = warning (OPT_Wredundant_decls, "redundant redeclaration of %q+D",
2128                         newdecl);
2129     }
2130
2131   /* Report location of previous decl/defn.  */
2132   if (warned || pedwarned)
2133     locate_old_decl (olddecl);
2134
2135 #undef DECL_EXTERN_INLINE
2136
2137   return retval;
2138 }
2139
2140 /* Subroutine of duplicate_decls.  NEWDECL has been found to be
2141    consistent with OLDDECL, but carries new information.  Merge the
2142    new information into OLDDECL.  This function issues no
2143    diagnostics.  */
2144
2145 static void
2146 merge_decls (tree newdecl, tree olddecl, tree newtype, tree oldtype)
2147 {
2148   bool new_is_definition = (TREE_CODE (newdecl) == FUNCTION_DECL
2149                             && DECL_INITIAL (newdecl) != 0);
2150   bool new_is_prototype = (TREE_CODE (newdecl) == FUNCTION_DECL
2151                            && prototype_p (TREE_TYPE (newdecl)));
2152   bool old_is_prototype = (TREE_CODE (olddecl) == FUNCTION_DECL
2153                            && prototype_p (TREE_TYPE (olddecl)));
2154   bool extern_changed = false;
2155
2156   /* For real parm decl following a forward decl, rechain the old decl
2157      in its new location and clear TREE_ASM_WRITTEN (it's not a
2158      forward decl anymore).  */
2159   if (TREE_CODE (newdecl) == PARM_DECL
2160       && TREE_ASM_WRITTEN (olddecl) && !TREE_ASM_WRITTEN (newdecl))
2161     {
2162       struct c_binding *b, **here;
2163
2164       for (here = &current_scope->bindings; *here; here = &(*here)->prev)
2165         if ((*here)->decl == olddecl)
2166           goto found;
2167       gcc_unreachable ();
2168
2169     found:
2170       b = *here;
2171       *here = b->prev;
2172       b->prev = current_scope->bindings;
2173       current_scope->bindings = b;
2174
2175       TREE_ASM_WRITTEN (olddecl) = 0;
2176     }
2177
2178   DECL_ATTRIBUTES (newdecl)
2179     = targetm.merge_decl_attributes (olddecl, newdecl);
2180
2181   /* Merge the data types specified in the two decls.  */
2182   TREE_TYPE (newdecl)
2183     = TREE_TYPE (olddecl)
2184     = composite_type (newtype, oldtype);
2185
2186   /* Lay the type out, unless already done.  */
2187   if (!comptypes (oldtype, TREE_TYPE (newdecl)))
2188     {
2189       if (TREE_TYPE (newdecl) != error_mark_node)
2190         layout_type (TREE_TYPE (newdecl));
2191       if (TREE_CODE (newdecl) != FUNCTION_DECL
2192           && TREE_CODE (newdecl) != TYPE_DECL
2193           && TREE_CODE (newdecl) != CONST_DECL)
2194         layout_decl (newdecl, 0);
2195     }
2196   else
2197     {
2198       /* Since the type is OLDDECL's, make OLDDECL's size go with.  */
2199       DECL_SIZE (newdecl) = DECL_SIZE (olddecl);
2200       DECL_SIZE_UNIT (newdecl) = DECL_SIZE_UNIT (olddecl);
2201       DECL_MODE (newdecl) = DECL_MODE (olddecl);
2202       if (DECL_ALIGN (olddecl) > DECL_ALIGN (newdecl))
2203         {
2204           DECL_ALIGN (newdecl) = DECL_ALIGN (olddecl);
2205           DECL_USER_ALIGN (newdecl) |= DECL_USER_ALIGN (olddecl);
2206         }
2207     }
2208
2209   /* Keep the old rtl since we can safely use it.  */
2210   if (HAS_RTL_P (olddecl))
2211     COPY_DECL_RTL (olddecl, newdecl);
2212
2213   /* Merge the type qualifiers.  */
2214   if (TREE_READONLY (newdecl))
2215     TREE_READONLY (olddecl) = 1;
2216
2217   if (TREE_THIS_VOLATILE (newdecl))
2218     TREE_THIS_VOLATILE (olddecl) = 1;
2219
2220   /* Merge deprecatedness.  */
2221   if (TREE_DEPRECATED (newdecl))
2222     TREE_DEPRECATED (olddecl) = 1;
2223
2224   /* If a decl is in a system header and the other isn't, keep the one on the
2225      system header. Otherwise, keep source location of definition rather than
2226      declaration and of prototype rather than non-prototype unless that
2227      prototype is built-in.  */
2228   if (CODE_CONTAINS_STRUCT (TREE_CODE (olddecl), TS_DECL_WITH_VIS)
2229       && DECL_IN_SYSTEM_HEADER (olddecl)
2230       && !DECL_IN_SYSTEM_HEADER (newdecl) )
2231     DECL_SOURCE_LOCATION (newdecl) = DECL_SOURCE_LOCATION (olddecl);
2232   else if (CODE_CONTAINS_STRUCT (TREE_CODE (olddecl), TS_DECL_WITH_VIS)
2233            && DECL_IN_SYSTEM_HEADER (newdecl)
2234            && !DECL_IN_SYSTEM_HEADER (olddecl))
2235     DECL_SOURCE_LOCATION (olddecl) = DECL_SOURCE_LOCATION (newdecl);
2236   else if ((DECL_INITIAL (newdecl) == 0 && DECL_INITIAL (olddecl) != 0)
2237            || (old_is_prototype && !new_is_prototype
2238                && !C_DECL_BUILTIN_PROTOTYPE (olddecl)))
2239     DECL_SOURCE_LOCATION (newdecl) = DECL_SOURCE_LOCATION (olddecl);
2240
2241   /* Merge the initialization information.  */
2242    if (DECL_INITIAL (newdecl) == 0)
2243     DECL_INITIAL (newdecl) = DECL_INITIAL (olddecl);
2244
2245   /* Merge the threadprivate attribute.  */
2246   if (TREE_CODE (olddecl) == VAR_DECL && C_DECL_THREADPRIVATE_P (olddecl))
2247     {
2248       DECL_TLS_MODEL (newdecl) = DECL_TLS_MODEL (olddecl);
2249       C_DECL_THREADPRIVATE_P (newdecl) = 1;
2250     }
2251
2252   if (CODE_CONTAINS_STRUCT (TREE_CODE (olddecl), TS_DECL_WITH_VIS))
2253     {
2254       /* Merge the section attribute.
2255          We want to issue an error if the sections conflict but that
2256          must be done later in decl_attributes since we are called
2257          before attributes are assigned.  */
2258       if (DECL_SECTION_NAME (newdecl) == NULL_TREE)
2259         DECL_SECTION_NAME (newdecl) = DECL_SECTION_NAME (olddecl);
2260
2261       /* Copy the assembler name.
2262          Currently, it can only be defined in the prototype.  */
2263       COPY_DECL_ASSEMBLER_NAME (olddecl, newdecl);
2264
2265       /* Use visibility of whichever declaration had it specified */
2266       if (DECL_VISIBILITY_SPECIFIED (olddecl))
2267         {
2268           DECL_VISIBILITY (newdecl) = DECL_VISIBILITY (olddecl);
2269           DECL_VISIBILITY_SPECIFIED (newdecl) = 1;
2270         }
2271
2272       if (TREE_CODE (newdecl) == FUNCTION_DECL)
2273         {
2274           DECL_STATIC_CONSTRUCTOR(newdecl) |= DECL_STATIC_CONSTRUCTOR(olddecl);
2275           DECL_STATIC_DESTRUCTOR (newdecl) |= DECL_STATIC_DESTRUCTOR (olddecl);
2276           DECL_NO_LIMIT_STACK (newdecl) |= DECL_NO_LIMIT_STACK (olddecl);
2277           DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (newdecl)
2278             |= DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (olddecl);
2279           TREE_THIS_VOLATILE (newdecl) |= TREE_THIS_VOLATILE (olddecl);
2280           DECL_IS_MALLOC (newdecl) |= DECL_IS_MALLOC (olddecl);
2281           DECL_IS_OPERATOR_NEW (newdecl) |= DECL_IS_OPERATOR_NEW (olddecl);
2282           TREE_READONLY (newdecl) |= TREE_READONLY (olddecl);
2283           DECL_PURE_P (newdecl) |= DECL_PURE_P (olddecl);
2284           DECL_IS_NOVOPS (newdecl) |= DECL_IS_NOVOPS (olddecl);
2285         }
2286
2287       /* Merge the storage class information.  */
2288       merge_weak (newdecl, olddecl);
2289
2290       /* For functions, static overrides non-static.  */
2291       if (TREE_CODE (newdecl) == FUNCTION_DECL)
2292         {
2293           TREE_PUBLIC (newdecl) &= TREE_PUBLIC (olddecl);
2294           /* This is since we don't automatically
2295              copy the attributes of NEWDECL into OLDDECL.  */
2296           TREE_PUBLIC (olddecl) = TREE_PUBLIC (newdecl);
2297           /* If this clears `static', clear it in the identifier too.  */
2298           if (!TREE_PUBLIC (olddecl))
2299             TREE_PUBLIC (DECL_NAME (olddecl)) = 0;
2300         }
2301     }
2302
2303   /* In c99, 'extern' declaration before (or after) 'inline' means this
2304      function is not DECL_EXTERNAL, unless 'gnu_inline' attribute
2305      is present.  */
2306   if (TREE_CODE (newdecl) == FUNCTION_DECL
2307       && !flag_gnu89_inline
2308       && (DECL_DECLARED_INLINE_P (newdecl)
2309           || DECL_DECLARED_INLINE_P (olddecl))
2310       && (!DECL_DECLARED_INLINE_P (newdecl)
2311           || !DECL_DECLARED_INLINE_P (olddecl)
2312           || !DECL_EXTERNAL (olddecl))
2313       && DECL_EXTERNAL (newdecl)
2314       && !lookup_attribute ("gnu_inline", DECL_ATTRIBUTES (newdecl))
2315       && !current_function_decl)
2316     DECL_EXTERNAL (newdecl) = 0;
2317
2318   if (DECL_EXTERNAL (newdecl))
2319     {
2320       TREE_STATIC (newdecl) = TREE_STATIC (olddecl);
2321       DECL_EXTERNAL (newdecl) = DECL_EXTERNAL (olddecl);
2322
2323       /* An extern decl does not override previous storage class.  */
2324       TREE_PUBLIC (newdecl) = TREE_PUBLIC (olddecl);
2325       if (!DECL_EXTERNAL (newdecl))
2326         {
2327           DECL_CONTEXT (newdecl) = DECL_CONTEXT (olddecl);
2328           DECL_COMMON (newdecl) = DECL_COMMON (olddecl);
2329         }
2330     }
2331   else
2332     {
2333       TREE_STATIC (olddecl) = TREE_STATIC (newdecl);
2334       TREE_PUBLIC (olddecl) = TREE_PUBLIC (newdecl);
2335     }
2336
2337   if (TREE_CODE (newdecl) == FUNCTION_DECL)
2338     {
2339       /* If we're redefining a function previously defined as extern
2340          inline, make sure we emit debug info for the inline before we
2341          throw it away, in case it was inlined into a function that
2342          hasn't been written out yet.  */
2343       if (new_is_definition && DECL_INITIAL (olddecl))
2344         /* The new defn must not be inline.  */
2345         DECL_UNINLINABLE (newdecl) = 1;
2346       else
2347         {
2348           /* If either decl says `inline', this fn is inline, unless
2349              its definition was passed already.  */
2350           if (DECL_DECLARED_INLINE_P (newdecl)
2351               || DECL_DECLARED_INLINE_P (olddecl))
2352             DECL_DECLARED_INLINE_P (newdecl) = 1;
2353
2354           DECL_UNINLINABLE (newdecl) = DECL_UNINLINABLE (olddecl)
2355             = (DECL_UNINLINABLE (newdecl) || DECL_UNINLINABLE (olddecl));
2356
2357           DECL_DISREGARD_INLINE_LIMITS (newdecl)
2358             = DECL_DISREGARD_INLINE_LIMITS (olddecl)
2359             = (DECL_DISREGARD_INLINE_LIMITS (newdecl)
2360                || DECL_DISREGARD_INLINE_LIMITS (olddecl));
2361         }
2362
2363       if (DECL_BUILT_IN (olddecl))
2364         {
2365           /* If redeclaring a builtin function, it stays built in.
2366              But it gets tagged as having been declared.  */
2367           DECL_BUILT_IN_CLASS (newdecl) = DECL_BUILT_IN_CLASS (olddecl);
2368           DECL_FUNCTION_CODE (newdecl) = DECL_FUNCTION_CODE (olddecl);
2369           C_DECL_DECLARED_BUILTIN (newdecl) = 1;
2370           if (new_is_prototype)
2371             {
2372               C_DECL_BUILTIN_PROTOTYPE (newdecl) = 0;
2373               if (DECL_BUILT_IN_CLASS (newdecl) == BUILT_IN_NORMAL)
2374                 {
2375                   enum built_in_function fncode = DECL_FUNCTION_CODE (newdecl);
2376                   switch (fncode)
2377                     {
2378                       /* If a compatible prototype of these builtin functions
2379                          is seen, assume the runtime implements it with the
2380                          expected semantics.  */
2381                     case BUILT_IN_STPCPY:
2382                       if (builtin_decl_explicit_p (fncode))
2383                         set_builtin_decl_implicit_p (fncode, true);
2384                       break;
2385                     default:
2386                       break;
2387                     }
2388                 }
2389             }
2390           else
2391             C_DECL_BUILTIN_PROTOTYPE (newdecl)
2392               = C_DECL_BUILTIN_PROTOTYPE (olddecl);
2393         }
2394
2395       /* Preserve function specific target and optimization options */
2396       if (DECL_FUNCTION_SPECIFIC_TARGET (olddecl)
2397           && !DECL_FUNCTION_SPECIFIC_TARGET (newdecl))
2398         DECL_FUNCTION_SPECIFIC_TARGET (newdecl)
2399           = DECL_FUNCTION_SPECIFIC_TARGET (olddecl);
2400
2401       if (DECL_FUNCTION_SPECIFIC_OPTIMIZATION (olddecl)
2402           && !DECL_FUNCTION_SPECIFIC_OPTIMIZATION (newdecl))
2403         DECL_FUNCTION_SPECIFIC_OPTIMIZATION (newdecl)
2404           = DECL_FUNCTION_SPECIFIC_OPTIMIZATION (olddecl);
2405
2406       /* Also preserve various other info from the definition.  */
2407       if (!new_is_definition)
2408         {
2409           tree t;
2410           DECL_RESULT (newdecl) = DECL_RESULT (olddecl);
2411           DECL_INITIAL (newdecl) = DECL_INITIAL (olddecl);
2412           DECL_STRUCT_FUNCTION (newdecl) = DECL_STRUCT_FUNCTION (olddecl);
2413           DECL_SAVED_TREE (newdecl) = DECL_SAVED_TREE (olddecl);
2414           DECL_ARGUMENTS (newdecl) = copy_list (DECL_ARGUMENTS (olddecl));
2415           for (t = DECL_ARGUMENTS (newdecl); t ; t = DECL_CHAIN (t))
2416             DECL_CONTEXT (t) = newdecl;
2417
2418           /* See if we've got a function to instantiate from.  */
2419           if (DECL_SAVED_TREE (olddecl))
2420             DECL_ABSTRACT_ORIGIN (newdecl)
2421               = DECL_ABSTRACT_ORIGIN (olddecl);
2422         }
2423     }
2424
2425   extern_changed = DECL_EXTERNAL (olddecl) && !DECL_EXTERNAL (newdecl);
2426
2427   /* Merge the USED information.  */
2428   if (TREE_USED (olddecl))
2429     TREE_USED (newdecl) = 1;
2430   else if (TREE_USED (newdecl))
2431     TREE_USED (olddecl) = 1;
2432   if (TREE_CODE (olddecl) == VAR_DECL || TREE_CODE (olddecl) == PARM_DECL)
2433     DECL_READ_P (newdecl) |= DECL_READ_P (olddecl);
2434   if (DECL_PRESERVE_P (olddecl))
2435     DECL_PRESERVE_P (newdecl) = 1;
2436   else if (DECL_PRESERVE_P (newdecl))
2437     DECL_PRESERVE_P (olddecl) = 1;
2438
2439   /* Copy most of the decl-specific fields of NEWDECL into OLDDECL.
2440      But preserve OLDDECL's DECL_UID, DECL_CONTEXT and
2441      DECL_ARGUMENTS (if appropriate).  */
2442   {
2443     unsigned olddecl_uid = DECL_UID (olddecl);
2444     tree olddecl_context = DECL_CONTEXT (olddecl);
2445     tree olddecl_arguments = NULL;
2446     if (TREE_CODE (olddecl) == FUNCTION_DECL)
2447       olddecl_arguments = DECL_ARGUMENTS (olddecl);
2448
2449     memcpy ((char *) olddecl + sizeof (struct tree_common),
2450             (char *) newdecl + sizeof (struct tree_common),
2451             sizeof (struct tree_decl_common) - sizeof (struct tree_common));
2452     DECL_USER_ALIGN (olddecl) = DECL_USER_ALIGN (newdecl);
2453     switch (TREE_CODE (olddecl))
2454       {
2455       case FUNCTION_DECL:
2456       case FIELD_DECL:
2457       case VAR_DECL:
2458       case PARM_DECL:
2459       case LABEL_DECL:
2460       case RESULT_DECL:
2461       case CONST_DECL:
2462       case TYPE_DECL:
2463         memcpy ((char *) olddecl + sizeof (struct tree_decl_common),
2464                 (char *) newdecl + sizeof (struct tree_decl_common),
2465                 tree_code_size (TREE_CODE (olddecl)) - sizeof (struct tree_decl_common));
2466         break;
2467
2468       default:
2469
2470         memcpy ((char *) olddecl + sizeof (struct tree_decl_common),
2471                 (char *) newdecl + sizeof (struct tree_decl_common),
2472                 sizeof (struct tree_decl_non_common) - sizeof (struct tree_decl_common));
2473       }
2474     DECL_UID (olddecl) = olddecl_uid;
2475     DECL_CONTEXT (olddecl) = olddecl_context;
2476     if (TREE_CODE (olddecl) == FUNCTION_DECL)
2477       DECL_ARGUMENTS (olddecl) = olddecl_arguments;
2478   }
2479
2480   /* If OLDDECL had its DECL_RTL instantiated, re-invoke make_decl_rtl
2481      so that encode_section_info has a chance to look at the new decl
2482      flags and attributes.  */
2483   if (DECL_RTL_SET_P (olddecl)
2484       && (TREE_CODE (olddecl) == FUNCTION_DECL
2485           || (TREE_CODE (olddecl) == VAR_DECL
2486               && TREE_STATIC (olddecl))))
2487     make_decl_rtl (olddecl);
2488
2489   /* If we changed a function from DECL_EXTERNAL to !DECL_EXTERNAL,
2490      and the definition is coming from the old version, cgraph needs
2491      to be called again.  */
2492   if (extern_changed && !new_is_definition
2493       && TREE_CODE (olddecl) == FUNCTION_DECL && DECL_INITIAL (olddecl))
2494     cgraph_mark_if_needed (olddecl);
2495 }
2496
2497 /* Handle when a new declaration NEWDECL has the same name as an old
2498    one OLDDECL in the same binding contour.  Prints an error message
2499    if appropriate.
2500
2501    If safely possible, alter OLDDECL to look like NEWDECL, and return
2502    true.  Otherwise, return false.  */
2503
2504 static bool
2505 duplicate_decls (tree newdecl, tree olddecl)
2506 {
2507   tree newtype = NULL, oldtype = NULL;
2508
2509   if (!diagnose_mismatched_decls (newdecl, olddecl, &newtype, &oldtype))
2510     {
2511       /* Avoid `unused variable' and other warnings for OLDDECL.  */
2512       TREE_NO_WARNING (olddecl) = 1;
2513       return false;
2514     }
2515
2516   merge_decls (newdecl, olddecl, newtype, oldtype);
2517   return true;
2518 }
2519
2520 \f
2521 /* Check whether decl-node NEW_DECL shadows an existing declaration.  */
2522 static void
2523 warn_if_shadowing (tree new_decl)
2524 {
2525   struct c_binding *b;
2526
2527   /* Shadow warnings wanted?  */
2528   if (!warn_shadow
2529       /* No shadow warnings for internally generated vars.  */
2530       || DECL_IS_BUILTIN (new_decl)
2531       /* No shadow warnings for vars made for inlining.  */
2532       || DECL_FROM_INLINE (new_decl))
2533     return;
2534
2535   /* Is anything being shadowed?  Invisible decls do not count.  */
2536   for (b = I_SYMBOL_BINDING (DECL_NAME (new_decl)); b; b = b->shadowed)
2537     if (b->decl && b->decl != new_decl && !b->invisible
2538         && (b->decl == error_mark_node
2539             || diagnostic_report_warnings_p (global_dc,
2540                                              DECL_SOURCE_LOCATION (b->decl))))
2541       {
2542         tree old_decl = b->decl;
2543
2544         if (old_decl == error_mark_node)
2545           {
2546             warning (OPT_Wshadow, "declaration of %q+D shadows previous "
2547                      "non-variable", new_decl);
2548             break;
2549           }
2550         else if (TREE_CODE (old_decl) == PARM_DECL)
2551           warning (OPT_Wshadow, "declaration of %q+D shadows a parameter",
2552                    new_decl);
2553         else if (DECL_FILE_SCOPE_P (old_decl))
2554           warning (OPT_Wshadow, "declaration of %q+D shadows a global "
2555                    "declaration", new_decl);
2556         else if (TREE_CODE (old_decl) == FUNCTION_DECL
2557                  && DECL_BUILT_IN (old_decl))
2558           {
2559             warning (OPT_Wshadow, "declaration of %q+D shadows "
2560                      "a built-in function", new_decl);
2561             break;
2562           }
2563         else
2564           warning (OPT_Wshadow, "declaration of %q+D shadows a previous local",
2565                    new_decl);
2566
2567         warning_at (DECL_SOURCE_LOCATION (old_decl), OPT_Wshadow,
2568                     "shadowed declaration is here");
2569
2570         break;
2571       }
2572 }
2573
2574 /* Record a decl-node X as belonging to the current lexical scope.
2575    Check for errors (such as an incompatible declaration for the same
2576    name already seen in the same scope).
2577
2578    Returns either X or an old decl for the same name.
2579    If an old decl is returned, it may have been smashed
2580    to agree with what X says.  */
2581
2582 tree
2583 pushdecl (tree x)
2584 {
2585   tree name = DECL_NAME (x);
2586   struct c_scope *scope = current_scope;
2587   struct c_binding *b;
2588   bool nested = false;
2589   location_t locus = DECL_SOURCE_LOCATION (x);
2590
2591   /* Must set DECL_CONTEXT for everything not at file scope or
2592      DECL_FILE_SCOPE_P won't work.  Local externs don't count
2593      unless they have initializers (which generate code).  */
2594   if (current_function_decl
2595       && ((TREE_CODE (x) != FUNCTION_DECL && TREE_CODE (x) != VAR_DECL)
2596           || DECL_INITIAL (x) || !DECL_EXTERNAL (x)))
2597     DECL_CONTEXT (x) = current_function_decl;
2598
2599   /* Anonymous decls are just inserted in the scope.  */
2600   if (!name)
2601     {
2602       bind (name, x, scope, /*invisible=*/false, /*nested=*/false,
2603             locus);
2604       return x;
2605     }
2606
2607   /* First, see if there is another declaration with the same name in
2608      the current scope.  If there is, duplicate_decls may do all the
2609      work for us.  If duplicate_decls returns false, that indicates
2610      two incompatible decls in the same scope; we are to silently
2611      replace the old one (duplicate_decls has issued all appropriate
2612      diagnostics).  In particular, we should not consider possible
2613      duplicates in the external scope, or shadowing.  */
2614   b = I_SYMBOL_BINDING (name);
2615   if (b && B_IN_SCOPE (b, scope))
2616     {
2617       struct c_binding *b_ext, *b_use;
2618       tree type = TREE_TYPE (x);
2619       tree visdecl = b->decl;
2620       tree vistype = TREE_TYPE (visdecl);
2621       if (TREE_CODE (TREE_TYPE (x)) == ARRAY_TYPE
2622           && COMPLETE_TYPE_P (TREE_TYPE (x)))
2623         b->inner_comp = false;
2624       b_use = b;
2625       b_ext = b;
2626       /* If this is an external linkage declaration, we should check
2627          for compatibility with the type in the external scope before
2628          setting the type at this scope based on the visible
2629          information only.  */
2630       if (TREE_PUBLIC (x) && TREE_PUBLIC (visdecl))
2631         {
2632           while (b_ext && !B_IN_EXTERNAL_SCOPE (b_ext))
2633             b_ext = b_ext->shadowed;
2634           if (b_ext)
2635             {
2636               b_use = b_ext;
2637               if (b_use->u.type)
2638                 TREE_TYPE (b_use->decl) = b_use->u.type;
2639             }
2640         }
2641       if (duplicate_decls (x, b_use->decl))
2642         {
2643           if (b_use != b)
2644             {
2645               /* Save the updated type in the external scope and
2646                  restore the proper type for this scope.  */
2647               tree thistype;
2648               if (comptypes (vistype, type))
2649                 thistype = composite_type (vistype, type);
2650               else
2651                 thistype = TREE_TYPE (b_use->decl);
2652               b_use->u.type = TREE_TYPE (b_use->decl);
2653               if (TREE_CODE (b_use->decl) == FUNCTION_DECL
2654                   && DECL_BUILT_IN (b_use->decl))
2655                 thistype
2656                   = build_type_attribute_variant (thistype,
2657                                                   TYPE_ATTRIBUTES
2658                                                   (b_use->u.type));
2659               TREE_TYPE (b_use->decl) = thistype;
2660             }
2661           return b_use->decl;
2662         }
2663       else
2664         goto skip_external_and_shadow_checks;
2665     }
2666
2667   /* All declarations with external linkage, and all external
2668      references, go in the external scope, no matter what scope is
2669      current.  However, the binding in that scope is ignored for
2670      purposes of normal name lookup.  A separate binding structure is
2671      created in the requested scope; this governs the normal
2672      visibility of the symbol.
2673
2674      The binding in the externals scope is used exclusively for
2675      detecting duplicate declarations of the same object, no matter
2676      what scope they are in; this is what we do here.  (C99 6.2.7p2:
2677      All declarations that refer to the same object or function shall
2678      have compatible type; otherwise, the behavior is undefined.)  */
2679   if (DECL_EXTERNAL (x) || scope == file_scope)
2680     {
2681       tree type = TREE_TYPE (x);
2682       tree vistype = 0;
2683       tree visdecl = 0;
2684       bool type_saved = false;
2685       if (b && !B_IN_EXTERNAL_SCOPE (b)
2686           && (TREE_CODE (b->decl) == FUNCTION_DECL
2687               || TREE_CODE (b->decl) == VAR_DECL)
2688           && DECL_FILE_SCOPE_P (b->decl))
2689         {
2690           visdecl = b->decl;
2691           vistype = TREE_TYPE (visdecl);
2692         }
2693       if (scope != file_scope
2694           && !DECL_IN_SYSTEM_HEADER (x))
2695         warning (OPT_Wnested_externs, "nested extern declaration of %qD", x);
2696
2697       while (b && !B_IN_EXTERNAL_SCOPE (b))
2698         {
2699           /* If this decl might be modified, save its type.  This is
2700              done here rather than when the decl is first bound
2701              because the type may change after first binding, through
2702              being completed or through attributes being added.  If we
2703              encounter multiple such decls, only the first should have
2704              its type saved; the others will already have had their
2705              proper types saved and the types will not have changed as
2706              their scopes will not have been re-entered.  */
2707           if (DECL_P (b->decl) && DECL_FILE_SCOPE_P (b->decl) && !type_saved)
2708             {
2709               b->u.type = TREE_TYPE (b->decl);
2710               type_saved = true;
2711             }
2712           if (B_IN_FILE_SCOPE (b)
2713               && TREE_CODE (b->decl) == VAR_DECL
2714               && TREE_STATIC (b->decl)
2715               && TREE_CODE (TREE_TYPE (b->decl)) == ARRAY_TYPE
2716               && !TYPE_DOMAIN (TREE_TYPE (b->decl))
2717               && TREE_CODE (type) == ARRAY_TYPE
2718               && TYPE_DOMAIN (type)
2719               && TYPE_MAX_VALUE (TYPE_DOMAIN (type))
2720               && !integer_zerop (TYPE_MAX_VALUE (TYPE_DOMAIN (type))))
2721             {
2722               /* Array type completed in inner scope, which should be
2723                  diagnosed if the completion does not have size 1 and
2724                  it does not get completed in the file scope.  */
2725               b->inner_comp = true;
2726             }
2727           b = b->shadowed;
2728         }
2729
2730       /* If a matching external declaration has been found, set its
2731          type to the composite of all the types of that declaration.
2732          After the consistency checks, it will be reset to the
2733          composite of the visible types only.  */
2734       if (b && (TREE_PUBLIC (x) || same_translation_unit_p (x, b->decl))
2735           && b->u.type)
2736         TREE_TYPE (b->decl) = b->u.type;
2737
2738       /* The point of the same_translation_unit_p check here is,
2739          we want to detect a duplicate decl for a construct like
2740          foo() { extern bar(); } ... static bar();  but not if
2741          they are in different translation units.  In any case,
2742          the static does not go in the externals scope.  */
2743       if (b
2744           && (TREE_PUBLIC (x) || same_translation_unit_p (x, b->decl))
2745           && duplicate_decls (x, b->decl))
2746         {
2747           tree thistype;
2748           if (vistype)
2749             {
2750               if (comptypes (vistype, type))
2751                 thistype = composite_type (vistype, type);
2752               else
2753                 thistype = TREE_TYPE (b->decl);
2754             }
2755           else
2756             thistype = type;
2757           b->u.type = TREE_TYPE (b->decl);
2758           if (TREE_CODE (b->decl) == FUNCTION_DECL && DECL_BUILT_IN (b->decl))
2759             thistype
2760               = build_type_attribute_variant (thistype,
2761                                               TYPE_ATTRIBUTES (b->u.type));
2762           TREE_TYPE (b->decl) = thistype;
2763           bind (name, b->decl, scope, /*invisible=*/false, /*nested=*/true,
2764                 locus);
2765           return b->decl;
2766         }
2767       else if (TREE_PUBLIC (x))
2768         {
2769           if (visdecl && !b && duplicate_decls (x, visdecl))
2770             {
2771               /* An external declaration at block scope referring to a
2772                  visible entity with internal linkage.  The composite
2773                  type will already be correct for this scope, so we
2774                  just need to fall through to make the declaration in
2775                  this scope.  */
2776               nested = true;
2777               x = visdecl;
2778             }
2779           else
2780             {
2781               bind (name, x, external_scope, /*invisible=*/true,
2782                     /*nested=*/false, locus);
2783               nested = true;
2784             }
2785         }
2786     }
2787
2788   if (TREE_CODE (x) != PARM_DECL)
2789     warn_if_shadowing (x);
2790
2791  skip_external_and_shadow_checks:
2792   if (TREE_CODE (x) == TYPE_DECL)
2793     {
2794       /* So this is a typedef, set its underlying type.  */
2795       set_underlying_type (x);
2796
2797       /* If X is a typedef defined in the current function, record it
2798          for the purpose of implementing the -Wunused-local-typedefs
2799          warning.  */
2800       record_locally_defined_typedef (x);
2801     }
2802
2803   bind (name, x, scope, /*invisible=*/false, nested, locus);
2804
2805   /* If x's type is incomplete because it's based on a
2806      structure or union which has not yet been fully declared,
2807      attach it to that structure or union type, so we can go
2808      back and complete the variable declaration later, if the
2809      structure or union gets fully declared.
2810
2811      If the input is erroneous, we can have error_mark in the type
2812      slot (e.g. "f(void a, ...)") - that doesn't count as an
2813      incomplete type.  */
2814   if (TREE_TYPE (x) != error_mark_node
2815       && !COMPLETE_TYPE_P (TREE_TYPE (x)))
2816     {
2817       tree element = TREE_TYPE (x);
2818
2819       while (TREE_CODE (element) == ARRAY_TYPE)
2820         element = TREE_TYPE (element);
2821       element = TYPE_MAIN_VARIANT (element);
2822
2823       if ((TREE_CODE (element) == RECORD_TYPE
2824            || TREE_CODE (element) == UNION_TYPE)
2825           && (TREE_CODE (x) != TYPE_DECL
2826               || TREE_CODE (TREE_TYPE (x)) == ARRAY_TYPE)
2827           && !COMPLETE_TYPE_P (element))
2828         C_TYPE_INCOMPLETE_VARS (element)
2829           = tree_cons (NULL_TREE, x, C_TYPE_INCOMPLETE_VARS (element));
2830     }
2831   return x;
2832 }
2833
2834 /* Record X as belonging to file scope.
2835    This is used only internally by the Objective-C front end,
2836    and is limited to its needs.  duplicate_decls is not called;
2837    if there is any preexisting decl for this identifier, it is an ICE.  */
2838
2839 tree
2840 pushdecl_top_level (tree x)
2841 {
2842   tree name;
2843   bool nested = false;
2844   gcc_assert (TREE_CODE (x) == VAR_DECL || TREE_CODE (x) == CONST_DECL);
2845
2846   name = DECL_NAME (x);
2847
2848  gcc_assert (TREE_CODE (x) == CONST_DECL || !I_SYMBOL_BINDING (name));
2849
2850   if (TREE_PUBLIC (x))
2851     {
2852       bind (name, x, external_scope, /*invisible=*/true, /*nested=*/false,
2853             UNKNOWN_LOCATION);
2854       nested = true;
2855     }
2856   if (file_scope)
2857     bind (name, x, file_scope, /*invisible=*/false, nested, UNKNOWN_LOCATION);
2858
2859   return x;
2860 }
2861 \f
2862 static void
2863 implicit_decl_warning (tree id, tree olddecl)
2864 {
2865   if (warn_implicit_function_declaration)
2866     {
2867       bool warned;
2868
2869       if (flag_isoc99)
2870         warned = pedwarn (input_location, OPT_Wimplicit_function_declaration,
2871                           "implicit declaration of function %qE", id);
2872       else
2873         warned = warning (OPT_Wimplicit_function_declaration,
2874                           G_("implicit declaration of function %qE"), id);
2875       if (olddecl && warned)
2876         locate_old_decl (olddecl);
2877     }
2878 }
2879
2880 /* Generate an implicit declaration for identifier FUNCTIONID at LOC as a
2881    function of type int ().  */
2882
2883 tree
2884 implicitly_declare (location_t loc, tree functionid)
2885 {
2886   struct c_binding *b;
2887   tree decl = 0;
2888   tree asmspec_tree;
2889
2890   for (b = I_SYMBOL_BINDING (functionid); b; b = b->shadowed)
2891     {
2892       if (B_IN_SCOPE (b, external_scope))
2893         {
2894           decl = b->decl;
2895           break;
2896         }
2897     }
2898
2899   if (decl)
2900     {
2901       if (decl == error_mark_node)
2902         return decl;
2903
2904       /* FIXME: Objective-C has weird not-really-builtin functions
2905          which are supposed to be visible automatically.  They wind up
2906          in the external scope because they're pushed before the file
2907          scope gets created.  Catch this here and rebind them into the
2908          file scope.  */
2909       if (!DECL_BUILT_IN (decl) && DECL_IS_BUILTIN (decl))
2910         {
2911           bind (functionid, decl, file_scope,
2912                 /*invisible=*/false, /*nested=*/true,
2913                 DECL_SOURCE_LOCATION (decl));
2914           return decl;
2915         }
2916       else
2917         {
2918           tree newtype = default_function_type;
2919           if (b->u.type)
2920             TREE_TYPE (decl) = b->u.type;
2921           /* Implicit declaration of a function already declared
2922              (somehow) in a different scope, or as a built-in.
2923              If this is the first time this has happened, warn;
2924              then recycle the old declaration but with the new type.  */
2925           if (!C_DECL_IMPLICIT (decl))
2926             {
2927               implicit_decl_warning (functionid, decl);
2928               C_DECL_IMPLICIT (decl) = 1;
2929             }
2930           if (DECL_BUILT_IN (decl))
2931             {
2932               newtype = build_type_attribute_variant (newtype,
2933                                                       TYPE_ATTRIBUTES
2934                                                       (TREE_TYPE (decl)));
2935               if (!comptypes (newtype, TREE_TYPE (decl)))
2936                 {
2937                   warning_at (loc, 0, "incompatible implicit declaration of "
2938                               "built-in function %qD", decl);
2939                   newtype = TREE_TYPE (decl);
2940                 }
2941             }
2942           else
2943             {
2944               if (!comptypes (newtype, TREE_TYPE (decl)))
2945                 {
2946                   error_at (loc, "incompatible implicit declaration of function %qD", decl);
2947                   locate_old_decl (decl);
2948                 }
2949             }
2950           b->u.type = TREE_TYPE (decl);
2951           TREE_TYPE (decl) = newtype;
2952           bind (functionid, decl, current_scope,
2953                 /*invisible=*/false, /*nested=*/true,
2954                 DECL_SOURCE_LOCATION (decl));
2955           return decl;
2956         }
2957     }
2958
2959   /* Not seen before.  */
2960   decl = build_decl (loc, FUNCTION_DECL, functionid, default_function_type);
2961   DECL_EXTERNAL (decl) = 1;
2962   TREE_PUBLIC (decl) = 1;
2963   C_DECL_IMPLICIT (decl) = 1;
2964   implicit_decl_warning (functionid, 0);
2965   asmspec_tree = maybe_apply_renaming_pragma (decl, /*asmname=*/NULL);
2966   if (asmspec_tree)
2967     set_user_assembler_name (decl, TREE_STRING_POINTER (asmspec_tree));
2968
2969   /* C89 says implicit declarations are in the innermost block.
2970      So we record the decl in the standard fashion.  */
2971   decl = pushdecl (decl);
2972
2973   /* No need to call objc_check_decl here - it's a function type.  */
2974   rest_of_decl_compilation (decl, 0, 0);
2975
2976   /* Write a record describing this implicit function declaration
2977      to the prototypes file (if requested).  */
2978   gen_aux_info_record (decl, 0, 1, 0);
2979
2980   /* Possibly apply some default attributes to this implicit declaration.  */
2981   decl_attributes (&decl, NULL_TREE, 0);
2982
2983   return decl;
2984 }
2985
2986 /* Issue an error message for a reference to an undeclared variable
2987    ID, including a reference to a builtin outside of function-call
2988    context.  Establish a binding of the identifier to error_mark_node
2989    in an appropriate scope, which will suppress further errors for the
2990    same identifier.  The error message should be given location LOC.  */
2991 void
2992 undeclared_variable (location_t loc, tree id)
2993 {
2994   static bool already = false;
2995   struct c_scope *scope;
2996
2997   if (current_function_decl == 0)
2998     {
2999       error_at (loc, "%qE undeclared here (not in a function)", id);
3000       scope = current_scope;
3001     }
3002   else
3003     {
3004       if (!objc_diagnose_private_ivar (id))
3005         error_at (loc, "%qE undeclared (first use in this function)", id);
3006       if (!already)
3007         {
3008           inform (loc, "each undeclared identifier is reported only"
3009                   " once for each function it appears in");
3010           already = true;
3011         }
3012
3013       /* If we are parsing old-style parameter decls, current_function_decl
3014          will be nonnull but current_function_scope will be null.  */
3015       scope = current_function_scope ? current_function_scope : current_scope;
3016     }
3017   bind (id, error_mark_node, scope, /*invisible=*/false, /*nested=*/false,
3018         UNKNOWN_LOCATION);
3019 }
3020 \f
3021 /* Subroutine of lookup_label, declare_label, define_label: construct a
3022    LABEL_DECL with all the proper frills.  Also create a struct
3023    c_label_vars initialized for the current scope.  */
3024
3025 static tree
3026 make_label (location_t location, tree name, bool defining,
3027             struct c_label_vars **p_label_vars)
3028 {
3029   tree label = build_decl (location, LABEL_DECL, name, void_type_node);
3030   struct c_label_vars *label_vars;
3031
3032   DECL_CONTEXT (label) = current_function_decl;
3033   DECL_MODE (label) = VOIDmode;
3034
3035   label_vars = ggc_alloc_c_label_vars ();
3036   label_vars->shadowed = NULL;
3037   set_spot_bindings (&label_vars->label_bindings, defining);
3038   label_vars->decls_in_scope = make_tree_vector ();
3039   label_vars->gotos = VEC_alloc (c_goto_bindings_p, gc, 0);
3040   *p_label_vars = label_vars;
3041
3042   return label;
3043 }
3044
3045 /* Get the LABEL_DECL corresponding to identifier NAME as a label.
3046    Create one if none exists so far for the current function.
3047    This is called when a label is used in a goto expression or
3048    has its address taken.  */
3049
3050 tree
3051 lookup_label (tree name)
3052 {
3053   tree label;
3054   struct c_label_vars *label_vars;
3055
3056   if (current_function_scope == 0)
3057     {
3058       error ("label %qE referenced outside of any function", name);
3059       return 0;
3060     }
3061
3062   /* Use a label already defined or ref'd with this name, but not if
3063      it is inherited from a containing function and wasn't declared
3064      using __label__.  */
3065   label = I_LABEL_DECL (name);
3066   if (label && (DECL_CONTEXT (label) == current_function_decl
3067                 || C_DECLARED_LABEL_FLAG (label)))
3068     {
3069       /* If the label has only been declared, update its apparent
3070          location to point here, for better diagnostics if it
3071          turns out not to have been defined.  */
3072       if (DECL_INITIAL (label) == NULL_TREE)
3073         DECL_SOURCE_LOCATION (label) = input_location;
3074       return label;
3075     }
3076
3077   /* No label binding for that identifier; make one.  */
3078   label = make_label (input_location, name, false, &label_vars);
3079
3080   /* Ordinary labels go in the current function scope.  */
3081   bind_label (name, label, current_function_scope, label_vars);
3082
3083   return label;
3084 }
3085
3086 /* Issue a warning about DECL for a goto statement at GOTO_LOC going
3087    to LABEL.  */
3088
3089 static void
3090 warn_about_goto (location_t goto_loc, tree label, tree decl)
3091 {
3092   if (variably_modified_type_p (TREE_TYPE (decl), NULL_TREE))
3093     error_at (goto_loc,
3094               "jump into scope of identifier with variably modified type");
3095   else
3096     warning_at (goto_loc, OPT_Wjump_misses_init,
3097                 "jump skips variable initialization");
3098   inform (DECL_SOURCE_LOCATION (label), "label %qD defined here", label);
3099   inform (DECL_SOURCE_LOCATION (decl), "%qD declared here", decl);
3100 }
3101
3102 /* Look up a label because of a goto statement.  This is like
3103    lookup_label, but also issues any appropriate warnings.  */
3104
3105 tree
3106 lookup_label_for_goto (location_t loc, tree name)
3107 {
3108   tree label;
3109   struct c_label_vars *label_vars;
3110   unsigned int ix;
3111   tree decl;
3112
3113   label = lookup_label (name);
3114   if (label == NULL_TREE)
3115     return NULL_TREE;
3116
3117   /* If we are jumping to a different function, we can't issue any
3118      useful warnings.  */
3119   if (DECL_CONTEXT (label) != current_function_decl)
3120     {
3121       gcc_assert (C_DECLARED_LABEL_FLAG (label));
3122       return label;
3123     }
3124
3125   label_vars = I_LABEL_BINDING (name)->u.label;
3126
3127   /* If the label has not yet been defined, then push this goto on a
3128      list for possible later warnings.  */
3129   if (label_vars->label_bindings.scope == NULL)
3130     {
3131       struct c_goto_bindings *g;
3132
3133       g = ggc_alloc_c_goto_bindings ();
3134       g->loc = loc;
3135       set_spot_bindings (&g->goto_bindings, true);
3136       VEC_safe_push (c_goto_bindings_p, gc, label_vars->gotos, g);
3137       return label;
3138     }
3139
3140   /* If there are any decls in label_vars->decls_in_scope, then this
3141      goto has missed the declaration of the decl.  This happens for a
3142      case like
3143        int i = 1;
3144       lab:
3145        ...
3146        goto lab;
3147      Issue a warning or error.  */
3148   FOR_EACH_VEC_ELT (tree, label_vars->decls_in_scope, ix, decl)
3149     warn_about_goto (loc, label, decl);
3150
3151   if (label_vars->label_bindings.left_stmt_expr)
3152     {
3153       error_at (loc, "jump into statement expression");
3154       inform (DECL_SOURCE_LOCATION (label), "label %qD defined here", label);
3155     }
3156
3157   return label;
3158 }
3159
3160 /* Make a label named NAME in the current function, shadowing silently
3161    any that may be inherited from containing functions or containing
3162    scopes.  This is called for __label__ declarations.  */
3163
3164 tree
3165 declare_label (tree name)
3166 {
3167   struct c_binding *b = I_LABEL_BINDING (name);
3168   tree label;
3169   struct c_label_vars *label_vars;
3170
3171   /* Check to make sure that the label hasn't already been declared
3172      at this scope */
3173   if (b && B_IN_CURRENT_SCOPE (b))
3174     {
3175       error ("duplicate label declaration %qE", name);
3176       locate_old_decl (b->decl);
3177
3178       /* Just use the previous declaration.  */
3179       return b->decl;
3180     }
3181
3182   label = make_label (input_location, name, false, &label_vars);
3183   C_DECLARED_LABEL_FLAG (label) = 1;
3184
3185   /* Declared labels go in the current scope.  */
3186   bind_label (name, label, current_scope, label_vars);
3187
3188   return label;
3189 }
3190
3191 /* When we define a label, issue any appropriate warnings if there are
3192    any gotos earlier in the function which jump to this label.  */
3193
3194 static void
3195 check_earlier_gotos (tree label, struct c_label_vars* label_vars)
3196 {
3197   unsigned int ix;
3198   struct c_goto_bindings *g;
3199
3200   FOR_EACH_VEC_ELT (c_goto_bindings_p, label_vars->gotos, ix, g)
3201     {
3202       struct c_binding *b;
3203       struct c_scope *scope;
3204
3205       /* We have a goto to this label.  The goto is going forward.  In
3206          g->scope, the goto is going to skip any binding which was
3207          defined after g->bindings_in_scope.  */
3208       if (g->goto_bindings.scope->has_jump_unsafe_decl)
3209         {
3210           for (b = g->goto_bindings.scope->bindings;
3211                b != g->goto_bindings.bindings_in_scope;
3212                b = b->prev)
3213             {
3214               if (decl_jump_unsafe (b->decl))
3215                 warn_about_goto (g->loc, label, b->decl);
3216             }
3217         }
3218
3219       /* We also need to warn about decls defined in any scopes
3220          between the scope of the label and the scope of the goto.  */
3221       for (scope = label_vars->label_bindings.scope;
3222            scope != g->goto_bindings.scope;
3223            scope = scope->outer)
3224         {
3225           gcc_assert (scope != NULL);
3226           if (scope->has_jump_unsafe_decl)
3227             {
3228               if (scope == label_vars->label_bindings.scope)
3229                 b = label_vars->label_bindings.bindings_in_scope;
3230               else
3231                 b = scope->bindings;
3232               for (; b != NULL; b = b->prev)
3233                 {
3234                   if (decl_jump_unsafe (b->decl))
3235                     warn_about_goto (g->loc, label, b->decl);
3236                 }
3237             }
3238         }
3239
3240       if (g->goto_bindings.stmt_exprs > 0)
3241         {
3242           error_at (g->loc, "jump into statement expression");
3243           inform (DECL_SOURCE_LOCATION (label), "label %qD defined here",
3244                   label);
3245         }
3246     }
3247
3248   /* Now that the label is defined, we will issue warnings about
3249      subsequent gotos to this label when we see them.  */
3250   VEC_truncate (c_goto_bindings_p, label_vars->gotos, 0);
3251   label_vars->gotos = NULL;
3252 }
3253
3254 /* Define a label, specifying the location in the source file.
3255    Return the LABEL_DECL node for the label, if the definition is valid.
3256    Otherwise return 0.  */
3257
3258 tree
3259 define_label (location_t location, tree name)
3260 {
3261   /* Find any preexisting label with this name.  It is an error
3262      if that label has already been defined in this function, or
3263      if there is a containing function with a declared label with
3264      the same name.  */
3265   tree label = I_LABEL_DECL (name);
3266
3267   if (label
3268       && ((DECL_CONTEXT (label) == current_function_decl
3269            && DECL_INITIAL (label) != 0)
3270           || (DECL_CONTEXT (label) != current_function_decl
3271               && C_DECLARED_LABEL_FLAG (label))))
3272     {
3273       error_at (location, "duplicate label %qD", label);
3274       locate_old_decl (label);
3275       return 0;
3276     }
3277   else if (label && DECL_CONTEXT (label) == current_function_decl)
3278     {
3279       struct c_label_vars *label_vars = I_LABEL_BINDING (name)->u.label;
3280
3281       /* The label has been used or declared already in this function,
3282          but not defined.  Update its location to point to this
3283          definition.  */
3284       DECL_SOURCE_LOCATION (label) = location;
3285       set_spot_bindings (&label_vars->label_bindings, true);
3286
3287       /* Issue warnings as required about any goto statements from
3288          earlier in the function.  */
3289       check_earlier_gotos (label, label_vars);
3290     }
3291   else
3292     {
3293       struct c_label_vars *label_vars;
3294
3295       /* No label binding for that identifier; make one.  */
3296       label = make_label (location, name, true, &label_vars);
3297
3298       /* Ordinary labels go in the current function scope.  */
3299       bind_label (name, label, current_function_scope, label_vars);
3300     }
3301
3302   if (!in_system_header && lookup_name (name))
3303     warning_at (location, OPT_Wtraditional,
3304                 "traditional C lacks a separate namespace "
3305                 "for labels, identifier %qE conflicts", name);
3306
3307   /* Mark label as having been defined.  */
3308   DECL_INITIAL (label) = error_mark_node;
3309   return label;
3310 }
3311 \f
3312 /* Get the bindings for a new switch statement.  This is used to issue
3313    warnings as appropriate for jumps from the switch to case or
3314    default labels.  */
3315
3316 struct c_spot_bindings *
3317 c_get_switch_bindings (void)
3318 {
3319   struct c_spot_bindings *switch_bindings;
3320
3321   switch_bindings = XNEW (struct c_spot_bindings);
3322   set_spot_bindings (switch_bindings, true);
3323   return switch_bindings;
3324 }
3325
3326 void
3327 c_release_switch_bindings (struct c_spot_bindings *bindings)
3328 {
3329   gcc_assert (bindings->stmt_exprs == 0 && !bindings->left_stmt_expr);
3330   XDELETE (bindings);
3331 }
3332
3333 /* This is called at the point of a case or default label to issue
3334    warnings about decls as needed.  It returns true if it found an
3335    error, not just a warning.  */
3336
3337 bool
3338 c_check_switch_jump_warnings (struct c_spot_bindings *switch_bindings,
3339                               location_t switch_loc, location_t case_loc)
3340 {
3341   bool saw_error;
3342   struct c_scope *scope;
3343
3344   saw_error = false;
3345   for (scope = current_scope;
3346        scope != switch_bindings->scope;
3347        scope = scope->outer)
3348     {
3349       struct c_binding *b;
3350
3351       gcc_assert (scope != NULL);
3352
3353       if (!scope->has_jump_unsafe_decl)
3354         continue;
3355
3356       for (b = scope->bindings; b != NULL; b = b->prev)
3357         {
3358           if (decl_jump_unsafe (b->decl))
3359             {
3360               if (variably_modified_type_p (TREE_TYPE (b->decl), NULL_TREE))
3361                 {
3362                   saw_error = true;
3363                   error_at (case_loc,
3364                             ("switch jumps into scope of identifier with "
3365                              "variably modified type"));
3366                 }
3367               else
3368                 warning_at (case_loc, OPT_Wjump_misses_init,
3369                             "switch jumps over variable initialization");
3370               inform (switch_loc, "switch starts here");
3371               inform (DECL_SOURCE_LOCATION (b->decl), "%qD declared here",
3372                       b->decl);
3373             }
3374         }
3375     }
3376
3377   if (switch_bindings->stmt_exprs > 0)
3378     {
3379       saw_error = true;
3380       error_at (case_loc, "switch jumps into statement expression");
3381       inform (switch_loc, "switch starts here");
3382     }
3383
3384   return saw_error;
3385 }
3386 \f
3387 /* Given NAME, an IDENTIFIER_NODE,
3388    return the structure (or union or enum) definition for that name.
3389    If THISLEVEL_ONLY is nonzero, searches only the current_scope.
3390    CODE says which kind of type the caller wants;
3391    it is RECORD_TYPE or UNION_TYPE or ENUMERAL_TYPE.
3392    If PLOC is not NULL and this returns non-null, it sets *PLOC to the
3393    location where the tag was defined.
3394    If the wrong kind of type is found, an error is reported.  */
3395
3396 static tree
3397 lookup_tag (enum tree_code code, tree name, int thislevel_only,
3398             location_t *ploc)
3399 {
3400   struct c_binding *b = I_TAG_BINDING (name);
3401   int thislevel = 0;
3402
3403   if (!b || !b->decl)
3404     return 0;
3405
3406   /* We only care about whether it's in this level if
3407      thislevel_only was set or it might be a type clash.  */
3408   if (thislevel_only || TREE_CODE (b->decl) != code)
3409     {
3410       /* For our purposes, a tag in the external scope is the same as
3411          a tag in the file scope.  (Primarily relevant to Objective-C
3412          and its builtin structure tags, which get pushed before the
3413          file scope is created.)  */
3414       if (B_IN_CURRENT_SCOPE (b)
3415           || (current_scope == file_scope && B_IN_EXTERNAL_SCOPE (b)))
3416         thislevel = 1;
3417     }
3418
3419   if (thislevel_only && !thislevel)
3420     return 0;
3421
3422   if (TREE_CODE (b->decl) != code)
3423     {
3424       /* Definition isn't the kind we were looking for.  */
3425       pending_invalid_xref = name;
3426       pending_invalid_xref_location = input_location;
3427
3428       /* If in the same binding level as a declaration as a tag
3429          of a different type, this must not be allowed to
3430          shadow that tag, so give the error immediately.
3431          (For example, "struct foo; union foo;" is invalid.)  */
3432       if (thislevel)
3433         pending_xref_error ();
3434     }
3435
3436   if (ploc != NULL)
3437     *ploc = b->locus;
3438
3439   return b->decl;
3440 }
3441
3442 /* Print an error message now
3443    for a recent invalid struct, union or enum cross reference.
3444    We don't print them immediately because they are not invalid
3445    when used in the `struct foo;' construct for shadowing.  */
3446
3447 void
3448 pending_xref_error (void)
3449 {
3450   if (pending_invalid_xref != 0)
3451     error_at (pending_invalid_xref_location, "%qE defined as wrong kind of tag",
3452               pending_invalid_xref);
3453   pending_invalid_xref = 0;
3454 }
3455
3456 \f
3457 /* Look up NAME in the current scope and its superiors
3458    in the namespace of variables, functions and typedefs.
3459    Return a ..._DECL node of some kind representing its definition,
3460    or return 0 if it is undefined.  */
3461
3462 tree
3463 lookup_name (tree name)
3464 {
3465   struct c_binding *b = I_SYMBOL_BINDING (name);
3466   if (b && !b->invisible)
3467     {
3468       maybe_record_typedef_use (b->decl);
3469       return b->decl;
3470     }
3471   return 0;
3472 }
3473
3474 /* Similar to `lookup_name' but look only at the indicated scope.  */
3475
3476 static tree
3477 lookup_name_in_scope (tree name, struct c_scope *scope)
3478 {
3479   struct c_binding *b;
3480
3481   for (b = I_SYMBOL_BINDING (name); b; b = b->shadowed)
3482     if (B_IN_SCOPE (b, scope))
3483       return b->decl;
3484   return 0;
3485 }
3486 \f
3487 /* Create the predefined scalar types of C,
3488    and some nodes representing standard constants (0, 1, (void *) 0).
3489    Initialize the global scope.
3490    Make definitions for built-in primitive functions.  */
3491
3492 void
3493 c_init_decl_processing (void)
3494 {
3495   location_t save_loc = input_location;
3496
3497   /* Initialize reserved words for parser.  */
3498   c_parse_init ();
3499
3500   current_function_decl = 0;
3501
3502   gcc_obstack_init (&parser_obstack);
3503
3504   /* Make the externals scope.  */
3505   push_scope ();
3506   external_scope = current_scope;
3507
3508   /* Declarations from c_common_nodes_and_builtins must not be associated
3509      with this input file, lest we get differences between using and not
3510      using preprocessed headers.  */
3511   input_location = BUILTINS_LOCATION;
3512
3513   c_common_nodes_and_builtins ();
3514
3515   /* In C, comparisons and TRUTH_* expressions have type int.  */
3516   truthvalue_type_node = integer_type_node;
3517   truthvalue_true_node = integer_one_node;
3518   truthvalue_false_node = integer_zero_node;
3519
3520   /* Even in C99, which has a real boolean type.  */
3521   pushdecl (build_decl (UNKNOWN_LOCATION, TYPE_DECL, get_identifier ("_Bool"),
3522                         boolean_type_node));
3523
3524   input_location = save_loc;
3525
3526   pedantic_lvalues = true;
3527
3528   make_fname_decl = c_make_fname_decl;
3529   start_fname_decls ();
3530 }
3531
3532 /* Create the VAR_DECL at LOC for __FUNCTION__ etc. ID is the name to
3533    give the decl, NAME is the initialization string and TYPE_DEP
3534    indicates whether NAME depended on the type of the function.  As we
3535    don't yet implement delayed emission of static data, we mark the
3536    decl as emitted so it is not placed in the output.  Anything using
3537    it must therefore pull out the STRING_CST initializer directly.
3538    FIXME.  */
3539
3540 static tree
3541 c_make_fname_decl (location_t loc, tree id, int type_dep)
3542 {
3543   const char *name = fname_as_string (type_dep);
3544   tree decl, type, init;
3545   size_t length = strlen (name);
3546
3547   type = build_array_type (char_type_node,
3548                            build_index_type (size_int (length)));
3549   type = c_build_qualified_type (type, TYPE_QUAL_CONST);
3550
3551   decl = build_decl (loc, VAR_DECL, id, type);
3552
3553   TREE_STATIC (decl) = 1;
3554   TREE_READONLY (decl) = 1;
3555   DECL_ARTIFICIAL (decl) = 1;
3556
3557   init = build_string (length + 1, name);
3558   free (CONST_CAST (char *, name));
3559   TREE_TYPE (init) = type;
3560   DECL_INITIAL (decl) = init;
3561
3562   TREE_USED (decl) = 1;
3563
3564   if (current_function_decl
3565       /* For invalid programs like this:
3566
3567          void foo()
3568          const char* p = __FUNCTION__;
3569
3570          the __FUNCTION__ is believed to appear in K&R style function
3571          parameter declarator.  In that case we still don't have
3572          function_scope.  */
3573       && (!seen_error () || current_function_scope))
3574     {
3575       DECL_CONTEXT (decl) = current_function_decl;
3576       bind (id, decl, current_function_scope,
3577             /*invisible=*/false, /*nested=*/false, UNKNOWN_LOCATION);
3578     }
3579
3580   finish_decl (decl, loc, init, NULL_TREE, NULL_TREE);
3581
3582   return decl;
3583 }
3584
3585 tree
3586 c_builtin_function (tree decl)
3587 {
3588   tree type = TREE_TYPE (decl);
3589   tree   id = DECL_NAME (decl);
3590
3591   const char *name = IDENTIFIER_POINTER (id);
3592   C_DECL_BUILTIN_PROTOTYPE (decl) = prototype_p (type);
3593
3594   /* Should never be called on a symbol with a preexisting meaning.  */
3595   gcc_assert (!I_SYMBOL_BINDING (id));
3596
3597   bind (id, decl, external_scope, /*invisible=*/true, /*nested=*/false,
3598         UNKNOWN_LOCATION);
3599
3600   /* Builtins in the implementation namespace are made visible without
3601      needing to be explicitly declared.  See push_file_scope.  */
3602   if (name[0] == '_' && (name[1] == '_' || ISUPPER (name[1])))
3603     {
3604       DECL_CHAIN (decl) = visible_builtins;
3605       visible_builtins = decl;
3606     }
3607
3608   return decl;
3609 }
3610
3611 tree
3612 c_builtin_function_ext_scope (tree decl)
3613 {
3614   tree type = TREE_TYPE (decl);
3615   tree   id = DECL_NAME (decl);
3616
3617   const char *name = IDENTIFIER_POINTER (id);
3618   C_DECL_BUILTIN_PROTOTYPE (decl) = prototype_p (type);
3619
3620   /* Should never be called on a symbol with a preexisting meaning.  */
3621   gcc_assert (!I_SYMBOL_BINDING (id));
3622
3623   bind (id, decl, external_scope, /*invisible=*/false, /*nested=*/false,
3624         UNKNOWN_LOCATION);
3625
3626   /* Builtins in the implementation namespace are made visible without
3627      needing to be explicitly declared.  See push_file_scope.  */
3628   if (name[0] == '_' && (name[1] == '_' || ISUPPER (name[1])))
3629     {
3630       DECL_CHAIN (decl) = visible_builtins;
3631       visible_builtins = decl;
3632     }
3633
3634   return decl;
3635 }
3636 \f
3637 /* Called when a declaration is seen that contains no names to declare.
3638    If its type is a reference to a structure, union or enum inherited
3639    from a containing scope, shadow that tag name for the current scope
3640    with a forward reference.
3641    If its type defines a new named structure or union
3642    or defines an enum, it is valid but we need not do anything here.
3643    Otherwise, it is an error.  */
3644
3645 void
3646 shadow_tag (const struct c_declspecs *declspecs)
3647 {
3648   shadow_tag_warned (declspecs, 0);
3649 }
3650
3651 /* WARNED is 1 if we have done a pedwarn, 2 if we have done a warning,
3652    but no pedwarn.  */
3653 void
3654 shadow_tag_warned (const struct c_declspecs *declspecs, int warned)
3655 {
3656   bool found_tag = false;
3657
3658   if (declspecs->type && !declspecs->default_int_p && !declspecs->typedef_p)
3659     {
3660       tree value = declspecs->type;
3661       enum tree_code code = TREE_CODE (value);
3662
3663       if (code == RECORD_TYPE || code == UNION_TYPE || code == ENUMERAL_TYPE)
3664         /* Used to test also that TYPE_SIZE (value) != 0.
3665            That caused warning for `struct foo;' at top level in the file.  */
3666         {
3667           tree name = TYPE_NAME (value);
3668           tree t;
3669
3670           found_tag = true;
3671
3672           if (declspecs->restrict_p)
3673             {
3674               error ("invalid use of %<restrict%>");
3675               warned = 1;
3676             }
3677
3678           if (name == 0)
3679             {
3680               if (warned != 1 && code != ENUMERAL_TYPE)
3681                 /* Empty unnamed enum OK */
3682                 {
3683                   pedwarn (input_location, 0,
3684                            "unnamed struct/union that defines no instances");
3685                   warned = 1;
3686                 }
3687             }
3688           else if (declspecs->typespec_kind != ctsk_tagdef
3689                    && declspecs->typespec_kind != ctsk_tagfirstref
3690                    && declspecs->storage_class != csc_none)
3691             {
3692               if (warned != 1)
3693                 pedwarn (input_location, 0,
3694                          "empty declaration with storage class specifier "
3695                          "does not redeclare tag");
3696               warned = 1;
3697               pending_xref_error ();
3698             }
3699           else if (declspecs->typespec_kind != ctsk_tagdef
3700                    && declspecs->typespec_kind != ctsk_tagfirstref
3701                    && (declspecs->const_p
3702                        || declspecs->volatile_p
3703                        || declspecs->restrict_p
3704                        || declspecs->address_space))
3705             {
3706               if (warned != 1)
3707                 pedwarn (input_location, 0,
3708                          "empty declaration with type qualifier "
3709                           "does not redeclare tag");
3710               warned = 1;
3711               pending_xref_error ();
3712             }
3713           else if (declspecs->typespec_kind != ctsk_tagdef
3714                    && declspecs->typespec_kind != ctsk_tagfirstref
3715                    && declspecs->alignas_p)
3716             {
3717               if (warned != 1)
3718                 pedwarn (input_location, 0,
3719                          "empty declaration with %<_Alignas%> "
3720                           "does not redeclare tag");
3721               warned = 1;
3722               pending_xref_error ();
3723             }
3724           else
3725             {
3726               pending_invalid_xref = 0;
3727               t = lookup_tag (code, name, 1, NULL);
3728
3729               if (t == 0)
3730                 {
3731                   t = make_node (code);
3732                   pushtag (input_location, name, t);
3733                 }
3734             }
3735         }
3736       else
3737         {
3738           if (warned != 1 && !in_system_header)
3739             {
3740               pedwarn (input_location, 0,
3741                        "useless type name in empty declaration");
3742               warned = 1;
3743             }
3744         }
3745     }
3746   else if (warned != 1 && !in_system_header && declspecs->typedef_p)
3747     {
3748       pedwarn (input_location, 0, "useless type name in empty declaration");
3749       warned = 1;
3750     }
3751
3752   pending_invalid_xref = 0;
3753
3754   if (declspecs->inline_p)
3755     {
3756       error ("%<inline%> in empty declaration");
3757       warned = 1;
3758     }
3759
3760   if (declspecs->noreturn_p)
3761     {
3762       error ("%<_Noreturn%> in empty declaration");
3763       warned = 1;
3764     }
3765
3766   if (current_scope == file_scope && declspecs->storage_class == csc_auto)
3767     {
3768       error ("%<auto%> in file-scope empty declaration");
3769       warned = 1;
3770     }
3771
3772   if (current_scope == file_scope && declspecs->storage_class == csc_register)
3773     {
3774       error ("%<register%> in file-scope empty declaration");
3775       warned = 1;
3776     }
3777
3778   if (!warned && !in_system_header && declspecs->storage_class != csc_none)
3779     {
3780       warning (0, "useless storage class specifier in empty declaration");
3781       warned = 2;
3782     }
3783
3784   if (!warned && !in_system_header && declspecs->thread_p)
3785     {
3786       warning (0, "useless %<__thread%> in empty declaration");
3787       warned = 2;
3788     }
3789
3790   if (!warned && !in_system_header && (declspecs->const_p
3791                                        || declspecs->volatile_p
3792                                        || declspecs->restrict_p
3793                                        || declspecs->address_space))
3794     {
3795       warning (0, "useless type qualifier in empty declaration");
3796       warned = 2;
3797     }
3798
3799   if (!warned && !in_system_header && declspecs->alignas_p)
3800     {
3801       warning (0, "useless %<_Alignas%> in empty declaration");
3802       warned = 2;
3803     }
3804
3805   if (warned != 1)
3806     {
3807       if (!found_tag)
3808         pedwarn (input_location, 0, "empty declaration");
3809     }
3810 }
3811 \f
3812
3813 /* Return the qualifiers from SPECS as a bitwise OR of TYPE_QUAL_*
3814    bits.  SPECS represents declaration specifiers that the grammar
3815    only permits to contain type qualifiers and attributes.  */
3816
3817 int
3818 quals_from_declspecs (const struct c_declspecs *specs)
3819 {
3820   int quals = ((specs->const_p ? TYPE_QUAL_CONST : 0)
3821                | (specs->volatile_p ? TYPE_QUAL_VOLATILE : 0)
3822                | (specs->restrict_p ? TYPE_QUAL_RESTRICT : 0)
3823                | (ENCODE_QUAL_ADDR_SPACE (specs->address_space)));
3824   gcc_assert (!specs->type
3825               && !specs->decl_attr
3826               && specs->typespec_word == cts_none
3827               && specs->storage_class == csc_none
3828               && !specs->typedef_p
3829               && !specs->explicit_signed_p
3830               && !specs->deprecated_p
3831               && !specs->long_p
3832               && !specs->long_long_p
3833               && !specs->short_p
3834               && !specs->signed_p
3835               && !specs->unsigned_p
3836               && !specs->complex_p
3837               && !specs->inline_p
3838               && !specs->noreturn_p
3839               && !specs->thread_p);
3840   return quals;
3841 }
3842
3843 /* Construct an array declarator.  LOC is the location of the
3844    beginning of the array (usually the opening brace).  EXPR is the
3845    expression inside [], or NULL_TREE.  QUALS are the type qualifiers
3846    inside the [] (to be applied to the pointer to which a parameter
3847    array is converted).  STATIC_P is true if "static" is inside the
3848    [], false otherwise.  VLA_UNSPEC_P is true if the array is [*], a
3849    VLA of unspecified length which is nevertheless a complete type,
3850    false otherwise.  The field for the contained declarator is left to
3851    be filled in by set_array_declarator_inner.  */
3852
3853 struct c_declarator *
3854 build_array_declarator (location_t loc,
3855                         tree expr, struct c_declspecs *quals, bool static_p,
3856                         bool vla_unspec_p)
3857 {
3858   struct c_declarator *declarator = XOBNEW (&parser_obstack,
3859                                             struct c_declarator);
3860   declarator->id_loc = loc;
3861   declarator->kind = cdk_array;
3862   declarator->declarator = 0;
3863   declarator->u.array.dimen = expr;
3864   if (quals)
3865     {
3866       declarator->u.array.attrs = quals->attrs;
3867       declarator->u.array.quals = quals_from_declspecs (quals);
3868     }
3869   else
3870     {
3871       declarator->u.array.attrs = NULL_TREE;
3872       declarator->u.array.quals = 0;
3873     }
3874   declarator->u.array.static_p = static_p;
3875   declarator->u.array.vla_unspec_p = vla_unspec_p;
3876   if (!flag_isoc99)
3877     {
3878       if (static_p || quals != NULL)
3879         pedwarn (loc, OPT_pedantic,
3880                  "ISO C90 does not support %<static%> or type "
3881                  "qualifiers in parameter array declarators");
3882       if (vla_unspec_p)
3883         pedwarn (loc, OPT_pedantic,
3884                  "ISO C90 does not support %<[*]%> array declarators");
3885     }
3886   if (vla_unspec_p)
3887     {
3888       if (!current_scope->parm_flag)
3889         {
3890           /* C99 6.7.5.2p4 */
3891           error_at (loc, "%<[*]%> not allowed in other than "
3892                     "function prototype scope");
3893           declarator->u.array.vla_unspec_p = false;
3894           return NULL;
3895         }
3896       current_scope->had_vla_unspec = true;
3897     }
3898   return declarator;
3899 }
3900
3901 /* Set the contained declarator of an array declarator.  DECL is the
3902    declarator, as constructed by build_array_declarator; INNER is what
3903    appears on the left of the [].  */
3904
3905 struct c_declarator *
3906 set_array_declarator_inner (struct c_declarator *decl,
3907                             struct c_declarator *inner)
3908 {
3909   decl->declarator = inner;
3910   return decl;
3911 }
3912
3913 /* INIT is a constructor that forms DECL's initializer.  If the final
3914    element initializes a flexible array field, add the size of that
3915    initializer to DECL's size.  */
3916
3917 static void
3918 add_flexible_array_elts_to_size (tree decl, tree init)
3919 {
3920   tree elt, type;
3921
3922   if (VEC_empty (constructor_elt, CONSTRUCTOR_ELTS (init)))
3923     return;
3924
3925   elt = VEC_last (constructor_elt, CONSTRUCTOR_ELTS (init))->value;
3926   type = TREE_TYPE (elt);
3927   if (TREE_CODE (type) == ARRAY_TYPE
3928       && TYPE_SIZE (type) == NULL_TREE
3929       && TYPE_DOMAIN (type) != NULL_TREE
3930       && TYPE_MAX_VALUE (TYPE_DOMAIN (type)) == NULL_TREE)
3931     {
3932       complete_array_type (&type, elt, false);
3933       DECL_SIZE (decl)
3934         = size_binop (PLUS_EXPR, DECL_SIZE (decl), TYPE_SIZE (type));
3935       DECL_SIZE_UNIT (decl)
3936         = size_binop (PLUS_EXPR, DECL_SIZE_UNIT (decl), TYPE_SIZE_UNIT (type));
3937     }
3938 }
3939 \f
3940 /* Decode a "typename", such as "int **", returning a ..._TYPE node.
3941    Set *EXPR, if EXPR not NULL, to any expression to be evaluated
3942    before the type name, and set *EXPR_CONST_OPERANDS, if
3943    EXPR_CONST_OPERANDS not NULL, to indicate whether the type name may
3944    appear in a constant expression.  */
3945
3946 tree
3947 groktypename (struct c_type_name *type_name, tree *expr,
3948               bool *expr_const_operands)
3949 {
3950   tree type;
3951   tree attrs = type_name->specs->attrs;
3952
3953   type_name->specs->attrs = NULL_TREE;
3954
3955   type = grokdeclarator (type_name->declarator, type_name->specs, TYPENAME,
3956                          false, NULL, &attrs, expr, expr_const_operands,
3957                          DEPRECATED_NORMAL);
3958
3959   /* Apply attributes.  */
3960   decl_attributes (&type, attrs, 0);
3961
3962   return type;
3963 }
3964
3965 /* Decode a declarator in an ordinary declaration or data definition.
3966    This is called as soon as the type information and variable name
3967    have been parsed, before parsing the initializer if any.
3968    Here we create the ..._DECL node, fill in its type,
3969    and put it on the list of decls for the current context.
3970    The ..._DECL node is returned as the value.
3971
3972    Exception: for arrays where the length is not specified,
3973    the type is left null, to be filled in by `finish_decl'.
3974
3975    Function definitions do not come here; they go to start_function
3976    instead.  However, external and forward declarations of functions
3977    do go through here.  Structure field declarations are done by
3978    grokfield and not through here.  */
3979
3980 tree
3981 start_decl (struct c_declarator *declarator, struct c_declspecs *declspecs,
3982             bool initialized, tree attributes)
3983 {
3984   tree decl;
3985   tree tem;
3986   tree expr = NULL_TREE;
3987   enum deprecated_states deprecated_state = DEPRECATED_NORMAL;
3988
3989   /* An object declared as __attribute__((deprecated)) suppresses
3990      warnings of uses of other deprecated items.  */
3991   if (lookup_attribute ("deprecated", attributes))
3992     deprecated_state = DEPRECATED_SUPPRESS;
3993
3994   decl = grokdeclarator (declarator, declspecs,
3995                          NORMAL, initialized, NULL, &attributes, &expr, NULL,
3996                          deprecated_state);
3997   if (!decl)
3998     return 0;
3999
4000   if (expr)
4001     add_stmt (fold_convert (void_type_node, expr));
4002
4003   if (TREE_CODE (decl) != FUNCTION_DECL && MAIN_NAME_P (DECL_NAME (decl)))
4004     warning (OPT_Wmain, "%q+D is usually a function", decl);
4005
4006   if (initialized)
4007     /* Is it valid for this decl to have an initializer at all?
4008        If not, set INITIALIZED to zero, which will indirectly
4009        tell 'finish_decl' to ignore the initializer once it is parsed.  */
4010     switch (TREE_CODE (decl))
4011       {
4012       case TYPE_DECL:
4013         error ("typedef %qD is initialized (use __typeof__ instead)", decl);
4014         initialized = 0;
4015         break;
4016
4017       case FUNCTION_DECL:
4018         error ("function %qD is initialized like a variable", decl);
4019         initialized = 0;
4020         break;
4021
4022       case PARM_DECL:
4023         /* DECL_INITIAL in a PARM_DECL is really DECL_ARG_TYPE.  */
4024         error ("parameter %qD is initialized", decl);
4025         initialized = 0;
4026         break;
4027
4028       default:
4029         /* Don't allow initializations for incomplete types except for
4030            arrays which might be completed by the initialization.  */
4031
4032         /* This can happen if the array size is an undefined macro.
4033            We already gave a warning, so we don't need another one.  */
4034         if (TREE_TYPE (decl) == error_mark_node)
4035           initialized = 0;
4036         else if (COMPLETE_TYPE_P (TREE_TYPE (decl)))
4037           {
4038             /* A complete type is ok if size is fixed.  */
4039
4040             if (TREE_CODE (TYPE_SIZE (TREE_TYPE (decl))) != INTEGER_CST
4041                 || C_DECL_VARIABLE_SIZE (decl))
4042               {
4043                 error ("variable-sized object may not be initialized");
4044                 initialized = 0;
4045               }
4046           }
4047         else if (TREE_CODE (TREE_TYPE (decl)) != ARRAY_TYPE)
4048           {
4049             error ("variable %qD has initializer but incomplete type", decl);
4050             initialized = 0;
4051           }
4052         else if (C_DECL_VARIABLE_SIZE (decl))
4053           {
4054             /* Although C99 is unclear about whether incomplete arrays
4055                of VLAs themselves count as VLAs, it does not make
4056                sense to permit them to be initialized given that
4057                ordinary VLAs may not be initialized.  */
4058             error ("variable-sized object may not be initialized");
4059             initialized = 0;
4060           }
4061       }
4062
4063   if (initialized)
4064     {
4065       if (current_scope == file_scope)
4066         TREE_STATIC (decl) = 1;
4067
4068       /* Tell 'pushdecl' this is an initialized decl
4069          even though we don't yet have the initializer expression.
4070          Also tell 'finish_decl' it may store the real initializer.  */
4071       DECL_INITIAL (decl) = error_mark_node;
4072     }
4073
4074