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