OSDN Git Service

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