OSDN Git Service

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