OSDN Git Service

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