1 /* Process declarations and variables for C compiler.
2 Copyright (C) 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
3 2001 Free Software Foundation, Inc.
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify it under
8 the terms of the GNU General Public License as published by the Free
9 Software Foundation; either version 2, or (at your option) any later
12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING. If not, write to the Free
19 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
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. */
26 /* ??? not all decl nodes are given the most useful possible
27 line numbers. For example, the CONST_DECLs for enum values. */
33 #include "tree-inline.h"
50 /* In grokdeclarator, distinguish syntactic contexts of declarators. */
52 { NORMAL, /* Ordinary declaration */
53 FUNCDEF, /* Function definition */
54 PARM, /* Declaration of parm before function body */
55 FIELD, /* Declaration inside struct or union */
56 BITFIELD, /* Likewise but with specified width */
57 TYPENAME}; /* Typename (inside cast or sizeof) */
60 /* Nonzero if we have seen an invalid cross reference
61 to a struct, union, or enum, but not yet printed the message. */
63 tree pending_invalid_xref;
64 /* File and line to appear in the eventual error message. */
65 const char *pending_invalid_xref_file;
66 int pending_invalid_xref_line;
68 /* While defining an enum type, this is 1 plus the last enumerator
69 constant value. Note that will do not have to save this or `enum_overflow'
70 around nested function definition since such a definition could only
71 occur in an enum value expression and we don't use these variables in
74 static tree enum_next_value;
76 /* Nonzero means that there was overflow computing enum_next_value. */
78 static int enum_overflow;
80 /* Parsing a function declarator leaves a list of parameter names
81 or a chain or parameter decls here. */
83 static tree last_function_parms;
85 /* Parsing a function declarator leaves here a chain of structure
86 and enum types declared in the parmlist. */
88 static tree last_function_parm_tags;
90 /* After parsing the declarator that starts a function definition,
91 `start_function' puts here the list of parameter names or chain of decls.
92 `store_parm_decls' finds it here. */
94 static tree current_function_parms;
96 /* Similar, for last_function_parm_tags. */
97 static tree current_function_parm_tags;
99 /* Similar, for the file and line that the prototype came from if this is
100 an old-style definition. */
101 static const char *current_function_prototype_file;
102 static int current_function_prototype_line;
104 /* The current statement tree. */
106 static struct stmt_tree_s c_stmt_tree;
108 /* The current scope statement stack. */
110 static tree c_scope_stmt_stack;
112 /* A list (chain of TREE_LIST nodes) of all LABEL_DECLs in the function
113 that have names. Here so we can clear out their names' definitions
114 at the end of the function. */
116 static tree named_labels;
118 /* A list of LABEL_DECLs from outer contexts that are currently shadowed. */
120 static tree shadowed_labels;
122 /* Nonzero when store_parm_decls is called indicates a varargs function.
123 Value not meaningful after store_parm_decls. */
125 static int c_function_varargs;
127 /* Set to 0 at beginning of a function definition, set to 1 if
128 a return statement that specifies a return value is seen. */
130 int current_function_returns_value;
132 /* Set to 0 at beginning of a function definition, set to 1 if
133 a return statement with no argument is seen. */
135 int current_function_returns_null;
137 /* Set to nonzero by `grokdeclarator' for a function
138 whose return type is defaulted, if warnings for this are desired. */
140 static int warn_about_return_type;
142 /* Nonzero when starting a function declared `extern inline'. */
144 static int current_extern_inline;
146 /* For each binding contour we allocate a binding_level structure
147 * which records the names defined in that contour.
150 * 1) one for each function definition,
151 * where internal declarations of the parameters appear.
152 * 2) one for each compound statement,
153 * to record its declarations.
155 * The current meaning of a name can be found by searching the levels from
156 * the current one out to the global one.
159 /* Note that the information in the `names' component of the global contour
160 is duplicated in the IDENTIFIER_GLOBAL_VALUEs of all identifiers. */
164 /* A chain of _DECL nodes for all variables, constants, functions,
165 and typedef types. These are in the reverse of the order supplied.
169 /* A list of structure, union and enum definitions,
170 * for looking up tag names.
171 * It is a chain of TREE_LIST nodes, each of whose TREE_PURPOSE is a name,
172 * or NULL_TREE; and whose TREE_VALUE is a RECORD_TYPE, UNION_TYPE,
173 * or ENUMERAL_TYPE node.
177 /* For each level, a list of shadowed outer-level local definitions
178 to be restored when this level is popped.
179 Each link is a TREE_LIST whose TREE_PURPOSE is an identifier and
180 whose TREE_VALUE is its old definition (a kind of ..._DECL node). */
183 /* For each level (except not the global one),
184 a chain of BLOCK nodes for all the levels
185 that were entered and exited one level down. */
188 /* The BLOCK node for this level, if one has been preallocated.
189 If 0, the BLOCK is allocated (if needed) when the level is popped. */
192 /* The binding level which this one is contained in (inherits from). */
193 struct binding_level *level_chain;
195 /* Nonzero for the level that holds the parameters of a function. */
198 /* Nonzero if this level "doesn't exist" for tags. */
199 char tag_transparent;
201 /* Nonzero if sublevels of this level "don't exist" for tags.
202 This is set in the parm level of a function definition
203 while reading the function body, so that the outermost block
204 of the function body will be tag-transparent. */
205 char subblocks_tag_transparent;
207 /* Nonzero means make a BLOCK for this level regardless of all else. */
210 /* Nonzero means make a BLOCK if this level has any subblocks. */
211 char keep_if_subblocks;
213 /* Number of decls in `names' that have incomplete
214 structure or union types. */
217 /* A list of decls giving the (reversed) specified order of parms,
218 not including any forward-decls in the parmlist.
219 This is so we can put the parms in proper order for assign_parms. */
223 #define NULL_BINDING_LEVEL (struct binding_level *) NULL
225 /* The binding level currently in effect. */
227 static struct binding_level *current_binding_level;
229 /* A chain of binding_level structures awaiting reuse. */
231 static struct binding_level *free_binding_level;
233 /* The outermost binding level, for names of file scope.
234 This is created when the compiler is started and exists
235 through the entire run. */
237 static struct binding_level *global_binding_level;
239 /* Binding level structures are initialized by copying this one. */
241 static struct binding_level clear_binding_level
242 = {NULL, NULL, NULL, NULL, NULL, NULL_BINDING_LEVEL, 0, 0, 0, 0, 0, 0,
245 /* Nonzero means unconditionally make a BLOCK for the next level pushed. */
247 static int keep_next_level_flag;
249 /* Nonzero means make a BLOCK for the next level pushed
250 if it has subblocks. */
252 static int keep_next_if_subblocks;
254 /* The chain of outer levels of label scopes.
255 This uses the same data structure used for binding levels,
256 but it works differently: each link in the chain records
257 saved values of named_labels and shadowed_labels for
258 a label binding level outside the current one. */
260 static struct binding_level *label_level_chain;
262 /* Functions called automatically at the beginning and end of execution. */
264 tree static_ctors, static_dtors;
266 /* Forward declarations. */
268 static struct binding_level * make_binding_level PARAMS ((void));
269 static void mark_binding_level PARAMS ((void *));
270 static void clear_limbo_values PARAMS ((tree));
271 static int duplicate_decls PARAMS ((tree, tree, int));
272 static int redeclaration_error_message PARAMS ((tree, tree));
273 static void storedecls PARAMS ((tree));
274 static void storetags PARAMS ((tree));
275 static tree lookup_tag PARAMS ((enum tree_code, tree,
276 struct binding_level *, int));
277 static tree lookup_tag_reverse PARAMS ((tree));
278 static tree grokdeclarator PARAMS ((tree, tree, enum decl_context,
280 static tree grokparms PARAMS ((tree, int));
281 static void layout_array_type PARAMS ((tree));
282 static tree c_make_fname_decl PARAMS ((tree, int));
283 static void c_expand_body PARAMS ((tree, int, int));
284 static void warn_if_shadowing PARAMS ((tree, tree));
286 /* C-specific option variables. */
288 /* Nonzero means allow type mismatches in conditional expressions;
289 just make their values `void'. */
291 int flag_cond_mismatch;
293 /* Nonzero means don't recognize the keyword `asm'. */
297 /* Nonzero means do some things the same way PCC does. */
299 int flag_traditional;
301 /* Nonzero means enable C89 Amendment 1 features. */
305 /* Nonzero means use the ISO C99 dialect of C. */
309 /* Nonzero means that we have builtin functions, and main is an int */
313 /* Nonzero means add default format_arg attributes for functions not
316 int flag_noniso_default_format_attributes = 1;
318 /* Nonzero means to allow single precision math even if we're generally
319 being traditional. */
320 int flag_allow_single_precision = 0;
322 /* Nonzero means to treat bitfields as signed unless they say `unsigned'. */
324 int flag_signed_bitfields = 1;
325 int explicit_flag_signed_bitfields = 0;
327 /* Nonzero means warn about use of implicit int. */
329 int warn_implicit_int;
331 /* Nonzero means warn about usage of long long when `-pedantic'. */
333 int warn_long_long = 1;
335 /* Nonzero means message about use of implicit function declarations;
336 1 means warning; 2 means error. */
338 int mesg_implicit_function_declaration = -1;
340 /* Nonzero means give string constants the type `const char *'
341 to get extra warnings from them. These warnings will be too numerous
342 to be useful, except in thoroughly ANSIfied programs. */
344 int flag_const_strings;
346 /* Nonzero means warn about pointer casts that can drop a type qualifier
347 from the pointer target type. */
351 /* Nonzero means warn when casting a function call to a type that does
352 not match the return type (e.g. (float)sqrt() or (anything*)malloc()
353 when there is no previous declaration of sqrt or malloc. */
355 int warn_bad_function_cast;
357 /* Warn about functions which might be candidates for format attributes. */
359 int warn_missing_format_attribute;
361 /* Warn about traditional constructs whose meanings changed in ANSI C. */
363 int warn_traditional;
365 /* Nonzero means warn about sizeof(function) or addition/subtraction
366 of function pointers. */
368 int warn_pointer_arith;
370 /* Nonzero means warn for non-prototype function decls
371 or non-prototyped defs without previous prototype. */
373 int warn_strict_prototypes;
375 /* Nonzero means warn for any global function def
376 without separate previous prototype decl. */
378 int warn_missing_prototypes;
380 /* Nonzero means warn for any global function def
381 without separate previous decl. */
383 int warn_missing_declarations;
385 /* Nonzero means warn about multiple (redundant) decls for the same single
386 variable or function. */
388 int warn_redundant_decls = 0;
390 /* Nonzero means warn about extern declarations of objects not at
391 file-scope level and about *all* declarations of functions (whether
392 extern or static) not at file-scope level. Note that we exclude
393 implicit function declarations. To get warnings about those, use
396 int warn_nested_externs = 0;
398 /* Warn about a subscript that has type char. */
400 int warn_char_subscripts = 0;
402 /* Warn if a type conversion is done that might have confusing results. */
406 /* Warn if adding () is suggested. */
408 int warn_parentheses;
410 /* Warn if initializer is not completely bracketed. */
412 int warn_missing_braces;
414 /* Warn if main is suspicious. */
418 /* Warn about #pragma directives that are not recognised. */
420 int warn_unknown_pragmas = 0; /* Tri state variable. */
422 /* Warn about comparison of signed and unsigned values.
423 If -1, neither -Wsign-compare nor -Wno-sign-compare has been specified. */
425 int warn_sign_compare = -1;
427 /* Warn about testing equality of floating point numbers. */
429 int warn_float_equal = 0;
431 /* Nonzero means warn about use of multicharacter literals. */
433 int warn_multichar = 1;
435 /* The variant of the C language being processed. */
437 c_language_kind c_language = clk_c;
439 /* Nonzero means `$' can be in an identifier. */
441 #ifndef DOLLARS_IN_IDENTIFIERS
442 #define DOLLARS_IN_IDENTIFIERS 1
444 int dollars_in_ident = DOLLARS_IN_IDENTIFIERS;
446 /* Decode the string P as a language-specific option for C.
447 Return the number of strings consumed. Should not complain
448 if it does not recognise the option. */
451 c_decode_option (argc, argv)
452 int argc ATTRIBUTE_UNUSED;
455 int strings_processed;
458 strings_processed = cpp_handle_option (parse_in, argc, argv);
460 if (!strcmp (p, "-ftraditional") || !strcmp (p, "-traditional"))
462 warning ("-traditional is deprecated and may be removed");
463 flag_traditional = 1;
464 flag_writable_strings = 1;
466 else if (!strcmp (p, "-fallow-single-precision"))
467 flag_allow_single_precision = 1;
468 else if (!strcmp (p, "-fhosted") || !strcmp (p, "-fno-freestanding"))
473 else if (!strcmp (p, "-ffreestanding") || !strcmp (p, "-fno-hosted"))
477 /* warn_main will be 2 if set by -Wall, 1 if set by -Wmain */
481 else if (!strcmp (p, "-fnotraditional") || !strcmp (p, "-fno-traditional"))
483 flag_traditional = 0;
484 flag_writable_strings = 0;
486 else if (!strncmp (p, "-std=", 5))
488 /* Select the appropriate language standard. We currently
490 -std=iso9899:1990 same as -ansi
491 -std=iso9899:199409 ISO C as modified in amend. 1
492 -std=iso9899:1999 ISO C 99
493 -std=c89 same as -std=iso9899:1990
494 -std=c99 same as -std=iso9899:1999
495 -std=gnu89 default, iso9899:1990 + gnu extensions
496 -std=gnu99 iso9899:1999 + gnu extensions
498 const char *const argstart = &p[5];
500 if (!strcmp (argstart, "iso9899:1990")
501 || !strcmp (argstart, "c89"))
506 flag_traditional = 0;
507 flag_writable_strings = 0;
509 flag_no_nonansi_builtin = 1;
510 flag_noniso_default_format_attributes = 0;
513 else if (!strcmp (argstart, "iso9899:199409"))
518 else if (!strcmp (argstart, "iso9899:199x")
519 || !strcmp (argstart, "iso9899:1999")
520 || !strcmp (argstart, "c9x")
521 || !strcmp (argstart, "c99"))
523 flag_traditional = 0;
524 flag_writable_strings = 0;
526 flag_no_nonansi_builtin = 1;
527 flag_noniso_default_format_attributes = 0;
531 else if (!strcmp (argstart, "gnu89"))
533 flag_traditional = 0;
534 flag_writable_strings = 0;
536 flag_no_nonansi_builtin = 0;
537 flag_noniso_default_format_attributes = 1;
541 else if (!strcmp (argstart, "gnu9x") || !strcmp (argstart, "gnu99"))
543 flag_traditional = 0;
544 flag_writable_strings = 0;
546 flag_no_nonansi_builtin = 0;
547 flag_noniso_default_format_attributes = 1;
552 error ("unknown C standard `%s'", argstart);
554 else if (!strcmp (p, "-fdollars-in-identifiers"))
555 dollars_in_ident = 1;
556 else if (!strcmp (p, "-fno-dollars-in-identifiers"))
557 dollars_in_ident = 0;
558 else if (!strcmp (p, "-fsigned-char"))
559 flag_signed_char = 1;
560 else if (!strcmp (p, "-funsigned-char"))
561 flag_signed_char = 0;
562 else if (!strcmp (p, "-fno-signed-char"))
563 flag_signed_char = 0;
564 else if (!strcmp (p, "-fno-unsigned-char"))
565 flag_signed_char = 1;
566 else if (!strcmp (p, "-fsigned-bitfields")
567 || !strcmp (p, "-fno-unsigned-bitfields"))
569 flag_signed_bitfields = 1;
570 explicit_flag_signed_bitfields = 1;
572 else if (!strcmp (p, "-funsigned-bitfields")
573 || !strcmp (p, "-fno-signed-bitfields"))
575 flag_signed_bitfields = 0;
576 explicit_flag_signed_bitfields = 1;
578 else if (!strcmp (p, "-fshort-enums"))
579 flag_short_enums = 1;
580 else if (!strcmp (p, "-fno-short-enums"))
581 flag_short_enums = 0;
582 else if (!strcmp (p, "-fshort-wchar"))
583 flag_short_wchar = 1;
584 else if (!strcmp (p, "-fno-short-wchar"))
585 flag_short_wchar = 0;
586 else if (!strcmp (p, "-fcond-mismatch"))
587 flag_cond_mismatch = 1;
588 else if (!strcmp (p, "-fno-cond-mismatch"))
589 flag_cond_mismatch = 0;
590 else if (!strcmp (p, "-fshort-double"))
591 flag_short_double = 1;
592 else if (!strcmp (p, "-fno-short-double"))
593 flag_short_double = 0;
594 else if (!strcmp (p, "-fasm"))
596 else if (!strcmp (p, "-fno-asm"))
598 else if (!strcmp (p, "-fbuiltin"))
600 else if (!strcmp (p, "-fno-builtin"))
602 else if (!strncmp (p, "-fno-builtin-", strlen ("-fno-builtin-")))
603 disable_builtin_function (p + strlen ("-fno-builtin-"));
604 else if (p[0] == '-' && p[1] == 'f' && dump_switch_p (p + 2))
606 else if (!strcmp (p, "-ansi"))
608 else if (!strcmp (p, "-Werror-implicit-function-declaration"))
609 mesg_implicit_function_declaration = 2;
610 else if (!strcmp (p, "-Wimplicit-function-declaration"))
611 mesg_implicit_function_declaration = 1;
612 else if (!strcmp (p, "-Wno-implicit-function-declaration"))
613 mesg_implicit_function_declaration = 0;
614 else if (!strcmp (p, "-Wimplicit-int"))
615 warn_implicit_int = 1;
616 else if (!strcmp (p, "-Wno-implicit-int"))
617 warn_implicit_int = 0;
618 else if (!strcmp (p, "-Wimplicit"))
620 warn_implicit_int = 1;
621 if (mesg_implicit_function_declaration != 2)
622 mesg_implicit_function_declaration = 1;
624 else if (!strcmp (p, "-Wno-implicit"))
625 warn_implicit_int = 0, mesg_implicit_function_declaration = 0;
626 else if (!strcmp (p, "-Wlong-long"))
628 else if (!strcmp (p, "-Wno-long-long"))
630 else if (!strcmp (p, "-Wwrite-strings"))
631 flag_const_strings = 1;
632 else if (!strcmp (p, "-Wno-write-strings"))
633 flag_const_strings = 0;
634 else if (!strcmp (p, "-Wcast-qual"))
636 else if (!strcmp (p, "-Wno-cast-qual"))
638 else if (!strcmp (p, "-Wbad-function-cast"))
639 warn_bad_function_cast = 1;
640 else if (!strcmp (p, "-Wno-bad-function-cast"))
641 warn_bad_function_cast = 0;
642 else if (!strcmp (p, "-Wno-missing-noreturn"))
643 warn_missing_noreturn = 0;
644 else if (!strcmp (p, "-Wmissing-format-attribute"))
645 warn_missing_format_attribute = 1;
646 else if (!strcmp (p, "-Wno-missing-format-attribute"))
647 warn_missing_format_attribute = 0;
648 else if (!strcmp (p, "-Wpointer-arith"))
649 warn_pointer_arith = 1;
650 else if (!strcmp (p, "-Wno-pointer-arith"))
651 warn_pointer_arith = 0;
652 else if (!strcmp (p, "-Wstrict-prototypes"))
653 warn_strict_prototypes = 1;
654 else if (!strcmp (p, "-Wno-strict-prototypes"))
655 warn_strict_prototypes = 0;
656 else if (!strcmp (p, "-Wmissing-prototypes"))
657 warn_missing_prototypes = 1;
658 else if (!strcmp (p, "-Wno-missing-prototypes"))
659 warn_missing_prototypes = 0;
660 else if (!strcmp (p, "-Wmissing-declarations"))
661 warn_missing_declarations = 1;
662 else if (!strcmp (p, "-Wno-missing-declarations"))
663 warn_missing_declarations = 0;
664 else if (!strcmp (p, "-Wredundant-decls"))
665 warn_redundant_decls = 1;
666 else if (!strcmp (p, "-Wno-redundant-decls"))
667 warn_redundant_decls = 0;
668 else if (!strcmp (p, "-Wnested-externs"))
669 warn_nested_externs = 1;
670 else if (!strcmp (p, "-Wno-nested-externs"))
671 warn_nested_externs = 0;
672 else if (!strcmp (p, "-Wtraditional"))
673 warn_traditional = 1;
674 else if (!strcmp (p, "-Wno-traditional"))
675 warn_traditional = 0;
676 else if (!strncmp (p, "-Wformat=", 9))
677 set_Wformat (atoi (p + 9));
678 else if (!strcmp (p, "-Wformat"))
680 else if (!strcmp (p, "-Wno-format"))
682 else if (!strcmp (p, "-Wformat-y2k"))
684 else if (!strcmp (p, "-Wno-format-y2k"))
686 else if (!strcmp (p, "-Wformat-extra-args"))
687 warn_format_extra_args = 1;
688 else if (!strcmp (p, "-Wno-format-extra-args"))
689 warn_format_extra_args = 0;
690 else if (!strcmp (p, "-Wformat-nonliteral"))
691 warn_format_nonliteral = 1;
692 else if (!strcmp (p, "-Wno-format-nonliteral"))
693 warn_format_nonliteral = 0;
694 else if (!strcmp (p, "-Wformat-security"))
695 warn_format_security = 1;
696 else if (!strcmp (p, "-Wno-format-security"))
697 warn_format_security = 0;
698 else if (!strcmp (p, "-Wchar-subscripts"))
699 warn_char_subscripts = 1;
700 else if (!strcmp (p, "-Wno-char-subscripts"))
701 warn_char_subscripts = 0;
702 else if (!strcmp (p, "-Wconversion"))
704 else if (!strcmp (p, "-Wno-conversion"))
706 else if (!strcmp (p, "-Wparentheses"))
707 warn_parentheses = 1;
708 else if (!strcmp (p, "-Wno-parentheses"))
709 warn_parentheses = 0;
710 else if (!strcmp (p, "-Wreturn-type"))
711 warn_return_type = 1;
712 else if (!strcmp (p, "-Wno-return-type"))
713 warn_return_type = 0;
714 else if (!strcmp (p, "-Wsequence-point"))
715 warn_sequence_point = 1;
716 else if (!strcmp (p, "-Wno-sequence-point"))
717 warn_sequence_point = 0;
718 else if (!strcmp (p, "-Wcomment"))
719 ; /* cpp handles this one. */
720 else if (!strcmp (p, "-Wno-comment"))
721 ; /* cpp handles this one. */
722 else if (!strcmp (p, "-Wcomments"))
723 ; /* cpp handles this one. */
724 else if (!strcmp (p, "-Wno-comments"))
725 ; /* cpp handles this one. */
726 else if (!strcmp (p, "-Wtrigraphs"))
727 ; /* cpp handles this one. */
728 else if (!strcmp (p, "-Wno-trigraphs"))
729 ; /* cpp handles this one. */
730 else if (!strcmp (p, "-Wundef"))
731 ; /* cpp handles this one. */
732 else if (!strcmp (p, "-Wno-undef"))
733 ; /* cpp handles this one. */
734 else if (!strcmp (p, "-Wimport"))
735 ; /* cpp handles this one. */
736 else if (!strcmp (p, "-Wno-import"))
737 ; /* cpp handles this one. */
738 else if (!strcmp (p, "-Wmissing-braces"))
739 warn_missing_braces = 1;
740 else if (!strcmp (p, "-Wno-missing-braces"))
741 warn_missing_braces = 0;
742 else if (!strcmp (p, "-Wmain"))
744 else if (!strcmp (p, "-Wno-main"))
746 else if (!strcmp (p, "-Wsign-compare"))
747 warn_sign_compare = 1;
748 else if (!strcmp (p, "-Wno-sign-compare"))
749 warn_sign_compare = 0;
750 else if (!strcmp (p, "-Wfloat-equal"))
751 warn_float_equal = 1;
752 else if (!strcmp (p, "-Wno-float-equal"))
753 warn_float_equal = 0;
754 else if (!strcmp (p, "-Wmultichar"))
756 else if (!strcmp (p, "-Wno-multichar"))
758 else if (!strcmp (p, "-Wdiv-by-zero"))
759 warn_div_by_zero = 1;
760 else if (!strcmp (p, "-Wno-div-by-zero"))
761 warn_div_by_zero = 0;
762 else if (!strcmp (p, "-Wunknown-pragmas"))
763 /* Set to greater than 1, so that even unknown pragmas in system
764 headers will be warned about. */
765 warn_unknown_pragmas = 2;
766 else if (!strcmp (p, "-Wno-unknown-pragmas"))
767 warn_unknown_pragmas = 0;
768 else if (!strcmp (p, "-Wall"))
770 /* We save the value of warn_uninitialized, since if they put
771 -Wuninitialized on the command line, we need to generate a
772 warning about not using it without also specifying -O. */
773 if (warn_uninitialized != 1)
774 warn_uninitialized = 2;
775 warn_implicit_int = 1;
776 mesg_implicit_function_declaration = 1;
777 warn_return_type = 1;
781 warn_char_subscripts = 1;
782 warn_parentheses = 1;
783 warn_sequence_point = 1;
784 warn_missing_braces = 1;
785 /* We set this to 2 here, but 1 in -Wmain, so -ffreestanding can turn
786 it off only if it's not explicit. */
788 /* Only warn about unknown pragmas that are not in system headers. */
789 warn_unknown_pragmas = 1;
792 return strings_processed;
798 c_print_identifier (file, node, indent)
803 print_node (file, "global", IDENTIFIER_GLOBAL_VALUE (node), indent + 4);
804 print_node (file, "local", IDENTIFIER_LOCAL_VALUE (node), indent + 4);
805 print_node (file, "label", IDENTIFIER_LABEL_VALUE (node), indent + 4);
806 print_node (file, "implicit", IDENTIFIER_IMPLICIT_DECL (node), indent + 4);
807 print_node (file, "error locus", IDENTIFIER_ERROR_LOCUS (node), indent + 4);
808 print_node (file, "limbo value", IDENTIFIER_LIMBO_VALUE (node), indent + 4);
809 if (C_IS_RESERVED_WORD (node))
811 tree rid = ridpointers[C_RID_CODE (node)];
812 indent_to (file, indent + 4);
813 fprintf (file, "rid ");
814 fprintf (file, HOST_PTR_PRINTF, (void *)rid);
815 fprintf (file, " \"%s\"", IDENTIFIER_POINTER (rid));
819 /* Hook called at end of compilation to assume 1 elt
820 for a top-level tentative array defn that wasn't complete before. */
823 finish_incomplete_decl (decl)
826 if (TREE_CODE (decl) == VAR_DECL)
828 tree type = TREE_TYPE (decl);
829 if (type != error_mark_node
830 && TREE_CODE (type) == ARRAY_TYPE
831 && ! DECL_EXTERNAL (decl)
832 && TYPE_DOMAIN (type) == 0)
834 warning_with_decl (decl, "array `%s' assumed to have one element");
836 complete_array_type (type, NULL_TREE, 1);
838 layout_decl (decl, 0);
843 /* Create a new `struct binding_level'. */
845 static struct binding_level *
846 make_binding_level ()
849 return (struct binding_level *) xmalloc (sizeof (struct binding_level));
852 /* Nonzero if we are currently in the global binding level. */
857 return current_binding_level == global_binding_level;
863 keep_next_level_flag = 1;
866 /* Nonzero if the current level needs to have a BLOCK made. */
871 return ((current_binding_level->keep_if_subblocks
872 && current_binding_level->blocks != 0)
873 || current_binding_level->keep
874 || current_binding_level->names != 0
875 || (current_binding_level->tags != 0
876 && !current_binding_level->tag_transparent));
879 /* Identify this binding level as a level of parameters.
880 DEFINITION_FLAG is 1 for a definition, 0 for a declaration.
881 But it turns out there is no way to pass the right value for
882 DEFINITION_FLAG, so we ignore it. */
885 declare_parm_level (definition_flag)
886 int definition_flag ATTRIBUTE_UNUSED;
888 current_binding_level->parm_flag = 1;
891 /* Nonzero if currently making parm declarations. */
896 return current_binding_level->parm_flag;
899 /* Enter a new binding level.
900 If TAG_TRANSPARENT is nonzero, do so only for the name space of variables,
901 not for that of tags. */
904 pushlevel (tag_transparent)
907 struct binding_level *newlevel = NULL_BINDING_LEVEL;
909 /* If this is the top level of a function,
910 just make sure that NAMED_LABELS is 0. */
912 if (current_binding_level == global_binding_level)
917 /* Reuse or create a struct for this binding level. */
919 if (free_binding_level)
921 newlevel = free_binding_level;
922 free_binding_level = free_binding_level->level_chain;
926 newlevel = make_binding_level ();
929 /* Add this level to the front of the chain (stack) of levels that
932 *newlevel = clear_binding_level;
933 newlevel->tag_transparent
935 || (current_binding_level
936 ? current_binding_level->subblocks_tag_transparent
938 newlevel->level_chain = current_binding_level;
939 current_binding_level = newlevel;
940 newlevel->keep = keep_next_level_flag;
941 keep_next_level_flag = 0;
942 newlevel->keep_if_subblocks = keep_next_if_subblocks;
943 keep_next_if_subblocks = 0;
946 /* Clear the limbo values of all identifiers defined in BLOCK or a subblock. */
949 clear_limbo_values (block)
954 for (tem = BLOCK_VARS (block); tem; tem = TREE_CHAIN (tem))
955 if (DECL_NAME (tem) != 0)
956 IDENTIFIER_LIMBO_VALUE (DECL_NAME (tem)) = 0;
958 for (tem = BLOCK_SUBBLOCKS (block); tem; tem = TREE_CHAIN (tem))
959 clear_limbo_values (tem);
962 /* Exit a binding level.
963 Pop the level off, and restore the state of the identifier-decl mappings
964 that were in effect when this level was entered.
966 If KEEP is nonzero, this level had explicit declarations, so
967 and create a "block" (a BLOCK node) for the level
968 to record its declarations and subblocks for symbol table output.
970 If FUNCTIONBODY is nonzero, this level is the body of a function,
971 so create a block as if KEEP were set and also clear out all
974 If REVERSE is nonzero, reverse the order of decls before putting
975 them into the BLOCK. */
978 poplevel (keep, reverse, functionbody)
984 /* The chain of decls was accumulated in reverse order.
985 Put it into forward order, just for cleanliness. */
987 tree tags = current_binding_level->tags;
988 tree subblocks = current_binding_level->blocks;
991 int block_previously_created;
993 keep |= current_binding_level->keep;
995 /* This warning is turned off because it causes warnings for
996 declarations like `extern struct foo *x'. */
998 /* Warn about incomplete structure types in this level. */
999 for (link = tags; link; link = TREE_CHAIN (link))
1000 if (!COMPLETE_TYPE_P (TREE_VALUE (link)))
1002 tree type = TREE_VALUE (link);
1003 tree type_name = TYPE_NAME (type);
1004 char *id = IDENTIFIER_POINTER (TREE_CODE (type_name) == IDENTIFIER_NODE
1006 : DECL_NAME (type_name));
1007 switch (TREE_CODE (type))
1010 error ("`struct %s' incomplete in scope ending here", id);
1013 error ("`union %s' incomplete in scope ending here", id);
1016 error ("`enum %s' incomplete in scope ending here", id);
1022 /* Get the decls in the order they were written.
1023 Usually current_binding_level->names is in reverse order.
1024 But parameter decls were previously put in forward order. */
1027 current_binding_level->names
1028 = decls = nreverse (current_binding_level->names);
1030 decls = current_binding_level->names;
1032 /* Output any nested inline functions within this block
1033 if they weren't already output. */
1035 for (decl = decls; decl; decl = TREE_CHAIN (decl))
1036 if (TREE_CODE (decl) == FUNCTION_DECL
1037 && ! TREE_ASM_WRITTEN (decl)
1038 && DECL_INITIAL (decl) != 0
1039 && TREE_ADDRESSABLE (decl))
1041 /* If this decl was copied from a file-scope decl
1042 on account of a block-scope extern decl,
1043 propagate TREE_ADDRESSABLE to the file-scope decl.
1045 DECL_ABSTRACT_ORIGIN can be set to itself if warn_return_type is
1046 true, since then the decl goes through save_for_inline_copying. */
1047 if (DECL_ABSTRACT_ORIGIN (decl) != 0
1048 && DECL_ABSTRACT_ORIGIN (decl) != decl)
1049 TREE_ADDRESSABLE (DECL_ABSTRACT_ORIGIN (decl)) = 1;
1052 /* We used to warn about unused variables in expand_end_bindings,
1053 i.e. while generating RTL. But in function-at-a-time mode we may
1054 choose to never expand a function at all (e.g. auto inlining), so
1055 we do this explicitly now. */
1056 warn_about_unused_variables (getdecls ());
1058 /* If there were any declarations or structure tags in that level,
1059 or if this level is a function body,
1060 create a BLOCK to record them for the life of this function. */
1063 block_previously_created = (current_binding_level->this_block != 0);
1064 if (block_previously_created)
1065 block = current_binding_level->this_block;
1066 else if (keep || functionbody
1067 || (current_binding_level->keep_if_subblocks && subblocks != 0))
1068 block = make_node (BLOCK);
1071 BLOCK_VARS (block) = decls;
1072 BLOCK_SUBBLOCKS (block) = subblocks;
1075 /* In each subblock, record that this is its superior. */
1077 for (link = subblocks; link; link = TREE_CHAIN (link))
1078 BLOCK_SUPERCONTEXT (link) = block;
1080 /* Clear out the meanings of the local variables of this level. */
1082 for (link = decls; link; link = TREE_CHAIN (link))
1084 if (DECL_NAME (link) != 0)
1086 /* If the ident. was used or addressed via a local extern decl,
1087 don't forget that fact. */
1088 if (DECL_EXTERNAL (link))
1090 if (TREE_USED (link))
1091 TREE_USED (DECL_NAME (link)) = 1;
1092 if (TREE_ADDRESSABLE (link))
1093 TREE_ADDRESSABLE (DECL_ASSEMBLER_NAME (link)) = 1;
1095 IDENTIFIER_LOCAL_VALUE (DECL_NAME (link)) = 0;
1099 /* Restore all name-meanings of the outer levels
1100 that were shadowed by this level. */
1102 for (link = current_binding_level->shadowed; link; link = TREE_CHAIN (link))
1103 IDENTIFIER_LOCAL_VALUE (TREE_PURPOSE (link)) = TREE_VALUE (link);
1105 /* If the level being exited is the top level of a function,
1106 check over all the labels, and clear out the current
1107 (function local) meanings of their names. */
1111 clear_limbo_values (block);
1113 /* If this is the top level block of a function,
1114 the vars are the function's parameters.
1115 Don't leave them in the BLOCK because they are
1116 found in the FUNCTION_DECL instead. */
1118 BLOCK_VARS (block) = 0;
1120 /* Clear out the definitions of all label names,
1121 since their scopes end here,
1122 and add them to BLOCK_VARS. */
1124 for (link = named_labels; link; link = TREE_CHAIN (link))
1126 tree label = TREE_VALUE (link);
1128 if (DECL_INITIAL (label) == 0)
1130 error_with_decl (label, "label `%s' used but not defined");
1131 /* Avoid crashing later. */
1132 define_label (input_filename, lineno,
1135 else if (warn_unused_label && !TREE_USED (label))
1136 warning_with_decl (label, "label `%s' defined but not used");
1137 IDENTIFIER_LABEL_VALUE (DECL_NAME (label)) = 0;
1139 /* Put the labels into the "variables" of the
1140 top-level block, so debugger can see them. */
1141 TREE_CHAIN (label) = BLOCK_VARS (block);
1142 BLOCK_VARS (block) = label;
1146 /* Pop the current level, and free the structure for reuse. */
1149 struct binding_level *level = current_binding_level;
1150 current_binding_level = current_binding_level->level_chain;
1152 level->level_chain = free_binding_level;
1153 free_binding_level = level;
1156 /* Dispose of the block that we just made inside some higher level. */
1158 DECL_INITIAL (current_function_decl) = block;
1161 if (!block_previously_created)
1162 current_binding_level->blocks
1163 = chainon (current_binding_level->blocks, block);
1165 /* If we did not make a block for the level just exited,
1166 any blocks made for inner levels
1167 (since they cannot be recorded as subblocks in that level)
1168 must be carried forward so they will later become subblocks
1169 of something else. */
1171 current_binding_level->blocks
1172 = chainon (current_binding_level->blocks, subblocks);
1174 /* Set the TYPE_CONTEXTs for all of the tagged types belonging to this
1175 binding contour so that they point to the appropriate construct, i.e.
1176 either to the current FUNCTION_DECL node, or else to the BLOCK node
1177 we just constructed.
1179 Note that for tagged types whose scope is just the formal parameter
1180 list for some function type specification, we can't properly set
1181 their TYPE_CONTEXTs here, because we don't have a pointer to the
1182 appropriate FUNCTION_TYPE node readily available to us. For those
1183 cases, the TYPE_CONTEXTs of the relevant tagged type nodes get set
1184 in `grokdeclarator' as soon as we have created the FUNCTION_TYPE
1185 node which will represent the "scope" for these "parameter list local"
1189 for (link = tags; link; link = TREE_CHAIN (link))
1190 TYPE_CONTEXT (TREE_VALUE (link)) = current_function_decl;
1192 for (link = tags; link; link = TREE_CHAIN (link))
1193 TYPE_CONTEXT (TREE_VALUE (link)) = block;
1196 TREE_USED (block) = 1;
1201 /* Insert BLOCK at the end of the list of subblocks of the
1202 current binding level. This is used when a BIND_EXPR is expanded,
1203 to handle the BLOCK node inside the BIND_EXPR. */
1206 insert_block (block)
1209 TREE_USED (block) = 1;
1210 current_binding_level->blocks
1211 = chainon (current_binding_level->blocks, block);
1214 /* Set the BLOCK node for the innermost scope
1215 (the one we are currently in). */
1221 current_binding_level->this_block = block;
1222 current_binding_level->names = chainon (current_binding_level->names,
1223 BLOCK_VARS (block));
1224 current_binding_level->blocks = chainon (current_binding_level->blocks,
1225 BLOCK_SUBBLOCKS (block));
1231 struct binding_level *newlevel;
1233 /* Reuse or create a struct for this binding level. */
1235 if (free_binding_level)
1237 newlevel = free_binding_level;
1238 free_binding_level = free_binding_level->level_chain;
1242 newlevel = make_binding_level ();
1245 /* Add this level to the front of the chain (stack) of label levels. */
1247 newlevel->level_chain = label_level_chain;
1248 label_level_chain = newlevel;
1250 newlevel->names = named_labels;
1251 newlevel->shadowed = shadowed_labels;
1253 shadowed_labels = 0;
1259 struct binding_level *level = label_level_chain;
1262 /* Clear out the definitions of the declared labels in this level.
1263 Leave in the list any ordinary, non-declared labels. */
1264 for (link = named_labels, prev = 0; link;)
1266 if (C_DECLARED_LABEL_FLAG (TREE_VALUE (link)))
1268 if (DECL_SOURCE_LINE (TREE_VALUE (link)) == 0)
1270 error_with_decl (TREE_VALUE (link),
1271 "label `%s' used but not defined");
1272 /* Avoid crashing later. */
1273 define_label (input_filename, lineno,
1274 DECL_NAME (TREE_VALUE (link)));
1276 else if (warn_unused_label && !TREE_USED (TREE_VALUE (link)))
1277 warning_with_decl (TREE_VALUE (link),
1278 "label `%s' defined but not used");
1279 IDENTIFIER_LABEL_VALUE (DECL_NAME (TREE_VALUE (link))) = 0;
1281 /* Delete this element from the list. */
1282 link = TREE_CHAIN (link);
1284 TREE_CHAIN (prev) = link;
1286 named_labels = link;
1291 link = TREE_CHAIN (link);
1295 /* Bring back all the labels that were shadowed. */
1296 for (link = shadowed_labels; link; link = TREE_CHAIN (link))
1297 if (DECL_NAME (TREE_VALUE (link)) != 0)
1298 IDENTIFIER_LABEL_VALUE (DECL_NAME (TREE_VALUE (link)))
1299 = TREE_VALUE (link);
1301 named_labels = chainon (named_labels, level->names);
1302 shadowed_labels = level->shadowed;
1304 /* Pop the current level, and free the structure for reuse. */
1305 label_level_chain = label_level_chain->level_chain;
1306 level->level_chain = free_binding_level;
1307 free_binding_level = level;
1310 /* Push a definition or a declaration of struct, union or enum tag "name".
1311 "type" should be the type node.
1312 We assume that the tag "name" is not already defined.
1314 Note that the definition may really be just a forward reference.
1315 In that case, the TYPE_SIZE will be zero. */
1318 pushtag (name, type)
1321 struct binding_level *b;
1323 /* Find the proper binding level for this type tag. */
1325 for (b = current_binding_level; b->tag_transparent; b = b->level_chain)
1330 /* Record the identifier as the type's name if it has none. */
1332 if (TYPE_NAME (type) == 0)
1333 TYPE_NAME (type) = name;
1336 b->tags = tree_cons (name, type, b->tags);
1338 /* Create a fake NULL-named TYPE_DECL node whose TREE_TYPE will be the
1339 tagged type we just added to the current binding level. This fake
1340 NULL-named TYPE_DECL node helps dwarfout.c to know when it needs
1341 to output a representation of a tagged type, and it also gives
1342 us a convenient place to record the "scope start" address for the
1345 TYPE_STUB_DECL (type) = pushdecl (build_decl (TYPE_DECL, NULL_TREE, type));
1347 /* An approximation for now, so we can tell this is a function-scope tag.
1348 This will be updated in poplevel. */
1349 TYPE_CONTEXT (type) = DECL_CONTEXT (TYPE_STUB_DECL (type));
1352 /* Handle when a new declaration NEWDECL
1353 has the same name as an old one OLDDECL
1354 in the same binding contour.
1355 Prints an error message if appropriate.
1357 If safely possible, alter OLDDECL to look like NEWDECL, and return 1.
1358 Otherwise, return 0.
1360 When DIFFERENT_BINDING_LEVEL is true, NEWDECL is an external declaration,
1361 and OLDDECL is in an outer binding level and should thus not be changed. */
1364 duplicate_decls (newdecl, olddecl, different_binding_level)
1365 tree newdecl, olddecl;
1366 int different_binding_level;
1368 int types_match = comptypes (TREE_TYPE (newdecl), TREE_TYPE (olddecl));
1369 int new_is_definition = (TREE_CODE (newdecl) == FUNCTION_DECL
1370 && DECL_INITIAL (newdecl) != 0);
1371 tree oldtype = TREE_TYPE (olddecl);
1372 tree newtype = TREE_TYPE (newdecl);
1375 if (DECL_P (olddecl))
1377 if (TREE_CODE (newdecl) == FUNCTION_DECL
1378 && TREE_CODE (olddecl) == FUNCTION_DECL
1379 && (DECL_UNINLINABLE (newdecl) || DECL_UNINLINABLE (olddecl)))
1381 if (DECL_DECLARED_INLINE_P (newdecl)
1382 && DECL_UNINLINABLE (newdecl)
1383 && lookup_attribute ("noinline", DECL_ATTRIBUTES (newdecl)))
1384 /* Already warned elsewhere. */;
1385 else if (DECL_DECLARED_INLINE_P (olddecl)
1386 && DECL_UNINLINABLE (olddecl)
1387 && lookup_attribute ("noinline", DECL_ATTRIBUTES (olddecl)))
1388 /* Already warned. */;
1389 else if (DECL_DECLARED_INLINE_P (newdecl)
1390 && ! DECL_DECLARED_INLINE_P (olddecl)
1391 && DECL_UNINLINABLE (olddecl)
1392 && lookup_attribute ("noinline", DECL_ATTRIBUTES (olddecl)))
1394 warning_with_decl (newdecl,
1395 "function `%s' redeclared as inline");
1396 warning_with_decl (olddecl,
1397 "previous declaration of function `%s' with attribute noinline");
1399 else if (DECL_DECLARED_INLINE_P (olddecl)
1400 && DECL_UNINLINABLE (newdecl)
1401 && lookup_attribute ("noinline", DECL_ATTRIBUTES (newdecl)))
1403 warning_with_decl (newdecl,
1404 "function `%s' redeclared with attribute noinline");
1405 warning_with_decl (olddecl,
1406 "previous declaration of function `%s' was inline");
1410 DECL_ATTRIBUTES (newdecl)
1411 = (*targetm.merge_decl_attributes) (olddecl, newdecl);
1414 if (TREE_CODE (newtype) == ERROR_MARK
1415 || TREE_CODE (oldtype) == ERROR_MARK)
1418 /* New decl is completely inconsistent with the old one =>
1419 tell caller to replace the old one.
1420 This is always an error except in the case of shadowing a builtin. */
1421 if (TREE_CODE (olddecl) != TREE_CODE (newdecl))
1423 if (TREE_CODE (olddecl) == FUNCTION_DECL
1424 && (DECL_BUILT_IN (olddecl)
1425 || DECL_BUILT_IN_NONANSI (olddecl)))
1427 /* If you declare a built-in or predefined function name as static,
1428 the old definition is overridden,
1429 but optionally warn this was a bad choice of name. */
1430 if (!TREE_PUBLIC (newdecl))
1434 else if (DECL_BUILT_IN (olddecl))
1435 warning_with_decl (newdecl, "shadowing built-in function `%s'");
1437 warning_with_decl (newdecl, "shadowing library function `%s'");
1439 /* Likewise, if the built-in is not ansi, then programs can
1440 override it even globally without an error. */
1441 else if (! DECL_BUILT_IN (olddecl))
1442 warning_with_decl (newdecl,
1443 "library function `%s' declared as non-function");
1445 else if (DECL_BUILT_IN_NONANSI (olddecl))
1446 warning_with_decl (newdecl,
1447 "built-in function `%s' declared as non-function");
1449 warning_with_decl (newdecl,
1450 "built-in function `%s' declared as non-function");
1454 error_with_decl (newdecl, "`%s' redeclared as different kind of symbol");
1455 error_with_decl (olddecl, "previous declaration of `%s'");
1461 /* For real parm decl following a forward decl,
1462 return 1 so old decl will be reused. */
1463 if (types_match && TREE_CODE (newdecl) == PARM_DECL
1464 && TREE_ASM_WRITTEN (olddecl) && ! TREE_ASM_WRITTEN (newdecl))
1467 /* The new declaration is the same kind of object as the old one.
1468 The declarations may partially match. Print warnings if they don't
1469 match enough. Ultimately, copy most of the information from the new
1470 decl to the old one, and keep using the old one. */
1472 if (flag_traditional && TREE_CODE (newdecl) == FUNCTION_DECL
1473 && IDENTIFIER_IMPLICIT_DECL (DECL_NAME (newdecl)) == olddecl
1474 && DECL_INITIAL (olddecl) == 0)
1475 /* If -traditional, avoid error for redeclaring fcn
1476 after implicit decl. */
1478 else if (TREE_CODE (olddecl) == FUNCTION_DECL
1479 && DECL_BUILT_IN (olddecl))
1481 /* A function declaration for a built-in function. */
1482 if (!TREE_PUBLIC (newdecl))
1484 /* If you declare a built-in function name as static, the
1485 built-in definition is overridden,
1486 but optionally warn this was a bad choice of name. */
1488 warning_with_decl (newdecl, "shadowing built-in function `%s'");
1489 /* Discard the old built-in function. */
1492 else if (!types_match)
1494 /* Accept the return type of the new declaration if same modes. */
1495 tree oldreturntype = TREE_TYPE (oldtype);
1496 tree newreturntype = TREE_TYPE (newtype);
1498 if (TYPE_MODE (oldreturntype) == TYPE_MODE (newreturntype))
1500 /* Function types may be shared, so we can't just modify
1501 the return type of olddecl's function type. */
1503 = build_function_type (newreturntype,
1504 TYPE_ARG_TYPES (oldtype));
1505 trytype = build_type_attribute_variant (trytype,
1506 TYPE_ATTRIBUTES (oldtype));
1508 types_match = comptypes (newtype, trytype);
1512 /* Accept harmless mismatch in first argument type also.
1513 This is for the ffs and fprintf builtins. */
1514 if (TYPE_ARG_TYPES (TREE_TYPE (newdecl)) != 0
1515 && TYPE_ARG_TYPES (oldtype) != 0
1516 && TREE_VALUE (TYPE_ARG_TYPES (newtype)) != 0
1517 && TREE_VALUE (TYPE_ARG_TYPES (oldtype)) != 0
1518 && (TYPE_MODE (TREE_VALUE (TYPE_ARG_TYPES (newtype)))
1519 == TYPE_MODE (TREE_VALUE (TYPE_ARG_TYPES (oldtype)))))
1521 /* Function types may be shared, so we can't just modify
1522 the return type of olddecl's function type. */
1524 = build_function_type (TREE_TYPE (oldtype),
1525 tree_cons (NULL_TREE,
1526 TREE_VALUE (TYPE_ARG_TYPES (newtype)),
1527 TREE_CHAIN (TYPE_ARG_TYPES (oldtype))));
1528 trytype = build_type_attribute_variant (trytype,
1529 TYPE_ATTRIBUTES (oldtype));
1531 types_match = comptypes (newtype, trytype);
1535 if (! different_binding_level)
1536 TREE_TYPE (olddecl) = oldtype;
1540 /* If types don't match for a built-in, throw away the built-in. */
1541 warning_with_decl (newdecl, "conflicting types for built-in function `%s'");
1545 else if (TREE_CODE (olddecl) == FUNCTION_DECL
1546 && DECL_SOURCE_LINE (olddecl) == 0)
1548 /* A function declaration for a predeclared function
1549 that isn't actually built in. */
1550 if (!TREE_PUBLIC (newdecl))
1552 /* If you declare it as static, the
1553 default definition is overridden. */
1556 else if (!types_match)
1558 /* If the types don't match, preserve volatility indication.
1559 Later on, we will discard everything else about the
1560 default declaration. */
1561 TREE_THIS_VOLATILE (newdecl) |= TREE_THIS_VOLATILE (olddecl);
1564 /* Permit char *foo () to match void *foo (...) if not pedantic,
1565 if one of them came from a system header file. */
1566 else if (!types_match
1567 && TREE_CODE (olddecl) == FUNCTION_DECL
1568 && TREE_CODE (newdecl) == FUNCTION_DECL
1569 && TREE_CODE (TREE_TYPE (oldtype)) == POINTER_TYPE
1570 && TREE_CODE (TREE_TYPE (newtype)) == POINTER_TYPE
1571 && (DECL_IN_SYSTEM_HEADER (olddecl)
1572 || DECL_IN_SYSTEM_HEADER (newdecl))
1573 && ((TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (newtype))) == void_type_node
1574 && TYPE_ARG_TYPES (oldtype) == 0
1575 && self_promoting_args_p (TYPE_ARG_TYPES (newtype))
1576 && TREE_TYPE (TREE_TYPE (oldtype)) == char_type_node)
1578 (TREE_TYPE (TREE_TYPE (newtype)) == char_type_node
1579 && TYPE_ARG_TYPES (newtype) == 0
1580 && self_promoting_args_p (TYPE_ARG_TYPES (oldtype))
1581 && TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (oldtype))) == void_type_node)))
1584 pedwarn_with_decl (newdecl, "conflicting types for `%s'");
1585 /* Make sure we keep void * as ret type, not char *. */
1586 if (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (oldtype))) == void_type_node)
1587 TREE_TYPE (newdecl) = newtype = oldtype;
1589 /* Set DECL_IN_SYSTEM_HEADER, so that if we see another declaration
1590 we will come back here again. */
1591 DECL_IN_SYSTEM_HEADER (newdecl) = 1;
1593 else if (!types_match
1594 /* Permit char *foo (int, ...); followed by char *foo ();
1596 && ! (TREE_CODE (olddecl) == FUNCTION_DECL
1598 /* Return types must still match. */
1599 && comptypes (TREE_TYPE (oldtype),
1600 TREE_TYPE (newtype))
1601 && TYPE_ARG_TYPES (newtype) == 0))
1603 error_with_decl (newdecl, "conflicting types for `%s'");
1604 /* Check for function type mismatch
1605 involving an empty arglist vs a nonempty one. */
1606 if (TREE_CODE (olddecl) == FUNCTION_DECL
1607 && comptypes (TREE_TYPE (oldtype),
1608 TREE_TYPE (newtype))
1609 && ((TYPE_ARG_TYPES (oldtype) == 0
1610 && DECL_INITIAL (olddecl) == 0)
1612 (TYPE_ARG_TYPES (newtype) == 0
1613 && DECL_INITIAL (newdecl) == 0)))
1615 /* Classify the problem further. */
1616 tree t = TYPE_ARG_TYPES (oldtype);
1618 t = TYPE_ARG_TYPES (newtype);
1619 for (; t; t = TREE_CHAIN (t))
1621 tree type = TREE_VALUE (t);
1623 if (TREE_CHAIN (t) == 0
1624 && TYPE_MAIN_VARIANT (type) != void_type_node)
1626 error ("a parameter list with an ellipsis can't match an empty parameter name list declaration");
1630 if (simple_type_promotes_to (type) != NULL_TREE)
1632 error ("an argument type that has a default promotion can't match an empty parameter name list declaration");
1637 error_with_decl (olddecl, "previous declaration of `%s'");
1641 errmsg = redeclaration_error_message (newdecl, olddecl);
1647 error_with_decl (newdecl, "redefinition of `%s'");
1650 error_with_decl (newdecl, "redeclaration of `%s'");
1653 error_with_decl (newdecl, "conflicting declarations of `%s'");
1659 error_with_decl (olddecl,
1660 ((DECL_INITIAL (olddecl)
1661 && current_binding_level == global_binding_level)
1662 ? "`%s' previously defined here"
1663 : "`%s' previously declared here"));
1665 else if (TREE_CODE (newdecl) == TYPE_DECL
1666 && (DECL_IN_SYSTEM_HEADER (olddecl)
1667 || DECL_IN_SYSTEM_HEADER (newdecl)))
1669 warning_with_decl (newdecl, "redefinition of `%s'");
1672 ((DECL_INITIAL (olddecl)
1673 && current_binding_level == global_binding_level)
1674 ? "`%s' previously defined here"
1675 : "`%s' previously declared here"));
1677 else if (TREE_CODE (olddecl) == FUNCTION_DECL
1678 && DECL_INITIAL (olddecl) != 0
1679 && TYPE_ARG_TYPES (oldtype) == 0
1680 && TYPE_ARG_TYPES (newtype) != 0
1681 && TYPE_ACTUAL_ARG_TYPES (oldtype) != 0)
1685 /* Prototype decl follows defn w/o prototype. */
1687 for (parm = TYPE_ACTUAL_ARG_TYPES (oldtype),
1688 type = TYPE_ARG_TYPES (newtype),
1691 parm = TREE_CHAIN (parm), type = TREE_CHAIN (type), nargs++)
1693 if (TYPE_MAIN_VARIANT (TREE_VALUE (parm)) == void_type_node
1694 && TYPE_MAIN_VARIANT (TREE_VALUE (type)) == void_type_node)
1696 warning_with_decl (newdecl, "prototype for `%s' follows");
1697 warning_with_decl (olddecl, "non-prototype definition here");
1700 if (TYPE_MAIN_VARIANT (TREE_VALUE (parm)) == void_type_node
1701 || TYPE_MAIN_VARIANT (TREE_VALUE (type)) == void_type_node)
1703 error_with_decl (newdecl,
1704 "prototype for `%s' follows and number of arguments doesn't match");
1705 error_with_decl (olddecl, "non-prototype definition here");
1709 /* Type for passing arg must be consistent
1710 with that declared for the arg. */
1711 if (! comptypes (TREE_VALUE (parm), TREE_VALUE (type))
1712 /* If -traditional, allow `unsigned int' instead of `int'
1713 in the prototype. */
1714 && (! (flag_traditional
1715 && TYPE_MAIN_VARIANT (TREE_VALUE (parm)) == integer_type_node
1716 && TYPE_MAIN_VARIANT (TREE_VALUE (type)) == unsigned_type_node)))
1718 error_with_decl (newdecl,
1719 "prototype for `%s' follows and argument %d doesn't match",
1721 error_with_decl (olddecl, "non-prototype definition here");
1727 /* Warn about mismatches in various flags. */
1730 /* Warn if function is now inline
1731 but was previously declared not inline and has been called. */
1732 if (TREE_CODE (olddecl) == FUNCTION_DECL
1733 && ! DECL_DECLARED_INLINE_P (olddecl)
1734 && DECL_DECLARED_INLINE_P (newdecl)
1735 && TREE_USED (olddecl))
1736 warning_with_decl (newdecl,
1737 "`%s' declared inline after being called");
1738 if (TREE_CODE (olddecl) == FUNCTION_DECL
1739 && ! DECL_DECLARED_INLINE_P (olddecl)
1740 && DECL_DECLARED_INLINE_P (newdecl)
1741 && DECL_INITIAL (olddecl) != 0)
1742 warning_with_decl (newdecl,
1743 "`%s' declared inline after its definition");
1745 /* If pedantic, warn when static declaration follows a non-static
1746 declaration. Otherwise, do so only for functions. */
1747 if ((pedantic || TREE_CODE (olddecl) == FUNCTION_DECL)
1748 && TREE_PUBLIC (olddecl)
1749 && !TREE_PUBLIC (newdecl))
1750 warning_with_decl (newdecl, "static declaration for `%s' follows non-static");
1752 /* If warn_traditional, warn when a non-static function
1753 declaration follows a static one. */
1754 if (warn_traditional && !in_system_header
1755 && TREE_CODE (olddecl) == FUNCTION_DECL
1756 && !TREE_PUBLIC (olddecl)
1757 && TREE_PUBLIC (newdecl))
1758 warning_with_decl (newdecl, "non-static declaration for `%s' follows static");
1760 /* Warn when const declaration follows a non-const
1761 declaration, but not for functions. */
1762 if (TREE_CODE (olddecl) != FUNCTION_DECL
1763 && !TREE_READONLY (olddecl)
1764 && TREE_READONLY (newdecl))
1765 warning_with_decl (newdecl, "const declaration for `%s' follows non-const");
1766 /* These bits are logically part of the type, for variables.
1767 But not for functions
1768 (where qualifiers are not valid ANSI anyway). */
1769 else if (pedantic && TREE_CODE (olddecl) != FUNCTION_DECL
1770 && (TREE_READONLY (newdecl) != TREE_READONLY (olddecl)
1771 || TREE_THIS_VOLATILE (newdecl) != TREE_THIS_VOLATILE (olddecl)))
1772 pedwarn_with_decl (newdecl, "type qualifiers for `%s' conflict with previous decl");
1776 /* Optionally warn about more than one declaration for the same name. */
1777 if (errmsg == 0 && warn_redundant_decls && DECL_SOURCE_LINE (olddecl) != 0
1778 /* Don't warn about a function declaration
1779 followed by a definition. */
1780 && !(TREE_CODE (newdecl) == FUNCTION_DECL && DECL_INITIAL (newdecl) != 0
1781 && DECL_INITIAL (olddecl) == 0)
1782 /* Don't warn about extern decl followed by (tentative) definition. */
1783 && !(DECL_EXTERNAL (olddecl) && ! DECL_EXTERNAL (newdecl)))
1785 warning_with_decl (newdecl, "redundant redeclaration of `%s' in same scope");
1786 warning_with_decl (olddecl, "previous declaration of `%s'");
1789 /* Copy all the DECL_... slots specified in the new decl
1790 except for any that we copy here from the old type.
1792 Past this point, we don't change OLDTYPE and NEWTYPE
1793 even if we change the types of NEWDECL and OLDDECL. */
1797 /* When copying info to olddecl, we store into write_olddecl
1798 instead. This allows us to avoid modifying olddecl when
1799 different_binding_level is true. */
1800 tree write_olddecl = different_binding_level ? newdecl : olddecl;
1802 /* Merge the data types specified in the two decls. */
1803 if (TREE_CODE (newdecl) != FUNCTION_DECL || !DECL_BUILT_IN (olddecl))
1805 if (different_binding_level)
1807 if (TYPE_ARG_TYPES (oldtype) != 0
1808 && TYPE_ARG_TYPES (newtype) == 0)
1809 TREE_TYPE (newdecl) = common_type (newtype, oldtype);
1812 = build_type_attribute_variant
1814 merge_attributes (TYPE_ATTRIBUTES (newtype),
1815 TYPE_ATTRIBUTES (oldtype)));
1819 = TREE_TYPE (olddecl)
1820 = common_type (newtype, oldtype);
1823 /* Lay the type out, unless already done. */
1824 if (oldtype != TREE_TYPE (newdecl))
1826 if (TREE_TYPE (newdecl) != error_mark_node)
1827 layout_type (TREE_TYPE (newdecl));
1828 if (TREE_CODE (newdecl) != FUNCTION_DECL
1829 && TREE_CODE (newdecl) != TYPE_DECL
1830 && TREE_CODE (newdecl) != CONST_DECL)
1831 layout_decl (newdecl, 0);
1835 /* Since the type is OLDDECL's, make OLDDECL's size go with. */
1836 DECL_SIZE (newdecl) = DECL_SIZE (olddecl);
1837 DECL_SIZE_UNIT (newdecl) = DECL_SIZE_UNIT (olddecl);
1838 DECL_MODE (newdecl) = DECL_MODE (olddecl);
1839 if (TREE_CODE (olddecl) != FUNCTION_DECL)
1840 if (DECL_ALIGN (olddecl) > DECL_ALIGN (newdecl))
1842 DECL_ALIGN (newdecl) = DECL_ALIGN (olddecl);
1843 DECL_USER_ALIGN (newdecl) |= DECL_ALIGN (olddecl);
1847 /* Keep the old rtl since we can safely use it. */
1848 COPY_DECL_RTL (olddecl, newdecl);
1850 /* Merge the type qualifiers. */
1851 if (TREE_CODE (olddecl) == FUNCTION_DECL
1852 && DECL_BUILT_IN_NONANSI (olddecl) && TREE_THIS_VOLATILE (olddecl)
1853 && ! TREE_THIS_VOLATILE (newdecl))
1854 TREE_THIS_VOLATILE (write_olddecl) = 0;
1856 if (TREE_READONLY (newdecl))
1857 TREE_READONLY (write_olddecl) = 1;
1859 if (TREE_THIS_VOLATILE (newdecl))
1861 TREE_THIS_VOLATILE (write_olddecl) = 1;
1862 if (TREE_CODE (newdecl) == VAR_DECL
1863 /* If an automatic variable is re-declared in the same
1864 function scope, but the old declaration was not
1865 volatile, make_var_volatile() would crash because the
1866 variable would have been assigned to a pseudo, not a
1867 MEM. Since this duplicate declaration is invalid
1868 anyway, we just skip the call. */
1870 make_var_volatile (newdecl);
1873 /* Keep source location of definition rather than declaration. */
1874 /* When called with different_binding_level set, keep the old
1875 information so that meaningful diagnostics can be given. */
1876 if (DECL_INITIAL (newdecl) == 0 && DECL_INITIAL (olddecl) != 0
1877 && ! different_binding_level)
1879 DECL_SOURCE_LINE (newdecl) = DECL_SOURCE_LINE (olddecl);
1880 DECL_SOURCE_FILE (newdecl) = DECL_SOURCE_FILE (olddecl);
1883 /* Merge the unused-warning information. */
1884 if (DECL_IN_SYSTEM_HEADER (olddecl))
1885 DECL_IN_SYSTEM_HEADER (newdecl) = 1;
1886 else if (DECL_IN_SYSTEM_HEADER (newdecl))
1887 DECL_IN_SYSTEM_HEADER (write_olddecl) = 1;
1889 /* Merge the initialization information. */
1890 /* When called with different_binding_level set, don't copy over
1891 DECL_INITIAL, so that we don't accidentally change function
1892 declarations into function definitions. */
1893 if (DECL_INITIAL (newdecl) == 0 && ! different_binding_level)
1894 DECL_INITIAL (newdecl) = DECL_INITIAL (olddecl);
1896 /* Merge the section attribute.
1897 We want to issue an error if the sections conflict but that must be
1898 done later in decl_attributes since we are called before attributes
1900 if (DECL_SECTION_NAME (newdecl) == NULL_TREE)
1901 DECL_SECTION_NAME (newdecl) = DECL_SECTION_NAME (olddecl);
1903 /* Copy the assembler name.
1904 Currently, it can only be defined in the prototype. */
1905 COPY_DECL_ASSEMBLER_NAME (olddecl, newdecl);
1907 if (TREE_CODE (newdecl) == FUNCTION_DECL)
1909 DECL_STATIC_CONSTRUCTOR(newdecl) |= DECL_STATIC_CONSTRUCTOR(olddecl);
1910 DECL_STATIC_DESTRUCTOR (newdecl) |= DECL_STATIC_DESTRUCTOR (olddecl);
1911 DECL_NO_LIMIT_STACK (newdecl) |= DECL_NO_LIMIT_STACK (olddecl);
1912 DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (newdecl)
1913 |= DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (olddecl);
1916 /* If cannot merge, then use the new type and qualifiers,
1917 and don't preserve the old rtl. */
1918 else if (! different_binding_level)
1920 TREE_TYPE (olddecl) = TREE_TYPE (newdecl);
1921 TREE_READONLY (olddecl) = TREE_READONLY (newdecl);
1922 TREE_THIS_VOLATILE (olddecl) = TREE_THIS_VOLATILE (newdecl);
1923 TREE_SIDE_EFFECTS (olddecl) = TREE_SIDE_EFFECTS (newdecl);
1926 /* Merge the storage class information. */
1927 DECL_WEAK (newdecl) |= DECL_WEAK (olddecl);
1928 /* For functions, static overrides non-static. */
1929 if (TREE_CODE (newdecl) == FUNCTION_DECL)
1931 TREE_PUBLIC (newdecl) &= TREE_PUBLIC (olddecl);
1932 /* This is since we don't automatically
1933 copy the attributes of NEWDECL into OLDDECL. */
1934 /* No need to worry about different_binding_level here because
1935 then TREE_PUBLIC (newdecl) was true. */
1936 TREE_PUBLIC (olddecl) = TREE_PUBLIC (newdecl);
1937 /* If this clears `static', clear it in the identifier too. */
1938 if (! TREE_PUBLIC (olddecl))
1939 TREE_PUBLIC (DECL_NAME (olddecl)) = 0;
1941 if (DECL_EXTERNAL (newdecl))
1943 if (! different_binding_level)
1945 /* Don't mess with these flags on local externs; they remain
1946 external even if there's a declaration at file scope which
1948 TREE_STATIC (newdecl) = TREE_STATIC (olddecl);
1949 DECL_EXTERNAL (newdecl) = DECL_EXTERNAL (olddecl);
1951 /* An extern decl does not override previous storage class. */
1952 TREE_PUBLIC (newdecl) = TREE_PUBLIC (olddecl);
1953 if (! DECL_EXTERNAL (newdecl))
1954 DECL_CONTEXT (newdecl) = DECL_CONTEXT (olddecl);
1958 TREE_STATIC (olddecl) = TREE_STATIC (newdecl);
1959 TREE_PUBLIC (olddecl) = TREE_PUBLIC (newdecl);
1962 if (TREE_CODE (newdecl) == FUNCTION_DECL)
1964 /* If we're redefining a function previously defined as extern
1965 inline, make sure we emit debug info for the inline before we
1966 throw it away, in case it was inlined into a function that hasn't
1967 been written out yet. */
1968 if (new_is_definition && DECL_INITIAL (olddecl) && TREE_USED (olddecl))
1970 (*debug_hooks->outlining_inline_function) (olddecl);
1972 /* The new defn must not be inline. */
1973 DECL_INLINE (newdecl) = 0;
1974 DECL_UNINLINABLE (newdecl) = 1;
1978 /* If either decl says `inline', this fn is inline,
1979 unless its definition was passed already. */
1980 if (DECL_DECLARED_INLINE_P (newdecl)
1981 && DECL_DECLARED_INLINE_P (olddecl) == 0)
1982 DECL_DECLARED_INLINE_P (olddecl) = 1;
1984 DECL_DECLARED_INLINE_P (newdecl) = DECL_DECLARED_INLINE_P (olddecl);
1986 DECL_UNINLINABLE (newdecl) = DECL_UNINLINABLE (olddecl)
1987 = (DECL_UNINLINABLE (newdecl) || DECL_UNINLINABLE (olddecl));
1990 if (DECL_BUILT_IN (olddecl))
1992 /* Get rid of any built-in function if new arg types don't match it
1993 or if we have a function definition. */
1994 if (! types_match || new_is_definition)
1996 if (! different_binding_level)
1998 TREE_TYPE (olddecl) = TREE_TYPE (newdecl);
1999 DECL_BUILT_IN_CLASS (olddecl) = NOT_BUILT_IN;
2004 /* If redeclaring a builtin function, and not a definition,
2005 it stays built in. */
2006 DECL_BUILT_IN_CLASS (newdecl) = DECL_BUILT_IN_CLASS (olddecl);
2007 DECL_FUNCTION_CODE (newdecl) = DECL_FUNCTION_CODE (olddecl);
2010 /* Also preserve various other info from the definition. */
2011 else if (! new_is_definition)
2012 DECL_NUM_STMTS (newdecl) = DECL_NUM_STMTS (olddecl);
2013 if (! new_is_definition)
2015 DECL_RESULT (newdecl) = DECL_RESULT (olddecl);
2016 /* When called with different_binding_level set, don't copy over
2017 DECL_INITIAL, so that we don't accidentally change function
2018 declarations into function definitions. */
2019 if (! different_binding_level)
2020 DECL_INITIAL (newdecl) = DECL_INITIAL (olddecl);
2021 DECL_SAVED_INSNS (newdecl) = DECL_SAVED_INSNS (olddecl);
2022 DECL_SAVED_TREE (newdecl) = DECL_SAVED_TREE (olddecl);
2023 DECL_ARGUMENTS (newdecl) = DECL_ARGUMENTS (olddecl);
2024 if (DECL_INLINE (newdecl))
2025 DECL_ABSTRACT_ORIGIN (newdecl)
2026 = (different_binding_level
2027 ? DECL_ORIGIN (olddecl)
2028 : DECL_ABSTRACT_ORIGIN (olddecl));
2031 if (different_binding_level)
2034 /* Copy most of the decl-specific fields of NEWDECL into OLDDECL.
2035 But preserve OLDDECL's DECL_UID. */
2037 unsigned olddecl_uid = DECL_UID (olddecl);
2039 memcpy ((char *) olddecl + sizeof (struct tree_common),
2040 (char *) newdecl + sizeof (struct tree_common),
2041 sizeof (struct tree_decl) - sizeof (struct tree_common));
2042 DECL_UID (olddecl) = olddecl_uid;
2045 /* NEWDECL contains the merged attribute lists.
2046 Update OLDDECL to be the same. */
2047 DECL_ATTRIBUTES (olddecl) = DECL_ATTRIBUTES (newdecl);
2052 /* Check whether decl-node X shadows an existing declaration.
2053 OLDLOCAL is the old IDENTIFIER_LOCAL_VALUE of the DECL_NAME of X,
2054 which might be a NULL_TREE. */
2056 warn_if_shadowing (x, oldlocal)
2061 if (DECL_EXTERNAL (x))
2064 name = DECL_NAME (x);
2066 /* Warn if shadowing an argument at the top level of the body. */
2068 /* This warning doesn't apply to the parms of a nested fcn. */
2069 && ! current_binding_level->parm_flag
2070 /* Check that this is one level down from the parms. */
2071 && current_binding_level->level_chain->parm_flag
2072 /* Check that the decl being shadowed
2073 comes from the parm level, one level up. */
2074 && chain_member (oldlocal, current_binding_level->level_chain->names))
2076 if (TREE_CODE (oldlocal) == PARM_DECL)
2077 pedwarn ("declaration of `%s' shadows a parameter",
2078 IDENTIFIER_POINTER (name));
2080 pedwarn ("declaration of `%s' shadows a symbol from the parameter list",
2081 IDENTIFIER_POINTER (name));
2083 /* Maybe warn if shadowing something else. */
2084 else if (warn_shadow
2085 /* No shadow warnings for internally generated vars. */
2086 && DECL_SOURCE_LINE (x) != 0
2087 /* No shadow warnings for vars made for inlining. */
2088 && ! DECL_FROM_INLINE (x))
2090 if (TREE_CODE (x) == PARM_DECL
2091 && current_binding_level->level_chain->parm_flag)
2092 /* Don't warn about the parm names in function declarator
2093 within a function declarator.
2094 It would be nice to avoid warning in any function
2095 declarator in a declaration, as opposed to a definition,
2096 but there is no way to tell it's not a definition. */
2100 if (TREE_CODE (oldlocal) == PARM_DECL)
2101 shadow_warning ("a parameter", name, oldlocal);
2103 shadow_warning ("a previous local", name, oldlocal);
2105 else if (IDENTIFIER_GLOBAL_VALUE (name) != 0
2106 && IDENTIFIER_GLOBAL_VALUE (name) != error_mark_node)
2107 shadow_warning ("a global declaration", name,
2108 IDENTIFIER_GLOBAL_VALUE (name));
2112 /* Record a decl-node X as belonging to the current lexical scope.
2113 Check for errors (such as an incompatible declaration for the same
2114 name already seen in the same scope).
2116 Returns either X or an old decl for the same name.
2117 If an old decl is returned, it may have been smashed
2118 to agree with what X says. */
2125 tree name = DECL_NAME (x);
2126 struct binding_level *b = current_binding_level;
2128 /* Functions need the lang_decl data. */
2129 if (TREE_CODE (x) == FUNCTION_DECL && ! DECL_LANG_SPECIFIC (x))
2130 DECL_LANG_SPECIFIC (x) = (struct lang_decl *)
2131 ggc_alloc_cleared (sizeof (struct lang_decl));
2133 DECL_CONTEXT (x) = current_function_decl;
2134 /* A local extern declaration for a function doesn't constitute nesting.
2135 A local auto declaration does, since it's a forward decl
2136 for a nested function coming later. */
2137 if ((TREE_CODE (x) == FUNCTION_DECL || TREE_CODE (x) == VAR_DECL)
2138 && DECL_INITIAL (x) == 0 && DECL_EXTERNAL (x))
2139 DECL_CONTEXT (x) = 0;
2143 int different_binding_level = 0;
2145 if (warn_nested_externs
2146 && DECL_EXTERNAL (x)
2147 && b != global_binding_level
2148 && x != IDENTIFIER_IMPLICIT_DECL (name)
2149 /* No error messages for __FUNCTION__ and __PRETTY_FUNCTION__. */
2150 && !DECL_IN_SYSTEM_HEADER (x))
2151 warning ("nested extern declaration of `%s'",
2152 IDENTIFIER_POINTER (name));
2154 t = lookup_name_current_level (name);
2155 /* Don't type check externs here when -traditional. This is so that
2156 code with conflicting declarations inside blocks will get warnings
2157 not errors. X11 for instance depends on this. */
2158 if (! t && DECL_EXTERNAL (x) && TREE_PUBLIC (x) && ! flag_traditional)
2160 t = lookup_name (name);
2161 /* Type decls at global scope don't conflict with externs declared
2162 inside lexical blocks. */
2163 if (t && TREE_CODE (t) == TYPE_DECL)
2165 different_binding_level = 1;
2167 if (t != 0 && t == error_mark_node)
2168 /* error_mark_node is 0 for a while during initialization! */
2171 error_with_decl (x, "`%s' used prior to declaration");
2174 /* If this decl is `static' and an implicit decl was seen previously,
2175 warn. But don't complain if -traditional,
2176 since traditional compilers don't complain. */
2177 if (! flag_traditional && TREE_PUBLIC (name)
2178 /* Don't test for DECL_EXTERNAL, because grokdeclarator
2179 sets this for all functions. */
2180 && ! TREE_PUBLIC (x)
2181 && (TREE_CODE (x) == FUNCTION_DECL || b == global_binding_level)
2182 /* We used to warn also for explicit extern followed by static,
2183 but sometimes you need to do it that way. */
2184 && IDENTIFIER_IMPLICIT_DECL (name) != 0)
2186 pedwarn ("`%s' was declared implicitly `extern' and later `static'",
2187 IDENTIFIER_POINTER (name));
2188 pedwarn_with_file_and_line
2189 (DECL_SOURCE_FILE (IDENTIFIER_IMPLICIT_DECL (name)),
2190 DECL_SOURCE_LINE (IDENTIFIER_IMPLICIT_DECL (name)),
2191 "previous declaration of `%s'",
2192 IDENTIFIER_POINTER (name));
2193 TREE_THIS_VOLATILE (name) = 1;
2196 if (t != 0 && duplicate_decls (x, t, different_binding_level))
2198 if (TREE_CODE (t) == PARM_DECL)
2200 /* Don't allow more than one "real" duplicate
2201 of a forward parm decl. */
2202 TREE_ASM_WRITTEN (t) = TREE_ASM_WRITTEN (x);
2208 /* If we are processing a typedef statement, generate a whole new
2209 ..._TYPE node (which will be just an variant of the existing
2210 ..._TYPE node with identical properties) and then install the
2211 TYPE_DECL node generated to represent the typedef name as the
2212 TYPE_NAME of this brand new (duplicate) ..._TYPE node.
2214 The whole point here is to end up with a situation where each
2215 and every ..._TYPE node the compiler creates will be uniquely
2216 associated with AT MOST one node representing a typedef name.
2217 This way, even though the compiler substitutes corresponding
2218 ..._TYPE nodes for TYPE_DECL (i.e. "typedef name") nodes very
2219 early on, later parts of the compiler can always do the reverse
2220 translation and get back the corresponding typedef name. For
2223 typedef struct S MY_TYPE;
2226 Later parts of the compiler might only know that `object' was of
2227 type `struct S' if it were not for code just below. With this
2228 code however, later parts of the compiler see something like:
2230 struct S' == struct S
2231 typedef struct S' MY_TYPE;
2234 And they can then deduce (from the node for type struct S') that
2235 the original object declaration was:
2239 Being able to do this is important for proper support of protoize,
2240 and also for generating precise symbolic debugging information
2241 which takes full account of the programmer's (typedef) vocabulary.
2243 Obviously, we don't want to generate a duplicate ..._TYPE node if
2244 the TYPE_DECL node that we are now processing really represents a
2245 standard built-in type.
2247 Since all standard types are effectively declared at line zero
2248 in the source file, we can easily check to see if we are working
2249 on a standard type by checking the current value of lineno. */
2251 if (TREE_CODE (x) == TYPE_DECL)
2253 if (DECL_SOURCE_LINE (x) == 0)
2255 if (TYPE_NAME (TREE_TYPE (x)) == 0)
2256 TYPE_NAME (TREE_TYPE (x)) = x;
2258 else if (TREE_TYPE (x) != error_mark_node
2259 && DECL_ORIGINAL_TYPE (x) == NULL_TREE)
2261 tree tt = TREE_TYPE (x);
2262 DECL_ORIGINAL_TYPE (x) = tt;
2263 tt = build_type_copy (tt);
2265 TREE_USED (tt) = TREE_USED (x);
2270 /* Multiple external decls of the same identifier ought to match.
2271 Check against both global declarations (when traditional) and out of
2272 scope (limbo) block level declarations.
2274 We get warnings about inline functions where they are defined.
2275 Avoid duplicate warnings where they are used. */
2277 && ! (TREE_CODE (x) == FUNCTION_DECL && DECL_INLINE (x)))
2281 if (flag_traditional && IDENTIFIER_GLOBAL_VALUE (name) != 0
2282 && (DECL_EXTERNAL (IDENTIFIER_GLOBAL_VALUE (name))
2283 || TREE_PUBLIC (IDENTIFIER_GLOBAL_VALUE (name))))
2284 decl = IDENTIFIER_GLOBAL_VALUE (name);
2285 else if (IDENTIFIER_LIMBO_VALUE (name) != 0)
2286 /* Decls in limbo are always extern, so no need to check that. */
2287 decl = IDENTIFIER_LIMBO_VALUE (name);
2291 if (decl && ! comptypes (TREE_TYPE (x), TREE_TYPE (decl))
2292 /* If old decl is built-in, we already warned if we should. */
2293 && !DECL_BUILT_IN (decl))
2295 pedwarn_with_decl (x,
2296 "type mismatch with previous external decl");
2297 pedwarn_with_decl (decl, "previous external decl of `%s'");
2301 /* If a function has had an implicit declaration, and then is defined,
2302 make sure they are compatible. */
2304 if (IDENTIFIER_IMPLICIT_DECL (name) != 0
2305 && IDENTIFIER_GLOBAL_VALUE (name) == 0
2306 && TREE_CODE (x) == FUNCTION_DECL
2307 && ! comptypes (TREE_TYPE (x),
2308 TREE_TYPE (IDENTIFIER_IMPLICIT_DECL (name))))
2310 warning_with_decl (x, "type mismatch with previous implicit declaration");
2311 warning_with_decl (IDENTIFIER_IMPLICIT_DECL (name),
2312 "previous implicit declaration of `%s'");
2315 /* In PCC-compatibility mode, extern decls of vars with no current decl
2316 take effect at top level no matter where they are. */
2317 if (flag_traditional && DECL_EXTERNAL (x)
2318 && lookup_name (name) == 0)
2320 tree type = TREE_TYPE (x);
2322 /* But don't do this if the type contains temporary nodes. */
2325 if (type == error_mark_node)
2327 if (TYPE_CONTEXT (type))
2329 warning_with_decl (x, "type of external `%s' is not global");
2330 /* By exiting the loop early, we leave TYPE nonzero,
2331 and thus prevent globalization of the decl. */
2334 else if (TREE_CODE (type) == FUNCTION_TYPE
2335 && TYPE_ARG_TYPES (type) != 0)
2336 /* The types might not be truly local,
2337 but the list of arg types certainly is temporary.
2338 Since prototypes are nontraditional,
2339 ok not to do the traditional thing. */
2341 type = TREE_TYPE (type);
2345 b = global_binding_level;
2348 /* This name is new in its binding level.
2349 Install the new declaration and return it. */
2350 if (b == global_binding_level)
2352 /* Install a global value. */
2354 /* If the first global decl has external linkage,
2355 warn if we later see static one. */
2356 if (IDENTIFIER_GLOBAL_VALUE (name) == 0 && TREE_PUBLIC (x))
2357 TREE_PUBLIC (name) = 1;
2359 IDENTIFIER_GLOBAL_VALUE (name) = x;
2361 /* We no longer care about any previous block level declarations. */
2362 IDENTIFIER_LIMBO_VALUE (name) = 0;
2364 /* Don't forget if the function was used via an implicit decl. */
2365 if (IDENTIFIER_IMPLICIT_DECL (name)
2366 && TREE_USED (IDENTIFIER_IMPLICIT_DECL (name)))
2367 TREE_USED (x) = 1, TREE_USED (name) = 1;
2369 /* Don't forget if its address was taken in that way. */
2370 if (IDENTIFIER_IMPLICIT_DECL (name)
2371 && TREE_ADDRESSABLE (IDENTIFIER_IMPLICIT_DECL (name)))
2372 TREE_ADDRESSABLE (x) = 1;
2374 /* Warn about mismatches against previous implicit decl. */
2375 if (IDENTIFIER_IMPLICIT_DECL (name) != 0
2376 /* If this real decl matches the implicit, don't complain. */
2377 && ! (TREE_CODE (x) == FUNCTION_DECL
2378 && (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (x)))
2379 == integer_type_node)))
2380 pedwarn ("`%s' was previously implicitly declared to return `int'",
2381 IDENTIFIER_POINTER (name));
2383 /* If this decl is `static' and an `extern' was seen previously,
2384 that is erroneous. */
2385 if (TREE_PUBLIC (name)
2386 && ! TREE_PUBLIC (x) && ! DECL_EXTERNAL (x))
2388 /* Okay to redeclare an ANSI built-in as static. */
2389 if (t != 0 && DECL_BUILT_IN (t))
2391 /* Okay to declare a non-ANSI built-in as anything. */
2392 else if (t != 0 && DECL_BUILT_IN_NONANSI (t))
2394 /* Okay to have global type decl after an earlier extern
2395 declaration inside a lexical block. */
2396 else if (TREE_CODE (x) == TYPE_DECL)
2398 else if (IDENTIFIER_IMPLICIT_DECL (name))
2400 if (! TREE_THIS_VOLATILE (name))
2401 pedwarn ("`%s' was declared implicitly `extern' and later `static'",
2402 IDENTIFIER_POINTER (name));
2405 pedwarn ("`%s' was declared `extern' and later `static'",
2406 IDENTIFIER_POINTER (name));
2411 /* Here to install a non-global value. */
2412 tree oldlocal = IDENTIFIER_LOCAL_VALUE (name);
2413 tree oldglobal = IDENTIFIER_GLOBAL_VALUE (name);
2415 IDENTIFIER_LOCAL_VALUE (name) = x;
2417 /* If this is an extern function declaration, see if we
2418 have a global definition or declaration for the function. */
2421 && TREE_CODE (x) == FUNCTION_DECL
2422 && TREE_CODE (oldglobal) == FUNCTION_DECL
2423 && DECL_EXTERNAL (x)
2424 && ! DECL_DECLARED_INLINE_P (x))
2426 /* We have one. Their types must agree. */
2427 if (! comptypes (TREE_TYPE (x),
2428 TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (name))))
2429 pedwarn_with_decl (x, "extern declaration of `%s' doesn't match global one");
2432 /* Inner extern decl is inline if global one is.
2433 Copy enough to really inline it. */
2434 if (DECL_DECLARED_INLINE_P (oldglobal))
2436 DECL_DECLARED_INLINE_P (x)
2437 = DECL_DECLARED_INLINE_P (oldglobal);
2438 DECL_INLINE (x) = DECL_INLINE (oldglobal);
2439 DECL_INITIAL (x) = (current_function_decl == oldglobal
2440 ? 0 : DECL_INITIAL (oldglobal));
2441 DECL_SAVED_INSNS (x) = DECL_SAVED_INSNS (oldglobal);
2442 DECL_NUM_STMTS (x) = DECL_NUM_STMTS (oldglobal);
2443 DECL_ARGUMENTS (x) = DECL_ARGUMENTS (oldglobal);
2444 DECL_RESULT (x) = DECL_RESULT (oldglobal);
2445 TREE_ASM_WRITTEN (x) = TREE_ASM_WRITTEN (oldglobal);
2446 DECL_ABSTRACT_ORIGIN (x)
2447 = DECL_ABSTRACT_ORIGIN (oldglobal);
2449 /* Inner extern decl is built-in if global one is. */
2450 if (DECL_BUILT_IN (oldglobal))
2452 DECL_BUILT_IN_CLASS (x) = DECL_BUILT_IN_CLASS (oldglobal);
2453 DECL_FUNCTION_CODE (x) = DECL_FUNCTION_CODE (oldglobal);
2455 /* Keep the arg types from a file-scope fcn defn. */
2456 if (TYPE_ARG_TYPES (TREE_TYPE (oldglobal)) != 0
2457 && DECL_INITIAL (oldglobal)
2458 && TYPE_ARG_TYPES (TREE_TYPE (x)) == 0)
2459 TREE_TYPE (x) = TREE_TYPE (oldglobal);
2464 /* This case is probably sometimes the right thing to do. */
2465 /* If we have a local external declaration,
2466 then any file-scope declaration should not
2467 have been static. */
2468 if (oldlocal == 0 && oldglobal != 0
2469 && !TREE_PUBLIC (oldglobal)
2470 && DECL_EXTERNAL (x) && TREE_PUBLIC (x))
2471 warning ("`%s' locally external but globally static",
2472 IDENTIFIER_POINTER (name));
2475 /* If we have a local external declaration,
2476 and no file-scope declaration has yet been seen,
2477 then if we later have a file-scope decl it must not be static. */
2479 && DECL_EXTERNAL (x)
2483 TREE_PUBLIC (name) = 1;
2485 /* Save this decl, so that we can do type checking against
2486 other decls after it falls out of scope.
2488 Only save it once. This prevents temporary decls created in
2489 expand_inline_function from being used here, since this
2490 will have been set when the inline function was parsed.
2491 It also helps give slightly better warnings. */
2492 if (IDENTIFIER_LIMBO_VALUE (name) == 0)
2493 IDENTIFIER_LIMBO_VALUE (name) = x;
2496 warn_if_shadowing (x, oldlocal);
2498 /* If storing a local value, there may already be one (inherited).
2499 If so, record it for restoration when this binding level ends. */
2501 b->shadowed = tree_cons (name, oldlocal, b->shadowed);
2504 /* Keep count of variables in this level with incomplete type.
2505 If the input is erroneous, we can have error_mark in the type
2506 slot (e.g. "f(void a, ...)") - that doesn't count as an
2508 if (TREE_TYPE (x) != error_mark_node
2509 && !COMPLETE_TYPE_P (TREE_TYPE (x)))
2511 tree element = TREE_TYPE (x);
2513 while (TREE_CODE (element) == ARRAY_TYPE)
2514 element = TREE_TYPE (element);
2515 if (TREE_CODE (element) == RECORD_TYPE
2516 || TREE_CODE (element) == UNION_TYPE)
2521 /* Put decls on list in reverse order.
2522 We will reverse them later if necessary. */
2523 TREE_CHAIN (x) = b->names;
2529 /* Like pushdecl, only it places X in GLOBAL_BINDING_LEVEL, if appropriate. */
2532 pushdecl_top_level (x)
2536 struct binding_level *b = current_binding_level;
2538 current_binding_level = global_binding_level;
2540 current_binding_level = b;
2544 /* Generate an implicit declaration for identifier FUNCTIONID
2545 as a function of type int (). Print a warning if appropriate. */
2548 implicitly_declare (functionid)
2552 int traditional_warning = 0;
2553 /* Only one "implicit declaration" warning per identifier. */
2554 int implicit_warning;
2556 /* We used to reuse an old implicit decl here,
2557 but this loses with inline functions because it can clobber
2558 the saved decl chains. */
2560 if (IDENTIFIER_IMPLICIT_DECL (functionid) != 0)
2561 decl = IDENTIFIER_IMPLICIT_DECL (functionid);
2564 decl = build_decl (FUNCTION_DECL, functionid, default_function_type);
2566 /* Warn of implicit decl following explicit local extern decl.
2567 This is probably a program designed for traditional C. */
2568 if (TREE_PUBLIC (functionid) && IDENTIFIER_GLOBAL_VALUE (functionid) == 0)
2569 traditional_warning = 1;
2571 /* Warn once of an implicit declaration. */
2572 implicit_warning = (IDENTIFIER_IMPLICIT_DECL (functionid) == 0);
2574 DECL_EXTERNAL (decl) = 1;
2575 TREE_PUBLIC (decl) = 1;
2577 /* Record that we have an implicit decl and this is it. */
2578 IDENTIFIER_IMPLICIT_DECL (functionid) = decl;
2580 /* ANSI standard says implicit declarations are in the innermost block.
2581 So we record the decl in the standard fashion.
2582 If flag_traditional is set, pushdecl does it top-level. */
2585 /* This is a no-op in c-lang.c or something real in objc-actions.c. */
2586 maybe_objc_check_decl (decl);
2588 rest_of_decl_compilation (decl, NULL, 0, 0);
2590 if (implicit_warning)
2591 implicit_decl_warning (functionid);
2592 else if (warn_traditional && traditional_warning)
2593 warning ("function `%s' was previously declared within a block",
2594 IDENTIFIER_POINTER (functionid));
2596 /* Write a record describing this implicit function declaration to the
2597 prototypes file (if requested). */
2599 gen_aux_info_record (decl, 0, 1, 0);
2601 /* Possibly apply some default attributes to this implicit declaration. */
2602 decl_attributes (&decl, NULL_TREE, 0);
2608 implicit_decl_warning (id)
2611 const char *name = IDENTIFIER_POINTER (id);
2612 if (mesg_implicit_function_declaration == 2)
2613 error ("implicit declaration of function `%s'", name);
2614 else if (mesg_implicit_function_declaration == 1)
2615 warning ("implicit declaration of function `%s'", name);
2618 /* Return zero if the declaration NEWDECL is valid
2619 when the declaration OLDDECL (assumed to be for the same name)
2620 has already been seen.
2621 Otherwise return 1 if NEWDECL is a redefinition, 2 if it is a redeclaration,
2622 and 3 if it is a conflicting declaration. */
2625 redeclaration_error_message (newdecl, olddecl)
2626 tree newdecl, olddecl;
2628 if (TREE_CODE (newdecl) == TYPE_DECL)
2630 if (flag_traditional && TREE_TYPE (newdecl) == TREE_TYPE (olddecl))
2632 /* pushdecl creates distinct types for TYPE_DECLs by calling
2633 build_type_copy, so the above comparison generally fails. We do
2634 another test against the TYPE_MAIN_VARIANT of the olddecl, which
2635 is equivalent to what this code used to do before the build_type_copy
2636 call. The variant type distinction should not matter for traditional
2637 code, because it doesn't have type qualifiers. */
2638 if (flag_traditional
2639 && TYPE_MAIN_VARIANT (TREE_TYPE (olddecl)) == TREE_TYPE (newdecl))
2641 if (DECL_IN_SYSTEM_HEADER (olddecl) || DECL_IN_SYSTEM_HEADER (newdecl))
2645 else if (TREE_CODE (newdecl) == FUNCTION_DECL)
2647 /* Declarations of functions can insist on internal linkage
2648 but they can't be inconsistent with internal linkage,
2649 so there can be no error on that account.
2650 However defining the same name twice is no good. */
2651 if (DECL_INITIAL (olddecl) != 0 && DECL_INITIAL (newdecl) != 0
2652 /* However, defining once as extern inline and a second
2653 time in another way is ok. */
2654 && ! (DECL_DECLARED_INLINE_P (olddecl) && DECL_EXTERNAL (olddecl)
2655 && ! (DECL_DECLARED_INLINE_P (newdecl)
2656 && DECL_EXTERNAL (newdecl))))
2660 else if (DECL_CONTEXT (newdecl) == NULL_TREE)
2662 /* Objects declared at top level: */
2663 /* If at least one is a reference, it's ok. */
2664 if (DECL_EXTERNAL (newdecl) || DECL_EXTERNAL (olddecl))
2666 /* Reject two definitions. */
2667 if (DECL_INITIAL (olddecl) != 0 && DECL_INITIAL (newdecl) != 0)
2669 /* Now we have two tentative defs, or one tentative and one real def. */
2670 /* Insist that the linkage match. */
2671 if (TREE_PUBLIC (olddecl) != TREE_PUBLIC (newdecl))
2675 else if (current_binding_level->parm_flag
2676 && TREE_ASM_WRITTEN (olddecl) && !TREE_ASM_WRITTEN (newdecl))
2680 /* Newdecl has block scope. If olddecl has block scope also, then
2681 reject two definitions, and reject a definition together with an
2682 external reference. Otherwise, it is OK, because newdecl must
2683 be an extern reference to olddecl. */
2684 if (!(DECL_EXTERNAL (newdecl) && DECL_EXTERNAL (olddecl))
2685 && DECL_CONTEXT (newdecl) == DECL_CONTEXT (olddecl))
2691 /* Get the LABEL_DECL corresponding to identifier ID as a label.
2692 Create one if none exists so far for the current function.
2693 This function is called for both label definitions and label references. */
2699 tree decl = IDENTIFIER_LABEL_VALUE (id);
2701 if (current_function_decl == 0)
2703 error ("label %s referenced outside of any function",
2704 IDENTIFIER_POINTER (id));
2708 /* Use a label already defined or ref'd with this name. */
2711 /* But not if it is inherited and wasn't declared to be inheritable. */
2712 if (DECL_CONTEXT (decl) != current_function_decl
2713 && ! C_DECLARED_LABEL_FLAG (decl))
2714 return shadow_label (id);
2718 decl = build_decl (LABEL_DECL, id, void_type_node);
2720 /* A label not explicitly declared must be local to where it's ref'd. */
2721 DECL_CONTEXT (decl) = current_function_decl;
2723 DECL_MODE (decl) = VOIDmode;
2725 /* Say where one reference is to the label,
2726 for the sake of the error if it is not defined. */
2727 DECL_SOURCE_LINE (decl) = lineno;
2728 DECL_SOURCE_FILE (decl) = input_filename;
2730 IDENTIFIER_LABEL_VALUE (id) = decl;
2732 named_labels = tree_cons (NULL_TREE, decl, named_labels);
2737 /* Make a label named NAME in the current function,
2738 shadowing silently any that may be inherited from containing functions
2739 or containing scopes.
2741 Note that valid use, if the label being shadowed
2742 comes from another scope in the same function,
2743 requires calling declare_nonlocal_label right away. */
2749 tree decl = IDENTIFIER_LABEL_VALUE (name);
2755 /* Check to make sure that the label hasn't already been declared
2756 at this label scope */
2757 for (dup = named_labels; dup; dup = TREE_CHAIN (dup))
2758 if (TREE_VALUE (dup) == decl)
2760 error ("duplicate label declaration `%s'",
2761 IDENTIFIER_POINTER (name));
2762 error_with_decl (TREE_VALUE (dup),
2763 "this is a previous declaration");
2764 /* Just use the previous declaration. */
2765 return lookup_label (name);
2768 shadowed_labels = tree_cons (NULL_TREE, decl, shadowed_labels);
2769 IDENTIFIER_LABEL_VALUE (name) = decl = 0;
2772 return lookup_label (name);
2775 /* Define a label, specifying the location in the source file.
2776 Return the LABEL_DECL node for the label, if the definition is valid.
2777 Otherwise return 0. */
2780 define_label (filename, line, name)
2781 const char *filename;
2785 tree decl = lookup_label (name);
2787 /* If label with this name is known from an outer context, shadow it. */
2788 if (decl != 0 && DECL_CONTEXT (decl) != current_function_decl)
2790 shadowed_labels = tree_cons (NULL_TREE, decl, shadowed_labels);
2791 IDENTIFIER_LABEL_VALUE (name) = 0;
2792 decl = lookup_label (name);
2795 if (warn_traditional && !in_system_header && lookup_name (name))
2796 warning_with_file_and_line (filename, line,
2797 "traditional C lacks a separate namespace for labels, identifier `%s' conflicts",
2798 IDENTIFIER_POINTER (name));
2800 if (DECL_INITIAL (decl) != 0)
2802 error_with_file_and_line (filename, line, "duplicate label `%s'",
2803 IDENTIFIER_POINTER (name));
2808 /* Mark label as having been defined. */
2809 DECL_INITIAL (decl) = error_mark_node;
2810 /* Say where in the source. */
2811 DECL_SOURCE_FILE (decl) = filename;
2812 DECL_SOURCE_LINE (decl) = line;
2817 /* Return the list of declarations of the current level.
2818 Note that this list is in reverse order unless/until
2819 you nreverse it; and when you do nreverse it, you must
2820 store the result back using `storedecls' or you will lose. */
2825 return current_binding_level->names;
2828 /* Return the list of type-tags (for structs, etc) of the current level. */
2833 return current_binding_level->tags;
2836 /* Store the list of declarations of the current level.
2837 This is done for the parameter declarations of a function being defined,
2838 after they are modified in the light of any missing parameters. */
2844 current_binding_level->names = decls;
2847 /* Similarly, store the list of tags of the current level. */
2853 current_binding_level->tags = tags;
2856 /* Given NAME, an IDENTIFIER_NODE,
2857 return the structure (or union or enum) definition for that name.
2858 Searches binding levels from BINDING_LEVEL up to the global level.
2859 If THISLEVEL_ONLY is nonzero, searches only the specified context
2860 (but skips any tag-transparent contexts to find one that is
2861 meaningful for tags).
2862 CODE says which kind of type the caller wants;
2863 it is RECORD_TYPE or UNION_TYPE or ENUMERAL_TYPE.
2864 If the wrong kind of type is found, an error is reported. */
2867 lookup_tag (code, name, binding_level, thislevel_only)
2868 enum tree_code code;
2869 struct binding_level *binding_level;
2873 struct binding_level *level;
2876 for (level = binding_level; level; level = level->level_chain)
2879 for (tail = level->tags; tail; tail = TREE_CHAIN (tail))
2881 if (TREE_PURPOSE (tail) == name)
2883 if (TREE_CODE (TREE_VALUE (tail)) != code)
2885 /* Definition isn't the kind we were looking for. */
2886 pending_invalid_xref = name;
2887 pending_invalid_xref_file = input_filename;
2888 pending_invalid_xref_line = lineno;
2889 /* If in the same binding level as a declaration as a tag
2890 of a different type, this must not be allowed to
2891 shadow that tag, so give the error immediately.
2892 (For example, "struct foo; union foo;" is invalid.) */
2894 pending_xref_error ();
2896 return TREE_VALUE (tail);
2899 if (! level->tag_transparent)
2909 /* Print an error message now
2910 for a recent invalid struct, union or enum cross reference.
2911 We don't print them immediately because they are not invalid
2912 when used in the `struct foo;' construct for shadowing. */
2915 pending_xref_error ()
2917 if (pending_invalid_xref != 0)
2918 error_with_file_and_line (pending_invalid_xref_file,
2919 pending_invalid_xref_line,
2920 "`%s' defined as wrong kind of tag",
2921 IDENTIFIER_POINTER (pending_invalid_xref));
2922 pending_invalid_xref = 0;
2925 /* Given a type, find the tag that was defined for it and return the tag name.
2926 Otherwise return 0. */
2929 lookup_tag_reverse (type)
2932 struct binding_level *level;
2934 for (level = current_binding_level; level; level = level->level_chain)
2937 for (tail = level->tags; tail; tail = TREE_CHAIN (tail))
2939 if (TREE_VALUE (tail) == type)
2940 return TREE_PURPOSE (tail);
2946 /* Look up NAME in the current binding level and its superiors
2947 in the namespace of variables, functions and typedefs.
2948 Return a ..._DECL node of some kind representing its definition,
2949 or return 0 if it is undefined. */
2957 if (current_binding_level != global_binding_level
2958 && IDENTIFIER_LOCAL_VALUE (name))
2959 val = IDENTIFIER_LOCAL_VALUE (name);
2961 val = IDENTIFIER_GLOBAL_VALUE (name);
2965 /* Similar to `lookup_name' but look only at current binding level. */
2968 lookup_name_current_level (name)
2973 if (current_binding_level == global_binding_level)
2974 return IDENTIFIER_GLOBAL_VALUE (name);
2976 if (IDENTIFIER_LOCAL_VALUE (name) == 0)
2979 for (t = current_binding_level->names; t; t = TREE_CHAIN (t))
2980 if (DECL_NAME (t) == name)
2986 /* Mark ARG for GC. */
2989 mark_binding_level (arg)
2992 struct binding_level *level = *(struct binding_level **) arg;
2994 for (; level != 0; level = level->level_chain)
2996 ggc_mark_tree (level->names);
2997 ggc_mark_tree (level->tags);
2998 ggc_mark_tree (level->shadowed);
2999 ggc_mark_tree (level->blocks);
3000 ggc_mark_tree (level->this_block);
3001 ggc_mark_tree (level->parm_order);
3005 /* Create the predefined scalar types of C,
3006 and some nodes representing standard constants (0, 1, (void *) 0).
3007 Initialize the global binding level.
3008 Make definitions for built-in primitive functions. */
3011 c_init_decl_processing ()
3014 tree ptr_ftype_void, ptr_ftype_ptr;
3016 /* Adds some ggc roots, and reserved words for c-parse.in. */
3019 current_function_decl = NULL;
3020 named_labels = NULL;
3021 current_binding_level = NULL_BINDING_LEVEL;
3022 free_binding_level = NULL_BINDING_LEVEL;
3024 /* Make the binding_level structure for global names. */
3026 global_binding_level = current_binding_level;
3028 build_common_tree_nodes (flag_signed_char);
3030 c_common_nodes_and_builtins ();
3032 boolean_type_node = integer_type_node;
3033 boolean_true_node = integer_one_node;
3034 boolean_false_node = integer_zero_node;
3036 /* With GCC, C99's _Bool is always of size 1. */
3037 c_bool_type_node = make_unsigned_type (CHAR_TYPE_SIZE);
3038 TREE_SET_CODE (c_bool_type_node, BOOLEAN_TYPE);
3039 TYPE_MAX_VALUE (c_bool_type_node) = build_int_2 (1, 0);
3040 TREE_TYPE (TYPE_MAX_VALUE (c_bool_type_node)) = c_bool_type_node;
3041 TYPE_PRECISION (c_bool_type_node) = 1;
3042 pushdecl (build_decl (TYPE_DECL, get_identifier ("_Bool"),
3044 c_bool_false_node = build_int_2 (0, 0);
3045 TREE_TYPE (c_bool_false_node) = c_bool_type_node;
3046 c_bool_true_node = build_int_2 (1, 0);
3047 TREE_TYPE (c_bool_true_node) = c_bool_type_node;
3049 endlink = void_list_node;
3050 ptr_ftype_void = build_function_type (ptr_type_node, endlink);
3052 = build_function_type (ptr_type_node,
3053 tree_cons (NULL_TREE, ptr_type_node, endlink));
3055 /* Types which are common to the fortran compiler and libf2c. When
3056 changing these, you also need to be concerned with f/com.h. */
3058 if (TYPE_PRECISION (float_type_node)
3059 == TYPE_PRECISION (long_integer_type_node))
3061 g77_integer_type_node = long_integer_type_node;
3062 g77_uinteger_type_node = long_unsigned_type_node;
3064 else if (TYPE_PRECISION (float_type_node)
3065 == TYPE_PRECISION (integer_type_node))
3067 g77_integer_type_node = integer_type_node;
3068 g77_uinteger_type_node = unsigned_type_node;
3071 g77_integer_type_node = g77_uinteger_type_node = NULL_TREE;
3073 if (g77_integer_type_node != NULL_TREE)
3075 pushdecl (build_decl (TYPE_DECL, get_identifier ("__g77_integer"),
3076 g77_integer_type_node));
3077 pushdecl (build_decl (TYPE_DECL, get_identifier ("__g77_uinteger"),
3078 g77_uinteger_type_node));
3081 if (TYPE_PRECISION (float_type_node) * 2
3082 == TYPE_PRECISION (long_integer_type_node))
3084 g77_longint_type_node = long_integer_type_node;
3085 g77_ulongint_type_node = long_unsigned_type_node;
3087 else if (TYPE_PRECISION (float_type_node) * 2
3088 == TYPE_PRECISION (long_long_integer_type_node))
3090 g77_longint_type_node = long_long_integer_type_node;
3091 g77_ulongint_type_node = long_long_unsigned_type_node;
3094 g77_longint_type_node = g77_ulongint_type_node = NULL_TREE;
3096 if (g77_longint_type_node != NULL_TREE)
3098 pushdecl (build_decl (TYPE_DECL, get_identifier ("__g77_longint"),
3099 g77_longint_type_node));
3100 pushdecl (build_decl (TYPE_DECL, get_identifier ("__g77_ulongint"),
3101 g77_ulongint_type_node));
3104 pedantic_lvalues = pedantic;
3106 make_fname_decl = c_make_fname_decl;
3107 start_fname_decls ();
3109 incomplete_decl_finalize_hook = finish_incomplete_decl;
3111 /* Record our roots. */
3113 ggc_add_tree_root (c_global_trees, CTI_MAX);
3114 ggc_add_root (&c_stmt_tree, 1, sizeof c_stmt_tree, mark_stmt_tree);
3115 ggc_add_tree_root (&c_scope_stmt_stack, 1);
3116 ggc_add_tree_root (&named_labels, 1);
3117 ggc_add_tree_root (&shadowed_labels, 1);
3118 ggc_add_root (¤t_binding_level, 1, sizeof current_binding_level,
3119 mark_binding_level);
3120 ggc_add_root (&label_level_chain, 1, sizeof label_level_chain,
3121 mark_binding_level);
3122 ggc_add_tree_root (&static_ctors, 1);
3123 ggc_add_tree_root (&static_dtors, 1);
3126 /* Create the VAR_DECL for __FUNCTION__ etc. ID is the name to give the
3127 decl, NAME is the initialization string and TYPE_DEP indicates whether
3128 NAME depended on the type of the function. As we don't yet implement
3129 delayed emission of static data, we mark the decl as emitted
3130 so it is not placed in the output. Anything using it must therefore pull
3131 out the STRING_CST initializer directly. This does mean that these names
3132 are string merging candidates, which is wrong for C99's __func__. FIXME. */
3135 c_make_fname_decl (id, type_dep)
3139 const char *name = fname_as_string (type_dep);
3140 tree decl, type, init;
3141 size_t length = strlen (name);
3143 type = build_array_type
3144 (build_qualified_type (char_type_node, TYPE_QUAL_CONST),
3145 build_index_type (size_int (length)));
3147 decl = build_decl (VAR_DECL, id, type);
3148 /* We don't push the decl, so have to set its context here. */
3149 DECL_CONTEXT (decl) = current_function_decl;
3151 TREE_STATIC (decl) = 1;
3152 TREE_READONLY (decl) = 1;
3153 DECL_ARTIFICIAL (decl) = 1;
3155 init = build_string (length + 1, name);
3156 TREE_TYPE (init) = type;
3157 DECL_INITIAL (decl) = init;
3159 TREE_USED (decl) = 1;
3161 finish_decl (decl, init, NULL_TREE);
3166 /* Return a definition for a builtin function named NAME and whose data type
3167 is TYPE. TYPE should be a function type with argument types.
3168 FUNCTION_CODE tells later passes how to compile calls to this function.
3169 See tree.h for its possible values.
3171 If LIBRARY_NAME is nonzero, use that for DECL_ASSEMBLER_NAME,
3172 the name to be called if we can't opencode the function. */
3175 builtin_function (name, type, function_code, class, library_name)
3179 enum built_in_class class;
3180 const char *library_name;
3182 tree decl = build_decl (FUNCTION_DECL, get_identifier (name), type);
3183 DECL_EXTERNAL (decl) = 1;
3184 TREE_PUBLIC (decl) = 1;
3185 /* If -traditional, permit redefining a builtin function any way you like.
3186 (Though really, if the program redefines these functions,
3187 it probably won't work right unless compiled with -fno-builtin.) */
3188 if (flag_traditional && name[0] != '_')
3189 DECL_BUILT_IN_NONANSI (decl) = 1;
3191 SET_DECL_ASSEMBLER_NAME (decl, get_identifier (library_name));
3192 make_decl_rtl (decl, NULL);
3194 DECL_BUILT_IN_CLASS (decl) = class;
3195 DECL_FUNCTION_CODE (decl) = function_code;
3197 /* Warn if a function in the namespace for users
3198 is used without an occasion to consider it declared. */
3199 if (name[0] != '_' || name[1] != '_')
3200 C_DECL_ANTICIPATED (decl) = 1;
3202 /* Possibly apply some default attributes to this built-in function. */
3203 decl_attributes (&decl, NULL_TREE, 0);
3208 /* Apply default attributes to a function, if a system function with default
3212 insert_default_attributes (decl)
3215 if (!TREE_PUBLIC (decl))
3217 c_common_insert_default_attributes (decl);
3220 /* Called when a declaration is seen that contains no names to declare.
3221 If its type is a reference to a structure, union or enum inherited
3222 from a containing scope, shadow that tag name for the current scope
3223 with a forward reference.
3224 If its type defines a new named structure or union
3225 or defines an enum, it is valid but we need not do anything here.
3226 Otherwise, it is an error. */
3229 shadow_tag (declspecs)
3232 shadow_tag_warned (declspecs, 0);
3236 shadow_tag_warned (declspecs, warned)
3239 /* 1 => we have done a pedwarn. 2 => we have done a warning, but
3246 pending_invalid_xref = 0;
3248 /* Remove the attributes from declspecs, since they will confuse the
3250 split_specs_attrs (declspecs, &specs, &attrs);
3252 for (link = specs; link; link = TREE_CHAIN (link))
3254 tree value = TREE_VALUE (link);
3255 enum tree_code code = TREE_CODE (value);
3257 if (code == RECORD_TYPE || code == UNION_TYPE || code == ENUMERAL_TYPE)
3258 /* Used to test also that TYPE_SIZE (value) != 0.
3259 That caused warning for `struct foo;' at top level in the file. */
3261 tree name = lookup_tag_reverse (value);
3268 if (warned != 1 && code != ENUMERAL_TYPE)
3269 /* Empty unnamed enum OK */
3271 pedwarn ("unnamed struct/union that defines no instances");
3277 t = lookup_tag (code, name, current_binding_level, 1);
3281 t = make_node (code);
3288 if (!warned && ! in_system_header)
3290 warning ("useless keyword or type name in empty declaration");
3297 error ("two types specified in one empty declaration");
3302 pedwarn ("empty declaration");
3306 /* Construct an array declarator. EXPR is the expression inside [], or
3307 NULL_TREE. QUALS are the type qualifiers inside the [] (to be applied
3308 to the pointer to which a parameter array is converted). STATIC_P is
3309 non-zero if "static" is inside the [], zero otherwise. VLA_UNSPEC_P
3310 is non-zero is the array is [*], a VLA of unspecified length which is
3311 nevertheless a complete type (not currently implemented by GCC),
3312 zero otherwise. The declarator is constructed as an ARRAY_REF
3313 (to be decoded by grokdeclarator), whose operand 0 is what's on the
3314 left of the [] (filled by in set_array_declarator_type) and operand 1
3315 is the expression inside; whose TREE_TYPE is the type qualifiers and
3316 which has TREE_STATIC set if "static" is used. */
3319 build_array_declarator (expr, quals, static_p, vla_unspec_p)
3326 decl = build_nt (ARRAY_REF, NULL_TREE, expr);
3327 TREE_TYPE (decl) = quals;
3328 TREE_STATIC (decl) = (static_p ? 1 : 0);
3329 if (pedantic && !flag_isoc99)
3331 if (static_p || quals != NULL_TREE)
3332 pedwarn ("ISO C89 does not support `static' or type qualifiers in parameter array declarators");
3334 pedwarn ("ISO C89 does not support `[*]' array declarators");
3337 warning ("GCC does not yet properly implement `[*]' array declarators");
3341 /* Set the type of an array declarator. DECL is the declarator, as
3342 constructed by build_array_declarator; TYPE is what appears on the left
3343 of the [] and goes in operand 0. ABSTRACT_P is non-zero if it is an
3344 abstract declarator, zero otherwise; this is used to reject static and
3345 type qualifiers in abstract declarators, where they are not in the
3349 set_array_declarator_type (decl, type, abstract_p)
3354 TREE_OPERAND (decl, 0) = type;
3355 if (abstract_p && (TREE_TYPE (decl) != NULL_TREE || TREE_STATIC (decl)))
3356 error ("static or type qualifiers in abstract declarator");
3360 /* Decode a "typename", such as "int **", returning a ..._TYPE node. */
3363 groktypename (typename)
3366 if (TREE_CODE (typename) != TREE_LIST)
3368 return grokdeclarator (TREE_VALUE (typename),
3369 TREE_PURPOSE (typename),
3373 /* Return a PARM_DECL node for a given pair of specs and declarator. */
3376 groktypename_in_parm_context (typename)
3379 if (TREE_CODE (typename) != TREE_LIST)
3381 return grokdeclarator (TREE_VALUE (typename),
3382 TREE_PURPOSE (typename),
3386 /* Decode a declarator in an ordinary declaration or data definition.
3387 This is called as soon as the type information and variable name
3388 have been parsed, before parsing the initializer if any.
3389 Here we create the ..._DECL node, fill in its type,
3390 and put it on the list of decls for the current context.
3391 The ..._DECL node is returned as the value.
3393 Exception: for arrays where the length is not specified,
3394 the type is left null, to be filled in by `finish_decl'.
3396 Function definitions do not come here; they go to start_function
3397 instead. However, external and forward declarations of functions
3398 do go through here. Structure field declarations are done by
3399 grokfield and not through here. */
3402 start_decl (declarator, declspecs, initialized, attributes)
3403 tree declarator, declspecs;
3407 tree decl = grokdeclarator (declarator, declspecs,
3408 NORMAL, initialized);
3411 if (warn_main > 0 && TREE_CODE (decl) != FUNCTION_DECL
3412 && MAIN_NAME_P (DECL_NAME (decl)))
3413 warning_with_decl (decl, "`%s' is usually a function");
3416 /* Is it valid for this decl to have an initializer at all?
3417 If not, set INITIALIZED to zero, which will indirectly
3418 tell `finish_decl' to ignore the initializer once it is parsed. */
3419 switch (TREE_CODE (decl))
3422 /* typedef foo = bar means give foo the same type as bar.
3423 We haven't parsed bar yet, so `finish_decl' will fix that up.
3424 Any other case of an initialization in a TYPE_DECL is an error. */
3425 if (pedantic || list_length (declspecs) > 1)
3427 error ("typedef `%s' is initialized",
3428 IDENTIFIER_POINTER (DECL_NAME (decl)));
3434 error ("function `%s' is initialized like a variable",
3435 IDENTIFIER_POINTER (DECL_NAME (decl)));
3440 /* DECL_INITIAL in a PARM_DECL is really DECL_ARG_TYPE. */
3441 error ("parameter `%s' is initialized",
3442 IDENTIFIER_POINTER (DECL_NAME (decl)));
3447 /* Don't allow initializations for incomplete types
3448 except for arrays which might be completed by the initialization. */
3450 /* This can happen if the array size is an undefined macro. We already
3451 gave a warning, so we don't need another one. */
3452 if (TREE_TYPE (decl) == error_mark_node)
3454 else if (COMPLETE_TYPE_P (TREE_TYPE (decl)))
3456 /* A complete type is ok if size is fixed. */
3458 if (TREE_CODE (TYPE_SIZE (TREE_TYPE (decl))) != INTEGER_CST
3459 || C_DECL_VARIABLE_SIZE (decl))
3461 error ("variable-sized object may not be initialized");
3465 else if (TREE_CODE (TREE_TYPE (decl)) != ARRAY_TYPE)
3467 error ("variable `%s' has initializer but incomplete type",
3468 IDENTIFIER_POINTER (DECL_NAME (decl)));
3471 else if (!COMPLETE_TYPE_P (TREE_TYPE (TREE_TYPE (decl))))
3473 error ("elements of array `%s' have incomplete type",
3474 IDENTIFIER_POINTER (DECL_NAME (decl)));
3482 /* Seems redundant with grokdeclarator. */
3483 if (current_binding_level != global_binding_level
3484 && DECL_EXTERNAL (decl)
3485 && TREE_CODE (decl) != FUNCTION_DECL)
3486 warning ("declaration of `%s' has `extern' and is initialized",
3487 IDENTIFIER_POINTER (DECL_NAME (decl)));
3489 DECL_EXTERNAL (decl) = 0;
3490 if (current_binding_level == global_binding_level)
3491 TREE_STATIC (decl) = 1;
3493 /* Tell `pushdecl' this is an initialized decl
3494 even though we don't yet have the initializer expression.
3495 Also tell `finish_decl' it may store the real initializer. */
3496 DECL_INITIAL (decl) = error_mark_node;
3499 /* If this is a function declaration, write a record describing it to the
3500 prototypes file (if requested). */
3502 if (TREE_CODE (decl) == FUNCTION_DECL)
3503 gen_aux_info_record (decl, 0, 0, TYPE_ARG_TYPES (TREE_TYPE (decl)) != 0);
3505 /* ANSI specifies that a tentative definition which is not merged with
3506 a non-tentative definition behaves exactly like a definition with an
3507 initializer equal to zero. (Section 3.7.2)
3508 -fno-common gives strict ANSI behavior. Usually you don't want it.
3509 This matters only for variables with external linkage. */
3510 if (! flag_no_common || ! TREE_PUBLIC (decl))
3511 DECL_COMMON (decl) = 1;
3513 /* Set attributes here so if duplicate decl, will have proper attributes. */
3514 decl_attributes (&decl, attributes, 0);
3516 if (TREE_CODE (decl) == FUNCTION_DECL
3517 && DECL_DECLARED_INLINE_P (decl)
3518 && DECL_UNINLINABLE (decl)
3519 && lookup_attribute ("noinline", DECL_ATTRIBUTES (decl)))
3520 warning_with_decl (decl,
3521 "inline function `%s' given attribute noinline");
3523 /* Add this decl to the current binding level.
3524 TEM may equal DECL or it may be a previous decl of the same name. */
3525 tem = pushdecl (decl);
3527 /* For a local variable, define the RTL now. */
3528 if (current_binding_level != global_binding_level
3529 /* But not if this is a duplicate decl
3530 and we preserved the rtl from the previous one
3531 (which may or may not happen). */
3532 && !DECL_RTL_SET_P (tem)
3533 && !DECL_CONTEXT (tem))
3535 if (TREE_TYPE (tem) != error_mark_node
3536 && COMPLETE_TYPE_P (TREE_TYPE (tem)))
3538 else if (TREE_CODE (TREE_TYPE (tem)) == ARRAY_TYPE
3539 && DECL_INITIAL (tem) != 0)
3546 /* Finish processing of a declaration;
3547 install its initial value.
3548 If the length of an array type is not known before,
3549 it must be determined now, from the initial value, or it is an error. */
3552 finish_decl (decl, init, asmspec_tree)
3556 tree type = TREE_TYPE (decl);
3557 int was_incomplete = (DECL_SIZE (decl) == 0);
3558 const char *asmspec = 0;
3560 /* If a name was specified, get the string. */
3562 asmspec = TREE_STRING_POINTER (asmspec_tree);
3564 /* If `start_decl' didn't like having an initialization, ignore it now. */
3565 if (init != 0 && DECL_INITIAL (decl) == 0)
3568 /* Don't crash if parm is initialized. */
3569 if (TREE_CODE (decl) == PARM_DECL)
3574 if (TREE_CODE (decl) != TYPE_DECL)
3575 store_init_value (decl, init);
3578 /* typedef foo = bar; store the type of bar as the type of foo. */
3579 TREE_TYPE (decl) = TREE_TYPE (init);
3580 DECL_INITIAL (decl) = init = 0;
3584 /* Deduce size of array from initialization, if not already known */
3585 if (TREE_CODE (type) == ARRAY_TYPE
3586 && TYPE_DOMAIN (type) == 0
3587 && TREE_CODE (decl) != TYPE_DECL)
3590 = (TREE_STATIC (decl)
3591 /* Even if pedantic, an external linkage array
3592 may have incomplete type at first. */
3593 ? pedantic && !TREE_PUBLIC (decl)
3594 : !DECL_EXTERNAL (decl));
3596 = complete_array_type (type, DECL_INITIAL (decl), do_default);
3598 /* Get the completed type made by complete_array_type. */
3599 type = TREE_TYPE (decl);
3602 error_with_decl (decl, "initializer fails to determine size of `%s'");
3604 else if (failure == 2)
3607 error_with_decl (decl, "array size missing in `%s'");
3608 /* If a `static' var's size isn't known,
3609 make it extern as well as static, so it does not get
3611 If it is not `static', then do not mark extern;
3612 finish_incomplete_decl will give it a default size
3613 and it will get allocated. */
3614 else if (!pedantic && TREE_STATIC (decl) && ! TREE_PUBLIC (decl))
3615 DECL_EXTERNAL (decl) = 1;
3618 /* TYPE_MAX_VALUE is always one less than the number of elements
3619 in the array, because we start counting at zero. Therefore,
3620 warn only if the value is less than zero. */
3621 else if (pedantic && TYPE_DOMAIN (type) != 0
3622 && tree_int_cst_sgn (TYPE_MAX_VALUE (TYPE_DOMAIN (type))) < 0)
3623 error_with_decl (decl, "zero or negative size array `%s'");
3625 layout_decl (decl, 0);
3628 if (TREE_CODE (decl) == VAR_DECL)
3630 if (DECL_SIZE (decl) == 0 && TREE_TYPE (decl) != error_mark_node
3631 && COMPLETE_TYPE_P (TREE_TYPE (decl)))
3632 layout_decl (decl, 0);
3634 if (DECL_SIZE (decl) == 0
3635 /* Don't give an error if we already gave one earlier. */
3636 && TREE_TYPE (decl) != error_mark_node
3637 && (TREE_STATIC (decl)
3639 /* A static variable with an incomplete type
3640 is an error if it is initialized.
3641 Also if it is not file scope.
3642 Otherwise, let it through, but if it is not `extern'
3643 then it may cause an error message later. */
3644 (DECL_INITIAL (decl) != 0
3645 || DECL_CONTEXT (decl) != 0)
3647 /* An automatic variable with an incomplete type
3649 !DECL_EXTERNAL (decl)))
3651 error_with_decl (decl, "storage size of `%s' isn't known");
3652 TREE_TYPE (decl) = error_mark_node;
3655 if ((DECL_EXTERNAL (decl) || TREE_STATIC (decl))
3656 && DECL_SIZE (decl) != 0)
3658 if (TREE_CODE (DECL_SIZE (decl)) == INTEGER_CST)
3659 constant_expression_warning (DECL_SIZE (decl));
3661 error_with_decl (decl, "storage size of `%s' isn't constant");
3664 if (TREE_USED (type))
3665 TREE_USED (decl) = 1;
3668 /* If this is a function and an assembler name is specified, it isn't
3669 builtin any more. Also reset DECL_RTL so we can give it its new
3671 if (TREE_CODE (decl) == FUNCTION_DECL && asmspec)
3673 DECL_BUILT_IN_CLASS (decl) = NOT_BUILT_IN;
3674 SET_DECL_RTL (decl, NULL_RTX);
3675 SET_DECL_ASSEMBLER_NAME (decl, get_identifier (asmspec));
3678 /* Output the assembler code and/or RTL code for variables and functions,
3679 unless the type is an undefined structure or union.
3680 If not, it will get done when the type is completed. */
3682 if (TREE_CODE (decl) == VAR_DECL || TREE_CODE (decl) == FUNCTION_DECL)
3684 /* This is a no-op in c-lang.c or something real in objc-actions.c. */
3685 maybe_objc_check_decl (decl);
3687 if (!DECL_CONTEXT (decl))
3689 if (DECL_INITIAL (decl) == NULL_TREE
3690 || DECL_INITIAL (decl) == error_mark_node)
3691 /* Don't output anything
3692 when a tentative file-scope definition is seen.
3693 But at end of compilation, do output code for them. */
3694 DECL_DEFER_OUTPUT (decl) = 1;
3695 rest_of_decl_compilation (decl, asmspec,
3696 (DECL_CONTEXT (decl) == 0
3697 || TREE_ASM_WRITTEN (decl)), 0);
3701 /* This is a local variable. If there is an ASMSPEC, the
3702 user has requested that we handle it specially. */
3705 /* In conjunction with an ASMSPEC, the `register'
3706 keyword indicates that we should place the variable
3707 in a particular register. */
3708 if (DECL_REGISTER (decl))
3709 DECL_C_HARD_REGISTER (decl) = 1;
3711 /* If this is not a static variable, issue a warning.
3712 It doesn't make any sense to give an ASMSPEC for an
3713 ordinary, non-register local variable. Historically,
3714 GCC has accepted -- but ignored -- the ASMSPEC in
3716 if (TREE_CODE (decl) == VAR_DECL
3717 && !DECL_REGISTER (decl)
3718 && !TREE_STATIC (decl))
3719 warning_with_decl (decl,
3720 "ignoring asm-specifier for non-static local variable `%s'");
3722 SET_DECL_ASSEMBLER_NAME (decl, get_identifier (asmspec));
3725 if (TREE_CODE (decl) != FUNCTION_DECL)
3726 add_decl_stmt (decl);
3729 if (DECL_CONTEXT (decl) != 0)
3731 /* Recompute the RTL of a local array now
3732 if it used to be an incomplete type. */
3734 && ! TREE_STATIC (decl) && ! DECL_EXTERNAL (decl))
3736 /* If we used it already as memory, it must stay in memory. */
3737 TREE_ADDRESSABLE (decl) = TREE_USED (decl);
3738 /* If it's still incomplete now, no init will save it. */
3739 if (DECL_SIZE (decl) == 0)
3740 DECL_INITIAL (decl) = 0;
3745 if (TREE_CODE (decl) == TYPE_DECL)
3747 /* This is a no-op in c-lang.c or something real in objc-actions.c. */
3748 maybe_objc_check_decl (decl);
3749 rest_of_decl_compilation (decl, NULL, DECL_CONTEXT (decl) == 0, 0);
3752 /* At the end of a declaration, throw away any variable type sizes
3753 of types defined inside that declaration. There is no use
3754 computing them in the following function definition. */
3755 if (current_binding_level == global_binding_level)
3756 get_pending_sizes ();
3759 /* If DECL has a cleanup, build and return that cleanup here.
3760 This is a callback called by expand_expr. */
3763 maybe_build_cleanup (decl)
3764 tree decl ATTRIBUTE_UNUSED;
3766 /* There are no cleanups in C. */
3770 /* Given a parsed parameter declaration,
3771 decode it into a PARM_DECL and push that on the current binding level.
3772 Also, for the sake of forward parm decls,
3773 record the given order of parms in `parm_order'. */
3776 push_parm_decl (parm)
3780 int old_immediate_size_expand = immediate_size_expand;
3781 /* Don't try computing parm sizes now -- wait till fn is called. */
3782 immediate_size_expand = 0;
3784 decl = grokdeclarator (TREE_VALUE (TREE_PURPOSE (parm)),
3785 TREE_PURPOSE (TREE_PURPOSE (parm)), PARM, 0);
3786 decl_attributes (&decl, TREE_VALUE (parm), 0);
3789 if (DECL_NAME (decl))
3792 olddecl = lookup_name (DECL_NAME (decl));
3793 if (pedantic && olddecl != 0 && TREE_CODE (olddecl) == TYPE_DECL)
3794 pedwarn_with_decl (decl,
3795 "ISO C forbids parameter `%s' shadowing typedef");
3799 decl = pushdecl (decl);
3801 immediate_size_expand = old_immediate_size_expand;
3803 current_binding_level->parm_order
3804 = tree_cons (NULL_TREE, decl, current_binding_level->parm_order);
3806 /* Add this decl to the current binding level. */
3807 finish_decl (decl, NULL_TREE, NULL_TREE);
3810 /* Clear the given order of parms in `parm_order'.
3811 Used at start of parm list,
3812 and also at semicolon terminating forward decls. */
3817 current_binding_level->parm_order = NULL_TREE;
3820 /* Build a COMPOUND_LITERAL_EXPR. TYPE is the type given in the compound
3821 literal, which may be an incomplete array type completed by the
3822 initializer; INIT is a CONSTRUCTOR that initializes the compound
3826 build_compound_literal (type, init)
3830 /* We do not use start_decl here because we have a type, not a declarator;
3831 and do not use finish_decl because the decl should be stored inside
3832 the COMPOUND_LITERAL_EXPR rather than added elsewhere as a DECL_STMT. */
3833 tree decl = build_decl (VAR_DECL, NULL_TREE, type);
3835 DECL_EXTERNAL (decl) = 0;
3836 TREE_PUBLIC (decl) = 0;
3837 TREE_STATIC (decl) = (current_binding_level == global_binding_level);
3838 DECL_CONTEXT (decl) = current_function_decl;
3839 TREE_USED (decl) = 1;
3840 TREE_TYPE (decl) = type;
3841 store_init_value (decl, init);
3843 if (TREE_CODE (type) == ARRAY_TYPE && !COMPLETE_TYPE_P (type))
3845 int failure = complete_array_type (type, DECL_INITIAL (decl), 1);
3850 type = TREE_TYPE (decl);
3851 if (type == error_mark_node || !COMPLETE_TYPE_P (type))
3852 return error_mark_node;
3854 complit = build1 (COMPOUND_LITERAL_EXPR, TREE_TYPE (decl), decl);
3855 TREE_SIDE_EFFECTS (complit) = 1;
3857 layout_decl (decl, 0);
3859 if (TREE_STATIC (decl))
3861 /* This decl needs a name for the assembler output. We also need
3862 a unique suffix to be added to the name, for which DECL_CONTEXT
3864 DECL_NAME (decl) = get_identifier ("__compound_literal");
3865 DECL_CONTEXT (decl) = complit;
3866 rest_of_decl_compilation (decl, NULL, 1, 0);
3867 DECL_CONTEXT (decl) = NULL_TREE;
3873 /* Make TYPE a complete type based on INITIAL_VALUE.
3874 Return 0 if successful, 1 if INITIAL_VALUE can't be deciphered,
3875 2 if there was no information (in which case assume 1 if DO_DEFAULT). */
3878 complete_array_type (type, initial_value, do_default)
3883 tree maxindex = NULL_TREE;
3888 /* Note MAXINDEX is really the maximum index,
3889 one less than the size. */
3890 if (TREE_CODE (initial_value) == STRING_CST)
3893 = int_size_in_bytes (TREE_TYPE (TREE_TYPE (initial_value)));
3894 maxindex = build_int_2 ((TREE_STRING_LENGTH (initial_value)
3897 else if (TREE_CODE (initial_value) == CONSTRUCTOR)
3899 tree elts = CONSTRUCTOR_ELTS (initial_value);
3900 maxindex = build_int_2 (-1, -1);
3901 for (; elts; elts = TREE_CHAIN (elts))
3903 if (TREE_PURPOSE (elts))
3904 maxindex = TREE_PURPOSE (elts);
3906 maxindex = fold (build (PLUS_EXPR, integer_type_node,
3907 maxindex, integer_one_node));
3909 maxindex = copy_node (maxindex);
3913 /* Make an error message unless that happened already. */
3914 if (initial_value != error_mark_node)
3917 /* Prevent further error messages. */
3918 maxindex = build_int_2 (0, 0);
3925 maxindex = build_int_2 (0, 0);
3931 TYPE_DOMAIN (type) = build_index_type (maxindex);
3932 if (!TREE_TYPE (maxindex))
3933 TREE_TYPE (maxindex) = TYPE_DOMAIN (type);
3936 /* Lay out the type now that we can get the real answer. */
3943 /* Given declspecs and a declarator,
3944 determine the name and type of the object declared
3945 and construct a ..._DECL node for it.
3946 (In one case we can return a ..._TYPE node instead.
3947 For invalid input we sometimes return 0.)
3949 DECLSPECS is a chain of tree_list nodes whose value fields
3950 are the storage classes and type specifiers.
3952 DECL_CONTEXT says which syntactic context this declaration is in:
3953 NORMAL for most contexts. Make a VAR_DECL or FUNCTION_DECL or TYPE_DECL.
3954 FUNCDEF for a function definition. Like NORMAL but a few different
3955 error messages in each case. Return value may be zero meaning
3956 this definition is too screwy to try to parse.
3957 PARM for a parameter declaration (either within a function prototype
3958 or before a function body). Make a PARM_DECL, or return void_type_node.
3959 TYPENAME if for a typename (in a cast or sizeof).
3960 Don't make a DECL node; just return the ..._TYPE node.
3961 FIELD for a struct or union field; make a FIELD_DECL.
3962 BITFIELD for a field with specified width.
3963 INITIALIZED is 1 if the decl has an initializer.
3965 In the TYPENAME case, DECLARATOR is really an absolute declarator.
3966 It may also be so in the PARM case, for a prototype where the
3967 argument type is specified but not the name.
3969 This function is where the complicated C meanings of `static'
3970 and `extern' are interpreted. */
3973 grokdeclarator (declarator, declspecs, decl_context, initialized)
3976 enum decl_context decl_context;
3981 tree type = NULL_TREE;
3986 int type_quals = TYPE_UNQUALIFIED;
3988 int explicit_int = 0;
3989 int explicit_char = 0;
3990 int defaulted_int = 0;
3991 tree typedef_decl = 0;
3993 tree typedef_type = 0;
3994 int funcdef_flag = 0;
3995 enum tree_code innermost_code = ERROR_MARK;
3997 int size_varies = 0;
3998 tree decl_attr = NULL_TREE;
3999 tree array_ptr_quals = NULL_TREE;
4000 int array_parm_static = 0;
4001 tree returned_attrs = NULL_TREE;
4003 if (decl_context == BITFIELD)
4004 bitfield = 1, decl_context = FIELD;
4006 if (decl_context == FUNCDEF)
4007 funcdef_flag = 1, decl_context = NORMAL;
4009 /* Look inside a declarator for the name being declared
4010 and get it as a string, for an error message. */
4012 tree decl = declarator;
4016 switch (TREE_CODE (decl))
4021 innermost_code = TREE_CODE (decl);
4022 decl = TREE_OPERAND (decl, 0);
4026 decl = TREE_VALUE (decl);
4029 case IDENTIFIER_NODE:
4030 name = IDENTIFIER_POINTER (decl);
4041 /* A function definition's declarator must have the form of
4042 a function declarator. */
4044 if (funcdef_flag && innermost_code != CALL_EXPR)
4047 /* Anything declared one level down from the top level
4048 must be one of the parameters of a function
4049 (because the body is at least two levels down). */
4051 /* If this looks like a function definition, make it one,
4052 even if it occurs where parms are expected.
4053 Then store_parm_decls will reject it and not use it as a parm. */
4054 if (decl_context == NORMAL && !funcdef_flag
4055 && current_binding_level->parm_flag)
4056 decl_context = PARM;
4058 /* Look through the decl specs and record which ones appear.
4059 Some typespecs are defined as built-in typenames.
4060 Others, the ones that are modifiers of other types,
4061 are represented by bits in SPECBITS: set the bits for
4062 the modifiers that appear. Storage class keywords are also in SPECBITS.
4064 If there is a typedef name or a type, store the type in TYPE.
4065 This includes builtin typedefs such as `int'.
4067 Set EXPLICIT_INT or EXPLICIT_CHAR if the type is `int' or `char'
4068 and did not come from a user typedef.
4070 Set LONGLONG if `long' is mentioned twice. */
4072 for (spec = declspecs; spec; spec = TREE_CHAIN (spec))
4074 tree id = TREE_VALUE (spec);
4076 if (id == ridpointers[(int) RID_INT])
4078 if (id == ridpointers[(int) RID_CHAR])
4081 if (TREE_CODE (id) == IDENTIFIER_NODE && C_IS_RESERVED_WORD (id))
4083 enum rid i = C_RID_CODE (id);
4084 if ((int) i <= (int) RID_LAST_MODIFIER)
4086 if (i == RID_LONG && (specbits & (1 << (int) i)))
4089 error ("`long long long' is too long for GCC");
4092 if (pedantic && !flag_isoc99 && ! in_system_header
4094 pedwarn ("ISO C89 does not support `long long'");
4098 else if (specbits & (1 << (int) i))
4099 pedwarn ("duplicate `%s'", IDENTIFIER_POINTER (id));
4100 specbits |= 1 << (int) i;
4105 error ("two or more data types in declaration of `%s'", name);
4106 /* Actual typedefs come to us as TYPE_DECL nodes. */
4107 else if (TREE_CODE (id) == TYPE_DECL)
4109 type = TREE_TYPE (id);
4110 decl_attr = DECL_ATTRIBUTES (id);
4113 /* Built-in types come as identifiers. */
4114 else if (TREE_CODE (id) == IDENTIFIER_NODE)
4116 tree t = lookup_name (id);
4117 if (TREE_TYPE (t) == error_mark_node)
4119 else if (!t || TREE_CODE (t) != TYPE_DECL)
4120 error ("`%s' fails to be a typedef or built in type",
4121 IDENTIFIER_POINTER (id));
4124 type = TREE_TYPE (t);
4128 else if (TREE_CODE (id) != ERROR_MARK)
4135 typedef_type = type;
4137 size_varies = C_TYPE_VARIABLE_SIZE (type);
4139 /* No type at all: default to `int', and set DEFAULTED_INT
4140 because it was not a user-defined typedef. */
4144 if ((! (specbits & ((1 << (int) RID_LONG) | (1 << (int) RID_SHORT)
4145 | (1 << (int) RID_SIGNED)
4146 | (1 << (int) RID_UNSIGNED)
4147 | (1 << (int) RID_COMPLEX))))
4148 /* Don't warn about typedef foo = bar. */
4149 && ! (specbits & (1 << (int) RID_TYPEDEF) && initialized)
4150 && ! in_system_header)
4152 /* Issue a warning if this is an ISO C 99 program or if -Wreturn-type
4153 and this is a function, or if -Wimplicit; prefer the former
4154 warning since it is more explicit. */
4155 if ((warn_implicit_int || warn_return_type || flag_isoc99)
4157 warn_about_return_type = 1;
4158 else if (warn_implicit_int || flag_isoc99)
4159 pedwarn_c99 ("type defaults to `int' in declaration of `%s'",
4164 type = integer_type_node;
4167 /* Now process the modifiers that were specified
4168 and check for invalid combinations. */
4170 /* Long double is a special combination. */
4172 if ((specbits & 1 << (int) RID_LONG) && ! longlong
4173 && TYPE_MAIN_VARIANT (type) == double_type_node)
4175 specbits &= ~(1 << (int) RID_LONG);
4176 type = long_double_type_node;
4179 /* Check all other uses of type modifiers. */
4181 if (specbits & ((1 << (int) RID_LONG) | (1 << (int) RID_SHORT)
4182 | (1 << (int) RID_UNSIGNED) | (1 << (int) RID_SIGNED)))
4186 if ((specbits & 1 << (int) RID_LONG)
4187 && (specbits & 1 << (int) RID_SHORT))
4188 error ("both long and short specified for `%s'", name);
4189 else if (((specbits & 1 << (int) RID_LONG)
4190 || (specbits & 1 << (int) RID_SHORT))
4192 error ("long or short specified with char for `%s'", name);
4193 else if (((specbits & 1 << (int) RID_LONG)
4194 || (specbits & 1 << (int) RID_SHORT))
4195 && TREE_CODE (type) == REAL_TYPE)
4197 static int already = 0;
4199 error ("long or short specified with floating type for `%s'", name);
4200 if (! already && ! pedantic)
4202 error ("the only valid combination is `long double'");
4206 else if ((specbits & 1 << (int) RID_SIGNED)
4207 && (specbits & 1 << (int) RID_UNSIGNED))
4208 error ("both signed and unsigned specified for `%s'", name);
4209 else if (TREE_CODE (type) != INTEGER_TYPE)
4210 error ("long, short, signed or unsigned invalid for `%s'", name);
4214 if (!explicit_int && !defaulted_int && !explicit_char && pedantic)
4216 pedwarn ("long, short, signed or unsigned used invalidly for `%s'",
4218 if (flag_pedantic_errors)
4223 /* Discard the type modifiers if they are invalid. */
4226 specbits &= ~((1 << (int) RID_LONG) | (1 << (int) RID_SHORT)
4227 | (1 << (int) RID_UNSIGNED) | (1 << (int) RID_SIGNED));
4232 if ((specbits & (1 << (int) RID_COMPLEX))
4233 && TREE_CODE (type) != INTEGER_TYPE && TREE_CODE (type) != REAL_TYPE)
4235 error ("complex invalid for `%s'", name);
4236 specbits &= ~(1 << (int) RID_COMPLEX);
4239 /* Decide whether an integer type is signed or not.
4240 Optionally treat bitfields as signed by default. */
4241 if (specbits & 1 << (int) RID_UNSIGNED
4242 /* Traditionally, all bitfields are unsigned. */
4243 || (bitfield && flag_traditional
4244 && (! explicit_flag_signed_bitfields || !flag_signed_bitfields))
4245 || (bitfield && ! flag_signed_bitfields
4246 && (explicit_int || defaulted_int || explicit_char
4247 /* A typedef for plain `int' without `signed'
4248 can be controlled just like plain `int'. */
4249 || ! (typedef_decl != 0
4250 && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl)))
4251 && TREE_CODE (type) != ENUMERAL_TYPE
4252 && !(specbits & 1 << (int) RID_SIGNED)))
4255 type = long_long_unsigned_type_node;
4256 else if (specbits & 1 << (int) RID_LONG)
4257 type = long_unsigned_type_node;
4258 else if (specbits & 1 << (int) RID_SHORT)
4259 type = short_unsigned_type_node;
4260 else if (type == char_type_node)
4261 type = unsigned_char_type_node;
4262 else if (typedef_decl)
4263 type = unsigned_type (type);
4265 type = unsigned_type_node;
4267 else if ((specbits & 1 << (int) RID_SIGNED)
4268 && type == char_type_node)
4269 type = signed_char_type_node;
4271 type = long_long_integer_type_node;
4272 else if (specbits & 1 << (int) RID_LONG)
4273 type = long_integer_type_node;
4274 else if (specbits & 1 << (int) RID_SHORT)
4275 type = short_integer_type_node;
4277 if (specbits & 1 << (int) RID_COMPLEX)
4279 if (pedantic && !flag_isoc99)
4280 pedwarn ("ISO C89 does not support complex types");
4281 /* If we just have "complex", it is equivalent to
4282 "complex double", but if any modifiers at all are specified it is
4283 the complex form of TYPE. E.g, "complex short" is
4284 "complex short int". */
4286 if (defaulted_int && ! longlong
4287 && ! (specbits & ((1 << (int) RID_LONG) | (1 << (int) RID_SHORT)
4288 | (1 << (int) RID_SIGNED)
4289 | (1 << (int) RID_UNSIGNED))))
4292 pedwarn ("ISO C does not support plain `complex' meaning `double complex'");
4293 type = complex_double_type_node;
4295 else if (type == integer_type_node)
4298 pedwarn ("ISO C does not support complex integer types");
4299 type = complex_integer_type_node;
4301 else if (type == float_type_node)
4302 type = complex_float_type_node;
4303 else if (type == double_type_node)
4304 type = complex_double_type_node;
4305 else if (type == long_double_type_node)
4306 type = complex_long_double_type_node;
4310 pedwarn ("ISO C does not support complex integer types");
4311 type = build_complex_type (type);
4315 /* Figure out the type qualifiers for the declaration. There are
4316 two ways a declaration can become qualified. One is something
4317 like `const int i' where the `const' is explicit. Another is
4318 something like `typedef const int CI; CI i' where the type of the
4319 declaration contains the `const'. */
4320 constp = !! (specbits & 1 << (int) RID_CONST) + TYPE_READONLY (type);
4321 restrictp = !! (specbits & 1 << (int) RID_RESTRICT) + TYPE_RESTRICT (type);
4322 volatilep = !! (specbits & 1 << (int) RID_VOLATILE) + TYPE_VOLATILE (type);
4323 inlinep = !! (specbits & (1 << (int) RID_INLINE));
4324 if (constp > 1 && ! flag_isoc99)
4325 pedwarn ("duplicate `const'");
4326 if (restrictp > 1 && ! flag_isoc99)
4327 pedwarn ("duplicate `restrict'");
4328 if (volatilep > 1 && ! flag_isoc99)
4329 pedwarn ("duplicate `volatile'");
4330 if (! flag_gen_aux_info && (TYPE_QUALS (type)))
4331 type = TYPE_MAIN_VARIANT (type);
4332 type_quals = ((constp ? TYPE_QUAL_CONST : 0)
4333 | (restrictp ? TYPE_QUAL_RESTRICT : 0)
4334 | (volatilep ? TYPE_QUAL_VOLATILE : 0));
4336 /* Warn if two storage classes are given. Default to `auto'. */
4341 if (specbits & 1 << (int) RID_AUTO) nclasses++;
4342 if (specbits & 1 << (int) RID_STATIC) nclasses++;
4343 if (specbits & 1 << (int) RID_EXTERN) nclasses++;
4344 if (specbits & 1 << (int) RID_REGISTER) nclasses++;
4345 if (specbits & 1 << (int) RID_TYPEDEF) nclasses++;
4347 /* Warn about storage classes that are invalid for certain
4348 kinds of declarations (parameters, typenames, etc.). */
4351 error ("multiple storage classes in declaration of `%s'", name);
4352 else if (funcdef_flag
4354 & ((1 << (int) RID_REGISTER)
4355 | (1 << (int) RID_AUTO)
4356 | (1 << (int) RID_TYPEDEF))))
4358 if (specbits & 1 << (int) RID_AUTO
4359 && (pedantic || current_binding_level == global_binding_level))
4360 pedwarn ("function definition declared `auto'");
4361 if (specbits & 1 << (int) RID_REGISTER)
4362 error ("function definition declared `register'");
4363 if (specbits & 1 << (int) RID_TYPEDEF)
4364 error ("function definition declared `typedef'");
4365 specbits &= ~((1 << (int) RID_TYPEDEF) | (1 << (int) RID_REGISTER)
4366 | (1 << (int) RID_AUTO));
4368 else if (decl_context != NORMAL && nclasses > 0)
4370 if (decl_context == PARM && specbits & 1 << (int) RID_REGISTER)
4374 switch (decl_context)
4377 error ("storage class specified for structure field `%s'",
4381 error ("storage class specified for parameter `%s'", name);
4384 error ("storage class specified for typename");
4387 specbits &= ~((1 << (int) RID_TYPEDEF) | (1 << (int) RID_REGISTER)
4388 | (1 << (int) RID_AUTO) | (1 << (int) RID_STATIC)
4389 | (1 << (int) RID_EXTERN));
4392 else if (specbits & 1 << (int) RID_EXTERN && initialized && ! funcdef_flag)
4394 /* `extern' with initialization is invalid if not at top level. */
4395 if (current_binding_level == global_binding_level)
4396 warning ("`%s' initialized and declared `extern'", name);
4398 error ("`%s' has both `extern' and initializer", name);
4400 else if (specbits & 1 << (int) RID_EXTERN && funcdef_flag
4401 && current_binding_level != global_binding_level)
4402 error ("nested function `%s' declared `extern'", name);
4403 else if (current_binding_level == global_binding_level
4404 && specbits & (1 << (int) RID_AUTO))
4405 error ("top-level declaration of `%s' specifies `auto'", name);
4408 /* Now figure out the structure of the declarator proper.
4409 Descend through it, creating more complex types, until we reach
4410 the declared identifier (or NULL_TREE, in an absolute declarator). */
4412 while (declarator && TREE_CODE (declarator) != IDENTIFIER_NODE)
4414 if (type == error_mark_node)
4416 declarator = TREE_OPERAND (declarator, 0);
4420 /* Each level of DECLARATOR is either an ARRAY_REF (for ...[..]),
4421 an INDIRECT_REF (for *...),
4422 a CALL_EXPR (for ...(...)),
4423 a TREE_LIST (for nested attributes),
4424 an identifier (for the name being declared)
4425 or a null pointer (for the place in an absolute declarator
4426 where the name was omitted).
4427 For the last two cases, we have just exited the loop.
4429 At this point, TYPE is the type of elements of an array,
4430 or for a function to return, or for a pointer to point to.
4431 After this sequence of ifs, TYPE is the type of the
4432 array or function or pointer, and DECLARATOR has had its
4433 outermost layer removed. */
4435 if (array_ptr_quals != NULL_TREE || array_parm_static)
4437 /* Only the innermost declarator (making a parameter be of
4438 array type which is converted to pointer type)
4439 may have static or type qualifiers. */
4440 error ("static or type qualifiers in non-parameter array declarator");
4441 array_ptr_quals = NULL_TREE;
4442 array_parm_static = 0;
4445 if (TREE_CODE (declarator) == TREE_LIST)
4447 /* We encode a declarator with embedded attributes using
4449 tree attrs = TREE_PURPOSE (declarator);
4452 declarator = TREE_VALUE (declarator);
4453 inner_decl = declarator;
4454 while (inner_decl != NULL_TREE
4455 && TREE_CODE (inner_decl) == TREE_LIST)
4456 inner_decl = TREE_VALUE (inner_decl);
4457 if (inner_decl == NULL_TREE
4458 || TREE_CODE (inner_decl) == IDENTIFIER_NODE)
4459 attr_flags |= (int) ATTR_FLAG_DECL_NEXT;
4460 if (TREE_CODE (inner_decl) == CALL_EXPR)
4461 attr_flags |= (int) ATTR_FLAG_FUNCTION_NEXT;
4462 if (TREE_CODE (inner_decl) == ARRAY_REF)
4463 attr_flags |= (int) ATTR_FLAG_ARRAY_NEXT;
4464 returned_attrs = decl_attributes (&type,
4465 chainon (returned_attrs, attrs),
4468 else if (TREE_CODE (declarator) == ARRAY_REF)
4470 tree itype = NULL_TREE;
4471 tree size = TREE_OPERAND (declarator, 1);
4472 /* The index is a signed object `sizetype' bits wide. */
4473 tree index_type = signed_type (sizetype);
4475 array_ptr_quals = TREE_TYPE (declarator);
4476 array_parm_static = TREE_STATIC (declarator);
4478 declarator = TREE_OPERAND (declarator, 0);
4480 /* Check for some types that there cannot be arrays of. */
4482 if (VOID_TYPE_P (type))
4484 error ("declaration of `%s' as array of voids", name);
4485 type = error_mark_node;
4488 if (TREE_CODE (type) == FUNCTION_TYPE)
4490 error ("declaration of `%s' as array of functions", name);
4491 type = error_mark_node;
4494 if (size == error_mark_node)
4495 type = error_mark_node;
4497 if (type == error_mark_node)
4500 /* If size was specified, set ITYPE to a range-type for that size.
4501 Otherwise, ITYPE remains null. finish_decl may figure it out
4502 from an initial value. */
4506 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue. */
4507 STRIP_TYPE_NOPS (size);
4509 if (! INTEGRAL_TYPE_P (TREE_TYPE (size)))
4511 error ("size of array `%s' has non-integer type", name);
4512 size = integer_one_node;
4515 if (pedantic && integer_zerop (size))
4516 pedwarn ("ISO C forbids zero-size array `%s'", name);
4518 if (TREE_CODE (size) == INTEGER_CST)
4520 constant_expression_warning (size);
4521 if (tree_int_cst_sgn (size) < 0)
4523 error ("size of array `%s' is negative", name);
4524 size = integer_one_node;
4529 /* Make sure the array size remains visibly nonconstant
4530 even if it is (eg) a const variable with known value. */
4535 if (TREE_CONSTANT (size))
4536 pedwarn ("ISO C89 forbids array `%s' whose size can't be evaluated",
4539 pedwarn ("ISO C89 forbids variable-size array `%s'",
4544 if (integer_zerop (size))
4546 /* A zero-length array cannot be represented with an
4547 unsigned index type, which is what we'll get with
4548 build_index_type. Create an open-ended range instead. */
4549 itype = build_range_type (sizetype, size, NULL_TREE);
4553 /* Compute the maximum valid index, that is, size - 1.
4554 Do the calculation in index_type, so that if it is
4555 a variable the computations will be done in the
4557 itype = fold (build (MINUS_EXPR, index_type,
4558 convert (index_type, size),
4559 convert (index_type, size_one_node)));
4561 /* If that overflowed, the array is too big.
4562 ??? While a size of INT_MAX+1 technically shouldn't
4563 cause an overflow (because we subtract 1), the overflow
4564 is recorded during the conversion to index_type, before
4565 the subtraction. Handling this case seems like an
4566 unnecessary complication. */
4567 if (TREE_OVERFLOW (itype))
4569 error ("size of array `%s' is too large", name);
4570 type = error_mark_node;
4575 itype = variable_size (itype);
4576 itype = build_index_type (itype);
4579 else if (decl_context == FIELD)
4581 /* ??? Need to check somewhere that this is a structure
4582 and not a union, that this field is last, and that
4583 this structure has at least one other named member. */
4585 if (pedantic && !flag_isoc99 && !in_system_header)
4586 pedwarn ("ISO C89 does not support flexible array members");
4588 /* ISO C99 Flexible array members are effectively identical
4589 to GCC's zero-length array extension. */
4590 itype = build_range_type (sizetype, size_zero_node, NULL_TREE);
4593 /* If pedantic, complain about arrays of incomplete types. */
4595 if (pedantic && !COMPLETE_TYPE_P (type))
4596 pedwarn ("array type has incomplete element type");
4599 /* We shouldn't have a function type here at all!
4600 Functions aren't allowed as array elements. */
4601 if (pedantic && TREE_CODE (type) == FUNCTION_TYPE
4602 && (constp || volatilep))
4603 pedwarn ("ISO C forbids const or volatile function types");
4606 /* Build the array type itself, then merge any constancy or
4607 volatility into the target type. We must do it in this order
4608 to ensure that the TYPE_MAIN_VARIANT field of the array type
4609 is set correctly. */
4611 type = build_array_type (type, itype);
4613 type = c_build_qualified_type (type, type_quals);
4616 C_TYPE_VARIABLE_SIZE (type) = 1;
4618 /* The GCC extension for zero-length arrays differs from
4619 ISO flexible array members in that sizeof yields zero. */
4620 if (size && integer_zerop (size))
4623 TYPE_SIZE (type) = bitsize_zero_node;
4624 TYPE_SIZE_UNIT (type) = size_zero_node;
4626 if (decl_context != PARM
4627 && (array_ptr_quals != NULL_TREE || array_parm_static))
4629 error ("static or type qualifiers in non-parameter array declarator");
4630 array_ptr_quals = NULL_TREE;
4631 array_parm_static = 0;
4634 else if (TREE_CODE (declarator) == CALL_EXPR)
4638 /* Declaring a function type.
4639 Make sure we have a valid type for the function to return. */
4640 if (type == error_mark_node)
4645 /* Warn about some types functions can't return. */
4647 if (TREE_CODE (type) == FUNCTION_TYPE)
4649 error ("`%s' declared as function returning a function", name);
4650 type = integer_type_node;
4652 if (TREE_CODE (type) == ARRAY_TYPE)
4654 error ("`%s' declared as function returning an array", name);
4655 type = integer_type_node;
4658 #ifndef TRADITIONAL_RETURN_FLOAT
4659 /* Traditionally, declaring return type float means double. */
4661 if (flag_traditional && TYPE_MAIN_VARIANT (type) == float_type_node)
4662 type = double_type_node;
4663 #endif /* TRADITIONAL_RETURN_FLOAT */
4665 /* Construct the function type and go to the next
4666 inner layer of declarator. */
4668 arg_types = grokparms (TREE_OPERAND (declarator, 1),
4670 /* Say it's a definition
4671 only for the CALL_EXPR
4672 closest to the identifier. */
4673 && TREE_CODE (TREE_OPERAND (declarator, 0)) == IDENTIFIER_NODE);
4674 /* Type qualifiers before the return type of the function
4675 qualify the return type, not the function type. */
4678 /* Type qualifiers on a function return type are normally
4679 permitted by the standard but have no effect, so give a
4680 warning at -W. Qualifiers on a void return type have
4681 meaning as a GNU extension, and are banned on function
4682 definitions in ISO C. FIXME: strictly we shouldn't
4683 pedwarn for qualified void return types except on function
4684 definitions, but not doing so could lead to the undesirable
4685 state of a "volatile void" function return type not being
4686 warned about, and a use of the function being compiled
4687 with GNU semantics, with no diagnostics under -pedantic. */
4688 if (VOID_TYPE_P (type) && pedantic && !in_system_header)
4689 pedwarn ("ISO C forbids qualified void function return type");
4690 else if (extra_warnings
4691 && !(VOID_TYPE_P (type)
4692 && type_quals == TYPE_QUAL_VOLATILE))
4693 warning ("type qualifiers ignored on function return type");
4695 type = c_build_qualified_type (type, type_quals);
4697 type_quals = TYPE_UNQUALIFIED;
4699 type = build_function_type (type, arg_types);
4700 declarator = TREE_OPERAND (declarator, 0);
4702 /* Set the TYPE_CONTEXTs for each tagged type which is local to
4703 the formal parameter list of this FUNCTION_TYPE to point to
4704 the FUNCTION_TYPE node itself. */
4709 for (link = last_function_parm_tags;
4711 link = TREE_CHAIN (link))
4712 TYPE_CONTEXT (TREE_VALUE (link)) = type;
4715 else if (TREE_CODE (declarator) == INDIRECT_REF)
4717 /* Merge any constancy or volatility into the target type
4720 if (pedantic && TREE_CODE (type) == FUNCTION_TYPE
4722 pedwarn ("ISO C forbids qualified function types");
4724 type = c_build_qualified_type (type, type_quals);
4725 type_quals = TYPE_UNQUALIFIED;
4728 type = build_pointer_type (type);
4730 /* Process a list of type modifier keywords
4731 (such as const or volatile) that were given inside the `*'. */
4733 if (TREE_TYPE (declarator))
4741 for (typemodlist = TREE_TYPE (declarator); typemodlist;
4742 typemodlist = TREE_CHAIN (typemodlist))
4744 tree qualifier = TREE_VALUE (typemodlist);
4746 if (C_IS_RESERVED_WORD (qualifier))
4748 if (C_RID_CODE (qualifier) == RID_CONST)
4750 else if (C_RID_CODE (qualifier) == RID_VOLATILE)
4752 else if (C_RID_CODE (qualifier) == RID_RESTRICT)
4762 error ("invalid type modifier within pointer declarator");
4763 if (constp > 1 && ! flag_isoc99)
4764 pedwarn ("duplicate `const'");
4765 if (volatilep > 1 && ! flag_isoc99)
4766 pedwarn ("duplicate `volatile'");
4767 if (restrictp > 1 && ! flag_isoc99)
4768 pedwarn ("duplicate `restrict'");
4770 type_quals = ((constp ? TYPE_QUAL_CONST : 0)
4771 | (restrictp ? TYPE_QUAL_RESTRICT : 0)
4772 | (volatilep ? TYPE_QUAL_VOLATILE : 0));
4775 declarator = TREE_OPERAND (declarator, 0);
4782 /* Now TYPE has the actual type. */
4784 /* Did array size calculations overflow? */
4786 if (TREE_CODE (type) == ARRAY_TYPE
4787 && COMPLETE_TYPE_P (type)
4788 && TREE_OVERFLOW (TYPE_SIZE (type)))
4790 error ("size of array `%s' is too large", name);
4791 /* If we proceed with the array type as it is, we'll eventually
4792 crash in tree_low_cst(). */
4793 type = error_mark_node;
4796 /* If this is declaring a typedef name, return a TYPE_DECL. */
4798 if (specbits & (1 << (int) RID_TYPEDEF))
4801 /* Note that the grammar rejects storage classes
4802 in typenames, fields or parameters */
4803 if (pedantic && TREE_CODE (type) == FUNCTION_TYPE
4805 pedwarn ("ISO C forbids qualified function types");
4807 type = c_build_qualified_type (type, type_quals);
4808 decl = build_decl (TYPE_DECL, declarator, type);
4809 if ((specbits & (1 << (int) RID_SIGNED))
4810 || (typedef_decl && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl)))
4811 C_TYPEDEF_EXPLICITLY_SIGNED (decl) = 1;
4812 decl_attributes (&decl, returned_attrs, 0);
4816 /* Detect the case of an array type of unspecified size
4817 which came, as such, direct from a typedef name.
4818 We must copy the type, so that each identifier gets
4819 a distinct type, so that each identifier's size can be
4820 controlled separately by its own initializer. */
4822 if (type != 0 && typedef_type != 0
4823 && TREE_CODE (type) == ARRAY_TYPE && TYPE_DOMAIN (type) == 0
4824 && TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (typedef_type))
4826 type = build_array_type (TREE_TYPE (type), 0);
4828 C_TYPE_VARIABLE_SIZE (type) = 1;
4831 /* If this is a type name (such as, in a cast or sizeof),
4832 compute the type and return it now. */
4834 if (decl_context == TYPENAME)
4836 /* Note that the grammar rejects storage classes
4837 in typenames, fields or parameters */
4838 if (pedantic && TREE_CODE (type) == FUNCTION_TYPE
4840 pedwarn ("ISO C forbids const or volatile function types");
4842 type = c_build_qualified_type (type, type_quals);
4843 decl_attributes (&type, returned_attrs, 0);
4847 /* Aside from typedefs and type names (handle above),
4848 `void' at top level (not within pointer)
4849 is allowed only in public variables.
4850 We don't complain about parms either, but that is because
4851 a better error message can be made later. */
4853 if (VOID_TYPE_P (type) && decl_context != PARM
4854 && ! ((decl_context != FIELD && TREE_CODE (type) != FUNCTION_TYPE)
4855 && ((specbits & (1 << (int) RID_EXTERN))
4856 || (current_binding_level == global_binding_level
4858 & ((1 << (int) RID_STATIC) | (1 << (int) RID_REGISTER)))))))
4860 error ("variable or field `%s' declared void", name);
4861 type = integer_type_node;
4864 /* Now create the decl, which may be a VAR_DECL, a PARM_DECL
4865 or a FUNCTION_DECL, depending on DECL_CONTEXT and TYPE. */
4870 if (decl_context == PARM)
4872 tree type_as_written;
4875 /* A parameter declared as an array of T is really a pointer to T.
4876 One declared as a function is really a pointer to a function. */
4878 if (TREE_CODE (type) == ARRAY_TYPE)
4880 /* Transfer const-ness of array into that of type pointed to. */
4881 type = TREE_TYPE (type);
4883 type = c_build_qualified_type (type, type_quals);
4884 type = build_pointer_type (type);
4885 type_quals = TYPE_UNQUALIFIED;
4886 if (array_ptr_quals)
4888 tree new_ptr_quals, new_ptr_attrs;
4890 split_specs_attrs (array_ptr_quals, &new_ptr_quals, &new_ptr_attrs);
4891 /* We don't yet implement attributes in this context. */
4892 if (new_ptr_attrs != NULL_TREE)
4893 warning ("attributes in parameter array declarator ignored");
4898 for (; new_ptr_quals; new_ptr_quals = TREE_CHAIN (new_ptr_quals))
4900 tree qualifier = TREE_VALUE (new_ptr_quals);
4902 if (C_IS_RESERVED_WORD (qualifier))
4904 if (C_RID_CODE (qualifier) == RID_CONST)
4906 else if (C_RID_CODE (qualifier) == RID_VOLATILE)
4908 else if (C_RID_CODE (qualifier) == RID_RESTRICT)
4918 error ("invalid type modifier within array declarator");
4920 type_quals = ((constp ? TYPE_QUAL_CONST : 0)
4921 | (restrictp ? TYPE_QUAL_RESTRICT : 0)
4922 | (volatilep ? TYPE_QUAL_VOLATILE : 0));
4926 else if (TREE_CODE (type) == FUNCTION_TYPE)
4928 if (pedantic && type_quals)
4929 pedwarn ("ISO C forbids qualified function types");
4931 type = c_build_qualified_type (type, type_quals);
4932 type = build_pointer_type (type);
4933 type_quals = TYPE_UNQUALIFIED;
4935 else if (type_quals)
4936 type = c_build_qualified_type (type, type_quals);
4938 type_as_written = type;
4940 decl = build_decl (PARM_DECL, declarator, type);
4942 C_DECL_VARIABLE_SIZE (decl) = 1;
4944 /* Compute the type actually passed in the parmlist,
4945 for the case where there is no prototype.
4946 (For example, shorts and chars are passed as ints.)
4947 When there is a prototype, this is overridden later. */
4949 if (type == error_mark_node)
4950 promoted_type = type;
4953 promoted_type = simple_type_promotes_to (type);
4954 if (! promoted_type)
4955 promoted_type = type;
4958 DECL_ARG_TYPE (decl) = promoted_type;
4959 DECL_ARG_TYPE_AS_WRITTEN (decl) = type_as_written;
4961 else if (decl_context == FIELD)
4963 /* Structure field. It may not be a function. */
4965 if (TREE_CODE (type) == FUNCTION_TYPE)
4967 error ("field `%s' declared as a function", name);
4968 type = build_pointer_type (type);
4970 else if (TREE_CODE (type) != ERROR_MARK
4971 && !COMPLETE_OR_UNBOUND_ARRAY_TYPE_P (type))
4973 error ("field `%s' has incomplete type", name);
4974 type = error_mark_node;
4976 /* Move type qualifiers down to element of an array. */
4977 if (TREE_CODE (type) == ARRAY_TYPE && type_quals)
4979 type = build_array_type (c_build_qualified_type (TREE_TYPE (type),
4981 TYPE_DOMAIN (type));
4983 /* Leave the field const or volatile as well. */
4984 type_quals = TYPE_UNQUALIFIED;
4987 decl = build_decl (FIELD_DECL, declarator, type);
4988 DECL_NONADDRESSABLE_P (decl) = bitfield;
4991 C_DECL_VARIABLE_SIZE (decl) = 1;
4993 else if (TREE_CODE (type) == FUNCTION_TYPE)
4995 /* Every function declaration is "external"
4996 except for those which are inside a function body
4997 in which `auto' is used.
4998 That is a case not specified by ANSI C,
4999 and we use it for forward declarations for nested functions. */
5000 int extern_ref = (!(specbits & (1 << (int) RID_AUTO))
5001 || current_binding_level == global_binding_level);
5003 if (specbits & (1 << (int) RID_AUTO)
5004 && (pedantic || current_binding_level == global_binding_level))
5005 pedwarn ("invalid storage class for function `%s'", name);
5006 if (specbits & (1 << (int) RID_REGISTER))
5007 error ("invalid storage class for function `%s'", name);
5008 /* Function declaration not at top level.
5009 Storage classes other than `extern' are not allowed
5010 and `extern' makes no difference. */
5011 if (current_binding_level != global_binding_level
5012 && (specbits & ((1 << (int) RID_STATIC) | (1 << (int) RID_INLINE)))
5014 pedwarn ("invalid storage class for function `%s'", name);
5016 decl = build_decl (FUNCTION_DECL, declarator, type);
5017 decl = build_decl_attribute_variant (decl, decl_attr);
5019 DECL_LANG_SPECIFIC (decl) = (struct lang_decl *)
5020 ggc_alloc_cleared (sizeof (struct lang_decl));
5022 if (pedantic && type_quals && ! DECL_IN_SYSTEM_HEADER (decl))
5023 pedwarn ("ISO C forbids qualified function types");
5025 /* GNU C interprets a `volatile void' return type to indicate
5026 that the function does not return. */
5027 if ((type_quals & TYPE_QUAL_VOLATILE)
5028 && !VOID_TYPE_P (TREE_TYPE (TREE_TYPE (decl))))
5029 warning ("`noreturn' function returns non-void value");
5032 DECL_EXTERNAL (decl) = 1;
5033 /* Record absence of global scope for `static' or `auto'. */
5035 = !(specbits & ((1 << (int) RID_STATIC) | (1 << (int) RID_AUTO)));
5037 /* Record presence of `inline', if it is reasonable. */
5038 if (MAIN_NAME_P (declarator))
5041 warning ("cannot inline function `main'");
5045 /* Assume that otherwise the function can be inlined. */
5046 DECL_INLINE (decl) = 1;
5047 DECL_DECLARED_INLINE_P (decl) = 1;
5049 if (specbits & (1 << (int) RID_EXTERN))
5050 current_extern_inline = 1;
5052 /* If -finline-functions, assume it can be inlined. This does
5053 two things: let the function be deferred until it is actually
5054 needed, and let dwarf2 know that the function is inlinable. */
5055 else if (flag_inline_trees == 2)
5057 DECL_INLINE (decl) = 1;
5058 DECL_DECLARED_INLINE_P (decl) = 0;
5063 /* It's a variable. */
5064 /* An uninitialized decl with `extern' is a reference. */
5065 int extern_ref = !initialized && (specbits & (1 << (int) RID_EXTERN));
5067 /* Move type qualifiers down to element of an array. */
5068 if (TREE_CODE (type) == ARRAY_TYPE && type_quals)
5070 int saved_align = TYPE_ALIGN(type);
5071 type = build_array_type (c_build_qualified_type (TREE_TYPE (type),
5073 TYPE_DOMAIN (type));
5074 TYPE_ALIGN (type) = saved_align;
5075 #if 0 /* Leave the variable const or volatile as well. */
5076 type_quals = TYPE_UNQUALIFIED;
5079 else if (type_quals)
5080 type = c_build_qualified_type (type, type_quals);
5082 decl = build_decl (VAR_DECL, declarator, type);
5084 C_DECL_VARIABLE_SIZE (decl) = 1;
5087 pedwarn_with_decl (decl, "variable `%s' declared `inline'");
5089 DECL_EXTERNAL (decl) = extern_ref;
5090 /* At top level, the presence of a `static' or `register' storage
5091 class specifier, or the absence of all storage class specifiers
5092 makes this declaration a definition (perhaps tentative). Also,
5093 the absence of both `static' and `register' makes it public. */
5094 if (current_binding_level == global_binding_level)
5098 & ((1 << (int) RID_STATIC) | (1 << (int) RID_REGISTER)));
5099 TREE_STATIC (decl) = ! DECL_EXTERNAL (decl);
5101 /* Not at top level, only `static' makes a static definition. */
5104 TREE_STATIC (decl) = (specbits & (1 << (int) RID_STATIC)) != 0;
5105 TREE_PUBLIC (decl) = DECL_EXTERNAL (decl);
5109 /* Record `register' declaration for warnings on &
5110 and in case doing stupid register allocation. */
5112 if (specbits & (1 << (int) RID_REGISTER))
5113 DECL_REGISTER (decl) = 1;
5115 /* Record constancy and volatility. */
5116 c_apply_type_quals_to_decl (type_quals, decl);
5118 /* If a type has volatile components, it should be stored in memory.
5119 Otherwise, the fact that those components are volatile
5120 will be ignored, and would even crash the compiler. */
5121 if (C_TYPE_FIELDS_VOLATILE (TREE_TYPE (decl)))
5122 mark_addressable (decl);
5124 decl_attributes (&decl, returned_attrs, 0);
5130 /* Decode the parameter-list info for a function type or function definition.
5131 The argument is the value returned by `get_parm_info' (or made in parse.y
5132 if there is an identifier list instead of a parameter decl list).
5133 These two functions are separate because when a function returns
5134 or receives functions then each is called multiple times but the order
5135 of calls is different. The last call to `grokparms' is always the one
5136 that contains the formal parameter names of a function definition.
5138 Store in `last_function_parms' a chain of the decls of parms.
5139 Also store in `last_function_parm_tags' a chain of the struct, union,
5140 and enum tags declared among the parms.
5142 Return a list of arg types to use in the FUNCTION_TYPE for this function.
5144 FUNCDEF_FLAG is nonzero for a function definition, 0 for
5145 a mere declaration. A nonempty identifier-list gets an error message
5146 when FUNCDEF_FLAG is zero. */
5149 grokparms (parms_info, funcdef_flag)
5153 tree first_parm = TREE_CHAIN (parms_info);
5155 last_function_parms = TREE_PURPOSE (parms_info);
5156 last_function_parm_tags = TREE_VALUE (parms_info);
5158 if (warn_strict_prototypes && first_parm == 0 && !funcdef_flag
5159 && !in_system_header)
5160 warning ("function declaration isn't a prototype");
5163 && TREE_CODE (TREE_VALUE (first_parm)) == IDENTIFIER_NODE)
5166 pedwarn ("parameter names (without types) in function declaration");
5168 last_function_parms = first_parm;
5175 /* We no longer test FUNCDEF_FLAG.
5176 If the arg types are incomplete in a declaration,
5177 they must include undefined tags.
5178 These tags can never be defined in the scope of the declaration,
5179 so the types can never be completed,
5180 and no call can be compiled successfully. */
5182 /* In a fcn definition, arg types must be complete. */
5185 for (parm = last_function_parms, typelt = first_parm;
5187 parm = TREE_CHAIN (parm))
5188 /* Skip over any enumeration constants declared here. */
5189 if (TREE_CODE (parm) == PARM_DECL)
5191 /* Barf if the parameter itself has an incomplete type. */
5192 tree type = TREE_VALUE (typelt);
5193 if (type == error_mark_node)
5195 if (!COMPLETE_TYPE_P (type))
5197 if (funcdef_flag && DECL_NAME (parm) != 0)
5198 error ("parameter `%s' has incomplete type",
5199 IDENTIFIER_POINTER (DECL_NAME (parm)));
5201 warning ("parameter has incomplete type");
5204 TREE_VALUE (typelt) = error_mark_node;
5205 TREE_TYPE (parm) = error_mark_node;
5209 /* This has been replaced by parm_tags_warning, which
5210 uses a more accurate criterion for what to warn
5214 /* Now warn if is a pointer to an incomplete type. */
5215 while (TREE_CODE (type) == POINTER_TYPE
5216 || TREE_CODE (type) == REFERENCE_TYPE)
5217 type = TREE_TYPE (type);
5218 type = TYPE_MAIN_VARIANT (type);
5219 if (!COMPLETE_TYPE_P (type))
5221 if (DECL_NAME (parm) != 0)
5222 warning ("parameter `%s' points to incomplete type",
5223 IDENTIFIER_POINTER (DECL_NAME (parm)));
5225 warning ("parameter points to incomplete type");
5229 typelt = TREE_CHAIN (typelt);
5236 /* Return a tree_list node with info on a parameter list just parsed.
5237 The TREE_PURPOSE is a chain of decls of those parms.
5238 The TREE_VALUE is a list of structure, union and enum tags defined.
5239 The TREE_CHAIN is a list of argument types to go in the FUNCTION_TYPE.
5240 This tree_list node is later fed to `grokparms'.
5242 VOID_AT_END nonzero means append `void' to the end of the type-list.
5243 Zero means the parmlist ended with an ellipsis so don't append `void'. */
5246 get_parm_info (void_at_end)
5252 tree tags = gettags ();
5253 tree parms = getdecls ();
5255 tree order = current_binding_level->parm_order;
5257 /* Just `void' (and no ellipsis) is special. There are really no parms.
5258 But if the `void' is qualified (by `const' or `volatile') or has a
5259 storage class specifier (`register'), then the behavior is undefined;
5260 by not counting it as the special case of `void' we will cause an
5261 error later. Typedefs for `void' are OK (see DR#157). */
5262 if (void_at_end && parms != 0
5263 && TREE_CHAIN (parms) == 0
5264 && VOID_TYPE_P (TREE_TYPE (parms))
5265 && ! TREE_THIS_VOLATILE (parms)
5266 && ! TREE_READONLY (parms)
5267 && ! DECL_REGISTER (parms)
5268 && DECL_NAME (parms) == 0)
5271 storedecls (NULL_TREE);
5272 return tree_cons (NULL_TREE, NULL_TREE,
5273 tree_cons (NULL_TREE, void_type_node, NULL_TREE));
5276 /* Extract enumerator values and other non-parms declared with the parms.
5277 Likewise any forward parm decls that didn't have real parm decls. */
5278 for (decl = parms; decl;)
5280 tree next = TREE_CHAIN (decl);
5282 if (TREE_CODE (decl) != PARM_DECL)
5284 TREE_CHAIN (decl) = new_parms;
5287 else if (TREE_ASM_WRITTEN (decl))
5289 error_with_decl (decl,
5290 "parameter `%s' has just a forward declaration");
5291 TREE_CHAIN (decl) = new_parms;
5297 /* Put the parm decls back in the order they were in in the parm list. */
5298 for (t = order; t; t = TREE_CHAIN (t))
5301 TREE_CHAIN (TREE_VALUE (t)) = TREE_VALUE (TREE_CHAIN (t));
5303 TREE_CHAIN (TREE_VALUE (t)) = 0;
5306 new_parms = chainon (order ? nreverse (TREE_VALUE (order)) : 0,
5309 /* Store the parmlist in the binding level since the old one
5310 is no longer a valid list. (We have changed the chain pointers.) */
5311 storedecls (new_parms);
5313 for (decl = new_parms; decl; decl = TREE_CHAIN (decl))
5314 /* There may also be declarations for enumerators if an enumeration
5315 type is declared among the parms. Ignore them here. */
5316 if (TREE_CODE (decl) == PARM_DECL)
5318 /* Since there is a prototype,
5319 args are passed in their declared types. */
5320 tree type = TREE_TYPE (decl);
5321 DECL_ARG_TYPE (decl) = type;
5322 if (PROMOTE_PROTOTYPES
5323 && INTEGRAL_TYPE_P (type)
5324 && TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node))
5325 DECL_ARG_TYPE (decl) = integer_type_node;
5327 types = tree_cons (NULL_TREE, TREE_TYPE (decl), types);
5328 if (VOID_TYPE_P (TREE_VALUE (types)) && ! erred
5329 && DECL_NAME (decl) == 0)
5331 error ("`void' in parameter list must be the entire list");
5337 return tree_cons (new_parms, tags,
5338 nreverse (tree_cons (NULL_TREE, void_type_node, types)));
5340 return tree_cons (new_parms, tags, nreverse (types));
5343 /* At end of parameter list, warn about any struct, union or enum tags
5344 defined within. Do so because these types cannot ever become complete. */
5347 parmlist_tags_warning ()
5352 for (elt = current_binding_level->tags; elt; elt = TREE_CHAIN (elt))
5354 enum tree_code code = TREE_CODE (TREE_VALUE (elt));
5355 /* An anonymous union parm type is meaningful as a GNU extension.
5356 So don't warn for that. */
5357 if (code == UNION_TYPE && TREE_PURPOSE (elt) == 0 && !pedantic)
5359 if (TREE_PURPOSE (elt) != 0)
5361 if (code == RECORD_TYPE)
5362 warning ("`struct %s' declared inside parameter list",
5363 IDENTIFIER_POINTER (TREE_PURPOSE (elt)));
5364 else if (code == UNION_TYPE)
5365 warning ("`union %s' declared inside parameter list",
5366 IDENTIFIER_POINTER (TREE_PURPOSE (elt)));
5368 warning ("`enum %s' declared inside parameter list",
5369 IDENTIFIER_POINTER (TREE_PURPOSE (elt)));
5373 /* For translation these need to be separate warnings */
5374 if (code == RECORD_TYPE)
5375 warning ("anonymous struct declared inside parameter list");
5376 else if (code == UNION_TYPE)
5377 warning ("anonymous union declared inside parameter list");
5379 warning ("anonymous enum declared inside parameter list");
5383 warning ("its scope is only this definition or declaration, which is probably not what you want");
5389 /* Get the struct, enum or union (CODE says which) with tag NAME.
5390 Define the tag as a forward-reference if it is not defined. */
5393 xref_tag (code, name)
5394 enum tree_code code;
5397 /* If a cross reference is requested, look up the type
5398 already defined for this tag and return it. */
5400 tree ref = lookup_tag (code, name, current_binding_level, 0);
5401 /* If this is the right type of tag, return what we found.
5402 (This reference will be shadowed by shadow_tag later if appropriate.)
5403 If this is the wrong type of tag, do not return it. If it was the
5404 wrong type in the same binding level, we will have had an error
5405 message already; if in a different binding level and declaring
5406 a name, pending_xref_error will give an error message; but if in a
5407 different binding level and not declaring a name, this tag should
5408 shadow the previous declaration of a different type of tag, and
5409 this would not work properly if we return the reference found.
5410 (For example, with "struct foo" in an outer scope, "union foo;"
5411 must shadow that tag with a new one of union type.) */
5412 if (ref && TREE_CODE (ref) == code)
5415 /* If no such tag is yet defined, create a forward-reference node
5416 and record it as the "definition".
5417 When a real declaration of this type is found,
5418 the forward-reference will be altered into a real type. */
5420 ref = make_node (code);
5421 if (code == ENUMERAL_TYPE)
5423 /* Give the type a default layout like unsigned int
5424 to avoid crashing if it does not get defined. */
5425 TYPE_MODE (ref) = TYPE_MODE (unsigned_type_node);
5426 TYPE_ALIGN (ref) = TYPE_ALIGN (unsigned_type_node);
5427 TYPE_USER_ALIGN (ref) = 0;
5428 TREE_UNSIGNED (ref) = 1;
5429 TYPE_PRECISION (ref) = TYPE_PRECISION (unsigned_type_node);
5430 TYPE_MIN_VALUE (ref) = TYPE_MIN_VALUE (unsigned_type_node);
5431 TYPE_MAX_VALUE (ref) = TYPE_MAX_VALUE (unsigned_type_node);
5434 pushtag (name, ref);
5439 /* Make sure that the tag NAME is defined *in the current binding level*
5440 at least as a forward reference.
5441 CODE says which kind of tag NAME ought to be. */
5444 start_struct (code, name)
5445 enum tree_code code;
5448 /* If there is already a tag defined at this binding level
5449 (as a forward reference), just return it. */
5454 ref = lookup_tag (code, name, current_binding_level, 1);
5455 if (ref && TREE_CODE (ref) == code)
5457 C_TYPE_BEING_DEFINED (ref) = 1;
5458 TYPE_PACKED (ref) = flag_pack_struct;
5459 if (TYPE_FIELDS (ref))
5461 if (code == UNION_TYPE)
5462 error ("redefinition of `union %s'",
5463 IDENTIFIER_POINTER (name));
5465 error ("redefinition of `struct %s'",
5466 IDENTIFIER_POINTER (name));
5472 /* Otherwise create a forward-reference just so the tag is in scope. */
5474 ref = make_node (code);
5475 pushtag (name, ref);
5476 C_TYPE_BEING_DEFINED (ref) = 1;
5477 TYPE_PACKED (ref) = flag_pack_struct;
5481 /* Process the specs, declarator (NULL if omitted) and width (NULL if omitted)
5482 of a structure component, returning a FIELD_DECL node.
5483 WIDTH is non-NULL for bit fields only, and is an INTEGER_CST node.
5485 This is done during the parsing of the struct declaration.
5486 The FIELD_DECL nodes are chained together and the lot of them
5487 are ultimately passed to `build_struct' to make the RECORD_TYPE node. */
5490 grokfield (filename, line, declarator, declspecs, width)
5491 const char *filename ATTRIBUTE_UNUSED;
5492 int line ATTRIBUTE_UNUSED;
5493 tree declarator, declspecs, width;
5497 if (declarator == NULL_TREE && width == NULL_TREE)
5499 /* This is an unnamed decl. We only support unnamed
5500 structs/unions, so check for other things and refuse them. */
5501 if (TREE_CODE (TREE_VALUE (declspecs)) != RECORD_TYPE
5502 && TREE_CODE (TREE_VALUE (declspecs)) != UNION_TYPE)
5504 error ("unnamed fields of type other than struct or union are not allowed");
5509 value = grokdeclarator (declarator, declspecs, width ? BITFIELD : FIELD, 0);
5511 finish_decl (value, NULL_TREE, NULL_TREE);
5512 DECL_INITIAL (value) = width;
5514 maybe_objc_check_decl (value);
5518 /* Fill in the fields of a RECORD_TYPE or UNION_TYPE node, T.
5519 FIELDLIST is a chain of FIELD_DECL nodes for the fields.
5520 ATTRIBUTES are attributes to be applied to the structure. */
5523 finish_struct (t, fieldlist, attributes)
5529 int toplevel = global_binding_level == current_binding_level;
5530 int saw_named_field;
5532 /* If this type was previously laid out as a forward reference,
5533 make sure we lay it out again. */
5537 decl_attributes (&t, attributes, (int) ATTR_FLAG_TYPE_IN_PLACE);
5539 /* Nameless union parm types are useful as GCC extension. */
5540 if (! (TREE_CODE (t) == UNION_TYPE && TYPE_NAME (t) == 0) && !pedantic)
5541 /* Otherwise, warn about any struct or union def. in parmlist. */
5542 if (in_parm_level_p ())
5545 pedwarn ("%s defined inside parms",
5546 TREE_CODE (t) == UNION_TYPE ? _("union") : _("structure"));
5547 else if (! flag_traditional)
5548 warning ("%s defined inside parms",
5549 TREE_CODE (t) == UNION_TYPE ? _("union") : _("structure"));
5554 for (x = fieldlist; x; x = TREE_CHAIN (x))
5555 if (DECL_NAME (x) != 0)
5559 pedwarn ("%s has no %s",
5560 TREE_CODE (t) == UNION_TYPE ? _("union") : _("struct"),
5561 fieldlist ? _("named members") : _("members"));
5564 /* Install struct as DECL_CONTEXT of each field decl.
5565 Also process specified field sizes,m which is found in the DECL_INITIAL.
5566 Store 0 there, except for ": 0" fields (so we can find them
5567 and delete them, below). */
5569 saw_named_field = 0;
5570 for (x = fieldlist; x; x = TREE_CHAIN (x))
5572 DECL_CONTEXT (x) = t;
5573 DECL_PACKED (x) |= TYPE_PACKED (t);
5575 /* If any field is const, the structure type is pseudo-const. */
5576 if (TREE_READONLY (x))
5577 C_TYPE_FIELDS_READONLY (t) = 1;
5580 /* A field that is pseudo-const makes the structure likewise. */
5581 tree t1 = TREE_TYPE (x);
5582 while (TREE_CODE (t1) == ARRAY_TYPE)
5583 t1 = TREE_TYPE (t1);
5584 if ((TREE_CODE (t1) == RECORD_TYPE || TREE_CODE (t1) == UNION_TYPE)
5585 && C_TYPE_FIELDS_READONLY (t1))
5586 C_TYPE_FIELDS_READONLY (t) = 1;
5589 /* Any field that is volatile means variables of this type must be
5590 treated in some ways as volatile. */
5591 if (TREE_THIS_VOLATILE (x))
5592 C_TYPE_FIELDS_VOLATILE (t) = 1;
5594 /* Any field of nominal variable size implies structure is too. */
5595 if (C_DECL_VARIABLE_SIZE (x))
5596 C_TYPE_VARIABLE_SIZE (t) = 1;
5598 /* Detect invalid nested redefinition. */
5599 if (TREE_TYPE (x) == t)
5600 error ("nested redefinition of `%s'",
5601 IDENTIFIER_POINTER (TYPE_NAME (t)));
5603 /* Detect invalid bit-field size. */
5604 if (DECL_INITIAL (x))
5605 STRIP_NOPS (DECL_INITIAL (x));
5606 if (DECL_INITIAL (x))
5608 if (TREE_CODE (DECL_INITIAL (x)) == INTEGER_CST)
5609 constant_expression_warning (DECL_INITIAL (x));
5613 "bit-field `%s' width not an integer constant");
5614 DECL_INITIAL (x) = NULL;
5618 /* Detect invalid bit-field type. */
5619 if (DECL_INITIAL (x)
5620 && TREE_CODE (TREE_TYPE (x)) != INTEGER_TYPE
5621 && TREE_CODE (TREE_TYPE (x)) != BOOLEAN_TYPE
5622 && TREE_CODE (TREE_TYPE (x)) != ENUMERAL_TYPE)
5624 error_with_decl (x, "bit-field `%s' has invalid type");
5625 DECL_INITIAL (x) = NULL;
5628 if (DECL_INITIAL (x) && pedantic
5629 && TYPE_MAIN_VARIANT (TREE_TYPE (x)) != integer_type_node
5630 && TYPE_MAIN_VARIANT (TREE_TYPE (x)) != unsigned_type_node
5631 && TYPE_MAIN_VARIANT (TREE_TYPE (x)) != c_bool_type_node
5632 /* Accept an enum that's equivalent to int or unsigned int. */
5633 && !(TREE_CODE (TREE_TYPE (x)) == ENUMERAL_TYPE
5634 && (TYPE_PRECISION (TREE_TYPE (x))
5635 == TYPE_PRECISION (integer_type_node))))
5636 pedwarn_with_decl (x, "bit-field `%s' type invalid in ISO C");
5638 /* Detect and ignore out of range field width and process valid
5640 if (DECL_INITIAL (x))
5643 if (TYPE_MAIN_VARIANT (TREE_TYPE (x)) == c_bool_type_node)
5644 max_width = CHAR_TYPE_SIZE;
5646 max_width = TYPE_PRECISION (TREE_TYPE (x));
5647 if (tree_int_cst_sgn (DECL_INITIAL (x)) < 0)
5648 error_with_decl (x, "negative width in bit-field `%s'");
5649 else if (0 < compare_tree_int (DECL_INITIAL (x), max_width))
5650 pedwarn_with_decl (x, "width of `%s' exceeds its type");
5651 else if (integer_zerop (DECL_INITIAL (x)) && DECL_NAME (x) != 0)
5652 error_with_decl (x, "zero width for bit-field `%s'");
5655 /* The test above has assured us that TREE_INT_CST_HIGH is 0. */
5656 unsigned HOST_WIDE_INT width
5657 = TREE_INT_CST_LOW (DECL_INITIAL (x));
5659 if (TREE_CODE (TREE_TYPE (x)) == ENUMERAL_TYPE
5660 && (width < min_precision (TYPE_MIN_VALUE (TREE_TYPE (x)),
5661 TREE_UNSIGNED (TREE_TYPE (x)))
5663 < min_precision (TYPE_MAX_VALUE (TREE_TYPE (x)),
5664 TREE_UNSIGNED (TREE_TYPE (x))))))
5665 warning_with_decl (x,
5666 "`%s' is narrower than values of its type");
5668 DECL_SIZE (x) = bitsize_int (width);
5669 DECL_BIT_FIELD (x) = 1;
5670 SET_DECL_C_BIT_FIELD (x);
5674 /* field size 0 => force desired amount of alignment. */
5675 #ifdef EMPTY_FIELD_BOUNDARY
5676 DECL_ALIGN (x) = MAX (DECL_ALIGN (x), EMPTY_FIELD_BOUNDARY);
5678 #ifdef PCC_BITFIELD_TYPE_MATTERS
5679 if (PCC_BITFIELD_TYPE_MATTERS)
5681 DECL_ALIGN (x) = MAX (DECL_ALIGN (x),
5682 TYPE_ALIGN (TREE_TYPE (x)));
5683 DECL_USER_ALIGN (x) |= TYPE_USER_ALIGN (TREE_TYPE (x));
5690 else if (TREE_TYPE (x) != error_mark_node)
5692 unsigned int min_align = (DECL_PACKED (x) ? BITS_PER_UNIT
5693 : TYPE_ALIGN (TREE_TYPE (x)));
5695 /* Non-bit-fields are aligned for their type, except packed
5696 fields which require only BITS_PER_UNIT alignment. */
5697 DECL_ALIGN (x) = MAX (DECL_ALIGN (x), min_align);
5698 if (! DECL_PACKED (x))
5699 DECL_USER_ALIGN (x) |= TYPE_USER_ALIGN (TREE_TYPE (x));
5702 DECL_INITIAL (x) = 0;
5704 /* Detect flexible array member in an invalid context. */
5705 if (TREE_CODE (TREE_TYPE (x)) == ARRAY_TYPE
5706 && TYPE_SIZE (TREE_TYPE (x)) == NULL_TREE
5707 && TYPE_DOMAIN (TREE_TYPE (x)) != NULL_TREE
5708 && TYPE_MAX_VALUE (TYPE_DOMAIN (TREE_TYPE (x))) == NULL_TREE)
5710 if (TREE_CODE (t) == UNION_TYPE)
5711 error_with_decl (x, "flexible array member in union");
5712 else if (TREE_CHAIN (x) != NULL_TREE)
5713 error_with_decl (x, "flexible array member not at end of struct");
5714 else if (! saw_named_field)
5715 error_with_decl (x, "flexible array member in otherwise empty struct");
5718 saw_named_field = 1;
5721 /* Delete all duplicate fields from the fieldlist */
5722 for (x = fieldlist; x && TREE_CHAIN (x);)
5723 /* Anonymous fields aren't duplicates. */
5724 if (DECL_NAME (TREE_CHAIN (x)) == 0)
5732 if (DECL_NAME (y) == DECL_NAME (TREE_CHAIN (x)))
5738 if (DECL_NAME (y) == DECL_NAME (TREE_CHAIN (x)))
5740 error_with_decl (TREE_CHAIN (x), "duplicate member `%s'");
5741 TREE_CHAIN (x) = TREE_CHAIN (TREE_CHAIN (x));
5747 /* Now we have the nearly final fieldlist. Record it,
5748 then lay out the structure or union (including the fields). */
5750 TYPE_FIELDS (t) = fieldlist;
5754 /* Delete all zero-width bit-fields from the fieldlist */
5756 tree *fieldlistp = &fieldlist;
5758 if (TREE_CODE (*fieldlistp) == FIELD_DECL && DECL_INITIAL (*fieldlistp))
5759 *fieldlistp = TREE_CHAIN (*fieldlistp);
5761 fieldlistp = &TREE_CHAIN (*fieldlistp);
5764 /* Now we have the truly final field list.
5765 Store it in this type and in the variants. */
5767 TYPE_FIELDS (t) = fieldlist;
5769 for (x = TYPE_MAIN_VARIANT (t); x; x = TYPE_NEXT_VARIANT (x))
5771 TYPE_FIELDS (x) = TYPE_FIELDS (t);
5772 TYPE_LANG_SPECIFIC (x) = TYPE_LANG_SPECIFIC (t);
5773 TYPE_ALIGN (x) = TYPE_ALIGN (t);
5774 TYPE_USER_ALIGN (x) = TYPE_USER_ALIGN (t);
5777 /* If this was supposed to be a transparent union, but we can't
5778 make it one, warn and turn off the flag. */
5779 if (TREE_CODE (t) == UNION_TYPE
5780 && TYPE_TRANSPARENT_UNION (t)
5781 && TYPE_MODE (t) != DECL_MODE (TYPE_FIELDS (t)))
5783 TYPE_TRANSPARENT_UNION (t) = 0;
5784 warning ("union cannot be made transparent");
5787 /* If this structure or union completes the type of any previous
5788 variable declaration, lay it out and output its rtl. */
5790 if (current_binding_level->n_incomplete != 0)
5793 for (decl = current_binding_level->names; decl; decl = TREE_CHAIN (decl))
5795 if (TYPE_MAIN_VARIANT (TREE_TYPE (decl)) == TYPE_MAIN_VARIANT (t)
5796 && TREE_CODE (decl) != TYPE_DECL)
5798 layout_decl (decl, 0);
5799 /* This is a no-op in c-lang.c or something real in objc-actions.c. */
5800 maybe_objc_check_decl (decl);
5801 rest_of_decl_compilation (decl, NULL, toplevel, 0);
5804 if (--current_binding_level->n_incomplete == 0)
5807 else if (!COMPLETE_TYPE_P (TREE_TYPE (decl))
5808 && TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE)
5810 tree element = TREE_TYPE (decl);
5811 while (TREE_CODE (element) == ARRAY_TYPE)
5812 element = TREE_TYPE (element);
5815 layout_array_type (TREE_TYPE (decl));
5816 if (TREE_CODE (decl) != TYPE_DECL)
5818 layout_decl (decl, 0);
5819 maybe_objc_check_decl (decl);
5820 rest_of_decl_compilation (decl, NULL, toplevel, 0);
5824 if (--current_binding_level->n_incomplete == 0)
5831 /* Finish debugging output for this type. */
5832 rest_of_type_compilation (t, toplevel);
5837 /* Lay out the type T, and its element type, and so on. */
5840 layout_array_type (t)
5843 if (TREE_CODE (TREE_TYPE (t)) == ARRAY_TYPE)
5844 layout_array_type (TREE_TYPE (t));
5848 /* Begin compiling the definition of an enumeration type.
5849 NAME is its name (or null if anonymous).
5850 Returns the type object, as yet incomplete.
5851 Also records info about it so that build_enumerator
5852 may be used to declare the individual values as they are read. */
5860 /* If this is the real definition for a previous forward reference,
5861 fill in the contents in the same object that used to be the
5862 forward reference. */
5865 enumtype = lookup_tag (ENUMERAL_TYPE, name, current_binding_level, 1);
5867 if (enumtype == 0 || TREE_CODE (enumtype) != ENUMERAL_TYPE)
5869 enumtype = make_node (ENUMERAL_TYPE);
5870 pushtag (name, enumtype);
5873 C_TYPE_BEING_DEFINED (enumtype) = 1;
5875 if (TYPE_VALUES (enumtype) != 0)
5877 /* This enum is a named one that has been declared already. */
5878 error ("redeclaration of `enum %s'", IDENTIFIER_POINTER (name));
5880 /* Completely replace its old definition.
5881 The old enumerators remain defined, however. */
5882 TYPE_VALUES (enumtype) = 0;
5885 enum_next_value = integer_zero_node;
5888 if (flag_short_enums)
5889 TYPE_PACKED (enumtype) = 1;
5894 /* After processing and defining all the values of an enumeration type,
5895 install their decls in the enumeration type and finish it off.
5896 ENUMTYPE is the type object, VALUES a list of decl-value pairs,
5897 and ATTRIBUTES are the specified attributes.
5898 Returns ENUMTYPE. */
5901 finish_enum (enumtype, values, attributes)
5907 tree minnode = 0, maxnode = 0, enum_value_type;
5908 int precision, unsign;
5909 int toplevel = (global_binding_level == current_binding_level);
5911 if (in_parm_level_p ())
5912 warning ("enum defined inside parms");
5914 decl_attributes (&enumtype, attributes, (int) ATTR_FLAG_TYPE_IN_PLACE);
5916 /* Calculate the maximum value of any enumerator in this type. */
5918 if (values == error_mark_node)
5919 minnode = maxnode = integer_zero_node;
5922 minnode = maxnode = TREE_VALUE (values);
5923 for (pair = TREE_CHAIN (values); pair; pair = TREE_CHAIN (pair))
5925 tree value = TREE_VALUE (pair);
5926 if (tree_int_cst_lt (maxnode, value))
5928 if (tree_int_cst_lt (value, minnode))
5933 /* Construct the final type of this enumeration. It is the same
5934 as one of the integral types - the narrowest one that fits, except
5935 that normally we only go as narrow as int - and signed iff any of
5936 the values are negative. */
5937 unsign = (tree_int_cst_sgn (minnode) >= 0);
5938 precision = MAX (min_precision (minnode, unsign),
5939 min_precision (maxnode, unsign));
5940 if (TYPE_PACKED (enumtype) || precision > TYPE_PRECISION (integer_type_node))
5942 tree narrowest = type_for_size (precision, unsign);
5945 warning ("enumeration values exceed range of largest integer");
5946 narrowest = long_long_integer_type_node;
5949 precision = TYPE_PRECISION (narrowest);
5952 precision = TYPE_PRECISION (integer_type_node);
5954 if (precision == TYPE_PRECISION (integer_type_node))
5955 enum_value_type = type_for_size (precision, 0);
5957 enum_value_type = enumtype;
5959 TYPE_MIN_VALUE (enumtype) = minnode;
5960 TYPE_MAX_VALUE (enumtype) = maxnode;
5961 TYPE_PRECISION (enumtype) = precision;
5962 TREE_UNSIGNED (enumtype) = unsign;
5963 TYPE_SIZE (enumtype) = 0;
5964 layout_type (enumtype);
5966 if (values != error_mark_node)
5968 /* Change the type of the enumerators to be the enum type. We
5969 need to do this irrespective of the size of the enum, for
5970 proper type checking. Replace the DECL_INITIALs of the
5971 enumerators, and the value slots of the list, with copies
5972 that have the enum type; they cannot be modified in place
5973 because they may be shared (e.g. integer_zero_node) Finally,
5974 change the purpose slots to point to the names of the decls. */
5975 for (pair = values; pair; pair = TREE_CHAIN (pair))
5977 tree enu = TREE_PURPOSE (pair);
5979 TREE_TYPE (enu) = enumtype;
5980 DECL_SIZE (enu) = TYPE_SIZE (enumtype);
5981 DECL_SIZE_UNIT (enu) = TYPE_SIZE_UNIT (enumtype);
5982 DECL_ALIGN (enu) = TYPE_ALIGN (enumtype);
5983 DECL_USER_ALIGN (enu) = TYPE_USER_ALIGN (enumtype);
5984 DECL_MODE (enu) = TYPE_MODE (enumtype);
5986 /* The ISO C Standard mandates enumerators to have type int,
5987 even though the underlying type of an enum type is
5988 unspecified. Here we convert any enumerators that fit in
5989 an int to type int, to avoid promotions to unsigned types
5990 when comparing integers with enumerators that fit in the
5991 int range. When -pedantic is given, build_enumerator()
5992 would have already taken care of those that don't fit. */
5993 if (int_fits_type_p (DECL_INITIAL (enu), enum_value_type))
5994 DECL_INITIAL (enu) = convert (enum_value_type, DECL_INITIAL (enu));
5996 DECL_INITIAL (enu) = convert (enumtype, DECL_INITIAL (enu));
5998 TREE_PURPOSE (pair) = DECL_NAME (enu);
5999 TREE_VALUE (pair) = DECL_INITIAL (enu);
6002 TYPE_VALUES (enumtype) = values;
6005 /* Fix up all variant types of this enum type. */
6006 for (tem = TYPE_MAIN_VARIANT (enumtype); tem; tem = TYPE_NEXT_VARIANT (tem))
6008 if (tem == enumtype)
6010 TYPE_VALUES (tem) = TYPE_VALUES (enumtype);
6011 TYPE_MIN_VALUE (tem) = TYPE_MIN_VALUE (enumtype);
6012 TYPE_MAX_VALUE (tem) = TYPE_MAX_VALUE (enumtype);
6013 TYPE_SIZE (tem) = TYPE_SIZE (enumtype);
6014 TYPE_SIZE_UNIT (tem) = TYPE_SIZE_UNIT (enumtype);
6015 TYPE_MODE (tem) = TYPE_MODE (enumtype);
6016 TYPE_PRECISION (tem) = TYPE_PRECISION (enumtype);
6017 TYPE_ALIGN (tem) = TYPE_ALIGN (enumtype);
6018 TYPE_USER_ALIGN (tem) = TYPE_USER_ALIGN (enumtype);
6019 TREE_UNSIGNED (tem) = TREE_UNSIGNED (enumtype);
6022 /* Finish debugging output for this type. */
6023 rest_of_type_compilation (enumtype, toplevel);
6028 /* Build and install a CONST_DECL for one value of the
6029 current enumeration type (one that was begun with start_enum).
6030 Return a tree-list containing the CONST_DECL and its value.
6031 Assignment of sequential values by default is handled here. */
6034 build_enumerator (name, value)
6039 /* Validate and default VALUE. */
6041 /* Remove no-op casts from the value. */
6043 STRIP_TYPE_NOPS (value);
6047 if (TREE_CODE (value) == INTEGER_CST)
6049 value = default_conversion (value);
6050 constant_expression_warning (value);
6054 error ("enumerator value for `%s' not integer constant",
6055 IDENTIFIER_POINTER (name));
6060 /* Default based on previous value. */
6061 /* It should no longer be possible to have NON_LVALUE_EXPR
6065 value = enum_next_value;
6067 error ("overflow in enumeration values");
6070 if (pedantic && ! int_fits_type_p (value, integer_type_node))
6072 pedwarn ("ISO C restricts enumerator values to range of `int'");
6073 value = convert (integer_type_node, value);
6076 /* Set basis for default for next value. */
6077 enum_next_value = build_binary_op (PLUS_EXPR, value, integer_one_node, 0);
6078 enum_overflow = tree_int_cst_lt (enum_next_value, value);
6080 /* Now create a declaration for the enum value name. */
6082 type = TREE_TYPE (value);
6083 type = type_for_size (MAX (TYPE_PRECISION (type),
6084 TYPE_PRECISION (integer_type_node)),
6086 || TYPE_PRECISION (type) >= TYPE_PRECISION (integer_type_node))
6087 && TREE_UNSIGNED (type)));
6089 decl = build_decl (CONST_DECL, name, type);
6090 DECL_INITIAL (decl) = convert (type, value);
6093 return tree_cons (decl, value, NULL_TREE);
6097 /* Create the FUNCTION_DECL for a function definition.
6098 DECLSPECS, DECLARATOR and ATTRIBUTES are the parts of
6099 the declaration; they describe the function's name and the type it returns,
6100 but twisted together in a fashion that parallels the syntax of C.
6102 This function creates a binding context for the function body
6103 as well as setting up the FUNCTION_DECL in current_function_decl.
6105 Returns 1 on success. If the DECLARATOR is not suitable for a function
6106 (it defines a datum instead), we return 0, which tells
6107 yyparse to report a parse error. */
6110 start_function (declspecs, declarator, attributes)
6111 tree declarator, declspecs, attributes;
6113 tree decl1, old_decl;
6115 int old_immediate_size_expand = immediate_size_expand;
6117 current_function_returns_value = 0; /* Assume, until we see it does. */
6118 current_function_returns_null = 0;
6119 warn_about_return_type = 0;
6120 current_extern_inline = 0;
6121 c_function_varargs = 0;
6123 shadowed_labels = 0;
6125 /* Don't expand any sizes in the return type of the function. */
6126 immediate_size_expand = 0;
6128 decl1 = grokdeclarator (declarator, declspecs, FUNCDEF, 1);
6130 /* If the declarator is not suitable for a function definition,
6131 cause a syntax error. */
6134 immediate_size_expand = old_immediate_size_expand;
6138 decl_attributes (&decl1, attributes, 0);
6140 if (DECL_DECLARED_INLINE_P (decl1)
6141 && DECL_UNINLINABLE (decl1)
6142 && lookup_attribute ("noinline", DECL_ATTRIBUTES (decl1)))
6143 warning_with_decl (decl1,
6144 "inline function `%s' given attribute noinline");
6146 announce_function (decl1);
6148 if (!COMPLETE_OR_VOID_TYPE_P (TREE_TYPE (TREE_TYPE (decl1))))
6150 error ("return type is an incomplete type");
6151 /* Make it return void instead. */
6153 = build_function_type (void_type_node,
6154 TYPE_ARG_TYPES (TREE_TYPE (decl1)));
6157 if (warn_about_return_type)
6158 pedwarn_c99 ("return type defaults to `int'");
6160 /* Save the parm names or decls from this function's declarator
6161 where store_parm_decls will find them. */
6162 current_function_parms = last_function_parms;
6163 current_function_parm_tags = last_function_parm_tags;
6165 /* Make the init_value nonzero so pushdecl knows this is not tentative.
6166 error_mark_node is replaced below (in poplevel) with the BLOCK. */
6167 DECL_INITIAL (decl1) = error_mark_node;
6169 /* If this definition isn't a prototype and we had a prototype declaration
6170 before, copy the arg type info from that prototype.
6171 But not if what we had before was a builtin function. */
6172 old_decl = lookup_name_current_level (DECL_NAME (decl1));
6173 if (old_decl != 0 && TREE_CODE (TREE_TYPE (old_decl)) == FUNCTION_TYPE
6174 && !DECL_BUILT_IN (old_decl)
6175 && (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (decl1)))
6176 == TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (old_decl))))
6177 && TYPE_ARG_TYPES (TREE_TYPE (decl1)) == 0)
6179 TREE_TYPE (decl1) = TREE_TYPE (old_decl);
6180 current_function_prototype_file = DECL_SOURCE_FILE (old_decl);
6181 current_function_prototype_line = DECL_SOURCE_LINE (old_decl);
6184 /* If there is no explicit declaration, look for any out-of-scope implicit
6187 old_decl = IDENTIFIER_IMPLICIT_DECL (DECL_NAME (decl1));
6189 /* Optionally warn of old-fashioned def with no previous prototype. */
6190 if (warn_strict_prototypes
6191 && TYPE_ARG_TYPES (TREE_TYPE (decl1)) == 0
6193 && (TYPE_ARG_TYPES (TREE_TYPE (old_decl)) != 0
6194 || (DECL_BUILT_IN (old_decl)
6195 && ! C_DECL_ANTICIPATED (old_decl)))))
6196 warning ("function declaration isn't a prototype");
6197 /* Optionally warn of any global def with no previous prototype. */
6198 else if (warn_missing_prototypes
6199 && TREE_PUBLIC (decl1)
6201 && (TYPE_ARG_TYPES (TREE_TYPE (old_decl)) != 0
6202 || (DECL_BUILT_IN (old_decl)
6203 && ! C_DECL_ANTICIPATED (old_decl))))
6204 && ! MAIN_NAME_P (DECL_NAME (decl1)))
6205 warning_with_decl (decl1, "no previous prototype for `%s'");
6206 /* Optionally warn of any def with no previous prototype
6207 if the function has already been used. */
6208 else if (warn_missing_prototypes
6209 && old_decl != 0 && TREE_USED (old_decl)
6210 && TYPE_ARG_TYPES (TREE_TYPE (old_decl)) == 0)
6211 warning_with_decl (decl1,
6212 "`%s' was used with no prototype before its definition");
6213 /* Optionally warn of any global def with no previous declaration. */
6214 else if (warn_missing_declarations
6215 && TREE_PUBLIC (decl1)
6217 && ! MAIN_NAME_P (DECL_NAME (decl1)))
6218 warning_with_decl (decl1, "no previous declaration for `%s'");
6219 /* Optionally warn of any def with no previous declaration
6220 if the function has already been used. */
6221 else if (warn_missing_declarations
6222 && old_decl != 0 && TREE_USED (old_decl)
6223 && old_decl == IDENTIFIER_IMPLICIT_DECL (DECL_NAME (decl1)))
6224 warning_with_decl (decl1,
6225 "`%s' was used with no declaration before its definition");
6227 /* This is a definition, not a reference.
6228 So normally clear DECL_EXTERNAL.
6229 However, `extern inline' acts like a declaration
6230 except for defining how to inline. So set DECL_EXTERNAL in that case. */
6231 DECL_EXTERNAL (decl1) = current_extern_inline;
6233 /* This function exists in static storage.
6234 (This does not mean `static' in the C sense!) */
6235 TREE_STATIC (decl1) = 1;
6237 /* A nested function is not global. */
6238 if (current_function_decl != 0)
6239 TREE_PUBLIC (decl1) = 0;
6241 /* Warn for unlikely, improbable, or stupid declarations of `main'. */
6242 if (warn_main > 0 && MAIN_NAME_P (DECL_NAME (decl1)))
6247 if (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (decl1)))
6248 != integer_type_node)
6249 pedwarn_with_decl (decl1, "return type of `%s' is not `int'");
6251 for (args = TYPE_ARG_TYPES (TREE_TYPE (decl1)); args;
6252 args = TREE_CHAIN (args))
6254 tree type = args ? TREE_VALUE (args) : 0;
6256 if (type == void_type_node)
6263 if (TYPE_MAIN_VARIANT (type) != integer_type_node)
6264 pedwarn_with_decl (decl1,
6265 "first argument of `%s' should be `int'");
6269 if (TREE_CODE (type) != POINTER_TYPE
6270 || TREE_CODE (TREE_TYPE (type)) != POINTER_TYPE
6271 || (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (type)))
6273 pedwarn_with_decl (decl1,
6274 "second argument of `%s' should be `char **'");
6278 if (TREE_CODE (type) != POINTER_TYPE
6279 || TREE_CODE (TREE_TYPE (type)) != POINTER_TYPE
6280 || (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (type)))
6282 pedwarn_with_decl (decl1,
6283 "third argument of `%s' should probably be `char **'");
6288 /* It is intentional that this message does not mention the third
6289 argument because it's only mentioned in an appendix of the
6291 if (argct > 0 && (argct < 2 || argct > 3))
6292 pedwarn_with_decl (decl1, "`%s' takes only zero or two arguments");
6294 if (! TREE_PUBLIC (decl1))
6295 pedwarn_with_decl (decl1, "`%s' is normally a non-static function");
6298 /* Record the decl so that the function name is defined.
6299 If we already have a decl for this name, and it is a FUNCTION_DECL,
6300 use the old decl. */
6302 current_function_decl = pushdecl (decl1);
6305 declare_parm_level (1);
6306 current_binding_level->subblocks_tag_transparent = 1;
6308 make_decl_rtl (current_function_decl, NULL);
6310 restype = TREE_TYPE (TREE_TYPE (current_function_decl));
6311 /* Promote the value to int before returning it. */
6312 if (c_promoting_integer_type_p (restype))
6314 /* It retains unsignedness if traditional
6315 or if not really getting wider. */
6316 if (TREE_UNSIGNED (restype)
6317 && (flag_traditional
6318 || (TYPE_PRECISION (restype)
6319 == TYPE_PRECISION (integer_type_node))))
6320 restype = unsigned_type_node;
6322 restype = integer_type_node;
6324 DECL_RESULT (current_function_decl)
6325 = build_decl (RESULT_DECL, NULL_TREE, restype);
6327 /* If this fcn was already referenced via a block-scope `extern' decl
6328 (or an implicit decl), propagate certain information about the usage. */
6329 if (TREE_ADDRESSABLE (DECL_ASSEMBLER_NAME (current_function_decl)))
6330 TREE_ADDRESSABLE (current_function_decl) = 1;
6332 immediate_size_expand = old_immediate_size_expand;
6334 start_fname_decls ();
6339 /* Record that this function is going to be a varargs function.
6340 This is called before store_parm_decls, which is too early
6341 to call mark_varargs directly. */
6346 c_function_varargs = 1;
6349 /* Store the parameter declarations into the current function declaration.
6350 This is called after parsing the parameter declarations, before
6351 digesting the body of the function.
6353 For an old-style definition, modify the function's type
6354 to specify at least the number of arguments. */
6359 tree fndecl = current_function_decl;
6362 /* This is either a chain of PARM_DECLs (if a prototype was used)
6363 or a list of IDENTIFIER_NODEs (for an old-fashioned C definition). */
6364 tree specparms = current_function_parms;
6366 /* This is a list of types declared among parms in a prototype. */
6367 tree parmtags = current_function_parm_tags;
6369 /* This is a chain of PARM_DECLs from old-style parm declarations. */
6370 tree parmdecls = getdecls ();
6372 /* This is a chain of any other decls that came in among the parm
6373 declarations. If a parm is declared with enum {foo, bar} x;
6374 then CONST_DECLs for foo and bar are put here. */
6377 /* The function containing FNDECL, if any. */
6378 tree context = decl_function_context (fndecl);
6380 /* Nonzero if this definition is written with a prototype. */
6383 int saved_warn_shadow = warn_shadow;
6385 /* Don't re-emit shadow warnings. */
6388 if (specparms != 0 && TREE_CODE (specparms) != TREE_LIST)
6390 /* This case is when the function was defined with an ANSI prototype.
6391 The parms already have decls, so we need not do anything here
6392 except record them as in effect
6393 and complain if any redundant old-style parm decls were written. */
6404 error_with_decl (fndecl,
6405 "parm types given both in parmlist and separately");
6406 /* Get rid of the erroneous decls; don't keep them on
6407 the list of parms, since they might not be PARM_DECLs. */
6408 for (decl = current_binding_level->names;
6409 decl; decl = TREE_CHAIN (decl))
6410 if (DECL_NAME (decl))
6411 IDENTIFIER_LOCAL_VALUE (DECL_NAME (decl)) = 0;
6412 for (link = current_binding_level->shadowed;
6413 link; link = TREE_CHAIN (link))
6414 IDENTIFIER_LOCAL_VALUE (TREE_PURPOSE (link)) = TREE_VALUE (link);
6415 current_binding_level->names = 0;
6416 current_binding_level->shadowed = 0;
6419 specparms = nreverse (specparms);
6420 for (parm = specparms; parm; parm = next)
6422 next = TREE_CHAIN (parm);
6423 if (TREE_CODE (parm) == PARM_DECL)
6425 if (DECL_NAME (parm) == 0)
6426 error_with_decl (parm, "parameter name omitted");
6427 else if (TREE_CODE (TREE_TYPE (parm)) != ERROR_MARK
6428 && VOID_TYPE_P (TREE_TYPE (parm)))
6430 error_with_decl (parm, "parameter `%s' declared void");
6431 /* Change the type to error_mark_node so this parameter
6432 will be ignored by assign_parms. */
6433 TREE_TYPE (parm) = error_mark_node;
6439 /* If we find an enum constant or a type tag,
6440 put it aside for the moment. */
6441 TREE_CHAIN (parm) = 0;
6442 others = chainon (others, parm);
6446 /* Get the decls in their original chain order
6447 and record in the function. */
6448 DECL_ARGUMENTS (fndecl) = getdecls ();
6451 /* If this function takes a variable number of arguments,
6452 add a phony parameter to the end of the parm list,
6453 to represent the position of the first unnamed argument. */
6454 if (TREE_VALUE (tree_last (TYPE_ARG_TYPES (TREE_TYPE (fndecl))))
6457 tree dummy = build_decl (PARM_DECL, NULL_TREE, void_type_node);
6458 /* Let's hope the address of the unnamed parm
6459 won't depend on its type. */
6460 TREE_TYPE (dummy) = integer_type_node;
6461 DECL_ARG_TYPE (dummy) = integer_type_node;
6462 DECL_ARGUMENTS (fndecl) = chainon (DECL_ARGUMENTS (fndecl), dummy);
6466 /* Now pushdecl the enum constants. */
6467 for (parm = others; parm; parm = next)
6469 next = TREE_CHAIN (parm);
6470 if (DECL_NAME (parm) == 0)
6472 else if (TYPE_MAIN_VARIANT (TREE_TYPE (parm)) == void_type_node)
6474 else if (TREE_CODE (parm) != PARM_DECL)
6478 storetags (chainon (parmtags, gettags ()));
6482 /* SPECPARMS is an identifier list--a chain of TREE_LIST nodes
6483 each with a parm name as the TREE_VALUE.
6485 PARMDECLS is a chain of declarations for parameters.
6486 Warning! It can also contain CONST_DECLs which are not parameters
6487 but are names of enumerators of any enum types
6488 declared among the parameters.
6490 First match each formal parameter name with its declaration.
6491 Associate decls with the names and store the decls
6492 into the TREE_PURPOSE slots. */
6494 /* We use DECL_WEAK as a flag to show which parameters have been
6495 seen already since it is not used on PARM_DECL or CONST_DECL. */
6496 for (parm = parmdecls; parm; parm = TREE_CHAIN (parm))
6497 DECL_WEAK (parm) = 0;
6499 for (parm = specparms; parm; parm = TREE_CHAIN (parm))
6501 tree tail, found = NULL;
6503 if (TREE_VALUE (parm) == 0)
6505 error_with_decl (fndecl,
6506 "parameter name missing from parameter list");
6507 TREE_PURPOSE (parm) = 0;
6511 /* See if any of the parmdecls specifies this parm by name.
6512 Ignore any enumerator decls. */
6513 for (tail = parmdecls; tail; tail = TREE_CHAIN (tail))
6514 if (DECL_NAME (tail) == TREE_VALUE (parm)
6515 && TREE_CODE (tail) == PARM_DECL)
6521 /* If declaration already marked, we have a duplicate name.
6522 Complain, and don't use this decl twice. */
6523 if (found && DECL_WEAK (found))
6525 error_with_decl (found, "multiple parameters named `%s'");
6529 /* If the declaration says "void", complain and ignore it. */
6530 if (found && VOID_TYPE_P (TREE_TYPE (found)))
6532 error_with_decl (found, "parameter `%s' declared void");
6533 TREE_TYPE (found) = integer_type_node;
6534 DECL_ARG_TYPE (found) = integer_type_node;
6535 layout_decl (found, 0);
6538 /* Traditionally, a parm declared float is actually a double. */
6539 if (found && flag_traditional
6540 && TYPE_MAIN_VARIANT (TREE_TYPE (found)) == float_type_node)
6542 TREE_TYPE (found) = double_type_node;
6543 DECL_ARG_TYPE (found) = double_type_node;
6544 layout_decl (found, 0);
6547 /* If no declaration found, default to int. */
6550 found = build_decl (PARM_DECL, TREE_VALUE (parm),
6552 DECL_ARG_TYPE (found) = TREE_TYPE (found);
6553 DECL_SOURCE_LINE (found) = DECL_SOURCE_LINE (fndecl);
6554 DECL_SOURCE_FILE (found) = DECL_SOURCE_FILE (fndecl);
6556 pedwarn_with_decl (found, "type of `%s' defaults to `int'");
6557 else if (extra_warnings)
6558 warning_with_decl (found, "type of `%s' defaults to `int'");
6562 TREE_PURPOSE (parm) = found;
6564 /* Mark this decl as "already found". */
6565 DECL_WEAK (found) = 1;
6568 /* Put anything which is on the parmdecls chain and which is
6569 not a PARM_DECL onto the list NONPARMS. (The types of
6570 non-parm things which might appear on the list include
6571 enumerators and NULL-named TYPE_DECL nodes.) Complain about
6572 any actual PARM_DECLs not matched with any names. */
6575 for (parm = parmdecls; parm;)
6577 tree next = TREE_CHAIN (parm);
6578 TREE_CHAIN (parm) = 0;
6580 if (TREE_CODE (parm) != PARM_DECL)
6581 nonparms = chainon (nonparms, parm);
6584 /* Complain about args with incomplete types. */
6585 if (!COMPLETE_TYPE_P (TREE_TYPE (parm)))
6587 error_with_decl (parm, "parameter `%s' has incomplete type");
6588 TREE_TYPE (parm) = error_mark_node;
6591 if (! DECL_WEAK (parm))
6593 error_with_decl (parm,
6594 "declaration for parameter `%s' but no such parameter");
6595 /* Pretend the parameter was not missing.
6596 This gets us to a standard state and minimizes
6597 further error messages. */
6599 = chainon (specparms,
6600 tree_cons (parm, NULL_TREE, NULL_TREE));
6607 /* Chain the declarations together in the order of the list of
6608 names. Store that chain in the function decl, replacing the
6611 DECL_ARGUMENTS (fndecl) = 0;
6614 for (last = 0; parm; parm = TREE_CHAIN (parm))
6615 if (TREE_PURPOSE (parm))
6618 DECL_ARGUMENTS (fndecl) = TREE_PURPOSE (parm);
6620 TREE_CHAIN (last) = TREE_PURPOSE (parm);
6621 last = TREE_PURPOSE (parm);
6622 TREE_CHAIN (last) = 0;
6626 /* If there was a previous prototype,
6627 set the DECL_ARG_TYPE of each argument according to
6628 the type previously specified, and report any mismatches. */
6630 if (TYPE_ARG_TYPES (TREE_TYPE (fndecl)))
6633 for (parm = DECL_ARGUMENTS (fndecl),
6634 type = TYPE_ARG_TYPES (TREE_TYPE (fndecl));
6635 parm || (type && (TYPE_MAIN_VARIANT (TREE_VALUE (type))
6636 != void_type_node));
6637 parm = TREE_CHAIN (parm), type = TREE_CHAIN (type))
6639 if (parm == 0 || type == 0
6640 || TYPE_MAIN_VARIANT (TREE_VALUE (type)) == void_type_node)
6642 error ("number of arguments doesn't match prototype");
6643 error_with_file_and_line (current_function_prototype_file,
6644 current_function_prototype_line,
6645 "prototype declaration");
6648 /* Type for passing arg must be consistent with that
6649 declared for the arg. ISO C says we take the unqualified
6650 type for parameters declared with qualified type. */
6651 if (! comptypes (TYPE_MAIN_VARIANT (DECL_ARG_TYPE (parm)),
6652 TYPE_MAIN_VARIANT (TREE_VALUE (type))))
6654 if (TYPE_MAIN_VARIANT (TREE_TYPE (parm))
6655 == TYPE_MAIN_VARIANT (TREE_VALUE (type)))
6657 /* Adjust argument to match prototype. E.g. a previous
6658 `int foo(float);' prototype causes
6659 `int foo(x) float x; {...}' to be treated like
6660 `int foo(float x) {...}'. This is particularly
6661 useful for argument types like uid_t. */
6662 DECL_ARG_TYPE (parm) = TREE_TYPE (parm);
6664 if (PROMOTE_PROTOTYPES
6665 && INTEGRAL_TYPE_P (TREE_TYPE (parm))
6666 && TYPE_PRECISION (TREE_TYPE (parm))
6667 < TYPE_PRECISION (integer_type_node))
6668 DECL_ARG_TYPE (parm) = integer_type_node;
6672 pedwarn ("promoted argument `%s' doesn't match prototype",
6673 IDENTIFIER_POINTER (DECL_NAME (parm)));
6674 warning_with_file_and_line
6675 (current_function_prototype_file,
6676 current_function_prototype_line,
6677 "prototype declaration");
6680 /* If -traditional, allow `int' argument to match
6681 `unsigned' prototype. */
6682 else if (! (flag_traditional
6683 && TYPE_MAIN_VARIANT (TREE_TYPE (parm)) == integer_type_node
6684 && TYPE_MAIN_VARIANT (TREE_VALUE (type)) == unsigned_type_node))
6686 error ("argument `%s' doesn't match prototype",
6687 IDENTIFIER_POINTER (DECL_NAME (parm)));
6688 error_with_file_and_line (current_function_prototype_file,
6689 current_function_prototype_line,
6690 "prototype declaration");
6694 TYPE_ACTUAL_ARG_TYPES (TREE_TYPE (fndecl)) = 0;
6697 /* Otherwise, create a prototype that would match. */
6701 tree actual = 0, last = 0, type;
6703 for (parm = DECL_ARGUMENTS (fndecl); parm; parm = TREE_CHAIN (parm))
6705 type = tree_cons (NULL_TREE, DECL_ARG_TYPE (parm), NULL_TREE);
6707 TREE_CHAIN (last) = type;
6712 type = tree_cons (NULL_TREE, void_type_node, NULL_TREE);
6714 TREE_CHAIN (last) = type;
6718 /* We are going to assign a new value for the TYPE_ACTUAL_ARG_TYPES
6719 of the type of this function, but we need to avoid having this
6720 affect the types of other similarly-typed functions, so we must
6721 first force the generation of an identical (but separate) type
6722 node for the relevant function type. The new node we create
6723 will be a variant of the main variant of the original function
6726 TREE_TYPE (fndecl) = build_type_copy (TREE_TYPE (fndecl));
6728 TYPE_ACTUAL_ARG_TYPES (TREE_TYPE (fndecl)) = actual;
6731 /* Now store the final chain of decls for the arguments
6732 as the decl-chain of the current lexical scope.
6733 Put the enumerators in as well, at the front so that
6734 DECL_ARGUMENTS is not modified. */
6736 storedecls (chainon (nonparms, DECL_ARGUMENTS (fndecl)));
6739 /* Make sure the binding level for the top of the function body
6740 gets a BLOCK if there are any in the function.
6741 Otherwise, the dbx output is wrong. */
6743 keep_next_if_subblocks = 1;
6745 /* ??? This might be an improvement,
6746 but needs to be thought about some more. */
6748 keep_next_level_flag = 1;
6751 /* Write a record describing this function definition to the prototypes
6752 file (if requested). */
6754 gen_aux_info_record (fndecl, 1, 0, prototype);
6756 /* Initialize the RTL code for the function. */
6757 init_function_start (fndecl, input_filename, lineno);
6759 /* Begin the statement tree for this function. */
6760 begin_stmt_tree (&DECL_SAVED_TREE (current_function_decl));
6762 /* If this is a nested function, save away the sizes of any
6763 variable-size types so that we can expand them when generating
6769 DECL_LANG_SPECIFIC (fndecl)->pending_sizes
6770 = nreverse (get_pending_sizes ());
6771 for (t = DECL_LANG_SPECIFIC (fndecl)->pending_sizes;
6774 SAVE_EXPR_CONTEXT (TREE_VALUE (t)) = context;
6777 /* This function is being processed in whole-function mode. */
6778 cfun->x_whole_function_mode_p = 1;
6780 /* Even though we're inside a function body, we still don't want to
6781 call expand_expr to calculate the size of a variable-sized array.
6782 We haven't necessarily assigned RTL to all variables yet, so it's
6783 not safe to try to expand expressions involving them. */
6784 immediate_size_expand = 0;
6785 cfun->x_dont_save_pending_sizes_p = 1;
6787 warn_shadow = saved_warn_shadow;
6790 /* Finish up a function declaration and compile that function
6791 all the way to assembler language output. The free the storage
6792 for the function definition.
6794 This is called after parsing the body of the function definition.
6796 NESTED is nonzero if the function being finished is nested in another. */
6799 finish_function (nested)
6802 tree fndecl = current_function_decl;
6804 /* TREE_READONLY (fndecl) = 1;
6805 This caused &foo to be of type ptr-to-const-function
6806 which then got a warning when stored in a ptr-to-function variable. */
6809 BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl)) = fndecl;
6811 /* Must mark the RESULT_DECL as being in this function. */
6813 DECL_CONTEXT (DECL_RESULT (fndecl)) = fndecl;
6815 /* Obey `register' declarations if `setjmp' is called in this fn. */
6816 if (flag_traditional && current_function_calls_setjmp)
6818 setjmp_protect (DECL_INITIAL (fndecl));
6819 setjmp_protect_args ();
6822 if (MAIN_NAME_P (DECL_NAME (fndecl)) && flag_hosted)
6824 if (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (fndecl)))
6825 != integer_type_node)
6827 /* If warn_main is 1 (-Wmain) or 2 (-Wall), we have already warned.
6828 If warn_main is -1 (-Wno-main) we don't want to be warned. */
6830 pedwarn_with_decl (fndecl, "return type of `%s' is not `int'");
6834 #ifdef DEFAULT_MAIN_RETURN
6835 /* Make it so that `main' always returns success by default. */
6836 DEFAULT_MAIN_RETURN;
6839 c_expand_return (integer_zero_node);
6844 finish_fname_decls ();
6846 /* Tie off the statement tree for this function. */
6847 finish_stmt_tree (&DECL_SAVED_TREE (fndecl));
6848 /* Clear out memory we no longer need. */
6849 free_after_parsing (cfun);
6850 /* Since we never call rest_of_compilation, we never clear
6851 CFUN. Do so explicitly. */
6852 free_after_compilation (cfun);
6857 /* Generate RTL for the body of this function. */
6858 c_expand_body (fndecl, nested, 1);
6859 /* Let the error reporting routines know that we're outside a
6860 function. For a nested function, this value is used in
6861 pop_c_function_context and then reset via pop_function_context. */
6862 current_function_decl = NULL;
6866 /* Generate the RTL for a deferred function FNDECL. */
6869 c_expand_deferred_function (fndecl)
6872 /* DECL_INLINE or DECL_RESULT might got cleared after the inline
6873 function was deferred, e.g. in duplicate_decls. */
6874 if (DECL_INLINE (fndecl) && DECL_RESULT (fndecl))
6876 c_expand_body (fndecl, 0, 0);
6877 current_function_decl = NULL;
6881 /* Generate the RTL for the body of FNDECL. If NESTED_P is non-zero,
6882 then we are already in the process of generating RTL for another
6883 function. If can_defer_p is zero, we won't attempt to defer the
6884 generation of RTL. */
6887 c_expand_body (fndecl, nested_p, can_defer_p)
6889 int nested_p, can_defer_p;
6891 int uninlinable = 1;
6893 /* There's no reason to do any of the work here if we're only doing
6894 semantic analysis; this code just generates RTL. */
6895 if (flag_syntax_only)
6898 if (flag_inline_trees)
6900 /* First, cache whether the current function is inlinable. Some
6901 predicates depend on cfun and current_function_decl to
6902 function completely. */
6903 timevar_push (TV_INTEGRATION);
6904 uninlinable = ! tree_inlinable_function_p (fndecl);
6906 if (! uninlinable && can_defer_p
6907 /* Save function tree for inlining. Should return 0 if the
6908 language does not support function deferring or the
6909 function could not be deferred. */
6910 && defer_fn (fndecl))
6912 /* Let the back-end know that this function exists. */
6913 (*debug_hooks->deferred_inline_function) (fndecl);
6914 timevar_pop (TV_INTEGRATION);
6918 /* Then, inline any functions called in it. */
6919 optimize_inline_calls (fndecl);
6920 timevar_pop (TV_INTEGRATION);
6923 timevar_push (TV_EXPAND);
6927 /* Make sure that we will evaluate variable-sized types involved
6928 in our function's type. */
6929 expand_pending_sizes (DECL_LANG_SPECIFIC (fndecl)->pending_sizes);
6930 /* Squirrel away our current state. */
6931 push_function_context ();
6934 /* Initialize the RTL code for the function. */
6935 current_function_decl = fndecl;
6936 init_function_start (fndecl, input_filename, DECL_SOURCE_LINE (fndecl));
6938 /* This function is being processed in whole-function mode. */
6939 cfun->x_whole_function_mode_p = 1;
6941 /* Even though we're inside a function body, we still don't want to
6942 call expand_expr to calculate the size of a variable-sized array.
6943 We haven't necessarily assigned RTL to all variables yet, so it's
6944 not safe to try to expand expressions involving them. */
6945 immediate_size_expand = 0;
6946 cfun->x_dont_save_pending_sizes_p = 1;
6948 /* If this is a varargs function, inform function.c. */
6949 if (c_function_varargs)
6952 /* Set up parameters and prepare for return, for the function. */
6953 expand_function_start (fndecl, 0);
6955 /* If this function is `main', emit a call to `__main'
6956 to run global initializers, etc. */
6957 if (DECL_NAME (fndecl)
6958 && MAIN_NAME_P (DECL_NAME (fndecl))
6959 && DECL_CONTEXT (fndecl) == NULL_TREE)
6960 expand_main_function ();
6962 /* Generate the RTL for this function. */
6963 expand_stmt (DECL_SAVED_TREE (fndecl));
6966 /* Allow the body of the function to be garbage collected. */
6967 DECL_SAVED_TREE (fndecl) = NULL_TREE;
6970 /* We hard-wired immediate_size_expand to zero above.
6971 expand_function_end will decrement this variable. So, we set the
6972 variable to one here, so that after the decrement it will remain
6974 immediate_size_expand = 1;
6976 /* Allow language dialects to perform special processing. */
6977 if (lang_expand_function_end)
6978 (*lang_expand_function_end) ();
6980 /* Generate rtl for function exit. */
6981 expand_function_end (input_filename, lineno, 0);
6983 /* If this is a nested function, protect the local variables in the stack
6984 above us from being collected while we're compiling this function. */
6986 ggc_push_context ();
6988 /* Run the optimizers and output the assembler code for this function. */
6989 rest_of_compilation (fndecl);
6991 /* Undo the GC context switch. */
6995 /* With just -W, complain only if function returns both with
6996 and without a value. */
6998 && current_function_returns_value
6999 && current_function_returns_null)
7000 warning ("this function may return with or without a value");
7002 /* If requested, warn about function definitions where the function will
7003 return a value (usually of some struct or union type) which itself will
7004 take up a lot of stack space. */
7006 if (warn_larger_than && !DECL_EXTERNAL (fndecl) && TREE_TYPE (fndecl))
7008 tree ret_type = TREE_TYPE (TREE_TYPE (fndecl));
7010 if (ret_type && TYPE_SIZE_UNIT (ret_type)
7011 && TREE_CODE (TYPE_SIZE_UNIT (ret_type)) == INTEGER_CST
7012 && 0 < compare_tree_int (TYPE_SIZE_UNIT (ret_type),
7015 unsigned int size_as_int
7016 = TREE_INT_CST_LOW (TYPE_SIZE_UNIT (ret_type));
7018 if (compare_tree_int (TYPE_SIZE_UNIT (ret_type), size_as_int) == 0)
7019 warning_with_decl (fndecl,
7020 "size of return value of `%s' is %u bytes",
7023 warning_with_decl (fndecl,
7024 "size of return value of `%s' is larger than %d bytes",
7029 if (DECL_SAVED_INSNS (fndecl) == 0 && ! nested_p
7030 && ! flag_inline_trees)
7032 /* Stop pointing to the local nodes about to be freed.
7033 But DECL_INITIAL must remain nonzero so we know this
7034 was an actual function definition.
7035 For a nested function, this is done in pop_c_function_context.
7036 If rest_of_compilation set this to 0, leave it 0. */
7037 if (DECL_INITIAL (fndecl) != 0)
7038 DECL_INITIAL (fndecl) = error_mark_node;
7040 DECL_ARGUMENTS (fndecl) = 0;
7043 if (DECL_STATIC_CONSTRUCTOR (fndecl))
7045 if (targetm.have_ctors_dtors)
7046 (* targetm.asm_out.constructor) (XEXP (DECL_RTL (fndecl), 0),
7047 DEFAULT_INIT_PRIORITY);
7049 static_ctors = tree_cons (NULL_TREE, fndecl, static_ctors);
7052 if (DECL_STATIC_DESTRUCTOR (fndecl))
7054 if (targetm.have_ctors_dtors)
7055 (* targetm.asm_out.destructor) (XEXP (DECL_RTL (fndecl), 0),
7056 DEFAULT_INIT_PRIORITY);
7058 static_dtors = tree_cons (NULL_TREE, fndecl, static_dtors);
7062 /* Return to the enclosing function. */
7063 pop_function_context ();
7064 timevar_pop (TV_EXPAND);
7067 /* Check the declarations given in a for-loop for satisfying the C99
7070 check_for_loop_decls ()
7076 /* If we get here, declarations have been used in a for loop without
7077 the C99 for loop scope. This doesn't make much sense, so don't
7079 error ("`for' loop initial declaration used outside C99 mode");
7082 /* C99 subclause 6.8.5 paragraph 3:
7084 [#3] The declaration part of a for statement shall only
7085 declare identifiers for objects having storage class auto or
7088 It isn't clear whether, in this sentence, "identifiers" binds to
7089 "shall only declare" or to "objects" - that is, whether all identifiers
7090 declared must be identifiers for objects, or whether the restriction
7091 only applies to those that are. (A question on this in comp.std.c
7092 in November 2000 received no answer.) We implement the strictest
7093 interpretation, to avoid creating an extension which later causes
7096 for (t = gettags (); t; t = TREE_CHAIN (t))
7098 if (TREE_PURPOSE (t) != 0)
7100 enum tree_code code = TREE_CODE (TREE_VALUE (t));
7102 if (code == RECORD_TYPE)
7103 error ("`struct %s' declared in `for' loop initial declaration",
7104 IDENTIFIER_POINTER (TREE_PURPOSE (t)));
7105 else if (code == UNION_TYPE)
7106 error ("`union %s' declared in `for' loop initial declaration",
7107 IDENTIFIER_POINTER (TREE_PURPOSE (t)));
7109 error ("`enum %s' declared in `for' loop initial declaration",
7110 IDENTIFIER_POINTER (TREE_PURPOSE (t)));
7114 for (t = getdecls (); t; t = TREE_CHAIN (t))
7116 if (TREE_CODE (t) != VAR_DECL && DECL_NAME (t))
7117 error_with_decl (t, "declaration of non-variable `%s' in `for' loop initial declaration");
7118 else if (TREE_STATIC (t))
7119 error_with_decl (t, "declaration of static variable `%s' in `for' loop initial declaration");
7120 else if (DECL_EXTERNAL (t))
7121 error_with_decl (t, "declaration of `extern' variable `%s' in `for' loop initial declaration");
7125 /* Save and restore the variables in this file and elsewhere
7126 that keep track of the progress of compilation of the current function.
7127 Used for nested functions. */
7129 struct c_language_function
7131 struct language_function base;
7133 tree shadowed_labels;
7136 int warn_about_return_type;
7138 struct binding_level *binding_level;
7141 /* Save and reinitialize the variables
7142 used during compilation of a C function. */
7145 push_c_function_context (f)
7148 struct c_language_function *p;
7149 p = ((struct c_language_function *)
7150 xmalloc (sizeof (struct c_language_function)));
7151 f->language = (struct language_function *) p;
7153 p->base.x_stmt_tree = c_stmt_tree;
7154 p->base.x_scope_stmt_stack = c_scope_stmt_stack;
7155 p->named_labels = named_labels;
7156 p->shadowed_labels = shadowed_labels;
7157 p->returns_value = current_function_returns_value;
7158 p->returns_null = current_function_returns_null;
7159 p->warn_about_return_type = warn_about_return_type;
7160 p->extern_inline = current_extern_inline;
7161 p->binding_level = current_binding_level;
7164 /* Restore the variables used during compilation of a C function. */
7167 pop_c_function_context (f)
7170 struct c_language_function *p
7171 = (struct c_language_function *) f->language;
7174 /* Bring back all the labels that were shadowed. */
7175 for (link = shadowed_labels; link; link = TREE_CHAIN (link))
7176 if (DECL_NAME (TREE_VALUE (link)) != 0)
7177 IDENTIFIER_LABEL_VALUE (DECL_NAME (TREE_VALUE (link)))
7178 = TREE_VALUE (link);
7180 if (DECL_SAVED_INSNS (current_function_decl) == 0
7181 && DECL_SAVED_TREE (current_function_decl) == NULL_TREE)
7183 /* Stop pointing to the local nodes about to be freed. */
7184 /* But DECL_INITIAL must remain nonzero so we know this
7185 was an actual function definition. */
7186 DECL_INITIAL (current_function_decl) = error_mark_node;
7187 DECL_ARGUMENTS (current_function_decl) = 0;
7190 c_stmt_tree = p->base.x_stmt_tree;
7191 c_scope_stmt_stack = p->base.x_scope_stmt_stack;
7192 named_labels = p->named_labels;
7193 shadowed_labels = p->shadowed_labels;
7194 current_function_returns_value = p->returns_value;
7195 current_function_returns_null = p->returns_null;
7196 warn_about_return_type = p->warn_about_return_type;
7197 current_extern_inline = p->extern_inline;
7198 current_binding_level = p->binding_level;
7204 /* Mark the language specific parts of F for GC. */
7207 mark_c_function_context (f)
7210 struct c_language_function *p
7211 = (struct c_language_function *) f->language;
7216 mark_c_language_function (&p->base);
7217 ggc_mark_tree (p->shadowed_labels);
7218 ggc_mark_tree (p->named_labels);
7219 mark_binding_level (&p->binding_level);
7222 /* Copy the DECL_LANG_SPECIFIC data associated with NODE. */
7225 copy_lang_decl (decl)
7228 struct lang_decl *ld;
7230 if (!DECL_LANG_SPECIFIC (decl))
7233 ld = (struct lang_decl *) ggc_alloc (sizeof (struct lang_decl));
7234 memcpy ((char *) ld, (char *) DECL_LANG_SPECIFIC (decl),
7235 sizeof (struct lang_decl));
7236 DECL_LANG_SPECIFIC (decl) = ld;
7239 /* Mark the language specific bits in T for GC. */
7245 if (TREE_CODE (t) == IDENTIFIER_NODE)
7247 struct lang_identifier *i = (struct lang_identifier *) t;
7248 ggc_mark_tree (i->global_value);
7249 ggc_mark_tree (i->local_value);
7250 ggc_mark_tree (i->label_value);
7251 ggc_mark_tree (i->implicit_decl);
7252 ggc_mark_tree (i->error_locus);
7253 ggc_mark_tree (i->limbo_value);
7255 else if (TYPE_P (t) && TYPE_LANG_SPECIFIC (t))
7256 ggc_mark (TYPE_LANG_SPECIFIC (t));
7257 else if (DECL_P (t) && DECL_LANG_SPECIFIC (t))
7259 ggc_mark (DECL_LANG_SPECIFIC (t));
7260 c_mark_lang_decl (&DECL_LANG_SPECIFIC (t)->base);
7261 ggc_mark_tree (DECL_LANG_SPECIFIC (t)->pending_sizes);
7265 /* The functions below are required for functionality of doing
7266 function at once processing in the C front end. Currently these
7267 functions are not called from anywhere in the C front end, but as
7268 these changes continue, that will change. */
7270 /* Returns non-zero if the current statement is a full expression,
7271 i.e. temporaries created during that statement should be destroyed
7272 at the end of the statement. */
7275 stmts_are_full_exprs_p ()
7280 /* Returns the stmt_tree (if any) to which statements are currently
7281 being added. If there is no active statement-tree, NULL is
7285 current_stmt_tree ()
7287 return &c_stmt_tree;
7290 /* Returns the stack of SCOPE_STMTs for the current function. */
7293 current_scope_stmt_stack ()
7295 return &c_scope_stmt_stack;
7298 /* Nonzero if TYPE is an anonymous union or struct type. Always 0 in
7302 anon_aggr_type_p (node)
7303 tree node ATTRIBUTE_UNUSED;
7308 /* Dummy function in place of callback used by C++. */
7311 extract_interface_info ()
7315 /* Return a new COMPOUND_STMT, after adding it to the current
7319 c_begin_compound_stmt ()
7323 /* Create the COMPOUND_STMT. */
7324 stmt = add_stmt (build_stmt (COMPOUND_STMT, NULL_TREE));
7329 /* Expand T (a DECL_STMT) if it declares an entity not handled by the
7333 c_expand_decl_stmt (t)
7336 tree decl = DECL_STMT_DECL (t);
7338 /* Expand nested functions. */
7339 if (TREE_CODE (decl) == FUNCTION_DECL
7340 && DECL_CONTEXT (decl) == current_function_decl
7341 && DECL_SAVED_TREE (decl))
7342 c_expand_body (decl, /*nested_p=*/1, /*can_defer_p=*/0);
7345 /* Return the IDENTIFIER_GLOBAL_VALUE of T, for use in common code, since
7346 the definition of IDENTIFIER_GLOBAL_VALUE is different for C and C++. */
7349 identifier_global_value (t)
7352 return IDENTIFIER_GLOBAL_VALUE (t);
7355 /* Record a builtin type for C. If NAME is non-NULL, it is the name used;
7356 otherwise the name is found in ridpointers from RID_INDEX. */
7359 record_builtin_type (rid_index, name, type)
7366 id = ridpointers[(int) rid_index];
7368 id = get_identifier (name);
7369 pushdecl (build_decl (TYPE_DECL, id, type));
7372 /* Build the void_list_node (void_type_node having been created). */
7374 build_void_list_node ()
7376 tree t = build_tree_list (NULL_TREE, void_type_node);