OSDN Git Service

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