OSDN Git Service

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