OSDN Git Service

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