OSDN Git Service

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