OSDN Git Service

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