OSDN Git Service

fed04dca9e98e9d2b9f15bafc12103c82b5c0628
[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)
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             warning (OPT_Wunused_variable, "unused variable %q+D", p);
1175
1176           if (b->inner_comp)
1177             {
1178               error ("type of array %q+D completed incompatibly with"
1179                      " implicit initialization", p);
1180             }
1181
1182           /* Fall through.  */
1183         case TYPE_DECL:
1184         case CONST_DECL:
1185         common_symbol:
1186           /* All of these go in BLOCK_VARS, but only if this is the
1187              binding in the home scope.  */
1188           if (!b->nested)
1189             {
1190               TREE_CHAIN (p) = BLOCK_VARS (block);
1191               BLOCK_VARS (block) = p;
1192             }
1193           else if (VAR_OR_FUNCTION_DECL_P (p))
1194             {
1195               /* For block local externs add a special
1196                  DECL_EXTERNAL decl for debug info generation.  */
1197               tree extp = copy_node (p);
1198
1199               DECL_EXTERNAL (extp) = 1;
1200               TREE_STATIC (extp) = 0;
1201               TREE_PUBLIC (extp) = 1;
1202               DECL_INITIAL (extp) = NULL_TREE;
1203               DECL_LANG_SPECIFIC (extp) = NULL;
1204               DECL_CONTEXT (extp) = current_function_decl;
1205               if (TREE_CODE (p) == FUNCTION_DECL)
1206                 {
1207                   DECL_RESULT (extp) = NULL_TREE;
1208                   DECL_SAVED_TREE (extp) = NULL_TREE;
1209                   DECL_STRUCT_FUNCTION (extp) = NULL;
1210                 }
1211               if (b->locus != UNKNOWN_LOCATION)
1212                 DECL_SOURCE_LOCATION (extp) = b->locus;
1213               TREE_CHAIN (extp) = BLOCK_VARS (block);
1214               BLOCK_VARS (block) = extp;
1215             }
1216           /* If this is the file scope, and we are processing more
1217              than one translation unit in this compilation, set
1218              DECL_CONTEXT of each decl to the TRANSLATION_UNIT_DECL.
1219              This makes same_translation_unit_p work, and causes
1220              static declarations to be given disambiguating suffixes.  */
1221           if (scope == file_scope && num_in_fnames > 1)
1222             {
1223               DECL_CONTEXT (p) = context;
1224               if (TREE_CODE (p) == TYPE_DECL)
1225                 set_type_context (TREE_TYPE (p), context);
1226             }
1227
1228           /* Fall through.  */
1229           /* Parameters go in DECL_ARGUMENTS, not BLOCK_VARS, and have
1230              already been put there by store_parm_decls.  Unused-
1231              parameter warnings are handled by function.c.
1232              error_mark_node obviously does not go in BLOCK_VARS and
1233              does not get unused-variable warnings.  */
1234         case PARM_DECL:
1235         case ERROR_MARK:
1236           /* It is possible for a decl not to have a name.  We get
1237              here with b->id NULL in this case.  */
1238           if (b->id)
1239             {
1240               gcc_assert (I_SYMBOL_BINDING (b->id) == b);
1241               I_SYMBOL_BINDING (b->id) = b->shadowed;
1242               if (b->shadowed && b->shadowed->u.type)
1243                 TREE_TYPE (b->shadowed->decl) = b->shadowed->u.type;
1244             }
1245           break;
1246
1247         default:
1248           gcc_unreachable ();
1249         }
1250     }
1251
1252
1253   /* Dispose of the block that we just made inside some higher level.  */
1254   if ((scope->function_body || scope == file_scope) && context)
1255     {
1256       DECL_INITIAL (context) = block;
1257       BLOCK_SUPERCONTEXT (block) = context;
1258     }
1259   else if (scope->outer)
1260     {
1261       if (block)
1262         SCOPE_LIST_APPEND (scope->outer, blocks, block);
1263       /* If we did not make a block for the scope just exited, any
1264          blocks made for inner scopes must be carried forward so they
1265          will later become subblocks of something else.  */
1266       else if (scope->blocks)
1267         SCOPE_LIST_CONCAT (scope->outer, blocks, scope, blocks);
1268     }
1269
1270   /* Pop the current scope, and free the structure for reuse.  */
1271   current_scope = scope->outer;
1272   if (scope->function_body)
1273     current_function_scope = scope->outer_function;
1274
1275   memset (scope, 0, sizeof (struct c_scope));
1276   scope->outer = scope_freelist;
1277   scope_freelist = scope;
1278
1279   return block;
1280 }
1281
1282 void
1283 push_file_scope (void)
1284 {
1285   tree decl;
1286
1287   if (file_scope)
1288     return;
1289
1290   push_scope ();
1291   file_scope = current_scope;
1292
1293   start_fname_decls ();
1294
1295   for (decl = visible_builtins; decl; decl = TREE_CHAIN (decl))
1296     bind (DECL_NAME (decl), decl, file_scope,
1297           /*invisible=*/false, /*nested=*/true, DECL_SOURCE_LOCATION (decl));
1298 }
1299
1300 void
1301 pop_file_scope (void)
1302 {
1303   /* In case there were missing closebraces, get us back to the global
1304      binding level.  */
1305   while (current_scope != file_scope)
1306     pop_scope ();
1307
1308   /* __FUNCTION__ is defined at file scope ("").  This
1309      call may not be necessary as my tests indicate it
1310      still works without it.  */
1311   finish_fname_decls ();
1312
1313   check_inline_statics ();
1314
1315   /* This is the point to write out a PCH if we're doing that.
1316      In that case we do not want to do anything else.  */
1317   if (pch_file)
1318     {
1319       c_common_write_pch ();
1320       return;
1321     }
1322
1323   /* Pop off the file scope and close this translation unit.  */
1324   pop_scope ();
1325   file_scope = 0;
1326
1327   maybe_apply_pending_pragma_weaks ();
1328 }
1329 \f
1330 /* Adjust the bindings for the start of a statement expression.  */
1331
1332 void
1333 c_bindings_start_stmt_expr (struct c_spot_bindings* switch_bindings)
1334 {
1335   struct c_scope *scope;
1336
1337   for (scope = current_scope; scope != NULL; scope = scope->outer)
1338     {
1339       struct c_binding *b;
1340
1341       if (!scope->has_label_bindings)
1342         continue;
1343
1344       for (b = scope->bindings; b != NULL; b = b->prev)
1345         {
1346           struct c_label_vars *label_vars;
1347           unsigned int ix;
1348           struct c_goto_bindings *g;
1349
1350           if (TREE_CODE (b->decl) != LABEL_DECL)
1351             continue;
1352           label_vars = b->u.label;
1353           ++label_vars->label_bindings.stmt_exprs;
1354           for (ix = 0;
1355                VEC_iterate (c_goto_bindings_p, label_vars->gotos, ix, g);
1356                ++ix)
1357             ++g->goto_bindings.stmt_exprs;
1358         }
1359     }
1360
1361   if (switch_bindings != NULL)
1362     ++switch_bindings->stmt_exprs;
1363 }
1364
1365 /* Adjust the bindings for the end of a statement expression.  */
1366
1367 void
1368 c_bindings_end_stmt_expr (struct c_spot_bindings *switch_bindings)
1369 {
1370   struct c_scope *scope;
1371
1372   for (scope = current_scope; scope != NULL; scope = scope->outer)
1373     {
1374       struct c_binding *b;
1375
1376       if (!scope->has_label_bindings)
1377         continue;
1378
1379       for (b = scope->bindings; b != NULL; b = b->prev)
1380         {
1381           struct c_label_vars *label_vars;
1382           unsigned int ix;
1383           struct c_goto_bindings *g;
1384
1385           if (TREE_CODE (b->decl) != LABEL_DECL)
1386             continue;
1387           label_vars = b->u.label;
1388           --label_vars->label_bindings.stmt_exprs;
1389           if (label_vars->label_bindings.stmt_exprs < 0)
1390             {
1391               label_vars->label_bindings.left_stmt_expr = true;
1392               label_vars->label_bindings.stmt_exprs = 0;
1393             }
1394           for (ix = 0;
1395                VEC_iterate (c_goto_bindings_p, label_vars->gotos, ix, g);
1396                ++ix)
1397             {
1398               --g->goto_bindings.stmt_exprs;
1399               if (g->goto_bindings.stmt_exprs < 0)
1400                 {
1401                   g->goto_bindings.left_stmt_expr = true;
1402                   g->goto_bindings.stmt_exprs = 0;
1403                 }
1404             }
1405         }
1406     }
1407
1408   if (switch_bindings != NULL)
1409     {
1410       --switch_bindings->stmt_exprs;
1411       gcc_assert (switch_bindings->stmt_exprs >= 0);
1412     }
1413 }
1414 \f
1415 /* Push a definition or a declaration of struct, union or enum tag "name".
1416    "type" should be the type node.
1417    We assume that the tag "name" is not already defined, and has a location
1418    of LOC.
1419
1420    Note that the definition may really be just a forward reference.
1421    In that case, the TYPE_SIZE will be zero.  */
1422
1423 static void
1424 pushtag (location_t loc, tree name, tree type)
1425 {
1426   /* Record the identifier as the type's name if it has none.  */
1427   if (name && !TYPE_NAME (type))
1428     TYPE_NAME (type) = name;
1429   bind (name, type, current_scope, /*invisible=*/false, /*nested=*/false, loc);
1430
1431   /* Create a fake NULL-named TYPE_DECL node whose TREE_TYPE will be the
1432      tagged type we just added to the current scope.  This fake
1433      NULL-named TYPE_DECL node helps dwarfout.c to know when it needs
1434      to output a representation of a tagged type, and it also gives
1435      us a convenient place to record the "scope start" address for the
1436      tagged type.  */
1437
1438   TYPE_STUB_DECL (type) = pushdecl (build_decl (loc,
1439                                                 TYPE_DECL, NULL_TREE, type));
1440
1441   /* An approximation for now, so we can tell this is a function-scope tag.
1442      This will be updated in pop_scope.  */
1443   TYPE_CONTEXT (type) = DECL_CONTEXT (TYPE_STUB_DECL (type));
1444
1445   if (warn_cxx_compat && name != NULL_TREE)
1446     {
1447       struct c_binding *b = I_SYMBOL_BINDING (name);
1448
1449       if (b != NULL
1450           && b->decl != NULL_TREE
1451           && TREE_CODE (b->decl) == TYPE_DECL
1452           && (B_IN_CURRENT_SCOPE (b)
1453               || (current_scope == file_scope && B_IN_EXTERNAL_SCOPE (b)))
1454           && (TYPE_MAIN_VARIANT (TREE_TYPE (b->decl))
1455               != TYPE_MAIN_VARIANT (type)))
1456         {
1457           warning_at (loc, OPT_Wc___compat,
1458                       ("using %qD as both a typedef and a tag is "
1459                        "invalid in C++"),
1460                       b->decl);
1461           if (b->locus != UNKNOWN_LOCATION)
1462             inform (b->locus, "originally defined here");
1463         }
1464     }
1465 }
1466 \f
1467 /* Subroutine of compare_decls.  Allow harmless mismatches in return
1468    and argument types provided that the type modes match.  This function
1469    return a unified type given a suitable match, and 0 otherwise.  */
1470
1471 static tree
1472 match_builtin_function_types (tree newtype, tree oldtype)
1473 {
1474   tree newrettype, oldrettype;
1475   tree newargs, oldargs;
1476   tree trytype, tryargs;
1477
1478   /* Accept the return type of the new declaration if same modes.  */
1479   oldrettype = TREE_TYPE (oldtype);
1480   newrettype = TREE_TYPE (newtype);
1481
1482   if (TYPE_MODE (oldrettype) != TYPE_MODE (newrettype))
1483     return 0;
1484
1485   oldargs = TYPE_ARG_TYPES (oldtype);
1486   newargs = TYPE_ARG_TYPES (newtype);
1487   tryargs = newargs;
1488
1489   while (oldargs || newargs)
1490     {
1491       if (!oldargs
1492           || !newargs
1493           || !TREE_VALUE (oldargs)
1494           || !TREE_VALUE (newargs)
1495           || TYPE_MODE (TREE_VALUE (oldargs))
1496              != TYPE_MODE (TREE_VALUE (newargs)))
1497         return 0;
1498
1499       oldargs = TREE_CHAIN (oldargs);
1500       newargs = TREE_CHAIN (newargs);
1501     }
1502
1503   trytype = build_function_type (newrettype, tryargs);
1504   return build_type_attribute_variant (trytype, TYPE_ATTRIBUTES (oldtype));
1505 }
1506
1507 /* Subroutine of diagnose_mismatched_decls.  Check for function type
1508    mismatch involving an empty arglist vs a nonempty one and give clearer
1509    diagnostics.  */
1510 static void
1511 diagnose_arglist_conflict (tree newdecl, tree olddecl,
1512                            tree newtype, tree oldtype)
1513 {
1514   tree t;
1515
1516   if (TREE_CODE (olddecl) != FUNCTION_DECL
1517       || !comptypes (TREE_TYPE (oldtype), TREE_TYPE (newtype))
1518       || !((TYPE_ARG_TYPES (oldtype) == 0 && DECL_INITIAL (olddecl) == 0)
1519            ||
1520            (TYPE_ARG_TYPES (newtype) == 0 && DECL_INITIAL (newdecl) == 0)))
1521     return;
1522
1523   t = TYPE_ARG_TYPES (oldtype);
1524   if (t == 0)
1525     t = TYPE_ARG_TYPES (newtype);
1526   for (; t; t = TREE_CHAIN (t))
1527     {
1528       tree type = TREE_VALUE (t);
1529
1530       if (TREE_CHAIN (t) == 0
1531           && TYPE_MAIN_VARIANT (type) != void_type_node)
1532         {
1533           inform (input_location, "a parameter list with an ellipsis can%'t match "
1534                   "an empty parameter name list declaration");
1535           break;
1536         }
1537
1538       if (c_type_promotes_to (type) != type)
1539         {
1540           inform (input_location, "an argument type that has a default promotion can%'t match "
1541                   "an empty parameter name list declaration");
1542           break;
1543         }
1544     }
1545 }
1546
1547 /* Another subroutine of diagnose_mismatched_decls.  OLDDECL is an
1548    old-style function definition, NEWDECL is a prototype declaration.
1549    Diagnose inconsistencies in the argument list.  Returns TRUE if
1550    the prototype is compatible, FALSE if not.  */
1551 static bool
1552 validate_proto_after_old_defn (tree newdecl, tree newtype, tree oldtype)
1553 {
1554   tree newargs, oldargs;
1555   int i;
1556
1557 #define END_OF_ARGLIST(t) ((t) == void_type_node)
1558
1559   oldargs = TYPE_ACTUAL_ARG_TYPES (oldtype);
1560   newargs = TYPE_ARG_TYPES (newtype);
1561   i = 1;
1562
1563   for (;;)
1564     {
1565       tree oldargtype = TREE_VALUE (oldargs);
1566       tree newargtype = TREE_VALUE (newargs);
1567
1568       if (oldargtype == error_mark_node || newargtype == error_mark_node)
1569         return false;
1570
1571       oldargtype = TYPE_MAIN_VARIANT (oldargtype);
1572       newargtype = TYPE_MAIN_VARIANT (newargtype);
1573
1574       if (END_OF_ARGLIST (oldargtype) && END_OF_ARGLIST (newargtype))
1575         break;
1576
1577       /* Reaching the end of just one list means the two decls don't
1578          agree on the number of arguments.  */
1579       if (END_OF_ARGLIST (oldargtype))
1580         {
1581           error ("prototype for %q+D declares more arguments "
1582                  "than previous old-style definition", newdecl);
1583           return false;
1584         }
1585       else if (END_OF_ARGLIST (newargtype))
1586         {
1587           error ("prototype for %q+D declares fewer arguments "
1588                  "than previous old-style definition", newdecl);
1589           return false;
1590         }
1591
1592       /* Type for passing arg must be consistent with that declared
1593          for the arg.  */
1594       else if (!comptypes (oldargtype, newargtype))
1595         {
1596           error ("prototype for %q+D declares argument %d"
1597                  " with incompatible type",
1598                  newdecl, i);
1599           return false;
1600         }
1601
1602       oldargs = TREE_CHAIN (oldargs);
1603       newargs = TREE_CHAIN (newargs);
1604       i++;
1605     }
1606
1607   /* If we get here, no errors were found, but do issue a warning
1608      for this poor-style construct.  */
1609   warning (0, "prototype for %q+D follows non-prototype definition",
1610            newdecl);
1611   return true;
1612 #undef END_OF_ARGLIST
1613 }
1614
1615 /* Subroutine of diagnose_mismatched_decls.  Report the location of DECL,
1616    first in a pair of mismatched declarations, using the diagnostic
1617    function DIAG.  */
1618 static void
1619 locate_old_decl (tree decl)
1620 {
1621   if (TREE_CODE (decl) == FUNCTION_DECL && DECL_BUILT_IN (decl))
1622     ;
1623   else if (DECL_INITIAL (decl))
1624     inform (input_location, "previous definition of %q+D was here", decl);
1625   else if (C_DECL_IMPLICIT (decl))
1626     inform (input_location, "previous implicit declaration of %q+D was here", decl);
1627   else
1628     inform (input_location, "previous declaration of %q+D was here", decl);
1629 }
1630
1631 /* Subroutine of duplicate_decls.  Compare NEWDECL to OLDDECL.
1632    Returns true if the caller should proceed to merge the two, false
1633    if OLDDECL should simply be discarded.  As a side effect, issues
1634    all necessary diagnostics for invalid or poor-style combinations.
1635    If it returns true, writes the types of NEWDECL and OLDDECL to
1636    *NEWTYPEP and *OLDTYPEP - these may have been adjusted from
1637    TREE_TYPE (NEWDECL, OLDDECL) respectively.  */
1638
1639 static bool
1640 diagnose_mismatched_decls (tree newdecl, tree olddecl,
1641                            tree *newtypep, tree *oldtypep)
1642 {
1643   tree newtype, oldtype;
1644   bool pedwarned = false;
1645   bool warned = false;
1646   bool retval = true;
1647
1648 #define DECL_EXTERN_INLINE(DECL) (DECL_DECLARED_INLINE_P (DECL)  \
1649                                   && DECL_EXTERNAL (DECL))
1650
1651   /* If we have error_mark_node for either decl or type, just discard
1652      the previous decl - we're in an error cascade already.  */
1653   if (olddecl == error_mark_node || newdecl == error_mark_node)
1654     return false;
1655   *oldtypep = oldtype = TREE_TYPE (olddecl);
1656   *newtypep = newtype = TREE_TYPE (newdecl);
1657   if (oldtype == error_mark_node || newtype == error_mark_node)
1658     return false;
1659
1660   /* Two different categories of symbol altogether.  This is an error
1661      unless OLDDECL is a builtin.  OLDDECL will be discarded in any case.  */
1662   if (TREE_CODE (olddecl) != TREE_CODE (newdecl))
1663     {
1664       if (!(TREE_CODE (olddecl) == FUNCTION_DECL
1665             && DECL_BUILT_IN (olddecl)
1666             && !C_DECL_DECLARED_BUILTIN (olddecl)))
1667         {
1668           error ("%q+D redeclared as different kind of symbol", newdecl);
1669           locate_old_decl (olddecl);
1670         }
1671       else if (TREE_PUBLIC (newdecl))
1672         warning (0, "built-in function %q+D declared as non-function",
1673                  newdecl);
1674       else
1675         warning (OPT_Wshadow, "declaration of %q+D shadows "
1676                  "a built-in function", newdecl);
1677       return false;
1678     }
1679
1680   /* Enumerators have no linkage, so may only be declared once in a
1681      given scope.  */
1682   if (TREE_CODE (olddecl) == CONST_DECL)
1683     {
1684       error ("redeclaration of enumerator %q+D", newdecl);
1685       locate_old_decl (olddecl);
1686       return false;
1687     }
1688
1689   if (!comptypes (oldtype, newtype))
1690     {
1691       if (TREE_CODE (olddecl) == FUNCTION_DECL
1692           && DECL_BUILT_IN (olddecl) && !C_DECL_DECLARED_BUILTIN (olddecl))
1693         {
1694           /* Accept harmless mismatch in function types.
1695              This is for the ffs and fprintf builtins.  */
1696           tree trytype = match_builtin_function_types (newtype, oldtype);
1697
1698           if (trytype && comptypes (newtype, trytype))
1699             *oldtypep = oldtype = trytype;
1700           else
1701             {
1702               /* If types don't match for a built-in, throw away the
1703                  built-in.  No point in calling locate_old_decl here, it
1704                  won't print anything.  */
1705               warning (0, "conflicting types for built-in function %q+D",
1706                        newdecl);
1707               return false;
1708             }
1709         }
1710       else if (TREE_CODE (olddecl) == FUNCTION_DECL
1711                && DECL_IS_BUILTIN (olddecl))
1712         {
1713           /* A conflicting function declaration for a predeclared
1714              function that isn't actually built in.  Objective C uses
1715              these.  The new declaration silently overrides everything
1716              but the volatility (i.e. noreturn) indication.  See also
1717              below.  FIXME: Make Objective C use normal builtins.  */
1718           TREE_THIS_VOLATILE (newdecl) |= TREE_THIS_VOLATILE (olddecl);
1719           return false;
1720         }
1721       /* Permit void foo (...) to match int foo (...) if the latter is
1722          the definition and implicit int was used.  See
1723          c-torture/compile/920625-2.c.  */
1724       else if (TREE_CODE (newdecl) == FUNCTION_DECL && DECL_INITIAL (newdecl)
1725                && TYPE_MAIN_VARIANT (TREE_TYPE (oldtype)) == void_type_node
1726                && TYPE_MAIN_VARIANT (TREE_TYPE (newtype)) == integer_type_node
1727                && C_FUNCTION_IMPLICIT_INT (newdecl) && !DECL_INITIAL (olddecl))
1728         {
1729           pedwarned = pedwarn (input_location, 0,
1730                                "conflicting types for %q+D", newdecl);
1731           /* Make sure we keep void as the return type.  */
1732           TREE_TYPE (newdecl) = *newtypep = newtype = oldtype;
1733           C_FUNCTION_IMPLICIT_INT (newdecl) = 0;
1734         }
1735       /* Permit void foo (...) to match an earlier call to foo (...) with
1736          no declared type (thus, implicitly int).  */
1737       else if (TREE_CODE (newdecl) == FUNCTION_DECL
1738                && TYPE_MAIN_VARIANT (TREE_TYPE (newtype)) == void_type_node
1739                && TYPE_MAIN_VARIANT (TREE_TYPE (oldtype)) == integer_type_node
1740                && C_DECL_IMPLICIT (olddecl) && !DECL_INITIAL (olddecl))
1741         {
1742           pedwarned = pedwarn (input_location, 0,
1743                                "conflicting types for %q+D", newdecl);
1744           /* Make sure we keep void as the return type.  */
1745           TREE_TYPE (olddecl) = *oldtypep = oldtype = newtype;
1746         }
1747       else
1748         {
1749           int new_quals = TYPE_QUALS (newtype);
1750           int old_quals = TYPE_QUALS (oldtype);
1751
1752           if (new_quals != old_quals)
1753             {
1754               addr_space_t new_addr = DECODE_QUAL_ADDR_SPACE (new_quals);
1755               addr_space_t old_addr = DECODE_QUAL_ADDR_SPACE (old_quals);
1756               if (new_addr != old_addr)
1757                 {
1758                   if (ADDR_SPACE_GENERIC_P (new_addr))
1759                     error ("conflicting named address spaces (generic vs %s) "
1760                            "for %q+D",
1761                            c_addr_space_name (old_addr), newdecl);
1762                   else if (ADDR_SPACE_GENERIC_P (old_addr))
1763                     error ("conflicting named address spaces (%s vs generic) "
1764                            "for %q+D",
1765                            c_addr_space_name (new_addr), newdecl);
1766                   else
1767                     error ("conflicting named address spaces (%s vs %s) "
1768                            "for %q+D",
1769                            c_addr_space_name (new_addr),
1770                            c_addr_space_name (old_addr),
1771                            newdecl);
1772                 }
1773
1774               if (CLEAR_QUAL_ADDR_SPACE (new_quals)
1775                   != CLEAR_QUAL_ADDR_SPACE (old_quals))
1776                 error ("conflicting type qualifiers for %q+D", newdecl);
1777             }
1778           else
1779             error ("conflicting types for %q+D", newdecl);
1780           diagnose_arglist_conflict (newdecl, olddecl, newtype, oldtype);
1781           locate_old_decl (olddecl);
1782           return false;
1783         }
1784     }
1785
1786   /* Redeclaration of a type is a constraint violation (6.7.2.3p1),
1787      but silently ignore the redeclaration if either is in a system
1788      header.  (Conflicting redeclarations were handled above.)  */
1789   if (TREE_CODE (newdecl) == TYPE_DECL)
1790     {
1791       if (DECL_IN_SYSTEM_HEADER (newdecl)
1792           || DECL_IN_SYSTEM_HEADER (olddecl)
1793           || TREE_NO_WARNING (newdecl)
1794           || TREE_NO_WARNING (olddecl))
1795         return true;  /* Allow OLDDECL to continue in use.  */
1796
1797       error ("redefinition of typedef %q+D", newdecl);
1798       locate_old_decl (olddecl);
1799       return false;
1800     }
1801
1802   /* Function declarations can either be 'static' or 'extern' (no
1803      qualifier is equivalent to 'extern' - C99 6.2.2p5) and therefore
1804      can never conflict with each other on account of linkage
1805      (6.2.2p4).  Multiple definitions are not allowed (6.9p3,5) but
1806      gnu89 mode permits two definitions if one is 'extern inline' and
1807      one is not.  The non- extern-inline definition supersedes the
1808      extern-inline definition.  */
1809
1810   else if (TREE_CODE (newdecl) == FUNCTION_DECL)
1811     {
1812       /* If you declare a built-in function name as static, or
1813          define the built-in with an old-style definition (so we
1814          can't validate the argument list) the built-in definition is
1815          overridden, but optionally warn this was a bad choice of name.  */
1816       if (DECL_BUILT_IN (olddecl)
1817           && !C_DECL_DECLARED_BUILTIN (olddecl)
1818           && (!TREE_PUBLIC (newdecl)
1819               || (DECL_INITIAL (newdecl)
1820                   && !TYPE_ARG_TYPES (TREE_TYPE (newdecl)))))
1821         {
1822           warning (OPT_Wshadow, "declaration of %q+D shadows "
1823                    "a built-in function", newdecl);
1824           /* Discard the old built-in function.  */
1825           return false;
1826         }
1827
1828       if (DECL_INITIAL (newdecl))
1829         {
1830           if (DECL_INITIAL (olddecl))
1831             {
1832               /* If both decls are in the same TU and the new declaration
1833                  isn't overriding an extern inline reject the new decl.
1834                  In c99, no overriding is allowed in the same translation
1835                  unit.  */
1836               if ((!DECL_EXTERN_INLINE (olddecl)
1837                    || DECL_EXTERN_INLINE (newdecl)
1838                    || (!flag_gnu89_inline
1839                        && (!DECL_DECLARED_INLINE_P (olddecl)
1840                            || !lookup_attribute ("gnu_inline",
1841                                                  DECL_ATTRIBUTES (olddecl)))
1842                        && (!DECL_DECLARED_INLINE_P (newdecl)
1843                            || !lookup_attribute ("gnu_inline",
1844                                                  DECL_ATTRIBUTES (newdecl))))
1845                   )
1846                   && same_translation_unit_p (newdecl, olddecl))
1847                 {
1848                   error ("redefinition of %q+D", newdecl);
1849                   locate_old_decl (olddecl);
1850                   return false;
1851                 }
1852             }
1853         }
1854       /* If we have a prototype after an old-style function definition,
1855          the argument types must be checked specially.  */
1856       else if (DECL_INITIAL (olddecl)
1857                && !TYPE_ARG_TYPES (oldtype) && TYPE_ARG_TYPES (newtype)
1858                && TYPE_ACTUAL_ARG_TYPES (oldtype)
1859                && !validate_proto_after_old_defn (newdecl, newtype, oldtype))
1860         {
1861           locate_old_decl (olddecl);
1862           return false;
1863         }
1864       /* A non-static declaration (even an "extern") followed by a
1865          static declaration is undefined behavior per C99 6.2.2p3-5,7.
1866          The same is true for a static forward declaration at block
1867          scope followed by a non-static declaration/definition at file
1868          scope.  Static followed by non-static at the same scope is
1869          not undefined behavior, and is the most convenient way to get
1870          some effects (see e.g.  what unwind-dw2-fde-glibc.c does to
1871          the definition of _Unwind_Find_FDE in unwind-dw2-fde.c), but
1872          we do diagnose it if -Wtraditional.  */
1873       if (TREE_PUBLIC (olddecl) && !TREE_PUBLIC (newdecl))
1874         {
1875           /* Two exceptions to the rule.  If olddecl is an extern
1876              inline, or a predeclared function that isn't actually
1877              built in, newdecl silently overrides olddecl.  The latter
1878              occur only in Objective C; see also above.  (FIXME: Make
1879              Objective C use normal builtins.)  */
1880           if (!DECL_IS_BUILTIN (olddecl)
1881               && !DECL_EXTERN_INLINE (olddecl))
1882             {
1883               error ("static declaration of %q+D follows "
1884                      "non-static declaration", newdecl);
1885               locate_old_decl (olddecl);
1886             }
1887           return false;
1888         }
1889       else if (TREE_PUBLIC (newdecl) && !TREE_PUBLIC (olddecl))
1890         {
1891           if (DECL_CONTEXT (olddecl))
1892             {
1893               error ("non-static declaration of %q+D follows "
1894                      "static declaration", newdecl);
1895               locate_old_decl (olddecl);
1896               return false;
1897             }
1898           else if (warn_traditional)
1899             {
1900               warned |= warning (OPT_Wtraditional,
1901                                  "non-static declaration of %q+D "
1902                                  "follows static declaration", newdecl);
1903             }
1904         }
1905
1906       /* Make sure gnu_inline attribute is either not present, or
1907          present on all inline decls.  */
1908       if (DECL_DECLARED_INLINE_P (olddecl)
1909           && DECL_DECLARED_INLINE_P (newdecl))
1910         {
1911           bool newa = lookup_attribute ("gnu_inline",
1912                                         DECL_ATTRIBUTES (newdecl)) != NULL;
1913           bool olda = lookup_attribute ("gnu_inline",
1914                                         DECL_ATTRIBUTES (olddecl)) != NULL;
1915           if (newa != olda)
1916             {
1917               error_at (input_location, "%<gnu_inline%> attribute present on %q+D",
1918                         newa ? newdecl : olddecl);
1919               error_at (DECL_SOURCE_LOCATION (newa ? olddecl : newdecl),
1920                         "but not here");
1921             }
1922         }
1923     }
1924   else if (TREE_CODE (newdecl) == VAR_DECL)
1925     {
1926       /* Only variables can be thread-local, and all declarations must
1927          agree on this property.  */
1928       if (C_DECL_THREADPRIVATE_P (olddecl) && !DECL_THREAD_LOCAL_P (newdecl))
1929         {
1930           /* Nothing to check.  Since OLDDECL is marked threadprivate
1931              and NEWDECL does not have a thread-local attribute, we
1932              will merge the threadprivate attribute into NEWDECL.  */
1933           ;
1934         }
1935       else if (DECL_THREAD_LOCAL_P (newdecl) != DECL_THREAD_LOCAL_P (olddecl))
1936         {
1937           if (DECL_THREAD_LOCAL_P (newdecl))
1938             error ("thread-local declaration of %q+D follows "
1939                    "non-thread-local declaration", newdecl);
1940           else
1941             error ("non-thread-local declaration of %q+D follows "
1942                    "thread-local declaration", newdecl);
1943
1944           locate_old_decl (olddecl);
1945           return false;
1946         }
1947
1948       /* Multiple initialized definitions are not allowed (6.9p3,5).  */
1949       if (DECL_INITIAL (newdecl) && DECL_INITIAL (olddecl))
1950         {
1951           error ("redefinition of %q+D", newdecl);
1952           locate_old_decl (olddecl);
1953           return false;
1954         }
1955
1956       /* Objects declared at file scope: if the first declaration had
1957          external linkage (even if it was an external reference) the
1958          second must have external linkage as well, or the behavior is
1959          undefined.  If the first declaration had internal linkage, then
1960          the second must too, or else be an external reference (in which
1961          case the composite declaration still has internal linkage).
1962          As for function declarations, we warn about the static-then-
1963          extern case only for -Wtraditional.  See generally 6.2.2p3-5,7.  */
1964       if (DECL_FILE_SCOPE_P (newdecl)
1965           && TREE_PUBLIC (newdecl) != TREE_PUBLIC (olddecl))
1966         {
1967           if (DECL_EXTERNAL (newdecl))
1968             {
1969               if (!DECL_FILE_SCOPE_P (olddecl))
1970                 {
1971                   error ("extern declaration of %q+D follows "
1972                          "declaration with no linkage", newdecl);
1973                   locate_old_decl (olddecl);
1974                   return false;
1975                 }
1976               else if (warn_traditional)
1977                 {
1978                   warned |= warning (OPT_Wtraditional,
1979                                      "non-static declaration of %q+D "
1980                                      "follows static declaration", newdecl);
1981                 }
1982             }
1983           else
1984             {
1985               if (TREE_PUBLIC (newdecl))
1986                 error ("non-static declaration of %q+D follows "
1987                        "static declaration", newdecl);
1988               else
1989                 error ("static declaration of %q+D follows "
1990                        "non-static declaration", newdecl);
1991
1992               locate_old_decl (olddecl);
1993               return false;
1994             }
1995         }
1996       /* Two objects with the same name declared at the same block
1997          scope must both be external references (6.7p3).  */
1998       else if (!DECL_FILE_SCOPE_P (newdecl))
1999         {
2000           if (DECL_EXTERNAL (newdecl))
2001             {
2002               /* Extern with initializer at block scope, which will
2003                  already have received an error.  */
2004             }
2005           else if (DECL_EXTERNAL (olddecl))
2006             {
2007               error ("declaration of %q+D with no linkage follows "
2008                      "extern declaration", newdecl);
2009               locate_old_decl (olddecl);
2010             }
2011           else
2012             {
2013               error ("redeclaration of %q+D with no linkage", newdecl);
2014               locate_old_decl (olddecl);
2015             }
2016
2017           return false;
2018         }
2019
2020       /* C++ does not permit a decl to appear multiple times at file
2021          scope.  */
2022       if (warn_cxx_compat
2023           && DECL_FILE_SCOPE_P (newdecl)
2024           && !DECL_EXTERNAL (newdecl)
2025           && !DECL_EXTERNAL (olddecl))
2026         warned |= warning_at (DECL_SOURCE_LOCATION (newdecl),
2027                               OPT_Wc___compat,
2028                               ("duplicate declaration of %qD is "
2029                                "invalid in C++"),
2030                               newdecl);
2031     }
2032
2033   /* warnings */
2034   /* All decls must agree on a visibility.  */
2035   if (CODE_CONTAINS_STRUCT (TREE_CODE (newdecl), TS_DECL_WITH_VIS)
2036       && DECL_VISIBILITY_SPECIFIED (newdecl) && DECL_VISIBILITY_SPECIFIED (olddecl)
2037       && DECL_VISIBILITY (newdecl) != DECL_VISIBILITY (olddecl))
2038     {
2039       warned |= warning (0, "redeclaration of %q+D with different visibility "
2040                          "(old visibility preserved)", newdecl);
2041     }
2042
2043   if (TREE_CODE (newdecl) == FUNCTION_DECL)
2044     {
2045       /* Diagnose inline __attribute__ ((noinline)) which is silly.  */
2046       if (DECL_DECLARED_INLINE_P (newdecl)
2047           && lookup_attribute ("noinline", DECL_ATTRIBUTES (olddecl)))
2048         {
2049           warned |= warning (OPT_Wattributes,
2050                              "inline declaration of %qD follows "
2051                              "declaration with attribute noinline", newdecl);
2052         }
2053       else if (DECL_DECLARED_INLINE_P (olddecl)
2054                && lookup_attribute ("noinline", DECL_ATTRIBUTES (newdecl)))
2055         {
2056           warned |= warning (OPT_Wattributes,
2057                              "declaration of %q+D with attribute "
2058                              "noinline follows inline declaration ", newdecl);
2059         }
2060     }
2061   else /* PARM_DECL, VAR_DECL */
2062     {
2063       /* Redeclaration of a parameter is a constraint violation (this is
2064          not explicitly stated, but follows from C99 6.7p3 [no more than
2065          one declaration of the same identifier with no linkage in the
2066          same scope, except type tags] and 6.2.2p6 [parameters have no
2067          linkage]).  We must check for a forward parameter declaration,
2068          indicated by TREE_ASM_WRITTEN on the old declaration - this is
2069          an extension, the mandatory diagnostic for which is handled by
2070          mark_forward_parm_decls.  */
2071
2072       if (TREE_CODE (newdecl) == PARM_DECL
2073           && (!TREE_ASM_WRITTEN (olddecl) || TREE_ASM_WRITTEN (newdecl)))
2074         {
2075           error ("redefinition of parameter %q+D", newdecl);
2076           locate_old_decl (olddecl);
2077           return false;
2078         }
2079     }
2080
2081   /* Optional warning for completely redundant decls.  */
2082   if (!warned && !pedwarned
2083       && warn_redundant_decls
2084       /* Don't warn about a function declaration followed by a
2085          definition.  */
2086       && !(TREE_CODE (newdecl) == FUNCTION_DECL
2087            && DECL_INITIAL (newdecl) && !DECL_INITIAL (olddecl))
2088       /* Don't warn about redundant redeclarations of builtins.  */
2089       && !(TREE_CODE (newdecl) == FUNCTION_DECL
2090            && !DECL_BUILT_IN (newdecl)
2091            && DECL_BUILT_IN (olddecl)
2092            && !C_DECL_DECLARED_BUILTIN (olddecl))
2093       /* Don't warn about an extern followed by a definition.  */
2094       && !(DECL_EXTERNAL (olddecl) && !DECL_EXTERNAL (newdecl))
2095       /* Don't warn about forward parameter decls.  */
2096       && !(TREE_CODE (newdecl) == PARM_DECL
2097            && TREE_ASM_WRITTEN (olddecl) && !TREE_ASM_WRITTEN (newdecl))
2098       /* Don't warn about a variable definition following a declaration.  */
2099       && !(TREE_CODE (newdecl) == VAR_DECL
2100            && DECL_INITIAL (newdecl) && !DECL_INITIAL (olddecl)))
2101     {
2102       warned = warning (OPT_Wredundant_decls, "redundant redeclaration of %q+D",
2103                         newdecl);
2104     }
2105
2106   /* Report location of previous decl/defn.  */
2107   if (warned || pedwarned)
2108     locate_old_decl (olddecl);
2109
2110 #undef DECL_EXTERN_INLINE
2111
2112   return retval;
2113 }
2114
2115 /* Subroutine of duplicate_decls.  NEWDECL has been found to be
2116    consistent with OLDDECL, but carries new information.  Merge the
2117    new information into OLDDECL.  This function issues no
2118    diagnostics.  */
2119
2120 static void
2121 merge_decls (tree newdecl, tree olddecl, tree newtype, tree oldtype)
2122 {
2123   bool new_is_definition = (TREE_CODE (newdecl) == FUNCTION_DECL
2124                             && DECL_INITIAL (newdecl) != 0);
2125   bool new_is_prototype = (TREE_CODE (newdecl) == FUNCTION_DECL
2126                            && TYPE_ARG_TYPES (TREE_TYPE (newdecl)) != 0);
2127   bool old_is_prototype = (TREE_CODE (olddecl) == FUNCTION_DECL
2128                            && TYPE_ARG_TYPES (TREE_TYPE (olddecl)) != 0);
2129   bool extern_changed = false;
2130
2131   /* For real parm decl following a forward decl, rechain the old decl
2132      in its new location and clear TREE_ASM_WRITTEN (it's not a
2133      forward decl anymore).  */
2134   if (TREE_CODE (newdecl) == PARM_DECL
2135       && TREE_ASM_WRITTEN (olddecl) && !TREE_ASM_WRITTEN (newdecl))
2136     {
2137       struct c_binding *b, **here;
2138
2139       for (here = &current_scope->bindings; *here; here = &(*here)->prev)
2140         if ((*here)->decl == olddecl)
2141           goto found;
2142       gcc_unreachable ();
2143
2144     found:
2145       b = *here;
2146       *here = b->prev;
2147       b->prev = current_scope->bindings;
2148       current_scope->bindings = b;
2149
2150       TREE_ASM_WRITTEN (olddecl) = 0;
2151     }
2152
2153   DECL_ATTRIBUTES (newdecl)
2154     = targetm.merge_decl_attributes (olddecl, newdecl);
2155
2156   /* Merge the data types specified in the two decls.  */
2157   TREE_TYPE (newdecl)
2158     = TREE_TYPE (olddecl)
2159     = composite_type (newtype, oldtype);
2160
2161   /* Lay the type out, unless already done.  */
2162   if (!comptypes (oldtype, TREE_TYPE (newdecl)))
2163     {
2164       if (TREE_TYPE (newdecl) != error_mark_node)
2165         layout_type (TREE_TYPE (newdecl));
2166       if (TREE_CODE (newdecl) != FUNCTION_DECL
2167           && TREE_CODE (newdecl) != TYPE_DECL
2168           && TREE_CODE (newdecl) != CONST_DECL)
2169         layout_decl (newdecl, 0);
2170     }
2171   else
2172     {
2173       /* Since the type is OLDDECL's, make OLDDECL's size go with.  */
2174       DECL_SIZE (newdecl) = DECL_SIZE (olddecl);
2175       DECL_SIZE_UNIT (newdecl) = DECL_SIZE_UNIT (olddecl);
2176       DECL_MODE (newdecl) = DECL_MODE (olddecl);
2177       if (DECL_ALIGN (olddecl) > DECL_ALIGN (newdecl))
2178         {
2179           DECL_ALIGN (newdecl) = DECL_ALIGN (olddecl);
2180           DECL_USER_ALIGN (newdecl) |= DECL_USER_ALIGN (olddecl);
2181         }
2182     }
2183
2184   /* Keep the old rtl since we can safely use it.  */
2185   if (HAS_RTL_P (olddecl))
2186     COPY_DECL_RTL (olddecl, newdecl);
2187
2188   /* Merge the type qualifiers.  */
2189   if (TREE_READONLY (newdecl))
2190     TREE_READONLY (olddecl) = 1;
2191
2192   if (TREE_THIS_VOLATILE (newdecl))
2193     TREE_THIS_VOLATILE (olddecl) = 1;
2194
2195   /* Merge deprecatedness.  */
2196   if (TREE_DEPRECATED (newdecl))
2197     TREE_DEPRECATED (olddecl) = 1;
2198
2199   /* If a decl is in a system header and the other isn't, keep the one on the
2200      system header. Otherwise, keep source location of definition rather than
2201      declaration and of prototype rather than non-prototype unless that
2202      prototype is built-in.  */
2203   if (CODE_CONTAINS_STRUCT (TREE_CODE (olddecl), TS_DECL_WITH_VIS)
2204       && DECL_IN_SYSTEM_HEADER (olddecl)
2205       && !DECL_IN_SYSTEM_HEADER (newdecl) )
2206     DECL_SOURCE_LOCATION (newdecl) = DECL_SOURCE_LOCATION (olddecl);
2207   else if (CODE_CONTAINS_STRUCT (TREE_CODE (olddecl), TS_DECL_WITH_VIS)
2208            && DECL_IN_SYSTEM_HEADER (newdecl)
2209            && !DECL_IN_SYSTEM_HEADER (olddecl))
2210     DECL_SOURCE_LOCATION (olddecl) = DECL_SOURCE_LOCATION (newdecl);
2211   else if ((DECL_INITIAL (newdecl) == 0 && DECL_INITIAL (olddecl) != 0)
2212            || (old_is_prototype && !new_is_prototype
2213                && !C_DECL_BUILTIN_PROTOTYPE (olddecl)))
2214     DECL_SOURCE_LOCATION (newdecl) = DECL_SOURCE_LOCATION (olddecl);
2215
2216   /* Merge the initialization information.  */
2217    if (DECL_INITIAL (newdecl) == 0)
2218     DECL_INITIAL (newdecl) = DECL_INITIAL (olddecl);
2219
2220   /* Merge the threadprivate attribute.  */
2221   if (TREE_CODE (olddecl) == VAR_DECL && C_DECL_THREADPRIVATE_P (olddecl))
2222     {
2223       DECL_TLS_MODEL (newdecl) = DECL_TLS_MODEL (olddecl);
2224       C_DECL_THREADPRIVATE_P (newdecl) = 1;
2225     }
2226
2227   if (CODE_CONTAINS_STRUCT (TREE_CODE (olddecl), TS_DECL_WITH_VIS))
2228     {
2229       /* Merge the section attribute.
2230          We want to issue an error if the sections conflict but that
2231          must be done later in decl_attributes since we are called
2232          before attributes are assigned.  */
2233       if (DECL_SECTION_NAME (newdecl) == NULL_TREE)
2234         DECL_SECTION_NAME (newdecl) = DECL_SECTION_NAME (olddecl);
2235
2236       /* Copy the assembler name.
2237          Currently, it can only be defined in the prototype.  */
2238       COPY_DECL_ASSEMBLER_NAME (olddecl, newdecl);
2239
2240       /* Use visibility of whichever declaration had it specified */
2241       if (DECL_VISIBILITY_SPECIFIED (olddecl))
2242         {
2243           DECL_VISIBILITY (newdecl) = DECL_VISIBILITY (olddecl);
2244           DECL_VISIBILITY_SPECIFIED (newdecl) = 1;
2245         }
2246
2247       if (TREE_CODE (newdecl) == FUNCTION_DECL)
2248         {
2249           DECL_STATIC_CONSTRUCTOR(newdecl) |= DECL_STATIC_CONSTRUCTOR(olddecl);
2250           DECL_STATIC_DESTRUCTOR (newdecl) |= DECL_STATIC_DESTRUCTOR (olddecl);
2251           DECL_NO_LIMIT_STACK (newdecl) |= DECL_NO_LIMIT_STACK (olddecl);
2252           DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (newdecl)
2253             |= DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (olddecl);
2254           TREE_THIS_VOLATILE (newdecl) |= TREE_THIS_VOLATILE (olddecl);
2255           DECL_IS_MALLOC (newdecl) |= DECL_IS_MALLOC (olddecl);
2256           DECL_IS_OPERATOR_NEW (newdecl) |= DECL_IS_OPERATOR_NEW (olddecl);
2257           TREE_READONLY (newdecl) |= TREE_READONLY (olddecl);
2258           DECL_PURE_P (newdecl) |= DECL_PURE_P (olddecl);
2259           DECL_IS_NOVOPS (newdecl) |= DECL_IS_NOVOPS (olddecl);
2260         }
2261
2262       /* Merge the storage class information.  */
2263       merge_weak (newdecl, olddecl);
2264
2265       /* For functions, static overrides non-static.  */
2266       if (TREE_CODE (newdecl) == FUNCTION_DECL)
2267         {
2268           TREE_PUBLIC (newdecl) &= TREE_PUBLIC (olddecl);
2269           /* This is since we don't automatically
2270              copy the attributes of NEWDECL into OLDDECL.  */
2271           TREE_PUBLIC (olddecl) = TREE_PUBLIC (newdecl);
2272           /* If this clears `static', clear it in the identifier too.  */
2273           if (!TREE_PUBLIC (olddecl))
2274             TREE_PUBLIC (DECL_NAME (olddecl)) = 0;
2275         }
2276     }
2277
2278   /* In c99, 'extern' declaration before (or after) 'inline' means this
2279      function is not DECL_EXTERNAL, unless 'gnu_inline' attribute
2280      is present.  */
2281   if (TREE_CODE (newdecl) == FUNCTION_DECL
2282       && !flag_gnu89_inline
2283       && (DECL_DECLARED_INLINE_P (newdecl)
2284           || DECL_DECLARED_INLINE_P (olddecl))
2285       && (!DECL_DECLARED_INLINE_P (newdecl)
2286           || !DECL_DECLARED_INLINE_P (olddecl)
2287           || !DECL_EXTERNAL (olddecl))
2288       && DECL_EXTERNAL (newdecl)
2289       && !lookup_attribute ("gnu_inline", DECL_ATTRIBUTES (newdecl))
2290       && !current_function_decl)
2291     DECL_EXTERNAL (newdecl) = 0;
2292
2293   if (DECL_EXTERNAL (newdecl))
2294     {
2295       TREE_STATIC (newdecl) = TREE_STATIC (olddecl);
2296       DECL_EXTERNAL (newdecl) = DECL_EXTERNAL (olddecl);
2297
2298       /* An extern decl does not override previous storage class.  */
2299       TREE_PUBLIC (newdecl) = TREE_PUBLIC (olddecl);
2300       if (!DECL_EXTERNAL (newdecl))
2301         {
2302           DECL_CONTEXT (newdecl) = DECL_CONTEXT (olddecl);
2303           DECL_COMMON (newdecl) = DECL_COMMON (olddecl);
2304         }
2305     }
2306   else
2307     {
2308       TREE_STATIC (olddecl) = TREE_STATIC (newdecl);
2309       TREE_PUBLIC (olddecl) = TREE_PUBLIC (newdecl);
2310     }
2311
2312   if (TREE_CODE (newdecl) == FUNCTION_DECL)
2313     {
2314       /* If we're redefining a function previously defined as extern
2315          inline, make sure we emit debug info for the inline before we
2316          throw it away, in case it was inlined into a function that
2317          hasn't been written out yet.  */
2318       if (new_is_definition && DECL_INITIAL (olddecl))
2319         /* The new defn must not be inline.  */
2320         DECL_UNINLINABLE (newdecl) = 1;
2321       else
2322         {
2323           /* If either decl says `inline', this fn is inline, unless
2324              its definition was passed already.  */
2325           if (DECL_DECLARED_INLINE_P (newdecl)
2326               || DECL_DECLARED_INLINE_P (olddecl))
2327             DECL_DECLARED_INLINE_P (newdecl) = 1;
2328
2329           DECL_UNINLINABLE (newdecl) = DECL_UNINLINABLE (olddecl)
2330             = (DECL_UNINLINABLE (newdecl) || DECL_UNINLINABLE (olddecl));
2331
2332           DECL_DISREGARD_INLINE_LIMITS (newdecl)
2333             = DECL_DISREGARD_INLINE_LIMITS (olddecl)
2334             = (DECL_DISREGARD_INLINE_LIMITS (newdecl)
2335                || DECL_DISREGARD_INLINE_LIMITS (olddecl));
2336         }
2337
2338       if (DECL_BUILT_IN (olddecl))
2339         {
2340           /* If redeclaring a builtin function, it stays built in.
2341              But it gets tagged as having been declared.  */
2342           DECL_BUILT_IN_CLASS (newdecl) = DECL_BUILT_IN_CLASS (olddecl);
2343           DECL_FUNCTION_CODE (newdecl) = DECL_FUNCTION_CODE (olddecl);
2344           C_DECL_DECLARED_BUILTIN (newdecl) = 1;
2345           if (new_is_prototype)
2346             C_DECL_BUILTIN_PROTOTYPE (newdecl) = 0;
2347           else
2348             C_DECL_BUILTIN_PROTOTYPE (newdecl)
2349               = C_DECL_BUILTIN_PROTOTYPE (olddecl);
2350         }
2351
2352       /* Preserve function specific target and optimization options */
2353       if (DECL_FUNCTION_SPECIFIC_TARGET (olddecl)
2354           && !DECL_FUNCTION_SPECIFIC_TARGET (newdecl))
2355         DECL_FUNCTION_SPECIFIC_TARGET (newdecl)
2356           = DECL_FUNCTION_SPECIFIC_TARGET (olddecl);
2357
2358       if (DECL_FUNCTION_SPECIFIC_OPTIMIZATION (olddecl)
2359           && !DECL_FUNCTION_SPECIFIC_OPTIMIZATION (newdecl))
2360         DECL_FUNCTION_SPECIFIC_OPTIMIZATION (newdecl)
2361           = DECL_FUNCTION_SPECIFIC_OPTIMIZATION (olddecl);
2362
2363       /* Also preserve various other info from the definition.  */
2364       if (!new_is_definition)
2365         {
2366           tree t;
2367           DECL_RESULT (newdecl) = DECL_RESULT (olddecl);
2368           DECL_INITIAL (newdecl) = DECL_INITIAL (olddecl);
2369           DECL_STRUCT_FUNCTION (newdecl) = DECL_STRUCT_FUNCTION (olddecl);
2370           DECL_SAVED_TREE (newdecl) = DECL_SAVED_TREE (olddecl);
2371           gimple_set_body (newdecl, gimple_body (olddecl));
2372           DECL_ARGUMENTS (newdecl) = copy_list (DECL_ARGUMENTS (olddecl));
2373           for (t = DECL_ARGUMENTS (newdecl); t ; t = TREE_CHAIN (t))
2374             DECL_CONTEXT (t) = newdecl;
2375
2376           /* See if we've got a function to instantiate from.  */
2377           if (DECL_SAVED_TREE (olddecl))
2378             DECL_ABSTRACT_ORIGIN (newdecl)
2379               = DECL_ABSTRACT_ORIGIN (olddecl);
2380         }
2381     }
2382
2383   extern_changed = DECL_EXTERNAL (olddecl) && !DECL_EXTERNAL (newdecl);
2384
2385   /* Merge the USED information.  */
2386   if (TREE_USED (olddecl))
2387     TREE_USED (newdecl) = 1;
2388   else if (TREE_USED (newdecl))
2389     TREE_USED (olddecl) = 1;
2390   if (DECL_PRESERVE_P (olddecl))
2391     DECL_PRESERVE_P (newdecl) = 1;
2392   else if (DECL_PRESERVE_P (newdecl))
2393     DECL_PRESERVE_P (olddecl) = 1;
2394
2395   /* Copy most of the decl-specific fields of NEWDECL into OLDDECL.
2396      But preserve OLDDECL's DECL_UID, DECL_CONTEXT and
2397      DECL_ARGUMENTS (if appropriate).  */
2398   {
2399     unsigned olddecl_uid = DECL_UID (olddecl);
2400     tree olddecl_context = DECL_CONTEXT (olddecl);
2401     tree olddecl_arguments = NULL;
2402     if (TREE_CODE (olddecl) == FUNCTION_DECL)
2403       olddecl_arguments = DECL_ARGUMENTS (olddecl);
2404
2405     memcpy ((char *) olddecl + sizeof (struct tree_common),
2406             (char *) newdecl + sizeof (struct tree_common),
2407             sizeof (struct tree_decl_common) - sizeof (struct tree_common));
2408     switch (TREE_CODE (olddecl))
2409       {
2410       case FUNCTION_DECL:
2411         gimple_set_body (olddecl, gimple_body (newdecl));
2412         /* fall through */
2413
2414       case FIELD_DECL:
2415       case VAR_DECL:
2416       case PARM_DECL:
2417       case LABEL_DECL:
2418       case RESULT_DECL:
2419       case CONST_DECL:
2420       case TYPE_DECL:
2421         memcpy ((char *) olddecl + sizeof (struct tree_decl_common),
2422                 (char *) newdecl + sizeof (struct tree_decl_common),
2423                 tree_code_size (TREE_CODE (olddecl)) - sizeof (struct tree_decl_common));
2424         break;
2425
2426       default:
2427
2428         memcpy ((char *) olddecl + sizeof (struct tree_decl_common),
2429                 (char *) newdecl + sizeof (struct tree_decl_common),
2430                 sizeof (struct tree_decl_non_common) - sizeof (struct tree_decl_common));
2431       }
2432     DECL_UID (olddecl) = olddecl_uid;
2433     DECL_CONTEXT (olddecl) = olddecl_context;
2434     if (TREE_CODE (olddecl) == FUNCTION_DECL)
2435       DECL_ARGUMENTS (olddecl) = olddecl_arguments;
2436   }
2437
2438   /* If OLDDECL had its DECL_RTL instantiated, re-invoke make_decl_rtl
2439      so that encode_section_info has a chance to look at the new decl
2440      flags and attributes.  */
2441   if (DECL_RTL_SET_P (olddecl)
2442       && (TREE_CODE (olddecl) == FUNCTION_DECL
2443           || (TREE_CODE (olddecl) == VAR_DECL
2444               && TREE_STATIC (olddecl))))
2445     make_decl_rtl (olddecl);
2446
2447   /* If we changed a function from DECL_EXTERNAL to !DECL_EXTERNAL,
2448      and the definition is coming from the old version, cgraph needs
2449      to be called again.  */
2450   if (extern_changed && !new_is_definition
2451       && TREE_CODE (olddecl) == FUNCTION_DECL && DECL_INITIAL (olddecl))
2452     cgraph_mark_if_needed (olddecl);
2453 }
2454
2455 /* Handle when a new declaration NEWDECL has the same name as an old
2456    one OLDDECL in the same binding contour.  Prints an error message
2457    if appropriate.
2458
2459    If safely possible, alter OLDDECL to look like NEWDECL, and return
2460    true.  Otherwise, return false.  */
2461
2462 static bool
2463 duplicate_decls (tree newdecl, tree olddecl)
2464 {
2465   tree newtype = NULL, oldtype = NULL;
2466
2467   if (!diagnose_mismatched_decls (newdecl, olddecl, &newtype, &oldtype))
2468     {
2469       /* Avoid `unused variable' and other warnings for OLDDECL.  */
2470       TREE_NO_WARNING (olddecl) = 1;
2471       return false;
2472     }
2473
2474   merge_decls (newdecl, olddecl, newtype, oldtype);
2475   return true;
2476 }
2477
2478 \f
2479 /* Check whether decl-node NEW_DECL shadows an existing declaration.  */
2480 static void
2481 warn_if_shadowing (tree new_decl)
2482 {
2483   struct c_binding *b;
2484
2485   /* Shadow warnings wanted?  */
2486   if (!warn_shadow
2487       /* No shadow warnings for internally generated vars.  */
2488       || DECL_IS_BUILTIN (new_decl)
2489       /* No shadow warnings for vars made for inlining.  */
2490       || DECL_FROM_INLINE (new_decl))
2491     return;
2492
2493   /* Is anything being shadowed?  Invisible decls do not count.  */
2494   for (b = I_SYMBOL_BINDING (DECL_NAME (new_decl)); b; b = b->shadowed)
2495     if (b->decl && b->decl != new_decl && !b->invisible)
2496       {
2497         tree old_decl = b->decl;
2498
2499         if (old_decl == error_mark_node)
2500           {
2501             warning (OPT_Wshadow, "declaration of %q+D shadows previous "
2502                      "non-variable", new_decl);
2503             break;
2504           }
2505         else if (TREE_CODE (old_decl) == PARM_DECL)
2506           warning (OPT_Wshadow, "declaration of %q+D shadows a parameter",
2507                    new_decl);
2508         else if (DECL_FILE_SCOPE_P (old_decl))
2509           warning (OPT_Wshadow, "declaration of %q+D shadows a global "
2510                    "declaration", new_decl);
2511         else if (TREE_CODE (old_decl) == FUNCTION_DECL
2512                  && DECL_BUILT_IN (old_decl))
2513           {
2514             warning (OPT_Wshadow, "declaration of %q+D shadows "
2515                      "a built-in function", new_decl);
2516             break;
2517           }
2518         else
2519           warning (OPT_Wshadow, "declaration of %q+D shadows a previous local",
2520                    new_decl);
2521
2522         warning_at (DECL_SOURCE_LOCATION (old_decl), OPT_Wshadow,
2523                     "shadowed declaration is here");
2524
2525         break;
2526       }
2527 }
2528
2529 /* Record a decl-node X as belonging to the current lexical scope.
2530    Check for errors (such as an incompatible declaration for the same
2531    name already seen in the same scope).
2532
2533    Returns either X or an old decl for the same name.
2534    If an old decl is returned, it may have been smashed
2535    to agree with what X says.  */
2536
2537 tree
2538 pushdecl (tree x)
2539 {
2540   tree name = DECL_NAME (x);
2541   struct c_scope *scope = current_scope;
2542   struct c_binding *b;
2543   bool nested = false;
2544   location_t locus = DECL_SOURCE_LOCATION (x);
2545
2546   /* Must set DECL_CONTEXT for everything not at file scope or
2547      DECL_FILE_SCOPE_P won't work.  Local externs don't count
2548      unless they have initializers (which generate code).  */
2549   if (current_function_decl
2550       && ((TREE_CODE (x) != FUNCTION_DECL && TREE_CODE (x) != VAR_DECL)
2551           || DECL_INITIAL (x) || !DECL_EXTERNAL (x)))
2552     DECL_CONTEXT (x) = current_function_decl;
2553
2554   /* Anonymous decls are just inserted in the scope.  */
2555   if (!name)
2556     {
2557       bind (name, x, scope, /*invisible=*/false, /*nested=*/false,
2558             locus);
2559       return x;
2560     }
2561
2562   /* First, see if there is another declaration with the same name in
2563      the current scope.  If there is, duplicate_decls may do all the
2564      work for us.  If duplicate_decls returns false, that indicates
2565      two incompatible decls in the same scope; we are to silently
2566      replace the old one (duplicate_decls has issued all appropriate
2567      diagnostics).  In particular, we should not consider possible
2568      duplicates in the external scope, or shadowing.  */
2569   b = I_SYMBOL_BINDING (name);
2570   if (b && B_IN_SCOPE (b, scope))
2571     {
2572       struct c_binding *b_ext, *b_use;
2573       tree type = TREE_TYPE (x);
2574       tree visdecl = b->decl;
2575       tree vistype = TREE_TYPE (visdecl);
2576       if (TREE_CODE (TREE_TYPE (x)) == ARRAY_TYPE
2577           && COMPLETE_TYPE_P (TREE_TYPE (x)))
2578         b->inner_comp = false;
2579       b_use = b;
2580       b_ext = b;
2581       /* If this is an external linkage declaration, we should check
2582          for compatibility with the type in the external scope before
2583          setting the type at this scope based on the visible
2584          information only.  */
2585       if (TREE_PUBLIC (x) && TREE_PUBLIC (visdecl))
2586         {
2587           while (b_ext && !B_IN_EXTERNAL_SCOPE (b_ext))
2588             b_ext = b_ext->shadowed;
2589           if (b_ext)
2590             {
2591               b_use = b_ext;
2592               if (b_use->u.type)
2593                 TREE_TYPE (b_use->decl) = b_use->u.type;
2594             }
2595         }
2596       if (duplicate_decls (x, b_use->decl))
2597         {
2598           if (b_use != b)
2599             {
2600               /* Save the updated type in the external scope and
2601                  restore the proper type for this scope.  */
2602               tree thistype;
2603               if (comptypes (vistype, type))
2604                 thistype = composite_type (vistype, type);
2605               else
2606                 thistype = TREE_TYPE (b_use->decl);
2607               b_use->u.type = TREE_TYPE (b_use->decl);
2608               if (TREE_CODE (b_use->decl) == FUNCTION_DECL
2609                   && DECL_BUILT_IN (b_use->decl))
2610                 thistype
2611                   = build_type_attribute_variant (thistype,
2612                                                   TYPE_ATTRIBUTES
2613                                                   (b_use->u.type));
2614               TREE_TYPE (b_use->decl) = thistype;
2615             }
2616           return b_use->decl;
2617         }
2618       else
2619         goto skip_external_and_shadow_checks;
2620     }
2621
2622   /* All declarations with external linkage, and all external
2623      references, go in the external scope, no matter what scope is
2624      current.  However, the binding in that scope is ignored for
2625      purposes of normal name lookup.  A separate binding structure is
2626      created in the requested scope; this governs the normal
2627      visibility of the symbol.
2628
2629      The binding in the externals scope is used exclusively for
2630      detecting duplicate declarations of the same object, no matter
2631      what scope they are in; this is what we do here.  (C99 6.2.7p2:
2632      All declarations that refer to the same object or function shall
2633      have compatible type; otherwise, the behavior is undefined.)  */
2634   if (DECL_EXTERNAL (x) || scope == file_scope)
2635     {
2636       tree type = TREE_TYPE (x);
2637       tree vistype = 0;
2638       tree visdecl = 0;
2639       bool type_saved = false;
2640       if (b && !B_IN_EXTERNAL_SCOPE (b)
2641           && (TREE_CODE (b->decl) == FUNCTION_DECL
2642               || TREE_CODE (b->decl) == VAR_DECL)
2643           && DECL_FILE_SCOPE_P (b->decl))
2644         {
2645           visdecl = b->decl;
2646           vistype = TREE_TYPE (visdecl);
2647         }
2648       if (scope != file_scope
2649           && !DECL_IN_SYSTEM_HEADER (x))
2650         warning (OPT_Wnested_externs, "nested extern declaration of %qD", x);
2651
2652       while (b && !B_IN_EXTERNAL_SCOPE (b))
2653         {
2654           /* If this decl might be modified, save its type.  This is
2655              done here rather than when the decl is first bound
2656              because the type may change after first binding, through
2657              being completed or through attributes being added.  If we
2658              encounter multiple such decls, only the first should have
2659              its type saved; the others will already have had their
2660              proper types saved and the types will not have changed as
2661              their scopes will not have been re-entered.  */
2662           if (DECL_P (b->decl) && DECL_FILE_SCOPE_P (b->decl) && !type_saved)
2663             {
2664               b->u.type = TREE_TYPE (b->decl);
2665               type_saved = true;
2666             }
2667           if (B_IN_FILE_SCOPE (b)
2668               && TREE_CODE (b->decl) == VAR_DECL
2669               && TREE_STATIC (b->decl)
2670               && TREE_CODE (TREE_TYPE (b->decl)) == ARRAY_TYPE
2671               && !TYPE_DOMAIN (TREE_TYPE (b->decl))
2672               && TREE_CODE (type) == ARRAY_TYPE
2673               && TYPE_DOMAIN (type)
2674               && TYPE_MAX_VALUE (TYPE_DOMAIN (type))
2675               && !integer_zerop (TYPE_MAX_VALUE (TYPE_DOMAIN (type))))
2676             {
2677               /* Array type completed in inner scope, which should be
2678                  diagnosed if the completion does not have size 1 and
2679                  it does not get completed in the file scope.  */
2680               b->inner_comp = true;
2681             }
2682           b = b->shadowed;
2683         }
2684
2685       /* If a matching external declaration has been found, set its
2686          type to the composite of all the types of that declaration.
2687          After the consistency checks, it will be reset to the
2688          composite of the visible types only.  */
2689       if (b && (TREE_PUBLIC (x) || same_translation_unit_p (x, b->decl))
2690           && b->u.type)
2691         TREE_TYPE (b->decl) = b->u.type;
2692
2693       /* The point of the same_translation_unit_p check here is,
2694          we want to detect a duplicate decl for a construct like
2695          foo() { extern bar(); } ... static bar();  but not if
2696          they are in different translation units.  In any case,
2697          the static does not go in the externals scope.  */
2698       if (b
2699           && (TREE_PUBLIC (x) || same_translation_unit_p (x, b->decl))
2700           && duplicate_decls (x, b->decl))
2701         {
2702           tree thistype;
2703           if (vistype)
2704             {
2705               if (comptypes (vistype, type))
2706                 thistype = composite_type (vistype, type);
2707               else
2708                 thistype = TREE_TYPE (b->decl);
2709             }
2710           else
2711             thistype = type;
2712           b->u.type = TREE_TYPE (b->decl);
2713           if (TREE_CODE (b->decl) == FUNCTION_DECL && DECL_BUILT_IN (b->decl))
2714             thistype
2715               = build_type_attribute_variant (thistype,
2716                                               TYPE_ATTRIBUTES (b->u.type));
2717           TREE_TYPE (b->decl) = thistype;
2718           bind (name, b->decl, scope, /*invisible=*/false, /*nested=*/true,
2719                 locus);
2720           return b->decl;
2721         }
2722       else if (TREE_PUBLIC (x))
2723         {
2724           if (visdecl && !b && duplicate_decls (x, visdecl))
2725             {
2726               /* An external declaration at block scope referring to a
2727                  visible entity with internal linkage.  The composite
2728                  type will already be correct for this scope, so we
2729                  just need to fall through to make the declaration in
2730                  this scope.  */
2731               nested = true;
2732               x = visdecl;
2733             }
2734           else
2735             {
2736               bind (name, x, external_scope, /*invisible=*/true,
2737                     /*nested=*/false, locus);
2738               nested = true;
2739             }
2740         }
2741     }
2742
2743   if (TREE_CODE (x) != PARM_DECL)
2744     warn_if_shadowing (x);
2745
2746  skip_external_and_shadow_checks:
2747   if (TREE_CODE (x) == TYPE_DECL)
2748     set_underlying_type (x);
2749
2750   bind (name, x, scope, /*invisible=*/false, nested, locus);
2751
2752   /* If x's type is incomplete because it's based on a
2753      structure or union which has not yet been fully declared,
2754      attach it to that structure or union type, so we can go
2755      back and complete the variable declaration later, if the
2756      structure or union gets fully declared.
2757
2758      If the input is erroneous, we can have error_mark in the type
2759      slot (e.g. "f(void a, ...)") - that doesn't count as an
2760      incomplete type.  */
2761   if (TREE_TYPE (x) != error_mark_node
2762       && !COMPLETE_TYPE_P (TREE_TYPE (x)))
2763     {
2764       tree element = TREE_TYPE (x);
2765
2766       while (TREE_CODE (element) == ARRAY_TYPE)
2767         element = TREE_TYPE (element);
2768       element = TYPE_MAIN_VARIANT (element);
2769
2770       if ((TREE_CODE (element) == RECORD_TYPE
2771            || TREE_CODE (element) == UNION_TYPE)
2772           && (TREE_CODE (x) != TYPE_DECL
2773               || TREE_CODE (TREE_TYPE (x)) == ARRAY_TYPE)
2774           && !COMPLETE_TYPE_P (element))
2775         C_TYPE_INCOMPLETE_VARS (element)
2776           = tree_cons (NULL_TREE, x, C_TYPE_INCOMPLETE_VARS (element));
2777     }
2778   return x;
2779 }
2780
2781 /* Record X as belonging to file scope.
2782    This is used only internally by the Objective-C front end,
2783    and is limited to its needs.  duplicate_decls is not called;
2784    if there is any preexisting decl for this identifier, it is an ICE.  */
2785
2786 tree
2787 pushdecl_top_level (tree x)
2788 {
2789   tree name;
2790   bool nested = false;
2791   gcc_assert (TREE_CODE (x) == VAR_DECL || TREE_CODE (x) == CONST_DECL);
2792
2793   name = DECL_NAME (x);
2794
2795  gcc_assert (TREE_CODE (x) == CONST_DECL || !I_SYMBOL_BINDING (name));
2796
2797   if (TREE_PUBLIC (x))
2798     {
2799       bind (name, x, external_scope, /*invisible=*/true, /*nested=*/false,
2800             UNKNOWN_LOCATION);
2801       nested = true;
2802     }
2803   if (file_scope)
2804     bind (name, x, file_scope, /*invisible=*/false, nested, UNKNOWN_LOCATION);
2805
2806   return x;
2807 }
2808 \f
2809 static void
2810 implicit_decl_warning (tree id, tree olddecl)
2811 {
2812   if (warn_implicit_function_declaration)
2813     {
2814       bool warned;
2815
2816       if (flag_isoc99)
2817         warned = pedwarn (input_location, OPT_Wimplicit_function_declaration,
2818                           "implicit declaration of function %qE", id);
2819       else
2820         warned = warning (OPT_Wimplicit_function_declaration,
2821                           G_("implicit declaration of function %qE"), id);
2822       if (olddecl && warned)
2823         locate_old_decl (olddecl);
2824     }
2825 }
2826
2827 /* Generate an implicit declaration for identifier FUNCTIONID at LOC as a
2828    function of type int ().  */
2829
2830 tree
2831 implicitly_declare (location_t loc, tree functionid)
2832 {
2833   struct c_binding *b;
2834   tree decl = 0;
2835   tree asmspec_tree;
2836
2837   for (b = I_SYMBOL_BINDING (functionid); b; b = b->shadowed)
2838     {
2839       if (B_IN_SCOPE (b, external_scope))
2840         {
2841           decl = b->decl;
2842           break;
2843         }
2844     }
2845
2846   if (decl)
2847     {
2848       if (decl == error_mark_node)
2849         return decl;
2850
2851       /* FIXME: Objective-C has weird not-really-builtin functions
2852          which are supposed to be visible automatically.  They wind up
2853          in the external scope because they're pushed before the file
2854          scope gets created.  Catch this here and rebind them into the
2855          file scope.  */
2856       if (!DECL_BUILT_IN (decl) && DECL_IS_BUILTIN (decl))
2857         {
2858           bind (functionid, decl, file_scope,
2859                 /*invisible=*/false, /*nested=*/true,
2860                 DECL_SOURCE_LOCATION (decl));
2861           return decl;
2862         }
2863       else
2864         {
2865           tree newtype = default_function_type;
2866           if (b->u.type)
2867             TREE_TYPE (decl) = b->u.type;
2868           /* Implicit declaration of a function already declared
2869              (somehow) in a different scope, or as a built-in.
2870              If this is the first time this has happened, warn;
2871              then recycle the old declaration but with the new type.  */
2872           if (!C_DECL_IMPLICIT (decl))
2873             {
2874               implicit_decl_warning (functionid, decl);
2875               C_DECL_IMPLICIT (decl) = 1;
2876             }
2877           if (DECL_BUILT_IN (decl))
2878             {
2879               newtype = build_type_attribute_variant (newtype,
2880                                                       TYPE_ATTRIBUTES
2881                                                       (TREE_TYPE (decl)));
2882               if (!comptypes (newtype, TREE_TYPE (decl)))
2883                 {
2884                   warning_at (loc, 0, "incompatible implicit declaration of "
2885                               "built-in function %qD", decl);
2886                   newtype = TREE_TYPE (decl);
2887                 }
2888             }
2889           else
2890             {
2891               if (!comptypes (newtype, TREE_TYPE (decl)))
2892                 {
2893                   error_at (loc, "incompatible implicit declaration of function %qD", decl);
2894                   locate_old_decl (decl);
2895                 }
2896             }
2897           b->u.type = TREE_TYPE (decl);
2898           TREE_TYPE (decl) = newtype;
2899           bind (functionid, decl, current_scope,
2900                 /*invisible=*/false, /*nested=*/true,
2901                 DECL_SOURCE_LOCATION (decl));
2902           return decl;
2903         }
2904     }
2905
2906   /* Not seen before.  */
2907   decl = build_decl (loc, FUNCTION_DECL, functionid, default_function_type);
2908   DECL_EXTERNAL (decl) = 1;
2909   TREE_PUBLIC (decl) = 1;
2910   C_DECL_IMPLICIT (decl) = 1;
2911   implicit_decl_warning (functionid, 0);
2912   asmspec_tree = maybe_apply_renaming_pragma (decl, /*asmname=*/NULL);
2913   if (asmspec_tree)
2914     set_user_assembler_name (decl, TREE_STRING_POINTER (asmspec_tree));
2915
2916   /* C89 says implicit declarations are in the innermost block.
2917      So we record the decl in the standard fashion.  */
2918   decl = pushdecl (decl);
2919
2920   /* No need to call objc_check_decl here - it's a function type.  */
2921   rest_of_decl_compilation (decl, 0, 0);
2922
2923   /* Write a record describing this implicit function declaration
2924      to the prototypes file (if requested).  */
2925   gen_aux_info_record (decl, 0, 1, 0);
2926
2927   /* Possibly apply some default attributes to this implicit declaration.  */
2928   decl_attributes (&decl, NULL_TREE, 0);
2929
2930   return decl;
2931 }
2932
2933 /* Issue an error message for a reference to an undeclared variable
2934    ID, including a reference to a builtin outside of function-call
2935    context.  Establish a binding of the identifier to error_mark_node
2936    in an appropriate scope, which will suppress further errors for the
2937    same identifier.  The error message should be given location LOC.  */
2938 void
2939 undeclared_variable (location_t loc, tree id)
2940 {
2941   static bool already = false;
2942   struct c_scope *scope;
2943
2944   if (current_function_decl == 0)
2945     {
2946       error_at (loc, "%qE undeclared here (not in a function)", id);
2947       scope = current_scope;
2948     }
2949   else
2950     {
2951       error_at (loc, "%qE undeclared (first use in this function)", id);
2952       if (!already)
2953         {
2954           inform (loc, "each undeclared identifier is reported only"
2955                   " once for each function it appears in");
2956           already = true;
2957         }
2958
2959       /* If we are parsing old-style parameter decls, current_function_decl
2960          will be nonnull but current_function_scope will be null.  */
2961       scope = current_function_scope ? current_function_scope : current_scope;
2962     }
2963   bind (id, error_mark_node, scope, /*invisible=*/false, /*nested=*/false,
2964         UNKNOWN_LOCATION);
2965 }
2966 \f
2967 /* Subroutine of lookup_label, declare_label, define_label: construct a
2968    LABEL_DECL with all the proper frills.  Also create a struct
2969    c_label_vars initialized for the current scope.  */
2970
2971 static tree
2972 make_label (location_t location, tree name, bool defining,
2973             struct c_label_vars **p_label_vars)
2974 {
2975   tree label = build_decl (location, LABEL_DECL, name, void_type_node);
2976   struct c_label_vars *label_vars;
2977
2978   DECL_CONTEXT (label) = current_function_decl;
2979   DECL_MODE (label) = VOIDmode;
2980
2981   label_vars = GGC_NEW (struct c_label_vars);
2982   label_vars->shadowed = NULL;
2983   set_spot_bindings (&label_vars->label_bindings, defining);
2984   label_vars->decls_in_scope = make_tree_vector ();
2985   label_vars->gotos = VEC_alloc (c_goto_bindings_p, gc, 0);
2986   *p_label_vars = label_vars;
2987
2988   return label;
2989 }
2990
2991 /* Get the LABEL_DECL corresponding to identifier NAME as a label.
2992    Create one if none exists so far for the current function.
2993    This is called when a label is used in a goto expression or
2994    has its address taken.  */
2995
2996 tree
2997 lookup_label (tree name)
2998 {
2999   tree label;
3000   struct c_label_vars *label_vars;
3001
3002   if (current_function_decl == 0)
3003     {
3004       error ("label %qE referenced outside of any function", name);
3005       return 0;
3006     }
3007
3008   /* Use a label already defined or ref'd with this name, but not if
3009      it is inherited from a containing function and wasn't declared
3010      using __label__.  */
3011   label = I_LABEL_DECL (name);
3012   if (label && (DECL_CONTEXT (label) == current_function_decl
3013                 || C_DECLARED_LABEL_FLAG (label)))
3014     {
3015       /* If the label has only been declared, update its apparent
3016          location to point here, for better diagnostics if it
3017          turns out not to have been defined.  */
3018       if (DECL_INITIAL (label) == NULL_TREE)
3019         DECL_SOURCE_LOCATION (label) = input_location;
3020       return label;
3021     }
3022
3023   /* No label binding for that identifier; make one.  */
3024   label = make_label (input_location, name, false, &label_vars);
3025
3026   /* Ordinary labels go in the current function scope.  */
3027   bind_label (name, label, current_function_scope, label_vars);
3028
3029   return label;
3030 }
3031
3032 /* Issue a warning about DECL for a goto statement at GOTO_LOC going
3033    to LABEL.  */
3034
3035 static void
3036 warn_about_goto (location_t goto_loc, tree label, tree decl)
3037 {
3038   if (variably_modified_type_p (TREE_TYPE (decl), NULL_TREE))
3039     error_at (goto_loc,
3040               "jump into scope of identifier with variably modified type");
3041   else
3042     warning_at (goto_loc, OPT_Wjump_misses_init,
3043                 "jump skips variable initialization");
3044   inform (DECL_SOURCE_LOCATION (label), "label %qD defined here", label);
3045   inform (DECL_SOURCE_LOCATION (decl), "%qD declared here", decl);
3046 }
3047
3048 /* Look up a label because of a goto statement.  This is like
3049    lookup_label, but also issues any appropriate warnings.  */
3050
3051 tree
3052 lookup_label_for_goto (location_t loc, tree name)
3053 {
3054   tree label;
3055   struct c_label_vars *label_vars;
3056   unsigned int ix;
3057   tree decl;
3058
3059   label = lookup_label (name);
3060   if (label == NULL_TREE)
3061     return NULL_TREE;
3062
3063   /* If we are jumping to a different function, we can't issue any
3064      useful warnings.  */
3065   if (DECL_CONTEXT (label) != current_function_decl)
3066     {
3067       gcc_assert (C_DECLARED_LABEL_FLAG (label));
3068       return label;
3069     }
3070
3071   label_vars = I_LABEL_BINDING (name)->u.label;
3072
3073   /* If the label has not yet been defined, then push this goto on a
3074      list for possible later warnings.  */
3075   if (label_vars->label_bindings.scope == NULL)
3076     {
3077       struct c_goto_bindings *g;
3078
3079       g = GGC_NEW (struct c_goto_bindings);
3080       g->loc = loc;
3081       set_spot_bindings (&g->goto_bindings, true);
3082       VEC_safe_push (c_goto_bindings_p, gc, label_vars->gotos, g);
3083       return label;
3084     }
3085
3086   /* If there are any decls in label_vars->decls_in_scope, then this
3087      goto has missed the declaration of the decl.  This happens for a
3088      case like
3089        int i = 1;
3090       lab:
3091        ...
3092        goto lab;
3093      Issue a warning or error.  */
3094   for (ix = 0; VEC_iterate (tree, label_vars->decls_in_scope, ix, decl); ++ix)
3095     warn_about_goto (loc, label, decl);
3096
3097   if (label_vars->label_bindings.left_stmt_expr)
3098     {
3099       error_at (loc, "jump into statement expression");
3100       inform (DECL_SOURCE_LOCATION (label), "label %qD defined here", label);
3101     }
3102
3103   return label;
3104 }
3105
3106 /* Make a label named NAME in the current function, shadowing silently
3107    any that may be inherited from containing functions or containing
3108    scopes.  This is called for __label__ declarations.  */
3109
3110 tree
3111 declare_label (tree name)
3112 {
3113   struct c_binding *b = I_LABEL_BINDING (name);
3114   tree label;
3115   struct c_label_vars *label_vars;
3116
3117   /* Check to make sure that the label hasn't already been declared
3118      at this scope */
3119   if (b && B_IN_CURRENT_SCOPE (b))
3120     {
3121       error ("duplicate label declaration %qE", name);
3122       locate_old_decl (b->decl);
3123
3124       /* Just use the previous declaration.  */
3125       return b->decl;
3126     }
3127
3128   label = make_label (input_location, name, false, &label_vars);
3129   C_DECLARED_LABEL_FLAG (label) = 1;
3130
3131   /* Declared labels go in the current scope.  */
3132   bind_label (name, label, current_scope, label_vars);
3133
3134   return label;
3135 }
3136
3137 /* When we define a label, issue any appropriate warnings if there are
3138    any gotos earlier in the function which jump to this label.  */
3139
3140 static void
3141 check_earlier_gotos (tree label, struct c_label_vars* label_vars)
3142 {
3143   unsigned int ix;
3144   struct c_goto_bindings *g;
3145
3146   for (ix = 0;
3147        VEC_iterate (c_goto_bindings_p, label_vars->gotos, ix, g);
3148        ++ix)
3149     {
3150       struct c_binding *b;
3151       struct c_scope *scope;
3152
3153       /* We have a goto to this label.  The goto is going forward.  In
3154          g->scope, the goto is going to skip any binding which was
3155          defined after g->bindings_in_scope.  */
3156       for (b = g->goto_bindings.scope->bindings;
3157            b != g->goto_bindings.bindings_in_scope;
3158            b = b->prev)
3159         {
3160           if (decl_jump_unsafe (b->decl))
3161             warn_about_goto (g->loc, label, b->decl);
3162         }
3163
3164       /* We also need to warn about decls defined in any scopes
3165          between the scope of the label and the scope of the goto.  */
3166       for (scope = label_vars->label_bindings.scope;
3167            scope != g->goto_bindings.scope;
3168            scope = scope->outer)
3169         {
3170           gcc_assert (scope != NULL);
3171           if (scope == label_vars->label_bindings.scope)
3172             b = label_vars->label_bindings.bindings_in_scope;
3173           else
3174             b = scope->bindings;
3175           for (; b != NULL; b = b->prev)
3176             {
3177               if (decl_jump_unsafe (b->decl))
3178                 warn_about_goto (g->loc, label, b->decl);
3179             }
3180         }
3181
3182       if (g->goto_bindings.stmt_exprs > 0)
3183         {
3184           error_at (g->loc, "jump into statement expression");
3185           inform (DECL_SOURCE_LOCATION (label), "label %qD defined here",
3186                   label);
3187         }
3188     }
3189
3190   /* Now that the label is defined, we will issue warnings about
3191      subsequent gotos to this label when we see them.  */
3192   VEC_truncate (c_goto_bindings_p, label_vars->gotos, 0);
3193   label_vars->gotos = NULL;
3194 }
3195
3196 /* Define a label, specifying the location in the source file.
3197    Return the LABEL_DECL node for the label, if the definition is valid.
3198    Otherwise return 0.  */
3199
3200 tree
3201 define_label (location_t location, tree name)
3202 {
3203   /* Find any preexisting label with this name.  It is an error
3204      if that label has already been defined in this function, or
3205      if there is a containing function with a declared label with
3206      the same name.  */
3207   tree label = I_LABEL_DECL (name);
3208
3209   if (label
3210       && ((DECL_CONTEXT (label) == current_function_decl
3211            && DECL_INITIAL (label) != 0)
3212           || (DECL_CONTEXT (label) != current_function_decl
3213               && C_DECLARED_LABEL_FLAG (label))))
3214     {
3215       error_at (location, "duplicate label %qD", label);
3216       locate_old_decl (label);
3217       return 0;
3218     }
3219   else if (label && DECL_CONTEXT (label) == current_function_decl)
3220     {
3221       struct c_label_vars *label_vars = I_LABEL_BINDING (name)->u.label;
3222
3223       /* The label has been used or declared already in this function,
3224          but not defined.  Update its location to point to this
3225          definition.  */
3226       DECL_SOURCE_LOCATION (label) = location;
3227       set_spot_bindings (&label_vars->label_bindings, true);
3228
3229       /* Issue warnings as required about any goto statements from
3230          earlier in the function.  */
3231       check_earlier_gotos (label, label_vars);
3232     }
3233   else
3234     {
3235       struct c_label_vars *label_vars;
3236
3237       /* No label binding for that identifier; make one.  */
3238       label = make_label (location, name, true, &label_vars);
3239
3240       /* Ordinary labels go in the current function scope.  */
3241       bind_label (name, label, current_function_scope, label_vars);
3242     }
3243
3244   if (!in_system_header && lookup_name (name))
3245     warning_at (location, OPT_Wtraditional,
3246                 "traditional C lacks a separate namespace "
3247                 "for labels, identifier %qE conflicts", name);
3248
3249   /* Mark label as having been defined.  */
3250   DECL_INITIAL (label) = error_mark_node;
3251   return label;
3252 }
3253 \f
3254 /* Get the bindings for a new switch statement.  This is used to issue
3255    warnings as appropriate for jumps from the switch to case or
3256    default labels.  */
3257
3258 struct c_spot_bindings *
3259 c_get_switch_bindings (void)
3260 {
3261   struct c_spot_bindings *switch_bindings;
3262
3263   switch_bindings = XNEW (struct c_spot_bindings);
3264   set_spot_bindings (switch_bindings, true);
3265   return switch_bindings;
3266 }
3267
3268 void
3269 c_release_switch_bindings (struct c_spot_bindings *bindings)
3270 {
3271   gcc_assert (bindings->stmt_exprs == 0 && !bindings->left_stmt_expr);
3272   XDELETE (bindings);
3273 }
3274
3275 /* This is called at the point of a case or default label to issue
3276    warnings about decls as needed.  It returns true if it found an
3277    error, not just a warning.  */
3278
3279 bool
3280 c_check_switch_jump_warnings (struct c_spot_bindings *switch_bindings,
3281                               location_t switch_loc, location_t case_loc)
3282 {
3283   bool saw_error;
3284   struct c_scope *scope;
3285
3286   saw_error = false;
3287   for (scope = current_scope;
3288        scope != switch_bindings->scope;
3289        scope = scope->outer)
3290     {
3291       struct c_binding *b;
3292
3293       gcc_assert (scope != NULL);
3294       for (b = scope->bindings; b != NULL; b = b->prev)
3295         {
3296           if (decl_jump_unsafe (b->decl))
3297             {
3298               if (variably_modified_type_p (TREE_TYPE (b->decl), NULL_TREE))
3299                 {
3300                   saw_error = true;
3301                   error_at (case_loc,
3302                             ("switch jumps into scope of identifier with "
3303                              "variably modified type"));
3304                 }
3305               else
3306                 warning_at (case_loc, OPT_Wjump_misses_init,
3307                             "switch jumps over variable initialization");
3308               inform (switch_loc, "switch starts here");
3309               inform (DECL_SOURCE_LOCATION (b->decl), "%qD declared here",
3310                       b->decl);
3311             }
3312         }
3313     }
3314
3315   if (switch_bindings->stmt_exprs > 0)
3316     {
3317       saw_error = true;
3318       error_at (case_loc, "switch jumps into statement expression");
3319       inform (switch_loc, "switch starts here");
3320     }
3321
3322   return saw_error;
3323 }
3324 \f
3325 /* Given NAME, an IDENTIFIER_NODE,
3326    return the structure (or union or enum) definition for that name.
3327    If THISLEVEL_ONLY is nonzero, searches only the current_scope.
3328    CODE says which kind of type the caller wants;
3329    it is RECORD_TYPE or UNION_TYPE or ENUMERAL_TYPE.
3330    If PLOC is not NULL and this returns non-null, it sets *PLOC to the
3331    location where the tag was defined.
3332    If the wrong kind of type is found, an error is reported.  */
3333
3334 static tree
3335 lookup_tag (enum tree_code code, tree name, int thislevel_only,
3336             location_t *ploc)
3337 {
3338   struct c_binding *b = I_TAG_BINDING (name);
3339   int thislevel = 0;
3340
3341   if (!b || !b->decl)
3342     return 0;
3343
3344   /* We only care about whether it's in this level if
3345      thislevel_only was set or it might be a type clash.  */
3346   if (thislevel_only || TREE_CODE (b->decl) != code)
3347     {
3348       /* For our purposes, a tag in the external scope is the same as
3349          a tag in the file scope.  (Primarily relevant to Objective-C
3350          and its builtin structure tags, which get pushed before the
3351          file scope is created.)  */
3352       if (B_IN_CURRENT_SCOPE (b)
3353           || (current_scope == file_scope && B_IN_EXTERNAL_SCOPE (b)))
3354         thislevel = 1;
3355     }
3356
3357   if (thislevel_only && !thislevel)
3358     return 0;
3359
3360   if (TREE_CODE (b->decl) != code)
3361     {
3362       /* Definition isn't the kind we were looking for.  */
3363       pending_invalid_xref = name;
3364       pending_invalid_xref_location = input_location;
3365
3366       /* If in the same binding level as a declaration as a tag
3367          of a different type, this must not be allowed to
3368          shadow that tag, so give the error immediately.
3369          (For example, "struct foo; union foo;" is invalid.)  */
3370       if (thislevel)
3371         pending_xref_error ();
3372     }
3373
3374   if (ploc != NULL)
3375     *ploc = b->locus;
3376
3377   return b->decl;
3378 }
3379
3380 /* Print an error message now
3381    for a recent invalid struct, union or enum cross reference.
3382    We don't print them immediately because they are not invalid
3383    when used in the `struct foo;' construct for shadowing.  */
3384
3385 void
3386 pending_xref_error (void)
3387 {
3388   if (pending_invalid_xref != 0)
3389     error_at (pending_invalid_xref_location, "%qE defined as wrong kind of tag",
3390               pending_invalid_xref);
3391   pending_invalid_xref = 0;
3392 }
3393
3394 \f
3395 /* Look up NAME in the current scope and its superiors
3396    in the namespace of variables, functions and typedefs.
3397    Return a ..._DECL node of some kind representing its definition,
3398    or return 0 if it is undefined.  */
3399
3400 tree
3401 lookup_name (tree name)
3402 {
3403   struct c_binding *b = I_SYMBOL_BINDING (name);
3404   if (b && !b->invisible)
3405     return b->decl;
3406   return 0;
3407 }
3408
3409 /* Similar to `lookup_name' but look only at the indicated scope.  */
3410
3411 static tree
3412 lookup_name_in_scope (tree name, struct c_scope *scope)
3413 {
3414   struct c_binding *b;
3415
3416   for (b = I_SYMBOL_BINDING (name); b; b = b->shadowed)
3417     if (B_IN_SCOPE (b, scope))
3418       return b->decl;
3419   return 0;
3420 }
3421 \f
3422 /* Create the predefined scalar types of C,
3423    and some nodes representing standard constants (0, 1, (void *) 0).
3424    Initialize the global scope.
3425    Make definitions for built-in primitive functions.  */
3426
3427 void
3428 c_init_decl_processing (void)
3429 {
3430   location_t save_loc = input_location;
3431
3432   /* Initialize reserved words for parser.  */
3433   c_parse_init ();
3434
3435   current_function_decl = 0;
3436
3437   gcc_obstack_init (&parser_obstack);
3438
3439   /* Make the externals scope.  */
3440   push_scope ();
3441   external_scope = current_scope;
3442
3443   /* Declarations from c_common_nodes_and_builtins must not be associated
3444      with this input file, lest we get differences between using and not
3445      using preprocessed headers.  */
3446   input_location = BUILTINS_LOCATION;
3447
3448   build_common_tree_nodes (flag_signed_char, false);
3449
3450   c_common_nodes_and_builtins ();
3451
3452   /* In C, comparisons and TRUTH_* expressions have type int.  */
3453   truthvalue_type_node = integer_type_node;
3454   truthvalue_true_node = integer_one_node;
3455   truthvalue_false_node = integer_zero_node;
3456
3457   /* Even in C99, which has a real boolean type.  */
3458   pushdecl (build_decl (UNKNOWN_LOCATION, TYPE_DECL, get_identifier ("_Bool"),
3459                         boolean_type_node));
3460
3461   input_location = save_loc;
3462
3463   pedantic_lvalues = true;
3464
3465   make_fname_decl = c_make_fname_decl;
3466   start_fname_decls ();
3467 }
3468
3469 /* Create the VAR_DECL at LOC for __FUNCTION__ etc. ID is the name to
3470    give the decl, NAME is the initialization string and TYPE_DEP
3471    indicates whether NAME depended on the type of the function.  As we
3472    don't yet implement delayed emission of static data, we mark the
3473    decl as emitted so it is not placed in the output.  Anything using
3474    it must therefore pull out the STRING_CST initializer directly.
3475    FIXME.  */
3476
3477 static tree
3478 c_make_fname_decl (location_t loc, tree id, int type_dep)
3479 {
3480   const char *name = fname_as_string (type_dep);
3481   tree decl, type, init;
3482   size_t length = strlen (name);
3483
3484   type = build_array_type (char_type_node,
3485                            build_index_type (size_int (length)));
3486   type = c_build_qualified_type (type, TYPE_QUAL_CONST);
3487
3488   decl = build_decl (loc, VAR_DECL, id, type);
3489
3490   TREE_STATIC (decl) = 1;
3491   TREE_READONLY (decl) = 1;
3492   DECL_ARTIFICIAL (decl) = 1;
3493
3494   init = build_string (length + 1, name);
3495   free (CONST_CAST (char *, name));
3496   TREE_TYPE (init) = type;
3497   DECL_INITIAL (decl) = init;
3498
3499   TREE_USED (decl) = 1;
3500
3501   if (current_function_decl
3502       /* For invalid programs like this:
3503
3504          void foo()
3505          const char* p = __FUNCTION__;
3506
3507          the __FUNCTION__ is believed to appear in K&R style function
3508          parameter declarator.  In that case we still don't have
3509          function_scope.  */
3510       && (!errorcount || current_function_scope))
3511     {
3512       DECL_CONTEXT (decl) = current_function_decl;
3513       bind (id, decl, current_function_scope,
3514             /*invisible=*/false, /*nested=*/false, UNKNOWN_LOCATION);
3515     }
3516
3517   finish_decl (decl, loc, init, NULL_TREE, NULL_TREE);
3518
3519   return decl;
3520 }
3521
3522 tree
3523 c_builtin_function (tree decl)
3524 {
3525   tree type = TREE_TYPE (decl);
3526   tree   id = DECL_NAME (decl);
3527
3528   const char *name = IDENTIFIER_POINTER (id);
3529   C_DECL_BUILTIN_PROTOTYPE (decl) = (TYPE_ARG_TYPES (type) != 0);
3530
3531   /* Should never be called on a symbol with a preexisting meaning.  */
3532   gcc_assert (!I_SYMBOL_BINDING (id));
3533
3534   bind (id, decl, external_scope, /*invisible=*/true, /*nested=*/false,
3535         UNKNOWN_LOCATION);
3536
3537   /* Builtins in the implementation namespace are made visible without
3538      needing to be explicitly declared.  See push_file_scope.  */
3539   if (name[0] == '_' && (name[1] == '_' || ISUPPER (name[1])))
3540     {
3541       TREE_CHAIN (decl) = visible_builtins;
3542       visible_builtins = decl;
3543     }
3544
3545   return decl;
3546 }
3547
3548 tree
3549 c_builtin_function_ext_scope (tree decl)
3550 {
3551   tree type = TREE_TYPE (decl);
3552   tree   id = DECL_NAME (decl);
3553
3554   const char *name = IDENTIFIER_POINTER (id);
3555   C_DECL_BUILTIN_PROTOTYPE (decl) = (TYPE_ARG_TYPES (type) != 0);
3556
3557   /* Should never be called on a symbol with a preexisting meaning.  */
3558   gcc_assert (!I_SYMBOL_BINDING (id));
3559
3560   bind (id, decl, external_scope, /*invisible=*/false, /*nested=*/false,
3561         UNKNOWN_LOCATION);
3562
3563   /* Builtins in the implementation namespace are made visible without
3564      needing to be explicitly declared.  See push_file_scope.  */
3565   if (name[0] == '_' && (name[1] == '_' || ISUPPER (name[1])))
3566     {
3567       TREE_CHAIN (decl) = visible_builtins;
3568       visible_builtins = decl;
3569     }
3570
3571   return decl;
3572 }
3573 \f
3574 /* Called when a declaration is seen that contains no names to declare.
3575    If its type is a reference to a structure, union or enum inherited
3576    from a containing scope, shadow that tag name for the current scope
3577    with a forward reference.
3578    If its type defines a new named structure or union
3579    or defines an enum, it is valid but we need not do anything here.
3580    Otherwise, it is an error.  */
3581
3582 void
3583 shadow_tag (const struct c_declspecs *declspecs)
3584 {
3585   shadow_tag_warned (declspecs, 0);
3586 }
3587
3588 /* WARNED is 1 if we have done a pedwarn, 2 if we have done a warning,
3589    but no pedwarn.  */
3590 void
3591 shadow_tag_warned (const struct c_declspecs *declspecs, int warned)
3592 {
3593   bool found_tag = false;
3594
3595   if (declspecs->type && !declspecs->default_int_p && !declspecs->typedef_p)
3596     {
3597       tree value = declspecs->type;
3598       enum tree_code code = TREE_CODE (value);
3599
3600       if (code == RECORD_TYPE || code == UNION_TYPE || code == ENUMERAL_TYPE)
3601         /* Used to test also that TYPE_SIZE (value) != 0.
3602            That caused warning for `struct foo;' at top level in the file.  */
3603         {
3604           tree name = TYPE_NAME (value);
3605           tree t;
3606
3607           found_tag = true;
3608
3609           if (declspecs->restrict_p)
3610             {
3611               error ("invalid use of %<restrict%>");
3612               warned = 1;
3613             }
3614
3615           if (name == 0)
3616             {
3617               if (warned != 1 && code != ENUMERAL_TYPE)
3618                 /* Empty unnamed enum OK */
3619                 {
3620                   pedwarn (input_location, 0,
3621                            "unnamed struct/union that defines no instances");
3622                   warned = 1;
3623                 }
3624             }
3625           else if (!declspecs->tag_defined_p
3626                    && declspecs->storage_class != csc_none)
3627             {
3628               if (warned != 1)
3629                 pedwarn (input_location, 0,
3630                          "empty declaration with storage class specifier "
3631                          "does not redeclare tag");
3632               warned = 1;
3633               pending_xref_error ();
3634             }
3635           else if (!declspecs->tag_defined_p
3636                    && (declspecs->const_p
3637                        || declspecs->volatile_p
3638                        || declspecs->restrict_p
3639                        || declspecs->address_space))
3640             {
3641               if (warned != 1)
3642                 pedwarn (input_location, 0,
3643                          "empty declaration with type qualifier "
3644                           "does not redeclare tag");
3645               warned = 1;
3646               pending_xref_error ();
3647             }
3648           else
3649             {
3650               pending_invalid_xref = 0;
3651               t = lookup_tag (code, name, 1, NULL);
3652
3653               if (t == 0)
3654                 {
3655                   t = make_node (code);
3656                   pushtag (input_location, name, t);
3657                 }
3658             }
3659         }
3660       else
3661         {
3662           if (warned != 1 && !in_system_header)
3663             {
3664               pedwarn (input_location, 0,
3665                        "useless type name in empty declaration");
3666               warned = 1;
3667             }
3668         }
3669     }
3670   else if (warned != 1 && !in_system_header && declspecs->typedef_p)
3671     {
3672       pedwarn (input_location, 0, "useless type name in empty declaration");
3673       warned = 1;
3674     }
3675
3676   pending_invalid_xref = 0;
3677
3678   if (declspecs->inline_p)
3679     {
3680       error ("%<inline%> in empty declaration");
3681       warned = 1;
3682     }
3683
3684   if (current_scope == file_scope && declspecs->storage_class == csc_auto)
3685     {
3686       error ("%<auto%> in file-scope empty declaration");
3687       warned = 1;
3688     }
3689
3690   if (current_scope == file_scope && declspecs->storage_class == csc_register)
3691     {
3692       error ("%<register%> in file-scope empty declaration");
3693       warned = 1;
3694     }
3695
3696   if (!warned && !in_system_header && declspecs->storage_class != csc_none)
3697     {
3698       warning (0, "useless storage class specifier in empty declaration");
3699       warned = 2;
3700     }
3701
3702   if (!warned && !in_system_header && declspecs->thread_p)
3703     {
3704       warning (0, "useless %<__thread%> in empty declaration");
3705       warned = 2;
3706     }
3707
3708   if (!warned && !in_system_header && (declspecs->const_p
3709                                        || declspecs->volatile_p
3710                                        || declspecs->restrict_p
3711                                        || declspecs->address_space))
3712     {
3713       warning (0, "useless type qualifier in empty declaration");
3714       warned = 2;
3715     }
3716
3717   if (warned != 1)
3718     {
3719       if (!found_tag)
3720         pedwarn (input_location, 0, "empty declaration");
3721     }
3722 }
3723 \f
3724
3725 /* Return the qualifiers from SPECS as a bitwise OR of TYPE_QUAL_*
3726    bits.  SPECS represents declaration specifiers that the grammar
3727    only permits to contain type qualifiers and attributes.  */
3728
3729 int
3730 quals_from_declspecs (const struct c_declspecs *specs)
3731 {
3732   int quals = ((specs->const_p ? TYPE_QUAL_CONST : 0)
3733                | (specs->volatile_p ? TYPE_QUAL_VOLATILE : 0)
3734                | (specs->restrict_p ? TYPE_QUAL_RESTRICT : 0)
3735                | (ENCODE_QUAL_ADDR_SPACE (specs->address_space)));
3736   gcc_assert (!specs->type
3737               && !specs->decl_attr
3738               && specs->typespec_word == cts_none
3739               && specs->storage_class == csc_none
3740               && !specs->typedef_p
3741               && !specs->explicit_signed_p
3742               && !specs->deprecated_p
3743               && !specs->long_p
3744               && !specs->long_long_p
3745               && !specs->short_p
3746               && !specs->signed_p
3747               && !specs->unsigned_p
3748               && !specs->complex_p
3749               && !specs->inline_p
3750               && !specs->thread_p);
3751   return quals;
3752 }
3753
3754 /* Construct an array declarator.  LOC is the location of the
3755    beginning of the array (usually the opening brace).  EXPR is the
3756    expression inside [], or NULL_TREE.  QUALS are the type qualifiers
3757    inside the [] (to be applied to the pointer to which a parameter
3758    array is converted).  STATIC_P is true if "static" is inside the
3759    [], false otherwise.  VLA_UNSPEC_P is true if the array is [*], a
3760    VLA of unspecified length which is nevertheless a complete type,
3761    false otherwise.  The field for the contained declarator is left to
3762    be filled in by set_array_declarator_inner.  */
3763
3764 struct c_declarator *
3765 build_array_declarator (location_t loc,
3766                         tree expr, struct c_declspecs *quals, bool static_p,
3767                         bool vla_unspec_p)
3768 {
3769   struct c_declarator *declarator = XOBNEW (&parser_obstack,
3770                                             struct c_declarator);
3771   declarator->id_loc = loc;
3772   declarator->kind = cdk_array;
3773   declarator->declarator = 0;
3774   declarator->u.array.dimen = expr;
3775   if (quals)
3776     {
3777       declarator->u.array.attrs = quals->attrs;
3778       declarator->u.array.quals = quals_from_declspecs (quals);
3779     }
3780   else
3781     {
3782       declarator->u.array.attrs = NULL_TREE;
3783       declarator->u.array.quals = 0;
3784     }
3785   declarator->u.array.static_p = static_p;
3786   declarator->u.array.vla_unspec_p = vla_unspec_p;
3787   if (!flag_isoc99)
3788     {
3789       if (static_p || quals != NULL)
3790         pedwarn (loc, OPT_pedantic,
3791                  "ISO C90 does not support %<static%> or type "
3792                  "qualifiers in parameter array declarators");
3793       if (vla_unspec_p)
3794         pedwarn (loc, OPT_pedantic,
3795                  "ISO C90 does not support %<[*]%> array declarators");
3796     }
3797   if (vla_unspec_p)
3798     {
3799       if (!current_scope->parm_flag)
3800         {
3801           /* C99 6.7.5.2p4 */
3802           error_at (loc, "%<[*]%> not allowed in other than "
3803                     "function prototype scope");
3804           declarator->u.array.vla_unspec_p = false;
3805           return NULL;
3806         }
3807       current_scope->had_vla_unspec = true;
3808     }
3809   return declarator;
3810 }
3811
3812 /* Set the contained declarator of an array declarator.  DECL is the
3813    declarator, as constructed by build_array_declarator; INNER is what
3814    appears on the left of the [].  */
3815
3816 struct c_declarator *
3817 set_array_declarator_inner (struct c_declarator *decl,
3818                             struct c_declarator *inner)
3819 {
3820   decl->declarator = inner;
3821   return decl;
3822 }
3823
3824 /* INIT is a constructor that forms DECL's initializer.  If the final
3825    element initializes a flexible array field, add the size of that
3826    initializer to DECL's size.  */
3827
3828 static void
3829 add_flexible_array_elts_to_size (tree decl, tree init)
3830 {
3831   tree elt, type;
3832
3833   if (VEC_empty (constructor_elt, CONSTRUCTOR_ELTS (init)))
3834     return;
3835
3836   elt = VEC_last (constructor_elt, CONSTRUCTOR_ELTS (init))->value;
3837   type = TREE_TYPE (elt);
3838   if (TREE_CODE (type) == ARRAY_TYPE
3839       && TYPE_SIZE (type) == NULL_TREE
3840       && TYPE_DOMAIN (type) != NULL_TREE
3841       && TYPE_MAX_VALUE (TYPE_DOMAIN (type)) == NULL_TREE)
3842     {
3843       complete_array_type (&type, elt, false);
3844       DECL_SIZE (decl)
3845         = size_binop (PLUS_EXPR, DECL_SIZE (decl), TYPE_SIZE (type));
3846       DECL_SIZE_UNIT (decl)
3847         = size_binop (PLUS_EXPR, DECL_SIZE_UNIT (decl), TYPE_SIZE_UNIT (type));
3848     }
3849 }
3850 \f
3851 /* Decode a "typename", such as "int **", returning a ..._TYPE node.
3852    Set *EXPR, if EXPR not NULL, to any expression to be evaluated
3853    before the type name, and set *EXPR_CONST_OPERANDS, if
3854    EXPR_CONST_OPERANDS not NULL, to indicate whether the type name may
3855    appear in a constant expression.  */
3856
3857 tree
3858 groktypename (struct c_type_name *type_name, tree *expr,
3859               bool *expr_const_operands)
3860 {
3861   tree type;
3862   tree attrs = type_name->specs->attrs;
3863
3864   type_name->specs->attrs = NULL_TREE;
3865
3866   type = grokdeclarator (type_name->declarator, type_name->specs, TYPENAME,
3867                          false, NULL, &attrs, expr, expr_const_operands,
3868                          DEPRECATED_NORMAL);
3869
3870   /* Apply attributes.  */
3871   decl_attributes (&type, attrs, 0);
3872
3873   return type;
3874 }
3875
3876 /* Decode a declarator in an ordinary declaration or data definition.
3877    This is called as soon as the type information and variable name
3878    have been parsed, before parsing the initializer if any.
3879    Here we create the ..._DECL node, fill in its type,
3880    and put it on the list of decls for the current context.
3881    The ..._DECL node is returned as the value.
3882
3883    Exception: for arrays where the length is not specified,
3884    the type is left null, to be filled in by `finish_decl'.
3885
3886    Function definitions do not come here; they go to start_function
3887    instead.  However, external and forward declarations of functions
3888    do go through here.  Structure field declarations are done by
3889    grokfield and not through here.  */
3890
3891 tree
3892 start_decl (struct c_declarator *declarator, struct c_declspecs *declspecs,
3893             bool initialized, tree attributes)
3894 {
3895   tree decl;
3896   tree tem;
3897   tree expr = NULL_TREE;
3898   enum deprecated_states deprecated_state = DEPRECATED_NORMAL;
3899
3900   /* An object declared as __attribute__((deprecated)) suppresses
3901      warnings of uses of other deprecated items.  */
3902   if (lookup_attribute ("deprecated", attributes))
3903     deprecated_state = DEPRECATED_SUPPRESS;
3904
3905   decl = grokdeclarator (declarator, declspecs,
3906                          NORMAL, initialized, NULL, &attributes, &expr, NULL,
3907                          deprecated_state);
3908   if (!decl)
3909     return 0;
3910
3911   if (expr)
3912     add_stmt (expr);
3913
3914   if (TREE_CODE (decl) != FUNCTION_DECL && MAIN_NAME_P (DECL_NAME (decl)))
3915     warning (OPT_Wmain, "%q+D is usually a function", decl);
3916
3917   if (initialized)
3918     /* Is it valid for this decl to have an initializer at all?
3919        If not, set INITIALIZED to zero, which will indirectly
3920        tell 'finish_decl' to ignore the initializer once it is parsed.  */
3921     switch (TREE_CODE (decl))
3922       {
3923       case TYPE_DECL:
3924         error ("typedef %qD is initialized (use __typeof__ instead)", decl);
3925         initialized = 0;
3926         break;
3927
3928       case FUNCTION_DECL:
3929         error ("function %qD is initialized like a variable", decl);
3930         initialized = 0;
3931         break;
3932
3933       case PARM_DECL:
3934         /* DECL_INITIAL in a PARM_DECL is really DECL_ARG_TYPE.  */
3935         error ("parameter %qD is initialized", decl);
3936         initialized = 0;
3937         break;
3938
3939       default:
3940         /* Don't allow initializations for incomplete types except for
3941            arrays which might be completed by the initialization.  */
3942
3943         /* This can happen if the array size is an undefined macro.
3944            We already gave a warning, so we don't need another one.  */
3945         if (TREE_TYPE (decl) == error_mark_node)
3946           initialized = 0;
3947         else if (COMPLETE_TYPE_P (TREE_TYPE (decl)))
3948           {
3949             /* A complete type is ok if size is fixed.  */
3950
3951             if (TREE_CODE (TYPE_SIZE (TREE_TYPE (decl))) != INTEGER_CST
3952                 || C_DECL_VARIABLE_SIZE (decl))
3953               {
3954                 error ("variable-sized object may not be initialized");
3955                 initialized = 0;
3956               }
3957           }
3958         else if (TREE_CODE (TREE_TYPE (decl)) != ARRAY_TYPE)
3959           {
3960             error ("variable %qD has initializer but incomplete type", decl);
3961             initialized = 0;
3962           }
3963         else if (C_DECL_VARIABLE_SIZE (decl))
3964           {
3965             /* Although C99 is unclear about whether incomplete arrays
3966                of VLAs themselves count as VLAs, it does not make
3967                sense to permit them to be initialized given that
3968                ordinary VLAs may not be initialized.  */
3969             error ("variable-sized object may not be initialized");
3970             initialized = 0;
3971           }
3972       }
3973
3974   if (initialized)
3975     {
3976       if (current_scope == file_scope)
3977         TREE_STATIC (decl) = 1;
3978
3979       /* Tell 'pushdecl' this is an initialized decl
3980          even though we don't yet have the initializer expression.
3981          Also tell 'finish_decl' it may store the real initializer.  */
3982       DECL_INITIAL (decl) = error_mark_node;
3983     }
3984
3985   /* If this is a function declaration, write a record describing it to the
3986      prototypes file (if requested).  */
3987
3988   if (TREE_CODE (decl) == FUNCTION_DECL)
3989     gen_aux_info_record (decl, 0, 0, TYPE_ARG_TYPES (TREE_TYPE (decl)) != 0);
3990
3991   /* ANSI specifies that a tentative definition which is not merged with
3992      a non-tentative definition behaves exactly like a definition with an
3993      initializer equal to zero.  (Section 3.7.2)
3994
3995      -fno-common gives strict ANSI behavior, though this tends to break
3996      a large body of code that grew up without this rule.
3997
3998      Thread-local variables are never common, since there's no entrenched
3999      body of code to break, and it allows more efficient variable references
4000      in the presence of dynamic linking.  */
4001
4002   if (TREE_CODE (decl) == VAR_DECL
4003       && !initialized
4004       && TREE_PUBLIC (decl)
4005       && !DECL_THREAD_LOCAL_P (decl)
4006       && !flag_no_common)
4007     DECL_COMMON (decl) = 1;
4008
4009   /* Set attributes here so if duplicate decl, will have proper attributes.  */
4010   decl_attributes (&decl, attributes, 0);
4011
4012   /* Handle gnu_inline attribute.  */
4013   if (declspecs->inline_p
4014       && !flag_gnu89_inline
4015       && TREE_CODE (decl) == FUNCTION_DECL
4016       && (lookup_attribute ("gnu_inline", DECL_ATTRIBUTES (decl))
4017           || current_function_decl))
4018     {
4019       if (declspecs->storage_class == csc_auto && current_scope != file_scope)
4020         ;
4021       else if (declspecs->storage_class != csc_static)
4022         DECL_EXTERNAL (decl) = !DECL_EXTERNAL (decl);
4023     }
4024
4025   if (TREE_CODE (decl) == FUNCTION_DECL
4026       && targetm.calls.promote_prototypes (TREE_TYPE (decl)))
4027     {
4028       struct c_declarator *ce = declarator;
4029
4030       if (ce->kind == cdk_pointer)
4031         ce = declarator->declarator;
4032       if (ce->kind == cdk_function)
4033         {
4034           tree args = ce->u.arg_info->parms;
4035           for (; args; args = TREE_CHAIN (args))
4036             {
4037               tree type = TREE_TYPE (args);
4038               if (type && INTEGRAL_TYPE_P (type)
4039                   && TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node))
4040                 DECL_ARG_TYPE (args) = integer_type_node;
4041             }
4042         }
4043     }
4044
4045   if (TREE_CODE (decl) == FUNCTION_DECL
4046       && DECL_DECLARED_INLINE_P (decl)
4047       && DECL_UNINLINABLE (decl)
4048       && lookup_attribute ("noinline", DECL_ATTRIBUTES (decl)))
4049     warning (OPT_Wattributes, "inline function %q+D given attribute noinline",
4050              decl);
4051
4052   /* C99 6.7.4p3: An inline definition of a function with external
4053      linkage shall not contain a definition of a modifiable object
4054      with static storage duration...  */
4055   if (TREE_CODE (decl) == VAR_DECL
4056       && current_scope != file_scope
4057       && TREE_STATIC (decl)
4058       && !TREE_READONLY (decl)
4059       && DECL_DECLARED_INLINE_P (current_function_decl)
4060       && DECL_EXTERNAL (current_function_decl))
4061     record_inline_static (input_location, current_function_decl,
4062                           decl, csi_modifiable);
4063
4064   /* Add this decl to the current scope.
4065      TEM may equal DECL or it may be a previous decl of the same name.  */
4066   tem = pushdecl (decl);
4067
4068   if (initialized && DECL_EXTERNAL (tem))
4069     {
4070       DECL_EXTERNAL (tem) = 0;
4071       TREE_STATIC (tem) = 1;
4072     }
4073
4074   return tem;
4075 }
4076
4077 /* Finish processing of a declaration;
4078    install its initial value.
4079    If ORIGTYPE is not NULL_TREE, it is the original type of INIT.
4080    If the length of an array type is not known before,
4081    it must be determined now, from the initial value, or it is an error.
4082
4083    INIT_LOC is the location of the initial value.  */
4084
4085 void
4086 finish_decl (tree decl, location_t init_loc, tree init,
4087              tree origtype, tree asmspec_tree)
4088 {
4089   tree type;
4090   bool was_incomplete = (DECL_SIZE (decl) == 0);
4091   const char *asmspec = 0;
4092
4093   /* If a name was specified, get the string.  */
4094   if ((TREE_CODE (decl) == FUNCTION_DECL || TREE_CODE (decl) == VAR_DECL)
4095       && DECL_FILE_SCOPE_P (decl))
4096     asmspec_tree = maybe_apply_renaming_pragma (decl, asmspec_tree);
4097   if (asmspec_tree)
4098     asmspec = TREE_STRING_POINTER (asmspec_tree);
4099
4100   if (TREE_CODE (decl) == VAR_DECL
4101       && TREE_STATIC (decl)
4102       && global_bindings_p ())
4103     /* So decl is a global variable. Record the types it uses
4104        so that we can decide later to emit debug info for them.  */
4105     record_types_used_by_current_var_decl (decl);
4106
4107   /* If `start_decl' didn't like having an initialization, ignore it now.  */
4108   if (init != 0 &&&n