OSDN Git Service

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