OSDN Git Service

* c-decl.c: Don't include gimple.h.
[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 "rtl.h"
38 #include "flags.h"
39 #include "function.h"
40 #include "output.h"
41 #include "c-tree.h"
42 #include "toplev.h"
43 #include "tm_p.h"
44 #include "cpplib.h"
45 #include "target.h"
46 #include "debug.h"
47 #include "opts.h"
48 #include "timevar.h"
49 #include "c-common.h"
50 #include "c-pragma.h"
51 #include "c-lang.h"
52 #include "langhooks.h"
53 #include "tree-mudflap.h"
54 #include "tree-iterator.h"
55 #include "diagnostic.h"
56 #include "tree-dump.h"
57 #include "cgraph.h"
58 #include "hashtab.h"
59 #include "langhooks-def.h"
60 #include "pointer-set.h"
61 #include "plugin.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_NEW (struct 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_NEW (struct 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_CNEW (struct 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 (ix = 0;
1003                    VEC_iterate (c_goto_bindings_p, label_vars->gotos, ix, g);
1004                    ++ix)
1005                 update_spot_bindings (scope, &g->goto_bindings);
1006             }
1007         }
1008
1009       /* Don't search beyond the current function.  */
1010       if (s == current_function_scope)
1011         break;
1012
1013       s = s->outer;
1014     }
1015 }
1016
1017 /* Set the TYPE_CONTEXT of all of TYPE's variants to CONTEXT.  */
1018
1019 static void
1020 set_type_context (tree type, tree context)
1021 {
1022   for (type = TYPE_MAIN_VARIANT (type); type;
1023        type = TYPE_NEXT_VARIANT (type))
1024     TYPE_CONTEXT (type) = context;
1025 }
1026
1027 /* Exit a scope.  Restore the state of the identifier-decl mappings
1028    that were in effect when this scope was entered.  Return a BLOCK
1029    node containing all the DECLs in this scope that are of interest
1030    to debug info generation.  */
1031
1032 tree
1033 pop_scope (void)
1034 {
1035   struct c_scope *scope = current_scope;
1036   tree block, context, p;
1037   struct c_binding *b;
1038
1039   bool functionbody = scope->function_body;
1040   bool keep = functionbody || scope->keep || scope->bindings;
1041
1042   update_label_decls (scope);
1043
1044   /* If appropriate, create a BLOCK to record the decls for the life
1045      of this function.  */
1046   block = 0;
1047   if (keep)
1048     {
1049       block = make_node (BLOCK);
1050       BLOCK_SUBBLOCKS (block) = scope->blocks;
1051       TREE_USED (block) = 1;
1052
1053       /* In each subblock, record that this is its superior.  */
1054       for (p = scope->blocks; p; p = BLOCK_CHAIN (p))
1055         BLOCK_SUPERCONTEXT (p) = block;
1056
1057       BLOCK_VARS (block) = 0;
1058     }
1059
1060   /* The TYPE_CONTEXTs for all of the tagged types belonging to this
1061      scope must be set so that they point to the appropriate
1062      construct, i.e.  either to the current FUNCTION_DECL node, or
1063      else to the BLOCK node we just constructed.
1064
1065      Note that for tagged types whose scope is just the formal
1066      parameter list for some function type specification, we can't
1067      properly set their TYPE_CONTEXTs here, because we don't have a
1068      pointer to the appropriate FUNCTION_TYPE node readily available
1069      to us.  For those cases, the TYPE_CONTEXTs of the relevant tagged
1070      type nodes get set in `grokdeclarator' as soon as we have created
1071      the FUNCTION_TYPE node which will represent the "scope" for these
1072      "parameter list local" tagged types.  */
1073   if (scope->function_body)
1074     context = current_function_decl;
1075   else if (scope == file_scope)
1076     {
1077       tree file_decl = build_decl (UNKNOWN_LOCATION,
1078                                    TRANSLATION_UNIT_DECL, 0, 0);
1079       TREE_CHAIN (file_decl) = all_translation_units;
1080       all_translation_units = file_decl;
1081       context = file_decl;
1082     }
1083   else
1084     context = block;
1085
1086   /* Clear all bindings in this scope.  */
1087   for (b = scope->bindings; b; b = free_binding_and_advance (b))
1088     {
1089       p = b->decl;
1090       switch (TREE_CODE (p))
1091         {
1092         case LABEL_DECL:
1093           /* Warnings for unused labels, errors for undefined labels.  */
1094           if (TREE_USED (p) && !DECL_INITIAL (p))
1095             {
1096               error ("label %q+D used but not defined", p);
1097               DECL_INITIAL (p) = error_mark_node;
1098             }
1099           else
1100             warn_for_unused_label (p);
1101
1102           /* Labels go in BLOCK_VARS.  */
1103           TREE_CHAIN (p) = BLOCK_VARS (block);
1104           BLOCK_VARS (block) = p;
1105           gcc_assert (I_LABEL_BINDING (b->id) == b);
1106           I_LABEL_BINDING (b->id) = b->shadowed;
1107
1108           /* Also pop back to the shadowed label_vars.  */
1109           release_tree_vector (b->u.label->decls_in_scope);
1110           b->u.label = b->u.label->shadowed;
1111           break;
1112
1113         case ENUMERAL_TYPE:
1114         case UNION_TYPE:
1115         case RECORD_TYPE:
1116           set_type_context (p, context);
1117
1118           /* Types may not have tag-names, in which case the type
1119              appears in the bindings list with b->id NULL.  */
1120           if (b->id)
1121             {
1122               gcc_assert (I_TAG_BINDING (b->id) == b);
1123               I_TAG_BINDING (b->id) = b->shadowed;
1124             }
1125           break;
1126
1127         case FUNCTION_DECL:
1128           /* Propagate TREE_ADDRESSABLE from nested functions to their
1129              containing functions.  */
1130           if (!TREE_ASM_WRITTEN (p)
1131               && DECL_INITIAL (p) != 0
1132               && TREE_ADDRESSABLE (p)
1133               && DECL_ABSTRACT_ORIGIN (p) != 0
1134               && DECL_ABSTRACT_ORIGIN (p) != p)
1135             TREE_ADDRESSABLE (DECL_ABSTRACT_ORIGIN (p)) = 1;
1136           if (!DECL_EXTERNAL (p)
1137               && !DECL_INITIAL (p)
1138               && scope != file_scope
1139               && scope != external_scope)
1140             {
1141               error ("nested function %q+D declared but never defined", p);
1142               undef_nested_function = true;
1143             }
1144           else if (DECL_DECLARED_INLINE_P (p)
1145                    && TREE_PUBLIC (p)
1146                    && !DECL_INITIAL (p))
1147             {
1148               /* C99 6.7.4p6: "a function with external linkage... declared
1149                  with an inline function specifier ... shall also be defined
1150                  in the same translation unit."  */
1151               if (!flag_gnu89_inline)
1152                 pedwarn (input_location, 0,
1153                          "inline function %q+D declared but never defined", p);
1154               DECL_EXTERNAL (p) = 1;
1155             }
1156
1157           goto common_symbol;
1158
1159         case VAR_DECL:
1160           /* Warnings for unused variables.  */
1161           if ((!TREE_USED (p) || !DECL_READ_P (p))
1162               && !TREE_NO_WARNING (p)
1163               && !DECL_IN_SYSTEM_HEADER (p)
1164               && DECL_NAME (p)
1165               && !DECL_ARTIFICIAL (p)
1166               && scope != file_scope
1167               && scope != external_scope)
1168             {
1169               if (!TREE_USED (p))
1170                 warning (OPT_Wunused_variable, "unused variable %q+D", p);
1171               else if (DECL_CONTEXT (p) == current_function_decl)
1172                 warning_at (DECL_SOURCE_LOCATION (p),
1173                             OPT_Wunused_but_set_variable,
1174                             "variable %qD set but not used", p);
1175             }
1176
1177           if (b->inner_comp)
1178             {
1179               error ("type of array %q+D completed incompatibly with"
1180                      " implicit initialization", p);
1181             }
1182
1183           /* Fall through.  */
1184         case TYPE_DECL:
1185         case CONST_DECL:
1186         common_symbol:
1187           /* All of these go in BLOCK_VARS, but only if this is the
1188              binding in the home scope.  */
1189           if (!b->nested)
1190             {
1191               TREE_CHAIN (p) = BLOCK_VARS (block);
1192               BLOCK_VARS (block) = p;
1193             }
1194           else if (VAR_OR_FUNCTION_DECL_P (p))
1195             {
1196               /* For block local externs add a special
1197                  DECL_EXTERNAL decl for debug info generation.  */
1198               tree extp = copy_node (p);
1199
1200               DECL_EXTERNAL (extp) = 1;
1201               TREE_STATIC (extp) = 0;
1202               TREE_PUBLIC (extp) = 1;
1203               DECL_INITIAL (extp) = NULL_TREE;
1204               DECL_LANG_SPECIFIC (extp) = NULL;
1205               DECL_CONTEXT (extp) = current_function_decl;
1206               if (TREE_CODE (p) == FUNCTION_DECL)
1207                 {
1208                   DECL_RESULT (extp) = NULL_TREE;
1209                   DECL_SAVED_TREE (extp) = NULL_TREE;
1210                   DECL_STRUCT_FUNCTION (extp) = NULL;
1211                 }
1212               if (b->locus != UNKNOWN_LOCATION)
1213                 DECL_SOURCE_LOCATION (extp) = b->locus;
1214               TREE_CHAIN (extp) = BLOCK_VARS (block);
1215               BLOCK_VARS (block) = extp;
1216             }
1217           /* If this is the file scope, and we are processing more
1218              than one translation unit in this compilation, set
1219              DECL_CONTEXT of each decl to the TRANSLATION_UNIT_DECL.
1220              This makes same_translation_unit_p work, and causes
1221              static declarations to be given disambiguating suffixes.  */
1222           if (scope == file_scope && num_in_fnames > 1)
1223             {
1224               DECL_CONTEXT (p) = context;
1225               if (TREE_CODE (p) == TYPE_DECL)
1226                 set_type_context (TREE_TYPE (p), context);
1227             }
1228
1229           /* Fall through.  */
1230           /* Parameters go in DECL_ARGUMENTS, not BLOCK_VARS, and have
1231              already been put there by store_parm_decls.  Unused-
1232              parameter warnings are handled by function.c.
1233              error_mark_node obviously does not go in BLOCK_VARS and
1234              does not get unused-variable warnings.  */
1235         case PARM_DECL:
1236         case ERROR_MARK:
1237           /* It is possible for a decl not to have a name.  We get
1238              here with b->id NULL in this case.  */
1239           if (b->id)
1240             {
1241               gcc_assert (I_SYMBOL_BINDING (b->id) == b);
1242               I_SYMBOL_BINDING (b->id) = b->shadowed;
1243               if (b->shadowed && b->shadowed->u.type)
1244                 TREE_TYPE (b->shadowed->decl) = b->shadowed->u.type;
1245             }
1246           break;
1247
1248         default:
1249           gcc_unreachable ();
1250         }
1251     }
1252
1253
1254   /* Dispose of the block that we just made inside some higher level.  */
1255   if ((scope->function_body || scope == file_scope) && context)
1256     {
1257       DECL_INITIAL (context) = block;
1258       BLOCK_SUPERCONTEXT (block) = context;
1259     }
1260   else if (scope->outer)
1261     {
1262       if (block)
1263         SCOPE_LIST_APPEND (scope->outer, blocks, block);
1264       /* If we did not make a block for the scope just exited, any
1265          blocks made for inner scopes must be carried forward so they
1266          will later become subblocks of something else.  */
1267       else if (scope->blocks)
1268         SCOPE_LIST_CONCAT (scope->outer, blocks, scope, blocks);
1269     }
1270
1271   /* Pop the current scope, and free the structure for reuse.  */
1272   current_scope = scope->outer;
1273   if (scope->function_body)
1274     current_function_scope = scope->outer_function;
1275
1276   memset (scope, 0, sizeof (struct c_scope));
1277   scope->outer = scope_freelist;
1278   scope_freelist = scope;
1279
1280   return block;
1281 }
1282
1283 void
1284 push_file_scope (void)
1285 {
1286   tree decl;
1287
1288   if (file_scope)
1289     return;
1290
1291   push_scope ();
1292   file_scope = current_scope;
1293
1294   start_fname_decls ();
1295
1296   for (decl = visible_builtins; decl; decl = TREE_CHAIN (decl))
1297     bind (DECL_NAME (decl), decl, file_scope,
1298           /*invisible=*/false, /*nested=*/true, DECL_SOURCE_LOCATION (decl));
1299 }
1300
1301 void
1302 pop_file_scope (void)
1303 {
1304   /* In case there were missing closebraces, get us back to the global
1305      binding level.  */
1306   while (current_scope != file_scope)
1307     pop_scope ();
1308
1309   /* __FUNCTION__ is defined at file scope ("").  This
1310      call may not be necessary as my tests indicate it
1311      still works without it.  */
1312   finish_fname_decls ();
1313
1314   check_inline_statics ();
1315
1316   /* This is the point to write out a PCH if we're doing that.
1317      In that case we do not want to do anything else.  */
1318   if (pch_file)
1319     {
1320       c_common_write_pch ();
1321       return;
1322     }
1323
1324   /* Pop off the file scope and close this translation unit.  */
1325   pop_scope ();
1326   file_scope = 0;
1327
1328   maybe_apply_pending_pragma_weaks ();
1329 }
1330 \f
1331 /* Adjust the bindings for the start of a statement expression.  */
1332
1333 void
1334 c_bindings_start_stmt_expr (struct c_spot_bindings* switch_bindings)
1335 {
1336   struct c_scope *scope;
1337
1338   for (scope = current_scope; scope != NULL; scope = scope->outer)
1339     {
1340       struct c_binding *b;
1341
1342       if (!scope->has_label_bindings)
1343         continue;
1344
1345       for (b = scope->bindings; b != NULL; b = b->prev)
1346         {
1347           struct c_label_vars *label_vars;
1348           unsigned int ix;
1349           struct c_goto_bindings *g;
1350
1351           if (TREE_CODE (b->decl) != LABEL_DECL)
1352             continue;
1353           label_vars = b->u.label;
1354           ++label_vars->label_bindings.stmt_exprs;
1355           for (ix = 0;
1356                VEC_iterate (c_goto_bindings_p, label_vars->gotos, ix, g);
1357                ++ix)
1358             ++g->goto_bindings.stmt_exprs;
1359         }
1360     }
1361
1362   if (switch_bindings != NULL)
1363     ++switch_bindings->stmt_exprs;
1364 }
1365
1366 /* Adjust the bindings for the end of a statement expression.  */
1367
1368 void
1369 c_bindings_end_stmt_expr (struct c_spot_bindings *switch_bindings)
1370 {
1371   struct c_scope *scope;
1372
1373   for (scope = current_scope; scope != NULL; scope = scope->outer)
1374     {
1375       struct c_binding *b;
1376
1377       if (!scope->has_label_bindings)
1378         continue;
1379
1380       for (b = scope->bindings; b != NULL; b = b->prev)
1381         {
1382           struct c_label_vars *label_vars;
1383           unsigned int ix;
1384           struct c_goto_bindings *g;
1385
1386           if (TREE_CODE (b->decl) != LABEL_DECL)
1387             continue;
1388           label_vars = b->u.label;
1389           --label_vars->label_bindings.stmt_exprs;
1390           if (label_vars->label_bindings.stmt_exprs < 0)
1391             {
1392               label_vars->label_bindings.left_stmt_expr = true;
1393               label_vars->label_bindings.stmt_exprs = 0;
1394             }
1395           for (ix = 0;
1396                VEC_iterate (c_goto_bindings_p, label_vars->gotos, ix, g);
1397                ++ix)
1398             {
1399               --g->goto_bindings.stmt_exprs;
1400               if (g->goto_bindings.stmt_exprs < 0)
1401                 {
1402                   g->goto_bindings.left_stmt_expr = true;
1403                   g->goto_bindings.stmt_exprs = 0;
1404                 }
1405             }
1406         }
1407     }
1408
1409   if (switch_bindings != NULL)
1410     {
1411       --switch_bindings->stmt_exprs;
1412       gcc_assert (switch_bindings->stmt_exprs >= 0);
1413     }
1414 }
1415 \f
1416 /* Push a definition or a declaration of struct, union or enum tag "name".
1417    "type" should be the type node.
1418    We assume that the tag "name" is not already defined, and has a location
1419    of LOC.
1420
1421    Note that the definition may really be just a forward reference.
1422    In that case, the TYPE_SIZE will be zero.  */
1423
1424 static void
1425 pushtag (location_t loc, tree name, tree type)
1426 {
1427   /* Record the identifier as the type's name if it has none.  */
1428   if (name && !TYPE_NAME (type))
1429     TYPE_NAME (type) = name;
1430   bind (name, type, current_scope, /*invisible=*/false, /*nested=*/false, loc);
1431
1432   /* Create a fake NULL-named TYPE_DECL node whose TREE_TYPE will be the
1433      tagged type we just added to the current scope.  This fake
1434      NULL-named TYPE_DECL node helps dwarfout.c to know when it needs
1435      to output a representation of a tagged type, and it also gives
1436      us a convenient place to record the "scope start" address for the
1437      tagged type.  */
1438
1439   TYPE_STUB_DECL (type) = pushdecl (build_decl (loc,
1440                                                 TYPE_DECL, NULL_TREE, type));
1441
1442   /* An approximation for now, so we can tell this is a function-scope tag.
1443      This will be updated in pop_scope.  */
1444   TYPE_CONTEXT (type) = DECL_CONTEXT (TYPE_STUB_DECL (type));
1445
1446   if (warn_cxx_compat && name != NULL_TREE)
1447     {
1448       struct c_binding *b = I_SYMBOL_BINDING (name);
1449
1450       if (b != NULL
1451           && b->decl != NULL_TREE
1452           && TREE_CODE (b->decl) == TYPE_DECL
1453           && (B_IN_CURRENT_SCOPE (b)
1454               || (current_scope == file_scope && B_IN_EXTERNAL_SCOPE (b)))
1455           && (TYPE_MAIN_VARIANT (TREE_TYPE (b->decl))
1456               != TYPE_MAIN_VARIANT (type)))
1457         {
1458           warning_at (loc, OPT_Wc___compat,
1459                       ("using %qD as both a typedef and a tag is "
1460                        "invalid in C++"),
1461                       b->decl);
1462           if (b->locus != UNKNOWN_LOCATION)
1463             inform (b->locus, "originally defined here");
1464         }
1465     }
1466 }
1467 \f
1468 /* Subroutine of compare_decls.  Allow harmless mismatches in return
1469    and argument types provided that the type modes match.  This function
1470    return a unified type given a suitable match, and 0 otherwise.  */
1471
1472 static tree
1473 match_builtin_function_types (tree newtype, tree oldtype)
1474 {
1475   tree newrettype, oldrettype;
1476   tree newargs, oldargs;
1477   tree trytype, tryargs;
1478
1479   /* Accept the return type of the new declaration if same modes.  */
1480   oldrettype = TREE_TYPE (oldtype);
1481   newrettype = TREE_TYPE (newtype);
1482
1483   if (TYPE_MODE (oldrettype) != TYPE_MODE (newrettype))
1484     return 0;
1485
1486   oldargs = TYPE_ARG_TYPES (oldtype);
1487   newargs = TYPE_ARG_TYPES (newtype);
1488   tryargs = newargs;
1489
1490   while (oldargs || newargs)
1491     {
1492       if (!oldargs
1493           || !newargs
1494           || !TREE_VALUE (oldargs)
1495           || !TREE_VALUE (newargs)
1496           || TYPE_MODE (TREE_VALUE (oldargs))
1497              != TYPE_MODE (TREE_VALUE (newargs)))
1498         return 0;
1499
1500       oldargs = TREE_CHAIN (oldargs);
1501       newargs = TREE_CHAIN (newargs);
1502     }
1503
1504   trytype = build_function_type (newrettype, tryargs);
1505   return build_type_attribute_variant (trytype, TYPE_ATTRIBUTES (oldtype));
1506 }
1507
1508 /* Subroutine of diagnose_mismatched_decls.  Check for function type
1509    mismatch involving an empty arglist vs a nonempty one and give clearer
1510    diagnostics.  */
1511 static void
1512 diagnose_arglist_conflict (tree newdecl, tree olddecl,
1513                            tree newtype, tree oldtype)
1514 {
1515   tree t;
1516
1517   if (TREE_CODE (olddecl) != FUNCTION_DECL
1518       || !comptypes (TREE_TYPE (oldtype), TREE_TYPE (newtype))
1519       || !((TYPE_ARG_TYPES (oldtype) == 0 && DECL_INITIAL (olddecl) == 0)
1520            ||
1521            (TYPE_ARG_TYPES (newtype) == 0 && DECL_INITIAL (newdecl) == 0)))
1522     return;
1523
1524   t = TYPE_ARG_TYPES (oldtype);
1525   if (t == 0)
1526     t = TYPE_ARG_TYPES (newtype);
1527   for (; t; t = TREE_CHAIN (t))
1528     {
1529       tree type = TREE_VALUE (t);
1530
1531       if (TREE_CHAIN (t) == 0
1532           && TYPE_MAIN_VARIANT (type) != void_type_node)
1533         {
1534           inform (input_location, "a parameter list with an ellipsis can%'t match "
1535                   "an empty parameter name list declaration");
1536           break;
1537         }
1538
1539       if (c_type_promotes_to (type) != type)
1540         {
1541           inform (input_location, "an argument type that has a default promotion can%'t match "
1542                   "an empty parameter name list declaration");
1543           break;
1544         }
1545     }
1546 }
1547
1548 /* Another subroutine of diagnose_mismatched_decls.  OLDDECL is an
1549    old-style function definition, NEWDECL is a prototype declaration.
1550    Diagnose inconsistencies in the argument list.  Returns TRUE if
1551    the prototype is compatible, FALSE if not.  */
1552 static bool
1553 validate_proto_after_old_defn (tree newdecl, tree newtype, tree oldtype)
1554 {
1555   tree newargs, oldargs;
1556   int i;
1557
1558 #define END_OF_ARGLIST(t) ((t) == void_type_node)
1559
1560   oldargs = TYPE_ACTUAL_ARG_TYPES (oldtype);
1561   newargs = TYPE_ARG_TYPES (newtype);
1562   i = 1;
1563
1564   for (;;)
1565     {
1566       tree oldargtype = TREE_VALUE (oldargs);
1567       tree newargtype = TREE_VALUE (newargs);
1568
1569       if (oldargtype == error_mark_node || newargtype == error_mark_node)
1570         return false;
1571
1572       oldargtype = TYPE_MAIN_VARIANT (oldargtype);
1573       newargtype = TYPE_MAIN_VARIANT (newargtype);
1574
1575       if (END_OF_ARGLIST (oldargtype) && END_OF_ARGLIST (newargtype))
1576         break;
1577
1578       /* Reaching the end of just one list means the two decls don't
1579          agree on the number of arguments.  */
1580       if (END_OF_ARGLIST (oldargtype))
1581         {
1582           error ("prototype for %q+D declares more arguments "
1583                  "than previous old-style definition", newdecl);
1584           return false;
1585         }
1586       else if (END_OF_ARGLIST (newargtype))
1587         {
1588           error ("prototype for %q+D declares fewer arguments "
1589                  "than previous old-style definition", newdecl);
1590           return false;
1591         }
1592
1593       /* Type for passing arg must be consistent with that declared
1594          for the arg.  */
1595       else if (!comptypes (oldargtype, newargtype))
1596         {
1597           error ("prototype for %q+D declares argument %d"
1598                  " with incompatible type",
1599                  newdecl, i);
1600           return false;
1601         }
1602
1603       oldargs = TREE_CHAIN (oldargs);
1604       newargs = TREE_CHAIN (newargs);
1605       i++;
1606     }
1607
1608   /* If we get here, no errors were found, but do issue a warning
1609      for this poor-style construct.  */
1610   warning (0, "prototype for %q+D follows non-prototype definition",
1611            newdecl);
1612   return true;
1613 #undef END_OF_ARGLIST
1614 }
1615
1616 /* Subroutine of diagnose_mismatched_decls.  Report the location of DECL,
1617    first in a pair of mismatched declarations, using the diagnostic
1618    function DIAG.  */
1619 static void
1620 locate_old_decl (tree decl)
1621 {
1622   if (TREE_CODE (decl) == FUNCTION_DECL && DECL_BUILT_IN (decl))
1623     ;
1624   else if (DECL_INITIAL (decl))
1625     inform (input_location, "previous definition of %q+D was here", decl);
1626   else if (C_DECL_IMPLICIT (decl))
1627     inform (input_location, "previous implicit declaration of %q+D was here", decl);
1628   else
1629     inform (input_location, "previous declaration of %q+D was here", decl);
1630 }
1631
1632 /* Subroutine of duplicate_decls.  Compare NEWDECL to OLDDECL.
1633    Returns true if the caller should proceed to merge the two, false
1634    if OLDDECL should simply be discarded.  As a side effect, issues
1635    all necessary diagnostics for invalid or poor-style combinations.
1636    If it returns true, writes the types of NEWDECL and OLDDECL to
1637    *NEWTYPEP and *OLDTYPEP - these may have been adjusted from
1638    TREE_TYPE (NEWDECL, OLDDECL) respectively.  */
1639
1640 static bool
1641 diagnose_mismatched_decls (tree newdecl, tree olddecl,
1642                            tree *newtypep, tree *oldtypep)
1643 {
1644   tree newtype, oldtype;
1645   bool pedwarned = false;
1646   bool warned = false;
1647   bool retval = true;
1648
1649 #define DECL_EXTERN_INLINE(DECL) (DECL_DECLARED_INLINE_P (DECL)  \
1650                                   && DECL_EXTERNAL (DECL))
1651
1652   /* If we have error_mark_node for either decl or type, just discard
1653      the previous decl - we're in an error cascade already.  */
1654   if (olddecl == error_mark_node || newdecl == error_mark_node)
1655     return false;
1656   *oldtypep = oldtype = TREE_TYPE (olddecl);
1657   *newtypep = newtype = TREE_TYPE (newdecl);
1658   if (oldtype == error_mark_node || newtype == error_mark_node)
1659     return false;
1660
1661   /* Two different categories of symbol altogether.  This is an error
1662      unless OLDDECL is a builtin.  OLDDECL will be discarded in any case.  */
1663   if (TREE_CODE (olddecl) != TREE_CODE (newdecl))
1664     {
1665       if (!(TREE_CODE (olddecl) == FUNCTION_DECL
1666             && DECL_BUILT_IN (olddecl)
1667             && !C_DECL_DECLARED_BUILTIN (olddecl)))
1668         {
1669           error ("%q+D redeclared as different kind of symbol", newdecl);
1670           locate_old_decl (olddecl);
1671         }
1672       else if (TREE_PUBLIC (newdecl))
1673         warning (0, "built-in function %q+D declared as non-function",
1674                  newdecl);
1675       else
1676         warning (OPT_Wshadow, "declaration of %q+D shadows "
1677                  "a built-in function", newdecl);
1678       return false;
1679     }
1680
1681   /* Enumerators have no linkage, so may only be declared once in a
1682      given scope.  */
1683   if (TREE_CODE (olddecl) == CONST_DECL)
1684     {
1685       error ("redeclaration of enumerator %q+D", newdecl);
1686       locate_old_decl (olddecl);
1687       return false;
1688     }
1689
1690   if (!comptypes (oldtype, newtype))
1691     {
1692       if (TREE_CODE (olddecl) == FUNCTION_DECL
1693           && DECL_BUILT_IN (olddecl) && !C_DECL_DECLARED_BUILTIN (olddecl))
1694         {
1695           /* Accept harmless mismatch in function types.
1696              This is for the ffs and fprintf builtins.  */
1697           tree trytype = match_builtin_function_types (newtype, oldtype);
1698
1699           if (trytype && comptypes (newtype, trytype))
1700             *oldtypep = oldtype = trytype;
1701           else
1702             {
1703               /* If types don't match for a built-in, throw away the
1704                  built-in.  No point in calling locate_old_decl here, it
1705                  won't print anything.  */
1706               warning (0, "conflicting types for built-in function %q+D",
1707                        newdecl);
1708               return false;
1709             }
1710         }
1711       else if (TREE_CODE (olddecl) == FUNCTION_DECL
1712                && DECL_IS_BUILTIN (olddecl))
1713         {
1714           /* A conflicting function declaration for a predeclared
1715              function that isn't actually built in.  Objective C uses
1716              these.  The new declaration silently overrides everything
1717              but the volatility (i.e. noreturn) indication.  See also
1718              below.  FIXME: Make Objective C use normal builtins.  */
1719           TREE_THIS_VOLATILE (newdecl) |= TREE_THIS_VOLATILE (olddecl);
1720           return false;
1721         }
1722       /* Permit void foo (...) to match int foo (...) if the latter is
1723          the definition and implicit int was used.  See
1724          c-torture/compile/920625-2.c.  */
1725       else if (TREE_CODE (newdecl) == FUNCTION_DECL && DECL_INITIAL (newdecl)
1726                && TYPE_MAIN_VARIANT (TREE_TYPE (oldtype)) == void_type_node
1727                && TYPE_MAIN_VARIANT (TREE_TYPE (newtype)) == integer_type_node
1728                && C_FUNCTION_IMPLICIT_INT (newdecl) && !DECL_INITIAL (olddecl))
1729         {
1730           pedwarned = pedwarn (input_location, 0,
1731                                "conflicting types for %q+D", newdecl);
1732           /* Make sure we keep void as the return type.  */
1733           TREE_TYPE (newdecl) = *newtypep = newtype = oldtype;
1734           C_FUNCTION_IMPLICIT_INT (newdecl) = 0;
1735         }
1736       /* Permit void foo (...) to match an earlier call to foo (...) with
1737          no declared type (thus, implicitly int).  */
1738       else if (TREE_CODE (newdecl) == FUNCTION_DECL
1739                && TYPE_MAIN_VARIANT (TREE_TYPE (newtype)) == void_type_node
1740                && TYPE_MAIN_VARIANT (TREE_TYPE (oldtype)) == integer_type_node
1741                && C_DECL_IMPLICIT (olddecl) && !DECL_INITIAL (olddecl))
1742         {
1743           pedwarned = pedwarn (input_location, 0,
1744                                "conflicting types for %q+D", newdecl);
1745           /* Make sure we keep void as the return type.  */
1746           TREE_TYPE (olddecl) = *oldtypep = oldtype = newtype;
1747         }
1748       else
1749         {
1750           int new_quals = TYPE_QUALS (newtype);
1751           int old_quals = TYPE_QUALS (oldtype);
1752
1753           if (new_quals != old_quals)
1754             {
1755               addr_space_t new_addr = DECODE_QUAL_ADDR_SPACE (new_quals);
1756               addr_space_t old_addr = DECODE_QUAL_ADDR_SPACE (old_quals);
1757               if (new_addr != old_addr)
1758                 {
1759                   if (ADDR_SPACE_GENERIC_P (new_addr))
1760                     error ("conflicting named address spaces (generic vs %s) "
1761                            "for %q+D",
1762                            c_addr_space_name (old_addr), newdecl);
1763                   else if (ADDR_SPACE_GENERIC_P (old_addr))
1764                     error ("conflicting named address spaces (%s vs generic) "
1765                            "for %q+D",
1766                            c_addr_space_name (new_addr), newdecl);
1767                   else
1768                     error ("conflicting named address spaces (%s vs %s) "
1769                            "for %q+D",
1770                            c_addr_space_name (new_addr),
1771                            c_addr_space_name (old_addr),
1772                            newdecl);
1773                 }
1774
1775               if (CLEAR_QUAL_ADDR_SPACE (new_quals)
1776                   != CLEAR_QUAL_ADDR_SPACE (old_quals))
1777                 error ("conflicting type qualifiers for %q+D", newdecl);
1778             }
1779           else
1780             error ("conflicting types for %q+D", newdecl);
1781           diagnose_arglist_conflict (newdecl, olddecl, newtype, oldtype);
1782           locate_old_decl (olddecl);
1783           return false;
1784         }
1785     }
1786
1787   /* Redeclaration of a type is a constraint violation (6.7.2.3p1),
1788      but silently ignore the redeclaration if either is in a system
1789      header.  (Conflicting redeclarations were handled above.)  */
1790   if (TREE_CODE (newdecl) == TYPE_DECL)
1791     {
1792       if (DECL_IN_SYSTEM_HEADER (newdecl)
1793           || DECL_IN_SYSTEM_HEADER (olddecl)
1794           || TREE_NO_WARNING (newdecl)
1795           || TREE_NO_WARNING (olddecl))
1796         return true;  /* Allow OLDDECL to continue in use.  */
1797
1798       error ("redefinition of typedef %q+D", newdecl);
1799       locate_old_decl (olddecl);
1800       return false;
1801     }
1802
1803   /* Function declarations can either be 'static' or 'extern' (no
1804      qualifier is equivalent to 'extern' - C99 6.2.2p5) and therefore
1805      can never conflict with each other on account of linkage
1806      (6.2.2p4).  Multiple definitions are not allowed (6.9p3,5) but
1807      gnu89 mode permits two definitions if one is 'extern inline' and
1808      one is not.  The non- extern-inline definition supersedes the
1809      extern-inline definition.  */
1810
1811   else if (TREE_CODE (newdecl) == FUNCTION_DECL)
1812     {
1813       /* If you declare a built-in function name as static, or
1814          define the built-in with an old-style definition (so we
1815          can't validate the argument list) the built-in definition is
1816          overridden, but optionally warn this was a bad choice of name.  */
1817       if (DECL_BUILT_IN (olddecl)
1818           && !C_DECL_DECLARED_BUILTIN (olddecl)
1819           && (!TREE_PUBLIC (newdecl)
1820               || (DECL_INITIAL (newdecl)
1821                   && !TYPE_ARG_TYPES (TREE_TYPE (newdecl)))))
1822         {
1823           warning (OPT_Wshadow, "declaration of %q+D shadows "
1824                    "a built-in function", newdecl);
1825           /* Discard the old built-in function.  */
1826           return false;
1827         }
1828
1829       if (DECL_INITIAL (newdecl))
1830         {
1831           if (DECL_INITIAL (olddecl))
1832             {
1833               /* If both decls are in the same TU and the new declaration
1834                  isn't overriding an extern inline reject the new decl.
1835                  In c99, no overriding is allowed in the same translation
1836                  unit.  */
1837               if ((!DECL_EXTERN_INLINE (olddecl)
1838                    || DECL_EXTERN_INLINE (newdecl)
1839                    || (!flag_gnu89_inline
1840                        && (!DECL_DECLARED_INLINE_P (olddecl)
1841                            || !lookup_attribute ("gnu_inline",
1842                                                  DECL_ATTRIBUTES (olddecl)))
1843                        && (!DECL_DECLARED_INLINE_P (newdecl)
1844                            || !lookup_attribute ("gnu_inline",
1845                                                  DECL_ATTRIBUTES (newdecl))))
1846                   )
1847                   && same_translation_unit_p (newdecl, olddecl))
1848                 {
1849                   error ("redefinition of %q+D", newdecl);
1850                   locate_old_decl (olddecl);
1851                   return false;
1852                 }
1853             }
1854         }
1855       /* If we have a prototype after an old-style function definition,
1856          the argument types must be checked specially.  */
1857       else if (DECL_INITIAL (olddecl)
1858                && !TYPE_ARG_TYPES (oldtype) && TYPE_ARG_TYPES (newtype)
1859                && TYPE_ACTUAL_ARG_TYPES (oldtype)
1860                && !validate_proto_after_old_defn (newdecl, newtype, oldtype))
1861         {
1862           locate_old_decl (olddecl);
1863           return false;
1864         }
1865       /* A non-static declaration (even an "extern") followed by a
1866          static declaration is undefined behavior per C99 6.2.2p3-5,7.
1867          The same is true for a static forward declaration at block
1868          scope followed by a non-static declaration/definition at file
1869          scope.  Static followed by non-static at the same scope is
1870          not undefined behavior, and is the most convenient way to get
1871          some effects (see e.g.  what unwind-dw2-fde-glibc.c does to
1872          the definition of _Unwind_Find_FDE in unwind-dw2-fde.c), but
1873          we do diagnose it if -Wtraditional.  */
1874       if (TREE_PUBLIC (olddecl) && !TREE_PUBLIC (newdecl))
1875         {
1876           /* Two exceptions to the rule.  If olddecl is an extern
1877              inline, or a predeclared function that isn't actually
1878              built in, newdecl silently overrides olddecl.  The latter
1879              occur only in Objective C; see also above.  (FIXME: Make
1880              Objective C use normal builtins.)  */
1881           if (!DECL_IS_BUILTIN (olddecl)
1882               && !DECL_EXTERN_INLINE (olddecl))
1883             {
1884               error ("static declaration of %q+D follows "
1885                      "non-static declaration", newdecl);
1886               locate_old_decl (olddecl);
1887             }
1888           return false;
1889         }
1890       else if (TREE_PUBLIC (newdecl) && !TREE_PUBLIC (olddecl))
1891         {
1892           if (DECL_CONTEXT (olddecl))
1893             {
1894               error ("non-static declaration of %q+D follows "
1895                      "static declaration", newdecl);
1896               locate_old_decl (olddecl);
1897               return false;
1898             }
1899           else if (warn_traditional)
1900             {
1901               warned |= warning (OPT_Wtraditional,
1902                                  "non-static declaration of %q+D "
1903                                  "follows static declaration", newdecl);
1904             }
1905         }
1906
1907       /* Make sure gnu_inline attribute is either not present, or
1908          present on all inline decls.  */
1909       if (DECL_DECLARED_INLINE_P (olddecl)
1910           && DECL_DECLARED_INLINE_P (newdecl))
1911         {
1912           bool newa = lookup_attribute ("gnu_inline",
1913                                         DECL_ATTRIBUTES (newdecl)) != NULL;
1914           bool olda = lookup_attribute ("gnu_inline",
1915                                         DECL_ATTRIBUTES (olddecl)) != NULL;
1916           if (newa != olda)
1917             {
1918               error_at (input_location, "%<gnu_inline%> attribute present on %q+D",
1919                         newa ? newdecl : olddecl);
1920               error_at (DECL_SOURCE_LOCATION (newa ? olddecl : newdecl),
1921                         "but not here");
1922             }
1923         }
1924     }
1925   else if (TREE_CODE (newdecl) == VAR_DECL)
1926     {
1927       /* Only variables can be thread-local, and all declarations must
1928          agree on this property.  */
1929       if (C_DECL_THREADPRIVATE_P (olddecl) && !DECL_THREAD_LOCAL_P (newdecl))
1930         {
1931           /* Nothing to check.  Since OLDDECL is marked threadprivate
1932              and NEWDECL does not have a thread-local attribute, we
1933              will merge the threadprivate attribute into NEWDECL.  */
1934           ;
1935         }
1936       else if (DECL_THREAD_LOCAL_P (newdecl) != DECL_THREAD_LOCAL_P (olddecl))
1937         {
1938           if (DECL_THREAD_LOCAL_P (newdecl))
1939             error ("thread-local declaration of %q+D follows "
1940                    "non-thread-local declaration", newdecl);
1941           else
1942             error ("non-thread-local declaration of %q+D follows "
1943                    "thread-local declaration", newdecl);
1944
1945           locate_old_decl (olddecl);
1946           return false;
1947         }
1948
1949       /* Multiple initialized definitions are not allowed (6.9p3,5).  */
1950       if (DECL_INITIAL (newdecl) && DECL_INITIAL (olddecl))
1951         {
1952           error ("redefinition of %q+D", newdecl);
1953           locate_old_decl (olddecl);
1954           return false;
1955         }
1956
1957       /* Objects declared at file scope: if the first declaration had
1958          external linkage (even if it was an external reference) the
1959          second must have external linkage as well, or the behavior is
1960          undefined.  If the first declaration had internal linkage, then
1961          the second must too, or else be an external reference (in which
1962          case the composite declaration still has internal linkage).
1963          As for function declarations, we warn about the static-then-
1964          extern case only for -Wtraditional.  See generally 6.2.2p3-5,7.  */
1965       if (DECL_FILE_SCOPE_P (newdecl)
1966           && TREE_PUBLIC (newdecl) != TREE_PUBLIC (olddecl))
1967         {
1968           if (DECL_EXTERNAL (newdecl))
1969             {
1970               if (!DECL_FILE_SCOPE_P (olddecl))
1971                 {
1972                   error ("extern declaration of %q+D follows "
1973                          "declaration with no linkage", newdecl);
1974                   locate_old_decl (olddecl);
1975                   return false;
1976                 }
1977               else if (warn_traditional)
1978                 {
1979                   warned |= warning (OPT_Wtraditional,
1980                                      "non-static declaration of %q+D "
1981                                      "follows static declaration", newdecl);
1982                 }
1983             }
1984           else
1985             {
1986               if (TREE_PUBLIC (newdecl))
1987                 error ("non-static declaration of %q+D follows "
1988                        "static declaration", newdecl);
1989               else
1990                 error ("static declaration of %q+D follows "
1991                        "non-static declaration", newdecl);
1992
1993               locate_old_decl (olddecl);
1994               return false;
1995             }
1996         }
1997       /* Two objects with the same name declared at the same block
1998          scope must both be external references (6.7p3).  */
1999       else if (!DECL_FILE_SCOPE_P (newdecl))
2000         {
2001           if (DECL_EXTERNAL (newdecl))
2002             {
2003               /* Extern with initializer at block scope, which will
2004                  already have received an error.  */
2005             }
2006           else if (DECL_EXTERNAL (olddecl))
2007             {
2008               error ("declaration of %q+D with no linkage follows "
2009                      "extern declaration", newdecl);
2010               locate_old_decl (olddecl);
2011             }
2012           else
2013             {
2014               error ("redeclaration of %q+D with no linkage", newdecl);
2015               locate_old_decl (olddecl);
2016             }
2017
2018           return false;
2019         }
2020
2021       /* C++ does not permit a decl to appear multiple times at file
2022          scope.  */
2023       if (warn_cxx_compat
2024           && DECL_FILE_SCOPE_P (newdecl)
2025           && !DECL_EXTERNAL (newdecl)
2026           && !DECL_EXTERNAL (olddecl))
2027         warned |= warning_at (DECL_SOURCE_LOCATION (newdecl),
2028                               OPT_Wc___compat,
2029                               ("duplicate declaration of %qD is "
2030                                "invalid in C++"),
2031                               newdecl);
2032     }
2033
2034   /* warnings */
2035   /* All decls must agree on a visibility.  */
2036   if (CODE_CONTAINS_STRUCT (TREE_CODE (newdecl), TS_DECL_WITH_VIS)
2037       && DECL_VISIBILITY_SPECIFIED (newdecl) && DECL_VISIBILITY_SPECIFIED (olddecl)
2038       && DECL_VISIBILITY (newdecl) != DECL_VISIBILITY (olddecl))
2039     {
2040       warned |= warning (0, "redeclaration of %q+D with different visibility "
2041                          "(old visibility preserved)", newdecl);
2042     }
2043
2044   if (TREE_CODE (newdecl) == FUNCTION_DECL)
2045     {
2046       /* Diagnose inline __attribute__ ((noinline)) which is silly.  */
2047       if (DECL_DECLARED_INLINE_P (newdecl)
2048           && lookup_attribute ("noinline", DECL_ATTRIBUTES (olddecl)))
2049         {
2050           warned |= warning (OPT_Wattributes,
2051                              "inline declaration of %qD follows "
2052                              "declaration with attribute noinline", newdecl);
2053         }
2054       else if (DECL_DECLARED_INLINE_P (olddecl)
2055                && lookup_attribute ("noinline", DECL_ATTRIBUTES (newdecl)))
2056         {
2057           warned |= warning (OPT_Wattributes,
2058                              "declaration of %q+D with attribute "
2059                              "noinline follows inline declaration ", newdecl);
2060         }
2061     }
2062   else /* PARM_DECL, VAR_DECL */
2063     {
2064       /* Redeclaration of a parameter is a constraint violation (this is
2065          not explicitly stated, but follows from C99 6.7p3 [no more than
2066          one declaration of the same identifier with no linkage in the
2067          same scope, except type tags] and 6.2.2p6 [parameters have no
2068          linkage]).  We must check for a forward parameter declaration,
2069          indicated by TREE_ASM_WRITTEN on the old declaration - this is
2070          an extension, the mandatory diagnostic for which is handled by
2071          mark_forward_parm_decls.  */
2072
2073       if (TREE_CODE (newdecl) == PARM_DECL
2074           && (!TREE_ASM_WRITTEN (olddecl) || TREE_ASM_WRITTEN (newdecl)))
2075         {
2076           error ("redefinition of parameter %q+D", newdecl);
2077           locate_old_decl (olddecl);
2078           return false;
2079         }
2080     }
2081
2082   /* Optional warning for completely redundant decls.  */
2083   if (!warned && !pedwarned
2084       && warn_redundant_decls
2085       /* Don't warn about a function declaration followed by a
2086          definition.  */
2087       && !(TREE_CODE (newdecl) == FUNCTION_DECL
2088            && DECL_INITIAL (newdecl) && !DECL_INITIAL (olddecl))
2089       /* Don't warn about redundant redeclarations of builtins.  */
2090       && !(TREE_CODE (newdecl) == FUNCTION_DECL
2091            && !DECL_BUILT_IN (newdecl)
2092            && DECL_BUILT_IN (olddecl)
2093            && !C_DECL_DECLARED_BUILTIN (olddecl))
2094       /* Don't warn about an extern followed by a definition.  */
2095       && !(DECL_EXTERNAL (olddecl) && !DECL_EXTERNAL (newdecl))
2096       /* Don't warn about forward parameter decls.  */
2097       && !(TREE_CODE (newdecl) == PARM_DECL
2098            && TREE_ASM_WRITTEN (olddecl) && !TREE_ASM_WRITTEN (newdecl))
2099       /* Don't warn about a variable definition following a declaration.  */
2100       && !(TREE_CODE (newdecl) == VAR_DECL
2101            && DECL_INITIAL (newdecl) && !DECL_INITIAL (olddecl)))
2102     {
2103       warned = warning (OPT_Wredundant_decls, "redundant redeclaration of %q+D",
2104                         newdecl);
2105     }
2106
2107   /* Report location of previous decl/defn.  */
2108   if (warned || pedwarned)
2109     locate_old_decl (olddecl);
2110
2111 #undef DECL_EXTERN_INLINE
2112
2113   return retval;
2114 }
2115
2116 /* Subroutine of duplicate_decls.  NEWDECL has been found to be
2117    consistent with OLDDECL, but carries new information.  Merge the
2118    new information into OLDDECL.  This function issues no
2119    diagnostics.  */
2120
2121 static void
2122 merge_decls (tree newdecl, tree olddecl, tree newtype, tree oldtype)
2123 {
2124   bool new_is_definition = (TREE_CODE (newdecl) == FUNCTION_DECL
2125                             && DECL_INITIAL (newdecl) != 0);
2126   bool new_is_prototype = (TREE_CODE (newdecl) == FUNCTION_DECL
2127                            && TYPE_ARG_TYPES (TREE_TYPE (newdecl)) != 0);
2128   bool old_is_prototype = (TREE_CODE (olddecl) == FUNCTION_DECL
2129                            && TYPE_ARG_TYPES (TREE_TYPE (olddecl)) != 0);
2130   bool extern_changed = false;
2131
2132   /* For real parm decl following a forward decl, rechain the old decl
2133      in its new location and clear TREE_ASM_WRITTEN (it's not a
2134      forward decl anymore).  */
2135   if (TREE_CODE (newdecl) == PARM_DECL
2136       && TREE_ASM_WRITTEN (olddecl) && !TREE_ASM_WRITTEN (newdecl))
2137     {
2138       struct c_binding *b, **here;
2139
2140       for (here = &current_scope->bindings; *here; here = &(*here)->prev)
2141         if ((*here)->decl == olddecl)
2142           goto found;
2143       gcc_unreachable ();
2144
2145     found:
2146       b = *here;
2147       *here = b->prev;
2148       b->prev = current_scope->bindings;
2149       current_scope->bindings = b;
2150
2151       TREE_ASM_WRITTEN (olddecl) = 0;
2152     }
2153
2154   DECL_ATTRIBUTES (newdecl)
2155     = targetm.merge_decl_attributes (olddecl, newdecl);
2156
2157   /* Merge the data types specified in the two decls.  */
2158   TREE_TYPE (newdecl)
2159     = TREE_TYPE (olddecl)
2160     = composite_type (newtype, oldtype);
2161
2162   /* Lay the type out, unless already done.  */
2163   if (!comptypes (oldtype, TREE_TYPE (newdecl)))
2164     {
2165       if (TREE_TYPE (newdecl) != error_mark_node)
2166         layout_type (TREE_TYPE (newdecl));
2167       if (TREE_CODE (newdecl) != FUNCTION_DECL
2168           && TREE_CODE (newdecl) != TYPE_DECL
2169           && TREE_CODE (newdecl) != CONST_DECL)
2170         layout_decl (newdecl, 0);
2171     }
2172   else
2173     {
2174       /* Since the type is OLDDECL's, make OLDDECL's size go with.  */
2175       DECL_SIZE (newdecl) = DECL_SIZE (olddecl);
2176       DECL_SIZE_UNIT (newdecl) = DECL_SIZE_UNIT (olddecl);
2177       DECL_MODE (newdecl) = DECL_MODE (olddecl);
2178       if (DECL_ALIGN (olddecl) > DECL_ALIGN (newdecl))
2179         {
2180           DECL_ALIGN (newdecl) = DECL_ALIGN (olddecl);
2181           DECL_USER_ALIGN (newdecl) |= DECL_USER_ALIGN (olddecl);
2182         }
2183     }
2184
2185   /* Keep the old rtl since we can safely use it.  */
2186   if (HAS_RTL_P (olddecl))
2187     COPY_DECL_RTL (olddecl, newdecl);
2188
2189   /* Merge the type qualifiers.  */
2190   if (TREE_READONLY (newdecl))
2191     TREE_READONLY (olddecl) = 1;
2192
2193   if (TREE_THIS_VOLATILE (newdecl))
2194     TREE_THIS_VOLATILE (olddecl) = 1;
2195
2196   /* Merge deprecatedness.  */
2197   if (TREE_DEPRECATED (newdecl))
2198     TREE_DEPRECATED (olddecl) = 1;
2199
2200   /* If a decl is in a system header and the other isn't, keep the one on the
2201      system header. Otherwise, keep source location of definition rather than
2202      declaration and of prototype rather than non-prototype unless that
2203      prototype is built-in.  */
2204   if (CODE_CONTAINS_STRUCT (TREE_CODE (olddecl), TS_DECL_WITH_VIS)
2205       && DECL_IN_SYSTEM_HEADER (olddecl)
2206       && !DECL_IN_SYSTEM_HEADER (newdecl) )
2207     DECL_SOURCE_LOCATION (newdecl) = DECL_SOURCE_LOCATION (olddecl);
2208   else if (CODE_CONTAINS_STRUCT (TREE_CODE (olddecl), TS_DECL_WITH_VIS)
2209            && DECL_IN_SYSTEM_HEADER (newdecl)
2210            && !DECL_IN_SYSTEM_HEADER (olddecl))
2211     DECL_SOURCE_LOCATION (olddecl) = DECL_SOURCE_LOCATION (newdecl);
2212   else if ((DECL_INITIAL (newdecl) == 0 && DECL_INITIAL (olddecl) != 0)
2213            || (old_is_prototype && !new_is_prototype
2214                && !C_DECL_BUILTIN_PROTOTYPE (olddecl)))
2215     DECL_SOURCE_LOCATION (newdecl) = DECL_SOURCE_LOCATION (olddecl);
2216
2217   /* Merge the initialization information.  */
2218    if (DECL_INITIAL (newdecl) == 0)
2219     DECL_INITIAL (newdecl) = DECL_INITIAL (olddecl);
2220
2221   /* Merge the threadprivate attribute.  */
2222   if (TREE_CODE (olddecl) == VAR_DECL && C_DECL_THREADPRIVATE_P (olddecl))
2223     {
2224       DECL_TLS_MODEL (newdecl) = DECL_TLS_MODEL (olddecl);
2225       C_DECL_THREADPRIVATE_P (newdecl) = 1;
2226     }
2227
2228   if (CODE_CONTAINS_STRUCT (TREE_CODE (olddecl), TS_DECL_WITH_VIS))
2229     {
2230       /* Merge the section attribute.
2231          We want to issue an error if the sections conflict but that
2232          must be done later in decl_attributes since we are called
2233          before attributes are assigned.  */
2234       if (DECL_SECTION_NAME (newdecl) == NULL_TREE)
2235         DECL_SECTION_NAME (newdecl) = DECL_SECTION_NAME (olddecl);
2236
2237       /* Copy the assembler name.
2238          Currently, it can only be defined in the prototype.  */
2239       COPY_DECL_ASSEMBLER_NAME (olddecl, newdecl);
2240
2241       /* Use visibility of whichever declaration had it specified */
2242       if (DECL_VISIBILITY_SPECIFIED (olddecl))
2243         {
2244           DECL_VISIBILITY (newdecl) = DECL_VISIBILITY (olddecl);
2245           DECL_VISIBILITY_SPECIFIED (newdecl) = 1;
2246         }
2247
2248       if (TREE_CODE (newdecl) == FUNCTION_DECL)
2249         {
2250           DECL_STATIC_CONSTRUCTOR(newdecl) |= DECL_STATIC_CONSTRUCTOR(olddecl);
2251           DECL_STATIC_DESTRUCTOR (newdecl) |= DECL_STATIC_DESTRUCTOR (olddecl);
2252           DECL_NO_LIMIT_STACK (newdecl) |= DECL_NO_LIMIT_STACK (olddecl);
2253           DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (newdecl)
2254             |= DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (olddecl);
2255           TREE_THIS_VOLATILE (newdecl) |= TREE_THIS_VOLATILE (olddecl);
2256           DECL_IS_MALLOC (newdecl) |= DECL_IS_MALLOC (olddecl);
2257           DECL_IS_OPERATOR_NEW (newdecl) |= DECL_IS_OPERATOR_NEW (olddecl);
2258           TREE_READONLY (newdecl) |= TREE_READONLY (olddecl);
2259           DECL_PURE_P (newdecl) |= DECL_PURE_P (olddecl);
2260           DECL_IS_NOVOPS (newdecl) |= DECL_IS_NOVOPS (olddecl);
2261         }
2262
2263       /* Merge the storage class information.  */
2264       merge_weak (newdecl, olddecl);
2265
2266       /* For functions, static overrides non-static.  */
2267       if (TREE_CODE (newdecl) == FUNCTION_DECL)
2268         {
2269           TREE_PUBLIC (newdecl) &= TREE_PUBLIC (olddecl);
2270           /* This is since we don't automatically
2271              copy the attributes of NEWDECL into OLDDECL.  */
2272           TREE_PUBLIC (olddecl) = TREE_PUBLIC (newdecl);
2273           /* If this clears `static', clear it in the identifier too.  */
2274           if (!TREE_PUBLIC (olddecl))
2275             TREE_PUBLIC (DECL_NAME (olddecl)) = 0;
2276         }
2277     }
2278
2279   /* In c99, 'extern' declaration before (or after) 'inline' means this
2280      function is not DECL_EXTERNAL, unless 'gnu_inline' attribute
2281      is present.  */
2282   if (TREE_CODE (newdecl) == FUNCTION_DECL
2283       && !flag_gnu89_inline
2284       && (DECL_DECLARED_INLINE_P (newdecl)
2285           || DECL_DECLARED_INLINE_P (olddecl))
2286       && (!DECL_DECLARED_INLINE_P (newdecl)
2287           || !DECL_DECLARED_INLINE_P (olddecl)
2288           || !DECL_EXTERNAL (olddecl))
2289       && DECL_EXTERNAL (newdecl)
2290       && !lookup_attribute ("gnu_inline", DECL_ATTRIBUTES (newdecl))
2291       && !current_function_decl)
2292     DECL_EXTERNAL (newdecl) = 0;
2293
2294   if (DECL_EXTERNAL (newdecl))
2295     {
2296       TREE_STATIC (newdecl) = TREE_STATIC (olddecl);
2297       DECL_EXTERNAL (newdecl) = DECL_EXTERNAL (olddecl);
2298
2299       /* An extern decl does not override previous storage class.  */
2300       TREE_PUBLIC (newdecl) = TREE_PUBLIC (olddecl);
2301       if (!DECL_EXTERNAL (newdecl))
2302         {
2303           DECL_CONTEXT (newdecl) = DECL_CONTEXT (olddecl);
2304           DECL_COMMON (newdecl) = DECL_COMMON (olddecl);
2305         }
2306     }
2307   else
2308     {
2309       TREE_STATIC (olddecl) = TREE_STATIC (newdecl);
2310       TREE_PUBLIC (olddecl) = TREE_PUBLIC (newdecl);
2311     }
2312
2313   if (TREE_CODE (newdecl) == FUNCTION_DECL)
2314     {
2315       /* If we're redefining a function previously defined as extern
2316          inline, make sure we emit debug info for the inline before we
2317          throw it away, in case it was inlined into a function that
2318          hasn't been written out yet.  */
2319       if (new_is_definition && DECL_INITIAL (olddecl))
2320         /* The new defn must not be inline.  */
2321         DECL_UNINLINABLE (newdecl) = 1;
2322       else
2323         {
2324           /* If either decl says `inline', this fn is inline, unless
2325              its definition was passed already.  */
2326           if (DECL_DECLARED_INLINE_P (newdecl)
2327               || DECL_DECLARED_INLINE_P (olddecl))
2328             DECL_DECLARED_INLINE_P (newdecl) = 1;
2329
2330           DECL_UNINLINABLE (newdecl) = DECL_UNINLINABLE (olddecl)
2331             = (DECL_UNINLINABLE (newdecl) || DECL_UNINLINABLE (olddecl));
2332
2333           DECL_DISREGARD_INLINE_LIMITS (newdecl)
2334             = DECL_DISREGARD_INLINE_LIMITS (olddecl)
2335             = (DECL_DISREGARD_INLINE_LIMITS (newdecl)
2336                || DECL_DISREGARD_INLINE_LIMITS (olddecl));
2337         }
2338
2339       if (DECL_BUILT_IN (olddecl))
2340         {
2341           /* If redeclaring a builtin function, it stays built in.
2342              But it gets tagged as having been declared.  */
2343           DECL_BUILT_IN_CLASS (newdecl) = DECL_BUILT_IN_CLASS (olddecl);
2344           DECL_FUNCTION_CODE (newdecl) = DECL_FUNCTION_CODE (olddecl);
2345           C_DECL_DECLARED_BUILTIN (newdecl) = 1;
2346           if (new_is_prototype)
2347             C_DECL_BUILTIN_PROTOTYPE (newdecl) = 0;
2348           else
2349             C_DECL_BUILTIN_PROTOTYPE (newdecl)
2350               = C_DECL_BUILTIN_PROTOTYPE (olddecl);
2351         }
2352
2353       /* Preserve function specific target and optimization options */
2354       if (DECL_FUNCTION_SPECIFIC_TARGET (olddecl)
2355           && !DECL_FUNCTION_SPECIFIC_TARGET (newdecl))
2356         DECL_FUNCTION_SPECIFIC_TARGET (newdecl)
2357           = DECL_FUNCTION_SPECIFIC_TARGET (olddecl);
2358
2359       if (DECL_FUNCTION_SPECIFIC_OPTIMIZATION (olddecl)
2360           && !DECL_FUNCTION_SPECIFIC_OPTIMIZATION (newdecl))
2361         DECL_FUNCTION_SPECIFIC_OPTIMIZATION (newdecl)
2362           = DECL_FUNCTION_SPECIFIC_OPTIMIZATION (olddecl);
2363
2364       /* Also preserve various other info from the definition.  */
2365       if (!new_is_definition)
2366         {
2367           tree t;
2368           DECL_RESULT (newdecl) = DECL_RESULT (olddecl);
2369           DECL_INITIAL (newdecl) = DECL_INITIAL (olddecl);
2370           DECL_STRUCT_FUNCTION (newdecl) = DECL_STRUCT_FUNCTION (olddecl);
2371           DECL_SAVED_TREE (newdecl) = DECL_SAVED_TREE (olddecl);
2372           DECL_ARGUMENTS (newdecl) = copy_list (DECL_ARGUMENTS (olddecl));
2373           for (t = DECL_ARGUMENTS (newdecl); t ; t = TREE_CHAIN (t))
2374             DECL_CONTEXT (t) = newdecl;
2375
2376           /* See if we've got a function to instantiate from.  */
2377           if (DECL_SAVED_TREE (olddecl))
2378             DECL_ABSTRACT_ORIGIN (newdecl)
2379               = DECL_ABSTRACT_ORIGIN (olddecl);
2380         }
2381     }
2382
2383   extern_changed = DECL_EXTERNAL (olddecl) && !DECL_EXTERNAL (newdecl);
2384
2385   /* Merge the USED information.  */
2386   if (TREE_USED (olddecl))
2387     TREE_USED (newdecl) = 1;
2388   else if (TREE_USED (newdecl))
2389     TREE_USED (olddecl) = 1;
2390   if (TREE_CODE (olddecl) == VAR_DECL || TREE_CODE (olddecl) == PARM_DECL)
2391     DECL_READ_P (newdecl) |= DECL_READ_P (olddecl);
2392   if (DECL_PRESERVE_P (olddecl))
2393     DECL_PRESERVE_P (newdecl) = 1;
2394   else if (DECL_PRESERVE_P (newdecl))
2395     DECL_PRESERVE_P (olddecl) = 1;
2396
2397   /* Copy most of the decl-specific fields of NEWDECL into OLDDECL.
2398      But preserve OLDDECL's DECL_UID, DECL_CONTEXT and
2399      DECL_ARGUMENTS (if appropriate).  */
2400   {
2401     unsigned olddecl_uid = DECL_UID (olddecl);
2402     tree olddecl_context = DECL_CONTEXT (olddecl);
2403     tree olddecl_arguments = NULL;
2404     if (TREE_CODE (olddecl) == FUNCTION_DECL)
2405       olddecl_arguments = DECL_ARGUMENTS (olddecl);
2406
2407     memcpy ((char *) olddecl + sizeof (struct tree_common),
2408             (char *) newdecl + sizeof (struct tree_common),
2409             sizeof (struct tree_decl_common) - sizeof (struct tree_common));
2410     switch (TREE_CODE (olddecl))
2411       {
2412       case FUNCTION_DECL:
2413       case FIELD_DECL:
2414       case VAR_DECL:
2415       case PARM_DECL:
2416       case LABEL_DECL:
2417       case RESULT_DECL:
2418       case CONST_DECL:
2419       case TYPE_DECL:
2420         memcpy ((char *) olddecl + sizeof (struct tree_decl_common),
2421                 (char *) newdecl + sizeof (struct tree_decl_common),
2422                 tree_code_size (TREE_CODE (olddecl)) - sizeof (struct tree_decl_common));
2423         break;
2424
2425       default:
2426
2427         memcpy ((char *) olddecl + sizeof (struct tree_decl_common),
2428                 (char *) newdecl + sizeof (struct tree_decl_common),
2429                 sizeof (struct tree_decl_non_common) - sizeof (struct tree_decl_common));
2430       }
2431     DECL_UID (olddecl) = olddecl_uid;
2432     DECL_CONTEXT (olddecl) = olddecl_context;
2433     if (TREE_CODE (olddecl) == FUNCTION_DECL)
2434       DECL_ARGUMENTS (olddecl) = olddecl_arguments;
2435   }
2436
2437   /* If OLDDECL had its DECL_RTL instantiated, re-invoke make_decl_rtl
2438      so that encode_section_info has a chance to look at the new decl
2439      flags and attributes.  */
2440   if (DECL_RTL_SET_P (olddecl)
2441       && (TREE_CODE (olddecl) == FUNCTION_DECL
2442           || (TREE_CODE (olddecl) == VAR_DECL
2443               && TREE_STATIC (olddecl))))
2444     make_decl_rtl (olddecl);
2445
2446   /* If we changed a function from DECL_EXTERNAL to !DECL_EXTERNAL,
2447      and the definition is coming from the old version, cgraph needs
2448      to be called again.  */
2449   if (extern_changed && !new_is_definition
2450       && TREE_CODE (olddecl) == FUNCTION_DECL && DECL_INITIAL (olddecl))
2451     cgraph_mark_if_needed (olddecl);
2452 }
2453
2454 /* Handle when a new declaration NEWDECL has the same name as an old
2455    one OLDDECL in the same binding contour.  Prints an error message
2456    if appropriate.
2457
2458    If safely possible, alter OLDDECL to look like NEWDECL, and return
2459    true.  Otherwise, return false.  */
2460
2461 static bool
2462 duplicate_decls (tree newdecl, tree olddecl)
2463 {
2464   tree newtype = NULL, oldtype = NULL;
2465
2466   if (!diagnose_mismatched_decls (newdecl, olddecl, &newtype, &oldtype))
2467     {
2468       /* Avoid `unused variable' and other warnings for OLDDECL.  */
2469       TREE_NO_WARNING (olddecl) = 1;
2470       return false;
2471     }
2472
2473   merge_decls (newdecl, olddecl, newtype, oldtype);
2474   return true;
2475 }
2476
2477 \f
2478 /* Check whether decl-node NEW_DECL shadows an existing declaration.  */
2479 static void
2480 warn_if_shadowing (tree new_decl)
2481 {
2482   struct c_binding *b;
2483
2484   /* Shadow warnings wanted?  */
2485   if (!warn_shadow
2486       /* No shadow warnings for internally generated vars.  */
2487       || DECL_IS_BUILTIN (new_decl)
2488       /* No shadow warnings for vars made for inlining.  */
2489       || DECL_FROM_INLINE (new_decl))
2490     return;
2491
2492   /* Is anything being shadowed?  Invisible decls do not count.  */
2493   for (b = I_SYMBOL_BINDING (DECL_NAME (new_decl)); b; b = b->shadowed)
2494     if (b->decl && b->decl != new_decl && !b->invisible)
2495       {
2496         tree old_decl = b->decl;
2497
2498         if (old_decl == error_mark_node)
2499           {
2500             warning (OPT_Wshadow, "declaration of %q+D shadows previous "
2501                      "non-variable", new_decl);
2502             break;
2503           }
2504         else if (TREE_CODE (old_decl) == PARM_DECL)
2505           warning (OPT_Wshadow, "declaration of %q+D shadows a parameter",
2506                    new_decl);
2507         else if (DECL_FILE_SCOPE_P (old_decl))
2508           warning (OPT_Wshadow, "declaration of %q+D shadows a global "
2509                    "declaration", new_decl);
2510         else if (TREE_CODE (old_decl) == FUNCTION_DECL
2511                  && DECL_BUILT_IN (old_decl))
2512           {
2513             warning (OPT_Wshadow, "declaration of %q+D shadows "
2514                      "a built-in function", new_decl);
2515             break;
2516           }
2517         else
2518           warning (OPT_Wshadow, "declaration of %q+D shadows a previous local",
2519                    new_decl);
2520
2521         warning_at (DECL_SOURCE_LOCATION (old_decl), OPT_Wshadow,
2522                     "shadowed declaration is here");
2523
2524         break;
2525       }
2526 }
2527
2528 /* Record a decl-node X as belonging to the current lexical scope.
2529    Check for errors (such as an incompatible declaration for the same
2530    name already seen in the same scope).
2531
2532    Returns either X or an old decl for the same name.
2533    If an old decl is returned, it may have been smashed
2534    to agree with what X says.  */
2535
2536 tree
2537 pushdecl (tree x)
2538 {
2539   tree name = DECL_NAME (x);
2540   struct c_scope *scope = current_scope;
2541   struct c_binding *b;
2542   bool nested = false;
2543   location_t locus = DECL_SOURCE_LOCATION (x);
2544
2545   /* Must set DECL_CONTEXT for everything not at file scope or
2546      DECL_FILE_SCOPE_P won't work.  Local externs don't count
2547      unless they have initializers (which generate code).  */
2548   if (current_function_decl
2549       && ((TREE_CODE (x) != FUNCTION_DECL && TREE_CODE (x) != VAR_DECL)
2550           || DECL_INITIAL (x) || !DECL_EXTERNAL (x)))
2551     DECL_CONTEXT (x) = current_function_decl;
2552
2553   /* Anonymous decls are just inserted in the scope.  */
2554   if (!name)
2555     {
2556       bind (name, x, scope, /*invisible=*/false, /*nested=*/false,
2557             locus);
2558       return x;
2559     }
2560
2561   /* First, see if there is another declaration with the same name in
2562      the current scope.  If there is, duplicate_decls may do all the
2563      work for us.  If duplicate_decls returns false, that indicates
2564      two incompatible decls in the same scope; we are to silently
2565      replace the old one (duplicate_decls has issued all appropriate
2566      diagnostics).  In particular, we should not consider possible
2567      duplicates in the external scope, or shadowing.  */
2568   b = I_SYMBOL_BINDING (name);
2569   if (b && B_IN_SCOPE (b, scope))
2570     {
2571       struct c_binding *b_ext, *b_use;
2572       tree type = TREE_TYPE (x);
2573       tree visdecl = b->decl;
2574       tree vistype = TREE_TYPE (visdecl);
2575       if (TREE_CODE (TREE_TYPE (x)) == ARRAY_TYPE
2576           && COMPLETE_TYPE_P (TREE_TYPE (x)))
2577         b->inner_comp = false;
2578       b_use = b;
2579       b_ext = b;
2580       /* If this is an external linkage declaration, we should check
2581          for compatibility with the type in the external scope before
2582          setting the type at this scope based on the visible
2583          information only.  */
2584       if (TREE_PUBLIC (x) && TREE_PUBLIC (visdecl))
2585         {
2586           while (b_ext && !B_IN_EXTERNAL_SCOPE (b_ext))
2587             b_ext = b_ext->shadowed;
2588           if (b_ext)
2589             {
2590               b_use = b_ext;
2591               if (b_use->u.type)
2592                 TREE_TYPE (b_use->decl) = b_use->u.type;
2593             }
2594         }
2595       if (duplicate_decls (x, b_use->decl))
2596         {
2597           if (b_use != b)
2598             {
2599               /* Save the updated type in the external scope and
2600                  restore the proper type for this scope.  */
2601               tree thistype;
2602               if (comptypes (vistype, type))
2603                 thistype = composite_type (vistype, type);
2604               else
2605                 thistype = TREE_TYPE (b_use->decl);
2606               b_use->u.type = TREE_TYPE (b_use->decl);
2607               if (TREE_CODE (b_use->decl) == FUNCTION_DECL
2608                   && DECL_BUILT_IN (b_use->decl))
2609                 thistype
2610                   = build_type_attribute_variant (thistype,
2611                                                   TYPE_ATTRIBUTES
2612                                                   (b_use->u.type));
2613               TREE_TYPE (b_use->decl) = thistype;
2614             }
2615           return b_use->decl;
2616         }
2617       else
2618         goto skip_external_and_shadow_checks;
2619     }
2620
2621   /* All declarations with external linkage, and all external
2622      references, go in the external scope, no matter what scope is
2623      current.  However, the binding in that scope is ignored for
2624      purposes of normal name lookup.  A separate binding structure is
2625      created in the requested scope; this governs the normal
2626      visibility of the symbol.
2627
2628      The binding in the externals scope is used exclusively for
2629      detecting duplicate declarations of the same object, no matter
2630      what scope they are in; this is what we do here.  (C99 6.2.7p2:
2631      All declarations that refer to the same object or function shall
2632      have compatible type; otherwise, the behavior is undefined.)  */
2633   if (DECL_EXTERNAL (x) || scope == file_scope)
2634     {
2635       tree type = TREE_TYPE (x);
2636       tree vistype = 0;
2637       tree visdecl = 0;
2638       bool type_saved = false;
2639       if (b && !B_IN_EXTERNAL_SCOPE (b)
2640           && (TREE_CODE (b->decl) == FUNCTION_DECL
2641               || TREE_CODE (b->decl) == VAR_DECL)
2642           && DECL_FILE_SCOPE_P (b->decl))
2643         {
2644           visdecl = b->decl;
2645           vistype = TREE_TYPE (visdecl);
2646         }
2647       if (scope != file_scope
2648           && !DECL_IN_SYSTEM_HEADER (x))
2649         warning (OPT_Wnested_externs, "nested extern declaration of %qD", x);
2650
2651       while (b && !B_IN_EXTERNAL_SCOPE (b))
2652         {
2653           /* If this decl might be modified, save its type.  This is
2654              done here rather than when the decl is first bound
2655              because the type may change after first binding, through
2656              being completed or through attributes being added.  If we
2657              encounter multiple such decls, only the first should have
2658              its type saved; the others will already have had their
2659              proper types saved and the types will not have changed as
2660              their scopes will not have been re-entered.  */
2661           if (DECL_P (b->decl) && DECL_FILE_SCOPE_P (b->decl) && !type_saved)
2662             {
2663               b->u.type = TREE_TYPE (b->decl);
2664               type_saved = true;
2665             }
2666           if (B_IN_FILE_SCOPE (b)
2667               && TREE_CODE (b->decl) == VAR_DECL
2668               && TREE_STATIC (b->decl)
2669               && TREE_CODE (TREE_TYPE (b->decl)) == ARRAY_TYPE
2670               && !TYPE_DOMAIN (TREE_TYPE (b->decl))
2671               && TREE_CODE (type) == ARRAY_TYPE
2672               && TYPE_DOMAIN (type)
2673               && TYPE_MAX_VALUE (TYPE_DOMAIN (type))
2674               && !integer_zerop (TYPE_MAX_VALUE (TYPE_DOMAIN (type))))
2675             {
2676               /* Array type completed in inner scope, which should be
2677                  diagnosed if the completion does not have size 1 and
2678                  it does not get completed in the file scope.  */
2679               b->inner_comp = true;
2680             }
2681           b = b->shadowed;
2682         }
2683
2684       /* If a matching external declaration has been found, set its
2685          type to the composite of all the types of that declaration.
2686          After the consistency checks, it will be reset to the
2687          composite of the visible types only.  */
2688       if (b && (TREE_PUBLIC (x) || same_translation_unit_p (x, b->decl))
2689           && b->u.type)
2690         TREE_TYPE (b->decl) = b->u.type;
2691
2692       /* The point of the same_translation_unit_p check here is,
2693          we want to detect a duplicate decl for a construct like
2694          foo() { extern bar(); } ... static bar();  but not if
2695          they are in different translation units.  In any case,
2696          the static does not go in the externals scope.  */
2697       if (b
2698           && (TREE_PUBLIC (x) || same_translation_unit_p (x, b->decl))
2699           && duplicate_decls (x, b->decl))
2700         {
2701           tree thistype;
2702           if (vistype)
2703             {
2704               if (comptypes (vistype, type))
2705                 thistype = composite_type (vistype, type);
2706               else
2707                 thistype = TREE_TYPE (b->decl);
2708             }
2709           else
2710             thistype = type;
2711           b->u.type = TREE_TYPE (b->decl);
2712           if (TREE_CODE (b->decl) == FUNCTION_DECL && DECL_BUILT_IN (b->decl))
2713             thistype
2714               = build_type_attribute_variant (thistype,
2715                                               TYPE_ATTRIBUTES (b->u.type));
2716           TREE_TYPE (b->decl) = thistype;
2717           bind (name, b->decl, scope, /*invisible=*/false, /*nested=*/true,
2718                 locus);
2719           return b->decl;
2720         }
2721       else if (TREE_PUBLIC (x))
2722         {
2723           if (visdecl && !b && duplicate_decls (x, visdecl))
2724             {
2725               /* An external declaration at block scope referring to a
2726                  visible entity with internal linkage.  The composite
2727                  type will already be correct for this scope, so we
2728                  just need to fall through to make the declaration in
2729                  this scope.  */
2730               nested = true;
2731               x = visdecl;
2732             }
2733           else
2734             {
2735               bind (name, x, external_scope, /*invisible=*/true,
2736                     /*nested=*/false, locus);
2737               nested = true;
2738             }
2739         }
2740     }
2741
2742   if (TREE_CODE (x) != PARM_DECL)
2743     warn_if_shadowing (x);
2744
2745  skip_external_and_shadow_checks:
2746   if (TREE_CODE (x) == TYPE_DECL)
2747     set_underlying_type (x);
2748
2749   bind (name, x, scope, /*invisible=*/false, nested, locus);
2750
2751   /* If x's type is incomplete because it's based on a
2752      structure or union which has not yet been fully declared,
2753      attach it to that structure or union type, so we can go
2754      back and complete the variable declaration later, if the
2755      structure or union gets fully declared.
2756
2757      If the input is erroneous, we can have error_mark in the type
2758      slot (e.g. "f(void a, ...)") - that doesn't count as an
2759      incomplete type.  */
2760   if (TREE_TYPE (x) != error_mark_node
2761       && !COMPLETE_TYPE_P (TREE_TYPE (x)))
2762     {
2763       tree element = TREE_TYPE (x);
2764
2765       while (TREE_CODE (element) == ARRAY_TYPE)
2766         element = TREE_TYPE (element);
2767       element = TYPE_MAIN_VARIANT (element);
2768
2769       if ((TREE_CODE (element) == RECORD_TYPE
2770            || TREE_CODE (element) == UNION_TYPE)
2771           && (TREE_CODE (x) != TYPE_DECL
2772               || TREE_CODE (TREE_TYPE (x)) == ARRAY_TYPE)
2773           && !COMPLETE_TYPE_P (element))
2774         C_TYPE_INCOMPLETE_VARS (element)
2775           = tree_cons (NULL_TREE, x, C_TYPE_INCOMPLETE_VARS (element));
2776     }
2777   return x;
2778 }
2779
2780 /* Record X as belonging to file scope.
2781    This is used only internally by the Objective-C front end,
2782    and is limited to its needs.  duplicate_decls is not called;
2783    if there is any preexisting decl for this identifier, it is an ICE.  */
2784
2785 tree
2786 pushdecl_top_level (tree x)
2787 {
2788   tree name;
2789   bool nested = false;
2790   gcc_assert (TREE_CODE (x) == VAR_DECL || TREE_CODE (x) == CONST_DECL);
2791
2792   name = DECL_NAME (x);
2793
2794  gcc_assert (TREE_CODE (x) == CONST_DECL || !I_SYMBOL_BINDING (name));
2795
2796   if (TREE_PUBLIC (x))
2797     {
2798       bind (name, x, external_scope, /*invisible=*/true, /*nested=*/false,
2799             UNKNOWN_LOCATION);
2800       nested = true;
2801     }
2802   if (file_scope)
2803     bind (name, x, file_scope, /*invisible=*/false, nested, UNKNOWN_LOCATION);
2804
2805   return x;
2806 }
2807 \f
2808 static void
2809 implicit_decl_warning (tree id, tree olddecl)
2810 {
2811   if (warn_implicit_function_declaration)
2812     {
2813       bool warned;
2814
2815       if (flag_isoc99)
2816         warned = pedwarn (input_location, OPT_Wimplicit_function_declaration,
2817                           "implicit declaration of function %qE", id);
2818       else
2819         warned = warning (OPT_Wimplicit_function_declaration,
2820                           G_("implicit declaration of function %qE"), id);
2821       if (olddecl && warned)
2822         locate_old_decl (olddecl);
2823     }
2824 }
2825
2826 /* Generate an implicit declaration for identifier FUNCTIONID at LOC as a
2827    function of type int ().  */
2828
2829 tree
2830 implicitly_declare (location_t loc, tree functionid)
2831 {
2832   struct c_binding *b;
2833   tree decl = 0;
2834   tree asmspec_tree;
2835
2836   for (b = I_SYMBOL_BINDING (functionid); b; b = b->shadowed)
2837     {
2838       if (B_IN_SCOPE (b, external_scope))
2839         {
2840           decl = b->decl;
2841           break;
2842         }
2843     }
2844
2845   if (decl)
2846     {
2847       if (decl == error_mark_node)
2848         return decl;
2849
2850       /* FIXME: Objective-C has weird not-really-builtin functions
2851          which are supposed to be visible automatically.  They wind up
2852          in the external scope because they're pushed before the file
2853          scope gets created.  Catch this here and rebind them into the
2854          file scope.  */
2855       if (!DECL_BUILT_IN (decl) && DECL_IS_BUILTIN (decl))
2856         {
2857           bind (functionid, decl, file_scope,
2858                 /*invisible=*/false, /*nested=*/true,
2859                 DECL_SOURCE_LOCATION (decl));
2860           return decl;
2861         }
2862       else
2863         {
2864           tree newtype = default_function_type;
2865           if (b->u.type)
2866             TREE_TYPE (decl) = b->u.type;
2867           /* Implicit declaration of a function already declared
2868              (somehow) in a different scope, or as a built-in.
2869              If this is the first time this has happened, warn;
2870              then recycle the old declaration but with the new type.  */
2871           if (!C_DECL_IMPLICIT (decl))
2872             {
2873               implicit_decl_warning (functionid, decl);
2874               C_DECL_IMPLICIT (decl) = 1;
2875             }
2876           if (DECL_BUILT_IN (decl))
2877             {
2878               newtype = build_type_attribute_variant (newtype,
2879                                                       TYPE_ATTRIBUTES
2880                                                       (TREE_TYPE (decl)));
2881               if (!comptypes (newtype, TREE_TYPE (decl)))
2882                 {
2883                   warning_at (loc, 0, "incompatible implicit declaration of "
2884                               "built-in function %qD", decl);
2885                   newtype = TREE_TYPE (decl);
2886                 }
2887             }
2888           else
2889             {
2890               if (!comptypes (newtype, TREE_TYPE (decl)))
2891                 {
2892                   error_at (loc, "incompatible implicit declaration of function %qD", decl);
2893                   locate_old_decl (decl);
2894                 }
2895             }
2896           b->u.type = TREE_TYPE (decl);
2897           TREE_TYPE (decl) = newtype;
2898           bind (functionid, decl, current_scope,
2899                 /*invisible=*/false, /*nested=*/true,
2900                 DECL_SOURCE_LOCATION (decl));
2901           return decl;
2902         }
2903     }
2904
2905   /* Not seen before.  */
2906   decl = build_decl (loc, FUNCTION_DECL, functionid, default_function_type);
2907   DECL_EXTERNAL (decl) = 1;
2908   TREE_PUBLIC (decl) = 1;
2909   C_DECL_IMPLICIT (decl) = 1;
2910   implicit_decl_warning (functionid, 0);
2911   asmspec_tree = maybe_apply_renaming_pragma (decl, /*asmname=*/NULL);
2912   if (asmspec_tree)
2913     set_user_assembler_name (decl, TREE_STRING_POINTER (asmspec_tree));
2914
2915   /* C89 says implicit declarations are in the innermost block.
2916      So we record the decl in the standard fashion.  */
2917   decl = pushdecl (decl);
2918
2919   /* No need to call objc_check_decl here - it's a function type.  */
2920   rest_of_decl_compilation (decl, 0, 0);
2921
2922   /* Write a record describing this implicit function declaration
2923      to the prototypes file (if requested).  */
2924   gen_aux_info_record (decl, 0, 1, 0);
2925
2926   /* Possibly apply some default attributes to this implicit declaration.  */
2927   decl_attributes (&decl, NULL_TREE, 0);
2928
2929   return decl;
2930 }
2931
2932 /* Issue an error message for a reference to an undeclared variable
2933    ID, including a reference to a builtin outside of function-call
2934    context.  Establish a binding of the identifier to error_mark_node
2935    in an appropriate scope, which will suppress further errors for the
2936    same identifier.  The error message should be given location LOC.  */
2937 void
2938 undeclared_variable (location_t loc, tree id)
2939 {
2940   static bool already = false;
2941   struct c_scope *scope;
2942
2943   if (current_function_decl == 0)
2944     {
2945       error_at (loc, "%qE undeclared here (not in a function)", id);
2946       scope = current_scope;
2947     }
2948   else
2949     {
2950       error_at (loc, "%qE undeclared (first use in this function)", id);
2951       if (!already)
2952         {
2953           inform (loc, "each undeclared identifier is reported only"
2954                   " once for each function it appears in");
2955           already = true;
2956         }
2957
2958       /* If we are parsing old-style parameter decls, current_function_decl
2959          will be nonnull but current_function_scope will be null.  */
2960       scope = current_function_scope ? current_function_scope : current_scope;
2961     }
2962   bind (id, error_mark_node, scope, /*invisible=*/false, /*nested=*/false,
2963         UNKNOWN_LOCATION);
2964 }
2965 \f
2966 /* Subroutine of lookup_label, declare_label, define_label: construct a
2967    LABEL_DECL with all the proper frills.  Also create a struct
2968    c_label_vars initialized for the current scope.  */
2969
2970 static tree
2971 make_label (location_t location, tree name, bool defining,
2972             struct c_label_vars **p_label_vars)
2973 {
2974   tree label = build_decl (location, LABEL_DECL, name, void_type_node);
2975   struct c_label_vars *label_vars;
2976
2977   DECL_CONTEXT (label) = current_function_decl;
2978   DECL_MODE (label) = VOIDmode;
2979
2980   label_vars = GGC_NEW (struct c_label_vars);
2981   label_vars->shadowed = NULL;
2982   set_spot_bindings (&label_vars->label_bindings, defining);
2983   label_vars->decls_in_scope = make_tree_vector ();
2984   label_vars->gotos = VEC_alloc (c_goto_bindings_p, gc, 0);
2985   *p_label_vars = label_vars;
2986
2987   return label;
2988 }
2989
2990 /* Get the LABEL_DECL corresponding to identifier NAME as a label.
2991    Create one if none exists so far for the current function.
2992    This is called when a label is used in a goto expression or
2993    has its address taken.  */
2994
2995 tree
2996 lookup_label (tree name)
2997 {
2998   tree label;
2999   struct c_label_vars *label_vars;
3000
3001   if (current_function_decl == 0)
3002     {
3003       error ("label %qE referenced outside of any function", name);
3004       return 0;
3005     }
3006
3007   /* Use a label already defined or ref'd with this name, but not if
3008      it is inherited from a containing function and wasn't declared
3009      using __label__.  */
3010   label = I_LABEL_DECL (name);
3011   if (label && (DECL_CONTEXT (label) == current_function_decl
3012                 || C_DECLARED_LABEL_FLAG (label)))
3013     {
3014       /* If the label has only been declared, update its apparent
3015          location to point here, for better diagnostics if it
3016          turns out not to have been defined.  */
3017       if (DECL_INITIAL (label) == NULL_TREE)
3018         DECL_SOURCE_LOCATION (label) = input_location;
3019       return label;
3020     }
3021
3022   /* No label binding for that identifier; make one.  */
3023   label = make_label (input_location, name, false, &label_vars);
3024
3025   /* Ordinary labels go in the current function scope.  */
3026   bind_label (name, label, current_function_scope, label_vars);
3027
3028   return label;
3029 }
3030
3031 /* Issue a warning about DECL for a goto statement at GOTO_LOC going
3032    to LABEL.  */
3033
3034 static void
3035 warn_about_goto (location_t goto_loc, tree label, tree decl)
3036 {
3037   if (variably_modified_type_p (TREE_TYPE (decl), NULL_TREE))
3038     error_at (goto_loc,
3039               "jump into scope of identifier with variably modified type");
3040   else
3041     warning_at (goto_loc, OPT_Wjump_misses_init,
3042                 "jump skips variable initialization");
3043   inform (DECL_SOURCE_LOCATION (label), "label %qD defined here", label);
3044   inform (DECL_SOURCE_LOCATION (decl), "%qD declared here", decl);
3045 }
3046
3047 /* Look up a label because of a goto statement.  This is like
3048    lookup_label, but also issues any appropriate warnings.  */
3049
3050 tree
3051 lookup_label_for_goto (location_t loc, tree name)
3052 {
3053   tree label;
3054   struct c_label_vars *label_vars;
3055   unsigned int ix;
3056   tree decl;
3057
3058   label = lookup_label (name);
3059   if (label == NULL_TREE)
3060     return NULL_TREE;
3061
3062   /* If we are jumping to a different function, we can't issue any
3063      useful warnings.  */
3064   if (DECL_CONTEXT (label) != current_function_decl)
3065     {
3066       gcc_assert (C_DECLARED_LABEL_FLAG (label));
3067       return label;
3068     }
3069
3070   label_vars = I_LABEL_BINDING (name)->u.label;
3071
3072   /* If the label has not yet been defined, then push this goto on a
3073      list for possible later warnings.  */
3074   if (label_vars->label_bindings.scope == NULL)
3075     {
3076       struct c_goto_bindings *g;
3077
3078       g = GGC_NEW (struct c_goto_bindings);
3079       g->loc = loc;
3080       set_spot_bindings (&g->goto_bindings, true);
3081       VEC_safe_push (c_goto_bindings_p, gc, label_vars->gotos, g);
3082       return label;
3083     }
3084
3085   /* If there are any decls in label_vars->decls_in_scope, then this
3086      goto has missed the declaration of the decl.  This happens for a
3087      case like
3088        int i = 1;
3089       lab:
3090        ...
3091        goto lab;
3092      Issue a warning or error.  */
3093   for (ix = 0; VEC_iterate (tree, label_vars->decls_in_scope, ix, decl); ++ix)
3094     warn_about_goto (loc, label, decl);
3095
3096   if (label_vars->label_bindings.left_stmt_expr)
3097     {
3098       error_at (loc, "jump into statement expression");
3099       inform (DECL_SOURCE_LOCATION (label), "label %qD defined here", label);
3100     }
3101
3102   return label;
3103 }
3104
3105 /* Make a label named NAME in the current function, shadowing silently
3106    any that may be inherited from containing functions or containing
3107    scopes.  This is called for __label__ declarations.  */
3108
3109 tree
3110 declare_label (tree name)
3111 {
3112   struct c_binding *b = I_LABEL_BINDING (name);
3113   tree label;
3114   struct c_label_vars *label_vars;
3115
3116   /* Check to make sure that the label hasn't already been declared
3117      at this scope */
3118   if (b && B_IN_CURRENT_SCOPE (b))
3119     {
3120       error ("duplicate label declaration %qE", name);
3121       locate_old_decl (b->decl);
3122
3123       /* Just use the previous declaration.  */
3124       return b->decl;
3125     }
3126
3127   label = make_label (input_location, name, false, &label_vars);
3128   C_DECLARED_LABEL_FLAG (label) = 1;
3129
3130   /* Declared labels go in the current scope.  */
3131   bind_label (name, label, current_scope, label_vars);
3132
3133   return label;
3134 }
3135
3136 /* When we define a label, issue any appropriate warnings if there are
3137    any gotos earlier in the function which jump to this label.  */
3138
3139 static void
3140 check_earlier_gotos (tree label, struct c_label_vars* label_vars)
3141 {
3142   unsigned int ix;
3143   struct c_goto_bindings *g;
3144
3145   for (ix = 0;
3146        VEC_iterate (c_goto_bindings_p, label_vars->gotos, ix, g);
3147        ++ix)
3148     {
3149       struct c_binding *b;
3150       struct c_scope *scope;
3151
3152       /* We have a goto to this label.  The goto is going forward.  In
3153          g->scope, the goto is going to skip any binding which was
3154          defined after g->bindings_in_scope.  */
3155       for (b = g->goto_bindings.scope->bindings;
3156            b != g->goto_bindings.bindings_in_scope;
3157            b = b->prev)
3158         {
3159           if (decl_jump_unsafe (b->decl))
3160             warn_about_goto (g->loc, label, b->decl);
3161         }
3162
3163       /* We also need to warn about decls defined in any scopes
3164          between the scope of the label and the scope of the goto.  */
3165       for (scope = label_vars->label_bindings.scope;
3166            scope != g->goto_bindings.scope;
3167            scope = scope->outer)
3168         {
3169           gcc_assert (scope != NULL);
3170           if (scope == label_vars->label_bindings.scope)
3171             b = label_vars->label_bindings.bindings_in_scope;
3172           else
3173             b = scope->bindings;
3174           for (; b != NULL; b = b->prev)
3175             {
3176               if (decl_jump_unsafe (b->decl))
3177                 warn_about_goto (g->loc, label, b->decl);
3178             }
3179         }
3180
3181       if (g->goto_bindings.stmt_exprs > 0)
3182         {
3183           error_at (g->loc, "jump into statement expression");
3184           inform (DECL_SOURCE_LOCATION (label), "label %qD defined here",
3185                   label);
3186         }
3187     }
3188
3189   /* Now that the label is defined, we will issue warnings about
3190      subsequent gotos to this label when we see them.  */
3191   VEC_truncate (c_goto_bindings_p, label_vars->gotos, 0);
3192   label_vars->gotos = NULL;
3193 }
3194
3195 /* Define a label, specifying the location in the source file.
3196    Return the LABEL_DECL node for the label, if the definition is valid.
3197    Otherwise return 0.  */
3198
3199 tree
3200 define_label (location_t location, tree name)
3201 {
3202   /* Find any preexisting label with this name.  It is an error
3203      if that label has already been defined in this function, or
3204      if there is a containing function with a declared label with
3205      the same name.  */
3206   tree label = I_LABEL_DECL (name);
3207
3208   if (label
3209       && ((DECL_CONTEXT (label) == current_function_decl
3210            && DECL_INITIAL (label) != 0)
3211           || (DECL_CONTEXT (label) != current_function_decl
3212               && C_DECLARED_LABEL_FLAG (label))))
3213     {
3214       error_at (location, "duplicate label %qD", label);
3215       locate_old_decl (label);
3216       return 0;
3217     }
3218   else if (label && DECL_CONTEXT (label) == current_function_decl)
3219     {
3220       struct c_label_vars *label_vars = I_LABEL_BINDING (name)->u.label;
3221
3222       /* The label has been used or declared already in this function,
3223          but not defined.  Update its location to point to this
3224          definition.  */
3225       DECL_SOURCE_LOCATION (label) = location;
3226       set_spot_bindings (&label_vars->label_bindings, true);
3227
3228       /* Issue warnings as required about any goto statements from
3229          earlier in the function.  */
3230       check_earlier_gotos (label, label_vars);
3231     }
3232   else
3233     {
3234       struct c_label_vars *label_vars;
3235
3236       /* No label binding for that identifier; make one.  */
3237       label = make_label (location, name, true, &label_vars);
3238
3239       /* Ordinary labels go in the current function scope.  */
3240       bind_label (name, label, current_function_scope, label_vars);
3241     }
3242
3243   if (!in_system_header && lookup_name (name))
3244     warning_at (location, OPT_Wtraditional,
3245                 "traditional C lacks a separate namespace "
3246                 "for labels, identifier %qE conflicts", name);
3247
3248   /* Mark label as having been defined.  */
3249   DECL_INITIAL (label) = error_mark_node;
3250   return label;
3251 }
3252 \f
3253 /* Get the bindings for a new switch statement.  This is used to issue
3254    warnings as appropriate for jumps from the switch to case or
3255    default labels.  */
3256
3257 struct c_spot_bindings *
3258 c_get_switch_bindings (void)
3259 {
3260   struct c_spot_bindings *switch_bindings;
3261
3262   switch_bindings = XNEW (struct c_spot_bindings);
3263   set_spot_bindings (switch_bindings, true);
3264   return switch_bindings;
3265 }
3266
3267 void
3268 c_release_switch_bindings (struct c_spot_bindings *bindings)
3269 {
3270   gcc_assert (bindings->stmt_exprs == 0 && !bindings->left_stmt_expr);
3271   XDELETE (bindings);
3272 }
3273
3274 /* This is called at the point of a case or default label to issue
3275    warnings about decls as needed.  It returns true if it found an
3276    error, not just a warning.  */
3277
3278 bool
3279 c_check_switch_jump_warnings (struct c_spot_bindings *switch_bindings,
3280                               location_t switch_loc, location_t case_loc)
3281 {
3282   bool saw_error;
3283   struct c_scope *scope;
3284
3285   saw_error = false;
3286   for (scope = current_scope;
3287        scope != switch_bindings->scope;
3288        scope = scope->outer)
3289     {
3290       struct c_binding *b;
3291
3292       gcc_assert (scope != NULL);
3293       for (b = scope->bindings; b != NULL; b = b->prev)
3294         {
3295           if (decl_jump_unsafe (b->decl))
3296             {
3297               if (variably_modified_type_p (TREE_TYPE (b->decl), NULL_TREE))
3298                 {
3299                   saw_error = true;
3300                   error_at (case_loc,
3301                             ("switch jumps into scope of identifier with "
3302                              "variably modified type"));
3303                 }
3304               else
3305                 warning_at (case_loc, OPT_Wjump_misses_init,
3306                             "switch jumps over variable initialization");
3307               inform (switch_loc, "switch starts here");
3308               inform (DECL_SOURCE_LOCATION (b->decl), "%qD declared here",
3309                       b->decl);
3310             }
3311         }
3312     }
3313
3314   if (switch_bindings->stmt_exprs > 0)
3315     {
3316       saw_error = true;
3317       error_at (case_loc, "switch jumps into statement expression");
3318       inform (switch_loc, "switch starts here");
3319     }
3320
3321   return saw_error;
3322 }
3323 \f
3324 /* Given NAME, an IDENTIFIER_NODE,
3325    return the structure (or union or enum) definition for that name.
3326    If THISLEVEL_ONLY is nonzero, searches only the current_scope.
3327    CODE says which kind of type the caller wants;
3328    it is RECORD_TYPE or UNION_TYPE or ENUMERAL_TYPE.
3329    If PLOC is not NULL and this returns non-null, it sets *PLOC to the
3330    location where the tag was defined.
3331    If the wrong kind of type is found, an error is reported.  */
3332
3333 static tree
3334 lookup_tag (enum tree_code code, tree name, int thislevel_only,
3335             location_t *ploc)
3336 {
3337   struct c_binding *b = I_TAG_BINDING (name);
3338   int thislevel = 0;
3339
3340   if (!b || !b->decl)
3341     return 0;
3342
3343   /* We only care about whether it's in this level if
3344      thislevel_only was set or it might be a type clash.  */
3345   if (thislevel_only || TREE_CODE (b->decl) != code)
3346     {
3347       /* For our purposes, a tag in the external scope is the same as
3348          a tag in the file scope.  (Primarily relevant to Objective-C
3349          and its builtin structure tags, which get pushed before the
3350          file scope is created.)  */
3351       if (B_IN_CURRENT_SCOPE (b)
3352           || (current_scope == file_scope && B_IN_EXTERNAL_SCOPE (b)))
3353         thislevel = 1;
3354     }
3355
3356   if (thislevel_only && !thislevel)
3357     return 0;
3358
3359   if (TREE_CODE (b->decl) != code)
3360     {
3361       /* Definition isn't the kind we were looking for.  */
3362       pending_invalid_xref = name;
3363       pending_invalid_xref_location = input_location;
3364
3365       /* If in the same binding level as a declaration as a tag
3366          of a different type, this must not be allowed to
3367          shadow that tag, so give the error immediately.
3368          (For example, "struct foo; union foo;" is invalid.)  */
3369       if (thislevel)
3370         pending_xref_error ();
3371     }
3372
3373   if (ploc != NULL)
3374     *ploc = b->locus;
3375
3376   return b->decl;
3377 }
3378
3379 /* Print an error message now
3380    for a recent invalid struct, union or enum cross reference.
3381    We don't print them immediately because they are not invalid
3382    when used in the `struct foo;' construct for shadowing.  */
3383
3384 void
3385 pending_xref_error (void)
3386 {
3387   if (pending_invalid_xref != 0)
3388     error_at (pending_invalid_xref_location, "%qE defined as wrong kind of tag",
3389               pending_invalid_xref);
3390   pending_invalid_xref = 0;
3391 }
3392
3393 \f
3394 /* Look up NAME in the current scope and its superiors
3395    in the namespace of variables, functions and typedefs.
3396    Return a ..._DECL node of some kind representing its definition,
3397    or return 0 if it is undefined.  */
3398
3399 tree
3400 lookup_name (tree name)
3401 {
3402   struct c_binding *b = I_SYMBOL_BINDING (name);
3403   if (b && !b->invisible)
3404     return b->decl;
3405   return 0;
3406 }
3407
3408 /* Similar to `lookup_name' but look only at the indicated scope.  */
3409
3410 static tree
3411 lookup_name_in_scope (tree name, struct c_scope *scope)
3412 {
3413   struct c_binding *b;
3414
3415   for (b = I_SYMBOL_BINDING (name); b; b = b->shadowed)
3416     if (B_IN_SCOPE (b, scope))
3417       return b->decl;
3418   return 0;
3419 }
3420 \f
3421 /* Create the predefined scalar types of C,
3422    and some nodes representing standard constants (0, 1, (void *) 0).
3423    Initialize the global scope.
3424    Make definitions for built-in primitive functions.  */
3425
3426 void
3427 c_init_decl_processing (void)
3428 {
3429   location_t save_loc = input_location;
3430
3431   /* Initialize reserved words for parser.  */
3432   c_parse_init ();
3433
3434   current_function_decl = 0;
3435
3436   gcc_obstack_init (&parser_obstack);
3437
3438   /* Make the externals scope.  */
3439   push_scope ();
3440   external_scope = current_scope;
3441
3442   /* Declarations from c_common_nodes_and_builtins must not be associated
3443      with this input file, lest we get differences between using and not
3444      using preprocessed headers.  */
3445   input_location = BUILTINS_LOCATION;
3446
3447   build_common_tree_nodes (flag_signed_char);
3448
3449   c_common_nodes_and_builtins ();
3450
3451   /* In C, comparisons and TRUTH_* expressions have type int.  */
3452   truthvalue_type_node = integer_type_node;
3453   truthvalue_true_node = integer_one_node;
3454   truthvalue_false_node = integer_zero_node;
3455
3456   /* Even in C99, which has a real boolean type.  */
3457   pushdecl (build_decl (UNKNOWN_LOCATION, TYPE_DECL, get_identifier ("_Bool"),
3458                         boolean_type_node));
3459
3460   input_location = save_loc;
3461
3462   pedantic_lvalues = true;
3463
3464   make_fname_decl = c_make_fname_decl;
3465   start_fname_decls ();
3466 }
3467
3468 /* Create the VAR_DECL at LOC for __FUNCTION__ etc. ID is the name to
3469    give the decl, NAME is the initialization string and TYPE_DEP
3470    indicates whether NAME depended on the type of the function.  As we
3471    don't yet implement delayed emission of static data, we mark the
3472    decl as emitted so it is not placed in the output.  Anything using
3473    it must therefore pull out the STRING_CST initializer directly.
3474    FIXME.  */
3475
3476 static tree
3477 c_make_fname_decl (location_t loc, tree id, int type_dep)
3478 {
3479   const char *name = fname_as_string (type_dep);
3480   tree decl, type, init;
3481   size_t length = strlen (name);
3482
3483   type = build_array_type (char_type_node,
3484                            build_index_type (size_int (length)));
3485   type = c_build_qualified_type (type, TYPE_QUAL_CONST);
3486
3487   decl = build_decl (loc, VAR_DECL, id, type);
3488
3489   TREE_STATIC (decl) = 1;
3490   TREE_READONLY (decl) = 1;
3491   DECL_ARTIFICIAL (decl) = 1;