OSDN Git Service

* c-tree.h, c-decl.c (build_enumerator): Add location parameter.
[pf3gnuchains/gcc-fork.git] / 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
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-pragma.h"
50 #include "c-lang.h"
51 #include "langhooks.h"
52 #include "tree-mudflap.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 /* Linked list of TRANSLATION_UNIT_DECLS for the translation units
122    included in this invocation.  Note that the current translation
123    unit is not included in this list.  */
124
125 static GTY(()) tree all_translation_units;
126
127 /* A list of decls to be made automatically visible in each file scope.  */
128 static GTY(()) tree visible_builtins;
129
130 /* Set to 0 at beginning of a function definition, set to 1 if
131    a return statement that specifies a return value is seen.  */
132
133 int current_function_returns_value;
134
135 /* Set to 0 at beginning of a function definition, set to 1 if
136    a return statement with no argument is seen.  */
137
138 int current_function_returns_null;
139
140 /* Set to 0 at beginning of a function definition, set to 1 if
141    a call to a noreturn function is seen.  */
142
143 int current_function_returns_abnormally;
144
145 /* Set to nonzero by `grokdeclarator' for a function
146    whose return type is defaulted, if warnings for this are desired.  */
147
148 static int warn_about_return_type;
149
150 /* Nonzero when the current toplevel function contains a declaration
151    of a nested function which is never defined.  */
152
153 static bool undef_nested_function;
154
155 /* True means global_bindings_p should return false even if the scope stack
156    says we are in file scope.  */
157 bool c_override_global_bindings_to_false;
158
159 \f
160 /* Each c_binding structure describes one binding of an identifier to
161    a decl.  All the decls in a scope - irrespective of namespace - are
162    chained together by the ->prev field, which (as the name implies)
163    runs in reverse order.  All the decls in a given namespace bound to
164    a given identifier are chained by the ->shadowed field, which runs
165    from inner to outer scopes.
166
167    The ->decl field usually points to a DECL node, but there are two
168    exceptions.  In the namespace of type tags, the bound entity is a
169    RECORD_TYPE, UNION_TYPE, or ENUMERAL_TYPE node.  If an undeclared
170    identifier is encountered, it is bound to error_mark_node to
171    suppress further errors about that identifier in the current
172    function.
173
174    The ->u.type field stores the type of the declaration in this scope;
175    if NULL, the type is the type of the ->decl field.  This is only of
176    relevance for objects with external or internal linkage which may
177    be redeclared in inner scopes, forming composite types that only
178    persist for the duration of those scopes.  In the external scope,
179    this stores the composite of all the types declared for this
180    object, visible or not.  The ->inner_comp field (used only at file
181    scope) stores whether an incomplete array type at file scope was
182    completed at an inner scope to an array size other than 1.
183
184    The ->u.label field is used for labels.  It points to a structure
185    which stores additional information used for warnings.
186
187    The depth field is copied from the scope structure that holds this
188    decl.  It is used to preserve the proper ordering of the ->shadowed
189    field (see bind()) and also for a handful of special-case checks.
190    Finally, the invisible bit is true for a decl which should be
191    ignored for purposes of normal name lookup, and the nested bit is
192    true for a decl that's been bound a second time in an inner scope;
193    in all such cases, the binding in the outer scope will have its
194    invisible bit true.  */
195
196 struct GTY((chain_next ("%h.prev"))) c_binding {
197   union GTY(()) {               /* first so GTY desc can use decl */
198     tree GTY((tag ("0"))) type; /* the type in this scope */
199     struct c_label_vars * GTY((tag ("1"))) label; /* for warnings */
200   } GTY((desc ("TREE_CODE (%0.decl) == LABEL_DECL"))) u;
201   tree decl;                    /* the decl bound */
202   tree id;                      /* the identifier it's bound to */
203   struct c_binding *prev;       /* the previous decl in this scope */
204   struct c_binding *shadowed;   /* the innermost decl shadowed by this one */
205   unsigned int depth : 28;      /* depth of this scope */
206   BOOL_BITFIELD invisible : 1;  /* normal lookup should ignore this binding */
207   BOOL_BITFIELD nested : 1;     /* do not set DECL_CONTEXT when popping */
208   BOOL_BITFIELD inner_comp : 1; /* incomplete array completed in inner scope */
209   BOOL_BITFIELD in_struct : 1;  /* currently defined as struct field */
210   location_t locus;             /* location for nested bindings */
211 };
212 #define B_IN_SCOPE(b1, b2) ((b1)->depth == (b2)->depth)
213 #define B_IN_CURRENT_SCOPE(b) ((b)->depth == current_scope->depth)
214 #define B_IN_FILE_SCOPE(b) ((b)->depth == 1 /*file_scope->depth*/)
215 #define B_IN_EXTERNAL_SCOPE(b) ((b)->depth == 0 /*external_scope->depth*/)
216
217 #define I_SYMBOL_BINDING(node) \
218   (((struct lang_identifier *) IDENTIFIER_NODE_CHECK(node))->symbol_binding)
219 #define I_SYMBOL_DECL(node) \
220  (I_SYMBOL_BINDING(node) ? I_SYMBOL_BINDING(node)->decl : 0)
221
222 #define I_TAG_BINDING(node) \
223   (((struct lang_identifier *) IDENTIFIER_NODE_CHECK(node))->tag_binding)
224 #define I_TAG_DECL(node) \
225  (I_TAG_BINDING(node) ? I_TAG_BINDING(node)->decl : 0)
226
227 #define I_LABEL_BINDING(node) \
228   (((struct lang_identifier *) IDENTIFIER_NODE_CHECK(node))->label_binding)
229 #define I_LABEL_DECL(node) \
230  (I_LABEL_BINDING(node) ? I_LABEL_BINDING(node)->decl : 0)
231
232 /* Each C symbol points to three linked lists of c_binding structures.
233    These describe the values of the identifier in the three different
234    namespaces defined by the language.  */
235
236 struct GTY(()) lang_identifier {
237   struct c_common_identifier common_id;
238   struct c_binding *symbol_binding; /* vars, funcs, constants, typedefs */
239   struct c_binding *tag_binding;    /* struct/union/enum tags */
240   struct c_binding *label_binding;  /* labels */
241 };
242
243 /* Validate c-lang.c's assumptions.  */
244 extern char C_SIZEOF_STRUCT_LANG_IDENTIFIER_isnt_accurate
245 [(sizeof(struct lang_identifier) == C_SIZEOF_STRUCT_LANG_IDENTIFIER) ? 1 : -1];
246
247 /* The resulting tree type.  */
248
249 union GTY((desc ("TREE_CODE (&%h.generic) == IDENTIFIER_NODE"),
250        chain_next ("TREE_CODE (&%h.generic) == INTEGER_TYPE ? (union lang_tree_node *) TYPE_NEXT_VARIANT (&%h.generic) : ((union lang_tree_node *) TREE_CHAIN (&%h.generic))")))  lang_tree_node
251  {
252   union tree_node GTY ((tag ("0"),
253                         desc ("tree_node_structure (&%h)")))
254     generic;
255   struct lang_identifier GTY ((tag ("1"))) identifier;
256 };
257
258 /* Track bindings and other things that matter for goto warnings.  For
259    efficiency, we do not gather all the decls at the point of
260    definition.  Instead, we point into the bindings structure.  As
261    scopes are popped, we update these structures and gather the decls
262    that matter at that time.  */
263
264 struct GTY(()) c_spot_bindings {
265   /* The currently open scope which holds bindings defined when the
266      label was defined or the goto statement was found.  */
267   struct c_scope *scope;
268   /* The bindings in the scope field which were defined at the point
269      of the label or goto.  This lets us look at older or newer
270      bindings in the scope, as appropriate.  */
271   struct c_binding *bindings_in_scope;
272   /* The number of statement expressions that have started since this
273      label or goto statement was defined.  This is zero if we are at
274      the same statement expression level.  It is positive if we are in
275      a statement expression started since this spot.  It is negative
276      if this spot was in a statement expression and we have left
277      it.  */
278   int stmt_exprs;
279   /* Whether we started in a statement expression but are no longer in
280      it.  This is set to true if stmt_exprs ever goes negative.  */
281   bool left_stmt_expr;
282 };
283
284 /* This structure is used to keep track of bindings seen when a goto
285    statement is defined.  This is only used if we see the goto
286    statement before we see the label.  */
287
288 struct GTY(()) c_goto_bindings {
289   /* The location of the goto statement.  */
290   location_t loc;
291   /* The bindings of the goto statement.  */
292   struct c_spot_bindings goto_bindings;
293 };
294
295 typedef struct c_goto_bindings *c_goto_bindings_p;
296 DEF_VEC_P(c_goto_bindings_p);
297 DEF_VEC_ALLOC_P(c_goto_bindings_p,gc);
298
299 /* The additional information we keep track of for a label binding.
300    These fields are updated as scopes are popped.  */
301
302 struct GTY(()) c_label_vars {
303   /* The shadowed c_label_vars, when one label shadows another (which
304      can only happen using a __label__ declaration).  */
305   struct c_label_vars *shadowed;
306   /* The bindings when the label was defined.  */
307   struct c_spot_bindings label_bindings;
308   /* A list of decls that we care about: decls about which we should
309      warn if a goto branches to this label from later in the function.
310      Decls are added to this list as scopes are popped.  We only add
311      the decls that matter.  */
312   VEC(tree,gc) *decls_in_scope;
313   /* A list of goto statements to this label.  This is only used for
314      goto statements seen before the label was defined, so that we can
315      issue appropriate warnings for them.  */
316   VEC(c_goto_bindings_p,gc) *gotos;
317 };
318
319 /* Each c_scope structure describes the complete contents of one
320    scope.  Four scopes are distinguished specially: the innermost or
321    current scope, the innermost function scope, the file scope (always
322    the second to outermost) and the outermost or external scope.
323
324    Most declarations are recorded in the current scope.
325
326    All normal label declarations are recorded in the innermost
327    function scope, as are bindings of undeclared identifiers to
328    error_mark_node.  (GCC permits nested functions as an extension,
329    hence the 'innermost' qualifier.)  Explicitly declared labels
330    (using the __label__ extension) appear in the current scope.
331
332    Being in the file scope (current_scope == file_scope) causes
333    special behavior in several places below.  Also, under some
334    conditions the Objective-C front end records declarations in the
335    file scope even though that isn't the current scope.
336
337    All declarations with external linkage are recorded in the external
338    scope, even if they aren't visible there; this models the fact that
339    such declarations are visible to the entire program, and (with a
340    bit of cleverness, see pushdecl) allows diagnosis of some violations
341    of C99 6.2.2p7 and 6.2.7p2:
342
343      If, within the same translation unit, the same identifier appears
344      with both internal and external linkage, the behavior is
345      undefined.
346
347      All declarations that refer to the same object or function shall
348      have compatible type; otherwise, the behavior is undefined.
349
350    Initially only the built-in declarations, which describe compiler
351    intrinsic functions plus a subset of the standard library, are in
352    this scope.
353
354    The order of the blocks list matters, and it is frequently appended
355    to.  To avoid having to walk all the way to the end of the list on
356    each insertion, or reverse the list later, we maintain a pointer to
357    the last list entry.  (FIXME: It should be feasible to use a reversed
358    list here.)
359
360    The bindings list is strictly in reverse order of declarations;
361    pop_scope relies on this.  */
362
363
364 struct GTY((chain_next ("%h.outer"))) c_scope {
365   /* The scope containing this one.  */
366   struct c_scope *outer;
367
368   /* The next outermost function scope.  */
369   struct c_scope *outer_function;
370
371   /* All bindings in this scope.  */
372   struct c_binding *bindings;
373
374   /* For each scope (except the global one), a chain of BLOCK nodes
375      for all the scopes that were entered and exited one level down.  */
376   tree blocks;
377   tree blocks_last;
378
379   /* The depth of this scope.  Used to keep the ->shadowed chain of
380      bindings sorted innermost to outermost.  */
381   unsigned int depth : 28;
382
383   /* True if we are currently filling this scope with parameter
384      declarations.  */
385   BOOL_BITFIELD parm_flag : 1;
386
387   /* True if we saw [*] in this scope.  Used to give an error messages
388      if these appears in a function definition.  */
389   BOOL_BITFIELD had_vla_unspec : 1;
390
391   /* True if we already complained about forward parameter decls
392      in this scope.  This prevents double warnings on
393      foo (int a; int b; ...)  */
394   BOOL_BITFIELD warned_forward_parm_decls : 1;
395
396   /* True if this is the outermost block scope of a function body.
397      This scope contains the parameters, the local variables declared
398      in the outermost block, and all the labels (except those in
399      nested functions, or declared at block scope with __label__).  */
400   BOOL_BITFIELD function_body : 1;
401
402   /* True means make a BLOCK for this scope no matter what.  */
403   BOOL_BITFIELD keep : 1;
404
405   /* True means that an unsuffixed float constant is _Decimal64.  */
406   BOOL_BITFIELD float_const_decimal64 : 1;
407
408   /* True if this scope has any label bindings.  This is used to speed
409      up searching for labels when popping scopes, particularly since
410      labels are normally only found at function scope.  */
411   BOOL_BITFIELD has_label_bindings : 1;
412 };
413
414 /* The scope currently in effect.  */
415
416 static GTY(()) struct c_scope *current_scope;
417
418 /* The innermost function scope.  Ordinary (not explicitly declared)
419    labels, bindings to error_mark_node, and the lazily-created
420    bindings of __func__ and its friends get this scope.  */
421
422 static GTY(()) struct c_scope *current_function_scope;
423
424 /* The C file scope.  This is reset for each input translation unit.  */
425
426 static GTY(()) struct c_scope *file_scope;
427
428 /* The outermost scope.  This is used for all declarations with
429    external linkage, and only these, hence the name.  */
430
431 static GTY(()) struct c_scope *external_scope;
432
433 /* A chain of c_scope structures awaiting reuse.  */
434
435 static GTY((deletable)) struct c_scope *scope_freelist;
436
437 /* A chain of c_binding structures awaiting reuse.  */
438
439 static GTY((deletable)) struct c_binding *binding_freelist;
440
441 /* Append VAR to LIST in scope SCOPE.  */
442 #define SCOPE_LIST_APPEND(scope, list, decl) do {       \
443   struct c_scope *s_ = (scope);                         \
444   tree d_ = (decl);                                     \
445   if (s_->list##_last)                                  \
446     BLOCK_CHAIN (s_->list##_last) = d_;                 \
447   else                                                  \
448     s_->list = d_;                                      \
449   s_->list##_last = d_;                                 \
450 } while (0)
451
452 /* Concatenate FROM in scope FSCOPE onto TO in scope TSCOPE.  */
453 #define SCOPE_LIST_CONCAT(tscope, to, fscope, from) do {        \
454   struct c_scope *t_ = (tscope);                                \
455   struct c_scope *f_ = (fscope);                                \
456   if (t_->to##_last)                                            \
457     BLOCK_CHAIN (t_->to##_last) = f_->from;                     \
458   else                                                          \
459     t_->to = f_->from;                                          \
460   t_->to##_last = f_->from##_last;                              \
461 } while (0)
462
463 /* A c_inline_static structure stores details of a static identifier
464    referenced in a definition of a function that may be an inline
465    definition if no subsequent declaration of that function uses
466    "extern" or does not use "inline".  */
467
468 struct GTY((chain_next ("%h.next"))) c_inline_static {
469   /* The location for a diagnostic.  */
470   location_t location;
471
472   /* The function that may be an inline definition.  */
473   tree function;
474
475   /* The object or function referenced.  */
476   tree static_decl;
477
478   /* What sort of reference this is.  */
479   enum c_inline_static_type type;
480
481   /* The next such structure or NULL.  */
482   struct c_inline_static *next;
483 };
484
485 /* List of static identifiers used or referenced in functions that may
486    be inline definitions.  */
487 static GTY(()) struct c_inline_static *c_inline_statics;
488
489 /* True means unconditionally make a BLOCK for the next scope pushed.  */
490
491 static bool keep_next_level_flag;
492
493 /* True means the next call to push_scope will be the outermost scope
494    of a function body, so do not push a new scope, merely cease
495    expecting parameter decls.  */
496
497 static bool next_is_function_body;
498
499 /* A VEC of pointers to c_binding structures.  */
500
501 typedef struct c_binding *c_binding_ptr;
502 DEF_VEC_P(c_binding_ptr);
503 DEF_VEC_ALLOC_P(c_binding_ptr,heap);
504
505 /* Information that we keep for a struct or union while it is being
506    parsed.  */
507
508 struct c_struct_parse_info
509 {
510   /* If warn_cxx_compat, a list of types defined within this
511      struct.  */
512   VEC(tree,heap) *struct_types;
513   /* If warn_cxx_compat, a list of field names which have bindings,
514      and which are defined in this struct, but which are not defined
515      in any enclosing struct.  This is used to clear the in_struct
516      field of the c_bindings structure.  */
517   VEC(c_binding_ptr,heap) *fields;
518   /* If warn_cxx_compat, a list of typedef names used when defining
519      fields in this struct.  */
520   VEC(tree,heap) *typedefs_seen;
521 };
522
523 /* Information for the struct or union currently being parsed, or
524    NULL if not parsing a struct or union.  */
525 static struct c_struct_parse_info *struct_parse_info;
526
527 /* Forward declarations.  */
528 static tree lookup_name_in_scope (tree, struct c_scope *);
529 static tree c_make_fname_decl (location_t, tree, int);
530 static tree grokdeclarator (const struct c_declarator *,
531                             struct c_declspecs *,
532                             enum decl_context, bool, tree *, tree *, tree *,
533                             bool *, enum deprecated_states);
534 static tree grokparms (struct c_arg_info *, bool);
535 static void layout_array_type (tree);
536 \f
537 /* T is a statement.  Add it to the statement-tree.  This is the
538    C/ObjC version--C++ has a slightly different version of this
539    function.  */
540
541 tree
542 add_stmt (tree t)
543 {
544   enum tree_code code = TREE_CODE (t);
545
546   if (CAN_HAVE_LOCATION_P (t) && code != LABEL_EXPR)
547     {
548       if (!EXPR_HAS_LOCATION (t))
549         SET_EXPR_LOCATION (t, input_location);
550     }
551
552   if (code == LABEL_EXPR || code == CASE_LABEL_EXPR)
553     STATEMENT_LIST_HAS_LABEL (cur_stmt_list) = 1;
554
555   /* Add T to the statement-tree.  Non-side-effect statements need to be
556      recorded during statement expressions.  */
557   append_to_statement_list_force (t, &cur_stmt_list);
558
559   return t;
560 }
561 \f
562
563 void
564 c_print_identifier (FILE *file, tree node, int indent)
565 {
566   print_node (file, "symbol", I_SYMBOL_DECL (node), indent + 4);
567   print_node (file, "tag", I_TAG_DECL (node), indent + 4);
568   print_node (file, "label", I_LABEL_DECL (node), indent + 4);
569   if (C_IS_RESERVED_WORD (node) && C_RID_CODE (node) != RID_CXX_COMPAT_WARN)
570     {
571       tree rid = ridpointers[C_RID_CODE (node)];
572       indent_to (file, indent + 4);
573       fprintf (file, "rid " HOST_PTR_PRINTF " \"%s\"",
574                (void *) rid, IDENTIFIER_POINTER (rid));
575     }
576 }
577
578 /* Establish a binding between NAME, an IDENTIFIER_NODE, and DECL,
579    which may be any of several kinds of DECL or TYPE or error_mark_node,
580    in the scope SCOPE.  */
581 static void
582 bind (tree name, tree decl, struct c_scope *scope, bool invisible,
583       bool nested, location_t locus)
584 {
585   struct c_binding *b, **here;
586
587   if (binding_freelist)
588     {
589       b = binding_freelist;
590       binding_freelist = b->prev;
591     }
592   else
593     b = ggc_alloc_c_binding ();
594
595   b->shadowed = 0;
596   b->decl = decl;
597   b->id = name;
598   b->depth = scope->depth;
599   b->invisible = invisible;
600   b->nested = nested;
601   b->inner_comp = 0;
602   b->in_struct = 0;
603   b->locus = locus;
604
605   b->u.type = NULL;
606
607   b->prev = scope->bindings;
608   scope->bindings = b;
609
610   if (!name)
611     return;
612
613   switch (TREE_CODE (decl))
614     {
615     case LABEL_DECL:     here = &I_LABEL_BINDING (name);   break;
616     case ENUMERAL_TYPE:
617     case UNION_TYPE:
618     case RECORD_TYPE:    here = &I_TAG_BINDING (name);     break;
619     case VAR_DECL:
620     case FUNCTION_DECL:
621     case TYPE_DECL:
622     case CONST_DECL:
623     case PARM_DECL:
624     case ERROR_MARK:     here = &I_SYMBOL_BINDING (name);  break;
625
626     default:
627       gcc_unreachable ();
628     }
629
630   /* Locate the appropriate place in the chain of shadowed decls
631      to insert this binding.  Normally, scope == current_scope and
632      this does nothing.  */
633   while (*here && (*here)->depth > scope->depth)
634     here = &(*here)->shadowed;
635
636   b->shadowed = *here;
637   *here = b;
638 }
639
640 /* Clear the binding structure B, stick it on the binding_freelist,
641    and return the former value of b->prev.  This is used by pop_scope
642    and get_parm_info to iterate destructively over all the bindings
643    from a given scope.  */
644 static struct c_binding *
645 free_binding_and_advance (struct c_binding *b)
646 {
647   struct c_binding *prev = b->prev;
648
649   memset (b, 0, sizeof (struct c_binding));
650   b->prev = binding_freelist;
651   binding_freelist = b;
652
653   return prev;
654 }
655
656 /* Bind a label.  Like bind, but skip fields which aren't used for
657    labels, and add the LABEL_VARS value.  */
658 static void
659 bind_label (tree name, tree label, struct c_scope *scope,
660             struct c_label_vars *label_vars)
661 {
662   struct c_binding *b;
663
664   bind (name, label, scope, /*invisible=*/false, /*nested=*/false,
665         UNKNOWN_LOCATION);
666
667   scope->has_label_bindings = true;
668
669   b = scope->bindings;
670   gcc_assert (b->decl == label);
671   label_vars->shadowed = b->u.label;
672   b->u.label = label_vars;
673 }
674 \f
675 /* Hook called at end of compilation to assume 1 elt
676    for a file-scope tentative array defn that wasn't complete before.  */
677
678 void
679 c_finish_incomplete_decl (tree decl)
680 {
681   if (TREE_CODE (decl) == VAR_DECL)
682     {
683       tree type = TREE_TYPE (decl);
684       if (type != error_mark_node
685           && TREE_CODE (type) == ARRAY_TYPE
686           && !DECL_EXTERNAL (decl)
687           && TYPE_DOMAIN (type) == 0)
688         {
689           warning_at (DECL_SOURCE_LOCATION (decl),
690                       0, "array %q+D assumed to have one element", decl);
691
692           complete_array_type (&TREE_TYPE (decl), NULL_TREE, true);
693
694           layout_decl (decl, 0);
695         }
696     }
697 }
698 \f
699 /* Record that inline function FUNC contains a reference (location
700    LOC) to static DECL (file-scope or function-local according to
701    TYPE).  */
702
703 void
704 record_inline_static (location_t loc, tree func, tree decl,
705                       enum c_inline_static_type type)
706 {
707   struct c_inline_static *csi = ggc_alloc_c_inline_static ();
708   csi->location = loc;
709   csi->function = func;
710   csi->static_decl = decl;
711   csi->type = type;
712   csi->next = c_inline_statics;
713   c_inline_statics = csi;
714 }
715
716 /* Check for references to static declarations in inline functions at
717    the end of the translation unit and diagnose them if the functions
718    are still inline definitions.  */
719
720 static void
721 check_inline_statics (void)
722 {
723   struct c_inline_static *csi;
724   for (csi = c_inline_statics; csi; csi = csi->next)
725     {
726       if (DECL_EXTERNAL (csi->function))
727         switch (csi->type)
728           {
729           case csi_internal:
730             pedwarn (csi->location, 0,
731                      "%qD is static but used in inline function %qD "
732                      "which is not static", csi->static_decl, csi->function);
733             break;
734           case csi_modifiable:
735             pedwarn (csi->location, 0,
736                      "%q+D is static but declared in inline function %qD "
737                      "which is not static", csi->static_decl, csi->function);
738             break;
739           default:
740             gcc_unreachable ();
741           }
742     }
743   c_inline_statics = NULL;
744 }
745 \f
746 /* Fill in a c_spot_bindings structure.  If DEFINING is true, set it
747    for the current state, otherwise set it to uninitialized.  */
748
749 static void
750 set_spot_bindings (struct c_spot_bindings *p, bool defining)
751 {
752   if (defining)
753     {
754       p->scope = current_scope;
755       p->bindings_in_scope = current_scope->bindings;
756     }
757   else
758     {
759       p->scope = NULL;
760       p->bindings_in_scope = NULL;
761     }
762   p->stmt_exprs = 0;
763   p->left_stmt_expr = false;
764 }
765
766 /* Return true if we will want to say something if a goto statement
767    crosses DECL.  */
768
769 static bool
770 decl_jump_unsafe (tree decl)
771 {
772   if (decl == error_mark_node || TREE_TYPE (decl) == error_mark_node)
773     return false;
774
775   /* Always warn about crossing variably modified types.  */
776   if ((TREE_CODE (decl) == VAR_DECL || TREE_CODE (decl) == TYPE_DECL)
777       && variably_modified_type_p (TREE_TYPE (decl), NULL_TREE))
778     return true;
779
780   /* Otherwise, only warn if -Wgoto-misses-init and this is an
781      initialized automatic decl.  */
782   if (warn_jump_misses_init
783       && TREE_CODE (decl) == VAR_DECL
784       && !TREE_STATIC (decl)
785       && DECL_INITIAL (decl) != NULL_TREE)
786     return true;
787
788   return false;
789 }
790
791 /* Update spot bindings P as we pop out of SCOPE.  Return true if we
792    should push decls for a label.  */
793
794 static bool
795 update_spot_bindings (struct c_scope *scope, struct c_spot_bindings *p)
796 {
797   if (p->scope != scope)
798     {
799       /* This label or goto is defined in some other scope, or it is a
800          label which is not yet defined.  There is nothing to
801          update.  */
802       return false;
803     }
804
805   /* Adjust the spot bindings to refer to the bindings already defined
806      in the enclosing scope.  */
807   p->scope = scope->outer;
808   p->bindings_in_scope = p->scope->bindings;
809
810   return true;
811 }
812 \f
813 /* The Objective-C front-end often needs to determine the current scope.  */
814
815 void *
816 objc_get_current_scope (void)
817 {
818   return current_scope;
819 }
820
821 /* The following function is used only by Objective-C.  It needs to live here
822    because it accesses the innards of c_scope.  */
823
824 void
825 objc_mark_locals_volatile (void *enclosing_blk)
826 {
827   struct c_scope *scope;
828   struct c_binding *b;
829
830   for (scope = current_scope;
831        scope && scope != enclosing_blk;
832        scope = scope->outer)
833     {
834       for (b = scope->bindings; b; b = b->prev)
835         objc_volatilize_decl (b->decl);
836
837       /* Do not climb up past the current function.  */
838       if (scope->function_body)
839         break;
840     }
841 }
842
843 /* Nonzero if we are currently in file scope.  */
844
845 int
846 global_bindings_p (void)
847 {
848   return (current_scope == file_scope && !c_override_global_bindings_to_false
849           ? -1
850           : 0);
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               unsigned int ix;
978               struct c_goto_bindings *g;
979
980               if (TREE_CODE (b->decl) != LABEL_DECL)
981                 continue;
982               label_vars = b->u.label;
983
984               b1 = label_vars->label_bindings.bindings_in_scope;
985               if (update_spot_bindings (scope, &label_vars->label_bindings))
986                 {
987                   /* This label is defined in this scope.  */
988                   for (; b1 != NULL;  b1 = b1->prev)
989                     {
990                       /* A goto from later in the function to this
991                          label will never see the initialization of
992                          B1, if any.  Save it to issue a warning if
993                          needed.  */
994                       if (decl_jump_unsafe (b1->decl))
995                         VEC_safe_push (tree, gc, label_vars->decls_in_scope,
996                                        b1->decl);
997                     }
998                 }
999
1000               /* Update the bindings of any goto statements associated
1001                  with this label.  */
1002               FOR_EACH_VEC_ELT (c_goto_bindings_p, label_vars->gotos, ix, g)
1003                 update_spot_bindings (scope, &g->goto_bindings);
1004             }
1005         }
1006
1007       /* Don't search beyond the current function.  */
1008       if (s == current_function_scope)
1009         break;
1010
1011       s = s->outer;
1012     }
1013 }
1014
1015 /* Set the TYPE_CONTEXT of all of TYPE's variants to CONTEXT.  */
1016
1017 static void
1018 set_type_context (tree type, tree context)
1019 {
1020   for (type = TYPE_MAIN_VARIANT (type); type;
1021        type = TYPE_NEXT_VARIANT (type))
1022     TYPE_CONTEXT (type) = context;
1023 }
1024
1025 /* Exit a scope.  Restore the state of the identifier-decl mappings
1026    that were in effect when this scope was entered.  Return a BLOCK
1027    node containing all the DECLs in this scope that are of interest
1028    to debug info generation.  */
1029
1030 tree
1031 pop_scope (void)
1032 {
1033   struct c_scope *scope = current_scope;
1034   tree block, context, p;
1035   struct c_binding *b;
1036
1037   bool functionbody = scope->function_body;
1038   bool keep = functionbody || scope->keep || scope->bindings;
1039
1040   update_label_decls (scope);
1041
1042   /* If appropriate, create a BLOCK to record the decls for the life
1043      of this function.  */
1044   block = 0;
1045   if (keep)
1046     {
1047       block = make_node (BLOCK);
1048       BLOCK_SUBBLOCKS (block) = scope->blocks;
1049       TREE_USED (block) = 1;
1050
1051       /* In each subblock, record that this is its superior.  */
1052       for (p = scope->blocks; p; p = BLOCK_CHAIN (p))
1053         BLOCK_SUPERCONTEXT (p) = block;
1054
1055       BLOCK_VARS (block) = 0;
1056     }
1057
1058   /* The TYPE_CONTEXTs for all of the tagged types belonging to this
1059      scope must be set so that they point to the appropriate
1060      construct, i.e.  either to the current FUNCTION_DECL node, or
1061      else to the BLOCK node we just constructed.
1062
1063      Note that for tagged types whose scope is just the formal
1064      parameter list for some function type specification, we can't
1065      properly set their TYPE_CONTEXTs here, because we don't have a
1066      pointer to the appropriate FUNCTION_TYPE node readily available
1067      to us.  For those cases, the TYPE_CONTEXTs of the relevant tagged
1068      type nodes get set in `grokdeclarator' as soon as we have created
1069      the FUNCTION_TYPE node which will represent the "scope" for these
1070      "parameter list local" tagged types.  */
1071   if (scope->function_body)
1072     context = current_function_decl;
1073   else if (scope == file_scope)
1074     {
1075       tree file_decl = build_decl (UNKNOWN_LOCATION,
1076                                    TRANSLATION_UNIT_DECL, 0, 0);
1077       DECL_CHAIN (file_decl) = all_translation_units;
1078       all_translation_units = file_decl;
1079       context = file_decl;
1080     }
1081   else
1082     context = block;
1083
1084   /* Clear all bindings in this scope.  */
1085   for (b = scope->bindings; b; b = free_binding_and_advance (b))
1086     {
1087       p = b->decl;
1088       switch (TREE_CODE (p))
1089         {
1090         case LABEL_DECL:
1091           /* Warnings for unused labels, errors for undefined labels.  */
1092           if (TREE_USED (p) && !DECL_INITIAL (p))
1093             {
1094               error ("label %q+D used but not defined", p);
1095               DECL_INITIAL (p) = error_mark_node;
1096             }
1097           else
1098             warn_for_unused_label (p);
1099
1100           /* Labels go in BLOCK_VARS.  */
1101           DECL_CHAIN (p) = BLOCK_VARS (block);
1102           BLOCK_VARS (block) = p;
1103           gcc_assert (I_LABEL_BINDING (b->id) == b);
1104           I_LABEL_BINDING (b->id) = b->shadowed;
1105
1106           /* Also pop back to the shadowed label_vars.  */
1107           release_tree_vector (b->u.label->decls_in_scope);
1108           b->u.label = b->u.label->shadowed;
1109           break;
1110
1111         case ENUMERAL_TYPE:
1112         case UNION_TYPE:
1113         case RECORD_TYPE:
1114           set_type_context (p, context);
1115
1116           /* Types may not have tag-names, in which case the type
1117              appears in the bindings list with b->id NULL.  */
1118           if (b->id)
1119             {
1120               gcc_assert (I_TAG_BINDING (b->id) == b);
1121               I_TAG_BINDING (b->id) = b->shadowed;
1122             }
1123           break;
1124
1125         case FUNCTION_DECL:
1126           /* Propagate TREE_ADDRESSABLE from nested functions to their
1127              containing functions.  */
1128           if (!TREE_ASM_WRITTEN (p)
1129               && DECL_INITIAL (p) != 0
1130               && TREE_ADDRESSABLE (p)
1131               && DECL_ABSTRACT_ORIGIN (p) != 0
1132               && DECL_ABSTRACT_ORIGIN (p) != p)
1133             TREE_ADDRESSABLE (DECL_ABSTRACT_ORIGIN (p)) = 1;
1134           if (!DECL_EXTERNAL (p)
1135               && !DECL_INITIAL (p)
1136               && scope != file_scope
1137               && scope != external_scope)
1138             {
1139               error ("nested function %q+D declared but never defined", p);
1140               undef_nested_function = true;
1141             }
1142           else if (DECL_DECLARED_INLINE_P (p)
1143                    && TREE_PUBLIC (p)
1144                    && !DECL_INITIAL (p))
1145             {
1146               /* C99 6.7.4p6: "a function with external linkage... declared
1147                  with an inline function specifier ... shall also be defined
1148                  in the same translation unit."  */
1149               if (!flag_gnu89_inline)
1150                 pedwarn (input_location, 0,
1151                          "inline function %q+D declared but never defined", p);
1152               DECL_EXTERNAL (p) = 1;
1153             }
1154
1155           goto common_symbol;
1156
1157         case VAR_DECL:
1158           /* Warnings for unused variables.  */
1159           if ((!TREE_USED (p) || !DECL_READ_P (p))
1160               && !TREE_NO_WARNING (p)
1161               && !DECL_IN_SYSTEM_HEADER (p)
1162               && DECL_NAME (p)
1163               && !DECL_ARTIFICIAL (p)
1164               && scope != file_scope
1165               && scope != external_scope)
1166             {
1167               if (!TREE_USED (p))
1168                 warning (OPT_Wunused_variable, "unused variable %q+D", p);
1169               else if (DECL_CONTEXT (p) == current_function_decl)
1170                 warning_at (DECL_SOURCE_LOCATION (p),
1171                             OPT_Wunused_but_set_variable,
1172                             "variable %qD set but not used", p);
1173             }
1174
1175           if (b->inner_comp)
1176             {
1177               error ("type of array %q+D completed incompatibly with"
1178                      " implicit initialization", p);
1179             }
1180
1181           /* Fall through.  */
1182         case TYPE_DECL:
1183         case CONST_DECL:
1184         common_symbol:
1185           /* All of these go in BLOCK_VARS, but only if this is the
1186              binding in the home scope.  */
1187           if (!b->nested)
1188             {
1189               DECL_CHAIN (p) = BLOCK_VARS (block);
1190               BLOCK_VARS (block) = p;
1191             }
1192           else if (VAR_OR_FUNCTION_DECL_P (p))
1193             {
1194               /* For block local externs add a special
1195                  DECL_EXTERNAL decl for debug info generation.  */
1196               tree extp = copy_node (p);
1197
1198               DECL_EXTERNAL (extp) = 1;
1199               TREE_STATIC (extp) = 0;
1200               TREE_PUBLIC (extp) = 1;
1201               DECL_INITIAL (extp) = NULL_TREE;
1202               DECL_LANG_SPECIFIC (extp) = NULL;
1203               DECL_CONTEXT (extp) = current_function_decl;
1204               if (TREE_CODE (p) == FUNCTION_DECL)
1205                 {
1206                   DECL_RESULT (extp) = NULL_TREE;
1207                   DECL_SAVED_TREE (extp) = NULL_TREE;
1208                   DECL_STRUCT_FUNCTION (extp) = NULL;
1209                 }
1210               if (b->locus != UNKNOWN_LOCATION)
1211                 DECL_SOURCE_LOCATION (extp) = b->locus;
1212               DECL_CHAIN (extp) = BLOCK_VARS (block);
1213               BLOCK_VARS (block) = extp;
1214             }
1215           /* If this is the file scope, and we are processing more
1216              than one translation unit in this compilation, set
1217              DECL_CONTEXT of each decl to the TRANSLATION_UNIT_DECL.
1218              This makes same_translation_unit_p work, and causes
1219              static declarations to be given disambiguating suffixes.  */
1220           if (scope == file_scope && num_in_fnames > 1)
1221             {
1222               DECL_CONTEXT (p) = context;
1223               if (TREE_CODE (p) == TYPE_DECL)
1224                 set_type_context (TREE_TYPE (p), context);
1225             }
1226
1227           /* Fall through.  */
1228           /* Parameters go in DECL_ARGUMENTS, not BLOCK_VARS, and have
1229              already been put there by store_parm_decls.  Unused-
1230              parameter warnings are handled by function.c.
1231              error_mark_node obviously does not go in BLOCK_VARS and
1232              does not get unused-variable warnings.  */
1233         case PARM_DECL:
1234         case ERROR_MARK:
1235           /* It is possible for a decl not to have a name.  We get
1236              here with b->id NULL in this case.  */
1237           if (b->id)
1238             {
1239               gcc_assert (I_SYMBOL_BINDING (b->id) == b);
1240               I_SYMBOL_BINDING (b->id) = b->shadowed;
1241               if (b->shadowed && b->shadowed->u.type)
1242                 TREE_TYPE (b->shadowed->decl) = b->shadowed->u.type;
1243             }
1244           break;
1245
1246         default:
1247           gcc_unreachable ();
1248         }
1249     }
1250
1251
1252   /* Dispose of the block that we just made inside some higher level.  */
1253   if ((scope->function_body || scope == file_scope) && context)
1254     {
1255       DECL_INITIAL (context) = block;
1256       BLOCK_SUPERCONTEXT (block) = context;
1257     }
1258   else if (scope->outer)
1259     {
1260       if (block)
1261         SCOPE_LIST_APPEND (scope->outer, blocks, block);
1262       /* If we did not make a block for the scope just exited, any
1263          blocks made for inner scopes must be carried forward so they
1264          will later become subblocks of something else.  */
1265       else if (scope->blocks)
1266         SCOPE_LIST_CONCAT (scope->outer, blocks, scope, blocks);
1267     }
1268
1269   /* Pop the current scope, and free the structure for reuse.  */
1270   current_scope = scope->outer;
1271   if (scope->function_body)
1272     current_function_scope = scope->outer_function;
1273
1274   memset (scope, 0, sizeof (struct c_scope));
1275   scope->outer = scope_freelist;
1276   scope_freelist = scope;
1277
1278   return block;
1279 }
1280
1281 void
1282 push_file_scope (void)
1283 {
1284   tree decl;
1285
1286   if (file_scope)
1287     return;
1288
1289   push_scope ();
1290   file_scope = current_scope;
1291
1292   start_fname_decls ();
1293
1294   for (decl = visible_builtins; decl; decl = DECL_CHAIN (decl))
1295     bind (DECL_NAME (decl), decl, file_scope,
1296           /*invisible=*/false, /*nested=*/true, DECL_SOURCE_LOCATION (decl));
1297 }
1298
1299 void
1300 pop_file_scope (void)
1301 {
1302   /* In case there were missing closebraces, get us back to the global
1303      binding level.  */
1304   while (current_scope != file_scope)
1305     pop_scope ();
1306
1307   /* __FUNCTION__ is defined at file scope ("").  This
1308      call may not be necessary as my tests indicate it
1309      still works without it.  */
1310   finish_fname_decls ();
1311
1312   check_inline_statics ();
1313
1314   /* This is the point to write out a PCH if we're doing that.
1315      In that case we do not want to do anything else.  */
1316   if (pch_file)
1317     {
1318       c_common_write_pch ();
1319       return;
1320     }
1321
1322   /* Pop off the file scope and close this translation unit.  */
1323   pop_scope ();
1324   file_scope = 0;
1325
1326   maybe_apply_pending_pragma_weaks ();
1327 }
1328 \f
1329 /* Adjust the bindings for the start of a statement expression.  */
1330
1331 void
1332 c_bindings_start_stmt_expr (struct c_spot_bindings* switch_bindings)
1333 {
1334   struct c_scope *scope;
1335
1336   for (scope = current_scope; scope != NULL; scope = scope->outer)
1337     {
1338       struct c_binding *b;
1339
1340       if (!scope->has_label_bindings)
1341         continue;
1342
1343       for (b = scope->bindings; b != NULL; b = b->prev)
1344         {
1345           struct c_label_vars *label_vars;
1346           unsigned int ix;
1347           struct c_goto_bindings *g;
1348
1349           if (TREE_CODE (b->decl) != LABEL_DECL)
1350             continue;
1351           label_vars = b->u.label;
1352           ++label_vars->label_bindings.stmt_exprs;
1353           FOR_EACH_VEC_ELT (c_goto_bindings_p, label_vars->gotos, ix, g)
1354             ++g->goto_bindings.stmt_exprs;
1355         }
1356     }
1357
1358   if (switch_bindings != NULL)
1359     ++switch_bindings->stmt_exprs;
1360 }
1361
1362 /* Adjust the bindings for the end of a statement expression.  */
1363
1364 void
1365 c_bindings_end_stmt_expr (struct c_spot_bindings *switch_bindings)
1366 {
1367   struct c_scope *scope;
1368
1369   for (scope = current_scope; scope != NULL; scope = scope->outer)
1370     {
1371       struct c_binding *b;
1372
1373       if (!scope->has_label_bindings)
1374         continue;
1375
1376       for (b = scope->bindings; b != NULL; b = b->prev)
1377         {
1378           struct c_label_vars *label_vars;
1379           unsigned int ix;
1380           struct c_goto_bindings *g;
1381
1382           if (TREE_CODE (b->decl) != LABEL_DECL)
1383             continue;
1384           label_vars = b->u.label;
1385           --label_vars->label_bindings.stmt_exprs;
1386           if (label_vars->label_bindings.stmt_exprs < 0)
1387             {
1388               label_vars->label_bindings.left_stmt_expr = true;
1389               label_vars->label_bindings.stmt_exprs = 0;
1390             }
1391           FOR_EACH_VEC_ELT (c_goto_bindings_p, label_vars->gotos, ix, g)
1392             {
1393               --g->goto_bindings.stmt_exprs;
1394               if (g->goto_bindings.stmt_exprs < 0)
1395                 {
1396                   g->goto_bindings.left_stmt_expr = true;
1397                   g->goto_bindings.stmt_exprs = 0;
1398                 }
1399             }
1400         }
1401     }
1402
1403   if (switch_bindings != NULL)
1404     {
1405       --switch_bindings->stmt_exprs;
1406       gcc_assert (switch_bindings->stmt_exprs >= 0);
1407     }
1408 }
1409 \f
1410 /* Push a definition or a declaration of struct, union or enum tag "name".
1411    "type" should be the type node.
1412    We assume that the tag "name" is not already defined, and has a location
1413    of LOC.
1414
1415    Note that the definition may really be just a forward reference.
1416    In that case, the TYPE_SIZE will be zero.  */
1417
1418 static void
1419 pushtag (location_t loc, tree name, tree type)
1420 {
1421   /* Record the identifier as the type's name if it has none.  */
1422   if (name && !TYPE_NAME (type))
1423     TYPE_NAME (type) = name;
1424   bind (name, type, current_scope, /*invisible=*/false, /*nested=*/false, loc);
1425
1426   /* Create a fake NULL-named TYPE_DECL node whose TREE_TYPE will be the
1427      tagged type we just added to the current scope.  This fake
1428      NULL-named TYPE_DECL node helps dwarfout.c to know when it needs
1429      to output a representation of a tagged type, and it also gives
1430      us a convenient place to record the "scope start" address for the
1431      tagged type.  */
1432
1433   TYPE_STUB_DECL (type) = pushdecl (build_decl (loc,
1434                                                 TYPE_DECL, NULL_TREE, type));
1435
1436   /* An approximation for now, so we can tell this is a function-scope tag.
1437      This will be updated in pop_scope.  */
1438   TYPE_CONTEXT (type) = DECL_CONTEXT (TYPE_STUB_DECL (type));
1439
1440   if (warn_cxx_compat && name != NULL_TREE)
1441     {
1442       struct c_binding *b = I_SYMBOL_BINDING (name);
1443
1444       if (b != NULL
1445           && b->decl != NULL_TREE
1446           && TREE_CODE (b->decl) == TYPE_DECL
1447           && (B_IN_CURRENT_SCOPE (b)
1448               || (current_scope == file_scope && B_IN_EXTERNAL_SCOPE (b)))
1449           && (TYPE_MAIN_VARIANT (TREE_TYPE (b->decl))
1450               != TYPE_MAIN_VARIANT (type)))
1451         {
1452           warning_at (loc, OPT_Wc___compat,
1453                       ("using %qD as both a typedef and a tag is "
1454                        "invalid in C++"),
1455                       b->decl);
1456           if (b->locus != UNKNOWN_LOCATION)
1457             inform (b->locus, "originally defined here");
1458         }
1459     }
1460 }
1461 \f
1462 /* Subroutine of compare_decls.  Allow harmless mismatches in return
1463    and argument types provided that the type modes match.  This function
1464    return a unified type given a suitable match, and 0 otherwise.  */
1465
1466 static tree
1467 match_builtin_function_types (tree newtype, tree oldtype)
1468 {
1469   tree newrettype, oldrettype;
1470   tree newargs, oldargs;
1471   tree trytype, tryargs;
1472
1473   /* Accept the return type of the new declaration if same modes.  */
1474   oldrettype = TREE_TYPE (oldtype);
1475   newrettype = TREE_TYPE (newtype);
1476
1477   if (TYPE_MODE (oldrettype) != TYPE_MODE (newrettype))
1478     return 0;
1479
1480   oldargs = TYPE_ARG_TYPES (oldtype);
1481   newargs = TYPE_ARG_TYPES (newtype);
1482   tryargs = newargs;
1483
1484   while (oldargs || newargs)
1485     {
1486       if (!oldargs
1487           || !newargs
1488           || !TREE_VALUE (oldargs)
1489           || !TREE_VALUE (newargs)
1490           || TYPE_MODE (TREE_VALUE (oldargs))
1491              != TYPE_MODE (TREE_VALUE (newargs)))
1492         return 0;
1493
1494       oldargs = TREE_CHAIN (oldargs);
1495       newargs = TREE_CHAIN (newargs);
1496     }
1497
1498   trytype = build_function_type (newrettype, tryargs);
1499   return build_type_attribute_variant (trytype, TYPE_ATTRIBUTES (oldtype));
1500 }
1501
1502 /* Subroutine of diagnose_mismatched_decls.  Check for function type
1503    mismatch involving an empty arglist vs a nonempty one and give clearer
1504    diagnostics.  */
1505 static void
1506 diagnose_arglist_conflict (tree newdecl, tree olddecl,
1507                            tree newtype, tree oldtype)
1508 {
1509   tree t;
1510
1511   if (TREE_CODE (olddecl) != FUNCTION_DECL
1512       || !comptypes (TREE_TYPE (oldtype), TREE_TYPE (newtype))
1513       || !((TYPE_ARG_TYPES (oldtype) == 0 && DECL_INITIAL (olddecl) == 0)
1514            ||
1515            (TYPE_ARG_TYPES (newtype) == 0 && DECL_INITIAL (newdecl) == 0)))
1516     return;
1517
1518   t = TYPE_ARG_TYPES (oldtype);
1519   if (t == 0)
1520     t = TYPE_ARG_TYPES (newtype);
1521   for (; t; t = TREE_CHAIN (t))
1522     {
1523       tree type = TREE_VALUE (t);
1524
1525       if (TREE_CHAIN (t) == 0
1526           && TYPE_MAIN_VARIANT (type) != void_type_node)
1527         {
1528           inform (input_location, "a parameter list with an ellipsis can%'t match "
1529                   "an empty parameter name list declaration");
1530           break;
1531         }
1532
1533       if (c_type_promotes_to (type) != type)
1534         {
1535           inform (input_location, "an argument type that has a default promotion can%'t match "
1536                   "an empty parameter name list declaration");
1537           break;
1538         }
1539     }
1540 }
1541
1542 /* Another subroutine of diagnose_mismatched_decls.  OLDDECL is an
1543    old-style function definition, NEWDECL is a prototype declaration.
1544    Diagnose inconsistencies in the argument list.  Returns TRUE if
1545    the prototype is compatible, FALSE if not.  */
1546 static bool
1547 validate_proto_after_old_defn (tree newdecl, tree newtype, tree oldtype)
1548 {
1549   tree newargs, oldargs;
1550   int i;
1551
1552 #define END_OF_ARGLIST(t) ((t) == void_type_node)
1553
1554   oldargs = TYPE_ACTUAL_ARG_TYPES (oldtype);
1555   newargs = TYPE_ARG_TYPES (newtype);
1556   i = 1;
1557
1558   for (;;)
1559     {
1560       tree oldargtype = TREE_VALUE (oldargs);
1561       tree newargtype = TREE_VALUE (newargs);
1562
1563       if (oldargtype == error_mark_node || newargtype == error_mark_node)
1564         return false;
1565
1566       oldargtype = TYPE_MAIN_VARIANT (oldargtype);
1567       newargtype = TYPE_MAIN_VARIANT (newargtype);
1568
1569       if (END_OF_ARGLIST (oldargtype) && END_OF_ARGLIST (newargtype))
1570         break;
1571
1572       /* Reaching the end of just one list means the two decls don't
1573          agree on the number of arguments.  */
1574       if (END_OF_ARGLIST (oldargtype))
1575         {
1576           error ("prototype for %q+D declares more arguments "
1577                  "than previous old-style definition", newdecl);
1578           return false;
1579         }
1580       else if (END_OF_ARGLIST (newargtype))
1581         {
1582           error ("prototype for %q+D declares fewer arguments "
1583                  "than previous old-style definition", newdecl);
1584           return false;
1585         }
1586
1587       /* Type for passing arg must be consistent with that declared
1588          for the arg.  */
1589       else if (!comptypes (oldargtype, newargtype))
1590         {
1591           error ("prototype for %q+D declares argument %d"
1592                  " with incompatible type",
1593                  newdecl, i);
1594           return false;
1595         }
1596
1597       oldargs = TREE_CHAIN (oldargs);
1598       newargs = TREE_CHAIN (newargs);
1599       i++;
1600     }
1601
1602   /* If we get here, no errors were found, but do issue a warning
1603      for this poor-style construct.  */
1604   warning (0, "prototype for %q+D follows non-prototype definition",
1605            newdecl);
1606   return true;
1607 #undef END_OF_ARGLIST
1608 }
1609
1610 /* Subroutine of diagnose_mismatched_decls.  Report the location of DECL,
1611    first in a pair of mismatched declarations, using the diagnostic
1612    function DIAG.  */
1613 static void
1614 locate_old_decl (tree decl)
1615 {
1616   if (TREE_CODE (decl) == FUNCTION_DECL && DECL_BUILT_IN (decl))
1617     ;
1618   else if (DECL_INITIAL (decl))
1619     inform (input_location, "previous definition of %q+D was here", decl);
1620   else if (C_DECL_IMPLICIT (decl))
1621     inform (input_location, "previous implicit declaration of %q+D was here", decl);
1622   else
1623     inform (input_location, "previous declaration of %q+D was here", decl);
1624 }
1625
1626 /* Subroutine of duplicate_decls.  Compare NEWDECL to OLDDECL.
1627    Returns true if the caller should proceed to merge the two, false
1628    if OLDDECL should simply be discarded.  As a side effect, issues
1629    all necessary diagnostics for invalid or poor-style combinations.
1630    If it returns true, writes the types of NEWDECL and OLDDECL to
1631    *NEWTYPEP and *OLDTYPEP - these may have been adjusted from
1632    TREE_TYPE (NEWDECL, OLDDECL) respectively.  */
1633
1634 static bool
1635 diagnose_mismatched_decls (tree newdecl, tree olddecl,
1636                            tree *newtypep, tree *oldtypep)
1637 {
1638   tree newtype, oldtype;
1639   bool pedwarned = false;
1640   bool warned = false;
1641   bool retval = true;
1642
1643 #define DECL_EXTERN_INLINE(DECL) (DECL_DECLARED_INLINE_P (DECL)  \
1644                                   && DECL_EXTERNAL (DECL))
1645
1646   /* If we have error_mark_node for either decl or type, just discard
1647      the previous decl - we're in an error cascade already.  */
1648   if (olddecl == error_mark_node || newdecl == error_mark_node)
1649     return false;
1650   *oldtypep = oldtype = TREE_TYPE (olddecl);
1651   *newtypep = newtype = TREE_TYPE (newdecl);
1652   if (oldtype == error_mark_node || newtype == error_mark_node)
1653     return false;
1654
1655   /* Two different categories of symbol altogether.  This is an error
1656      unless OLDDECL is a builtin.  OLDDECL will be discarded in any case.  */
1657   if (TREE_CODE (olddecl) != TREE_CODE (newdecl))
1658     {
1659       if (!(TREE_CODE (olddecl) == FUNCTION_DECL
1660             && DECL_BUILT_IN (olddecl)
1661             && !C_DECL_DECLARED_BUILTIN (olddecl)))
1662         {
1663           error ("%q+D redeclared as different kind of symbol", newdecl);
1664           locate_old_decl (olddecl);
1665         }
1666       else if (TREE_PUBLIC (newdecl))
1667         warning (0, "built-in function %q+D declared as non-function",
1668                  newdecl);
1669       else
1670         warning (OPT_Wshadow, "declaration of %q+D shadows "
1671                  "a built-in function", newdecl);
1672       return false;
1673     }
1674
1675   /* Enumerators have no linkage, so may only be declared once in a
1676      given scope.  */
1677   if (TREE_CODE (olddecl) == CONST_DECL)
1678     {
1679       error ("redeclaration of enumerator %q+D", newdecl);
1680       locate_old_decl (olddecl);
1681       return false;
1682     }
1683
1684   if (!comptypes (oldtype, newtype))
1685     {
1686       if (TREE_CODE (olddecl) == FUNCTION_DECL
1687           && DECL_BUILT_IN (olddecl) && !C_DECL_DECLARED_BUILTIN (olddecl))
1688         {
1689           /* Accept harmless mismatch in function types.
1690              This is for the ffs and fprintf builtins.  */
1691           tree trytype = match_builtin_function_types (newtype, oldtype);
1692
1693           if (trytype && comptypes (newtype, trytype))
1694             *oldtypep = oldtype = trytype;
1695           else
1696             {
1697               /* If types don't match for a built-in, throw away the
1698                  built-in.  No point in calling locate_old_decl here, it
1699                  won't print anything.  */
1700               warning (0, "conflicting types for built-in function %q+D",
1701                        newdecl);
1702               return false;
1703             }
1704         }
1705       else if (TREE_CODE (olddecl) == FUNCTION_DECL
1706                && DECL_IS_BUILTIN (olddecl))
1707         {
1708           /* A conflicting function declaration for a predeclared
1709              function that isn't actually built in.  Objective C uses
1710              these.  The new declaration silently overrides everything
1711              but the volatility (i.e. noreturn) indication.  See also
1712              below.  FIXME: Make Objective C use normal builtins.  */
1713           TREE_THIS_VOLATILE (newdecl) |= TREE_THIS_VOLATILE (olddecl);
1714           return false;
1715         }
1716       /* Permit void foo (...) to match int foo (...) if the latter is
1717          the definition and implicit int was used.  See
1718          c-torture/compile/920625-2.c.  */
1719       else if (TREE_CODE (newdecl) == FUNCTION_DECL && DECL_INITIAL (newdecl)
1720                && TYPE_MAIN_VARIANT (TREE_TYPE (oldtype)) == void_type_node
1721                && TYPE_MAIN_VARIANT (TREE_TYPE (newtype)) == integer_type_node
1722                && C_FUNCTION_IMPLICIT_INT (newdecl) && !DECL_INITIAL (olddecl))
1723         {
1724           pedwarned = pedwarn (input_location, 0,
1725                                "conflicting types for %q+D", newdecl);
1726           /* Make sure we keep void as the return type.  */
1727           TREE_TYPE (newdecl) = *newtypep = newtype = oldtype;
1728           C_FUNCTION_IMPLICIT_INT (newdecl) = 0;
1729         }
1730       /* Permit void foo (...) to match an earlier call to foo (...) with
1731          no declared type (thus, implicitly int).  */
1732       else if (TREE_CODE (newdecl) == FUNCTION_DECL
1733                && TYPE_MAIN_VARIANT (TREE_TYPE (newtype)) == void_type_node
1734                && TYPE_MAIN_VARIANT (TREE_TYPE (oldtype)) == integer_type_node
1735                && C_DECL_IMPLICIT (olddecl) && !DECL_INITIAL (olddecl))
1736         {
1737           pedwarned = pedwarn (input_location, 0,
1738                                "conflicting types for %q+D", newdecl);
1739           /* Make sure we keep void as the return type.  */
1740           TREE_TYPE (olddecl) = *oldtypep = oldtype = newtype;
1741         }
1742       else
1743         {
1744           int new_quals = TYPE_QUALS (newtype);
1745           int old_quals = TYPE_QUALS (oldtype);
1746
1747           if (new_quals != old_quals)
1748             {
1749               addr_space_t new_addr = DECODE_QUAL_ADDR_SPACE (new_quals);
1750               addr_space_t old_addr = DECODE_QUAL_ADDR_SPACE (old_quals);
1751               if (new_addr != old_addr)
1752                 {
1753                   if (ADDR_SPACE_GENERIC_P (new_addr))
1754                     error ("conflicting named address spaces (generic vs %s) "
1755                            "for %q+D",
1756                            c_addr_space_name (old_addr), newdecl);
1757                   else if (ADDR_SPACE_GENERIC_P (old_addr))
1758                     error ("conflicting named address spaces (%s vs generic) "
1759                            "for %q+D",
1760                            c_addr_space_name (new_addr), newdecl);
1761                   else
1762                     error ("conflicting named address spaces (%s vs %s) "
1763                            "for %q+D",
1764                            c_addr_space_name (new_addr),
1765                            c_addr_space_name (old_addr),
1766                            newdecl);
1767                 }
1768
1769               if (CLEAR_QUAL_ADDR_SPACE (new_quals)
1770                   != CLEAR_QUAL_ADDR_SPACE (old_quals))
1771                 error ("conflicting type qualifiers for %q+D", newdecl);
1772             }
1773           else
1774             error ("conflicting types for %q+D", newdecl);
1775           diagnose_arglist_conflict (newdecl, olddecl, newtype, oldtype);
1776           locate_old_decl (olddecl);
1777           return false;
1778         }
1779     }
1780
1781   /* Redeclaration of a type is a constraint violation (6.7.2.3p1),
1782      but silently ignore the redeclaration if either is in a system
1783      header.  (Conflicting redeclarations were handled above.)  This
1784      is allowed for C1X if the types are the same, not just
1785      compatible.  */
1786   if (TREE_CODE (newdecl) == TYPE_DECL)
1787     {
1788       bool types_different = false;
1789       int comptypes_result;
1790
1791       comptypes_result
1792         = comptypes_check_different_types (oldtype, newtype, &types_different);
1793
1794       if (comptypes_result != 1 || types_different)
1795         {
1796           error ("redefinition of typedef %q+D with different type", newdecl);
1797           locate_old_decl (olddecl);
1798           return false;
1799         }
1800
1801       if (DECL_IN_SYSTEM_HEADER (newdecl)
1802           || DECL_IN_SYSTEM_HEADER (olddecl)
1803           || TREE_NO_WARNING (newdecl)
1804           || TREE_NO_WARNING (olddecl))
1805         return true;  /* Allow OLDDECL to continue in use.  */
1806
1807       if (pedantic && !flag_isoc1x)
1808         {
1809           pedwarn (input_location, OPT_pedantic,
1810                    "redefinition of typedef %q+D", newdecl);
1811           locate_old_decl (olddecl);
1812         }
1813       else if (variably_modified_type_p (newtype, NULL))
1814         {
1815           /* Whether there is a constraint violation for the types not
1816              being the same cannot be determined at compile time; a
1817              warning that there may be one at runtime is considered
1818              appropriate (WG14 reflector message 11743, 8 May 2009).  */
1819           warning (0, "redefinition of typedef %q+D may be a constraint "
1820                    "violation at runtime", 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                   && !TYPE_ARG_TYPES (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                && !TYPE_ARG_TYPES (oldtype) && TYPE_ARG_TYPES (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                            && TYPE_ARG_TYPES (TREE_TYPE (newdecl)) != 0);
2152   bool old_is_prototype = (TREE_CODE (olddecl) == FUNCTION_DECL
2153                            && TYPE_ARG_TYPES (TREE_TYPE (olddecl)) != 0);
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             C_DECL_BUILTIN_PROTOTYPE (newdecl) = 0;
2372           else
2373             C_DECL_BUILTIN_PROTOTYPE (newdecl)
2374               = C_DECL_BUILTIN_PROTOTYPE (olddecl);
2375         }
2376
2377       /* Preserve function specific target and optimization options */
2378       if (DECL_FUNCTION_SPECIFIC_TARGET (olddecl)
2379           && !DECL_FUNCTION_SPECIFIC_TARGET (newdecl))
2380         DECL_FUNCTION_SPECIFIC_TARGET (newdecl)
2381           = DECL_FUNCTION_SPECIFIC_TARGET (olddecl);
2382
2383       if (DECL_FUNCTION_SPECIFIC_OPTIMIZATION (olddecl)
2384           && !DECL_FUNCTION_SPECIFIC_OPTIMIZATION (newdecl))
2385         DECL_FUNCTION_SPECIFIC_OPTIMIZATION (newdecl)
2386           = DECL_FUNCTION_SPECIFIC_OPTIMIZATION (olddecl);
2387
2388       /* Also preserve various other info from the definition.  */
2389       if (!new_is_definition)
2390         {
2391           tree t;
2392           DECL_RESULT (newdecl) = DECL_RESULT (olddecl);
2393           DECL_INITIAL (newdecl) = DECL_INITIAL (olddecl);
2394           DECL_STRUCT_FUNCTION (newdecl) = DECL_STRUCT_FUNCTION (olddecl);
2395           DECL_SAVED_TREE (newdecl) = DECL_SAVED_TREE (olddecl);
2396           DECL_ARGUMENTS (newdecl) = copy_list (DECL_ARGUMENTS (olddecl));
2397           for (t = DECL_ARGUMENTS (newdecl); t ; t = DECL_CHAIN (t))
2398             DECL_CONTEXT (t) = newdecl;
2399
2400           /* See if we've got a function to instantiate from.  */
2401           if (DECL_SAVED_TREE (olddecl))
2402             DECL_ABSTRACT_ORIGIN (newdecl)
2403               = DECL_ABSTRACT_ORIGIN (olddecl);
2404         }
2405     }
2406
2407   extern_changed = DECL_EXTERNAL (olddecl) && !DECL_EXTERNAL (newdecl);
2408
2409   /* Merge the USED information.  */
2410   if (TREE_USED (olddecl))
2411     TREE_USED (newdecl) = 1;
2412   else if (TREE_USED (newdecl))
2413     TREE_USED (olddecl) = 1;
2414   if (TREE_CODE (olddecl) == VAR_DECL || TREE_CODE (olddecl) == PARM_DECL)
2415     DECL_READ_P (newdecl) |= DECL_READ_P (olddecl);
2416   if (DECL_PRESERVE_P (olddecl))
2417     DECL_PRESERVE_P (newdecl) = 1;
2418   else if (DECL_PRESERVE_P (newdecl))
2419     DECL_PRESERVE_P (olddecl) = 1;
2420
2421   /* Copy most of the decl-specific fields of NEWDECL into OLDDECL.
2422      But preserve OLDDECL's DECL_UID, DECL_CONTEXT and
2423      DECL_ARGUMENTS (if appropriate).  */
2424   {
2425     unsigned olddecl_uid = DECL_UID (olddecl);
2426     tree olddecl_context = DECL_CONTEXT (olddecl);
2427     tree olddecl_arguments = NULL;
2428     if (TREE_CODE (olddecl) == FUNCTION_DECL)
2429       olddecl_arguments = DECL_ARGUMENTS (olddecl);
2430
2431     memcpy ((char *) olddecl + sizeof (struct tree_common),
2432             (char *) newdecl + sizeof (struct tree_common),
2433             sizeof (struct tree_decl_common) - sizeof (struct tree_common));
2434     switch (TREE_CODE (olddecl))
2435       {
2436       case FUNCTION_DECL:
2437       case FIELD_DECL:
2438       case VAR_DECL:
2439       case PARM_DECL:
2440       case LABEL_DECL:
2441       case RESULT_DECL:
2442       case CONST_DECL:
2443       case TYPE_DECL:
2444         memcpy ((char *) olddecl + sizeof (struct tree_decl_common),
2445                 (char *) newdecl + sizeof (struct tree_decl_common),
2446                 tree_code_size (TREE_CODE (olddecl)) - sizeof (struct tree_decl_common));
2447         break;
2448
2449       default:
2450
2451         memcpy ((char *) olddecl + sizeof (struct tree_decl_common),
2452                 (char *) newdecl + sizeof (struct tree_decl_common),
2453                 sizeof (struct tree_decl_non_common) - sizeof (struct tree_decl_common));
2454       }
2455     DECL_UID (olddecl) = olddecl_uid;
2456     DECL_CONTEXT (olddecl) = olddecl_context;
2457     if (TREE_CODE (olddecl) == FUNCTION_DECL)
2458       DECL_ARGUMENTS (olddecl) = olddecl_arguments;
2459   }
2460
2461   /* If OLDDECL had its DECL_RTL instantiated, re-invoke make_decl_rtl
2462      so that encode_section_info has a chance to look at the new decl
2463      flags and attributes.  */
2464   if (DECL_RTL_SET_P (olddecl)
2465       && (TREE_CODE (olddecl) == FUNCTION_DECL
2466           || (TREE_CODE (olddecl) == VAR_DECL
2467               && TREE_STATIC (olddecl))))
2468     make_decl_rtl (olddecl);
2469
2470   /* If we changed a function from DECL_EXTERNAL to !DECL_EXTERNAL,
2471      and the definition is coming from the old version, cgraph needs
2472      to be called again.  */
2473   if (extern_changed && !new_is_definition
2474       && TREE_CODE (olddecl) == FUNCTION_DECL && DECL_INITIAL (olddecl))
2475     cgraph_mark_if_needed (olddecl);
2476 }
2477
2478 /* Handle when a new declaration NEWDECL has the same name as an old
2479    one OLDDECL in the same binding contour.  Prints an error message
2480    if appropriate.
2481
2482    If safely possible, alter OLDDECL to look like NEWDECL, and return
2483    true.  Otherwise, return false.  */
2484
2485 static bool
2486 duplicate_decls (tree newdecl, tree olddecl)
2487 {
2488   tree newtype = NULL, oldtype = NULL;
2489
2490   if (!diagnose_mismatched_decls (newdecl, olddecl, &newtype, &oldtype))
2491     {
2492       /* Avoid `unused variable' and other warnings for OLDDECL.  */
2493       TREE_NO_WARNING (olddecl) = 1;
2494       return false;
2495     }
2496
2497   merge_decls (newdecl, olddecl, newtype, oldtype);
2498   return true;
2499 }
2500
2501 \f
2502 /* Check whether decl-node NEW_DECL shadows an existing declaration.  */
2503 static void
2504 warn_if_shadowing (tree new_decl)
2505 {
2506   struct c_binding *b;
2507
2508   /* Shadow warnings wanted?  */
2509   if (!warn_shadow
2510       /* No shadow warnings for internally generated vars.  */
2511       || DECL_IS_BUILTIN (new_decl)
2512       /* No shadow warnings for vars made for inlining.  */
2513       || DECL_FROM_INLINE (new_decl))
2514     return;
2515
2516   /* Is anything being shadowed?  Invisible decls do not count.  */
2517   for (b = I_SYMBOL_BINDING (DECL_NAME (new_decl)); b; b = b->shadowed)
2518     if (b->decl && b->decl != new_decl && !b->invisible)
2519       {
2520         tree old_decl = b->decl;
2521
2522         if (old_decl == error_mark_node)
2523           {
2524             warning (OPT_Wshadow, "declaration of %q+D shadows previous "
2525                      "non-variable", new_decl);
2526             break;
2527           }
2528         else if (TREE_CODE (old_decl) == PARM_DECL)
2529           warning (OPT_Wshadow, "declaration of %q+D shadows a parameter",
2530                    new_decl);
2531         else if (DECL_FILE_SCOPE_P (old_decl))
2532           warning (OPT_Wshadow, "declaration of %q+D shadows a global "
2533                    "declaration", new_decl);
2534         else if (TREE_CODE (old_decl) == FUNCTION_DECL
2535                  && DECL_BUILT_IN (old_decl))
2536           {
2537             warning (OPT_Wshadow, "declaration of %q+D shadows "
2538                      "a built-in function", new_decl);
2539             break;
2540           }
2541         else
2542           warning (OPT_Wshadow, "declaration of %q+D shadows a previous local",
2543                    new_decl);
2544
2545         warning_at (DECL_SOURCE_LOCATION (old_decl), OPT_Wshadow,
2546                     "shadowed declaration is here");
2547
2548         break;
2549       }
2550 }
2551
2552 /* Record a decl-node X as belonging to the current lexical scope.
2553    Check for errors (such as an incompatible declaration for the same
2554    name already seen in the same scope).
2555
2556    Returns either X or an old decl for the same name.
2557    If an old decl is returned, it may have been smashed
2558    to agree with what X says.  */
2559
2560 tree
2561 pushdecl (tree x)
2562 {
2563   tree name = DECL_NAME (x);
2564   struct c_scope *scope = current_scope;
2565   struct c_binding *b;
2566   bool nested = false;
2567   location_t locus = DECL_SOURCE_LOCATION (x);
2568
2569   /* Must set DECL_CONTEXT for everything not at file scope or
2570      DECL_FILE_SCOPE_P won't work.  Local externs don't count
2571      unless they have initializers (which generate code).  */
2572   if (current_function_decl
2573       && ((TREE_CODE (x) != FUNCTION_DECL && TREE_CODE (x) != VAR_DECL)
2574           || DECL_INITIAL (x) || !DECL_EXTERNAL (x)))
2575     DECL_CONTEXT (x) = current_function_decl;
2576
2577   /* Anonymous decls are just inserted in the scope.  */
2578   if (!name)
2579     {
2580       bind (name, x, scope, /*invisible=*/false, /*nested=*/false,
2581             locus);
2582       return x;
2583     }
2584
2585   /* First, see if there is another declaration with the same name in
2586      the current scope.  If there is, duplicate_decls may do all the
2587      work for us.  If duplicate_decls returns false, that indicates
2588      two incompatible decls in the same scope; we are to silently
2589      replace the old one (duplicate_decls has issued all appropriate
2590      diagnostics).  In particular, we should not consider possible
2591      duplicates in the external scope, or shadowing.  */
2592   b = I_SYMBOL_BINDING (name);
2593   if (b && B_IN_SCOPE (b, scope))
2594     {
2595       struct c_binding *b_ext, *b_use;
2596       tree type = TREE_TYPE (x);
2597       tree visdecl = b->decl;
2598       tree vistype = TREE_TYPE (visdecl);
2599       if (TREE_CODE (TREE_TYPE (x)) == ARRAY_TYPE
2600           && COMPLETE_TYPE_P (TREE_TYPE (x)))
2601         b->inner_comp = false;
2602       b_use = b;
2603       b_ext = b;
2604       /* If this is an external linkage declaration, we should check
2605          for compatibility with the type in the external scope before
2606          setting the type at this scope based on the visible
2607          information only.  */
2608       if (TREE_PUBLIC (x) && TREE_PUBLIC (visdecl))
2609         {
2610           while (b_ext && !B_IN_EXTERNAL_SCOPE (b_ext))
2611             b_ext = b_ext->shadowed;
2612           if (b_ext)
2613             {
2614               b_use = b_ext;
2615               if (b_use->u.type)
2616                 TREE_TYPE (b_use->decl) = b_use->u.type;
2617             }
2618         }
2619       if (duplicate_decls (x, b_use->decl))
2620         {
2621           if (b_use != b)
2622             {
2623               /* Save the updated type in the external scope and
2624                  restore the proper type for this scope.  */
2625               tree thistype;
2626               if (comptypes (vistype, type))
2627                 thistype = composite_type (vistype, type);
2628               else
2629                 thistype = TREE_TYPE (b_use->decl);
2630               b_use->u.type = TREE_TYPE (b_use->decl);
2631               if (TREE_CODE (b_use->decl) == FUNCTION_DECL
2632                   && DECL_BUILT_IN (b_use->decl))
2633                 thistype
2634                   = build_type_attribute_variant (thistype,
2635                                                   TYPE_ATTRIBUTES
2636                                                   (b_use->u.type));
2637               TREE_TYPE (b_use->decl) = thistype;
2638             }
2639           return b_use->decl;
2640         }
2641       else
2642         goto skip_external_and_shadow_checks;
2643     }
2644
2645   /* All declarations with external linkage, and all external
2646      references, go in the external scope, no matter what scope is
2647      current.  However, the binding in that scope is ignored for
2648      purposes of normal name lookup.  A separate binding structure is
2649      created in the requested scope; this governs the normal
2650      visibility of the symbol.
2651
2652      The binding in the externals scope is used exclusively for
2653      detecting duplicate declarations of the same object, no matter
2654      what scope they are in; this is what we do here.  (C99 6.2.7p2:
2655      All declarations that refer to the same object or function shall
2656      have compatible type; otherwise, the behavior is undefined.)  */
2657   if (DECL_EXTERNAL (x) || scope == file_scope)
2658     {
2659       tree type = TREE_TYPE (x);
2660       tree vistype = 0;
2661       tree visdecl = 0;
2662       bool type_saved = false;
2663       if (b && !B_IN_EXTERNAL_SCOPE (b)
2664           && (TREE_CODE (b->decl) == FUNCTION_DECL
2665               || TREE_CODE (b->decl) == VAR_DECL)
2666           && DECL_FILE_SCOPE_P (b->decl))
2667         {
2668           visdecl = b->decl;
2669           vistype = TREE_TYPE (visdecl);
2670         }
2671       if (scope != file_scope
2672           && !DECL_IN_SYSTEM_HEADER (x))
2673         warning (OPT_Wnested_externs, "nested extern declaration of %qD", x);
2674
2675       while (b && !B_IN_EXTERNAL_SCOPE (b))
2676         {
2677           /* If this decl might be modified, save its type.  This is
2678              done here rather than when the decl is first bound
2679              because the type may change after first binding, through
2680              being completed or through attributes being added.  If we
2681              encounter multiple such decls, only the first should have
2682              its type saved; the others will already have had their
2683              proper types saved and the types will not have changed as
2684              their scopes will not have been re-entered.  */
2685           if (DECL_P (b->decl) && DECL_FILE_SCOPE_P (b->decl) && !type_saved)
2686             {
2687               b->u.type = TREE_TYPE (b->decl);
2688               type_saved = true;
2689             }
2690           if (B_IN_FILE_SCOPE (b)
2691               && TREE_CODE (b->decl) == VAR_DECL
2692               && TREE_STATIC (b->decl)
2693               && TREE_CODE (TREE_TYPE (b->decl)) == ARRAY_TYPE
2694               && !TYPE_DOMAIN (TREE_TYPE (b->decl))
2695               && TREE_CODE (type) == ARRAY_TYPE
2696               && TYPE_DOMAIN (type)
2697               && TYPE_MAX_VALUE (TYPE_DOMAIN (type))
2698               && !integer_zerop (TYPE_MAX_VALUE (TYPE_DOMAIN (type))))
2699             {
2700               /* Array type completed in inner scope, which should be
2701                  diagnosed if the completion does not have size 1 and
2702                  it does not get completed in the file scope.  */
2703               b->inner_comp = true;
2704             }
2705           b = b->shadowed;
2706         }
2707
2708       /* If a matching external declaration has been found, set its
2709          type to the composite of all the types of that declaration.
2710          After the consistency checks, it will be reset to the
2711          composite of the visible types only.  */
2712       if (b && (TREE_PUBLIC (x) || same_translation_unit_p (x, b->decl))
2713           && b->u.type)
2714         TREE_TYPE (b->decl) = b->u.type;
2715
2716       /* The point of the same_translation_unit_p check here is,
2717          we want to detect a duplicate decl for a construct like
2718          foo() { extern bar(); } ... static bar();  but not if
2719          they are in different translation units.  In any case,
2720          the static does not go in the externals scope.  */
2721       if (b
2722           && (TREE_PUBLIC (x) || same_translation_unit_p (x, b->decl))
2723           && duplicate_decls (x, b->decl))
2724         {
2725           tree thistype;
2726           if (vistype)
2727             {
2728               if (comptypes (vistype, type))
2729                 thistype = composite_type (vistype, type);
2730               else
2731                 thistype = TREE_TYPE (b->decl);
2732             }
2733           else
2734             thistype = type;
2735           b->u.type = TREE_TYPE (b->decl);
2736           if (TREE_CODE (b->decl) == FUNCTION_DECL && DECL_BUILT_IN (b->decl))
2737             thistype
2738               = build_type_attribute_variant (thistype,
2739                                               TYPE_ATTRIBUTES (b->u.type));
2740           TREE_TYPE (b->decl) = thistype;
2741           bind (name, b->decl, scope, /*invisible=*/false, /*nested=*/true,
2742                 locus);
2743           return b->decl;
2744         }
2745       else if (TREE_PUBLIC (x))
2746         {
2747           if (visdecl && !b && duplicate_decls (x, visdecl))
2748             {
2749               /* An external declaration at block scope referring to a
2750                  visible entity with internal linkage.  The composite
2751                  type will already be correct for this scope, so we
2752                  just need to fall through to make the declaration in
2753                  this scope.  */
2754               nested = true;
2755               x = visdecl;
2756             }
2757           else
2758             {
2759               bind (name, x, external_scope, /*invisible=*/true,
2760                     /*nested=*/false, locus);
2761               nested = true;
2762             }
2763         }
2764     }
2765
2766   if (TREE_CODE (x) != PARM_DECL)
2767     warn_if_shadowing (x);
2768
2769  skip_external_and_shadow_checks:
2770   if (TREE_CODE (x) == TYPE_DECL)
2771     set_underlying_type (x);
2772
2773   bind (name, x, scope, /*invisible=*/false, nested, locus);
2774
2775   /* If x's type is incomplete because it's based on a
2776      structure or union which has not yet been fully declared,
2777      attach it to that structure or union type, so we can go
2778      back and complete the variable declaration later, if the
2779      structure or union gets fully declared.
2780
2781      If the input is erroneous, we can have error_mark in the type
2782      slot (e.g. "f(void a, ...)") - that doesn't count as an
2783      incomplete type.  */
2784   if (TREE_TYPE (x) != error_mark_node
2785       && !COMPLETE_TYPE_P (TREE_TYPE (x)))
2786     {
2787       tree element = TREE_TYPE (x);
2788
2789       while (TREE_CODE (element) == ARRAY_TYPE)
2790         element = TREE_TYPE (element);
2791       element = TYPE_MAIN_VARIANT (element);
2792
2793       if ((TREE_CODE (element) == RECORD_TYPE
2794            || TREE_CODE (element) == UNION_TYPE)
2795           && (TREE_CODE (x) != TYPE_DECL
2796               || TREE_CODE (TREE_TYPE (x)) == ARRAY_TYPE)
2797           && !COMPLETE_TYPE_P (element))
2798         C_TYPE_INCOMPLETE_VARS (element)
2799           = tree_cons (NULL_TREE, x, C_TYPE_INCOMPLETE_VARS (element));
2800     }
2801   return x;
2802 }
2803
2804 /* Record X as belonging to file scope.
2805    This is used only internally by the Objective-C front end,
2806    and is limited to its needs.  duplicate_decls is not called;
2807    if there is any preexisting decl for this identifier, it is an ICE.  */
2808
2809 tree
2810 pushdecl_top_level (tree x)
2811 {
2812   tree name;
2813   bool nested = false;
2814   gcc_assert (TREE_CODE (x) == VAR_DECL || TREE_CODE (x) == CONST_DECL);
2815
2816   name = DECL_NAME (x);
2817
2818  gcc_assert (TREE_CODE (x) == CONST_DECL || !I_SYMBOL_BINDING (name));
2819
2820   if (TREE_PUBLIC (x))
2821     {
2822       bind (name, x, external_scope, /*invisible=*/true, /*nested=*/false,
2823             UNKNOWN_LOCATION);
2824       nested = true;
2825     }
2826   if (file_scope)
2827     bind (name, x, file_scope, /*invisible=*/false, nested, UNKNOWN_LOCATION);
2828
2829   return x;
2830 }
2831 \f
2832 static void
2833 implicit_decl_warning (tree id, tree olddecl)
2834 {
2835   if (warn_implicit_function_declaration)
2836     {
2837       bool warned;
2838
2839       if (flag_isoc99)
2840         warned = pedwarn (input_location, OPT_Wimplicit_function_declaration,
2841                           "implicit declaration of function %qE", id);
2842       else
2843         warned = warning (OPT_Wimplicit_function_declaration,
2844                           G_("implicit declaration of function %qE"), id);
2845       if (olddecl && warned)
2846         locate_old_decl (olddecl);
2847     }
2848 }
2849
2850 /* Generate an implicit declaration for identifier FUNCTIONID at LOC as a
2851    function of type int ().  */
2852
2853 tree
2854 implicitly_declare (location_t loc, tree functionid)
2855 {
2856   struct c_binding *b;
2857   tree decl = 0;
2858   tree asmspec_tree;
2859
2860   for (b = I_SYMBOL_BINDING (functionid); b; b = b->shadowed)
2861     {
2862       if (B_IN_SCOPE (b, external_scope))
2863         {
2864           decl = b->decl;
2865           break;
2866         }
2867     }
2868
2869   if (decl)
2870     {
2871       if (decl == error_mark_node)
2872         return decl;
2873
2874       /* FIXME: Objective-C has weird not-really-builtin functions
2875          which are supposed to be visible automatically.  They wind up
2876          in the external scope because they're pushed before the file
2877          scope gets created.  Catch this here and rebind them into the
2878          file scope.  */
2879       if (!DECL_BUILT_IN (decl) && DECL_IS_BUILTIN (decl))
2880         {
2881           bind (functionid, decl, file_scope,
2882                 /*invisible=*/false, /*nested=*/true,
2883                 DECL_SOURCE_LOCATION (decl));
2884           return decl;
2885         }
2886       else
2887         {
2888           tree newtype = default_function_type;
2889           if (b->u.type)
2890             TREE_TYPE (decl) = b->u.type;
2891           /* Implicit declaration of a function already declared
2892              (somehow) in a different scope, or as a built-in.
2893              If this is the first time this has happened, warn;
2894              then recycle the old declaration but with the new type.  */
2895           if (!C_DECL_IMPLICIT (decl))
2896             {
2897               implicit_decl_warning (functionid, decl);
2898               C_DECL_IMPLICIT (decl) = 1;
2899             }
2900           if (DECL_BUILT_IN (decl))
2901             {
2902               newtype = build_type_attribute_variant (newtype,
2903                                                       TYPE_ATTRIBUTES
2904                                                       (TREE_TYPE (decl)));
2905               if (!comptypes (newtype, TREE_TYPE (decl)))
2906                 {
2907                   warning_at (loc, 0, "incompatible implicit declaration of "
2908                               "built-in function %qD", decl);
2909                   newtype = TREE_TYPE (decl);
2910                 }
2911             }
2912           else
2913             {
2914               if (!comptypes (newtype, TREE_TYPE (decl)))
2915                 {
2916                   error_at (loc, "incompatible implicit declaration of function %qD", decl);
2917                   locate_old_decl (decl);
2918                 }
2919             }
2920           b->u.type = TREE_TYPE (decl);
2921           TREE_TYPE (decl) = newtype;
2922           bind (functionid, decl, current_scope,
2923                 /*invisible=*/false, /*nested=*/true,
2924                 DECL_SOURCE_LOCATION (decl));
2925           return decl;
2926         }
2927     }
2928
2929   /* Not seen before.  */
2930   decl = build_decl (loc, FUNCTION_DECL, functionid, default_function_type);
2931   DECL_EXTERNAL (decl) = 1;
2932   TREE_PUBLIC (decl) = 1;
2933   C_DECL_IMPLICIT (decl) = 1;
2934   implicit_decl_warning (functionid, 0);
2935   asmspec_tree = maybe_apply_renaming_pragma (decl, /*asmname=*/NULL);
2936   if (asmspec_tree)
2937     set_user_assembler_name (decl, TREE_STRING_POINTER (asmspec_tree));
2938
2939   /* C89 says implicit declarations are in the innermost block.
2940      So we record the decl in the standard fashion.  */
2941   decl = pushdecl (decl);
2942
2943   /* No need to call objc_check_decl here - it's a function type.  */
2944   rest_of_decl_compilation (decl, 0, 0);
2945
2946   /* Write a record describing this implicit function declaration
2947      to the prototypes file (if requested).  */
2948   gen_aux_info_record (decl, 0, 1, 0);
2949
2950   /* Possibly apply some default attributes to this implicit declaration.  */
2951   decl_attributes (&decl, NULL_TREE, 0);
2952
2953   return decl;
2954 }
2955
2956 /* Issue an error message for a reference to an undeclared variable
2957    ID, including a reference to a builtin outside of function-call
2958    context.  Establish a binding of the identifier to error_mark_node
2959    in an appropriate scope, which will suppress further errors for the
2960    same identifier.  The error message should be given location LOC.  */
2961 void
2962 undeclared_variable (location_t loc, tree id)
2963 {
2964   static bool already = false;
2965   struct c_scope *scope;
2966
2967   if (current_function_decl == 0)
2968     {
2969       error_at (loc, "%qE undeclared here (not in a function)", id);
2970       scope = current_scope;
2971     }
2972   else
2973     {
2974       error_at (loc, "%qE undeclared (first use in this function)", id);
2975       if (!already)
2976         {
2977           inform (loc, "each undeclared identifier is reported only"
2978                   " once for each function it appears in");
2979           already = true;
2980         }
2981
2982       /* If we are parsing old-style parameter decls, current_function_decl
2983          will be nonnull but current_function_scope will be null.  */
2984       scope = current_function_scope ? current_function_scope : current_scope;
2985     }
2986   bind (id, error_mark_node, scope, /*invisible=*/false, /*nested=*/false,
2987         UNKNOWN_LOCATION);
2988 }
2989 \f
2990 /* Subroutine of lookup_label, declare_label, define_label: construct a
2991    LABEL_DECL with all the proper frills.  Also create a struct
2992    c_label_vars initialized for the current scope.  */
2993
2994 static tree
2995 make_label (location_t location, tree name, bool defining,
2996             struct c_label_vars **p_label_vars)
2997 {
2998   tree label = build_decl (location, LABEL_DECL, name, void_type_node);
2999   struct c_label_vars *label_vars;
3000
3001   DECL_CONTEXT (label) = current_function_decl;
3002   DECL_MODE (label) = VOIDmode;
3003
3004   label_vars = ggc_alloc_c_label_vars ();
3005   label_vars->shadowed = NULL;
3006   set_spot_bindings (&label_vars->label_bindings, defining);
3007   label_vars->decls_in_scope = make_tree_vector ();
3008   label_vars->gotos = VEC_alloc (c_goto_bindings_p, gc, 0);
3009   *p_label_vars = label_vars;
3010
3011   return label;
3012 }
3013
3014 /* Get the LABEL_DECL corresponding to identifier NAME as a label.
3015    Create one if none exists so far for the current function.
3016    This is called when a label is used in a goto expression or
3017    has its address taken.  */
3018
3019 tree
3020 lookup_label (tree name)
3021 {
3022   tree label;
3023   struct c_label_vars *label_vars;
3024
3025   if (current_function_decl == 0)
3026     {
3027       error ("label %qE referenced outside of any function", name);
3028       return 0;
3029     }
3030
3031   /* Use a label already defined or ref'd with this name, but not if
3032      it is inherited from a containing function and wasn't declared
3033      using __label__.  */
3034   label = I_LABEL_DECL (name);
3035   if (label && (DECL_CONTEXT (label) == current_function_decl
3036                 || C_DECLARED_LABEL_FLAG (label)))
3037     {
3038       /* If the label has only been declared, update its apparent
3039          location to point here, for better diagnostics if it
3040          turns out not to have been defined.  */
3041       if (DECL_INITIAL (label) == NULL_TREE)
3042         DECL_SOURCE_LOCATION (label) = input_location;
3043       return label;
3044     }
3045
3046   /* No label binding for that identifier; make one.  */
3047   label = make_label (input_location, name, false, &label_vars);
3048
3049   /* Ordinary labels go in the current function scope.  */
3050   bind_label (name, label, current_function_scope, label_vars);
3051
3052   return label;
3053 }
3054
3055 /* Issue a warning about DECL for a goto statement at GOTO_LOC going
3056    to LABEL.  */
3057
3058 static void
3059 warn_about_goto (location_t goto_loc, tree label, tree decl)
3060 {
3061   if (variably_modified_type_p (TREE_TYPE (decl), NULL_TREE))
3062     error_at (goto_loc,
3063               "jump into scope of identifier with variably modified type");
3064   else
3065     warning_at (goto_loc, OPT_Wjump_misses_init,
3066                 "jump skips variable initialization");
3067   inform (DECL_SOURCE_LOCATION (label), "label %qD defined here", label);
3068   inform (DECL_SOURCE_LOCATION (decl), "%qD declared here", decl);
3069 }
3070
3071 /* Look up a label because of a goto statement.  This is like
3072    lookup_label, but also issues any appropriate warnings.  */
3073
3074 tree
3075 lookup_label_for_goto (location_t loc, tree name)
3076 {
3077   tree label;
3078   struct c_label_vars *label_vars;
3079   unsigned int ix;
3080   tree decl;
3081
3082   label = lookup_label (name);
3083   if (label == NULL_TREE)
3084     return NULL_TREE;
3085
3086   /* If we are jumping to a different function, we can't issue any
3087      useful warnings.  */
3088   if (DECL_CONTEXT (label) != current_function_decl)
3089     {
3090       gcc_assert (C_DECLARED_LABEL_FLAG (label));
3091       return label;
3092     }
3093
3094   label_vars = I_LABEL_BINDING (name)->u.label;
3095
3096   /* If the label has not yet been defined, then push this goto on a
3097      list for possible later warnings.  */
3098   if (label_vars->label_bindings.scope == NULL)
3099     {
3100       struct c_goto_bindings *g;
3101
3102       g = ggc_alloc_c_goto_bindings ();
3103       g->loc = loc;
3104       set_spot_bindings (&g->goto_bindings, true);
3105       VEC_safe_push (c_goto_bindings_p, gc, label_vars->gotos, g);
3106       return label;
3107     }
3108
3109   /* If there are any decls in label_vars->decls_in_scope, then this
3110      goto has missed the declaration of the decl.  This happens for a
3111      case like
3112        int i = 1;
3113       lab:
3114        ...
3115        goto lab;
3116      Issue a warning or error.  */
3117   FOR_EACH_VEC_ELT (tree, label_vars->decls_in_scope, ix, decl)
3118     warn_about_goto (loc, label, decl);
3119
3120   if (label_vars->label_bindings.left_stmt_expr)
3121     {
3122       error_at (loc, "jump into statement expression");
3123       inform (DECL_SOURCE_LOCATION (label), "label %qD defined here", label);
3124     }
3125
3126   return label;
3127 }
3128
3129 /* Make a label named NAME in the current function, shadowing silently
3130    any that may be inherited from containing functions or containing
3131    scopes.  This is called for __label__ declarations.  */
3132
3133 tree
3134 declare_label (tree name)
3135 {
3136   struct c_binding *b = I_LABEL_BINDING (name);
3137   tree label;
3138   struct c_label_vars *label_vars;
3139
3140   /* Check to make sure that the label hasn't already been declared
3141      at this scope */
3142   if (b && B_IN_CURRENT_SCOPE (b))
3143     {
3144       error ("duplicate label declaration %qE", name);
3145       locate_old_decl (b->decl);
3146
3147       /* Just use the previous declaration.  */
3148       return b->decl;
3149     }
3150
3151   label = make_label (input_location, name, false, &label_vars);
3152   C_DECLARED_LABEL_FLAG (label) = 1;
3153
3154   /* Declared labels go in the current scope.  */
3155   bind_label (name, label, current_scope, label_vars);
3156
3157   return label;
3158 }
3159
3160 /* When we define a label, issue any appropriate warnings if there are
3161    any gotos earlier in the function which jump to this label.  */
3162
3163 static void
3164 check_earlier_gotos (tree label, struct c_label_vars* label_vars)
3165 {
3166   unsigned int ix;
3167   struct c_goto_bindings *g;
3168
3169   FOR_EACH_VEC_ELT (c_goto_bindings_p, label_vars->gotos, ix, g)
3170     {
3171       struct c_binding *b;
3172       struct c_scope *scope;
3173
3174       /* We have a goto to this label.  The goto is going forward.  In
3175          g->scope, the goto is going to skip any binding which was
3176          defined after g->bindings_in_scope.  */
3177       for (b = g->goto_bindings.scope->bindings;
3178            b != g->goto_bindings.bindings_in_scope;
3179            b = b->prev)
3180         {
3181           if (decl_jump_unsafe (b->decl))
3182             warn_about_goto (g->loc, label, b->decl);
3183         }
3184
3185       /* We also need to warn about decls defined in any scopes
3186          between the scope of the label and the scope of the goto.  */
3187       for (scope = label_vars->label_bindings.scope;
3188            scope != g->goto_bindings.scope;
3189            scope = scope->outer)
3190         {
3191           gcc_assert (scope != NULL);
3192           if (scope == label_vars->label_bindings.scope)
3193             b = label_vars->label_bindings.bindings_in_scope;
3194           else
3195             b = scope->bindings;
3196           for (; b != NULL; b = b->prev)
3197             {
3198               if (decl_jump_unsafe (b->decl))
3199                 warn_about_goto (g->loc, label, b->decl);
3200             }
3201         }
3202
3203       if (g->goto_bindings.stmt_exprs > 0)
3204         {
3205           error_at (g->loc, "jump into statement expression");
3206           inform (DECL_SOURCE_LOCATION (label), "label %qD defined here",
3207                   label);
3208         }
3209     }
3210
3211   /* Now that the label is defined, we will issue warnings about
3212      subsequent gotos to this label when we see them.  */
3213   VEC_truncate (c_goto_bindings_p, label_vars->gotos, 0);
3214   label_vars->gotos = NULL;
3215 }
3216
3217 /* Define a label, specifying the location in the source file.
3218    Return the LABEL_DECL node for the label, if the definition is valid.
3219    Otherwise return 0.  */
3220
3221 tree
3222 define_label (location_t location, tree name)
3223 {
3224   /* Find any preexisting label with this name.  It is an error
3225      if that label has already been defined in this function, or
3226      if there is a containing function with a declared label with
3227      the same name.  */
3228   tree label = I_LABEL_DECL (name);
3229
3230   if (label
3231       && ((DECL_CONTEXT (label) == current_function_decl
3232            && DECL_INITIAL (label) != 0)
3233           || (DECL_CONTEXT (label) != current_function_decl
3234               && C_DECLARED_LABEL_FLAG (label))))
3235     {
3236       error_at (location, "duplicate label %qD", label);
3237       locate_old_decl (label);
3238       return 0;
3239     }
3240   else if (label && DECL_CONTEXT (label) == current_function_decl)
3241     {
3242       struct c_label_vars *label_vars = I_LABEL_BINDING (name)->u.label;
3243
3244       /* The label has been used or declared already in this function,
3245          but not defined.  Update its location to point to this
3246          definition.  */
3247       DECL_SOURCE_LOCATION (label) = location;
3248       set_spot_bindings (&label_vars->label_bindings, true);
3249
3250       /* Issue warnings as required about any goto statements from
3251          earlier in the function.  */
3252       check_earlier_gotos (label, label_vars);
3253     }
3254   else
3255     {
3256       struct c_label_vars *label_vars;
3257
3258       /* No label binding for that identifier; make one.  */
3259       label = make_label (location, name, true, &label_vars);
3260
3261       /* Ordinary labels go in the current function scope.  */
3262       bind_label (name, label, current_function_scope, label_vars);
3263     }
3264
3265   if (!in_system_header && lookup_name (name))
3266     warning_at (location, OPT_Wtraditional,
3267                 "traditional C lacks a separate namespace "
3268                 "for labels, identifier %qE conflicts", name);
3269
3270   /* Mark label as having been defined.  */
3271   DECL_INITIAL (label) = error_mark_node;
3272   return label;
3273 }
3274 \f
3275 /* Get the bindings for a new switch statement.  This is used to issue
3276    warnings as appropriate for jumps from the switch to case or
3277    default labels.  */
3278
3279 struct c_spot_bindings *
3280 c_get_switch_bindings (void)
3281 {
3282   struct c_spot_bindings *switch_bindings;
3283
3284   switch_bindings = XNEW (struct c_spot_bindings);
3285   set_spot_bindings (switch_bindings, true);
3286   return switch_bindings;
3287 }
3288
3289 void
3290 c_release_switch_bindings (struct c_spot_bindings *bindings)
3291 {
3292   gcc_assert (bindings->stmt_exprs == 0 && !bindings->left_stmt_expr);
3293   XDELETE (bindings);
3294 }
3295
3296 /* This is called at the point of a case or default label to issue
3297    warnings about decls as needed.  It returns true if it found an
3298    error, not just a warning.  */
3299
3300 bool
3301 c_check_switch_jump_warnings (struct c_spot_bindings *switch_bindings,
3302                               location_t switch_loc, location_t case_loc)
3303 {
3304   bool saw_error;
3305   struct c_scope *scope;
3306
3307   saw_error = false;
3308   for (scope = current_scope;
3309        scope != switch_bindings->scope;
3310        scope = scope->outer)
3311     {
3312       struct c_binding *b;
3313
3314       gcc_assert (scope != NULL);
3315       for (b = scope->bindings; b != NULL; b = b->prev)
3316         {
3317           if (decl_jump_unsafe (b->decl))
3318             {
3319               if (variably_modified_type_p (TREE_TYPE (b->decl), NULL_TREE))
3320                 {
3321                   saw_error = true;
3322                   error_at (case_loc,
3323                             ("switch jumps into scope of identifier with "
3324                              "variably modified type"));
3325                 }
3326               else
3327                 warning_at (case_loc, OPT_Wjump_misses_init,
3328                             "switch jumps over variable initialization");
3329               inform (switch_loc, "switch starts here");
3330               inform (DECL_SOURCE_LOCATION (b->decl), "%qD declared here",
3331                       b->decl);
3332             }
3333         }
3334     }
3335
3336   if (switch_bindings->stmt_exprs > 0)
3337     {
3338       saw_error = true;
3339       error_at (case_loc, "switch jumps into statement expression");
3340       inform (switch_loc, "switch starts here");
3341     }
3342
3343   return saw_error;
3344 }
3345 \f
3346 /* Given NAME, an IDENTIFIER_NODE,
3347    return the structure (or union or enum) definition for that name.
3348    If THISLEVEL_ONLY is nonzero, searches only the current_scope.
3349    CODE says which kind of type the caller wants;
3350    it is RECORD_TYPE or UNION_TYPE or ENUMERAL_TYPE.
3351    If PLOC is not NULL and this returns non-null, it sets *PLOC to the
3352    location where the tag was defined.
3353    If the wrong kind of type is found, an error is reported.  */
3354
3355 static tree
3356 lookup_tag (enum tree_code code, tree name, int thislevel_only,
3357             location_t *ploc)
3358 {
3359   struct c_binding *b = I_TAG_BINDING (name);
3360   int thislevel = 0;
3361
3362   if (!b || !b->decl)
3363     return 0;
3364
3365   /* We only care about whether it's in this level if
3366      thislevel_only was set or it might be a type clash.  */
3367   if (thislevel_only || TREE_CODE (b->decl) != code)
3368     {
3369       /* For our purposes, a tag in the external scope is the same as
3370          a tag in the file scope.  (Primarily relevant to Objective-C
3371          and its builtin structure tags, which get pushed before the
3372          file scope is created.)  */
3373       if (B_IN_CURRENT_SCOPE (b)
3374           || (current_scope == file_scope && B_IN_EXTERNAL_SCOPE (b)))
3375         thislevel = 1;
3376     }
3377
3378   if (thislevel_only && !thislevel)
3379     return 0;
3380
3381   if (TREE_CODE (b->decl) != code)
3382     {
3383       /* Definition isn't the kind we were looking for.  */
3384       pending_invalid_xref = name;
3385       pending_invalid_xref_location = input_location;
3386
3387       /* If in the same binding level as a declaration as a tag
3388          of a different type, this must not be allowed to
3389          shadow that tag, so give the error immediately.
3390          (For example, "struct foo; union foo;" is invalid.)  */
3391       if (thislevel)
3392         pending_xref_error ();
3393     }
3394
3395   if (ploc != NULL)
3396     *ploc = b->locus;
3397
3398   return b->decl;
3399 }
3400
3401 /* Print an error message now
3402    for a recent invalid struct, union or enum cross reference.
3403    We don't print them immediately because they are not invalid
3404    when used in the `struct foo;' construct for shadowing.  */
3405
3406 void
3407 pending_xref_error (void)
3408 {
3409   if (pending_invalid_xref != 0)
3410     error_at (pending_invalid_xref_location, "%qE defined as wrong kind of tag",
3411               pending_invalid_xref);
3412   pending_invalid_xref = 0;
3413 }
3414
3415 \f
3416 /* Look up NAME in the current scope and its superiors
3417    in the namespace of variables, functions and typedefs.
3418    Return a ..._DECL node of some kind representing its definition,
3419    or return 0 if it is undefined.  */
3420
3421 tree
3422 lookup_name (tree name)
3423 {
3424   struct c_binding *b = I_SYMBOL_BINDING (name);
3425   if (b && !b->invisible)
3426     return b->decl;
3427   return 0;
3428 }
3429
3430 /* Similar to `lookup_name' but look only at the indicated scope.  */
3431
3432 static tree
3433 lookup_name_in_scope (tree name, struct c_scope *scope)
3434 {
3435   struct c_binding *b;
3436
3437   for (b = I_SYMBOL_BINDING (name); b; b = b->shadowed)
3438     if (B_IN_SCOPE (b, scope))
3439       return b->decl;
3440   return 0;
3441 }
3442 \f
3443 /* Create the predefined scalar types of C,
3444    and some nodes representing standard constants (0, 1, (void *) 0).
3445    Initialize the global scope.
3446    Make definitions for built-in primitive functions.  */
3447
3448 void
3449 c_init_decl_processing (void)
3450 {
3451   location_t save_loc = input_location;
3452
3453   /* Initialize reserved words for parser.  */
3454   c_parse_init ();
3455
3456   current_function_decl = 0;
3457
3458   gcc_obstack_init (&parser_obstack);
3459
3460   /* Make the externals scope.  */
3461   push_scope ();
3462   external_scope = current_scope;
3463
3464   /* Declarations from c_common_nodes_and_builtins must not be associated
3465      with this input file, lest we get differences between using and not
3466      using preprocessed headers.  */
3467   input_location = BUILTINS_LOCATION;
3468
3469   build_common_tree_nodes (flag_signed_char);
3470
3471   c_common_nodes_and_builtins ();
3472
3473   /* In C, comparisons and TRUTH_* expressions have type int.  */
3474   truthvalue_type_node = integer_type_node;
3475   truthvalue_true_node = integer_one_node;
3476   truthvalue_false_node = integer_zero_node;
3477
3478   /* Even in C99, which has a real boolean type.  */
3479   pushdecl (build_decl (UNKNOWN_LOCATION, TYPE_DECL, get_identifier ("_Bool"),
3480                         boolean_type_node));
3481
3482   input_location = save_loc;
3483
3484   pedantic_lvalues = true;
3485
3486   make_fname_decl = c_make_fname_decl;
3487   start_fname_decls ();
3488 }
3489
3490 /* Create the&nb