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