OSDN Git Service

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