OSDN Git Service

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