OSDN Git Service

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