OSDN Git Service

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