OSDN Git Service

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