OSDN Git Service

* c-decl.c (c_decode_option): Don't handle -lang-objc.
[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    Free Software Foundation, Inc.
4
5 This file is part of GNU CC.
6
7 GNU CC is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
10 any later version.
11
12 GNU CC is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15 GNU General Public License for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with GNU CC; see the file COPYING.  If not, write to
19 the Free Software Foundation, 59 Temple Place - Suite 330,
20 Boston, MA 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 "rtl.h"
34 #include "flags.h"
35 #include "function.h"
36 #include "output.h"
37 #include "expr.h"
38 #include "c-tree.h"
39 #include "c-lex.h"
40 #include "toplev.h"
41 #include "defaults.h"
42 #include "ggc.h"
43 #include "tm_p.h"
44 #include "cpplib.h"
45
46 /* In grokdeclarator, distinguish syntactic contexts of declarators.  */
47 enum decl_context
48 { NORMAL,                       /* Ordinary declaration */
49   FUNCDEF,                      /* Function definition */
50   PARM,                         /* Declaration of parm before function body */
51   FIELD,                        /* Declaration inside struct or union */
52   BITFIELD,                     /* Likewise but with specified width */
53   TYPENAME};                    /* Typename (inside cast or sizeof)  */
54
55 /* We let tm.h override the types used here, to handle trivial differences
56    such as the choice of unsigned int or long unsigned int for size_t.
57    When machines start needing nontrivial differences in the size type,
58    it would be best to do something here to figure out automatically
59    from other information what type to use.  */
60
61 #ifndef SIZE_TYPE
62 #define SIZE_TYPE "long unsigned int"
63 #endif
64
65 #ifndef PTRDIFF_TYPE
66 #define PTRDIFF_TYPE "long int"
67 #endif
68
69 #ifndef WCHAR_TYPE
70 #define WCHAR_TYPE "int"
71 #endif
72
73 #ifndef WINT_TYPE
74 #define WINT_TYPE "unsigned int"
75 #endif
76
77 #ifndef INTMAX_TYPE
78 #define INTMAX_TYPE ((INT_TYPE_SIZE == LONG_LONG_TYPE_SIZE)     \
79                      ? "int"                                    \
80                      : ((LONG_TYPE_SIZE == LONG_LONG_TYPE_SIZE) \
81                         ? "long int"                            \
82                         : "long long int"))
83 #endif
84
85 #ifndef UINTMAX_TYPE
86 #define UINTMAX_TYPE ((INT_TYPE_SIZE == LONG_LONG_TYPE_SIZE)    \
87                      ? "unsigned int"                           \
88                      : ((LONG_TYPE_SIZE == LONG_LONG_TYPE_SIZE) \
89                         ? "long unsigned int"                   \
90                         : "long long unsigned int"))
91 #endif
92 \f
93 /* Nonzero if we have seen an invalid cross reference
94    to a struct, union, or enum, but not yet printed the message.  */
95
96 tree pending_invalid_xref;
97 /* File and line to appear in the eventual error message.  */
98 const char *pending_invalid_xref_file;
99 int pending_invalid_xref_line;
100
101 /* While defining an enum type, this is 1 plus the last enumerator
102    constant value.  Note that will do not have to save this or `enum_overflow'
103    around nested function definition since such a definition could only
104    occur in an enum value expression and we don't use these variables in
105    that case.  */
106
107 static tree enum_next_value;
108
109 /* Nonzero means that there was overflow computing enum_next_value.  */
110
111 static int enum_overflow;
112
113 /* Parsing a function declarator leaves a list of parameter names
114    or a chain or parameter decls here.  */
115
116 static tree last_function_parms;
117
118 /* Parsing a function declarator leaves here a chain of structure
119    and enum types declared in the parmlist.  */
120
121 static tree last_function_parm_tags;
122
123 /* After parsing the declarator that starts a function definition,
124    `start_function' puts here the list of parameter names or chain of decls.
125    `store_parm_decls' finds it here.  */
126
127 static tree current_function_parms;
128
129 /* Similar, for last_function_parm_tags.  */
130 static tree current_function_parm_tags;
131
132 /* Similar, for the file and line that the prototype came from if this is
133    an old-style definition.  */
134 static const char *current_function_prototype_file;
135 static int current_function_prototype_line;
136
137 /* The current statement tree.  */
138
139 static struct stmt_tree_s c_stmt_tree;
140
141 /* The current scope statement stack.  */
142
143 static tree c_scope_stmt_stack;
144
145 /* Nonzero if __FUNCTION__ and its ilk have been declared in this
146    function.  */
147
148 static int c_function_name_declared_p;
149
150 /* A list (chain of TREE_LIST nodes) of all LABEL_DECLs in the function
151    that have names.  Here so we can clear out their names' definitions
152    at the end of the function.  */
153
154 static tree named_labels;
155
156 /* A list of LABEL_DECLs from outer contexts that are currently shadowed.  */
157
158 static tree shadowed_labels;
159
160 /* Nonzero when store_parm_decls is called indicates a varargs function.
161    Value not meaningful after store_parm_decls.  */
162
163 static int c_function_varargs;
164
165 /* Set to 0 at beginning of a function definition, set to 1 if
166    a return statement that specifies a return value is seen.  */
167
168 int current_function_returns_value;
169
170 /* Set to 0 at beginning of a function definition, set to 1 if
171    a return statement with no argument is seen.  */
172
173 int current_function_returns_null;
174
175 /* Set to nonzero by `grokdeclarator' for a function
176    whose return type is defaulted, if warnings for this are desired.  */
177
178 static int warn_about_return_type;
179
180 /* Nonzero when starting a function declared `extern inline'.  */
181
182 static int current_extern_inline;
183 \f
184 /* For each binding contour we allocate a binding_level structure
185  * which records the names defined in that contour.
186  * Contours include:
187  *  0) the global one
188  *  1) one for each function definition,
189  *     where internal declarations of the parameters appear.
190  *  2) one for each compound statement,
191  *     to record its declarations.
192  *
193  * The current meaning of a name can be found by searching the levels from
194  * the current one out to the global one.
195  */
196
197 /* Note that the information in the `names' component of the global contour
198    is duplicated in the IDENTIFIER_GLOBAL_VALUEs of all identifiers.  */
199
200 struct binding_level
201   {
202     /* A chain of _DECL nodes for all variables, constants, functions,
203        and typedef types.  These are in the reverse of the order supplied.
204      */
205     tree names;
206
207     /* A list of structure, union and enum definitions,
208      * for looking up tag names.
209      * It is a chain of TREE_LIST nodes, each of whose TREE_PURPOSE is a name,
210      * or NULL_TREE; and whose TREE_VALUE is a RECORD_TYPE, UNION_TYPE,
211      * or ENUMERAL_TYPE node.
212      */
213     tree tags;
214
215     /* For each level, a list of shadowed outer-level local definitions
216        to be restored when this level is popped.
217        Each link is a TREE_LIST whose TREE_PURPOSE is an identifier and
218        whose TREE_VALUE is its old definition (a kind of ..._DECL node).  */
219     tree shadowed;
220
221     /* For each level (except not the global one),
222        a chain of BLOCK nodes for all the levels
223        that were entered and exited one level down.  */
224     tree blocks;
225
226     /* The BLOCK node for this level, if one has been preallocated.
227        If 0, the BLOCK is allocated (if needed) when the level is popped.  */
228     tree this_block;
229
230     /* The binding level which this one is contained in (inherits from).  */
231     struct binding_level *level_chain;
232
233     /* Nonzero for the level that holds the parameters of a function.  */
234     char parm_flag;
235
236     /* Nonzero if this level "doesn't exist" for tags.  */
237     char tag_transparent;
238
239     /* Nonzero if sublevels of this level "don't exist" for tags.
240        This is set in the parm level of a function definition
241        while reading the function body, so that the outermost block
242        of the function body will be tag-transparent.  */
243     char subblocks_tag_transparent;
244
245     /* Nonzero means make a BLOCK for this level regardless of all else.  */
246     char keep;
247
248     /* Nonzero means make a BLOCK if this level has any subblocks.  */
249     char keep_if_subblocks;
250
251     /* Number of decls in `names' that have incomplete
252        structure or union types.  */
253     int n_incomplete;
254
255     /* A list of decls giving the (reversed) specified order of parms,
256        not including any forward-decls in the parmlist.
257        This is so we can put the parms in proper order for assign_parms.  */
258     tree parm_order;
259   };
260
261 #define NULL_BINDING_LEVEL (struct binding_level *) NULL
262
263 /* The binding level currently in effect.  */
264
265 static struct binding_level *current_binding_level;
266
267 /* A chain of binding_level structures awaiting reuse.  */
268
269 static struct binding_level *free_binding_level;
270
271 /* The outermost binding level, for names of file scope.
272    This is created when the compiler is started and exists
273    through the entire run.  */
274
275 static struct binding_level *global_binding_level;
276
277 /* Binding level structures are initialized by copying this one.  */
278
279 static struct binding_level clear_binding_level
280   = {NULL, NULL, NULL, NULL, NULL, NULL_BINDING_LEVEL, 0, 0, 0, 0, 0, 0,
281      NULL};
282
283 /* Nonzero means unconditionally make a BLOCK for the next level pushed.  */
284
285 static int keep_next_level_flag;
286
287 /* Nonzero means make a BLOCK for the next level pushed
288    if it has subblocks.  */
289
290 static int keep_next_if_subblocks;
291
292 /* The chain of outer levels of label scopes.
293    This uses the same data structure used for binding levels,
294    but it works differently: each link in the chain records
295    saved values of named_labels and shadowed_labels for
296    a label binding level outside the current one.  */
297
298 static struct binding_level *label_level_chain;
299
300 /* Functions called automatically at the beginning and end of execution.  */
301
302 tree static_ctors, static_dtors;
303
304 /* Forward declarations.  */
305
306 static struct binding_level * make_binding_level        PARAMS ((void));
307 static void mark_binding_level          PARAMS ((void *));
308 static void clear_limbo_values          PARAMS ((tree));
309 static int duplicate_decls              PARAMS ((tree, tree, int));
310 static int redeclaration_error_message  PARAMS ((tree, tree));
311 static void storedecls                  PARAMS ((tree));
312 static void storetags                   PARAMS ((tree));
313 static tree lookup_tag                  PARAMS ((enum tree_code, tree,
314                                                  struct binding_level *, int));
315 static tree lookup_tag_reverse          PARAMS ((tree));
316 static tree grokdeclarator              PARAMS ((tree, tree, enum decl_context,
317                                                  int));
318 static tree grokparms                   PARAMS ((tree, int));
319 static void layout_array_type           PARAMS ((tree));
320 static tree c_make_fname_decl           PARAMS ((tree, const char *, int));
321 static void c_expand_body               PARAMS ((tree, int));
322 \f
323 /* C-specific option variables.  */
324
325 /* Nonzero means allow type mismatches in conditional expressions;
326    just make their values `void'.   */
327
328 int flag_cond_mismatch;
329
330 /* Nonzero means give `double' the same size as `float'.  */
331
332 int flag_short_double;
333
334 /* Nonzero means give `wchar_t' the same size as `short'.  */
335
336 int flag_short_wchar;
337
338 /* Nonzero means don't recognize the keyword `asm'.  */
339
340 int flag_no_asm;
341
342 /* Nonzero means do some things the same way PCC does.  */
343
344 int flag_traditional;
345
346 /* Nonzero means enable C89 Amendment 1 features.  */
347
348 int flag_isoc94 = 0;
349
350 /* Nonzero means use the ISO C99 dialect of C.  */
351
352 int flag_isoc99 = 0;
353
354 /* Nonzero means that we have builtin functions, and main is an int */
355
356 int flag_hosted = 1;
357
358 /* Nonzero means add default format_arg attributes for functions not
359    in ISO C.  */
360
361 int flag_noniso_default_format_attributes = 1;
362
363 /* Nonzero means to allow single precision math even if we're generally
364    being traditional.  */
365 int flag_allow_single_precision = 0;
366
367 /* Nonzero means to treat bitfields as signed unless they say `unsigned'.  */
368
369 int flag_signed_bitfields = 1;
370 int explicit_flag_signed_bitfields = 0;
371
372 /* Nonzero means warn about use of implicit int.  */
373
374 int warn_implicit_int;
375
376 /* Nonzero means warn about usage of long long when `-pedantic'.  */
377
378 int warn_long_long = 1;
379
380 /* Nonzero means message about use of implicit function declarations;
381  1 means warning; 2 means error.  */
382
383 int mesg_implicit_function_declaration = -1;
384
385 /* Nonzero means give string constants the type `const char *'
386    to get extra warnings from them.  These warnings will be too numerous
387    to be useful, except in thoroughly ANSIfied programs.  */
388
389 int flag_const_strings;
390
391 /* Nonzero means warn about pointer casts that can drop a type qualifier
392    from the pointer target type.  */
393
394 int warn_cast_qual;
395
396 /* Nonzero means warn when casting a function call to a type that does
397    not match the return type (e.g. (float)sqrt() or (anything*)malloc()
398    when there is no previous declaration of sqrt or malloc.  */
399
400 int warn_bad_function_cast;
401
402 /* Warn about functions which might be candidates for format attributes.  */
403
404 int warn_missing_format_attribute;
405
406 /* Warn about traditional constructs whose meanings changed in ANSI C.  */
407
408 int warn_traditional;
409
410 /* Nonzero means warn about sizeof(function) or addition/subtraction
411    of function pointers.  */
412
413 int warn_pointer_arith;
414
415 /* Nonzero means warn for non-prototype function decls
416    or non-prototyped defs without previous prototype.  */
417
418 int warn_strict_prototypes;
419
420 /* Nonzero means warn for any global function def
421    without separate previous prototype decl.  */
422
423 int warn_missing_prototypes;
424
425 /* Nonzero means warn for any global function def
426    without separate previous decl.  */
427
428 int warn_missing_declarations;
429
430 /* Nonzero means warn about multiple (redundant) decls for the same single
431    variable or function.  */
432
433 int warn_redundant_decls = 0;
434
435 /* Nonzero means warn about extern declarations of objects not at
436    file-scope level and about *all* declarations of functions (whether
437    extern or static) not at file-scope level.  Note that we exclude
438    implicit function declarations.  To get warnings about those, use
439    -Wimplicit.  */
440
441 int warn_nested_externs = 0;
442
443 /* Warn about *printf or *scanf format/argument anomalies.  */
444
445 int warn_format;
446
447 /* Warn about a subscript that has type char.  */
448
449 int warn_char_subscripts = 0;
450
451 /* Warn if a type conversion is done that might have confusing results.  */
452
453 int warn_conversion;
454
455 /* Warn if adding () is suggested.  */
456
457 int warn_parentheses;
458
459 /* Warn if initializer is not completely bracketed.  */
460
461 int warn_missing_braces;
462
463 /* Warn if main is suspicious.  */
464
465 int warn_main;
466
467 /* Warn about #pragma directives that are not recognised.  */
468
469 int warn_unknown_pragmas = 0; /* Tri state variable.  */
470
471 /* Warn about comparison of signed and unsigned values.
472    If -1, neither -Wsign-compare nor -Wno-sign-compare has been specified.  */
473
474 int warn_sign_compare = -1;
475
476 /* Warn about testing equality of floating point numbers.  */
477
478 int warn_float_equal = 0;
479
480 /* Nonzero means warn about use of multicharacter literals.  */
481
482 int warn_multichar = 1;
483
484 /* The variant of the C language being processed.  */
485
486 c_language_kind c_language = clk_c;
487
488 /* Nonzero means `$' can be in an identifier.  */
489
490 #ifndef DOLLARS_IN_IDENTIFIERS
491 #define DOLLARS_IN_IDENTIFIERS 1
492 #endif
493 int dollars_in_ident = DOLLARS_IN_IDENTIFIERS;
494
495 /* Decode the string P as a language-specific option for C.
496    Return the number of strings consumed.  Should not complain
497    if it does not recognise the option.  */
498
499 int
500 c_decode_option (argc, argv)
501      int argc ATTRIBUTE_UNUSED;
502      char **argv;
503 {
504   int strings_processed;
505   const char *option_value = NULL;
506   char *p = argv[0];
507
508   strings_processed = cpp_handle_option (parse_in, argc, argv);
509
510   if (!strcmp (p, "-ftraditional") || !strcmp (p, "-traditional"))
511     {
512       flag_traditional = 1;
513       flag_writable_strings = 1;
514     }
515   else if (!strcmp (p, "-fallow-single-precision"))
516     flag_allow_single_precision = 1;
517   else if (!strcmp (p, "-fhosted") || !strcmp (p, "-fno-freestanding"))
518     {
519       flag_hosted = 1;
520       flag_no_builtin = 0;
521     }
522   else if (!strcmp (p, "-ffreestanding") || !strcmp (p, "-fno-hosted"))
523     {
524       flag_hosted = 0;
525       flag_no_builtin = 1;
526       /* warn_main will be 2 if set by -Wall, 1 if set by -Wmain */
527       if (warn_main == 2)
528         warn_main = 0;
529     }
530   else if (!strcmp (p, "-fnotraditional") || !strcmp (p, "-fno-traditional"))
531     {
532       flag_traditional = 0;
533       flag_writable_strings = 0;
534     }
535   else if (!strncmp (p, "-std=", 5))
536     {
537       /* Select the appropriate language standard.  We currently
538          recognize:
539          -std=iso9899:1990      same as -ansi
540          -std=iso9899:199409    ISO C as modified in amend. 1
541          -std=iso9899:1999      ISO C 99
542          -std=c89               same as -std=iso9899:1990
543          -std=c99               same as -std=iso9899:1999
544          -std=gnu89             default, iso9899:1990 + gnu extensions
545          -std=gnu99             iso9899:1999 + gnu extensions
546       */
547       const char *argstart = &p[5];
548
549       if (!strcmp (argstart, "iso9899:1990")
550           || !strcmp (argstart, "c89"))
551         {
552         iso_1990:
553           flag_isoc94 = 0;
554         iso_1994:
555           flag_traditional = 0;
556           flag_writable_strings = 0;
557           flag_no_asm = 1;
558           flag_no_nonansi_builtin = 1;
559           flag_noniso_default_format_attributes = 0;
560           flag_isoc99 = 0;
561         }
562       else if (!strcmp (argstart, "iso9899:199409"))
563         {
564           flag_isoc94 = 1;
565           goto iso_1994;
566         }
567       else if (!strcmp (argstart, "iso9899:199x")
568                || !strcmp (argstart, "iso9899:1999")
569                || !strcmp (argstart, "c9x")
570                || !strcmp (argstart, "c99"))
571         {
572           flag_traditional = 0;
573           flag_writable_strings = 0;
574           flag_no_asm = 1;
575           flag_no_nonansi_builtin = 1;
576           flag_noniso_default_format_attributes = 0;
577           flag_isoc99 = 1;
578           flag_isoc94 = 1;
579         }
580       else if (!strcmp (argstart, "gnu89"))
581         {
582           flag_traditional = 0;
583           flag_writable_strings = 0;
584           flag_no_asm = 0;
585           flag_no_nonansi_builtin = 0;
586           flag_noniso_default_format_attributes = 1;
587           flag_isoc99 = 0;
588           flag_isoc94 = 0;
589         }
590       else if (!strcmp (argstart, "gnu9x") || !strcmp (argstart, "gnu99"))
591         {
592           flag_traditional = 0;
593           flag_writable_strings = 0;
594           flag_no_asm = 0;
595           flag_no_nonansi_builtin = 0;
596           flag_noniso_default_format_attributes = 1;
597           flag_isoc99 = 1;
598           flag_isoc94 = 1;
599         }
600       else
601         error ("unknown C standard `%s'", argstart);
602     }
603   else if (!strcmp (p, "-fdollars-in-identifiers"))
604     dollars_in_ident = 1;
605   else if (!strcmp (p, "-fno-dollars-in-identifiers"))
606     dollars_in_ident = 0;
607   else if (!strcmp (p, "-fsigned-char"))
608     flag_signed_char = 1;
609   else if (!strcmp (p, "-funsigned-char"))
610     flag_signed_char = 0;
611   else if (!strcmp (p, "-fno-signed-char"))
612     flag_signed_char = 0;
613   else if (!strcmp (p, "-fno-unsigned-char"))
614     flag_signed_char = 1;
615   else if (!strcmp (p, "-fsigned-bitfields")
616            || !strcmp (p, "-fno-unsigned-bitfields"))
617     {
618       flag_signed_bitfields = 1;
619       explicit_flag_signed_bitfields = 1;
620     }
621   else if (!strcmp (p, "-funsigned-bitfields")
622            || !strcmp (p, "-fno-signed-bitfields"))
623     {
624       flag_signed_bitfields = 0;
625       explicit_flag_signed_bitfields = 1;
626     }
627   else if (!strcmp (p, "-fshort-enums"))
628     flag_short_enums = 1;
629   else if (!strcmp (p, "-fno-short-enums"))
630     flag_short_enums = 0;
631   else if (!strcmp (p, "-fshort-wchar"))
632     flag_short_wchar = 1;
633   else if (!strcmp (p, "-fno-short-wchar"))
634     flag_short_wchar = 0;
635   else if (!strcmp (p, "-fcond-mismatch"))
636     flag_cond_mismatch = 1;
637   else if (!strcmp (p, "-fno-cond-mismatch"))
638     flag_cond_mismatch = 0;
639   else if (!strcmp (p, "-fshort-double"))
640     flag_short_double = 1;
641   else if (!strcmp (p, "-fno-short-double"))
642     flag_short_double = 0;
643   else if (!strcmp (p, "-fasm"))
644     flag_no_asm = 0;
645   else if (!strcmp (p, "-fno-asm"))
646     flag_no_asm = 1;
647   else if (!strcmp (p, "-fbuiltin"))
648     flag_no_builtin = 0;
649   else if (!strcmp (p, "-fno-builtin"))
650     flag_no_builtin = 1;
651   else if ((option_value
652             = skip_leading_substring (p, "-fdump-translation-unit-")))
653     {
654       if (p[22] == '\0')
655         error ("no file specified with -fdump-translation-unit");
656       else
657         flag_dump_translation_unit = option_value;
658     }
659   else if (!strcmp (p, "-ansi"))
660     goto iso_1990;
661   else if (!strcmp (p, "-Werror-implicit-function-declaration"))
662     mesg_implicit_function_declaration = 2;
663   else if (!strcmp (p, "-Wimplicit-function-declaration"))
664     mesg_implicit_function_declaration = 1;
665   else if (!strcmp (p, "-Wno-implicit-function-declaration"))
666     mesg_implicit_function_declaration = 0;
667   else if (!strcmp (p, "-Wimplicit-int"))
668     warn_implicit_int = 1;
669   else if (!strcmp (p, "-Wno-implicit-int"))
670     warn_implicit_int = 0;
671   else if (!strcmp (p, "-Wimplicit"))
672     {
673       warn_implicit_int = 1;
674       if (mesg_implicit_function_declaration != 2)
675         mesg_implicit_function_declaration = 1;
676     }
677   else if (!strcmp (p, "-Wno-implicit"))
678     warn_implicit_int = 0, mesg_implicit_function_declaration = 0;
679   else if (!strcmp (p, "-Wlong-long"))
680     warn_long_long = 1;
681   else if (!strcmp (p, "-Wno-long-long"))
682     warn_long_long = 0;
683   else if (!strcmp (p, "-Wwrite-strings"))
684     flag_const_strings = 1;
685   else if (!strcmp (p, "-Wno-write-strings"))
686     flag_const_strings = 0;
687   else if (!strcmp (p, "-Wcast-qual"))
688     warn_cast_qual = 1;
689   else if (!strcmp (p, "-Wno-cast-qual"))
690     warn_cast_qual = 0;
691   else if (!strcmp (p, "-Wbad-function-cast"))
692     warn_bad_function_cast = 1;
693   else if (!strcmp (p, "-Wno-bad-function-cast"))
694     warn_bad_function_cast = 0;
695   else if (!strcmp (p, "-Wmissing-noreturn"))
696     warn_missing_noreturn = 1;
697   else if (!strcmp (p, "-Wno-missing-noreturn"))
698     warn_missing_noreturn = 0;
699   else if (!strcmp (p, "-Wmissing-format-attribute"))
700     warn_missing_format_attribute = 1;
701   else if (!strcmp (p, "-Wno-missing-format-attribute"))
702     warn_missing_format_attribute = 0;
703   else if (!strcmp (p, "-Wpointer-arith"))
704     warn_pointer_arith = 1;
705   else if (!strcmp (p, "-Wno-pointer-arith"))
706     warn_pointer_arith = 0;
707   else if (!strcmp (p, "-Wstrict-prototypes"))
708     warn_strict_prototypes = 1;
709   else if (!strcmp (p, "-Wno-strict-prototypes"))
710     warn_strict_prototypes = 0;
711   else if (!strcmp (p, "-Wmissing-prototypes"))
712     warn_missing_prototypes = 1;
713   else if (!strcmp (p, "-Wno-missing-prototypes"))
714     warn_missing_prototypes = 0;
715   else if (!strcmp (p, "-Wmissing-declarations"))
716     warn_missing_declarations = 1;
717   else if (!strcmp (p, "-Wno-missing-declarations"))
718     warn_missing_declarations = 0;
719   else if (!strcmp (p, "-Wredundant-decls"))
720     warn_redundant_decls = 1;
721   else if (!strcmp (p, "-Wno-redundant-decls"))
722     warn_redundant_decls = 0;
723   else if (!strcmp (p, "-Wnested-externs"))
724     warn_nested_externs = 1;
725   else if (!strcmp (p, "-Wno-nested-externs"))
726     warn_nested_externs = 0;
727   else if (!strcmp (p, "-Wtraditional"))
728     warn_traditional = 1;
729   else if (!strcmp (p, "-Wno-traditional"))
730     warn_traditional = 0;
731   else if (!strncmp (p, "-Wformat=", 9))
732     warn_format = atol (p + 9);
733   else if (!strcmp (p, "-Wformat"))
734     warn_format = 1;
735   else if (!strcmp (p, "-Wno-format"))
736     warn_format = 0;
737   else if (!strcmp (p, "-Wchar-subscripts"))
738     warn_char_subscripts = 1;
739   else if (!strcmp (p, "-Wno-char-subscripts"))
740     warn_char_subscripts = 0;
741   else if (!strcmp (p, "-Wconversion"))
742     warn_conversion = 1;
743   else if (!strcmp (p, "-Wno-conversion"))
744     warn_conversion = 0;
745   else if (!strcmp (p, "-Wparentheses"))
746     warn_parentheses = 1;
747   else if (!strcmp (p, "-Wno-parentheses"))
748     warn_parentheses = 0;
749   else if (!strcmp (p, "-Wreturn-type"))
750     warn_return_type = 1;
751   else if (!strcmp (p, "-Wno-return-type"))
752     warn_return_type = 0;
753   else if (!strcmp (p, "-Wsequence-point"))
754     warn_sequence_point = 1;
755   else if (!strcmp (p, "-Wno-sequence-point"))
756     warn_sequence_point = 0;
757   else if (!strcmp (p, "-Wcomment"))
758     ; /* cpp handles this one.  */
759   else if (!strcmp (p, "-Wno-comment"))
760     ; /* cpp handles this one.  */
761   else if (!strcmp (p, "-Wcomments"))
762     ; /* cpp handles this one.  */
763   else if (!strcmp (p, "-Wno-comments"))
764     ; /* cpp handles this one.  */
765   else if (!strcmp (p, "-Wtrigraphs"))
766     ; /* cpp handles this one.  */
767   else if (!strcmp (p, "-Wno-trigraphs"))
768     ; /* cpp handles this one.  */
769   else if (!strcmp (p, "-Wundef"))
770     ; /* cpp handles this one.  */
771   else if (!strcmp (p, "-Wno-undef"))
772     ; /* cpp handles this one.  */
773   else if (!strcmp (p, "-Wimport"))
774     ; /* cpp handles this one.  */
775   else if (!strcmp (p, "-Wno-import"))
776     ; /* cpp handles this one.  */
777   else if (!strcmp (p, "-Wmissing-braces"))
778     warn_missing_braces = 1;
779   else if (!strcmp (p, "-Wno-missing-braces"))
780     warn_missing_braces = 0;
781   else if (!strcmp (p, "-Wmain"))
782     warn_main = 1;
783   else if (!strcmp (p, "-Wno-main"))
784     warn_main = -1;
785   else if (!strcmp (p, "-Wsign-compare"))
786     warn_sign_compare = 1;
787   else if (!strcmp (p, "-Wno-sign-compare"))
788     warn_sign_compare = 0;
789   else if (!strcmp (p, "-Wfloat-equal"))
790     warn_float_equal = 1;
791   else if (!strcmp (p, "-Wno-float-equal"))
792     warn_float_equal = 0;
793   else if (!strcmp (p, "-Wmultichar"))
794     warn_multichar = 1;
795   else if (!strcmp (p, "-Wno-multichar"))
796     warn_multichar = 0;
797   else if (!strcmp (p, "-Wunknown-pragmas"))
798     /* Set to greater than 1, so that even unknown pragmas in system
799        headers will be warned about.  */
800     warn_unknown_pragmas = 2;
801   else if (!strcmp (p, "-Wno-unknown-pragmas"))
802     warn_unknown_pragmas = 0;
803   else if (!strcmp (p, "-Wall"))
804     {
805       /* We save the value of warn_uninitialized, since if they put
806          -Wuninitialized on the command line, we need to generate a
807          warning about not using it without also specifying -O.  */
808       if (warn_uninitialized != 1)
809         warn_uninitialized = 2;
810       warn_implicit_int = 1;
811       mesg_implicit_function_declaration = 1;
812       warn_return_type = 1;
813       set_Wunused (1);
814       warn_switch = 1;
815       warn_format = 1;
816       warn_char_subscripts = 1;
817       warn_parentheses = 1;
818       warn_sequence_point = 1;
819       warn_missing_braces = 1;
820       /* We set this to 2 here, but 1 in -Wmain, so -ffreestanding can turn
821          it off only if it's not explicit.  */
822       warn_main = 2;
823       /* Only warn about unknown pragmas that are not in system headers.  */
824       warn_unknown_pragmas = 1;
825     }
826   else
827     return strings_processed;
828
829   return 1;
830 }
831
832 /* Hooks for print_node.  */
833
834 void
835 print_lang_decl (file, node, indent)
836      FILE *file ATTRIBUTE_UNUSED;
837      tree node ATTRIBUTE_UNUSED;
838      int indent ATTRIBUTE_UNUSED;
839 {
840 }
841
842 void
843 print_lang_type (file, node, indent)
844      FILE *file ATTRIBUTE_UNUSED;
845      tree node ATTRIBUTE_UNUSED;
846      int indent ATTRIBUTE_UNUSED;
847 {
848 }
849
850 void
851 print_lang_identifier (file, node, indent)
852      FILE *file;
853      tree node;
854      int indent;
855 {
856   print_node (file, "global", IDENTIFIER_GLOBAL_VALUE (node), indent + 4);
857   print_node (file, "local", IDENTIFIER_LOCAL_VALUE (node), indent + 4);
858   print_node (file, "label", IDENTIFIER_LABEL_VALUE (node), indent + 4);
859   print_node (file, "implicit", IDENTIFIER_IMPLICIT_DECL (node), indent + 4);
860   print_node (file, "error locus", IDENTIFIER_ERROR_LOCUS (node), indent + 4);
861   print_node (file, "limbo value", IDENTIFIER_LIMBO_VALUE (node), indent + 4);
862   if (C_IS_RESERVED_WORD (node))
863     {
864       tree rid = ridpointers[C_RID_CODE (node)];
865       indent_to (file, indent + 4);
866       fprintf (file, "rid ");
867       fprintf (file, HOST_PTR_PRINTF, (void *)rid);
868       fprintf (file, " \"%s\"", IDENTIFIER_POINTER (rid));
869     }
870 }
871 \f
872 /* Hook called at end of compilation to assume 1 elt
873    for a top-level tentative array defn that wasn't complete before.  */
874
875 void
876 finish_incomplete_decl (decl)
877      tree decl;
878 {
879   if (TREE_CODE (decl) == VAR_DECL)
880     {
881       tree type = TREE_TYPE (decl);
882       if (type != error_mark_node
883           && TREE_CODE (type) == ARRAY_TYPE
884           && ! DECL_EXTERNAL (decl)
885           && TYPE_DOMAIN (type) == 0)
886         {
887           warning_with_decl (decl, "array `%s' assumed to have one element");
888
889           complete_array_type (type, NULL_TREE, 1);
890
891           layout_decl (decl, 0);
892         }
893     }
894 }
895 \f
896 /* Create a new `struct binding_level'.  */
897
898 static struct binding_level *
899 make_binding_level ()
900 {
901   /* NOSTRICT */
902   return (struct binding_level *) xmalloc (sizeof (struct binding_level));
903 }
904
905 /* Nonzero if we are currently in the global binding level.  */
906
907 int
908 global_bindings_p ()
909 {
910   return current_binding_level == global_binding_level;
911 }
912
913 void
914 keep_next_level ()
915 {
916   keep_next_level_flag = 1;
917 }
918
919 /* Nonzero if the current level needs to have a BLOCK made.  */
920
921 int
922 kept_level_p ()
923 {
924   return ((current_binding_level->keep_if_subblocks
925            && current_binding_level->blocks != 0)
926           || current_binding_level->keep
927           || current_binding_level->names != 0
928           || (current_binding_level->tags != 0
929               && !current_binding_level->tag_transparent));
930 }
931
932 /* Identify this binding level as a level of parameters.
933    DEFINITION_FLAG is 1 for a definition, 0 for a declaration.
934    But it turns out there is no way to pass the right value for
935    DEFINITION_FLAG, so we ignore it.  */
936
937 void
938 declare_parm_level (definition_flag)
939      int definition_flag ATTRIBUTE_UNUSED;
940 {
941   current_binding_level->parm_flag = 1;
942 }
943
944 /* Nonzero if currently making parm declarations.  */
945
946 int
947 in_parm_level_p ()
948 {
949   return current_binding_level->parm_flag;
950 }
951
952 /* Enter a new binding level.
953    If TAG_TRANSPARENT is nonzero, do so only for the name space of variables,
954    not for that of tags.  */
955
956 void
957 pushlevel (tag_transparent)
958      int tag_transparent;
959 {
960   register struct binding_level *newlevel = NULL_BINDING_LEVEL;
961
962   /* If this is the top level of a function,
963      just make sure that NAMED_LABELS is 0.  */
964
965   if (current_binding_level == global_binding_level)
966     {
967       named_labels = 0;
968     }
969
970   /* Reuse or create a struct for this binding level.  */
971
972   if (free_binding_level)
973     {
974       newlevel = free_binding_level;
975       free_binding_level = free_binding_level->level_chain;
976     }
977   else
978     {
979       newlevel = make_binding_level ();
980     }
981
982   /* Add this level to the front of the chain (stack) of levels that
983      are active.  */
984
985   *newlevel = clear_binding_level;
986   newlevel->tag_transparent
987     = (tag_transparent
988        || (current_binding_level
989            ? current_binding_level->subblocks_tag_transparent
990            : 0));
991   newlevel->level_chain = current_binding_level;
992   current_binding_level = newlevel;
993   newlevel->keep = keep_next_level_flag;
994   keep_next_level_flag = 0;
995   newlevel->keep_if_subblocks = keep_next_if_subblocks;
996   keep_next_if_subblocks = 0;
997 }
998
999 /* Clear the limbo values of all identifiers defined in BLOCK or a subblock.  */
1000
1001 static void
1002 clear_limbo_values (block)
1003      tree block;
1004 {
1005   tree tem;
1006
1007   for (tem = BLOCK_VARS (block); tem; tem = TREE_CHAIN (tem))
1008     if (DECL_NAME (tem) != 0)
1009       IDENTIFIER_LIMBO_VALUE (DECL_NAME (tem)) = 0;
1010
1011   for (tem = BLOCK_SUBBLOCKS (block); tem; tem = TREE_CHAIN (tem))
1012     clear_limbo_values (tem);
1013 }
1014
1015 /* Exit a binding level.
1016    Pop the level off, and restore the state of the identifier-decl mappings
1017    that were in effect when this level was entered.
1018
1019    If KEEP is nonzero, this level had explicit declarations, so
1020    and create a "block" (a BLOCK node) for the level
1021    to record its declarations and subblocks for symbol table output.
1022
1023    If FUNCTIONBODY is nonzero, this level is the body of a function,
1024    so create a block as if KEEP were set and also clear out all
1025    label names.
1026
1027    If REVERSE is nonzero, reverse the order of decls before putting
1028    them into the BLOCK.  */
1029
1030 tree
1031 poplevel (keep, reverse, functionbody)
1032      int keep;
1033      int reverse;
1034      int functionbody;
1035 {
1036   register tree link;
1037   /* The chain of decls was accumulated in reverse order.
1038      Put it into forward order, just for cleanliness.  */
1039   tree decls;
1040   tree tags = current_binding_level->tags;
1041   tree subblocks = current_binding_level->blocks;
1042   tree block = 0;
1043   tree decl;
1044   int block_previously_created;
1045
1046   keep |= current_binding_level->keep;
1047
1048   /* This warning is turned off because it causes warnings for
1049      declarations like `extern struct foo *x'.  */
1050 #if 0
1051   /* Warn about incomplete structure types in this level.  */
1052   for (link = tags; link; link = TREE_CHAIN (link))
1053     if (!COMPLETE_TYPE_P (TREE_VALUE (link)))
1054       {
1055         tree type = TREE_VALUE (link);
1056         tree type_name = TYPE_NAME (type);
1057         char *id = IDENTIFIER_POINTER (TREE_CODE (type_name) == IDENTIFIER_NODE
1058                                        ? type_name
1059                                        : DECL_NAME (type_name));
1060         switch (TREE_CODE (type))
1061           {
1062           case RECORD_TYPE:
1063             error ("`struct %s' incomplete in scope ending here", id);
1064             break;
1065           case UNION_TYPE:
1066             error ("`union %s' incomplete in scope ending here", id);
1067             break;
1068           case ENUMERAL_TYPE:
1069             error ("`enum %s' incomplete in scope ending here", id);
1070             break;
1071           }
1072       }
1073 #endif /* 0 */
1074
1075   /* Get the decls in the order they were written.
1076      Usually current_binding_level->names is in reverse order.
1077      But parameter decls were previously put in forward order.  */
1078
1079   if (reverse)
1080     current_binding_level->names
1081       = decls = nreverse (current_binding_level->names);
1082   else
1083     decls = current_binding_level->names;
1084
1085   /* Output any nested inline functions within this block
1086      if they weren't already output.  */
1087
1088   for (decl = decls; decl; decl = TREE_CHAIN (decl))
1089     if (TREE_CODE (decl) == FUNCTION_DECL
1090         && ! TREE_ASM_WRITTEN (decl)
1091         && DECL_INITIAL (decl) != 0
1092         && TREE_ADDRESSABLE (decl))
1093       {
1094         /* If this decl was copied from a file-scope decl
1095            on account of a block-scope extern decl,
1096            propagate TREE_ADDRESSABLE to the file-scope decl.
1097
1098            DECL_ABSTRACT_ORIGIN can be set to itself if warn_return_type is
1099            true, since then the decl goes through save_for_inline_copying.  */
1100         if (DECL_ABSTRACT_ORIGIN (decl) != 0
1101             && DECL_ABSTRACT_ORIGIN (decl) != decl)
1102           TREE_ADDRESSABLE (DECL_ABSTRACT_ORIGIN (decl)) = 1;
1103       }
1104
1105   /* We used to warn about unused variables in expand_end_bindings,
1106      i.e. while generating RTL.  But in function-at-a-time mode we may
1107      choose to never expand a function at all (e.g. auto inlining), so
1108      we do this explicitly now.  */
1109   warn_about_unused_variables (getdecls ());
1110
1111   /* If there were any declarations or structure tags in that level,
1112      or if this level is a function body,
1113      create a BLOCK to record them for the life of this function.  */
1114
1115   block = 0;
1116   block_previously_created = (current_binding_level->this_block != 0);
1117   if (block_previously_created)
1118     block = current_binding_level->this_block;
1119   else if (keep || functionbody
1120            || (current_binding_level->keep_if_subblocks && subblocks != 0))
1121     block = make_node (BLOCK);
1122   if (block != 0)
1123     {
1124       BLOCK_VARS (block) = decls;
1125       BLOCK_SUBBLOCKS (block) = subblocks;
1126     }
1127
1128   /* In each subblock, record that this is its superior.  */
1129
1130   for (link = subblocks; link; link = TREE_CHAIN (link))
1131     BLOCK_SUPERCONTEXT (link) = block;
1132
1133   /* Clear out the meanings of the local variables of this level.  */
1134
1135   for (link = decls; link; link = TREE_CHAIN (link))
1136     {
1137       if (DECL_NAME (link) != 0)
1138         {
1139           /* If the ident. was used or addressed via a local extern decl,
1140              don't forget that fact.  */
1141           if (DECL_EXTERNAL (link))
1142             {
1143               if (TREE_USED (link))
1144                 TREE_USED (DECL_NAME (link)) = 1;
1145               if (TREE_ADDRESSABLE (link))
1146                 TREE_ADDRESSABLE (DECL_ASSEMBLER_NAME (link)) = 1;
1147             }
1148           IDENTIFIER_LOCAL_VALUE (DECL_NAME (link)) = 0;
1149         }
1150     }
1151
1152   /* Restore all name-meanings of the outer levels
1153      that were shadowed by this level.  */
1154
1155   for (link = current_binding_level->shadowed; link; link = TREE_CHAIN (link))
1156     IDENTIFIER_LOCAL_VALUE (TREE_PURPOSE (link)) = TREE_VALUE (link);
1157
1158   /* If the level being exited is the top level of a function,
1159      check over all the labels, and clear out the current
1160      (function local) meanings of their names.  */
1161
1162   if (functionbody)
1163     {
1164       clear_limbo_values (block);
1165
1166       /* If this is the top level block of a function,
1167          the vars are the function's parameters.
1168          Don't leave them in the BLOCK because they are
1169          found in the FUNCTION_DECL instead.  */
1170
1171       BLOCK_VARS (block) = 0;
1172
1173       /* Clear out the definitions of all label names,
1174          since their scopes end here,
1175          and add them to BLOCK_VARS.  */
1176
1177       for (link = named_labels; link; link = TREE_CHAIN (link))
1178         {
1179           register tree label = TREE_VALUE (link);
1180
1181           if (DECL_INITIAL (label) == 0)
1182             {
1183               error_with_decl (label, "label `%s' used but not defined");
1184               /* Avoid crashing later.  */
1185               define_label (input_filename, lineno,
1186                             DECL_NAME (label));
1187             }
1188           else if (warn_unused_label && !TREE_USED (label))
1189             warning_with_decl (label, "label `%s' defined but not used");
1190           IDENTIFIER_LABEL_VALUE (DECL_NAME (label)) = 0;
1191
1192           /* Put the labels into the "variables" of the
1193              top-level block, so debugger can see them.  */
1194           TREE_CHAIN (label) = BLOCK_VARS (block);
1195           BLOCK_VARS (block) = label;
1196         }
1197     }
1198
1199   /* Pop the current level, and free the structure for reuse.  */
1200
1201   {
1202     register struct binding_level *level = current_binding_level;
1203     current_binding_level = current_binding_level->level_chain;
1204
1205     level->level_chain = free_binding_level;
1206     free_binding_level = level;
1207   }
1208
1209   /* Dispose of the block that we just made inside some higher level.  */
1210   if (functionbody)
1211     DECL_INITIAL (current_function_decl) = block;
1212   else if (block)
1213     {
1214       if (!block_previously_created)
1215         current_binding_level->blocks
1216           = chainon (current_binding_level->blocks, block);
1217     }
1218   /* If we did not make a block for the level just exited,
1219      any blocks made for inner levels
1220      (since they cannot be recorded as subblocks in that level)
1221      must be carried forward so they will later become subblocks
1222      of something else.  */
1223   else if (subblocks)
1224     current_binding_level->blocks
1225       = chainon (current_binding_level->blocks, subblocks);
1226
1227   /* Set the TYPE_CONTEXTs for all of the tagged types belonging to this
1228      binding contour so that they point to the appropriate construct, i.e.
1229      either to the current FUNCTION_DECL node, or else to the BLOCK node
1230      we just constructed.
1231
1232      Note that for tagged types whose scope is just the formal parameter
1233      list for some function type specification, we can't properly set
1234      their TYPE_CONTEXTs here, because we don't have a pointer to the
1235      appropriate FUNCTION_TYPE node readily available to us.  For those
1236      cases, the TYPE_CONTEXTs of the relevant tagged type nodes get set
1237      in `grokdeclarator' as soon as we have created the FUNCTION_TYPE
1238      node which will represent the "scope" for these "parameter list local"
1239      tagged types.  */
1240
1241   if (functionbody)
1242     for (link = tags; link; link = TREE_CHAIN (link))
1243       TYPE_CONTEXT (TREE_VALUE (link)) = current_function_decl;
1244   else if (block)
1245     for (link = tags; link; link = TREE_CHAIN (link))
1246       TYPE_CONTEXT (TREE_VALUE (link)) = block;
1247
1248   if (block)
1249     TREE_USED (block) = 1;
1250
1251   return block;
1252 }
1253
1254 /* Delete the node BLOCK from the current binding level.
1255    This is used for the block inside a stmt expr ({...})
1256    so that the block can be reinserted where appropriate.  */
1257
1258 void
1259 delete_block (block)
1260      tree block;
1261 {
1262   tree t;
1263   if (current_binding_level->blocks == block)
1264     current_binding_level->blocks = TREE_CHAIN (block);
1265   for (t = current_binding_level->blocks; t;)
1266     {
1267       if (TREE_CHAIN (t) == block)
1268         TREE_CHAIN (t) = TREE_CHAIN (block);
1269       else
1270         t = TREE_CHAIN (t);
1271     }
1272   TREE_CHAIN (block) = NULL;
1273   /* Clear TREE_USED which is always set by poplevel.
1274      The flag is set again if insert_block is called.  */
1275   TREE_USED (block) = 0;
1276 }
1277
1278 /* Insert BLOCK at the end of the list of subblocks of the
1279    current binding level.  This is used when a BIND_EXPR is expanded,
1280    to handle the BLOCK node inside the BIND_EXPR.  */
1281
1282 void
1283 insert_block (block)
1284      tree block;
1285 {
1286   TREE_USED (block) = 1;
1287   current_binding_level->blocks
1288     = chainon (current_binding_level->blocks, block);
1289 }
1290
1291 /* Set the BLOCK node for the innermost scope
1292    (the one we are currently in).  */
1293
1294 void
1295 set_block (block)
1296      register tree block;
1297 {
1298   current_binding_level->this_block = block;
1299 }
1300 \f
1301 void
1302 push_label_level ()
1303 {
1304   register struct binding_level *newlevel;
1305
1306   /* Reuse or create a struct for this binding level.  */
1307
1308   if (free_binding_level)
1309     {
1310       newlevel = free_binding_level;
1311       free_binding_level = free_binding_level->level_chain;
1312     }
1313   else
1314     {
1315       newlevel = make_binding_level ();
1316     }
1317
1318   /* Add this level to the front of the chain (stack) of label levels.  */
1319
1320   newlevel->level_chain = label_level_chain;
1321   label_level_chain = newlevel;
1322
1323   newlevel->names = named_labels;
1324   newlevel->shadowed = shadowed_labels;
1325   named_labels = 0;
1326   shadowed_labels = 0;
1327 }
1328
1329 void
1330 pop_label_level ()
1331 {
1332   register struct binding_level *level = label_level_chain;
1333   tree link, prev;
1334
1335   /* Clear out the definitions of the declared labels in this level.
1336      Leave in the list any ordinary, non-declared labels.  */
1337   for (link = named_labels, prev = 0; link;)
1338     {
1339       if (C_DECLARED_LABEL_FLAG (TREE_VALUE (link)))
1340         {
1341           if (DECL_SOURCE_LINE (TREE_VALUE (link)) == 0)
1342             {
1343               error_with_decl (TREE_VALUE (link),
1344                                "label `%s' used but not defined");
1345               /* Avoid crashing later.  */
1346               define_label (input_filename, lineno,
1347                             DECL_NAME (TREE_VALUE (link)));
1348             }
1349           else if (warn_unused_label && !TREE_USED (TREE_VALUE (link)))
1350             warning_with_decl (TREE_VALUE (link),
1351                                "label `%s' defined but not used");
1352           IDENTIFIER_LABEL_VALUE (DECL_NAME (TREE_VALUE (link))) = 0;
1353
1354           /* Delete this element from the list.  */
1355           link = TREE_CHAIN (link);
1356           if (prev)
1357             TREE_CHAIN (prev) = link;
1358           else
1359             named_labels = link;
1360         }
1361       else
1362         {
1363           prev = link;
1364           link = TREE_CHAIN (link);
1365         }
1366     }
1367
1368   /* Bring back all the labels that were shadowed.  */
1369   for (link = shadowed_labels; link; link = TREE_CHAIN (link))
1370     if (DECL_NAME (TREE_VALUE (link)) != 0)
1371       IDENTIFIER_LABEL_VALUE (DECL_NAME (TREE_VALUE (link)))
1372         = TREE_VALUE (link);
1373
1374   named_labels = chainon (named_labels, level->names);
1375   shadowed_labels = level->shadowed;
1376
1377   /* Pop the current level, and free the structure for reuse.  */
1378   label_level_chain = label_level_chain->level_chain;
1379   level->level_chain = free_binding_level;
1380   free_binding_level = level;
1381 }
1382 \f
1383 /* Push a definition or a declaration of struct, union or enum tag "name".
1384    "type" should be the type node.
1385    We assume that the tag "name" is not already defined.
1386
1387    Note that the definition may really be just a forward reference.
1388    In that case, the TYPE_SIZE will be zero.  */
1389
1390 void
1391 pushtag (name, type)
1392      tree name, type;
1393 {
1394   register struct binding_level *b;
1395
1396   /* Find the proper binding level for this type tag.  */
1397
1398   for (b = current_binding_level; b->tag_transparent; b = b->level_chain)
1399     continue;
1400
1401   if (name)
1402     {
1403       /* Record the identifier as the type's name if it has none.  */
1404
1405       if (TYPE_NAME (type) == 0)
1406         TYPE_NAME (type) = name;
1407     }
1408
1409   b->tags = tree_cons (name, type, b->tags);
1410
1411   /* Create a fake NULL-named TYPE_DECL node whose TREE_TYPE will be the
1412      tagged type we just added to the current binding level.  This fake
1413      NULL-named TYPE_DECL node helps dwarfout.c to know when it needs
1414      to output a representation of a tagged type, and it also gives
1415      us a convenient place to record the "scope start" address for the
1416      tagged type.  */
1417
1418   TYPE_STUB_DECL (type) = pushdecl (build_decl (TYPE_DECL, NULL_TREE, type));
1419
1420   /* An approximation for now, so we can tell this is a function-scope tag.
1421      This will be updated in poplevel.  */
1422   TYPE_CONTEXT (type) = DECL_CONTEXT (TYPE_STUB_DECL (type));
1423 }
1424 \f
1425 /* Handle when a new declaration NEWDECL
1426    has the same name as an old one OLDDECL
1427    in the same binding contour.
1428    Prints an error message if appropriate.
1429
1430    If safely possible, alter OLDDECL to look like NEWDECL, and return 1.
1431    Otherwise, return 0.
1432
1433    When DIFFERENT_BINDING_LEVEL is true, NEWDECL is an external declaration,
1434    and OLDDECL is in an outer binding level and should thus not be changed.  */
1435
1436 static int
1437 duplicate_decls (newdecl, olddecl, different_binding_level)
1438      register tree newdecl, olddecl;
1439      int different_binding_level;
1440 {
1441   int types_match = comptypes (TREE_TYPE (newdecl), TREE_TYPE (olddecl));
1442   int new_is_definition = (TREE_CODE (newdecl) == FUNCTION_DECL
1443                            && DECL_INITIAL (newdecl) != 0);
1444   tree oldtype = TREE_TYPE (olddecl);
1445   tree newtype = TREE_TYPE (newdecl);
1446   int errmsg = 0;
1447
1448   if (DECL_P (olddecl))
1449     DECL_MACHINE_ATTRIBUTES (newdecl)
1450       = merge_machine_decl_attributes (olddecl, newdecl);
1451
1452   if (TREE_CODE (newtype) == ERROR_MARK
1453       || TREE_CODE (oldtype) == ERROR_MARK)
1454     types_match = 0;
1455
1456   /* New decl is completely inconsistent with the old one =>
1457      tell caller to replace the old one.
1458      This is always an error except in the case of shadowing a builtin.  */
1459   if (TREE_CODE (olddecl) != TREE_CODE (newdecl))
1460     {
1461       if (TREE_CODE (olddecl) == FUNCTION_DECL
1462           && (DECL_BUILT_IN (olddecl)
1463               || DECL_BUILT_IN_NONANSI (olddecl)))
1464         {
1465           /* If you declare a built-in or predefined function name as static,
1466              the old definition is overridden,
1467              but optionally warn this was a bad choice of name.  */
1468           if (!TREE_PUBLIC (newdecl))
1469             {
1470               if (!warn_shadow)
1471                 ;
1472               else if (DECL_BUILT_IN (olddecl))
1473                 warning_with_decl (newdecl, "shadowing built-in function `%s'");
1474               else
1475                 warning_with_decl (newdecl, "shadowing library function `%s'");
1476             }
1477           /* Likewise, if the built-in is not ansi, then programs can
1478              override it even globally without an error.  */
1479           else if (! DECL_BUILT_IN (olddecl))
1480             warning_with_decl (newdecl,
1481                                "library function `%s' declared as non-function");
1482
1483           else if (DECL_BUILT_IN_NONANSI (olddecl))
1484             warning_with_decl (newdecl,
1485                                "built-in function `%s' declared as non-function");
1486           else
1487             warning_with_decl (newdecl,
1488                                "built-in function `%s' declared as non-function");
1489         }
1490       else
1491         {
1492           error_with_decl (newdecl, "`%s' redeclared as different kind of symbol");
1493           error_with_decl (olddecl, "previous declaration of `%s'");
1494         }
1495
1496       return 0;
1497     }
1498
1499   /* For real parm decl following a forward decl,
1500      return 1 so old decl will be reused.  */
1501   if (types_match && TREE_CODE (newdecl) == PARM_DECL
1502       && TREE_ASM_WRITTEN (olddecl) && ! TREE_ASM_WRITTEN (newdecl))
1503     return 1;
1504
1505   /* The new declaration is the same kind of object as the old one.
1506      The declarations may partially match.  Print warnings if they don't
1507      match enough.  Ultimately, copy most of the information from the new
1508      decl to the old one, and keep using the old one.  */
1509
1510   if (flag_traditional && TREE_CODE (newdecl) == FUNCTION_DECL
1511       && IDENTIFIER_IMPLICIT_DECL (DECL_NAME (newdecl)) == olddecl
1512       && DECL_INITIAL (olddecl) == 0)
1513     /* If -traditional, avoid error for redeclaring fcn
1514        after implicit decl.  */
1515     ;
1516   else if (TREE_CODE (olddecl) == FUNCTION_DECL
1517            && DECL_BUILT_IN (olddecl))
1518     {
1519       /* A function declaration for a built-in function.  */
1520       if (!TREE_PUBLIC (newdecl))
1521         {
1522           /* If you declare a built-in function name as static, the
1523              built-in definition is overridden,
1524              but optionally warn this was a bad choice of name.  */
1525           if (warn_shadow)
1526             warning_with_decl (newdecl, "shadowing built-in function `%s'");
1527           /* Discard the old built-in function.  */
1528           return 0;
1529         }
1530       else if (!types_match)
1531         {
1532           /* Accept the return type of the new declaration if same modes.  */
1533           tree oldreturntype = TREE_TYPE (oldtype);
1534           tree newreturntype = TREE_TYPE (newtype);
1535
1536           if (TYPE_MODE (oldreturntype) == TYPE_MODE (newreturntype))
1537             {
1538               /* Function types may be shared, so we can't just modify
1539                  the return type of olddecl's function type.  */
1540               tree trytype
1541                 = build_function_type (newreturntype,
1542                                        TYPE_ARG_TYPES (oldtype));
1543
1544               types_match = comptypes (newtype, trytype);
1545               if (types_match)
1546                 oldtype = trytype;
1547             }
1548           /* Accept harmless mismatch in first argument type also.
1549              This is for ffs.  */
1550           if (TYPE_ARG_TYPES (TREE_TYPE (newdecl)) != 0
1551               && TYPE_ARG_TYPES (oldtype) != 0
1552               && TREE_VALUE (TYPE_ARG_TYPES (newtype)) != 0
1553               && TREE_VALUE (TYPE_ARG_TYPES (oldtype)) != 0
1554               && (TYPE_MODE (TREE_VALUE (TYPE_ARG_TYPES (newtype)))
1555                   == TYPE_MODE (TREE_VALUE (TYPE_ARG_TYPES (oldtype)))))
1556             {
1557               /* Function types may be shared, so we can't just modify
1558                  the return type of olddecl's function type.  */
1559               tree trytype
1560                 = build_function_type (TREE_TYPE (oldtype),
1561                                        tree_cons (NULL_TREE,
1562                                                   TREE_VALUE (TYPE_ARG_TYPES (newtype)),
1563                                                   TREE_CHAIN (TYPE_ARG_TYPES (oldtype))));
1564
1565               types_match = comptypes (newtype, trytype);
1566               if (types_match)
1567                 oldtype = trytype;
1568             }
1569           if (! different_binding_level)
1570             TREE_TYPE (olddecl) = oldtype;
1571         }
1572       if (!types_match)
1573         {
1574           /* If types don't match for a built-in, throw away the built-in.  */
1575           warning_with_decl (newdecl, "conflicting types for built-in function `%s'");
1576           return 0;
1577         }
1578     }
1579   else if (TREE_CODE (olddecl) == FUNCTION_DECL
1580            && DECL_SOURCE_LINE (olddecl) == 0)
1581     {
1582       /* A function declaration for a predeclared function
1583          that isn't actually built in.  */
1584       if (!TREE_PUBLIC (newdecl))
1585         {
1586           /* If you declare it as static, the
1587              default definition is overridden.  */
1588           return 0;
1589         }
1590       else if (!types_match)
1591         {
1592           /* If the types don't match, preserve volatility indication.
1593              Later on, we will discard everything else about the
1594              default declaration.  */
1595           TREE_THIS_VOLATILE (newdecl) |= TREE_THIS_VOLATILE (olddecl);
1596         }
1597     }
1598   /* Permit char *foo () to match void *foo (...) if not pedantic,
1599      if one of them came from a system header file.  */
1600   else if (!types_match
1601            && TREE_CODE (olddecl) == FUNCTION_DECL
1602            && TREE_CODE (newdecl) == FUNCTION_DECL
1603            && TREE_CODE (TREE_TYPE (oldtype)) == POINTER_TYPE
1604            && TREE_CODE (TREE_TYPE (newtype)) == POINTER_TYPE
1605            && (DECL_IN_SYSTEM_HEADER (olddecl)
1606                || DECL_IN_SYSTEM_HEADER (newdecl))
1607            && ((TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (newtype))) == void_type_node
1608                 && TYPE_ARG_TYPES (oldtype) == 0
1609                 && self_promoting_args_p (TYPE_ARG_TYPES (newtype))
1610                 && TREE_TYPE (TREE_TYPE (oldtype)) == char_type_node)
1611                ||
1612                (TREE_TYPE (TREE_TYPE (newtype)) == char_type_node
1613                 && TYPE_ARG_TYPES (newtype) == 0
1614                 && self_promoting_args_p (TYPE_ARG_TYPES (oldtype))
1615                 && TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (oldtype))) == void_type_node)))
1616     {
1617       if (pedantic)
1618         pedwarn_with_decl (newdecl, "conflicting types for `%s'");
1619       /* Make sure we keep void * as ret type, not char *.  */
1620       if (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (oldtype))) == void_type_node)
1621         TREE_TYPE (newdecl) = newtype = oldtype;
1622
1623       /* Set DECL_IN_SYSTEM_HEADER, so that if we see another declaration
1624          we will come back here again.  */
1625       DECL_IN_SYSTEM_HEADER (newdecl) = 1;
1626     }
1627   else if (!types_match
1628            /* Permit char *foo (int, ...); followed by char *foo ();
1629               if not pedantic.  */
1630            && ! (TREE_CODE (olddecl) == FUNCTION_DECL
1631                  && ! pedantic
1632                  /* Return types must still match.  */
1633                  && comptypes (TREE_TYPE (oldtype),
1634                                TREE_TYPE (newtype))
1635                  && TYPE_ARG_TYPES (newtype) == 0))
1636     {
1637       error_with_decl (newdecl, "conflicting types for `%s'");
1638       /* Check for function type mismatch
1639          involving an empty arglist vs a nonempty one.  */
1640       if (TREE_CODE (olddecl) == FUNCTION_DECL
1641           && comptypes (TREE_TYPE (oldtype),
1642                         TREE_TYPE (newtype))
1643           && ((TYPE_ARG_TYPES (oldtype) == 0
1644                && DECL_INITIAL (olddecl) == 0)
1645               ||
1646               (TYPE_ARG_TYPES (newtype) == 0
1647                && DECL_INITIAL (newdecl) == 0)))
1648         {
1649           /* Classify the problem further.  */
1650           register tree t = TYPE_ARG_TYPES (oldtype);
1651           if (t == 0)
1652             t = TYPE_ARG_TYPES (newtype);
1653           for (; t; t = TREE_CHAIN (t))
1654             {
1655               register tree type = TREE_VALUE (t);
1656
1657               if (TREE_CHAIN (t) == 0
1658                   && TYPE_MAIN_VARIANT (type) != void_type_node)
1659                 {
1660                   error ("A parameter list with an ellipsis can't match an empty parameter name list declaration.");
1661                   break;
1662                 }
1663
1664               if (simple_type_promotes_to (type) != NULL_TREE)
1665                 {
1666                   error ("An argument type that has a default promotion can't match an empty parameter name list declaration.");
1667                   break;
1668                 }
1669             }
1670         }
1671       error_with_decl (olddecl, "previous declaration of `%s'");
1672     }
1673   else
1674     {
1675       errmsg = redeclaration_error_message (newdecl, olddecl);
1676       if (errmsg)
1677         {
1678           switch (errmsg)
1679             {
1680             case 1:
1681               error_with_decl (newdecl, "redefinition of `%s'");
1682               break;
1683             case 2:
1684               error_with_decl (newdecl, "redeclaration of `%s'");
1685               break;
1686             case 3:
1687               error_with_decl (newdecl, "conflicting declarations of `%s'");
1688               break;
1689             default:
1690               abort ();
1691             }
1692
1693           error_with_decl (olddecl,
1694                            ((DECL_INITIAL (olddecl)
1695                              && current_binding_level == global_binding_level)
1696                             ? "`%s' previously defined here"
1697                             : "`%s' previously declared here"));
1698         }
1699       else if (TREE_CODE (newdecl) == TYPE_DECL
1700                && (DECL_IN_SYSTEM_HEADER (olddecl)
1701                    || DECL_IN_SYSTEM_HEADER (newdecl)))
1702         {
1703           warning_with_decl (newdecl, "redefinition of `%s'");
1704           warning_with_decl
1705             (olddecl,
1706              ((DECL_INITIAL (olddecl)
1707                && current_binding_level == global_binding_level)
1708               ? "`%s' previously defined here"
1709               : "`%s' previously declared here"));
1710         }
1711       else if (TREE_CODE (olddecl) == FUNCTION_DECL
1712                && DECL_INITIAL (olddecl) != 0
1713                && TYPE_ARG_TYPES (oldtype) == 0
1714                && TYPE_ARG_TYPES (newtype) != 0
1715                && TYPE_ACTUAL_ARG_TYPES (oldtype) != 0)
1716         {
1717           register tree type, parm;
1718           register int nargs;
1719           /* Prototype decl follows defn w/o prototype.  */
1720
1721           for (parm = TYPE_ACTUAL_ARG_TYPES (oldtype),
1722                type = TYPE_ARG_TYPES (newtype),
1723                nargs = 1;
1724                ;
1725                parm = TREE_CHAIN (parm), type = TREE_CHAIN (type), nargs++)
1726             {
1727               if (TYPE_MAIN_VARIANT (TREE_VALUE (parm)) == void_type_node
1728                   && TYPE_MAIN_VARIANT (TREE_VALUE (type)) == void_type_node)
1729                 {
1730                   warning_with_decl (newdecl, "prototype for `%s' follows");
1731                   warning_with_decl (olddecl, "non-prototype definition here");
1732                   break;
1733                 }
1734               if (TYPE_MAIN_VARIANT (TREE_VALUE (parm)) == void_type_node
1735                   || TYPE_MAIN_VARIANT (TREE_VALUE (type)) == void_type_node)
1736                 {
1737                   error_with_decl (newdecl,
1738                                    "prototype for `%s' follows and number of arguments doesn't match");
1739                   error_with_decl (olddecl, "non-prototype definition here");
1740                   errmsg = 1;
1741                   break;
1742                 }
1743               /* Type for passing arg must be consistent
1744                  with that declared for the arg.  */
1745               if (! comptypes (TREE_VALUE (parm), TREE_VALUE (type))
1746                   /* If -traditional, allow `unsigned int' instead of `int'
1747                      in the prototype.  */
1748                   && (! (flag_traditional
1749                          && TYPE_MAIN_VARIANT (TREE_VALUE (parm)) == integer_type_node
1750                          && TYPE_MAIN_VARIANT (TREE_VALUE (type)) == unsigned_type_node)))
1751                 {
1752                   error_with_decl (newdecl,
1753                                    "prototype for `%s' follows and argument %d doesn't match",
1754                                    nargs);
1755                   error_with_decl (olddecl, "non-prototype definition here");
1756                   errmsg = 1;
1757                   break;
1758                 }
1759             }
1760         }
1761       /* Warn about mismatches in various flags.  */
1762       else
1763         {
1764           /* Warn if function is now inline
1765              but was previously declared not inline and has been called.  */
1766           if (TREE_CODE (olddecl) == FUNCTION_DECL
1767               && ! DECL_INLINE (olddecl) && DECL_INLINE (newdecl)
1768               && TREE_USED (olddecl))
1769             warning_with_decl (newdecl,
1770                                "`%s' declared inline after being called");
1771           if (TREE_CODE (olddecl) == FUNCTION_DECL
1772               && ! DECL_INLINE (olddecl) && DECL_INLINE (newdecl)
1773               && DECL_INITIAL (olddecl) != 0)
1774             warning_with_decl (newdecl,
1775                                "`%s' declared inline after its definition");
1776
1777           /* If pedantic, warn when static declaration follows a non-static
1778              declaration.  Otherwise, do so only for functions.  */
1779           if ((pedantic || TREE_CODE (olddecl) == FUNCTION_DECL)
1780               && TREE_PUBLIC (olddecl)
1781               && !TREE_PUBLIC (newdecl))
1782             warning_with_decl (newdecl, "static declaration for `%s' follows non-static");
1783
1784           /* If warn_traditional, warn when a non-static function
1785              declaration follows a static one.  */
1786           if (warn_traditional && !in_system_header
1787               && TREE_CODE (olddecl) == FUNCTION_DECL
1788               && !TREE_PUBLIC (olddecl)
1789               && TREE_PUBLIC (newdecl))
1790             warning_with_decl (newdecl, "non-static declaration for `%s' follows static");
1791
1792           /* Warn when const declaration follows a non-const
1793              declaration, but not for functions.  */
1794           if (TREE_CODE (olddecl) != FUNCTION_DECL
1795               && !TREE_READONLY (olddecl)
1796               && TREE_READONLY (newdecl))
1797             warning_with_decl (newdecl, "const declaration for `%s' follows non-const");
1798           /* These bits are logically part of the type, for variables.
1799              But not for functions
1800              (where qualifiers are not valid ANSI anyway).  */
1801           else if (pedantic && TREE_CODE (olddecl) != FUNCTION_DECL
1802               && (TREE_READONLY (newdecl) != TREE_READONLY (olddecl)
1803                   || TREE_THIS_VOLATILE (newdecl) != TREE_THIS_VOLATILE (olddecl)))
1804             pedwarn_with_decl (newdecl, "type qualifiers for `%s' conflict with previous decl");
1805         }
1806     }
1807
1808   /* Optionally warn about more than one declaration for the same name.  */
1809   if (errmsg == 0 && warn_redundant_decls && DECL_SOURCE_LINE (olddecl) != 0
1810       /* Don't warn about a function declaration
1811          followed by a definition.  */
1812       && !(TREE_CODE (newdecl) == FUNCTION_DECL && DECL_INITIAL (newdecl) != 0
1813            && DECL_INITIAL (olddecl) == 0)
1814       /* Don't warn about extern decl followed by (tentative) definition.  */
1815       && !(DECL_EXTERNAL (olddecl) && ! DECL_EXTERNAL (newdecl)))
1816     {
1817       warning_with_decl (newdecl, "redundant redeclaration of `%s' in same scope");
1818       warning_with_decl (olddecl, "previous declaration of `%s'");
1819     }
1820
1821   /* Copy all the DECL_... slots specified in the new decl
1822      except for any that we copy here from the old type.
1823
1824      Past this point, we don't change OLDTYPE and NEWTYPE
1825      even if we change the types of NEWDECL and OLDDECL.  */
1826
1827   if (types_match)
1828     {
1829       /* When copying info to olddecl, we store into write_olddecl
1830          instead.  This allows us to avoid modifying olddecl when
1831          different_binding_level is true.  */
1832       tree write_olddecl = different_binding_level ? newdecl : olddecl;
1833
1834       /* Merge the data types specified in the two decls.  */
1835       if (TREE_CODE (newdecl) != FUNCTION_DECL || !DECL_BUILT_IN (olddecl))
1836         {
1837           if (different_binding_level)
1838             TREE_TYPE (newdecl)
1839               = build_type_attribute_variant
1840                 (newtype,
1841                  merge_attributes (TYPE_ATTRIBUTES (newtype),
1842                                    TYPE_ATTRIBUTES (oldtype)));
1843           else
1844             TREE_TYPE (newdecl)
1845               = TREE_TYPE (olddecl)
1846                 = common_type (newtype, oldtype);
1847         }
1848
1849       /* Lay the type out, unless already done.  */
1850       if (oldtype != TREE_TYPE (newdecl))
1851         {
1852           if (TREE_TYPE (newdecl) != error_mark_node)
1853             layout_type (TREE_TYPE (newdecl));
1854           if (TREE_CODE (newdecl) != FUNCTION_DECL
1855               && TREE_CODE (newdecl) != TYPE_DECL
1856               && TREE_CODE (newdecl) != CONST_DECL)
1857             layout_decl (newdecl, 0);
1858         }
1859       else
1860         {
1861           /* Since the type is OLDDECL's, make OLDDECL's size go with.  */
1862           DECL_SIZE (newdecl) = DECL_SIZE (olddecl);
1863           DECL_SIZE_UNIT (newdecl) = DECL_SIZE_UNIT (olddecl);
1864           DECL_MODE (newdecl) = DECL_MODE (olddecl);
1865           if (TREE_CODE (olddecl) != FUNCTION_DECL)
1866             if (DECL_ALIGN (olddecl) > DECL_ALIGN (newdecl))
1867               {
1868                 DECL_ALIGN (newdecl) = DECL_ALIGN (olddecl);
1869                 DECL_USER_ALIGN (newdecl) |= DECL_ALIGN (olddecl);
1870               }
1871         }
1872
1873       /* Keep the old rtl since we can safely use it.  */
1874       DECL_RTL (newdecl) = DECL_RTL (olddecl);
1875
1876       /* Merge the type qualifiers.  */
1877       if (TREE_CODE (olddecl) == FUNCTION_DECL
1878           && DECL_BUILT_IN_NONANSI (olddecl) && TREE_THIS_VOLATILE (olddecl)
1879           && ! TREE_THIS_VOLATILE (newdecl))
1880         TREE_THIS_VOLATILE (write_olddecl) = 0;
1881
1882       if (TREE_READONLY (newdecl))
1883         TREE_READONLY (write_olddecl) = 1;
1884
1885       if (TREE_THIS_VOLATILE (newdecl))
1886         {
1887           TREE_THIS_VOLATILE (write_olddecl) = 1;
1888           if (TREE_CODE (newdecl) == VAR_DECL
1889               /* If an automatic variable is re-declared in the same
1890                  function scope, but the old declaration was not
1891                  volatile, make_var_volatile() would crash because the
1892                  variable would have been assigned to a pseudo, not a
1893                  MEM.  Since this duplicate declaration is invalid
1894                  anyway, we just skip the call.  */
1895               && errmsg == 0)
1896             make_var_volatile (newdecl);
1897         }
1898
1899       /* Keep source location of definition rather than declaration.  */
1900       /* When called with different_binding_level set, keep the old
1901          information so that meaningful diagnostics can be given.  */
1902       if (DECL_INITIAL (newdecl) == 0 && DECL_INITIAL (olddecl) != 0
1903           && ! different_binding_level)
1904         {
1905           DECL_SOURCE_LINE (newdecl) = DECL_SOURCE_LINE (olddecl);
1906           DECL_SOURCE_FILE (newdecl) = DECL_SOURCE_FILE (olddecl);
1907         }
1908
1909       /* Merge the unused-warning information.  */
1910       if (DECL_IN_SYSTEM_HEADER (olddecl))
1911         DECL_IN_SYSTEM_HEADER (newdecl) = 1;
1912       else if (DECL_IN_SYSTEM_HEADER (newdecl))
1913         DECL_IN_SYSTEM_HEADER (write_olddecl) = 1;
1914
1915       /* Merge the initialization information.  */
1916       /* When called with different_binding_level set, don't copy over
1917          DECL_INITIAL, so that we don't accidentally change function
1918          declarations into function definitions.  */
1919       if (DECL_INITIAL (newdecl) == 0 && ! different_binding_level)
1920         DECL_INITIAL (newdecl) = DECL_INITIAL (olddecl);
1921
1922       /* Merge the section attribute.
1923          We want to issue an error if the sections conflict but that must be
1924          done later in decl_attributes since we are called before attributes
1925          are assigned.  */
1926       if (DECL_SECTION_NAME (newdecl) == NULL_TREE)
1927         DECL_SECTION_NAME (newdecl) = DECL_SECTION_NAME (olddecl);
1928
1929       /* Copy the assembler name.
1930          Currently, it can only be defined in the prototype.  */
1931       DECL_ASSEMBLER_NAME (newdecl) = DECL_ASSEMBLER_NAME (olddecl);
1932
1933       if (TREE_CODE (newdecl) == FUNCTION_DECL)
1934         {
1935           DECL_STATIC_CONSTRUCTOR(newdecl) |= DECL_STATIC_CONSTRUCTOR(olddecl);
1936           DECL_STATIC_DESTRUCTOR (newdecl) |= DECL_STATIC_DESTRUCTOR (olddecl);
1937
1938           DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (newdecl)
1939             |= DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (olddecl);
1940           DECL_NO_CHECK_MEMORY_USAGE (newdecl)
1941             |= DECL_NO_CHECK_MEMORY_USAGE (olddecl);
1942           DECL_NO_LIMIT_STACK (newdecl)
1943             |= DECL_NO_LIMIT_STACK (olddecl);
1944         }
1945     }
1946   /* If cannot merge, then use the new type and qualifiers,
1947      and don't preserve the old rtl.  */
1948   else if (! different_binding_level)
1949     {
1950       TREE_TYPE (olddecl) = TREE_TYPE (newdecl);
1951       TREE_READONLY (olddecl) = TREE_READONLY (newdecl);
1952       TREE_THIS_VOLATILE (olddecl) = TREE_THIS_VOLATILE (newdecl);
1953       TREE_SIDE_EFFECTS (olddecl) = TREE_SIDE_EFFECTS (newdecl);
1954     }
1955
1956   /* Merge the storage class information.  */
1957   DECL_WEAK (newdecl) |= DECL_WEAK (olddecl);
1958   /* For functions, static overrides non-static.  */
1959   if (TREE_CODE (newdecl) == FUNCTION_DECL)
1960     {
1961       TREE_PUBLIC (newdecl) &= TREE_PUBLIC (olddecl);
1962       /* This is since we don't automatically
1963          copy the attributes of NEWDECL into OLDDECL.  */
1964       /* No need to worry about different_binding_level here because
1965          then TREE_PUBLIC (newdecl) was true.  */
1966       TREE_PUBLIC (olddecl) = TREE_PUBLIC (newdecl);
1967       /* If this clears `static', clear it in the identifier too.  */
1968       if (! TREE_PUBLIC (olddecl))
1969         TREE_PUBLIC (DECL_NAME (olddecl)) = 0;
1970     }
1971   if (DECL_EXTERNAL (newdecl))
1972     {
1973       if (! different_binding_level)
1974         {
1975           /* Don't mess with these flags on local externs; they remain
1976              external even if there's a declaration at file scope which
1977              isn't.  */
1978           TREE_STATIC (newdecl) = TREE_STATIC (olddecl);
1979           DECL_EXTERNAL (newdecl) = DECL_EXTERNAL (olddecl);
1980         }
1981       /* An extern decl does not override previous storage class.  */
1982       TREE_PUBLIC (newdecl) = TREE_PUBLIC (olddecl);
1983       if (! DECL_EXTERNAL (newdecl))
1984         DECL_CONTEXT (newdecl) = DECL_CONTEXT (olddecl);
1985     }
1986   else
1987     {
1988       TREE_STATIC (olddecl) = TREE_STATIC (newdecl);
1989       TREE_PUBLIC (olddecl) = TREE_PUBLIC (newdecl);
1990     }
1991
1992   if (TREE_CODE (newdecl) == FUNCTION_DECL)
1993     {
1994       /* If either decl says `inline', this fn is inline,
1995          unless its definition was passed already.  */
1996       if (DECL_INLINE (newdecl) && DECL_INITIAL (olddecl) == 0)
1997         DECL_INLINE (olddecl) = 1;
1998
1999       DECL_INLINE (newdecl) = DECL_INLINE (olddecl);
2000
2001       if (DECL_BUILT_IN (olddecl))
2002         {
2003           /* Get rid of any built-in function if new arg types don't match it
2004              or if we have a function definition.  */
2005           if (! types_match || new_is_definition)
2006             {
2007               if (! different_binding_level)
2008                 {
2009                   TREE_TYPE (olddecl) = TREE_TYPE (newdecl);
2010                   DECL_BUILT_IN_CLASS (olddecl) = NOT_BUILT_IN;
2011                 }
2012             }
2013           else
2014             {
2015               /* If redeclaring a builtin function, and not a definition,
2016                  it stays built in.  */
2017               DECL_BUILT_IN_CLASS (newdecl) = DECL_BUILT_IN_CLASS (olddecl);
2018               DECL_FUNCTION_CODE (newdecl) = DECL_FUNCTION_CODE (olddecl);
2019             }
2020         }
2021       /* Also preserve various other info from the definition.  */
2022       else if (! new_is_definition)
2023         DECL_FRAME_SIZE (newdecl) = DECL_FRAME_SIZE (olddecl);
2024       if (! new_is_definition)
2025         {
2026           DECL_RESULT (newdecl) = DECL_RESULT (olddecl);
2027           /* When called with different_binding_level set, don't copy over
2028              DECL_INITIAL, so that we don't accidentally change function
2029              declarations into function definitions.  */
2030           if (! different_binding_level)
2031             DECL_INITIAL (newdecl) = DECL_INITIAL (olddecl);
2032           DECL_SAVED_INSNS (newdecl) = DECL_SAVED_INSNS (olddecl);
2033           DECL_ARGUMENTS (newdecl) = DECL_ARGUMENTS (olddecl);
2034           if (DECL_INLINE (newdecl))
2035             DECL_ABSTRACT_ORIGIN (newdecl) = DECL_ABSTRACT_ORIGIN (olddecl);
2036         }
2037     }
2038   if (different_binding_level)
2039     return 0;
2040
2041   /* Copy most of the decl-specific fields of NEWDECL into OLDDECL.
2042      But preserve OLDDECL's DECL_UID.  */
2043   {
2044     register unsigned olddecl_uid = DECL_UID (olddecl);
2045
2046     memcpy ((char *) olddecl + sizeof (struct tree_common),
2047             (char *) newdecl + sizeof (struct tree_common),
2048             sizeof (struct tree_decl) - sizeof (struct tree_common));
2049     DECL_UID (olddecl) = olddecl_uid;
2050   }
2051
2052   /* NEWDECL contains the merged attribute lists.
2053      Update OLDDECL to be the same.  */
2054   DECL_MACHINE_ATTRIBUTES (olddecl) = DECL_MACHINE_ATTRIBUTES (newdecl);
2055
2056   return 1;
2057 }
2058
2059 /* Record a decl-node X as belonging to the current lexical scope.
2060    Check for errors (such as an incompatible declaration for the same
2061    name already seen in the same scope).
2062
2063    Returns either X or an old decl for the same name.
2064    If an old decl is returned, it may have been smashed
2065    to agree with what X says.  */
2066
2067 tree
2068 pushdecl (x)
2069      tree x;
2070 {
2071   register tree t;
2072   register tree name = DECL_NAME (x);
2073   register struct binding_level *b = current_binding_level;
2074
2075   DECL_CONTEXT (x) = current_function_decl;
2076   /* A local extern declaration for a function doesn't constitute nesting.
2077      A local auto declaration does, since it's a forward decl
2078      for a nested function coming later.  */
2079   if ((TREE_CODE (x) == FUNCTION_DECL || TREE_CODE (x) == VAR_DECL)
2080       && DECL_INITIAL (x) == 0 && DECL_EXTERNAL (x))
2081     DECL_CONTEXT (x) = 0;
2082
2083   if (warn_nested_externs && DECL_EXTERNAL (x) && b != global_binding_level
2084       && x != IDENTIFIER_IMPLICIT_DECL (name)
2085       /* Don't print error messages for __FUNCTION__ and __PRETTY_FUNCTION__ */
2086       && !DECL_IN_SYSTEM_HEADER (x))
2087     warning ("nested extern declaration of `%s'", IDENTIFIER_POINTER (name));
2088
2089   if (name)
2090     {
2091       const char *file;
2092       int line;
2093       int different_binding_level = 0;
2094
2095       t = lookup_name_current_level (name);
2096       /* Don't type check externs here when -traditional.  This is so that
2097          code with conflicting declarations inside blocks will get warnings
2098          not errors.  X11 for instance depends on this.  */
2099       if (! t && DECL_EXTERNAL (x) && TREE_PUBLIC (x) && ! flag_traditional)
2100         {
2101           t = IDENTIFIER_GLOBAL_VALUE (name);
2102           /* Type decls at global scope don't conflict with externs declared
2103              inside lexical blocks.  */
2104           if (t && TREE_CODE (t) == TYPE_DECL)
2105             t = 0;
2106           different_binding_level = 1;
2107         }
2108       if (t != 0 && t == error_mark_node)
2109         /* error_mark_node is 0 for a while during initialization!  */
2110         {
2111           t = 0;
2112           error_with_decl (x, "`%s' used prior to declaration");
2113         }
2114
2115       if (t != 0)
2116         {
2117           file = DECL_SOURCE_FILE (t);
2118           line = DECL_SOURCE_LINE (t);
2119         }
2120
2121       /* If this decl is `static' and an implicit decl was seen previously,
2122          warn.  But don't complain if -traditional,
2123          since traditional compilers don't complain.  */
2124       if (! flag_traditional && TREE_PUBLIC (name)
2125           /* Don't test for DECL_EXTERNAL, because grokdeclarator
2126              sets this for all functions.  */
2127           && ! TREE_PUBLIC (x)
2128           && (TREE_CODE (x) == FUNCTION_DECL || b == global_binding_level)
2129           /* We used to warn also for explicit extern followed by static,
2130              but sometimes you need to do it that way.  */
2131           && IDENTIFIER_IMPLICIT_DECL (name) != 0)
2132         {
2133           pedwarn ("`%s' was declared implicitly `extern' and later `static'",
2134                    IDENTIFIER_POINTER (name));
2135           pedwarn_with_file_and_line
2136             (DECL_SOURCE_FILE (IDENTIFIER_IMPLICIT_DECL (name)),
2137              DECL_SOURCE_LINE (IDENTIFIER_IMPLICIT_DECL (name)),
2138              "previous declaration of `%s'",
2139              IDENTIFIER_POINTER (name));
2140           TREE_THIS_VOLATILE (name) = 1;
2141         }
2142
2143       if (t != 0 && duplicate_decls (x, t, different_binding_level))
2144         {
2145           if (TREE_CODE (t) == PARM_DECL)
2146             {
2147               /* Don't allow more than one "real" duplicate
2148                  of a forward parm decl.  */
2149               TREE_ASM_WRITTEN (t) = TREE_ASM_WRITTEN (x);
2150               return t;
2151             }
2152           return t;
2153         }
2154
2155       /* If we are processing a typedef statement, generate a whole new
2156          ..._TYPE node (which will be just an variant of the existing
2157          ..._TYPE node with identical properties) and then install the
2158          TYPE_DECL node generated to represent the typedef name as the
2159          TYPE_NAME of this brand new (duplicate) ..._TYPE node.
2160
2161          The whole point here is to end up with a situation where each
2162          and every ..._TYPE node the compiler creates will be uniquely
2163          associated with AT MOST one node representing a typedef name.
2164          This way, even though the compiler substitutes corresponding
2165          ..._TYPE nodes for TYPE_DECL (i.e. "typedef name") nodes very
2166          early on, later parts of the compiler can always do the reverse
2167          translation and get back the corresponding typedef name.  For
2168          example, given:
2169
2170                 typedef struct S MY_TYPE;
2171                 MY_TYPE object;
2172
2173          Later parts of the compiler might only know that `object' was of
2174          type `struct S' if it were not for code just below.  With this
2175          code however, later parts of the compiler see something like:
2176
2177                 struct S' == struct S
2178                 typedef struct S' MY_TYPE;
2179                 struct S' object;
2180
2181          And they can then deduce (from the node for type struct S') that
2182          the original object declaration was:
2183
2184                 MY_TYPE object;
2185
2186          Being able to do this is important for proper support of protoize,
2187          and also for generating precise symbolic debugging information
2188          which takes full account of the programmer's (typedef) vocabulary.
2189
2190          Obviously, we don't want to generate a duplicate ..._TYPE node if
2191          the TYPE_DECL node that we are now processing really represents a
2192          standard built-in type.
2193
2194          Since all standard types are effectively declared at line zero
2195          in the source file, we can easily check to see if we are working
2196          on a standard type by checking the current value of lineno.  */
2197
2198       if (TREE_CODE (x) == TYPE_DECL)
2199         {
2200           if (DECL_SOURCE_LINE (x) == 0)
2201             {
2202               if (TYPE_NAME (TREE_TYPE (x)) == 0)
2203                 TYPE_NAME (TREE_TYPE (x)) = x;
2204             }
2205           else if (TREE_TYPE (x) != error_mark_node
2206                    && DECL_ORIGINAL_TYPE (x) == NULL_TREE)
2207             {
2208               tree tt = TREE_TYPE (x);
2209               DECL_ORIGINAL_TYPE (x) = tt;
2210               tt = build_type_copy (tt);
2211               TYPE_NAME (tt) = x;
2212               TREE_USED (tt) = TREE_USED (x);
2213               TREE_TYPE (x) = tt;
2214             }
2215         }
2216
2217       /* Multiple external decls of the same identifier ought to match.
2218          Check against both global declarations (when traditional) and out of
2219          scope (limbo) block level declarations.
2220
2221          We get warnings about inline functions where they are defined.
2222          Avoid duplicate warnings where they are used.  */
2223       if (TREE_PUBLIC (x)
2224           && ! (TREE_CODE (x) == FUNCTION_DECL && DECL_INLINE (x)))
2225         {
2226           tree decl;
2227
2228           if (flag_traditional && IDENTIFIER_GLOBAL_VALUE (name) != 0
2229               && (DECL_EXTERNAL (IDENTIFIER_GLOBAL_VALUE (name))
2230                   || TREE_PUBLIC (IDENTIFIER_GLOBAL_VALUE (name))))
2231             decl = IDENTIFIER_GLOBAL_VALUE (name);
2232           else if (IDENTIFIER_LIMBO_VALUE (name) != 0)
2233             /* Decls in limbo are always extern, so no need to check that.  */
2234             decl = IDENTIFIER_LIMBO_VALUE (name);
2235           else
2236             decl = 0;
2237
2238           if (decl && ! comptypes (TREE_TYPE (x), TREE_TYPE (decl))
2239               /* If old decl is built-in, we already warned if we should.  */
2240               && !DECL_BUILT_IN (decl))
2241             {
2242               pedwarn_with_decl (x,
2243                                  "type mismatch with previous external decl");
2244               pedwarn_with_decl (decl, "previous external decl of `%s'");
2245             }
2246         }
2247
2248       /* If a function has had an implicit declaration, and then is defined,
2249          make sure they are compatible.  */
2250
2251       if (IDENTIFIER_IMPLICIT_DECL (name) != 0
2252           && IDENTIFIER_GLOBAL_VALUE (name) == 0
2253           && TREE_CODE (x) == FUNCTION_DECL
2254           && ! comptypes (TREE_TYPE (x),
2255                           TREE_TYPE (IDENTIFIER_IMPLICIT_DECL (name))))
2256         {
2257           warning_with_decl (x, "type mismatch with previous implicit declaration");
2258           warning_with_decl (IDENTIFIER_IMPLICIT_DECL (name),
2259                              "previous implicit declaration of `%s'");
2260         }
2261
2262       /* In PCC-compatibility mode, extern decls of vars with no current decl
2263          take effect at top level no matter where they are.  */
2264       if (flag_traditional && DECL_EXTERNAL (x)
2265           && lookup_name (name) == 0)
2266         {
2267           tree type = TREE_TYPE (x);
2268
2269           /* But don't do this if the type contains temporary nodes.  */
2270           while (type)
2271             {
2272               if (type == error_mark_node)
2273                 break;
2274               if (TYPE_CONTEXT (type))
2275                 {
2276                   warning_with_decl (x, "type of external `%s' is not global");
2277                   /* By exiting the loop early, we leave TYPE nonzero,
2278                      and thus prevent globalization of the decl.  */
2279                   break;
2280                 }
2281               else if (TREE_CODE (type) == FUNCTION_TYPE
2282                        && TYPE_ARG_TYPES (type) != 0)
2283                 /* The types might not be truly local,
2284                    but the list of arg types certainly is temporary.
2285                    Since prototypes are nontraditional,
2286                    ok not to do the traditional thing.  */
2287                 break;
2288               type = TREE_TYPE (type);
2289             }
2290
2291           if (type == 0)
2292             b = global_binding_level;
2293         }
2294
2295       /* This name is new in its binding level.
2296          Install the new declaration and return it.  */
2297       if (b == global_binding_level)
2298         {
2299           /* Install a global value.  */
2300
2301           /* If the first global decl has external linkage,
2302              warn if we later see static one.  */
2303           if (IDENTIFIER_GLOBAL_VALUE (name) == 0 && TREE_PUBLIC (x))
2304             TREE_PUBLIC (name) = 1;
2305
2306           IDENTIFIER_GLOBAL_VALUE (name) = x;
2307
2308           /* We no longer care about any previous block level declarations.  */
2309           IDENTIFIER_LIMBO_VALUE (name) = 0;
2310
2311           /* Don't forget if the function was used via an implicit decl.  */
2312           if (IDENTIFIER_IMPLICIT_DECL (name)
2313               && TREE_USED (IDENTIFIER_IMPLICIT_DECL (name)))
2314             TREE_USED (x) = 1, TREE_USED (name) = 1;
2315
2316           /* Don't forget if its address was taken in that way.  */
2317           if (IDENTIFIER_IMPLICIT_DECL (name)
2318               && TREE_ADDRESSABLE (IDENTIFIER_IMPLICIT_DECL (name)))
2319             TREE_ADDRESSABLE (x) = 1;
2320
2321           /* Warn about mismatches against previous implicit decl.  */
2322           if (IDENTIFIER_IMPLICIT_DECL (name) != 0
2323               /* If this real decl matches the implicit, don't complain.  */
2324               && ! (TREE_CODE (x) == FUNCTION_DECL
2325                     && (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (x)))
2326                         == integer_type_node)))
2327             pedwarn ("`%s' was previously implicitly declared to return `int'",
2328                      IDENTIFIER_POINTER (name));
2329
2330           /* If this decl is `static' and an `extern' was seen previously,
2331              that is erroneous.  */
2332           if (TREE_PUBLIC (name)
2333               && ! TREE_PUBLIC (x) && ! DECL_EXTERNAL (x))
2334             {
2335               /* Okay to redeclare an ANSI built-in as static.  */
2336               if (t != 0 && DECL_BUILT_IN (t))
2337                 ;
2338               /* Okay to declare a non-ANSI built-in as anything.  */
2339               else if (t != 0 && DECL_BUILT_IN_NONANSI (t))
2340                 ;
2341               /* Okay to have global type decl after an earlier extern
2342                  declaration inside a lexical block.  */
2343               else if (TREE_CODE (x) == TYPE_DECL)
2344                 ;
2345               else if (IDENTIFIER_IMPLICIT_DECL (name))
2346                 {
2347                   if (! TREE_THIS_VOLATILE (name))
2348                     pedwarn ("`%s' was declared implicitly `extern' and later `static'",
2349                              IDENTIFIER_POINTER (name));
2350                 }
2351               else
2352                 pedwarn ("`%s' was declared `extern' and later `static'",
2353                          IDENTIFIER_POINTER (name));
2354             }
2355         }
2356       else
2357         {
2358           /* Here to install a non-global value.  */
2359           tree oldlocal = IDENTIFIER_LOCAL_VALUE (name);
2360           tree oldglobal = IDENTIFIER_GLOBAL_VALUE (name);
2361
2362           IDENTIFIER_LOCAL_VALUE (name) = x;
2363
2364           /* If this is an extern function declaration, see if we
2365              have a global definition or declaration for the function.  */
2366           if (oldlocal == 0
2367               && oldglobal != 0
2368               && TREE_CODE (x) == FUNCTION_DECL
2369               && TREE_CODE (oldglobal) == FUNCTION_DECL
2370               && DECL_EXTERNAL (x) && ! DECL_INLINE (x))
2371             {
2372               /* We have one.  Their types must agree.  */
2373               if (! comptypes (TREE_TYPE (x),
2374                                TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (name))))
2375                 pedwarn_with_decl (x, "extern declaration of `%s' doesn't match global one");
2376               else
2377                 {
2378                   /* Inner extern decl is inline if global one is.
2379                      Copy enough to really inline it.  */
2380                   if (DECL_INLINE (oldglobal))
2381                     {
2382                       DECL_INLINE (x) = DECL_INLINE (oldglobal);
2383                       DECL_INITIAL (x) = (current_function_decl == oldglobal
2384                                           ? 0 : DECL_INITIAL (oldglobal));
2385                       DECL_SAVED_INSNS (x) = DECL_SAVED_INSNS (oldglobal);
2386                       DECL_FRAME_SIZE (x) = DECL_FRAME_SIZE (oldglobal);
2387                       DECL_ARGUMENTS (x) = DECL_ARGUMENTS (oldglobal);
2388                       DECL_RESULT (x) = DECL_RESULT (oldglobal);
2389                       TREE_ASM_WRITTEN (x) = TREE_ASM_WRITTEN (oldglobal);
2390                       DECL_ABSTRACT_ORIGIN (x)
2391                         = DECL_ABSTRACT_ORIGIN (oldglobal);
2392                     }
2393                   /* Inner extern decl is built-in if global one is.  */
2394                   if (DECL_BUILT_IN (oldglobal))
2395                     {
2396                       DECL_BUILT_IN_CLASS (x) = DECL_BUILT_IN_CLASS (oldglobal);
2397                       DECL_FUNCTION_CODE (x) = DECL_FUNCTION_CODE (oldglobal);
2398                     }
2399                   /* Keep the arg types from a file-scope fcn defn.  */
2400                   if (TYPE_ARG_TYPES (TREE_TYPE (oldglobal)) != 0
2401                       && DECL_INITIAL (oldglobal)
2402                       && TYPE_ARG_TYPES (TREE_TYPE (x)) == 0)
2403                     TREE_TYPE (x) = TREE_TYPE (oldglobal);
2404                 }
2405             }
2406
2407 #if 0
2408           /* This case is probably sometimes the right thing to do.  */
2409           /* If we have a local external declaration,
2410              then any file-scope declaration should not
2411              have been static.  */
2412           if (oldlocal == 0 && oldglobal != 0
2413               && !TREE_PUBLIC (oldglobal)
2414               && DECL_EXTERNAL (x) && TREE_PUBLIC (x))
2415             warning ("`%s' locally external but globally static",
2416                      IDENTIFIER_POINTER (name));
2417 #endif
2418
2419           /* If we have a local external declaration,
2420              and no file-scope declaration has yet been seen,
2421              then if we later have a file-scope decl it must not be static.  */
2422           if (oldlocal == 0
2423               && DECL_EXTERNAL (x)
2424               && TREE_PUBLIC (x))
2425             {
2426               if (oldglobal == 0)
2427                 TREE_PUBLIC (name) = 1;
2428
2429               /* Save this decl, so that we can do type checking against
2430                  other decls after it falls out of scope.
2431
2432                  Only save it once.  This prevents temporary decls created in
2433                  expand_inline_function from being used here, since this
2434                  will have been set when the inline function was parsed.
2435                  It also helps give slightly better warnings.  */
2436               if (IDENTIFIER_LIMBO_VALUE (name) == 0)
2437                 IDENTIFIER_LIMBO_VALUE (name) = x;
2438             }
2439
2440           /* Warn if shadowing an argument at the top level of the body.  */
2441           if (oldlocal != 0 && !DECL_EXTERNAL (x)
2442               /* This warning doesn't apply to the parms of a nested fcn.  */
2443               && ! current_binding_level->parm_flag
2444               /* Check that this is one level down from the parms.  */
2445               && current_binding_level->level_chain->parm_flag
2446               /* Check that the decl being shadowed
2447                  comes from the parm level, one level up.  */
2448               && chain_member (oldlocal, current_binding_level->level_chain->names))
2449             {
2450               if (TREE_CODE (oldlocal) == PARM_DECL)
2451                 pedwarn ("declaration of `%s' shadows a parameter",
2452                          IDENTIFIER_POINTER (name));
2453               else
2454                 pedwarn ("declaration of `%s' shadows a symbol from the parameter list",
2455                          IDENTIFIER_POINTER (name));
2456             }
2457
2458           /* Maybe warn if shadowing something else.  */
2459           else if (warn_shadow && !DECL_EXTERNAL (x)
2460                    /* No shadow warnings for internally generated vars.  */
2461                    && DECL_SOURCE_LINE (x) != 0
2462                    /* No shadow warnings for vars made for inlining.  */
2463                    && ! DECL_FROM_INLINE (x))
2464             {
2465               const char *id = IDENTIFIER_POINTER (name);
2466
2467               if (TREE_CODE (x) == PARM_DECL
2468                   && current_binding_level->level_chain->parm_flag)
2469                 /* Don't warn about the parm names in function declarator
2470                    within a function declarator.
2471                    It would be nice to avoid warning in any function
2472                    declarator in a declaration, as opposed to a definition,
2473                    but there is no way to tell it's not a definition.  */
2474                 ;
2475               else if (oldlocal != 0 && TREE_CODE (oldlocal) == PARM_DECL)
2476                 warning ("declaration of `%s' shadows a parameter", id);
2477               else if (oldlocal != 0)
2478                 warning ("declaration of `%s' shadows previous local", id);
2479               else if (IDENTIFIER_GLOBAL_VALUE (name) != 0
2480                        && IDENTIFIER_GLOBAL_VALUE (name) != error_mark_node)
2481                 warning ("declaration of `%s' shadows global declaration", id);
2482             }
2483
2484           /* If storing a local value, there may already be one (inherited).
2485              If so, record it for restoration when this binding level ends.  */
2486           if (oldlocal != 0)
2487             b->shadowed = tree_cons (name, oldlocal, b->shadowed);
2488         }
2489
2490       /* Keep count of variables in this level with incomplete type.
2491          If the input is erroneous, we can have error_mark in the type
2492          slot (e.g. "f(void a, ...)") - that doesn't count as an
2493          incomplete type.  */
2494       if (TREE_TYPE (x) != error_mark_node
2495           && !COMPLETE_TYPE_P (TREE_TYPE (x)))
2496         ++b->n_incomplete;
2497     }
2498
2499   /* Put decls on list in reverse order.
2500      We will reverse them later if necessary.  */
2501   TREE_CHAIN (x) = b->names;
2502   b->names = x;
2503
2504   return x;
2505 }
2506
2507 /* Like pushdecl, only it places X in GLOBAL_BINDING_LEVEL, if appropriate.  */
2508
2509 tree
2510 pushdecl_top_level (x)
2511      tree x;
2512 {
2513   register tree t;
2514   register struct binding_level *b = current_binding_level;
2515
2516   current_binding_level = global_binding_level;
2517   t = pushdecl (x);
2518   current_binding_level = b;
2519   return t;
2520 }
2521 \f
2522 /* Generate an implicit declaration for identifier FUNCTIONID
2523    as a function of type int ().  Print a warning if appropriate.  */
2524
2525 tree
2526 implicitly_declare (functionid)
2527      tree functionid;
2528 {
2529   register tree decl;
2530   int traditional_warning = 0;
2531   /* Only one "implicit declaration" warning per identifier.  */
2532   int implicit_warning;
2533
2534   /* We used to reuse an old implicit decl here,
2535      but this loses with inline functions because it can clobber
2536      the saved decl chains.  */
2537 #if 0
2538   if (IDENTIFIER_IMPLICIT_DECL (functionid) != 0)
2539     decl = IDENTIFIER_IMPLICIT_DECL (functionid);
2540   else
2541 #endif
2542     decl = build_decl (FUNCTION_DECL, functionid, default_function_type);
2543
2544   /* Warn of implicit decl following explicit local extern decl.
2545      This is probably a program designed for traditional C.  */
2546   if (TREE_PUBLIC (functionid) && IDENTIFIER_GLOBAL_VALUE (functionid) == 0)
2547     traditional_warning = 1;
2548
2549   /* Warn once of an implicit declaration.  */
2550   implicit_warning = (IDENTIFIER_IMPLICIT_DECL (functionid) == 0);
2551
2552   DECL_EXTERNAL (decl) = 1;
2553   TREE_PUBLIC (decl) = 1;
2554
2555   /* Record that we have an implicit decl and this is it.  */
2556   IDENTIFIER_IMPLICIT_DECL (functionid) = decl;
2557
2558   /* ANSI standard says implicit declarations are in the innermost block.
2559      So we record the decl in the standard fashion.
2560      If flag_traditional is set, pushdecl does it top-level.  */
2561   pushdecl (decl);
2562
2563   /* This is a no-op in c-lang.c or something real in objc-actions.c.  */
2564   maybe_objc_check_decl (decl);
2565
2566   rest_of_decl_compilation (decl, NULL_PTR, 0, 0);
2567
2568   if (implicit_warning)
2569     implicit_decl_warning (functionid);
2570   else if (warn_traditional && traditional_warning)
2571     warning ("function `%s' was previously declared within a block",
2572              IDENTIFIER_POINTER (functionid));
2573
2574   /* Write a record describing this implicit function declaration to the
2575      prototypes file (if requested).  */
2576
2577   gen_aux_info_record (decl, 0, 1, 0);
2578
2579   return decl;
2580 }
2581
2582 void
2583 implicit_decl_warning (id)
2584      tree id;
2585 {
2586   const char *name = IDENTIFIER_POINTER (id);
2587   if (mesg_implicit_function_declaration == 2)
2588     error ("implicit declaration of function `%s'", name);
2589   else if (mesg_implicit_function_declaration == 1)
2590     warning ("implicit declaration of function `%s'", name);
2591 }
2592
2593 /* Return zero if the declaration NEWDECL is valid
2594    when the declaration OLDDECL (assumed to be for the same name)
2595    has already been seen.
2596    Otherwise return 1 if NEWDECL is a redefinition, 2 if it is a redeclaration,
2597    and 3 if it is a conflicting declaration.  */
2598
2599 static int
2600 redeclaration_error_message (newdecl, olddecl)
2601      tree newdecl, olddecl;
2602 {
2603   if (TREE_CODE (newdecl) == TYPE_DECL)
2604     {
2605       if (flag_traditional && TREE_TYPE (newdecl) == TREE_TYPE (olddecl))
2606         return 0;
2607       /* pushdecl creates distinct types for TYPE_DECLs by calling
2608          build_type_copy, so the above comparison generally fails.  We do
2609          another test against the TYPE_MAIN_VARIANT of the olddecl, which
2610          is equivalent to what this code used to do before the build_type_copy
2611          call.  The variant type distinction should not matter for traditional
2612          code, because it doesn't have type qualifiers.  */
2613       if (flag_traditional
2614           && TYPE_MAIN_VARIANT (TREE_TYPE (olddecl)) == TREE_TYPE (newdecl))
2615         return 0;
2616       if (DECL_IN_SYSTEM_HEADER (olddecl) || DECL_IN_SYSTEM_HEADER (newdecl))
2617         return 0;
2618       return 1;
2619     }
2620   else if (TREE_CODE (newdecl) == FUNCTION_DECL)
2621     {
2622       /* Declarations of functions can insist on internal linkage
2623          but they can't be inconsistent with internal linkage,
2624          so there can be no error on that account.
2625          However defining the same name twice is no good.  */
2626       if (DECL_INITIAL (olddecl) != 0 && DECL_INITIAL (newdecl) != 0
2627           /* However, defining once as extern inline and a second
2628              time in another way is ok.  */
2629           && ! (DECL_INLINE (olddecl) && DECL_EXTERNAL (olddecl)
2630                && ! (DECL_INLINE (newdecl) && DECL_EXTERNAL (newdecl))))
2631         return 1;
2632       return 0;
2633     }
2634   else if (DECL_CONTEXT (newdecl) == NULL_TREE)
2635     {
2636       /* Objects declared at top level:  */
2637       /* If at least one is a reference, it's ok.  */
2638       if (DECL_EXTERNAL (newdecl) || DECL_EXTERNAL (olddecl))
2639         return 0;
2640       /* Reject two definitions.  */
2641       if (DECL_INITIAL (olddecl) != 0 && DECL_INITIAL (newdecl) != 0)
2642         return 1;
2643       /* Now we have two tentative defs, or one tentative and one real def.  */
2644       /* Insist that the linkage match.  */
2645       if (TREE_PUBLIC (olddecl) != TREE_PUBLIC (newdecl))
2646         return 3;
2647       return 0;
2648     }
2649   else if (current_binding_level->parm_flag
2650            && TREE_ASM_WRITTEN (olddecl) && !TREE_ASM_WRITTEN (newdecl))
2651     return 0;
2652   else
2653     {
2654       /* Newdecl has block scope.  If olddecl has block scope also, then
2655          reject two definitions, and reject a definition together with an
2656          external reference.  Otherwise, it is OK, because newdecl must
2657          be an extern reference to olddecl.  */
2658       if (!(DECL_EXTERNAL (newdecl) && DECL_EXTERNAL (olddecl))
2659           && DECL_CONTEXT (newdecl) == DECL_CONTEXT (olddecl))
2660         return 2;
2661       return 0;
2662     }
2663 }
2664 \f
2665 /* Get the LABEL_DECL corresponding to identifier ID as a label.
2666    Create one if none exists so far for the current function.
2667    This function is called for both label definitions and label references.  */
2668
2669 tree
2670 lookup_label (id)
2671      tree id;
2672 {
2673   register tree decl = IDENTIFIER_LABEL_VALUE (id);
2674
2675   if (current_function_decl == 0)
2676     {
2677       error ("label %s referenced outside of any function",
2678              IDENTIFIER_POINTER (id));
2679       return 0;
2680     }
2681
2682   /* Use a label already defined or ref'd with this name.  */
2683   if (decl != 0)
2684     {
2685       /* But not if it is inherited and wasn't declared to be inheritable.  */
2686       if (DECL_CONTEXT (decl) != current_function_decl
2687           && ! C_DECLARED_LABEL_FLAG (decl))
2688         return shadow_label (id);
2689       return decl;
2690     }
2691
2692   decl = build_decl (LABEL_DECL, id, void_type_node);
2693
2694   /* A label not explicitly declared must be local to where it's ref'd.  */
2695   DECL_CONTEXT (decl) = current_function_decl;
2696
2697   DECL_MODE (decl) = VOIDmode;
2698
2699   /* Say where one reference is to the label,
2700      for the sake of the error if it is not defined.  */
2701   DECL_SOURCE_LINE (decl) = lineno;
2702   DECL_SOURCE_FILE (decl) = input_filename;
2703
2704   IDENTIFIER_LABEL_VALUE (id) = decl;
2705
2706   named_labels = tree_cons (NULL_TREE, decl, named_labels);
2707
2708   return decl;
2709 }
2710
2711 /* Make a label named NAME in the current function,
2712    shadowing silently any that may be inherited from containing functions
2713    or containing scopes.
2714
2715    Note that valid use, if the label being shadowed
2716    comes from another scope in the same function,
2717    requires calling declare_nonlocal_label right away.  */
2718
2719 tree
2720 shadow_label (name)
2721      tree name;
2722 {
2723   register tree decl = IDENTIFIER_LABEL_VALUE (name);
2724
2725   if (decl != 0)
2726     {
2727       register tree dup;
2728
2729       /* Check to make sure that the label hasn't already been declared
2730          at this label scope */
2731       for (dup = named_labels; dup; dup = TREE_CHAIN (dup))
2732         if (TREE_VALUE (dup) == decl)
2733           {
2734             error ("duplicate label declaration `%s'",
2735                    IDENTIFIER_POINTER (name));
2736             error_with_decl (TREE_VALUE (dup),
2737                              "this is a previous declaration");
2738             /* Just use the previous declaration.  */
2739             return lookup_label (name);
2740           }
2741
2742       shadowed_labels = tree_cons (NULL_TREE, decl, shadowed_labels);
2743       IDENTIFIER_LABEL_VALUE (name) = decl = 0;
2744     }
2745
2746   return lookup_label (name);
2747 }
2748
2749 /* Define a label, specifying the location in the source file.
2750    Return the LABEL_DECL node for the label, if the definition is valid.
2751    Otherwise return 0.  */
2752
2753 tree
2754 define_label (filename, line, name)
2755      const char *filename;
2756      int line;
2757      tree name;
2758 {
2759   tree decl = lookup_label (name);
2760
2761   /* If label with this name is known from an outer context, shadow it.  */
2762   if (decl != 0 && DECL_CONTEXT (decl) != current_function_decl)
2763     {
2764       shadowed_labels = tree_cons (NULL_TREE, decl, shadowed_labels);
2765       IDENTIFIER_LABEL_VALUE (name) = 0;
2766       decl = lookup_label (name);
2767     }
2768
2769   if (warn_traditional && !in_system_header && lookup_name (name))
2770     warning_with_file_and_line (filename, line,
2771                                 "traditional C lacks a separate namespace for labels, identifier `%s' conflicts",
2772                                 IDENTIFIER_POINTER (name));
2773
2774   if (DECL_INITIAL (decl) != 0)
2775     {
2776       error_with_file_and_line (filename, line, "duplicate label `%s'",
2777                                 IDENTIFIER_POINTER (name));
2778       return 0;
2779     }
2780   else
2781     {
2782       /* Mark label as having been defined.  */
2783       DECL_INITIAL (decl) = error_mark_node;
2784       /* Say where in the source.  */
2785       DECL_SOURCE_FILE (decl) = filename;
2786       DECL_SOURCE_LINE (decl) = line;
2787       return decl;
2788     }
2789 }
2790 \f
2791 /* Return the list of declarations of the current level.
2792    Note that this list is in reverse order unless/until
2793    you nreverse it; and when you do nreverse it, you must
2794    store the result back using `storedecls' or you will lose.  */
2795
2796 tree
2797 getdecls ()
2798 {
2799   return current_binding_level->names;
2800 }
2801
2802 /* Return the list of type-tags (for structs, etc) of the current level.  */
2803
2804 tree
2805 gettags ()
2806 {
2807   return current_binding_level->tags;
2808 }
2809
2810 /* Store the list of declarations of the current level.
2811    This is done for the parameter declarations of a function being defined,
2812    after they are modified in the light of any missing parameters.  */
2813
2814 static void
2815 storedecls (decls)
2816      tree decls;
2817 {
2818   current_binding_level->names = decls;
2819 }
2820
2821 /* Similarly, store the list of tags of the current level.  */
2822
2823 static void
2824 storetags (tags)
2825      tree tags;
2826 {
2827   current_binding_level->tags = tags;
2828 }
2829 \f
2830 /* Given NAME, an IDENTIFIER_NODE,
2831    return the structure (or union or enum) definition for that name.
2832    Searches binding levels from BINDING_LEVEL up to the global level.
2833    If THISLEVEL_ONLY is nonzero, searches only the specified context
2834    (but skips any tag-transparent contexts to find one that is
2835    meaningful for tags).
2836    CODE says which kind of type the caller wants;
2837    it is RECORD_TYPE or UNION_TYPE or ENUMERAL_TYPE.
2838    If the wrong kind of type is found, an error is reported.  */
2839
2840 static tree
2841 lookup_tag (code, name, binding_level, thislevel_only)
2842      enum tree_code code;
2843      struct binding_level *binding_level;
2844      tree name;
2845      int thislevel_only;
2846 {
2847   register struct binding_level *level;
2848
2849   for (level = binding_level; level; level = level->level_chain)
2850     {
2851       register tree tail;
2852       for (tail = level->tags; tail; tail = TREE_CHAIN (tail))
2853         {
2854           if (TREE_PURPOSE (tail) == name)
2855             {
2856               if (TREE_CODE (TREE_VALUE (tail)) != code)
2857                 {
2858                   /* Definition isn't the kind we were looking for.  */
2859                   pending_invalid_xref = name;
2860                   pending_invalid_xref_file = input_filename;
2861                   pending_invalid_xref_line = lineno;
2862                 }
2863               return TREE_VALUE (tail);
2864             }
2865         }
2866       if (thislevel_only && ! level->tag_transparent)
2867         return NULL_TREE;
2868     }
2869   return NULL_TREE;
2870 }
2871
2872 /* Print an error message now
2873    for a recent invalid struct, union or enum cross reference.
2874    We don't print them immediately because they are not invalid
2875    when used in the `struct foo;' construct for shadowing.  */
2876
2877 void
2878 pending_xref_error ()
2879 {
2880   if (pending_invalid_xref != 0)
2881     error_with_file_and_line (pending_invalid_xref_file,
2882                               pending_invalid_xref_line,
2883                               "`%s' defined as wrong kind of tag",
2884                               IDENTIFIER_POINTER (pending_invalid_xref));
2885   pending_invalid_xref = 0;
2886 }
2887
2888 /* Given a type, find the tag that was defined for it and return the tag name.
2889    Otherwise return 0.  */
2890
2891 static tree
2892 lookup_tag_reverse (type)
2893      tree type;
2894 {
2895   register struct binding_level *level;
2896
2897   for (level = current_binding_level; level; level = level->level_chain)
2898     {
2899       register tree tail;
2900       for (tail = level->tags; tail; tail = TREE_CHAIN (tail))
2901         {
2902           if (TREE_VALUE (tail) == type)
2903             return TREE_PURPOSE (tail);
2904         }
2905     }
2906   return NULL_TREE;
2907 }
2908 \f
2909 /* Look up NAME in the current binding level and its superiors
2910    in the namespace of variables, functions and typedefs.
2911    Return a ..._DECL node of some kind representing its definition,
2912    or return 0 if it is undefined.  */
2913
2914 tree
2915 lookup_name (name)
2916      tree name;
2917 {
2918   register tree val;
2919
2920   if (current_binding_level != global_binding_level
2921       && IDENTIFIER_LOCAL_VALUE (name))
2922     val = IDENTIFIER_LOCAL_VALUE (name);
2923   else
2924     val = IDENTIFIER_GLOBAL_VALUE (name);
2925   return val;
2926 }
2927
2928 /* Similar to `lookup_name' but look only at current binding level.  */
2929
2930 tree
2931 lookup_name_current_level (name)
2932      tree name;
2933 {
2934   register tree t;
2935
2936   if (current_binding_level == global_binding_level)
2937     return IDENTIFIER_GLOBAL_VALUE (name);
2938
2939   if (IDENTIFIER_LOCAL_VALUE (name) == 0)
2940     return 0;
2941
2942   for (t = current_binding_level->names; t; t = TREE_CHAIN (t))
2943     if (DECL_NAME (t) == name)
2944       break;
2945
2946   return t;
2947 }
2948 \f
2949 /* Mark ARG for GC.  */
2950
2951 static void
2952 mark_binding_level (arg)
2953      void *arg;
2954 {
2955   struct binding_level *level = *(struct binding_level **) arg;
2956
2957   for (; level != 0; level = level->level_chain)
2958     {
2959       ggc_mark_tree (level->names);
2960       ggc_mark_tree (level->tags);
2961       ggc_mark_tree (level->shadowed);
2962       ggc_mark_tree (level->blocks);
2963       ggc_mark_tree (level->this_block);
2964       ggc_mark_tree (level->parm_order);
2965     }
2966 }
2967
2968 /* Create the predefined scalar types of C,
2969    and some nodes representing standard constants (0, 1, (void *) 0).
2970    Initialize the global binding level.
2971    Make definitions for built-in primitive functions.  */
2972
2973 void
2974 init_decl_processing ()
2975 {
2976   register tree endlink;
2977   tree ptr_ftype_void, ptr_ftype_ptr;
2978   int wchar_type_size;
2979   tree array_domain_type;
2980   tree t;
2981
2982   current_function_decl = NULL;
2983   named_labels = NULL;
2984   current_binding_level = NULL_BINDING_LEVEL;
2985   free_binding_level = NULL_BINDING_LEVEL;
2986
2987   /* Make the binding_level structure for global names.  */
2988   pushlevel (0);
2989   global_binding_level = current_binding_level;
2990
2991   build_common_tree_nodes (flag_signed_char);
2992
2993   /* Define `int' and `char' first so that dbx will output them first.  */
2994   pushdecl (build_decl (TYPE_DECL, ridpointers[(int) RID_INT],
2995                         integer_type_node));
2996   pushdecl (build_decl (TYPE_DECL, get_identifier ("char"),
2997                         char_type_node));
2998   pushdecl (build_decl (TYPE_DECL, get_identifier ("long int"),
2999                         long_integer_type_node));
3000   pushdecl (build_decl (TYPE_DECL, get_identifier ("unsigned int"),
3001                         unsigned_type_node));
3002   pushdecl (build_decl (TYPE_DECL, get_identifier ("long unsigned int"),
3003                         long_unsigned_type_node));
3004   pushdecl (build_decl (TYPE_DECL, get_identifier ("long long int"),
3005                         long_long_integer_type_node));
3006   pushdecl (build_decl (TYPE_DECL, get_identifier ("long long unsigned int"),
3007                         long_long_unsigned_type_node));
3008   pushdecl (build_decl (TYPE_DECL, get_identifier ("short int"),
3009                         short_integer_type_node));
3010   pushdecl (build_decl (TYPE_DECL, get_identifier ("short unsigned int"),
3011                         short_unsigned_type_node));
3012   pushdecl (build_decl (TYPE_DECL, get_identifier ("signed char"),
3013                         signed_char_type_node));
3014   pushdecl (build_decl (TYPE_DECL, get_identifier ("unsigned char"),
3015                         unsigned_char_type_node));
3016   pushdecl (build_decl (TYPE_DECL, NULL_TREE, intQI_type_node));
3017   pushdecl (build_decl (TYPE_DECL, NULL_TREE, intHI_type_node));
3018   pushdecl (build_decl (TYPE_DECL, NULL_TREE, intSI_type_node));
3019   pushdecl (build_decl (TYPE_DECL, NULL_TREE, intDI_type_node));
3020 #if HOST_BITS_PER_WIDE_INT >= 64
3021   pushdecl (build_decl (TYPE_DECL, NULL_TREE, intTI_type_node));
3022 #endif
3023   pushdecl (build_decl (TYPE_DECL, NULL_TREE, unsigned_intQI_type_node));
3024   pushdecl (build_decl (TYPE_DECL, NULL_TREE, unsigned_intHI_type_node));
3025   pushdecl (build_decl (TYPE_DECL, NULL_TREE, unsigned_intSI_type_node));
3026   pushdecl (build_decl (TYPE_DECL, NULL_TREE, unsigned_intDI_type_node));
3027 #if HOST_BITS_PER_WIDE_INT >= 64
3028   pushdecl (build_decl (TYPE_DECL, NULL_TREE, unsigned_intTI_type_node));
3029 #endif
3030
3031   /* `unsigned long' is the standard type for sizeof.
3032      Traditionally, use a signed type.
3033      Note that stddef.h uses `unsigned long',
3034      and this must agree, even if long and int are the same size.  */
3035   t = TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (get_identifier (SIZE_TYPE)));
3036   signed_size_type_node = signed_type (t);
3037   if (flag_traditional && TREE_UNSIGNED (t))
3038     t = signed_type (t);
3039
3040   c_size_type_node = t;
3041   set_sizetype (t);
3042
3043   /* Create the widest literal types.  */
3044   widest_integer_literal_type_node
3045     = make_signed_type (HOST_BITS_PER_WIDE_INT * 2);
3046   widest_unsigned_literal_type_node
3047     = make_unsigned_type (HOST_BITS_PER_WIDE_INT * 2);
3048   pushdecl (build_decl (TYPE_DECL, NULL_TREE,
3049                         widest_integer_literal_type_node));
3050   pushdecl (build_decl (TYPE_DECL, NULL_TREE,
3051                         widest_unsigned_literal_type_node));
3052
3053   build_common_tree_nodes_2 (flag_short_double);
3054
3055   pushdecl (build_decl (TYPE_DECL, ridpointers[(int) RID_FLOAT],
3056                         float_type_node));
3057   pushdecl (build_decl (TYPE_DECL, ridpointers[(int) RID_DOUBLE],
3058                         double_type_node));
3059   pushdecl (build_decl (TYPE_DECL, get_identifier ("long double"),
3060                         long_double_type_node));
3061   pushdecl (build_decl (TYPE_DECL, get_identifier ("complex int"),
3062                         complex_integer_type_node));
3063   pushdecl (build_decl (TYPE_DECL, get_identifier ("complex float"),
3064                         complex_float_type_node));
3065   pushdecl (build_decl (TYPE_DECL, get_identifier ("complex double"),
3066                         complex_double_type_node));
3067   pushdecl (build_decl (TYPE_DECL, get_identifier ("complex long double"),
3068                         complex_long_double_type_node));
3069   pushdecl (build_decl (TYPE_DECL,
3070                         ridpointers[(int) RID_VOID], void_type_node));
3071
3072 #ifdef MD_INIT_BUILTINS
3073   MD_INIT_BUILTINS;
3074 #endif
3075
3076   wchar_type_node = get_identifier (flag_short_wchar
3077                                     ? "short unsigned int"
3078                                     : WCHAR_TYPE);
3079   wchar_type_node = TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (wchar_type_node));
3080   wchar_type_size = TYPE_PRECISION (wchar_type_node);
3081   signed_wchar_type_node = signed_type (wchar_type_node);
3082   unsigned_wchar_type_node = unsigned_type (wchar_type_node);
3083
3084   wint_type_node =
3085     TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (get_identifier (WINT_TYPE)));
3086
3087   intmax_type_node =
3088     TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (get_identifier (INTMAX_TYPE)));
3089   uintmax_type_node =
3090     TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (get_identifier (UINTMAX_TYPE)));
3091
3092   boolean_type_node = integer_type_node;
3093   boolean_true_node = integer_one_node;
3094   boolean_false_node = integer_zero_node;
3095
3096   /* With GCC, C99's _Bool is always of size 1.  */
3097   c_bool_type_node = make_unsigned_type (CHAR_TYPE_SIZE);
3098   TREE_SET_CODE (c_bool_type_node, BOOLEAN_TYPE);
3099   TYPE_MAX_VALUE (c_bool_type_node) = build_int_2 (1, 0);
3100   TREE_TYPE (TYPE_MAX_VALUE (c_bool_type_node)) = c_bool_type_node;
3101   TYPE_PRECISION (c_bool_type_node) = 1;
3102   pushdecl (build_decl (TYPE_DECL, get_identifier ("_Bool"),
3103                         c_bool_type_node));
3104   c_bool_false_node = build_int_2 (0, 0);
3105   TREE_TYPE (c_bool_false_node) = c_bool_type_node;
3106   c_bool_true_node = build_int_2 (1, 0);
3107   TREE_TYPE (c_bool_true_node) = c_bool_type_node;
3108
3109   string_type_node = build_pointer_type (char_type_node);
3110   const_string_type_node
3111     = build_pointer_type (build_type_variant (char_type_node, 1, 0));
3112
3113   /* Make a type to be the domain of a few array types
3114      whose domains don't really matter.
3115      200 is small enough that it always fits in size_t
3116      and large enough that it can hold most function names for the
3117      initializations of __FUNCTION__ and __PRETTY_FUNCTION__.  */
3118   array_domain_type = build_index_type (build_int_2 (200, 0));
3119
3120   /* make a type for arrays of characters.
3121      With luck nothing will ever really depend on the length of this
3122      array type.  */
3123   char_array_type_node = build_array_type (char_type_node, array_domain_type);
3124
3125   /* Likewise for arrays of ints.  */
3126   int_array_type_node
3127     = build_array_type (integer_type_node, array_domain_type);
3128
3129   /* This is for wide string constants.  */
3130   wchar_array_type_node
3131     = build_array_type (wchar_type_node, array_domain_type);
3132
3133   void_list_node = tree_cons (NULL_TREE, void_type_node, NULL_TREE);
3134
3135   default_function_type = build_function_type (integer_type_node, NULL_TREE);
3136   ptrdiff_type_node
3137     = TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (get_identifier (PTRDIFF_TYPE)));
3138   unsigned_ptrdiff_type_node = unsigned_type (ptrdiff_type_node);
3139
3140   c_common_nodes_and_builtins ();
3141
3142   endlink = void_list_node;
3143   ptr_ftype_void = build_function_type (ptr_type_node, endlink);
3144   ptr_ftype_ptr
3145     = build_function_type (ptr_type_node,
3146                            tree_cons (NULL_TREE, ptr_type_node, endlink));
3147
3148   /* Types which are common to the fortran compiler and libf2c.  When
3149      changing these, you also need to be concerned with f/com.h.  */
3150
3151   if (TYPE_PRECISION (float_type_node)
3152       == TYPE_PRECISION (long_integer_type_node))
3153     {
3154       g77_integer_type_node = long_integer_type_node;
3155       g77_uinteger_type_node = long_unsigned_type_node;
3156     }
3157   else if (TYPE_PRECISION (float_type_node)
3158            == TYPE_PRECISION (integer_type_node))
3159     {
3160       g77_integer_type_node = integer_type_node;
3161       g77_uinteger_type_node = unsigned_type_node;
3162     }
3163   else
3164     g77_integer_type_node = g77_uinteger_type_node = NULL_TREE;
3165
3166   if (g77_integer_type_node != NULL_TREE)
3167     {
3168       pushdecl (build_decl (TYPE_DECL, get_identifier ("__g77_integer"),
3169                             g77_integer_type_node));
3170       pushdecl (build_decl (TYPE_DECL, get_identifier ("__g77_uinteger"),
3171                             g77_uinteger_type_node));
3172     }
3173
3174   if (TYPE_PRECISION (float_type_node) * 2
3175       == TYPE_PRECISION (long_integer_type_node))
3176     {
3177       g77_longint_type_node = long_integer_type_node;
3178       g77_ulongint_type_node = long_unsigned_type_node;
3179     }
3180   else if (TYPE_PRECISION (float_type_node) * 2
3181            == TYPE_PRECISION (long_long_integer_type_node))
3182     {
3183       g77_longint_type_node = long_long_integer_type_node;
3184       g77_ulongint_type_node = long_long_unsigned_type_node;
3185     }
3186   else
3187     g77_longint_type_node = g77_ulongint_type_node = NULL_TREE;
3188
3189   if (g77_longint_type_node != NULL_TREE)
3190     {
3191       pushdecl (build_decl (TYPE_DECL, get_identifier ("__g77_longint"),
3192                             g77_longint_type_node));
3193       pushdecl (build_decl (TYPE_DECL, get_identifier ("__g77_ulongint"),
3194                             g77_ulongint_type_node));
3195     }
3196
3197   builtin_function ("__builtin_aggregate_incoming_address",
3198                     build_function_type (ptr_type_node, NULL_TREE),
3199                     BUILT_IN_AGGREGATE_INCOMING_ADDRESS,
3200                     BUILT_IN_NORMAL, NULL_PTR);
3201
3202   /* Hooks for the DWARF 2 __throw routine.  */
3203   builtin_function ("__builtin_unwind_init",
3204                     build_function_type (void_type_node, endlink),
3205                     BUILT_IN_UNWIND_INIT, BUILT_IN_NORMAL, NULL_PTR);
3206   builtin_function ("__builtin_dwarf_cfa", ptr_ftype_void,
3207                     BUILT_IN_DWARF_CFA, BUILT_IN_NORMAL, NULL_PTR);
3208   builtin_function ("__builtin_dwarf_fp_regnum",
3209                     build_function_type (unsigned_type_node, endlink),
3210                     BUILT_IN_DWARF_FP_REGNUM, BUILT_IN_NORMAL, NULL_PTR);
3211   builtin_function ("__builtin_init_dwarf_reg_size_table", void_ftype_ptr,
3212                     BUILT_IN_INIT_DWARF_REG_SIZES, BUILT_IN_NORMAL, NULL_PTR);
3213   builtin_function ("__builtin_frob_return_addr", ptr_ftype_ptr,
3214                     BUILT_IN_FROB_RETURN_ADDR, BUILT_IN_NORMAL, NULL_PTR);
3215   builtin_function ("__builtin_extract_return_addr", ptr_ftype_ptr,
3216                     BUILT_IN_EXTRACT_RETURN_ADDR, BUILT_IN_NORMAL, NULL_PTR);
3217   builtin_function
3218     ("__builtin_eh_return",
3219      build_function_type (void_type_node,
3220                           tree_cons (NULL_TREE, ptr_type_node,
3221                                      tree_cons (NULL_TREE,
3222                                                 type_for_mode (ptr_mode, 0),
3223                                                 tree_cons (NULL_TREE,
3224                                                            ptr_type_node,
3225                                                            endlink)))),
3226      BUILT_IN_EH_RETURN, BUILT_IN_NORMAL, NULL_PTR);
3227
3228   pedantic_lvalues = pedantic;
3229
3230   /* Create the global bindings for __FUNCTION__, __PRETTY_FUNCTION__,
3231      and __func__.  */
3232   function_id_node = get_identifier ("__FUNCTION__");
3233   pretty_function_id_node = get_identifier ("__PRETTY_FUNCTION__");
3234   func_id_node = get_identifier ("__func__");
3235   make_fname_decl = c_make_fname_decl;
3236   declare_function_name ();
3237
3238   start_identifier_warnings ();
3239
3240   /* Prepare to check format strings against argument lists.  */
3241   init_function_format_info ();
3242
3243   incomplete_decl_finalize_hook = finish_incomplete_decl;
3244
3245   /* Record our roots.  */
3246
3247   ggc_add_tree_root (c_global_trees, CTI_MAX);
3248   ggc_add_root (&c_stmt_tree, 1, sizeof c_stmt_tree, mark_stmt_tree);
3249   ggc_add_tree_root (&c_scope_stmt_stack, 1);
3250   ggc_add_tree_root (&named_labels, 1);
3251   ggc_add_tree_root (&shadowed_labels, 1);
3252   ggc_add_root (&current_binding_level, 1, sizeof current_binding_level,
3253                 mark_binding_level);
3254   ggc_add_root (&label_level_chain, 1, sizeof label_level_chain,
3255                 mark_binding_level);
3256   ggc_add_tree_root (&static_ctors, 1);
3257   ggc_add_tree_root (&static_dtors, 1);
3258 }
3259
3260 /* Create the VAR_DECL for __FUNCTION__ etc. ID is the name to give the
3261    decl, NAME is the initialization string and TYPE_DEP indicates whether
3262    NAME depended on the type of the function.  As we don't yet implement
3263    delayed emission of static data, we mark the decl as emitted
3264    so it is not placed in the output.  Anything using it must therefore pull
3265    out the STRING_CST initializer directly.  This does mean that these names
3266    are string merging candidates, which is wrong for C99's __func__.  FIXME.  */
3267
3268 static tree
3269 c_make_fname_decl (id, name, type_dep)
3270      tree id;
3271      const char *name;
3272      int type_dep ATTRIBUTE_UNUSED;
3273 {
3274   tree decl, type, init;
3275   size_t length = strlen (name);
3276
3277   type =  build_array_type
3278           (build_qualified_type (char_type_node, TYPE_QUAL_CONST),
3279            build_index_type (build_int_2 (length, 0)));
3280
3281   decl = build_decl (VAR_DECL, id, type);
3282   TREE_STATIC (decl) = 1;
3283   TREE_READONLY (decl) = 1;
3284   TREE_ASM_WRITTEN (decl) = 1;
3285   DECL_SOURCE_LINE (decl) = 0;
3286   DECL_ARTIFICIAL (decl) = 1;
3287   DECL_IN_SYSTEM_HEADER (decl) = 1;
3288   DECL_IGNORED_P (decl) = 1;
3289   init = build_string (length + 1, name);
3290   TREE_TYPE (init) = type;
3291   DECL_INITIAL (decl) = init;
3292   finish_decl (pushdecl (decl), init, NULL_TREE);
3293
3294   return decl;
3295 }
3296
3297 /* Return a definition for a builtin function named NAME and whose data type
3298    is TYPE.  TYPE should be a function type with argument types.
3299    FUNCTION_CODE tells later passes how to compile calls to this function.
3300    See tree.h for its possible values.
3301
3302    If LIBRARY_NAME is nonzero, use that for DECL_ASSEMBLER_NAME,
3303    the name to be called if we can't opencode the function.  */
3304
3305 tree
3306 builtin_function (name, type, function_code, class, library_name)
3307      const char *name;
3308      tree type;
3309      int function_code;
3310      enum built_in_class class;
3311      const char *library_name;
3312 {
3313   tree decl = build_decl (FUNCTION_DECL, get_identifier (name), type);
3314   DECL_EXTERNAL (decl) = 1;
3315   TREE_PUBLIC (decl) = 1;
3316   /* If -traditional, permit redefining a builtin function any way you like.
3317      (Though really, if the program redefines these functions,
3318      it probably won't work right unless compiled with -fno-builtin.)  */
3319   if (flag_traditional && name[0] != '_')
3320     DECL_BUILT_IN_NONANSI (decl) = 1;
3321   if (library_name)
3322     DECL_ASSEMBLER_NAME (decl) = get_identifier (library_name);
3323   make_decl_rtl (decl, NULL_PTR, 1);
3324   pushdecl (decl);
3325   DECL_BUILT_IN_CLASS (decl) = class;
3326   DECL_FUNCTION_CODE (decl) = function_code;
3327
3328   /* Warn if a function in the namespace for users
3329      is used without an occasion to consider it declared.  */
3330   if (name[0] != '_' || name[1] != '_')
3331     C_DECL_ANTICIPATED (decl) = 1;
3332
3333   return decl;
3334 }
3335 \f
3336 /* Called when a declaration is seen that contains no names to declare.
3337    If its type is a reference to a structure, union or enum inherited
3338    from a containing scope, shadow that tag name for the current scope
3339    with a forward reference.
3340    If its type defines a new named structure or union
3341    or defines an enum, it is valid but we need not do anything here.
3342    Otherwise, it is an error.  */
3343
3344 void
3345 shadow_tag (declspecs)
3346      tree declspecs;
3347 {
3348   shadow_tag_warned (declspecs, 0);
3349 }
3350
3351 void
3352 shadow_tag_warned (declspecs, warned)
3353      tree declspecs;
3354      int warned;
3355      /* 1 => we have done a pedwarn.  2 => we have done a warning, but
3356         no pedwarn.  */
3357 {
3358   int found_tag = 0;
3359   register tree link;
3360   tree specs, attrs;
3361
3362   pending_invalid_xref = 0;
3363
3364   /* Remove the attributes from declspecs, since they will confuse the
3365      following code.  */
3366   split_specs_attrs (declspecs, &specs, &attrs);
3367
3368   for (link = specs; link; link = TREE_CHAIN (link))
3369     {
3370       register tree value = TREE_VALUE (link);
3371       register enum tree_code code = TREE_CODE (value);
3372
3373       if (code == RECORD_TYPE || code == UNION_TYPE || code == ENUMERAL_TYPE)
3374         /* Used to test also that TYPE_SIZE (value) != 0.
3375            That caused warning for `struct foo;' at top level in the file.  */
3376         {
3377           register tree name = lookup_tag_reverse (value);
3378           register tree t;
3379
3380           found_tag++;
3381
3382           if (name == 0)
3383             {
3384               if (warned != 1 && code != ENUMERAL_TYPE)
3385                 /* Empty unnamed enum OK */
3386                 {
3387                   pedwarn ("unnamed struct/union that defines no instances");
3388                   warned = 1;
3389                 }
3390             }
3391           else
3392             {
3393               t = lookup_tag (code, name, current_binding_level, 1);
3394
3395               if (t == 0)
3396                 {
3397                   t = make_node (code);
3398                   pushtag (name, t);
3399                 }
3400             }
3401         }
3402       else
3403         {
3404           if (!warned && ! in_system_header)
3405             {
3406               warning ("useless keyword or type name in empty declaration");
3407               warned = 2;
3408             }
3409         }
3410     }
3411
3412   if (found_tag > 1)
3413     error ("two types specified in one empty declaration");
3414
3415   if (warned != 1)
3416     {
3417       if (found_tag == 0)
3418         pedwarn ("empty declaration");
3419     }
3420 }
3421 \f
3422 /* Decode a "typename", such as "int **", returning a ..._TYPE node.  */
3423
3424 tree
3425 groktypename (typename)
3426      tree typename;
3427 {
3428   if (TREE_CODE (typename) != TREE_LIST)
3429     return typename;
3430   return grokdeclarator (TREE_VALUE (typename),
3431                          TREE_PURPOSE (typename),
3432                          TYPENAME, 0);
3433 }
3434
3435 /* Return a PARM_DECL node for a given pair of specs and declarator.  */
3436
3437 tree
3438 groktypename_in_parm_context (typename)
3439      tree typename;
3440 {
3441   if (TREE_CODE (typename) != TREE_LIST)
3442     return typename;
3443   return grokdeclarator (TREE_VALUE (typename),
3444                          TREE_PURPOSE (typename),
3445                          PARM, 0);
3446 }
3447
3448 /* Decode a declarator in an ordinary declaration or data definition.
3449    This is called as soon as the type information and variable name
3450    have been parsed, before parsing the initializer if any.
3451    Here we create the ..._DECL node, fill in its type,
3452    and put it on the list of decls for the current context.
3453    The ..._DECL node is returned as the value.
3454
3455    Exception: for arrays where the length is not specified,
3456    the type is left null, to be filled in by `finish_decl'.
3457
3458    Function definitions do not come here; they go to start_function
3459    instead.  However, external and forward declarations of functions
3460    do go through here.  Structure field declarations are done by
3461    grokfield and not through here.  */
3462
3463 tree
3464 start_decl (declarator, declspecs, initialized, attributes, prefix_attributes)
3465      tree declarator, declspecs;
3466      int initialized;
3467      tree attributes, prefix_attributes;
3468 {
3469   register tree decl = grokdeclarator (declarator, declspecs,
3470                                        NORMAL, initialized);
3471   register tree tem;
3472