OSDN Git Service

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