OSDN Git Service

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