1 /* Process declarations and variables for C compiler.
2 Copyright (C) 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000
3 Free Software Foundation, Inc.
5 This file is part of GNU CC.
7 GNU CC is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
12 GNU CC is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GNU CC; see the file COPYING. If not, write to
19 the Free Software Foundation, 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
23 /* Process declarations and symbol lookup for C front end.
24 Also constructs types; the standard scalar types at initialization,
25 and structure, union, array and enum types when they are declared. */
27 /* ??? not all decl nodes are given the most useful possible
28 line numbers. For example, the CONST_DECLs for enum values. */
44 extern cpp_reader parse_in;
47 /* In grokdeclarator, distinguish syntactic contexts of declarators. */
49 { NORMAL, /* Ordinary declaration */
50 FUNCDEF, /* Function definition */
51 PARM, /* Declaration of parm before function body */
52 FIELD, /* Declaration inside struct or union */
53 BITFIELD, /* Likewise but with specified width */
54 TYPENAME}; /* Typename (inside cast or sizeof) */
56 /* We let tm.h override the types used here, to handle trivial differences
57 such as the choice of unsigned int or long unsigned int for size_t.
58 When machines start needing nontrivial differences in the size type,
59 it would be best to do something here to figure out automatically
60 from other information what type to use. */
63 #define SIZE_TYPE "long unsigned int"
67 #define PTRDIFF_TYPE "long int"
71 #define WCHAR_TYPE "int"
77 /* Nonzero if we have seen an invalid cross reference
78 to a struct, union, or enum, but not yet printed the message. */
80 tree pending_invalid_xref;
81 /* File and line to appear in the eventual error message. */
82 char *pending_invalid_xref_file;
83 int pending_invalid_xref_line;
85 /* While defining an enum type, this is 1 plus the last enumerator
86 constant value. Note that will do not have to save this or `enum_overflow'
87 around nested function definition since such a definition could only
88 occur in an enum value expression and we don't use these variables in
91 static tree enum_next_value;
93 /* Nonzero means that there was overflow computing enum_next_value. */
95 static int enum_overflow;
97 /* Parsing a function declarator leaves a list of parameter names
98 or a chain or parameter decls here. */
100 static tree last_function_parms;
102 /* Parsing a function declarator leaves here a chain of structure
103 and enum types declared in the parmlist. */
105 static tree last_function_parm_tags;
107 /* After parsing the declarator that starts a function definition,
108 `start_function' puts here the list of parameter names or chain of decls.
109 `store_parm_decls' finds it here. */
111 static tree current_function_parms;
113 /* Similar, for last_function_parm_tags. */
114 static tree current_function_parm_tags;
116 /* Similar, for the file and line that the prototype came from if this is
117 an old-style definition. */
118 static char *current_function_prototype_file;
119 static int current_function_prototype_line;
121 /* A list (chain of TREE_LIST nodes) of all LABEL_DECLs in the function
122 that have names. Here so we can clear out their names' definitions
123 at the end of the function. */
125 static tree named_labels;
127 /* A list of LABEL_DECLs from outer contexts that are currently shadowed. */
129 static tree shadowed_labels;
131 /* Nonzero when store_parm_decls is called indicates a varargs function.
132 Value not meaningful after store_parm_decls. */
134 static int c_function_varargs;
136 /* The FUNCTION_DECL for the function currently being compiled,
137 or 0 if between functions. */
138 tree current_function_decl;
140 /* Set to 0 at beginning of a function definition, set to 1 if
141 a return statement that specifies a return value is seen. */
143 int current_function_returns_value;
145 /* Set to 0 at beginning of a function definition, set to 1 if
146 a return statement with no argument is seen. */
148 int current_function_returns_null;
150 /* Set to nonzero by `grokdeclarator' for a function
151 whose return type is defaulted, if warnings for this are desired. */
153 static int warn_about_return_type;
155 /* Nonzero when starting a function declared `extern inline'. */
157 static int current_extern_inline;
159 /* For each binding contour we allocate a binding_level structure
160 * which records the names defined in that contour.
163 * 1) one for each function definition,
164 * where internal declarations of the parameters appear.
165 * 2) one for each compound statement,
166 * to record its declarations.
168 * The current meaning of a name can be found by searching the levels from
169 * the current one out to the global one.
172 /* Note that the information in the `names' component of the global contour
173 is duplicated in the IDENTIFIER_GLOBAL_VALUEs of all identifiers. */
177 /* A chain of _DECL nodes for all variables, constants, functions,
178 and typedef types. These are in the reverse of the order supplied.
182 /* A list of structure, union and enum definitions,
183 * for looking up tag names.
184 * It is a chain of TREE_LIST nodes, each of whose TREE_PURPOSE is a name,
185 * or NULL_TREE; and whose TREE_VALUE is a RECORD_TYPE, UNION_TYPE,
186 * or ENUMERAL_TYPE node.
190 /* For each level, a list of shadowed outer-level local definitions
191 to be restored when this level is popped.
192 Each link is a TREE_LIST whose TREE_PURPOSE is an identifier and
193 whose TREE_VALUE is its old definition (a kind of ..._DECL node). */
196 /* For each level (except not the global one),
197 a chain of BLOCK nodes for all the levels
198 that were entered and exited one level down. */
201 /* The BLOCK node for this level, if one has been preallocated.
202 If 0, the BLOCK is allocated (if needed) when the level is popped. */
205 /* The binding level which this one is contained in (inherits from). */
206 struct binding_level *level_chain;
208 /* Nonzero for the level that holds the parameters of a function. */
211 /* Nonzero if this level "doesn't exist" for tags. */
212 char tag_transparent;
214 /* Nonzero if sublevels of this level "don't exist" for tags.
215 This is set in the parm level of a function definition
216 while reading the function body, so that the outermost block
217 of the function body will be tag-transparent. */
218 char subblocks_tag_transparent;
220 /* Nonzero means make a BLOCK for this level regardless of all else. */
223 /* Nonzero means make a BLOCK if this level has any subblocks. */
224 char keep_if_subblocks;
226 /* Number of decls in `names' that have incomplete
227 structure or union types. */
230 /* A list of decls giving the (reversed) specified order of parms,
231 not including any forward-decls in the parmlist.
232 This is so we can put the parms in proper order for assign_parms. */
236 #define NULL_BINDING_LEVEL (struct binding_level *) NULL
238 /* The binding level currently in effect. */
240 static struct binding_level *current_binding_level;
242 /* A chain of binding_level structures awaiting reuse. */
244 static struct binding_level *free_binding_level;
246 /* The outermost binding level, for names of file scope.
247 This is created when the compiler is started and exists
248 through the entire run. */
250 static struct binding_level *global_binding_level;
252 /* Binding level structures are initialized by copying this one. */
254 static struct binding_level clear_binding_level
255 = {NULL, NULL, NULL, NULL, NULL, NULL_BINDING_LEVEL, 0, 0, 0, 0, 0, 0,
258 /* Nonzero means unconditionally make a BLOCK for the next level pushed. */
260 static int keep_next_level_flag;
262 /* Nonzero means make a BLOCK for the next level pushed
263 if it has subblocks. */
265 static int keep_next_if_subblocks;
267 /* The chain of outer levels of label scopes.
268 This uses the same data structure used for binding levels,
269 but it works differently: each link in the chain records
270 saved values of named_labels and shadowed_labels for
271 a label binding level outside the current one. */
273 static struct binding_level *label_level_chain;
275 /* Functions called automatically at the beginning and end of execution. */
277 tree static_ctors, static_dtors;
279 /* Forward declarations. */
281 static struct binding_level * make_binding_level PARAMS ((void));
282 static void mark_binding_level PARAMS ((void *));
283 static void clear_limbo_values PARAMS ((tree));
284 static int duplicate_decls PARAMS ((tree, tree, int));
285 static int redeclaration_error_message PARAMS ((tree, tree));
286 static void storedecls PARAMS ((tree));
287 static void storetags PARAMS ((tree));
288 static tree lookup_tag PARAMS ((enum tree_code, tree,
289 struct binding_level *, int));
290 static tree lookup_tag_reverse PARAMS ((tree));
291 static tree grokdeclarator PARAMS ((tree, tree, enum decl_context,
293 static tree grokparms PARAMS ((tree, int));
294 static void layout_array_type PARAMS ((tree));
296 /* C-specific option variables. */
298 /* Nonzero means allow type mismatches in conditional expressions;
299 just make their values `void'. */
301 int flag_cond_mismatch;
303 /* Nonzero means give `double' the same size as `float'. */
305 int flag_short_double;
307 /* Nonzero means give `wchar_t' the same size as `short'. */
309 int flag_short_wchar;
311 /* Nonzero means don't recognize the keyword `asm'. */
315 /* Nonzero means don't recognize any builtin functions. */
319 /* Nonzero means don't recognize the non-ANSI builtin functions.
322 int flag_no_nonansi_builtin;
324 /* Nonzero means do some things the same way PCC does. */
326 int flag_traditional;
328 /* Nonzero means use the ISO C99 dialect of C. */
332 /* Nonzero means that we have builtin functions, and main is an int */
336 /* Nonzero means to allow single precision math even if we're generally
337 being traditional. */
338 int flag_allow_single_precision = 0;
340 /* Nonzero means to treat bitfields as signed unless they say `unsigned'. */
342 int flag_signed_bitfields = 1;
343 int explicit_flag_signed_bitfields = 0;
345 /* Nonzero means warn about use of implicit int. */
347 int warn_implicit_int;
349 /* Nonzero means warn about usage of long long when `-pedantic'. */
351 int warn_long_long = 1;
353 /* Nonzero means message about use of implicit function declarations;
354 1 means warning; 2 means error. */
356 int mesg_implicit_function_declaration;
358 /* Nonzero means give string constants the type `const char *'
359 to get extra warnings from them. These warnings will be too numerous
360 to be useful, except in thoroughly ANSIfied programs. */
362 int flag_const_strings;
364 /* Nonzero means warn about pointer casts that can drop a type qualifier
365 from the pointer target type. */
369 /* Nonzero means warn when casting a function call to a type that does
370 not match the return type (e.g. (float)sqrt() or (anything*)malloc()
371 when there is no previous declaration of sqrt or malloc. */
373 int warn_bad_function_cast;
375 /* Warn about functions which might be candidates for attribute noreturn. */
377 int warn_missing_noreturn;
379 /* Warn about traditional constructs whose meanings changed in ANSI C. */
381 int warn_traditional;
383 /* Nonzero means warn about sizeof(function) or addition/subtraction
384 of function pointers. */
386 int warn_pointer_arith;
388 /* Nonzero means warn for non-prototype function decls
389 or non-prototyped defs without previous prototype. */
391 int warn_strict_prototypes;
393 /* Nonzero means warn for any global function def
394 without separate previous prototype decl. */
396 int warn_missing_prototypes;
398 /* Nonzero means warn for any global function def
399 without separate previous decl. */
401 int warn_missing_declarations;
403 /* Nonzero means warn about multiple (redundant) decls for the same single
404 variable or function. */
406 int warn_redundant_decls = 0;
408 /* Nonzero means warn about extern declarations of objects not at
409 file-scope level and about *all* declarations of functions (whether
410 extern or static) not at file-scope level. Note that we exclude
411 implicit function declarations. To get warnings about those, use
414 int warn_nested_externs = 0;
416 /* Warn about *printf or *scanf format/argument anomalies. */
420 /* Warn about a subscript that has type char. */
422 int warn_char_subscripts = 0;
424 /* Warn if a type conversion is done that might have confusing results. */
428 /* Warn if adding () is suggested. */
430 int warn_parentheses;
432 /* Warn if initializer is not completely bracketed. */
434 int warn_missing_braces;
436 /* Warn if main is suspicious. */
440 /* Warn about #pragma directives that are not recognised. */
442 int warn_unknown_pragmas = 0; /* Tri state variable. */
444 /* Warn about comparison of signed and unsigned values.
445 If -1, neither -Wsign-compare nor -Wno-sign-compare has been specified. */
447 int warn_sign_compare = -1;
449 /* Warn about testing equality of floating point numbers. */
451 int warn_float_equal = 0;
453 /* Nonzero means warn about use of multicharacter literals. */
455 int warn_multichar = 1;
457 /* Nonzero means `$' can be in an identifier. */
459 #ifndef DOLLARS_IN_IDENTIFIERS
460 #define DOLLARS_IN_IDENTIFIERS 1
462 int dollars_in_ident = DOLLARS_IN_IDENTIFIERS;
464 /* Decode the string P as a language-specific option for C.
465 Return the number of strings consumed. Should not complain
466 if it does not recognise the option. */
469 c_decode_option (argc, argv)
470 int argc ATTRIBUTE_UNUSED;
473 int strings_processed;
476 strings_processed = cpp_handle_option (&parse_in, argc, argv);
478 strings_processed = 0;
479 #endif /* ! USE_CPPLIB */
481 if (!strcmp (p, "-ftraditional") || !strcmp (p, "-traditional"))
483 flag_traditional = 1;
484 flag_writable_strings = 1;
486 else if (!strcmp (p, "-fallow-single-precision"))
487 flag_allow_single_precision = 1;
488 else if (!strcmp (p, "-fhosted") || !strcmp (p, "-fno-freestanding"))
493 else if (!strcmp (p, "-ffreestanding") || !strcmp (p, "-fno-hosted"))
497 /* warn_main will be 2 if set by -Wall, 1 if set by -Wmain */
501 else if (!strcmp (p, "-fnotraditional") || !strcmp (p, "-fno-traditional"))
503 flag_traditional = 0;
504 flag_writable_strings = 0;
506 else if (!strncmp (p, "-std=", 5))
508 /* Select the appropriate language standard. We currently
510 -std=iso9899:1990 same as -ansi
511 -std=iso9899:199409 ISO C as modified in amend. 1
512 -std=iso9899:1999 ISO C 99
513 -std=c89 same as -std=iso9899:1990
514 -std=c99 same as -std=iso9899:1999
515 -std=gnu89 default, iso9899:1990 + gnu extensions
516 -std=gnu99 iso9899:1999 + gnu extensions
518 const char *argstart = &p[5];
520 if (!strcmp (argstart, "iso9899:1990")
521 || !strcmp (argstart, "c89"))
524 flag_traditional = 0;
525 flag_writable_strings = 0;
527 flag_no_nonansi_builtin = 1;
530 else if (!strcmp (argstart, "iso9899:199409"))
532 /* ??? The changes since ISO C 1990 are not supported. */
535 else if (!strcmp (argstart, "iso9899:199x")
536 || !strcmp (argstart, "iso9899:1999")
537 || !strcmp (argstart, "c9x")
538 || !strcmp (argstart, "c99"))
540 flag_traditional = 0;
541 flag_writable_strings = 0;
543 flag_no_nonansi_builtin = 1;
546 else if (!strcmp (argstart, "gnu89"))
548 flag_traditional = 0;
549 flag_writable_strings = 0;
551 flag_no_nonansi_builtin = 0;
554 else if (!strcmp (argstart, "gnu9x") || !strcmp (argstart, "gnu99"))
556 flag_traditional = 0;
557 flag_writable_strings = 0;
559 flag_no_nonansi_builtin = 0;
563 error ("unknown C standard `%s'", argstart);
565 else if (!strcmp (p, "-fdollars-in-identifiers"))
566 dollars_in_ident = 1;
567 else if (!strcmp (p, "-fno-dollars-in-identifiers"))
568 dollars_in_ident = 0;
569 else if (!strcmp (p, "-fsigned-char"))
570 flag_signed_char = 1;
571 else if (!strcmp (p, "-funsigned-char"))
572 flag_signed_char = 0;
573 else if (!strcmp (p, "-fno-signed-char"))
574 flag_signed_char = 0;
575 else if (!strcmp (p, "-fno-unsigned-char"))
576 flag_signed_char = 1;
577 else if (!strcmp (p, "-fsigned-bitfields")
578 || !strcmp (p, "-fno-unsigned-bitfields"))
580 flag_signed_bitfields = 1;
581 explicit_flag_signed_bitfields = 1;
583 else if (!strcmp (p, "-funsigned-bitfields")
584 || !strcmp (p, "-fno-signed-bitfields"))
586 flag_signed_bitfields = 0;
587 explicit_flag_signed_bitfields = 1;
589 else if (!strcmp (p, "-fshort-enums"))
590 flag_short_enums = 1;
591 else if (!strcmp (p, "-fno-short-enums"))
592 flag_short_enums = 0;
593 else if (!strcmp (p, "-fshort-wchar"))
594 flag_short_wchar = 1;
595 else if (!strcmp (p, "-fno-short-wchar"))
596 flag_short_wchar = 0;
597 else if (!strcmp (p, "-fcond-mismatch"))
598 flag_cond_mismatch = 1;
599 else if (!strcmp (p, "-fno-cond-mismatch"))
600 flag_cond_mismatch = 0;
601 else if (!strcmp (p, "-fshort-double"))
602 flag_short_double = 1;
603 else if (!strcmp (p, "-fno-short-double"))
604 flag_short_double = 0;
605 else if (!strcmp (p, "-fasm"))
607 else if (!strcmp (p, "-fno-asm"))
609 else if (!strcmp (p, "-fbuiltin"))
611 else if (!strcmp (p, "-fno-builtin"))
613 else if (!strcmp (p, "-ansi"))
615 else if (!strcmp (p, "-Werror-implicit-function-declaration"))
616 mesg_implicit_function_declaration = 2;
617 else if (!strcmp (p, "-Wimplicit-function-declaration"))
618 mesg_implicit_function_declaration = 1;
619 else if (!strcmp (p, "-Wno-implicit-function-declaration"))
620 mesg_implicit_function_declaration = 0;
621 else if (!strcmp (p, "-Wimplicit-int"))
622 warn_implicit_int = 1;
623 else if (!strcmp (p, "-Wno-implicit-int"))
624 warn_implicit_int = 0;
625 else if (!strcmp (p, "-Wimplicit"))
627 warn_implicit_int = 1;
628 if (mesg_implicit_function_declaration != 2)
629 mesg_implicit_function_declaration = 1;
631 else if (!strcmp (p, "-Wno-implicit"))
632 warn_implicit_int = 0, mesg_implicit_function_declaration = 0;
633 else if (!strcmp (p, "-Wlong-long"))
635 else if (!strcmp (p, "-Wno-long-long"))
637 else if (!strcmp (p, "-Wwrite-strings"))
638 flag_const_strings = 1;
639 else if (!strcmp (p, "-Wno-write-strings"))
640 flag_const_strings = 0;
641 else if (!strcmp (p, "-Wcast-qual"))
643 else if (!strcmp (p, "-Wno-cast-qual"))
645 else if (!strcmp (p, "-Wbad-function-cast"))
646 warn_bad_function_cast = 1;
647 else if (!strcmp (p, "-Wno-bad-function-cast"))
648 warn_bad_function_cast = 0;
649 else if (!strcmp (p, "-Wmissing-noreturn"))
650 warn_missing_noreturn = 1;
651 else if (!strcmp (p, "-Wno-missing-noreturn"))
652 warn_missing_noreturn = 0;
653 else if (!strcmp (p, "-Wpointer-arith"))
654 warn_pointer_arith = 1;
655 else if (!strcmp (p, "-Wno-pointer-arith"))
656 warn_pointer_arith = 0;
657 else if (!strcmp (p, "-Wstrict-prototypes"))
658 warn_strict_prototypes = 1;
659 else if (!strcmp (p, "-Wno-strict-prototypes"))
660 warn_strict_prototypes = 0;
661 else if (!strcmp (p, "-Wmissing-prototypes"))
662 warn_missing_prototypes = 1;
663 else if (!strcmp (p, "-Wno-missing-prototypes"))
664 warn_missing_prototypes = 0;
665 else if (!strcmp (p, "-Wmissing-declarations"))
666 warn_missing_declarations = 1;
667 else if (!strcmp (p, "-Wno-missing-declarations"))
668 warn_missing_declarations = 0;
669 else if (!strcmp (p, "-Wredundant-decls"))
670 warn_redundant_decls = 1;
671 else if (!strcmp (p, "-Wno-redundant-decls"))
672 warn_redundant_decls = 0;
673 else if (!strcmp (p, "-Wnested-externs"))
674 warn_nested_externs = 1;
675 else if (!strcmp (p, "-Wno-nested-externs"))
676 warn_nested_externs = 0;
677 else if (!strcmp (p, "-Wtraditional"))
678 warn_traditional = 1;
679 else if (!strcmp (p, "-Wno-traditional"))
680 warn_traditional = 0;
681 else if (!strncmp (p, "-Wformat=", 9))
682 warn_format = atol (p + 9);
683 else if (!strcmp (p, "-Wformat"))
685 else if (!strcmp (p, "-Wno-format"))
687 else if (!strcmp (p, "-Wchar-subscripts"))
688 warn_char_subscripts = 1;
689 else if (!strcmp (p, "-Wno-char-subscripts"))
690 warn_char_subscripts = 0;
691 else if (!strcmp (p, "-Wconversion"))
693 else if (!strcmp (p, "-Wno-conversion"))
695 else if (!strcmp (p, "-Wparentheses"))
696 warn_parentheses = 1;
697 else if (!strcmp (p, "-Wno-parentheses"))
698 warn_parentheses = 0;
699 else if (!strcmp (p, "-Wreturn-type"))
700 warn_return_type = 1;
701 else if (!strcmp (p, "-Wno-return-type"))
702 warn_return_type = 0;
703 else if (!strcmp (p, "-Wcomment"))
704 ; /* cpp handles this one. */
705 else if (!strcmp (p, "-Wno-comment"))
706 ; /* cpp handles this one. */
707 else if (!strcmp (p, "-Wcomments"))
708 ; /* cpp handles this one. */
709 else if (!strcmp (p, "-Wno-comments"))
710 ; /* cpp handles this one. */
711 else if (!strcmp (p, "-Wtrigraphs"))
712 ; /* cpp handles this one. */
713 else if (!strcmp (p, "-Wno-trigraphs"))
714 ; /* cpp handles this one. */
715 else if (!strcmp (p, "-Wundef"))
716 ; /* cpp handles this one. */
717 else if (!strcmp (p, "-Wno-undef"))
718 ; /* cpp handles this one. */
719 else if (!strcmp (p, "-Wimport"))
720 ; /* cpp handles this one. */
721 else if (!strcmp (p, "-Wno-import"))
722 ; /* cpp handles this one. */
723 else if (!strcmp (p, "-Wmissing-braces"))
724 warn_missing_braces = 1;
725 else if (!strcmp (p, "-Wno-missing-braces"))
726 warn_missing_braces = 0;
727 else if (!strcmp (p, "-Wmain"))
729 else if (!strcmp (p, "-Wno-main"))
731 else if (!strcmp (p, "-Wsign-compare"))
732 warn_sign_compare = 1;
733 else if (!strcmp (p, "-Wno-sign-compare"))
734 warn_sign_compare = 0;
735 else if (!strcmp (p, "-Wfloat-equal"))
736 warn_float_equal = 1;
737 else if (!strcmp (p, "-Wno-float-equal"))
738 warn_float_equal = 0;
739 else if (!strcmp (p, "-Wmultichar"))
741 else if (!strcmp (p, "-Wno-multichar"))
743 else if (!strcmp (p, "-Wunknown-pragmas"))
744 /* Set to greater than 1, so that even unknown pragmas in system
745 headers will be warned about. */
746 warn_unknown_pragmas = 2;
747 else if (!strcmp (p, "-Wno-unknown-pragmas"))
748 warn_unknown_pragmas = 0;
749 else if (!strcmp (p, "-Wall"))
751 /* We save the value of warn_uninitialized, since if they put
752 -Wuninitialized on the command line, we need to generate a
753 warning about not using it without also specifying -O. */
754 if (warn_uninitialized != 1)
755 warn_uninitialized = 2;
756 warn_implicit_int = 1;
757 mesg_implicit_function_declaration = 1;
758 warn_return_type = 1;
762 warn_char_subscripts = 1;
763 warn_parentheses = 1;
764 warn_missing_braces = 1;
765 /* We set this to 2 here, but 1 in -Wmain, so -ffreestanding can turn
766 it off only if it's not explicit. */
768 /* Only warn about unknown pragmas that are not in system headers. */
769 warn_unknown_pragmas = 1;
772 return strings_processed;
777 /* Hooks for print_node. */
780 print_lang_decl (file, node, indent)
781 FILE *file ATTRIBUTE_UNUSED;
782 tree node ATTRIBUTE_UNUSED;
783 int indent ATTRIBUTE_UNUSED;
788 print_lang_type (file, node, indent)
789 FILE *file ATTRIBUTE_UNUSED;
790 tree node ATTRIBUTE_UNUSED;
791 int indent ATTRIBUTE_UNUSED;
796 print_lang_identifier (file, node, indent)
801 print_node (file, "global", IDENTIFIER_GLOBAL_VALUE (node), indent + 4);
802 print_node (file, "local", IDENTIFIER_LOCAL_VALUE (node), indent + 4);
803 print_node (file, "label", IDENTIFIER_LABEL_VALUE (node), indent + 4);
804 print_node (file, "implicit", IDENTIFIER_IMPLICIT_DECL (node), indent + 4);
805 print_node (file, "error locus", IDENTIFIER_ERROR_LOCUS (node), indent + 4);
806 print_node (file, "limbo value", IDENTIFIER_LIMBO_VALUE (node), indent + 4);
809 /* Hook called at end of compilation to assume 1 elt
810 for a top-level array decl that wasn't complete before. */
813 finish_incomplete_decl (decl)
816 if (TREE_CODE (decl) == VAR_DECL)
818 tree type = TREE_TYPE (decl);
819 if (type != error_mark_node
820 && TREE_CODE (type) == ARRAY_TYPE
821 && TYPE_DOMAIN (type) == 0)
823 if (! DECL_EXTERNAL (decl))
824 warning_with_decl (decl, "array `%s' assumed to have one element");
826 complete_array_type (type, NULL_TREE, 1);
828 layout_decl (decl, 0);
833 /* Create a new `struct binding_level'. */
836 struct binding_level *
837 make_binding_level ()
840 return (struct binding_level *) xmalloc (sizeof (struct binding_level));
843 /* Nonzero if we are currently in the global binding level. */
848 return current_binding_level == global_binding_level;
854 keep_next_level_flag = 1;
857 /* Nonzero if the current level needs to have a BLOCK made. */
862 return ((current_binding_level->keep_if_subblocks
863 && current_binding_level->blocks != 0)
864 || current_binding_level->keep
865 || current_binding_level->names != 0
866 || (current_binding_level->tags != 0
867 && !current_binding_level->tag_transparent));
870 /* Identify this binding level as a level of parameters.
871 DEFINITION_FLAG is 1 for a definition, 0 for a declaration.
872 But it turns out there is no way to pass the right value for
873 DEFINITION_FLAG, so we ignore it. */
876 declare_parm_level (definition_flag)
877 int definition_flag ATTRIBUTE_UNUSED;
879 current_binding_level->parm_flag = 1;
882 /* Nonzero if currently making parm declarations. */
887 return current_binding_level->parm_flag;
890 /* Enter a new binding level.
891 If TAG_TRANSPARENT is nonzero, do so only for the name space of variables,
892 not for that of tags. */
895 pushlevel (tag_transparent)
898 register struct binding_level *newlevel = NULL_BINDING_LEVEL;
900 /* If this is the top level of a function,
901 just make sure that NAMED_LABELS is 0. */
903 if (current_binding_level == global_binding_level)
908 /* Reuse or create a struct for this binding level. */
910 if (free_binding_level)
912 newlevel = free_binding_level;
913 free_binding_level = free_binding_level->level_chain;
917 newlevel = make_binding_level ();
920 /* Add this level to the front of the chain (stack) of levels that
923 *newlevel = clear_binding_level;
924 newlevel->tag_transparent
926 || (current_binding_level
927 ? current_binding_level->subblocks_tag_transparent
929 newlevel->level_chain = current_binding_level;
930 current_binding_level = newlevel;
931 newlevel->keep = keep_next_level_flag;
932 keep_next_level_flag = 0;
933 newlevel->keep_if_subblocks = keep_next_if_subblocks;
934 keep_next_if_subblocks = 0;
937 /* Clear the limbo values of all identifiers defined in BLOCK or a subblock. */
940 clear_limbo_values (block)
945 for (tem = BLOCK_VARS (block); tem; tem = TREE_CHAIN (tem))
946 if (DECL_NAME (tem) != 0)
947 IDENTIFIER_LIMBO_VALUE (DECL_NAME (tem)) = 0;
949 for (tem = BLOCK_SUBBLOCKS (block); tem; tem = TREE_CHAIN (tem))
950 clear_limbo_values (tem);
953 /* Exit a binding level.
954 Pop the level off, and restore the state of the identifier-decl mappings
955 that were in effect when this level was entered.
957 If KEEP is nonzero, this level had explicit declarations, so
958 and create a "block" (a BLOCK node) for the level
959 to record its declarations and subblocks for symbol table output.
961 If FUNCTIONBODY is nonzero, this level is the body of a function,
962 so create a block as if KEEP were set and also clear out all
965 If REVERSE is nonzero, reverse the order of decls before putting
966 them into the BLOCK. */
969 poplevel (keep, reverse, functionbody)
975 /* The chain of decls was accumulated in reverse order.
976 Put it into forward order, just for cleanliness. */
978 tree tags = current_binding_level->tags;
979 tree subblocks = current_binding_level->blocks;
982 int block_previously_created;
984 keep |= current_binding_level->keep;
986 /* This warning is turned off because it causes warnings for
987 declarations like `extern struct foo *x'. */
989 /* Warn about incomplete structure types in this level. */
990 for (link = tags; link; link = TREE_CHAIN (link))
991 if (TYPE_SIZE (TREE_VALUE (link)) == 0)
993 tree type = TREE_VALUE (link);
994 tree type_name = TYPE_NAME (type);
995 char *id = IDENTIFIER_POINTER (TREE_CODE (type_name) == IDENTIFIER_NODE
997 : DECL_NAME (type_name));
998 switch (TREE_CODE (type))
1001 error ("`struct %s' incomplete in scope ending here", id);
1004 error ("`union %s' incomplete in scope ending here", id);
1007 error ("`enum %s' incomplete in scope ending here", id);
1013 /* Get the decls in the order they were written.
1014 Usually current_binding_level->names is in reverse order.
1015 But parameter decls were previously put in forward order. */
1018 current_binding_level->names
1019 = decls = nreverse (current_binding_level->names);
1021 decls = current_binding_level->names;
1023 /* Output any nested inline functions within this block
1024 if they weren't already output. */
1026 for (decl = decls; decl; decl = TREE_CHAIN (decl))
1027 if (TREE_CODE (decl) == FUNCTION_DECL
1028 && ! TREE_ASM_WRITTEN (decl)
1029 && DECL_INITIAL (decl) != 0
1030 && TREE_ADDRESSABLE (decl))
1032 /* If this decl was copied from a file-scope decl
1033 on account of a block-scope extern decl,
1034 propagate TREE_ADDRESSABLE to the file-scope decl.
1036 DECL_ABSTRACT_ORIGIN can be set to itself if warn_return_type is
1037 true, since then the decl goes through save_for_inline_copying. */
1038 if (DECL_ABSTRACT_ORIGIN (decl) != 0
1039 && DECL_ABSTRACT_ORIGIN (decl) != decl)
1040 TREE_ADDRESSABLE (DECL_ABSTRACT_ORIGIN (decl)) = 1;
1041 else if (DECL_SAVED_INSNS (decl) != 0)
1043 push_function_context ();
1044 output_inline_function (decl);
1045 pop_function_context ();
1049 /* If there were any declarations or structure tags in that level,
1050 or if this level is a function body,
1051 create a BLOCK to record them for the life of this function. */
1054 block_previously_created = (current_binding_level->this_block != 0);
1055 if (block_previously_created)
1056 block = current_binding_level->this_block;
1057 else if (keep || functionbody
1058 || (current_binding_level->keep_if_subblocks && subblocks != 0))
1059 block = make_node (BLOCK);
1062 BLOCK_VARS (block) = decls;
1063 BLOCK_SUBBLOCKS (block) = subblocks;
1066 /* In each subblock, record that this is its superior. */
1068 for (link = subblocks; link; link = TREE_CHAIN (link))
1069 BLOCK_SUPERCONTEXT (link) = block;
1071 /* Clear out the meanings of the local variables of this level. */
1073 for (link = decls; link; link = TREE_CHAIN (link))
1075 if (DECL_NAME (link) != 0)
1077 /* If the ident. was used or addressed via a local extern decl,
1078 don't forget that fact. */
1079 if (DECL_EXTERNAL (link))
1081 if (TREE_USED (link))
1082 TREE_USED (DECL_NAME (link)) = 1;
1083 if (TREE_ADDRESSABLE (link))
1084 TREE_ADDRESSABLE (DECL_ASSEMBLER_NAME (link)) = 1;
1086 IDENTIFIER_LOCAL_VALUE (DECL_NAME (link)) = 0;
1090 /* Restore all name-meanings of the outer levels
1091 that were shadowed by this level. */
1093 for (link = current_binding_level->shadowed; link; link = TREE_CHAIN (link))
1094 IDENTIFIER_LOCAL_VALUE (TREE_PURPOSE (link)) = TREE_VALUE (link);
1096 /* If the level being exited is the top level of a function,
1097 check over all the labels, and clear out the current
1098 (function local) meanings of their names. */
1102 clear_limbo_values (block);
1104 /* If this is the top level block of a function,
1105 the vars are the function's parameters.
1106 Don't leave them in the BLOCK because they are
1107 found in the FUNCTION_DECL instead. */
1109 BLOCK_VARS (block) = 0;
1111 /* Clear out the definitions of all label names,
1112 since their scopes end here,
1113 and add them to BLOCK_VARS. */
1115 for (link = named_labels; link; link = TREE_CHAIN (link))
1117 register tree label = TREE_VALUE (link);
1119 if (DECL_INITIAL (label) == 0)
1121 error_with_decl (label, "label `%s' used but not defined");
1122 /* Avoid crashing later. */
1123 define_label (input_filename, lineno,
1126 else if (warn_unused && !TREE_USED (label))
1127 warning_with_decl (label, "label `%s' defined but not used");
1128 IDENTIFIER_LABEL_VALUE (DECL_NAME (label)) = 0;
1130 /* Put the labels into the "variables" of the
1131 top-level block, so debugger can see them. */
1132 TREE_CHAIN (label) = BLOCK_VARS (block);
1133 BLOCK_VARS (block) = label;
1137 /* Pop the current level, and free the structure for reuse. */
1140 register struct binding_level *level = current_binding_level;
1141 current_binding_level = current_binding_level->level_chain;
1143 level->level_chain = free_binding_level;
1144 free_binding_level = level;
1147 /* Dispose of the block that we just made inside some higher level. */
1149 DECL_INITIAL (current_function_decl) = block;
1152 if (!block_previously_created)
1153 current_binding_level->blocks
1154 = chainon (current_binding_level->blocks, block);
1156 /* If we did not make a block for the level just exited,
1157 any blocks made for inner levels
1158 (since they cannot be recorded as subblocks in that level)
1159 must be carried forward so they will later become subblocks
1160 of something else. */
1162 current_binding_level->blocks
1163 = chainon (current_binding_level->blocks, subblocks);
1165 /* Set the TYPE_CONTEXTs for all of the tagged types belonging to this
1166 binding contour so that they point to the appropriate construct, i.e.
1167 either to the current FUNCTION_DECL node, or else to the BLOCK node
1168 we just constructed.
1170 Note that for tagged types whose scope is just the formal parameter
1171 list for some function type specification, we can't properly set
1172 their TYPE_CONTEXTs here, because we don't have a pointer to the
1173 appropriate FUNCTION_TYPE node readily available to us. For those
1174 cases, the TYPE_CONTEXTs of the relevant tagged type nodes get set
1175 in `grokdeclarator' as soon as we have created the FUNCTION_TYPE
1176 node which will represent the "scope" for these "parameter list local"
1181 for (link = tags; link; link = TREE_CHAIN (link))
1182 TYPE_CONTEXT (TREE_VALUE (link)) = current_function_decl;
1184 for (link = tags; link; link = TREE_CHAIN (link))
1185 TYPE_CONTEXT (TREE_VALUE (link)) = block;
1188 TREE_USED (block) = 1;
1192 /* Delete the node BLOCK from the current binding level.
1193 This is used for the block inside a stmt expr ({...})
1194 so that the block can be reinserted where appropriate. */
1197 delete_block (block)
1201 if (current_binding_level->blocks == block)
1202 current_binding_level->blocks = TREE_CHAIN (block);
1203 for (t = current_binding_level->blocks; t;)
1205 if (TREE_CHAIN (t) == block)
1206 TREE_CHAIN (t) = TREE_CHAIN (block);
1210 TREE_CHAIN (block) = NULL;
1211 /* Clear TREE_USED which is always set by poplevel.
1212 The flag is set again if insert_block is called. */
1213 TREE_USED (block) = 0;
1216 /* Insert BLOCK at the end of the list of subblocks of the
1217 current binding level. This is used when a BIND_EXPR is expanded,
1218 to handle the BLOCK node inside the BIND_EXPR. */
1221 insert_block (block)
1224 TREE_USED (block) = 1;
1225 current_binding_level->blocks
1226 = chainon (current_binding_level->blocks, block);
1229 /* Set the BLOCK node for the innermost scope
1230 (the one we are currently in). */
1234 register tree block;
1236 current_binding_level->this_block = block;
1242 register struct binding_level *newlevel;
1244 /* Reuse or create a struct for this binding level. */
1246 if (free_binding_level)
1248 newlevel = free_binding_level;
1249 free_binding_level = free_binding_level->level_chain;
1253 newlevel = make_binding_level ();
1256 /* Add this level to the front of the chain (stack) of label levels. */
1258 newlevel->level_chain = label_level_chain;
1259 label_level_chain = newlevel;
1261 newlevel->names = named_labels;
1262 newlevel->shadowed = shadowed_labels;
1264 shadowed_labels = 0;
1270 register struct binding_level *level = label_level_chain;
1273 /* Clear out the definitions of the declared labels in this level.
1274 Leave in the list any ordinary, non-declared labels. */
1275 for (link = named_labels, prev = 0; link;)
1277 if (C_DECLARED_LABEL_FLAG (TREE_VALUE (link)))
1279 if (DECL_SOURCE_LINE (TREE_VALUE (link)) == 0)
1281 error_with_decl (TREE_VALUE (link),
1282 "label `%s' used but not defined");
1283 /* Avoid crashing later. */
1284 define_label (input_filename, lineno,
1285 DECL_NAME (TREE_VALUE (link)));
1287 else if (warn_unused && !TREE_USED (TREE_VALUE (link)))
1288 warning_with_decl (TREE_VALUE (link),
1289 "label `%s' defined but not used");
1290 IDENTIFIER_LABEL_VALUE (DECL_NAME (TREE_VALUE (link))) = 0;
1292 /* Delete this element from the list. */
1293 link = TREE_CHAIN (link);
1295 TREE_CHAIN (prev) = link;
1297 named_labels = link;
1302 link = TREE_CHAIN (link);
1306 /* Bring back all the labels that were shadowed. */
1307 for (link = shadowed_labels; link; link = TREE_CHAIN (link))
1308 if (DECL_NAME (TREE_VALUE (link)) != 0)
1309 IDENTIFIER_LABEL_VALUE (DECL_NAME (TREE_VALUE (link)))
1310 = TREE_VALUE (link);
1312 named_labels = chainon (named_labels, level->names);
1313 shadowed_labels = level->shadowed;
1315 /* Pop the current level, and free the structure for reuse. */
1316 label_level_chain = label_level_chain->level_chain;
1317 level->level_chain = free_binding_level;
1318 free_binding_level = level;
1321 /* Push a definition or a declaration of struct, union or enum tag "name".
1322 "type" should be the type node.
1323 We assume that the tag "name" is not already defined.
1325 Note that the definition may really be just a forward reference.
1326 In that case, the TYPE_SIZE will be zero. */
1329 pushtag (name, type)
1332 register struct binding_level *b;
1334 /* Find the proper binding level for this type tag. */
1336 for (b = current_binding_level; b->tag_transparent; b = b->level_chain)
1341 /* Record the identifier as the type's name if it has none. */
1343 if (TYPE_NAME (type) == 0)
1344 TYPE_NAME (type) = name;
1347 b->tags = tree_cons (name, type, b->tags);
1349 /* Create a fake NULL-named TYPE_DECL node whose TREE_TYPE will be the
1350 tagged type we just added to the current binding level. This fake
1351 NULL-named TYPE_DECL node helps dwarfout.c to know when it needs
1352 to output a representation of a tagged type, and it also gives
1353 us a convenient place to record the "scope start" address for the
1356 TYPE_STUB_DECL (type) = pushdecl (build_decl (TYPE_DECL, NULL_TREE, type));
1358 /* An approximation for now, so we can tell this is a function-scope tag.
1359 This will be updated in poplevel. */
1360 TYPE_CONTEXT (type) = DECL_CONTEXT (TYPE_STUB_DECL (type));
1363 /* Handle when a new declaration NEWDECL
1364 has the same name as an old one OLDDECL
1365 in the same binding contour.
1366 Prints an error message if appropriate.
1368 If safely possible, alter OLDDECL to look like NEWDECL, and return 1.
1369 Otherwise, return 0.
1371 When DIFFERENT_BINDING_LEVEL is true, NEWDECL is an external declaration,
1372 and OLDDECL is in an outer binding level and should thus not be changed. */
1375 duplicate_decls (newdecl, olddecl, different_binding_level)
1376 register tree newdecl, olddecl;
1377 int different_binding_level;
1379 int types_match = comptypes (TREE_TYPE (newdecl), TREE_TYPE (olddecl));
1380 int new_is_definition = (TREE_CODE (newdecl) == FUNCTION_DECL
1381 && DECL_INITIAL (newdecl) != 0);
1382 tree oldtype = TREE_TYPE (olddecl);
1383 tree newtype = TREE_TYPE (newdecl);
1386 if (TREE_CODE_CLASS (TREE_CODE (olddecl)) == 'd')
1387 DECL_MACHINE_ATTRIBUTES (newdecl)
1388 = merge_machine_decl_attributes (olddecl, newdecl);
1390 if (TREE_CODE (newtype) == ERROR_MARK
1391 || TREE_CODE (oldtype) == ERROR_MARK)
1394 /* New decl is completely inconsistent with the old one =>
1395 tell caller to replace the old one.
1396 This is always an error except in the case of shadowing a builtin. */
1397 if (TREE_CODE (olddecl) != TREE_CODE (newdecl))
1399 if (TREE_CODE (olddecl) == FUNCTION_DECL
1400 && (DECL_BUILT_IN (olddecl)
1401 || DECL_BUILT_IN_NONANSI (olddecl)))
1403 /* If you declare a built-in or predefined function name as static,
1404 the old definition is overridden,
1405 but optionally warn this was a bad choice of name. */
1406 if (!TREE_PUBLIC (newdecl))
1410 else if (DECL_BUILT_IN (olddecl))
1411 warning_with_decl (newdecl, "shadowing built-in function `%s'");
1413 warning_with_decl (newdecl, "shadowing library function `%s'");
1415 /* Likewise, if the built-in is not ansi, then programs can
1416 override it even globally without an error. */
1417 else if (! DECL_BUILT_IN (olddecl))
1418 warning_with_decl (newdecl,
1419 "library function `%s' declared as non-function");
1421 else if (DECL_BUILT_IN_NONANSI (olddecl))
1422 warning_with_decl (newdecl,
1423 "built-in function `%s' declared as non-function");
1425 warning_with_decl (newdecl,
1426 "built-in function `%s' declared as non-function");
1430 error_with_decl (newdecl, "`%s' redeclared as different kind of symbol");
1431 error_with_decl (olddecl, "previous declaration of `%s'");
1437 /* For real parm decl following a forward decl,
1438 return 1 so old decl will be reused. */
1439 if (types_match && TREE_CODE (newdecl) == PARM_DECL
1440 && TREE_ASM_WRITTEN (olddecl) && ! TREE_ASM_WRITTEN (newdecl))
1443 /* The new declaration is the same kind of object as the old one.
1444 The declarations may partially match. Print warnings if they don't
1445 match enough. Ultimately, copy most of the information from the new
1446 decl to the old one, and keep using the old one. */
1448 if (flag_traditional && TREE_CODE (newdecl) == FUNCTION_DECL
1449 && IDENTIFIER_IMPLICIT_DECL (DECL_NAME (newdecl)) == olddecl
1450 && DECL_INITIAL (olddecl) == 0)
1451 /* If -traditional, avoid error for redeclaring fcn
1452 after implicit decl. */
1454 else if (TREE_CODE (olddecl) == FUNCTION_DECL
1455 && DECL_BUILT_IN (olddecl))
1457 /* A function declaration for a built-in function. */
1458 if (!TREE_PUBLIC (newdecl))
1460 /* If you declare a built-in function name as static, the
1461 built-in definition is overridden,
1462 but optionally warn this was a bad choice of name. */
1464 warning_with_decl (newdecl, "shadowing built-in function `%s'");
1465 /* Discard the old built-in function. */
1468 else if (!types_match)
1470 /* Accept the return type of the new declaration if same modes. */
1471 tree oldreturntype = TREE_TYPE (oldtype);
1472 tree newreturntype = TREE_TYPE (newtype);
1474 if (TYPE_MODE (oldreturntype) == TYPE_MODE (newreturntype))
1476 /* Function types may be shared, so we can't just modify
1477 the return type of olddecl's function type. */
1479 = build_function_type (newreturntype,
1480 TYPE_ARG_TYPES (oldtype));
1482 types_match = comptypes (newtype, trytype);
1486 /* Accept harmless mismatch in first argument type also.
1488 if (TYPE_ARG_TYPES (TREE_TYPE (newdecl)) != 0
1489 && TYPE_ARG_TYPES (oldtype) != 0
1490 && TREE_VALUE (TYPE_ARG_TYPES (newtype)) != 0
1491 && TREE_VALUE (TYPE_ARG_TYPES (oldtype)) != 0
1492 && (TYPE_MODE (TREE_VALUE (TYPE_ARG_TYPES (newtype)))
1493 == TYPE_MODE (TREE_VALUE (TYPE_ARG_TYPES (oldtype)))))
1495 /* Function types may be shared, so we can't just modify
1496 the return type of olddecl's function type. */
1498 = build_function_type (TREE_TYPE (oldtype),
1499 tree_cons (NULL_TREE,
1500 TREE_VALUE (TYPE_ARG_TYPES (newtype)),
1501 TREE_CHAIN (TYPE_ARG_TYPES (oldtype))));
1503 types_match = comptypes (newtype, trytype);
1507 if (! different_binding_level)
1508 TREE_TYPE (olddecl) = oldtype;
1512 /* If types don't match for a built-in, throw away the built-in. */
1513 warning_with_decl (newdecl, "conflicting types for built-in function `%s'");
1517 else if (TREE_CODE (olddecl) == FUNCTION_DECL
1518 && DECL_SOURCE_LINE (olddecl) == 0)
1520 /* A function declaration for a predeclared function
1521 that isn't actually built in. */
1522 if (!TREE_PUBLIC (newdecl))
1524 /* If you declare it as static, the
1525 default definition is overridden. */
1528 else if (!types_match)
1530 /* If the types don't match, preserve volatility indication.
1531 Later on, we will discard everything else about the
1532 default declaration. */
1533 TREE_THIS_VOLATILE (newdecl) |= TREE_THIS_VOLATILE (olddecl);
1536 /* Permit char *foo () to match void *foo (...) if not pedantic,
1537 if one of them came from a system header file. */
1538 else if (!types_match
1539 && TREE_CODE (olddecl) == FUNCTION_DECL
1540 && TREE_CODE (newdecl) == FUNCTION_DECL
1541 && TREE_CODE (TREE_TYPE (oldtype)) == POINTER_TYPE
1542 && TREE_CODE (TREE_TYPE (newtype)) == POINTER_TYPE
1543 && (DECL_IN_SYSTEM_HEADER (olddecl)
1544 || DECL_IN_SYSTEM_HEADER (newdecl))
1545 && ((TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (newtype))) == void_type_node
1546 && TYPE_ARG_TYPES (oldtype) == 0
1547 && self_promoting_args_p (TYPE_ARG_TYPES (newtype))
1548 && TREE_TYPE (TREE_TYPE (oldtype)) == char_type_node)
1550 (TREE_TYPE (TREE_TYPE (newtype)) == char_type_node
1551 && TYPE_ARG_TYPES (newtype) == 0
1552 && self_promoting_args_p (TYPE_ARG_TYPES (oldtype))
1553 && TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (oldtype))) == void_type_node)))
1556 pedwarn_with_decl (newdecl, "conflicting types for `%s'");
1557 /* Make sure we keep void * as ret type, not char *. */
1558 if (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (oldtype))) == void_type_node)
1559 TREE_TYPE (newdecl) = newtype = oldtype;
1561 /* Set DECL_IN_SYSTEM_HEADER, so that if we see another declaration
1562 we will come back here again. */
1563 DECL_IN_SYSTEM_HEADER (newdecl) = 1;
1565 else if (!types_match
1566 /* Permit char *foo (int, ...); followed by char *foo ();
1568 && ! (TREE_CODE (olddecl) == FUNCTION_DECL
1570 /* Return types must still match. */
1571 && comptypes (TREE_TYPE (oldtype),
1572 TREE_TYPE (newtype))
1573 && TYPE_ARG_TYPES (newtype) == 0))
1575 error_with_decl (newdecl, "conflicting types for `%s'");
1576 /* Check for function type mismatch
1577 involving an empty arglist vs a nonempty one. */
1578 if (TREE_CODE (olddecl) == FUNCTION_DECL
1579 && comptypes (TREE_TYPE (oldtype),
1580 TREE_TYPE (newtype))
1581 && ((TYPE_ARG_TYPES (oldtype) == 0
1582 && DECL_INITIAL (olddecl) == 0)
1584 (TYPE_ARG_TYPES (newtype) == 0
1585 && DECL_INITIAL (newdecl) == 0)))
1587 /* Classify the problem further. */
1588 register tree t = TYPE_ARG_TYPES (oldtype);
1590 t = TYPE_ARG_TYPES (newtype);
1591 for (; t; t = TREE_CHAIN (t))
1593 register tree type = TREE_VALUE (t);
1595 if (TREE_CHAIN (t) == 0
1596 && TYPE_MAIN_VARIANT (type) != void_type_node)
1598 error ("A parameter list with an ellipsis can't match an empty parameter name list declaration.");
1602 if (simple_type_promotes_to (type) != NULL_TREE)
1604 error ("An argument type that has a default promotion can't match an empty parameter name list declaration.");
1609 error_with_decl (olddecl, "previous declaration of `%s'");
1613 errmsg = redeclaration_error_message (newdecl, olddecl);
1619 error_with_decl (newdecl, "redefinition of `%s'");
1622 error_with_decl (newdecl, "redeclaration of `%s'");
1625 error_with_decl (newdecl, "conflicting declarations of `%s'");
1631 error_with_decl (olddecl,
1632 ((DECL_INITIAL (olddecl)
1633 && current_binding_level == global_binding_level)
1634 ? "`%s' previously defined here"
1635 : "`%s' previously declared here"));
1637 else if (TREE_CODE (newdecl) == TYPE_DECL
1638 && (DECL_IN_SYSTEM_HEADER (olddecl)
1639 || DECL_IN_SYSTEM_HEADER (newdecl)))
1641 warning_with_decl (newdecl, "redefinition of `%s'");
1644 ((DECL_INITIAL (olddecl)
1645 && current_binding_level == global_binding_level)
1646 ? "`%s' previously defined here"
1647 : "`%s' previously declared here"));
1649 else if (TREE_CODE (olddecl) == FUNCTION_DECL
1650 && DECL_INITIAL (olddecl) != 0
1651 && TYPE_ARG_TYPES (oldtype) == 0
1652 && TYPE_ARG_TYPES (newtype) != 0
1653 && TYPE_ACTUAL_ARG_TYPES (oldtype) != 0)
1655 register tree type, parm;
1657 /* Prototype decl follows defn w/o prototype. */
1659 for (parm = TYPE_ACTUAL_ARG_TYPES (oldtype),
1660 type = TYPE_ARG_TYPES (newtype),
1663 parm = TREE_CHAIN (parm), type = TREE_CHAIN (type), nargs++)
1665 if (TYPE_MAIN_VARIANT (TREE_VALUE (parm)) == void_type_node
1666 && TYPE_MAIN_VARIANT (TREE_VALUE (type)) == void_type_node)
1668 warning_with_decl (newdecl, "prototype for `%s' follows");
1669 warning_with_decl (olddecl, "non-prototype definition here");
1672 if (TYPE_MAIN_VARIANT (TREE_VALUE (parm)) == void_type_node
1673 || TYPE_MAIN_VARIANT (TREE_VALUE (type)) == void_type_node)
1675 error_with_decl (newdecl, "prototype for `%s' follows and number of arguments doesn't match");
1676 error_with_decl (olddecl, "non-prototype definition here");
1680 /* Type for passing arg must be consistent
1681 with that declared for the arg. */
1682 if (! comptypes (TREE_VALUE (parm), TREE_VALUE (type))
1683 /* If -traditional, allow `unsigned int' instead of `int'
1684 in the prototype. */
1685 && (! (flag_traditional
1686 && TYPE_MAIN_VARIANT (TREE_VALUE (parm)) == integer_type_node
1687 && TYPE_MAIN_VARIANT (TREE_VALUE (type)) == unsigned_type_node)))
1689 error_with_decl (newdecl,
1690 "prototype for `%s' follows and argument %d doesn't match",
1692 error_with_decl (olddecl, "non-prototype definition here");
1698 /* Warn about mismatches in various flags. */
1701 /* Warn if function is now inline
1702 but was previously declared not inline and has been called. */
1703 if (TREE_CODE (olddecl) == FUNCTION_DECL
1704 && ! DECL_INLINE (olddecl) && DECL_INLINE (newdecl)
1705 && TREE_USED (olddecl))
1706 warning_with_decl (newdecl,
1707 "`%s' declared inline after being called");
1708 if (TREE_CODE (olddecl) == FUNCTION_DECL
1709 && ! DECL_INLINE (olddecl) && DECL_INLINE (newdecl)
1710 && DECL_INITIAL (olddecl) != 0)
1711 warning_with_decl (newdecl,
1712 "`%s' declared inline after its definition");
1714 /* If pedantic, warn when static declaration follows a non-static
1715 declaration. Otherwise, do so only for functions. */
1716 if ((pedantic || TREE_CODE (olddecl) == FUNCTION_DECL)
1717 && TREE_PUBLIC (olddecl)
1718 && !TREE_PUBLIC (newdecl))
1719 warning_with_decl (newdecl, "static declaration for `%s' follows non-static");
1721 /* If warn_traditional, warn when a non-static function
1722 declaration follows a static one. */
1723 if (warn_traditional
1724 && TREE_CODE (olddecl) == FUNCTION_DECL
1725 && !TREE_PUBLIC (olddecl)
1726 && TREE_PUBLIC (newdecl))
1727 warning_with_decl (newdecl, "non-static declaration for `%s' follows static");
1729 /* Warn when const declaration follows a non-const
1730 declaration, but not for functions. */
1731 if (TREE_CODE (olddecl) != FUNCTION_DECL
1732 && !TREE_READONLY (olddecl)
1733 && TREE_READONLY (newdecl))
1734 warning_with_decl (newdecl, "const declaration for `%s' follows non-const");
1735 /* These bits are logically part of the type, for variables.
1736 But not for functions
1737 (where qualifiers are not valid ANSI anyway). */
1738 else if (pedantic && TREE_CODE (olddecl) != FUNCTION_DECL
1739 && (TREE_READONLY (newdecl) != TREE_READONLY (olddecl)
1740 || TREE_THIS_VOLATILE (newdecl) != TREE_THIS_VOLATILE (olddecl)))
1741 pedwarn_with_decl (newdecl, "type qualifiers for `%s' conflict with previous decl");
1745 /* Optionally warn about more than one declaration for the same name. */
1746 if (errmsg == 0 && warn_redundant_decls && DECL_SOURCE_LINE (olddecl) != 0
1747 /* Don't warn about a function declaration
1748 followed by a definition. */
1749 && !(TREE_CODE (newdecl) == FUNCTION_DECL && DECL_INITIAL (newdecl) != 0
1750 && DECL_INITIAL (olddecl) == 0)
1751 /* Don't warn about extern decl followed by (tentative) definition. */
1752 && !(DECL_EXTERNAL (olddecl) && ! DECL_EXTERNAL (newdecl)))
1754 warning_with_decl (newdecl, "redundant redeclaration of `%s' in same scope");
1755 warning_with_decl (olddecl, "previous declaration of `%s'");
1758 /* Copy all the DECL_... slots specified in the new decl
1759 except for any that we copy here from the old type.
1761 Past this point, we don't change OLDTYPE and NEWTYPE
1762 even if we change the types of NEWDECL and OLDDECL. */
1766 /* When copying info to olddecl, we store into write_olddecl
1767 instead. This allows us to avoid modifying olddecl when
1768 different_binding_level is true. */
1769 tree write_olddecl = different_binding_level ? newdecl : olddecl;
1771 /* Merge the data types specified in the two decls. */
1772 if (TREE_CODE (newdecl) != FUNCTION_DECL || !DECL_BUILT_IN (olddecl))
1774 if (different_binding_level)
1776 = build_type_attribute_variant
1778 merge_attributes (TYPE_ATTRIBUTES (newtype),
1779 TYPE_ATTRIBUTES (oldtype)));
1782 = TREE_TYPE (olddecl)
1783 = common_type (newtype, oldtype);
1786 /* Lay the type out, unless already done. */
1787 if (oldtype != TREE_TYPE (newdecl))
1789 if (TREE_TYPE (newdecl) != error_mark_node)
1790 layout_type (TREE_TYPE (newdecl));
1791 if (TREE_CODE (newdecl) != FUNCTION_DECL
1792 && TREE_CODE (newdecl) != TYPE_DECL
1793 && TREE_CODE (newdecl) != CONST_DECL)
1794 layout_decl (newdecl, 0);
1798 /* Since the type is OLDDECL's, make OLDDECL's size go with. */
1799 DECL_SIZE (newdecl) = DECL_SIZE (olddecl);
1800 DECL_SIZE_UNIT (newdecl) = DECL_SIZE_UNIT (olddecl);
1801 DECL_MODE (newdecl) = DECL_MODE (olddecl);
1802 if (TREE_CODE (olddecl) != FUNCTION_DECL)
1803 if (DECL_ALIGN (olddecl) > DECL_ALIGN (newdecl))
1804 DECL_ALIGN (newdecl) = DECL_ALIGN (olddecl);
1807 /* Keep the old rtl since we can safely use it. */
1808 DECL_RTL (newdecl) = DECL_RTL (olddecl);
1810 /* Merge the type qualifiers. */
1811 if (DECL_BUILT_IN_NONANSI (olddecl) && TREE_THIS_VOLATILE (olddecl)
1812 && !TREE_THIS_VOLATILE (newdecl))
1813 TREE_THIS_VOLATILE (write_olddecl) = 0;
1814 if (TREE_READONLY (newdecl))
1815 TREE_READONLY (write_olddecl) = 1;
1816 if (TREE_THIS_VOLATILE (newdecl))
1818 TREE_THIS_VOLATILE (write_olddecl) = 1;
1819 if (TREE_CODE (newdecl) == VAR_DECL)
1820 make_var_volatile (newdecl);
1823 /* Keep source location of definition rather than declaration. */
1824 /* When called with different_binding_level set, keep the old
1825 information so that meaningful diagnostics can be given. */
1826 if (DECL_INITIAL (newdecl) == 0 && DECL_INITIAL (olddecl) != 0
1827 && ! different_binding_level)
1829 DECL_SOURCE_LINE (newdecl) = DECL_SOURCE_LINE (olddecl);
1830 DECL_SOURCE_FILE (newdecl) = DECL_SOURCE_FILE (olddecl);
1833 /* Merge the unused-warning information. */
1834 if (DECL_IN_SYSTEM_HEADER (olddecl))
1835 DECL_IN_SYSTEM_HEADER (newdecl) = 1;
1836 else if (DECL_IN_SYSTEM_HEADER (newdecl))
1837 DECL_IN_SYSTEM_HEADER (write_olddecl) = 1;
1839 /* Merge the initialization information. */
1840 /* When called with different_binding_level set, don't copy over
1841 DECL_INITIAL, so that we don't accidentally change function
1842 declarations into function definitions. */
1843 if (DECL_INITIAL (newdecl) == 0 && ! different_binding_level)
1844 DECL_INITIAL (newdecl) = DECL_INITIAL (olddecl);
1846 /* Merge the section attribute.
1847 We want to issue an error if the sections conflict but that must be
1848 done later in decl_attributes since we are called before attributes
1850 if (DECL_SECTION_NAME (newdecl) == NULL_TREE)
1851 DECL_SECTION_NAME (newdecl) = DECL_SECTION_NAME (olddecl);
1853 /* Copy the assembler name.
1854 Currently, it can only be defined in the prototype. */
1855 DECL_ASSEMBLER_NAME (newdecl) = DECL_ASSEMBLER_NAME (olddecl);
1857 if (TREE_CODE (newdecl) == FUNCTION_DECL)
1859 DECL_STATIC_CONSTRUCTOR(newdecl) |= DECL_STATIC_CONSTRUCTOR(olddecl);
1860 DECL_STATIC_DESTRUCTOR (newdecl) |= DECL_STATIC_DESTRUCTOR (olddecl);
1862 DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (newdecl)
1863 |= DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (olddecl);
1864 DECL_NO_CHECK_MEMORY_USAGE (newdecl)
1865 |= DECL_NO_CHECK_MEMORY_USAGE (olddecl);
1866 DECL_NO_LIMIT_STACK (newdecl)
1867 |= DECL_NO_LIMIT_STACK (olddecl);
1870 /* If cannot merge, then use the new type and qualifiers,
1871 and don't preserve the old rtl. */
1872 else if (! different_binding_level)
1874 TREE_TYPE (olddecl) = TREE_TYPE (newdecl);
1875 TREE_READONLY (olddecl) = TREE_READONLY (newdecl);
1876 TREE_THIS_VOLATILE (olddecl) = TREE_THIS_VOLATILE (newdecl);
1877 TREE_SIDE_EFFECTS (olddecl) = TREE_SIDE_EFFECTS (newdecl);
1880 /* Merge the storage class information. */
1881 DECL_WEAK (newdecl) |= DECL_WEAK (olddecl);
1882 /* For functions, static overrides non-static. */
1883 if (TREE_CODE (newdecl) == FUNCTION_DECL)
1885 TREE_PUBLIC (newdecl) &= TREE_PUBLIC (olddecl);
1886 /* This is since we don't automatically
1887 copy the attributes of NEWDECL into OLDDECL. */
1888 /* No need to worry about different_binding_level here because
1889 then TREE_PUBLIC (newdecl) was true. */
1890 TREE_PUBLIC (olddecl) = TREE_PUBLIC (newdecl);
1891 /* If this clears `static', clear it in the identifier too. */
1892 if (! TREE_PUBLIC (olddecl))
1893 TREE_PUBLIC (DECL_NAME (olddecl)) = 0;
1895 if (DECL_EXTERNAL (newdecl))
1897 TREE_STATIC (newdecl) = TREE_STATIC (olddecl);
1898 DECL_EXTERNAL (newdecl) = DECL_EXTERNAL (olddecl);
1899 /* An extern decl does not override previous storage class. */
1900 TREE_PUBLIC (newdecl) = TREE_PUBLIC (olddecl);
1901 if (! DECL_EXTERNAL (newdecl))
1902 DECL_CONTEXT (newdecl) = DECL_CONTEXT (olddecl);
1906 TREE_STATIC (olddecl) = TREE_STATIC (newdecl);
1907 TREE_PUBLIC (olddecl) = TREE_PUBLIC (newdecl);
1910 /* If either decl says `inline', this fn is inline,
1911 unless its definition was passed already. */
1912 if (DECL_INLINE (newdecl) && DECL_INITIAL (olddecl) == 0)
1913 DECL_INLINE (olddecl) = 1;
1914 DECL_INLINE (newdecl) = DECL_INLINE (olddecl);
1916 if (TREE_CODE (newdecl) == FUNCTION_DECL)
1918 if (DECL_BUILT_IN (olddecl))
1920 /* Get rid of any built-in function if new arg types don't match it
1921 or if we have a function definition. */
1922 if (! types_match || new_is_definition)
1924 if (! different_binding_level)
1926 TREE_TYPE (olddecl) = TREE_TYPE (newdecl);
1927 DECL_BUILT_IN_CLASS (olddecl) = NOT_BUILT_IN;
1932 /* If redeclaring a builtin function, and not a definition,
1933 it stays built in. */
1934 DECL_BUILT_IN_CLASS (newdecl) = DECL_BUILT_IN_CLASS (olddecl);
1935 DECL_FUNCTION_CODE (newdecl) = DECL_FUNCTION_CODE (olddecl);
1938 /* Also preserve various other info from the definition. */
1939 else if (! new_is_definition)
1940 DECL_FRAME_SIZE (newdecl) = DECL_FRAME_SIZE (olddecl);
1941 if (! new_is_definition)
1943 DECL_RESULT (newdecl) = DECL_RESULT (olddecl);
1944 /* When called with different_binding_level set, don't copy over
1945 DECL_INITIAL, so that we don't accidentally change function
1946 declarations into function definitions. */
1947 if (! different_binding_level)
1948 DECL_INITIAL (newdecl) = DECL_INITIAL (olddecl);
1949 DECL_SAVED_INSNS (newdecl) = DECL_SAVED_INSNS (olddecl);
1950 DECL_ARGUMENTS (newdecl) = DECL_ARGUMENTS (olddecl);
1951 if (DECL_INLINE (newdecl))
1952 DECL_ABSTRACT_ORIGIN (newdecl) = DECL_ORIGIN (olddecl);
1955 if (different_binding_level)
1957 /* Don't output a duplicate symbol or debugging information for this
1960 Do not set TREE_ASM_WRITTEN for a FUNCTION_DECL since we may actually
1961 just have two declarations without a definition. VAR_DECLs may need
1962 the same treatment, I'm not sure. */
1963 if (TREE_CODE (newdecl) == FUNCTION_DECL)
1964 DECL_IGNORED_P (newdecl) = 1;
1966 TREE_ASM_WRITTEN (newdecl) = DECL_IGNORED_P (newdecl) = 1;
1970 /* Copy most of the decl-specific fields of NEWDECL into OLDDECL.
1971 But preserve OLDDECL's DECL_UID. */
1973 register unsigned olddecl_uid = DECL_UID (olddecl);
1975 bcopy ((char *) newdecl + sizeof (struct tree_common),
1976 (char *) olddecl + sizeof (struct tree_common),
1977 sizeof (struct tree_decl) - sizeof (struct tree_common));
1978 DECL_UID (olddecl) = olddecl_uid;
1981 /* NEWDECL contains the merged attribute lists.
1982 Update OLDDECL to be the same. */
1983 DECL_MACHINE_ATTRIBUTES (olddecl) = DECL_MACHINE_ATTRIBUTES (newdecl);
1988 /* Record a decl-node X as belonging to the current lexical scope.
1989 Check for errors (such as an incompatible declaration for the same
1990 name already seen in the same scope).
1992 Returns either X or an old decl for the same name.
1993 If an old decl is returned, it may have been smashed
1994 to agree with what X says. */
2001 register tree name = DECL_NAME (x);
2002 register struct binding_level *b = current_binding_level;
2004 DECL_CONTEXT (x) = current_function_decl;
2005 /* A local extern declaration for a function doesn't constitute nesting.
2006 A local auto declaration does, since it's a forward decl
2007 for a nested function coming later. */
2008 if (TREE_CODE (x) == FUNCTION_DECL && DECL_INITIAL (x) == 0
2009 && DECL_EXTERNAL (x))
2010 DECL_CONTEXT (x) = 0;
2012 if (warn_nested_externs && DECL_EXTERNAL (x) && b != global_binding_level
2013 && x != IDENTIFIER_IMPLICIT_DECL (name)
2014 /* Don't print error messages for __FUNCTION__ and __PRETTY_FUNCTION__ */
2015 && !DECL_IN_SYSTEM_HEADER (x))
2016 warning ("nested extern declaration of `%s'", IDENTIFIER_POINTER (name));
2022 int different_binding_level = 0;
2024 t = lookup_name_current_level (name);
2025 /* Don't type check externs here when -traditional. This is so that
2026 code with conflicting declarations inside blocks will get warnings
2027 not errors. X11 for instance depends on this. */
2028 if (! t && DECL_EXTERNAL (x) && TREE_PUBLIC (x) && ! flag_traditional)
2030 t = IDENTIFIER_GLOBAL_VALUE (name);
2031 /* Type decls at global scope don't conflict with externs declared
2032 inside lexical blocks. */
2033 if (t && TREE_CODE (t) == TYPE_DECL)
2035 different_binding_level = 1;
2037 if (t != 0 && t == error_mark_node)
2038 /* error_mark_node is 0 for a while during initialization! */
2041 error_with_decl (x, "`%s' used prior to declaration");
2046 file = DECL_SOURCE_FILE (t);
2047 line = DECL_SOURCE_LINE (t);
2050 /* If this decl is `static' and an implicit decl was seen previously,
2051 warn. But don't complain if -traditional,
2052 since traditional compilers don't complain. */
2053 if (! flag_traditional && TREE_PUBLIC (name)
2054 /* Don't test for DECL_EXTERNAL, because grokdeclarator
2055 sets this for all functions. */
2056 && ! TREE_PUBLIC (x)
2057 && (TREE_CODE (x) == FUNCTION_DECL || b == global_binding_level)
2058 /* We used to warn also for explicit extern followed by static,
2059 but sometimes you need to do it that way. */
2060 && IDENTIFIER_IMPLICIT_DECL (name) != 0)
2062 pedwarn ("`%s' was declared implicitly `extern' and later `static'",
2063 IDENTIFIER_POINTER (name));
2064 pedwarn_with_file_and_line
2065 (DECL_SOURCE_FILE (IDENTIFIER_IMPLICIT_DECL (name)),
2066 DECL_SOURCE_LINE (IDENTIFIER_IMPLICIT_DECL (name)),
2067 "previous declaration of `%s'",
2068 IDENTIFIER_POINTER (name));
2069 TREE_THIS_VOLATILE (name) = 1;
2072 if (t != 0 && duplicate_decls (x, t, different_binding_level))
2074 if (TREE_CODE (t) == PARM_DECL)
2076 /* Don't allow more than one "real" duplicate
2077 of a forward parm decl. */
2078 TREE_ASM_WRITTEN (t) = TREE_ASM_WRITTEN (x);
2084 /* If we are processing a typedef statement, generate a whole new
2085 ..._TYPE node (which will be just an variant of the existing
2086 ..._TYPE node with identical properties) and then install the
2087 TYPE_DECL node generated to represent the typedef name as the
2088 TYPE_NAME of this brand new (duplicate) ..._TYPE node.
2090 The whole point here is to end up with a situation where each
2091 and every ..._TYPE node the compiler creates will be uniquely
2092 associated with AT MOST one node representing a typedef name.
2093 This way, even though the compiler substitutes corresponding
2094 ..._TYPE nodes for TYPE_DECL (i.e. "typedef name") nodes very
2095 early on, later parts of the compiler can always do the reverse
2096 translation and get back the corresponding typedef name. For
2099 typedef struct S MY_TYPE;
2102 Later parts of the compiler might only know that `object' was of
2103 type `struct S' if it were not for code just below. With this
2104 code however, later parts of the compiler see something like:
2106 struct S' == struct S
2107 typedef struct S' MY_TYPE;
2110 And they can then deduce (from the node for type struct S') that
2111 the original object declaration was:
2115 Being able to do this is important for proper support of protoize,
2116 and also for generating precise symbolic debugging information
2117 which takes full account of the programmer's (typedef) vocabulary.
2119 Obviously, we don't want to generate a duplicate ..._TYPE node if
2120 the TYPE_DECL node that we are now processing really represents a
2121 standard built-in type.
2123 Since all standard types are effectively declared at line zero
2124 in the source file, we can easily check to see if we are working
2125 on a standard type by checking the current value of lineno. */
2127 if (TREE_CODE (x) == TYPE_DECL)
2129 if (DECL_SOURCE_LINE (x) == 0)
2131 if (TYPE_NAME (TREE_TYPE (x)) == 0)
2132 TYPE_NAME (TREE_TYPE (x)) = x;
2134 else if (TREE_TYPE (x) != error_mark_node
2135 && DECL_ORIGINAL_TYPE (x) == NULL_TREE)
2137 tree tt = TREE_TYPE (x);
2138 DECL_ORIGINAL_TYPE (x) = tt;
2139 tt = build_type_copy (tt);
2145 /* Multiple external decls of the same identifier ought to match.
2146 Check against both global declarations (when traditional) and out of
2147 scope (limbo) block level declarations.
2149 We get warnings about inline functions where they are defined.
2150 Avoid duplicate warnings where they are used. */
2151 if (TREE_PUBLIC (x) && ! DECL_INLINE (x))
2155 if (flag_traditional && IDENTIFIER_GLOBAL_VALUE (name) != 0
2156 && (DECL_EXTERNAL (IDENTIFIER_GLOBAL_VALUE (name))
2157 || TREE_PUBLIC (IDENTIFIER_GLOBAL_VALUE (name))))
2158 decl = IDENTIFIER_GLOBAL_VALUE (name);
2159 else if (IDENTIFIER_LIMBO_VALUE (name) != 0)
2160 /* Decls in limbo are always extern, so no need to check that. */
2161 decl = IDENTIFIER_LIMBO_VALUE (name);
2165 if (decl && ! comptypes (TREE_TYPE (x), TREE_TYPE (decl))
2166 /* If old decl is built-in, we already warned if we should. */
2167 && !DECL_BUILT_IN (decl))
2169 pedwarn_with_decl (x,
2170 "type mismatch with previous external decl");
2171 pedwarn_with_decl (decl, "previous external decl of `%s'");
2175 /* If a function has had an implicit declaration, and then is defined,
2176 make sure they are compatible. */
2178 if (IDENTIFIER_IMPLICIT_DECL (name) != 0
2179 && IDENTIFIER_GLOBAL_VALUE (name) == 0
2180 && TREE_CODE (x) == FUNCTION_DECL
2181 && ! comptypes (TREE_TYPE (x),
2182 TREE_TYPE (IDENTIFIER_IMPLICIT_DECL (name))))
2184 warning_with_decl (x, "type mismatch with previous implicit declaration");
2185 warning_with_decl (IDENTIFIER_IMPLICIT_DECL (name),
2186 "previous implicit declaration of `%s'");
2189 /* In PCC-compatibility mode, extern decls of vars with no current decl
2190 take effect at top level no matter where they are. */
2191 if (flag_traditional && DECL_EXTERNAL (x)
2192 && lookup_name (name) == 0)
2194 tree type = TREE_TYPE (x);
2196 /* But don't do this if the type contains temporary nodes. */
2199 if (type == error_mark_node)
2201 if (! TYPE_CONTEXT (type))
2203 warning_with_decl (x, "type of external `%s' is not global");
2204 /* By exiting the loop early, we leave TYPE nonzero,
2205 and thus prevent globalization of the decl. */
2208 else if (TREE_CODE (type) == FUNCTION_TYPE
2209 && TYPE_ARG_TYPES (type) != 0)
2210 /* The types might not be truly local,
2211 but the list of arg types certainly is temporary.
2212 Since prototypes are nontraditional,
2213 ok not to do the traditional thing. */
2215 type = TREE_TYPE (type);
2219 b = global_binding_level;
2222 /* This name is new in its binding level.
2223 Install the new declaration and return it. */
2224 if (b == global_binding_level)
2226 /* Install a global value. */
2228 /* If the first global decl has external linkage,
2229 warn if we later see static one. */
2230 if (IDENTIFIER_GLOBAL_VALUE (name) == 0 && TREE_PUBLIC (x))
2231 TREE_PUBLIC (name) = 1;
2233 IDENTIFIER_GLOBAL_VALUE (name) = x;
2235 /* We no longer care about any previous block level declarations. */
2236 IDENTIFIER_LIMBO_VALUE (name) = 0;
2238 /* Don't forget if the function was used via an implicit decl. */
2239 if (IDENTIFIER_IMPLICIT_DECL (name)
2240 && TREE_USED (IDENTIFIER_IMPLICIT_DECL (name)))
2241 TREE_USED (x) = 1, TREE_USED (name) = 1;
2243 /* Don't forget if its address was taken in that way. */
2244 if (IDENTIFIER_IMPLICIT_DECL (name)
2245 && TREE_ADDRESSABLE (IDENTIFIER_IMPLICIT_DECL (name)))
2246 TREE_ADDRESSABLE (x) = 1;
2248 /* Warn about mismatches against previous implicit decl. */
2249 if (IDENTIFIER_IMPLICIT_DECL (name) != 0
2250 /* If this real decl matches the implicit, don't complain. */
2251 && ! (TREE_CODE (x) == FUNCTION_DECL
2252 && (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (x)))
2253 == integer_type_node)))
2254 pedwarn ("`%s' was previously implicitly declared to return `int'",
2255 IDENTIFIER_POINTER (name));
2257 /* If this decl is `static' and an `extern' was seen previously,
2258 that is erroneous. */
2259 if (TREE_PUBLIC (name)
2260 && ! TREE_PUBLIC (x) && ! DECL_EXTERNAL (x))
2262 /* Okay to redeclare an ANSI built-in as static. */
2263 if (t != 0 && DECL_BUILT_IN (t))
2265 /* Okay to declare a non-ANSI built-in as anything. */
2266 else if (t != 0 && DECL_BUILT_IN_NONANSI (t))
2268 /* Okay to have global type decl after an earlier extern
2269 declaration inside a lexical block. */
2270 else if (TREE_CODE (x) == TYPE_DECL)
2272 else if (IDENTIFIER_IMPLICIT_DECL (name))
2274 if (! TREE_THIS_VOLATILE (name))
2275 pedwarn ("`%s' was declared implicitly `extern' and later `static'",
2276 IDENTIFIER_POINTER (name));
2279 pedwarn ("`%s' was declared `extern' and later `static'",
2280 IDENTIFIER_POINTER (name));
2285 /* Here to install a non-global value. */
2286 tree oldlocal = IDENTIFIER_LOCAL_VALUE (name);
2287 tree oldglobal = IDENTIFIER_GLOBAL_VALUE (name);
2288 IDENTIFIER_LOCAL_VALUE (name) = x;
2290 /* If this is an extern function declaration, see if we
2291 have a global definition or declaration for the function. */
2293 && DECL_EXTERNAL (x) && !DECL_INLINE (x)
2295 && TREE_CODE (x) == FUNCTION_DECL
2296 && TREE_CODE (oldglobal) == FUNCTION_DECL)
2298 /* We have one. Their types must agree. */
2299 if (! comptypes (TREE_TYPE (x),
2300 TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (name))))
2301 pedwarn_with_decl (x, "extern declaration of `%s' doesn't match global one");
2304 /* Inner extern decl is inline if global one is.
2305 Copy enough to really inline it. */
2306 if (DECL_INLINE (oldglobal))
2308 DECL_INLINE (x) = DECL_INLINE (oldglobal);
2309 DECL_INITIAL (x) = (current_function_decl == oldglobal
2310 ? 0 : DECL_INITIAL (oldglobal));
2311 DECL_SAVED_INSNS (x) = DECL_SAVED_INSNS (oldglobal);
2312 DECL_FRAME_SIZE (x) = DECL_FRAME_SIZE (oldglobal);
2313 DECL_ARGUMENTS (x) = DECL_ARGUMENTS (oldglobal);
2314 DECL_RESULT (x) = DECL_RESULT (oldglobal);
2315 TREE_ASM_WRITTEN (x) = TREE_ASM_WRITTEN (oldglobal);
2316 DECL_ABSTRACT_ORIGIN (x) = DECL_ORIGIN (oldglobal);
2318 /* Inner extern decl is built-in if global one is. */
2319 if (DECL_BUILT_IN (oldglobal))
2321 DECL_BUILT_IN_CLASS (x) = DECL_BUILT_IN_CLASS (oldglobal);
2322 DECL_FUNCTION_CODE (x) = DECL_FUNCTION_CODE (oldglobal);
2324 /* Keep the arg types from a file-scope fcn defn. */
2325 if (TYPE_ARG_TYPES (TREE_TYPE (oldglobal)) != 0
2326 && DECL_INITIAL (oldglobal)
2327 && TYPE_ARG_TYPES (TREE_TYPE (x)) == 0)
2328 TREE_TYPE (x) = TREE_TYPE (oldglobal);
2332 #if 0 /* This case is probably sometimes the right thing to do. */
2333 /* If we have a local external declaration,
2334 then any file-scope declaration should not
2335 have been static. */
2336 if (oldlocal == 0 && oldglobal != 0
2337 && !TREE_PUBLIC (oldglobal)
2338 && DECL_EXTERNAL (x) && TREE_PUBLIC (x))
2339 warning ("`%s' locally external but globally static",
2340 IDENTIFIER_POINTER (name));
2343 /* If we have a local external declaration,
2344 and no file-scope declaration has yet been seen,
2345 then if we later have a file-scope decl it must not be static. */
2347 && DECL_EXTERNAL (x)
2351 TREE_PUBLIC (name) = 1;
2353 /* Save this decl, so that we can do type checking against
2354 other decls after it falls out of scope.
2356 Only save it once. This prevents temporary decls created in
2357 expand_inline_function from being used here, since this
2358 will have been set when the inline function was parsed.
2359 It also helps give slightly better warnings. */
2360 if (IDENTIFIER_LIMBO_VALUE (name) == 0)
2361 IDENTIFIER_LIMBO_VALUE (name) = x;
2364 /* Warn if shadowing an argument at the top level of the body. */
2365 if (oldlocal != 0 && !DECL_EXTERNAL (x)
2366 /* This warning doesn't apply to the parms of a nested fcn. */
2367 && ! current_binding_level->parm_flag
2368 /* Check that this is one level down from the parms. */
2369 && current_binding_level->level_chain->parm_flag
2370 /* Check that the decl being shadowed
2371 comes from the parm level, one level up. */
2372 && chain_member (oldlocal, current_binding_level->level_chain->names))
2374 if (TREE_CODE (oldlocal) == PARM_DECL)
2375 pedwarn ("declaration of `%s' shadows a parameter",
2376 IDENTIFIER_POINTER (name));
2378 pedwarn ("declaration of `%s' shadows a symbol from the parameter list",
2379 IDENTIFIER_POINTER (name));
2382 /* Maybe warn if shadowing something else. */
2383 else if (warn_shadow && !DECL_EXTERNAL (x)
2384 /* No shadow warnings for internally generated vars. */
2385 && DECL_SOURCE_LINE (x) != 0
2386 /* No shadow warnings for vars made for inlining. */
2387 && ! DECL_FROM_INLINE (x))
2389 char *id = IDENTIFIER_POINTER (name);
2391 if (TREE_CODE (x) == PARM_DECL
2392 && current_binding_level->level_chain->parm_flag)
2393 /* Don't warn about the parm names in function declarator
2394 within a function declarator.
2395 It would be nice to avoid warning in any function
2396 declarator in a declaration, as opposed to a definition,
2397 but there is no way to tell it's not a definition. */
2399 else if (oldlocal != 0 && TREE_CODE (oldlocal) == PARM_DECL)
2400 warning ("declaration of `%s' shadows a parameter", id);
2401 else if (oldlocal != 0)
2402 warning ("declaration of `%s' shadows previous local", id);
2403 else if (IDENTIFIER_GLOBAL_VALUE (name) != 0
2404 && IDENTIFIER_GLOBAL_VALUE (name) != error_mark_node)
2405 warning ("declaration of `%s' shadows global declaration", id);
2408 /* If storing a local value, there may already be one (inherited).
2409 If so, record it for restoration when this binding level ends. */
2411 b->shadowed = tree_cons (name, oldlocal, b->shadowed);
2414 /* Keep count of variables in this level with incomplete type. */
2415 if (TYPE_SIZE (TREE_TYPE (x)) == 0)
2419 /* Put decls on list in reverse order.
2420 We will reverse them later if necessary. */
2421 TREE_CHAIN (x) = b->names;
2427 /* Like pushdecl, only it places X in GLOBAL_BINDING_LEVEL, if appropriate. */
2430 pushdecl_top_level (x)
2434 register struct binding_level *b = current_binding_level;
2436 current_binding_level = global_binding_level;
2438 current_binding_level = b;
2442 /* Generate an implicit declaration for identifier FUNCTIONID
2443 as a function of type int (). Print a warning if appropriate. */
2446 implicitly_declare (functionid)
2450 int traditional_warning = 0;
2451 /* Only one "implicit declaration" warning per identifier. */
2452 int implicit_warning;
2454 /* We used to reuse an old implicit decl here,
2455 but this loses with inline functions because it can clobber
2456 the saved decl chains. */
2457 /* if (IDENTIFIER_IMPLICIT_DECL (functionid) != 0)
2458 decl = IDENTIFIER_IMPLICIT_DECL (functionid);
2460 decl = build_decl (FUNCTION_DECL, functionid, default_function_type);
2462 /* Warn of implicit decl following explicit local extern decl.
2463 This is probably a program designed for traditional C. */
2464 if (TREE_PUBLIC (functionid) && IDENTIFIER_GLOBAL_VALUE (functionid) == 0)
2465 traditional_warning = 1;
2467 /* Warn once of an implicit declaration. */
2468 implicit_warning = (IDENTIFIER_IMPLICIT_DECL (functionid) == 0);
2470 DECL_EXTERNAL (decl) = 1;
2471 TREE_PUBLIC (decl) = 1;
2473 /* Record that we have an implicit decl and this is it. */
2474 IDENTIFIER_IMPLICIT_DECL (functionid) = decl;
2476 /* ANSI standard says implicit declarations are in the innermost block.
2477 So we record the decl in the standard fashion.
2478 If flag_traditional is set, pushdecl does it top-level. */
2481 /* This is a no-op in c-lang.c or something real in objc-actions.c. */
2482 maybe_objc_check_decl (decl);
2484 rest_of_decl_compilation (decl, NULL_PTR, 0, 0);
2486 if (mesg_implicit_function_declaration && implicit_warning)
2488 if (mesg_implicit_function_declaration == 2)
2489 error ("implicit declaration of function `%s'",
2490 IDENTIFIER_POINTER (functionid));
2492 warning ("implicit declaration of function `%s'",
2493 IDENTIFIER_POINTER (functionid));
2495 else if (warn_traditional && traditional_warning)
2496 warning ("function `%s' was previously declared within a block",
2497 IDENTIFIER_POINTER (functionid));
2499 /* Write a record describing this implicit function declaration to the
2500 prototypes file (if requested). */
2502 gen_aux_info_record (decl, 0, 1, 0);
2507 /* Return zero if the declaration NEWDECL is valid
2508 when the declaration OLDDECL (assumed to be for the same name)
2509 has already been seen.
2510 Otherwise return 1 if NEWDECL is a redefinition, 2 if it is a redeclaration,
2511 and 3 if it is a conflicting declaration. */
2514 redeclaration_error_message (newdecl, olddecl)
2515 tree newdecl, olddecl;
2517 if (TREE_CODE (newdecl) == TYPE_DECL)
2519 if (flag_traditional && TREE_TYPE (newdecl) == TREE_TYPE (olddecl))
2521 /* pushdecl creates distinct types for TYPE_DECLs by calling
2522 build_type_copy, so the above comparison generally fails. We do
2523 another test against the TYPE_MAIN_VARIANT of the olddecl, which
2524 is equivalent to what this code used to do before the build_type_copy
2525 call. The variant type distinction should not matter for traditional
2526 code, because it doesn't have type qualifiers. */
2527 if (flag_traditional
2528 && TYPE_MAIN_VARIANT (TREE_TYPE (olddecl)) == TREE_TYPE (newdecl))
2530 if (DECL_IN_SYSTEM_HEADER (olddecl) || DECL_IN_SYSTEM_HEADER (newdecl))
2534 else if (TREE_CODE (newdecl) == FUNCTION_DECL)
2536 /* Declarations of functions can insist on internal linkage
2537 but they can't be inconsistent with internal linkage,
2538 so there can be no error on that account.
2539 However defining the same name twice is no good. */
2540 if (DECL_INITIAL (olddecl) != 0 && DECL_INITIAL (newdecl) != 0
2541 /* However, defining once as extern inline and a second
2542 time in another way is ok. */
2543 && !(DECL_INLINE (olddecl) && DECL_EXTERNAL (olddecl)
2544 && !(DECL_INLINE (newdecl) && DECL_EXTERNAL (newdecl))))
2548 else if (current_binding_level == global_binding_level)
2550 /* Objects declared at top level: */
2551 /* If at least one is a reference, it's ok. */
2552 if (DECL_EXTERNAL (newdecl) || DECL_EXTERNAL (olddecl))
2554 /* Reject two definitions. */
2555 if (DECL_INITIAL (olddecl) != 0 && DECL_INITIAL (newdecl) != 0)
2557 /* Now we have two tentative defs, or one tentative and one real def. */
2558 /* Insist that the linkage match. */
2559 if (TREE_PUBLIC (olddecl) != TREE_PUBLIC (newdecl))
2563 else if (current_binding_level->parm_flag
2564 && TREE_ASM_WRITTEN (olddecl) && !TREE_ASM_WRITTEN (newdecl))
2568 /* Newdecl has block scope. If olddecl has block scope also, then
2569 reject two definitions, and reject a definition together with an
2570 external reference. Otherwise, it is OK, because newdecl must
2571 be an extern reference to olddecl. */
2572 if (!(DECL_EXTERNAL (newdecl) && DECL_EXTERNAL (olddecl))
2573 && DECL_CONTEXT (newdecl) == DECL_CONTEXT (olddecl))
2579 /* Get the LABEL_DECL corresponding to identifier ID as a label.
2580 Create one if none exists so far for the current function.
2581 This function is called for both label definitions and label references. */
2587 register tree decl = IDENTIFIER_LABEL_VALUE (id);
2589 if (current_function_decl == 0)
2591 error ("label %s referenced outside of any function",
2592 IDENTIFIER_POINTER (id));
2596 /* Use a label already defined or ref'd with this name. */
2599 /* But not if it is inherited and wasn't declared to be inheritable. */
2600 if (DECL_CONTEXT (decl) != current_function_decl
2601 && ! C_DECLARED_LABEL_FLAG (decl))
2602 return shadow_label (id);
2606 decl = build_decl (LABEL_DECL, id, void_type_node);
2608 /* Make sure every label has an rtx. */
2611 /* A label not explicitly declared must be local to where it's ref'd. */
2612 DECL_CONTEXT (decl) = current_function_decl;
2614 DECL_MODE (decl) = VOIDmode;
2616 /* Say where one reference is to the label,
2617 for the sake of the error if it is not defined. */
2618 DECL_SOURCE_LINE (decl) = lineno;
2619 DECL_SOURCE_FILE (decl) = input_filename;
2621 IDENTIFIER_LABEL_VALUE (id) = decl;
2623 named_labels = tree_cons (NULL_TREE, decl, named_labels);
2628 /* Make a label named NAME in the current function,
2629 shadowing silently any that may be inherited from containing functions
2630 or containing scopes.
2632 Note that valid use, if the label being shadowed
2633 comes from another scope in the same function,
2634 requires calling declare_nonlocal_label right away. */
2640 register tree decl = IDENTIFIER_LABEL_VALUE (name);
2646 /* Check to make sure that the label hasn't already been declared
2647 at this label scope */
2648 for (dup = named_labels; dup; dup = TREE_CHAIN (dup))
2649 if (TREE_VALUE (dup) == decl)
2651 error ("duplicate label declaration `%s'",
2652 IDENTIFIER_POINTER (name));
2653 error_with_decl (TREE_VALUE (dup),
2654 "this is a previous declaration");
2655 /* Just use the previous declaration. */
2656 return lookup_label (name);
2659 shadowed_labels = tree_cons (NULL_TREE, decl, shadowed_labels);
2660 IDENTIFIER_LABEL_VALUE (name) = decl = 0;
2663 return lookup_label (name);
2666 /* Define a label, specifying the location in the source file.
2667 Return the LABEL_DECL node for the label, if the definition is valid.
2668 Otherwise return 0. */
2671 define_label (filename, line, name)
2676 tree decl = lookup_label (name);
2678 /* If label with this name is known from an outer context, shadow it. */
2679 if (decl != 0 && DECL_CONTEXT (decl) != current_function_decl)
2681 shadowed_labels = tree_cons (NULL_TREE, decl, shadowed_labels);
2682 IDENTIFIER_LABEL_VALUE (name) = 0;
2683 decl = lookup_label (name);
2686 if (DECL_INITIAL (decl) != 0)
2688 error ("duplicate label `%s'", IDENTIFIER_POINTER (name));
2693 /* Mark label as having been defined. */
2694 DECL_INITIAL (decl) = error_mark_node;
2695 /* Say where in the source. */
2696 DECL_SOURCE_FILE (decl) = filename;
2697 DECL_SOURCE_LINE (decl) = line;
2702 /* Return the list of declarations of the current level.
2703 Note that this list is in reverse order unless/until
2704 you nreverse it; and when you do nreverse it, you must
2705 store the result back using `storedecls' or you will lose. */
2710 return current_binding_level->names;
2713 /* Return the list of type-tags (for structs, etc) of the current level. */
2718 return current_binding_level->tags;
2721 /* Store the list of declarations of the current level.
2722 This is done for the parameter declarations of a function being defined,
2723 after they are modified in the light of any missing parameters. */
2729 current_binding_level->names = decls;
2732 /* Similarly, store the list of tags of the current level. */
2738 current_binding_level->tags = tags;
2741 /* Given NAME, an IDENTIFIER_NODE,
2742 return the structure (or union or enum) definition for that name.
2743 Searches binding levels from BINDING_LEVEL up to the global level.
2744 If THISLEVEL_ONLY is nonzero, searches only the specified context
2745 (but skips any tag-transparent contexts to find one that is
2746 meaningful for tags).
2747 CODE says which kind of type the caller wants;
2748 it is RECORD_TYPE or UNION_TYPE or ENUMERAL_TYPE.
2749 If the wrong kind of type is found, an error is reported. */
2752 lookup_tag (code, name, binding_level, thislevel_only)
2753 enum tree_code code;
2754 struct binding_level *binding_level;
2758 register struct binding_level *level;
2760 for (level = binding_level; level; level = level->level_chain)
2763 for (tail = level->tags; tail; tail = TREE_CHAIN (tail))
2765 if (TREE_PURPOSE (tail) == name)
2767 if (TREE_CODE (TREE_VALUE (tail)) != code)
2769 /* Definition isn't the kind we were looking for. */
2770 pending_invalid_xref = name;
2771 pending_invalid_xref_file = input_filename;
2772 pending_invalid_xref_line = lineno;
2774 return TREE_VALUE (tail);
2777 if (thislevel_only && ! level->tag_transparent)
2783 /* Print an error message now
2784 for a recent invalid struct, union or enum cross reference.
2785 We don't print them immediately because they are not invalid
2786 when used in the `struct foo;' construct for shadowing. */
2789 pending_xref_error ()
2791 if (pending_invalid_xref != 0)
2792 error_with_file_and_line (pending_invalid_xref_file,
2793 pending_invalid_xref_line,
2794 "`%s' defined as wrong kind of tag",
2795 IDENTIFIER_POINTER (pending_invalid_xref));
2796 pending_invalid_xref = 0;
2799 /* Given a type, find the tag that was defined for it and return the tag name.
2800 Otherwise return 0. */
2803 lookup_tag_reverse (type)
2806 register struct binding_level *level;
2808 for (level = current_binding_level; level; level = level->level_chain)
2811 for (tail = level->tags; tail; tail = TREE_CHAIN (tail))
2813 if (TREE_VALUE (tail) == type)
2814 return TREE_PURPOSE (tail);
2820 /* Look up NAME in the current binding level and its superiors
2821 in the namespace of variables, functions and typedefs.
2822 Return a ..._DECL node of some kind representing its definition,
2823 or return 0 if it is undefined. */
2830 if (current_binding_level != global_binding_level
2831 && IDENTIFIER_LOCAL_VALUE (name))
2832 val = IDENTIFIER_LOCAL_VALUE (name);
2834 val = IDENTIFIER_GLOBAL_VALUE (name);
2838 /* Similar to `lookup_name' but look only at current binding level. */
2841 lookup_name_current_level (name)
2846 if (current_binding_level == global_binding_level)
2847 return IDENTIFIER_GLOBAL_VALUE (name);
2849 if (IDENTIFIER_LOCAL_VALUE (name) == 0)
2852 for (t = current_binding_level->names; t; t = TREE_CHAIN (t))
2853 if (DECL_NAME (t) == name)
2859 /* Mark ARG for GC. */
2861 mark_binding_level (arg)
2864 struct binding_level *level = *(struct binding_level **) arg;
2868 ggc_mark_tree (level->names);
2869 ggc_mark_tree (level->tags);
2870 ggc_mark_tree (level->shadowed);
2871 ggc_mark_tree (level->blocks);
2872 ggc_mark_tree (level->this_block);
2873 ggc_mark_tree (level->parm_order);
2874 level = level->level_chain;
2878 /* Create the predefined scalar types of C,
2879 and some nodes representing standard constants (0, 1, (void *) 0).
2880 Initialize the global binding level.
2881 Make definitions for built-in primitive functions. */
2884 init_decl_processing ()
2886 register tree endlink;
2887 tree ptr_ftype_void, ptr_ftype_ptr;
2888 int wchar_type_size;
2889 tree array_domain_type;
2891 current_function_decl = NULL;
2892 named_labels = NULL;
2893 current_binding_level = NULL_BINDING_LEVEL;
2894 free_binding_level = NULL_BINDING_LEVEL;
2895 pushlevel (0); /* make the binding_level structure for global names */
2896 global_binding_level = current_binding_level;
2898 build_common_tree_nodes (flag_signed_char);
2900 /* Define `int' and `char' first so that dbx will output them first. */
2901 pushdecl (build_decl (TYPE_DECL, ridpointers[(int) RID_INT],
2902 integer_type_node));
2903 pushdecl (build_decl (TYPE_DECL, get_identifier ("char"),
2905 pushdecl (build_decl (TYPE_DECL, get_identifier ("long int"),
2906 long_integer_type_node));
2907 pushdecl (build_decl (TYPE_DECL, get_identifier ("unsigned int"),
2908 unsigned_type_node));
2909 pushdecl (build_decl (TYPE_DECL, get_identifier ("long unsigned int"),
2910 long_unsigned_type_node));
2911 pushdecl (build_decl (TYPE_DECL, get_identifier ("long long int"),
2912 long_long_integer_type_node));
2913 pushdecl (build_decl (TYPE_DECL, get_identifier ("long long unsigned int"),
2914 long_long_unsigned_type_node));
2915 pushdecl (build_decl (TYPE_DECL, get_identifier ("short int"),
2916 short_integer_type_node));
2917 pushdecl (build_decl (TYPE_DECL, get_identifier ("short unsigned int"),
2918 short_unsigned_type_node));
2919 pushdecl (build_decl (TYPE_DECL, get_identifier ("signed char"),
2920 signed_char_type_node));
2921 pushdecl (build_decl (TYPE_DECL, get_identifier ("unsigned char"),
2922 unsigned_char_type_node));
2923 pushdecl (build_decl (TYPE_DECL, NULL_TREE, intQI_type_node));
2924 pushdecl (build_decl (TYPE_DECL, NULL_TREE, intHI_type_node));
2925 pushdecl (build_decl (TYPE_DECL, NULL_TREE, intSI_type_node));
2926 pushdecl (build_decl (TYPE_DECL, NULL_TREE, intDI_type_node));
2927 #if HOST_BITS_PER_WIDE_INT >= 64
2928 pushdecl (build_decl (TYPE_DECL, NULL_TREE, intTI_type_node));
2930 pushdecl (build_decl (TYPE_DECL, NULL_TREE, unsigned_intQI_type_node));
2931 pushdecl (build_decl (TYPE_DECL, NULL_TREE, unsigned_intHI_type_node));
2932 pushdecl (build_decl (TYPE_DECL, NULL_TREE, unsigned_intSI_type_node));
2933 pushdecl (build_decl (TYPE_DECL, NULL_TREE, unsigned_intDI_type_node));
2934 #if HOST_BITS_PER_WIDE_INT >= 64
2935 pushdecl (build_decl (TYPE_DECL, NULL_TREE, unsigned_intTI_type_node));
2938 /* `unsigned long' is the standard type for sizeof.
2939 Traditionally, use a signed type.
2940 Note that stddef.h uses `unsigned long',
2941 and this must agree, even if long and int are the same size. */
2943 (TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (get_identifier (SIZE_TYPE))));
2944 if (flag_traditional && TREE_UNSIGNED (sizetype))
2945 set_sizetype (signed_type (sizetype));
2947 /* Create the widest literal types. */
2948 widest_integer_literal_type_node = make_signed_type (HOST_BITS_PER_WIDE_INT * 2);
2949 widest_unsigned_literal_type_node = make_unsigned_type (HOST_BITS_PER_WIDE_INT * 2);
2950 pushdecl (build_decl (TYPE_DECL, NULL_TREE,
2951 widest_integer_literal_type_node));
2952 pushdecl (build_decl (TYPE_DECL, NULL_TREE,
2953 widest_unsigned_literal_type_node));
2955 build_common_tree_nodes_2 (flag_short_double);
2957 pushdecl (build_decl (TYPE_DECL, ridpointers[(int) RID_FLOAT],
2959 pushdecl (build_decl (TYPE_DECL, ridpointers[(int) RID_DOUBLE],
2961 pushdecl (build_decl (TYPE_DECL, get_identifier ("long double"),
2962 long_double_type_node));
2963 pushdecl (build_decl (TYPE_DECL, get_identifier ("complex int"),
2964 complex_integer_type_node));
2965 pushdecl (build_decl (TYPE_DECL, get_identifier ("complex float"),
2966 complex_float_type_node));
2967 pushdecl (build_decl (TYPE_DECL, get_identifier ("complex double"),
2968 complex_double_type_node));
2969 pushdecl (build_decl (TYPE_DECL, get_identifier ("complex long double"),
2970 complex_long_double_type_node));
2971 pushdecl (build_decl (TYPE_DECL,
2972 ridpointers[(int) RID_VOID], void_type_node));
2974 #ifdef MD_INIT_BUILTINS
2978 wchar_type_node = get_identifier (flag_short_wchar
2979 ? "short unsigned int"
2981 wchar_type_node = TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (wchar_type_node));
2982 wchar_type_size = TYPE_PRECISION (wchar_type_node);
2983 signed_wchar_type_node = signed_type (wchar_type_node);
2984 unsigned_wchar_type_node = unsigned_type (wchar_type_node);
2986 boolean_type_node = integer_type_node;
2987 boolean_true_node = integer_one_node;
2988 boolean_false_node = integer_zero_node;
2990 string_type_node = build_pointer_type (char_type_node);
2991 const_string_type_node
2992 = build_pointer_type (build_type_variant (char_type_node, 1, 0));
2994 /* Make a type to be the domain of a few array types
2995 whose domains don't really matter.
2996 200 is small enough that it always fits in size_t
2997 and large enough that it can hold most function names for the
2998 initializations of __FUNCTION__ and __PRETTY_FUNCTION__. */
2999 array_domain_type = build_index_type (build_int_2 (200, 0));
3001 /* make a type for arrays of characters.
3002 With luck nothing will ever really depend on the length of this
3004 char_array_type_node
3005 = build_array_type (char_type_node, array_domain_type);
3006 /* Likewise for arrays of ints. */
3008 = build_array_type (integer_type_node, array_domain_type);
3009 /* This is for wide string constants. */
3010 wchar_array_type_node
3011 = build_array_type (wchar_type_node, array_domain_type);
3013 void_list_node = tree_cons (NULL_TREE, void_type_node, NULL_TREE);
3015 default_function_type
3016 = build_function_type (integer_type_node, NULL_TREE);
3018 = TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (get_identifier (PTRDIFF_TYPE)));
3020 c_common_nodes_and_builtins (0, flag_no_builtin, flag_no_nonansi_builtin);
3022 endlink = void_list_node;
3023 ptr_ftype_void = build_function_type (ptr_type_node, endlink);
3025 = build_function_type (ptr_type_node,
3026 tree_cons (NULL_TREE, ptr_type_node, endlink));
3028 builtin_function ("__builtin_aggregate_incoming_address",
3029 build_function_type (ptr_type_node, NULL_TREE),
3030 BUILT_IN_AGGREGATE_INCOMING_ADDRESS,
3031 BUILT_IN_NORMAL, NULL_PTR);
3033 /* Hooks for the DWARF 2 __throw routine. */
3034 builtin_function ("__builtin_unwind_init",
3035 build_function_type (void_type_node, endlink),
3036 BUILT_IN_UNWIND_INIT, BUILT_IN_NORMAL, NULL_PTR);
3037 builtin_function ("__builtin_dwarf_cfa", ptr_ftype_void,
3038 BUILT_IN_DWARF_CFA, BUILT_IN_NORMAL, NULL_PTR);
3039 builtin_function ("__builtin_dwarf_fp_regnum",
3040 build_function_type (unsigned_type_node, endlink),
3041 BUILT_IN_DWARF_FP_REGNUM, BUILT_IN_NORMAL, NULL_PTR);
3042 builtin_function ("__builtin_init_dwarf_reg_size_table", void_ftype_ptr,
3043 BUILT_IN_INIT_DWARF_REG_SIZES, BUILT_IN_NORMAL, NULL_PTR);
3044 builtin_function ("__builtin_frob_return_addr", ptr_ftype_ptr,
3045 BUILT_IN_FROB_RETURN_ADDR, BUILT_IN_NORMAL, NULL_PTR);
3046 builtin_function ("__builtin_extract_return_addr", ptr_ftype_ptr,
3047 BUILT_IN_EXTRACT_RETURN_ADDR, BUILT_IN_NORMAL, NULL_PTR);
3049 ("__builtin_eh_return",
3050 build_function_type (void_type_node,
3051 tree_cons (NULL_TREE, ptr_type_node,
3052 tree_cons (NULL_TREE,
3053 type_for_mode (ptr_mode, 0),
3054 tree_cons (NULL_TREE,
3057 BUILT_IN_EH_RETURN, BUILT_IN_NORMAL, NULL_PTR);
3059 pedantic_lvalues = pedantic;
3061 /* Create the global bindings for __FUNCTION__ and __PRETTY_FUNCTION__. */
3062 declare_function_name ();
3064 start_identifier_warnings ();
3066 /* Prepare to check format strings against argument lists. */
3067 init_function_format_info ();
3071 incomplete_decl_finalize_hook = finish_incomplete_decl;
3073 lang_get_alias_set = c_get_alias_set;
3075 /* Record our roots. */
3077 ggc_add_tree_root (c_global_trees, CTI_MAX);
3078 ggc_add_tree_root (¤t_function_decl, 1);
3079 ggc_add_tree_root (&named_labels, 1);
3080 ggc_add_tree_root (&shadowed_labels, 1);
3081 ggc_add_root (¤t_binding_level, 1, sizeof current_binding_level,
3082 mark_binding_level);
3083 ggc_add_root (&label_level_chain, 1, sizeof label_level_chain,
3084 mark_binding_level);
3085 ggc_add_tree_root (&static_ctors, 1);
3086 ggc_add_tree_root (&static_dtors, 1);
3089 /* Return a definition for a builtin function named NAME and whose data type
3090 is TYPE. TYPE should be a function type with argument types.
3091 FUNCTION_CODE tells later passes how to compile calls to this function.
3092 See tree.h for its possible values.
3094 If LIBRARY_NAME is nonzero, use that for DECL_ASSEMBLER_NAME,
3095 the name to be called if we can't opencode the function. */
3098 builtin_function (name, type, function_code, class, library_name)
3102 enum built_in_class class;
3103 const char *library_name;
3105 tree decl = build_decl (FUNCTION_DECL, get_identifier (name), type);
3106 DECL_EXTERNAL (decl) = 1;
3107 TREE_PUBLIC (decl) = 1;
3108 /* If -traditional, permit redefining a builtin function any way you like.
3109 (Though really, if the program redefines these functions,
3110 it probably won't work right unless compiled with -fno-builtin.) */
3111 if (flag_traditional && name[0] != '_')
3112 DECL_BUILT_IN_NONANSI (decl) = 1;
3114 DECL_ASSEMBLER_NAME (decl) = get_identifier (library_name);
3115 make_decl_rtl (decl, NULL_PTR, 1);
3117 DECL_BUILT_IN_CLASS (decl) = class;
3118 DECL_FUNCTION_CODE (decl) = function_code;
3120 /* Warn if a function in the namespace for users
3121 is used without an occasion to consider it declared. */
3122 if (name[0] != '_' || name[1] != '_')
3123 C_DECL_ANTICIPATED (decl) = 1;
3128 /* Called when a declaration is seen that contains no names to declare.
3129 If its type is a reference to a structure, union or enum inherited
3130 from a containing scope, shadow that tag name for the current scope
3131 with a forward reference.
3132 If its type defines a new named structure or union
3133 or defines an enum, it is valid but we need not do anything here.
3134 Otherwise, it is an error. */
3137 shadow_tag (declspecs)
3140 shadow_tag_warned (declspecs, 0);
3144 shadow_tag_warned (declspecs, warned)
3147 /* 1 => we have done a pedwarn. 2 => we have done a warning, but
3154 pending_invalid_xref = 0;
3156 /* Remove the attributes from declspecs, since they will confuse the
3158 split_specs_attrs (declspecs, &specs, &attrs);
3160 for (link = specs; link; link = TREE_CHAIN (link))
3162 register tree value = TREE_VALUE (link);
3163 register enum tree_code code = TREE_CODE (value);
3165 if (code == RECORD_TYPE || code == UNION_TYPE || code == ENUMERAL_TYPE)
3166 /* Used to test also that TYPE_SIZE (value) != 0.
3167 That caused warning for `struct foo;' at top level in the file. */
3169 register tree name = lookup_tag_reverse (value);
3176 if (warned != 1 && code != ENUMERAL_TYPE)
3177 /* Empty unnamed enum OK */
3179 pedwarn ("unnamed struct/union that defines no instances");
3185 t = lookup_tag (code, name, current_binding_level, 1);
3189 t = make_node (code);
3196 if (!warned && ! in_system_header)
3198 warning ("useless keyword or type name in empty declaration");
3205 error ("two types specified in one empty declaration");
3210 pedwarn ("empty declaration");
3214 /* Decode a "typename", such as "int **", returning a ..._TYPE node. */
3217 groktypename (typename)
3220 if (TREE_CODE (typename) != TREE_LIST)
3222 return grokdeclarator (TREE_VALUE (typename),
3223 TREE_PURPOSE (typename),
3227 /* Return a PARM_DECL node for a given pair of specs and declarator. */
3230 groktypename_in_parm_context (typename)
3233 if (TREE_CODE (typename) != TREE_LIST)
3235 return grokdeclarator (TREE_VALUE (typename),
3236 TREE_PURPOSE (typename),
3240 /* Decode a declarator in an ordinary declaration or data definition.
3241 This is called as soon as the type information and variable name
3242 have been parsed, before parsing the initializer if any.
3243 Here we create the ..._DECL node, fill in its type,
3244 and put it on the list of decls for the current context.
3245 The ..._DECL node is returned as the value.
3247 Exception: for arrays where the length is not specified,
3248 the type is left null, to be filled in by `finish_decl'.
3250 Function definitions do not come here; they go to start_function
3251 instead. However, external and forward declarations of functions
3252 do go through here. Structure field declarations are done by
3253 grokfield and not through here. */
3256 start_decl (declarator, declspecs, initialized, attributes, prefix_attributes)
3257 tree declarator, declspecs;
3259 tree attributes, prefix_attributes;
3261 register tree decl = grokdeclarator (declarator, declspecs,
3262 NORMAL, initialized);
3265 if (warn_main > 0 && TREE_CODE (decl) != FUNCTION_DECL
3266 && !strcmp (IDENTIFIER_POINTER (DECL_NAME (decl)), "main"))
3267 warning_with_decl (decl, "`%s' is usually a function");
3270 /* Is it valid for this decl to have an initializer at all?
3271 If not, set INITIALIZED to zero, which will indirectly
3272 tell `finish_decl' to ignore the initializer once it is parsed. */
3273 switch (TREE_CODE (decl))
3276 /* typedef foo = bar means give foo the same type as bar.
3277 We haven't parsed bar yet, so `finish_decl' will fix that up.
3278 Any other case of an initialization in a TYPE_DECL is an error. */
3279 if (pedantic || list_length (declspecs) > 1)
3281 error ("typedef `%s' is initialized",
3282 IDENTIFIER_POINTER (DECL_NAME (decl)));
3288 error ("function `%s' is initialized like a variable",
3289 IDENTIFIER_POINTER (DECL_NAME (decl)));
3294 /* DECL_INITIAL in a PARM_DECL is really DECL_ARG_TYPE. */
3295 error ("parameter `%s' is initialized",
3296 IDENTIFIER_POINTER (DECL_NAME (decl)));
3301 /* Don't allow initializations for incomplete types
3302 except for arrays which might be completed by the initialization. */
3303 if (TYPE_SIZE (TREE_TYPE (decl)) != 0)
3305 /* A complete type is ok if size is fixed. */
3307 if (TREE_CODE (TYPE_SIZE (TREE_TYPE (decl))) != INTEGER_CST
3308 || C_DECL_VARIABLE_SIZE (decl))
3310 error ("variable-sized object may not be initialized");
3314 else if (TREE_CODE (TREE_TYPE (decl)) != ARRAY_TYPE)
3316 error ("variable `%s' has initializer but incomplete type",
3317 IDENTIFIER_POINTER (DECL_NAME (decl)));
3320 else if (TYPE_SIZE (TREE_TYPE (TREE_TYPE (decl))) == 0)
3322 error ("elements of array `%s' have incomplete type",
3323 IDENTIFIER_POINTER (DECL_NAME (decl)));
3330 #if 0 /* Seems redundant with grokdeclarator. */
3331 if (current_binding_level != global_binding_level
3332 && DECL_EXTERNAL (decl)
3333 && TREE_CODE (decl) != FUNCTION_DECL)
3334 warning ("declaration of `%s' has `extern' and is initialized",
3335 IDENTIFIER_POINTER (DECL_NAME (decl)));
3337 DECL_EXTERNAL (decl) = 0;
3338 if (current_binding_level == global_binding_level)
3339 TREE_STATIC (decl) = 1;
3341 /* Tell `pushdecl' this is an initialized decl
3342 even though we don't yet have the initializer expression.
3343 Also tell `finish_decl' it may store the real initializer. */
3344 DECL_INITIAL (decl) = error_mark_node;
3347 /* If this is a function declaration, write a record describing it to the
3348 prototypes file (if requested). */
3350 if (TREE_CODE (decl) == FUNCTION_DECL)
3351 gen_aux_info_record (decl, 0, 0, TYPE_ARG_TYPES (TREE_TYPE (decl)) != 0);
3353 /* ANSI specifies that a tentative definition which is not merged with
3354 a non-tentative definition behaves exactly like a definition with an
3355 initializer equal to zero. (Section 3.7.2)
3356 -fno-common gives strict ANSI behavior. Usually you don't want it.
3357 This matters only for variables with external linkage. */
3358 if (! flag_no_common || ! TREE_PUBLIC (decl))
3359 DECL_COMMON (decl) = 1;
3361 #ifdef SET_DEFAULT_DECL_ATTRIBUTES
3362 SET_DEFAULT_DECL_ATTRIBUTES (decl, attributes);
3365 /* Set attributes here so if duplicate decl, will have proper attributes. */
3366 decl_attributes (decl, attributes, prefix_attributes);
3368 /* Add this decl to the current binding level.
3369 TEM may equal DECL or it may be a previous decl of the same name. */
3370 tem = pushdecl (decl);
3372 /* For a local variable, define the RTL now. */
3373 if (current_binding_level != global_binding_level
3374 /* But not if this is a duplicate decl
3375 and we preserved the rtl from the previous one
3376 (which may or may not happen). */
3377 && DECL_RTL (tem) == 0)
3379 if (TYPE_SIZE (TREE_TYPE (tem)) != 0)
3381 else if (TREE_CODE (TREE_TYPE (tem)) == ARRAY_TYPE
3382 && DECL_INITIAL (tem) != 0)
3389 /* Finish processing of a declaration;
3390 install its initial value.
3391 If the length of an array type is not known before,
3392 it must be determined now, from the initial value, or it is an error. */
3395 finish_decl (decl, init, asmspec_tree)
3399 register tree type = TREE_TYPE (decl);
3400 int was_incomplete = (DECL_SIZE (decl) == 0);
3403 /* If a name was specified, get the string. */
3405 asmspec = TREE_STRING_POINTER (asmspec_tree);
3407 /* If `start_decl' didn't like having an initialization, ignore it now. */
3409 if (init != 0 && DECL_INITIAL (decl) == 0)
3411 /* Don't crash if parm is initialized. */
3412 if (TREE_CODE (decl) == PARM_DECL)
3415 if (ITERATOR_P (decl))
3418 error_with_decl (decl, "iterator has no initial value");
3420 init = save_expr (init);
3425 if (TREE_CODE (decl) != TYPE_DECL)
3426 store_init_value (decl, init);
3429 /* typedef foo = bar; store the type of bar as the type of foo. */
3430 TREE_TYPE (decl) = TREE_TYPE (init);
3431 DECL_INITIAL (decl) = init = 0;
3435 /* Deduce size of array from initialization, if not already known */
3437 if (TREE_CODE (type) == ARRAY_TYPE
3438 && TYPE_DOMAIN (type) == 0
3439 && TREE_CODE (decl) != TYPE_DECL)
3442 = (TREE_STATIC (decl)
3443 /* Even if pedantic, an external linkage array
3444 may have incomplete type at first. */
3445 ? pedantic && !TREE_PUBLIC (decl)
3446 : !DECL_EXTERNAL (decl));
3448 = complete_array_type (type, DECL_INITIAL (decl), do_default);
3450 /* Get the completed type made by complete_array_type. */
3451 type = TREE_TYPE (decl);
3454 error_with_decl (decl, "initializer fails to determine size of `%s'");
3459 error_with_decl (decl, "array size missing in `%s'");
3460 /* If a `static' var's size isn't known,
3461 make it extern as well as static, so it does not get
3463 If it is not `static', then do not mark extern;
3464 finish_incomplete_decl will give it a default size
3465 and it will get allocated. */
3466 else if (!pedantic && TREE_STATIC (decl) && ! TREE_PUBLIC (decl))
3467 DECL_EXTERNAL (decl) = 1;
3470 /* TYPE_MAX_VALUE is always one less than the number of elements
3471 in the array, because we start counting at zero. Therefore,
3472 warn only if the value is less than zero. */
3473 if (pedantic && TYPE_DOMAIN (type) != 0
3474 && tree_int_cst_sgn (TYPE_MAX_VALUE (TYPE_DOMAIN (type))) < 0)
3475 error_with_decl (decl, "zero or negative size array `%s'");
3477 layout_decl (decl, 0);
3480 if (TREE_CODE (decl) == VAR_DECL)
3482 if (DECL_SIZE (decl) == 0 && TYPE_SIZE (TREE_TYPE (decl)) != 0)
3483 layout_decl (decl, 0);
3485 if (DECL_SIZE (decl) == 0
3486 && (TREE_STATIC (decl)
3488 /* A static variable with an incomplete type
3489 is an error if it is initialized.
3490 Also if it is not file scope.
3491 Otherwise, let it through, but if it is not `extern'
3492 then it may cause an error message later. */
3493 /* A duplicate_decls call could have changed an extern
3494 declaration into a file scope one. This can be detected
3495 by TREE_ASM_WRITTEN being set. */
3496 (DECL_INITIAL (decl) != 0
3497 || (DECL_CONTEXT (decl) != 0 && ! TREE_ASM_WRITTEN (decl)))
3499 /* An automatic variable with an incomplete type
3501 !DECL_EXTERNAL (decl)))
3503 error_with_decl (decl, "storage size of `%s' isn't known");
3504 TREE_TYPE (decl) = error_mark_node;
3507 if ((DECL_EXTERNAL (decl) || TREE_STATIC (decl))
3508 && DECL_SIZE (decl) != 0)
3510 if (TREE_CODE (DECL_SIZE (decl)) == INTEGER_CST)
3511 constant_expression_warning (DECL_SIZE (decl));
3513 error_with_decl (decl, "storage size of `%s' isn't constant");
3516 if (TREE_USED (type))
3517 TREE_USED (decl) = 1;
3520 /* If this is a function and an assembler name is specified, it isn't
3521 builtin any more. Also reset DECL_RTL so we can give it its new
3523 if (TREE_CODE (decl) == FUNCTION_DECL && asmspec)
3525 DECL_BUILT_IN_CLASS (decl) = NOT_BUILT_IN;
3526 DECL_RTL (decl) = 0;
3527 DECL_ASSEMBLER_NAME (decl) = get_identifier (asmspec);
3530 /* Output the assembler code and/or RTL code for variables and functions,
3531 unless the type is an undefined structure or union.
3532 If not, it will get done when the type is completed. */
3534 if (TREE_CODE (decl) == VAR_DECL || TREE_CODE (decl) == FUNCTION_DECL)
3536 /* This is a no-op in c-lang.c or something real in objc-actions.c. */
3537 maybe_objc_check_decl (decl);
3538 rest_of_decl_compilation (decl, asmspec,
3539 (DECL_CONTEXT (decl) == 0
3540 || TREE_ASM_WRITTEN (decl)), 0);
3542 if (DECL_CONTEXT (decl) != 0)
3544 /* Recompute the RTL of a local array now
3545 if it used to be an incomplete type. */
3547 && ! TREE_STATIC (decl) && ! DECL_EXTERNAL (decl))
3549 /* If we used it already as memory, it must stay in memory. */
3550 TREE_ADDRESSABLE (decl) = TREE_USED (decl);
3551 /* If it's still incomplete now, no init will save it. */
3552 if (DECL_SIZE (decl) == 0)
3553 DECL_INITIAL (decl) = 0;
3556 /* Compute and store the initial value. */
3557 if (TREE_CODE (decl) != FUNCTION_DECL)
3558 expand_decl_init (decl);
3562 if (TREE_CODE (decl) == TYPE_DECL)
3564 /* This is a no-op in c-lang.c or something real in objc-actions.c. */
3565 maybe_objc_check_decl (decl);
3566 rest_of_decl_compilation (decl, NULL_PTR, DECL_CONTEXT (decl) == 0, 0);
3569 /* At the end of a declaration, throw away any variable type sizes
3570 of types defined inside that declaration. There is no use
3571 computing them in the following function definition. */
3572 if (current_binding_level == global_binding_level)
3573 get_pending_sizes ();
3576 /* If DECL has a cleanup, build and return that cleanup here.
3577 This is a callback called by expand_expr. */
3580 maybe_build_cleanup (decl)
3581 tree decl ATTRIBUTE_UNUSED;
3583 /* There are no cleanups in C. */
3587 /* Given a parsed parameter declaration,
3588 decode it into a PARM_DECL and push that on the current binding level.
3589 Also, for the sake of forward parm decls,
3590 record the given order of parms in `parm_order'. */
3593 push_parm_decl (parm)
3597 int old_immediate_size_expand = immediate_size_expand;
3598 /* Don't try computing parm sizes now -- wait till fn is called. */
3599 immediate_size_expand = 0;
3601 decl = grokdeclarator (TREE_VALUE (TREE_PURPOSE (parm)),
3602 TREE_PURPOSE (TREE_PURPOSE (parm)), PARM, 0);
3603 decl_attributes (decl, TREE_VALUE (TREE_VALUE (parm)),
3604 TREE_PURPOSE (TREE_VALUE (parm)));
3607 if (DECL_NAME (decl))
3610 olddecl = lookup_name (DECL_NAME (decl));
3611 if (pedantic && olddecl != 0 && TREE_CODE (olddecl) == TYPE_DECL)
3612 pedwarn_with_decl (decl, "ANSI C forbids parameter `%s' shadowing typedef");
3616 decl = pushdecl (decl);
3618 immediate_size_expand = old_immediate_size_expand;
3620 current_binding_level->parm_order
3621 = tree_cons (NULL_TREE, decl, current_binding_level->parm_order);
3623 /* Add this decl to the current binding level. */
3624 finish_decl (decl, NULL_TREE, NULL_TREE);
3627 /* Clear the given order of parms in `parm_order'.
3628 Used at start of parm list,
3629 and also at semicolon terminating forward decls. */
3634 current_binding_level->parm_order = NULL_TREE;
3637 /* Make TYPE a complete type based on INITIAL_VALUE.
3638 Return 0 if successful, 1 if INITIAL_VALUE can't be deciphered,
3639 2 if there was no information (in which case assume 1 if DO_DEFAULT). */
3642 complete_array_type (type, initial_value, do_default)
3647 register tree maxindex = NULL_TREE;
3652 /* Note MAXINDEX is really the maximum index,
3653 one less than the size. */
3654 if (TREE_CODE (initial_value) == STRING_CST)
3657 = int_size_in_bytes (TREE_TYPE (TREE_TYPE (initial_value)));
3658 maxindex = build_int_2 ((TREE_STRING_LENGTH (initial_value)
3661 else if (TREE_CODE (initial_value) == CONSTRUCTOR)
3663 tree elts = CONSTRUCTOR_ELTS (initial_value);
3664 maxindex = size_binop (MINUS_EXPR, integer_zero_node, size_one_node);
3665 for (; elts; elts = TREE_CHAIN (elts))
3667 if (TREE_PURPOSE (elts))
3668 maxindex = TREE_PURPOSE (elts);
3670 maxindex = size_binop (PLUS_EXPR, maxindex, size_one_node);
3672 maxindex = copy_node (maxindex);
3676 /* Make an error message unless that happened already. */
3677 if (initial_value != error_mark_node)
3680 /* Prevent further error messages. */
3681 maxindex = build_int_2 (0, 0);
3688 maxindex = build_int_2 (0, 0);
3694 TYPE_DOMAIN (type) = build_index_type (maxindex);
3695 if (!TREE_TYPE (maxindex))
3696 TREE_TYPE (maxindex) = TYPE_DOMAIN (type);
3699 /* Lay out the type now that we can get the real answer. */
3706 /* Given declspecs and a declarator,
3707 determine the name and type of the object declared
3708 and construct a ..._DECL node for it.
3709 (In one case we can return a ..._TYPE node instead.
3710 For invalid input we sometimes return 0.)
3712 DECLSPECS is a chain of tree_list nodes whose value fields
3713 are the storage classes and type specifiers.
3715 DECL_CONTEXT says which syntactic context this declaration is in:
3716 NORMAL for most contexts. Make a VAR_DECL or FUNCTION_DECL or TYPE_DECL.
3717 FUNCDEF for a function definition. Like NORMAL but a few different
3718 error messages in each case. Return value may be zero meaning
3719 this definition is too screwy to try to parse.
3720 PARM for a parameter declaration (either within a function prototype
3721 or before a function body). Make a PARM_DECL, or return void_type_node.
3722 TYPENAME if for a typename (in a cast or sizeof).
3723 Don't make a DECL node; just return the ..._TYPE node.
3724 FIELD for a struct or union field; make a FIELD_DECL.
3725 BITFIELD for a field with specified width.
3726 INITIALIZED is 1 if the decl has an initializer.
3728 In the TYPENAME case, DECLARATOR is really an absolute declarator.
3729 It may also be so in the PARM case, for a prototype where the
3730 argument type is specified but not the name.
3732 This function is where the complicated C meanings of `static'
3733 and `extern' are interpreted. */
3736 grokdeclarator (declarator, declspecs, decl_context, initialized)
3739 enum decl_context decl_context;
3744 tree type = NULL_TREE;
3749 int type_quals = TYPE_UNQUALIFIED;
3751 int explicit_int = 0;
3752 int explicit_char = 0;
3753 int defaulted_int = 0;
3754 tree typedef_decl = 0;
3756 tree typedef_type = 0;
3757 int funcdef_flag = 0;
3758 enum tree_code innermost_code = ERROR_MARK;
3760 int size_varies = 0;
3761 tree decl_machine_attr = NULL_TREE;
3763 if (decl_context == BITFIELD)
3764 bitfield = 1, decl_context = FIELD;
3766 if (decl_context == FUNCDEF)
3767 funcdef_flag = 1, decl_context = NORMAL;
3769 /* Look inside a declarator for the name being declared
3770 and get it as a string, for an error message. */
3772 register tree decl = declarator;
3776 switch (TREE_CODE (decl))
3781 innermost_code = TREE_CODE (decl);
3782 decl = TREE_OPERAND (decl, 0);
3785 case IDENTIFIER_NODE:
3786 name = IDENTIFIER_POINTER (decl);
3797 /* A function definition's declarator must have the form of
3798 a function declarator. */
3800 if (funcdef_flag && innermost_code != CALL_EXPR)
3803 /* Anything declared one level down from the top level
3804 must be one of the parameters of a function
3805 (because the body is at least two levels down). */
3807 /* If this looks like a function definition, make it one,
3808 even if it occurs where parms are expected.
3809 Then store_parm_decls will reject it and not use it as a parm. */
3810 if (decl_context == NORMAL && !funcdef_flag
3811 && current_binding_level->parm_flag)
3812 decl_context = PARM;
3814 /* Look through the decl specs and record which ones appear.
3815 Some typespecs are defined as built-in typenames.
3816 Others, the ones that are modifiers of other types,
3817 are represented by bits in SPECBITS: set the bits for
3818 the modifiers that appear. Storage class keywords are also in SPECBITS.
3820 If there is a typedef name or a type, store the type in TYPE.
3821 This includes builtin typedefs such as `int'.
3823 Set EXPLICIT_INT or EXPLICIT_CHAR if the type is `int' or `char'
3824 and did not come from a user typedef.
3826 Set LONGLONG if `long' is mentioned twice. */
3828 for (spec = declspecs; spec; spec = TREE_CHAIN (spec))
3831 register tree id = TREE_VALUE (spec);
3833 if (id == ridpointers[(int) RID_INT])
3835 if (id == ridpointers[(int) RID_CHAR])
3838 if (TREE_CODE (id) == IDENTIFIER_NODE)
3839 for (i = (int) RID_FIRST_MODIFIER; i < (int) RID_MAX; i++)
3841 if (ridpointers[i] == id)
3843 if (i == (int) RID_LONG && specbits & (1<<i))
3846 error ("`long long long' is too long for GCC");
3849 if (pedantic && ! in_system_header && warn_long_long)
3850 pedwarn ("ANSI C does not support `long long'");
3854 else if (specbits & (1 << i))
3855 pedwarn ("duplicate `%s'", IDENTIFIER_POINTER (id));
3861 error ("two or more data types in declaration of `%s'", name);
3862 /* Actual typedefs come to us as TYPE_DECL nodes. */
3863 else if (TREE_CODE (id) == TYPE_DECL)
3865 type = TREE_TYPE (id);
3866 decl_machine_attr = DECL_MACHINE_ATTRIBUTES (id);
3869 /* Built-in types come as identifiers. */
3870 else if (TREE_CODE (id) == IDENTIFIER_NODE)
3872 register tree t = lookup_name (id);
3873 if (TREE_TYPE (t) == error_mark_node)
3875 else if (!t || TREE_CODE (t) != TYPE_DECL)
3876 error ("`%s' fails to be a typedef or built in type",
3877 IDENTIFIER_POINTER (id));
3880 type = TREE_TYPE (t);
3884 else if (TREE_CODE (id) != ERROR_MARK)
3890 typedef_type = type;
3892 size_varies = C_TYPE_VARIABLE_SIZE (type);
3894 /* No type at all: default to `int', and set DEFAULTED_INT
3895 because it was not a user-defined typedef. */
3899 if ((! (specbits & ((1 << (int) RID_LONG) | (1 << (int) RID_SHORT)
3900 | (1 << (int) RID_SIGNED)
3901 | (1 << (int) RID_UNSIGNED))))
3902 /* Don't warn about typedef foo = bar. */
3903 && ! (specbits & (1 << (int) RID_TYPEDEF) && initialized)
3904 && ! in_system_header)
3906 /* Issue a warning if this is an ISO C 99 program or if -Wreturn-type
3907 and this is a function, or if -Wimplicit; prefer the former
3908 warning since it is more explicit. */
3909 if ((warn_implicit_int || warn_return_type) && funcdef_flag)
3910 warn_about_return_type = 1;
3911 else if (warn_implicit_int || flag_isoc99)
3912 warning ("type defaults to `int' in declaration of `%s'", name);
3916 type = integer_type_node;
3919 /* Now process the modifiers that were specified
3920 and check for invalid combinations. */
3922 /* Long double is a special combination. */
3924 if ((specbits & 1 << (int) RID_LONG) && ! longlong
3925 && TYPE_MAIN_VARIANT (type) == double_type_node)
3927 specbits &= ~ (1 << (int) RID_LONG);
3928 type = long_double_type_node;
3931 /* Check all other uses of type modifiers. */
3933 if (specbits & ((1 << (int) RID_LONG) | (1 << (int) RID_SHORT)
3934 | (1 << (int) RID_UNSIGNED) | (1 << (int) RID_SIGNED)))
3938 if ((specbits & 1 << (int) RID_LONG)
3939 && (specbits & 1 << (int) RID_SHORT))
3940 error ("both long and short specified for `%s'", name);
3941 else if (((specbits & 1 << (int) RID_LONG)
3942 || (specbits & 1 << (int) RID_SHORT))
3944 error ("long or short specified with char for `%s'", name);
3945 else if (((specbits & 1 << (int) RID_LONG)
3946 || (specbits & 1 << (int) RID_SHORT))
3947 && TREE_CODE (type) == REAL_TYPE)
3949 static int already = 0;
3951 error ("long or short specified with floating type for `%s'", name);
3952 if (! already && ! pedantic)
3954 error ("the only valid combination is `long double'");
3958 else if ((specbits & 1 << (int) RID_SIGNED)
3959 && (specbits & 1 << (int) RID_UNSIGNED))
3960 error ("both signed and unsigned specified for `%s'", name);
3961 else if (TREE_CODE (type) != INTEGER_TYPE)
3962 error ("long, short, signed or unsigned invalid for `%s'", name);
3966 if (!explicit_int && !defaulted_int && !explicit_char && pedantic)
3968 pedwarn ("long, short, signed or unsigned used invalidly for `%s'",
3970 if (flag_pedantic_errors)
3975 /* Discard the type modifiers if they are invalid. */
3978 specbits &= ~((1 << (int) RID_LONG) | (1 << (int) RID_SHORT)
3979 | (1 << (int) RID_UNSIGNED) | (1 << (int) RID_SIGNED));
3984 if ((specbits & (1 << (int) RID_COMPLEX))
3985 && TREE_CODE (type) != INTEGER_TYPE && TREE_CODE (type) != REAL_TYPE)
3987 error ("complex invalid for `%s'", name);
3988 specbits &= ~ (1 << (int) RID_COMPLEX);
3991 /* Decide whether an integer type is signed or not.
3992 Optionally treat bitfields as signed by default. */
3993 if (specbits & 1 << (int) RID_UNSIGNED
3994 /* Traditionally, all bitfields are unsigned. */
3995 || (bitfield && flag_traditional
3996 && (! explicit_flag_signed_bitfields || !flag_signed_bitfields))
3997 || (bitfield && ! flag_signed_bitfields
3998 && (explicit_int || defaulted_int || explicit_char
3999 /* A typedef for plain `int' without `signed'
4000 can be controlled just like plain `int'. */
4001 || ! (typedef_decl != 0
4002 && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl)))
4003 && TREE_CODE (type) != ENUMERAL_TYPE
4004 && !(specbits & 1 << (int) RID_SIGNED)))
4007 type = long_long_unsigned_type_node;
4008 else if (specbits & 1 << (int) RID_LONG)
4009 type = long_unsigned_type_node;
4010 else if (specbits & 1 << (int) RID_SHORT)
4011 type = short_unsigned_type_node;
4012 else if (type == char_type_node)
4013 type = unsigned_char_type_node;
4014 else if (typedef_decl)
4015 type = unsigned_type (type);
4017 type = unsigned_type_node;
4019 else if ((specbits & 1 << (int) RID_SIGNED)
4020 && type == char_type_node)
4021 type = signed_char_type_node;
4023 type = long_long_integer_type_node;
4024 else if (specbits & 1 << (int) RID_LONG)
4025 type = long_integer_type_node;
4026 else if (specbits & 1 << (int) RID_SHORT)
4027 type = short_integer_type_node;
4029 if (specbits & 1 << (int) RID_COMPLEX)
4031 /* If we just have "complex", it is equivalent to
4032 "complex double", but if any modifiers at all are specified it is
4033 the complex form of TYPE. E.g, "complex short" is
4034 "complex short int". */
4036 if (defaulted_int && ! longlong
4037 && ! (specbits & ((1 << (int) RID_LONG) | (1 << (int) RID_SHORT)
4038 | (1 << (int) RID_SIGNED)
4039 | (1 << (int) RID_UNSIGNED))))
4040 type = complex_double_type_node;
4041 else if (type == integer_type_node)
4042 type = complex_integer_type_node;
4043 else if (type == float_type_node)
4044 type = complex_float_type_node;
4045 else if (type == double_type_node)
4046 type = complex_double_type_node;
4047 else if (type == long_double_type_node)
4048 type = complex_long_double_type_node;
4050 type = build_complex_type (type);
4053 /* Figure out the type qualifiers for the declaration. There are
4054 two ways a declaration can become qualified. One is something
4055 like `const int i' where the `const' is explicit. Another is
4056 something like `typedef const int CI; CI i' where the type of the
4057 declaration contains the `const'. */
4058 constp = !! (specbits & 1 << (int) RID_CONST) + TYPE_READONLY (type);
4059 restrictp = !! (specbits & 1 << (int) RID_RESTRICT) + TYPE_RESTRICT (type);
4060 volatilep = !! (specbits & 1 << (int) RID_VOLATILE) + TYPE_VOLATILE (type);
4061 inlinep = !! (specbits & (1 << (int) RID_INLINE));
4063 pedwarn ("duplicate `const'");
4065 pedwarn ("duplicate `restrict'");
4067 pedwarn ("duplicate `volatile'");
4068 if (! flag_gen_aux_info && (TYPE_QUALS (type)))
4069 type = TYPE_MAIN_VARIANT (type);
4070 type_quals = ((constp ? TYPE_QUAL_CONST : 0)
4071 | (restrictp ? TYPE_QUAL_RESTRICT : 0)
4072 | (volatilep ? TYPE_QUAL_VOLATILE : 0));
4074 /* Warn if two storage classes are given. Default to `auto'. */
4079 if (specbits & 1 << (int) RID_AUTO) nclasses++;
4080 if (specbits & 1 << (int) RID_STATIC) nclasses++;
4081 if (specbits & 1 << (int) RID_EXTERN) nclasses++;
4082 if (specbits & 1 << (int) RID_REGISTER) nclasses++;
4083 if (specbits & 1 << (int) RID_TYPEDEF) nclasses++;
4084 if (specbits & 1 << (int) RID_ITERATOR) nclasses++;
4086 /* Warn about storage classes that are invalid for certain
4087 kinds of declarations (parameters, typenames, etc.). */
4090 error ("multiple storage classes in declaration of `%s'", name);
4091 else if (funcdef_flag
4093 & ((1 << (int) RID_REGISTER)
4094 | (1 << (int) RID_AUTO)
4095 | (1 << (int) RID_TYPEDEF))))
4097 if (specbits & 1 << (int) RID_AUTO
4098 && (pedantic || current_binding_level == global_binding_level))
4099 pedwarn ("function definition declared `auto'");
4100 if (specbits & 1 << (int) RID_REGISTER)
4101 error ("function definition declared `register'");
4102 if (specbits & 1 << (int) RID_TYPEDEF)
4103 error ("function definition declared `typedef'");
4104 specbits &= ~ ((1 << (int) RID_TYPEDEF) | (1 << (int) RID_REGISTER)
4105 | (1 << (int) RID_AUTO));
4107 else if (decl_context != NORMAL && nclasses > 0)
4109 if (decl_context == PARM && specbits & 1 << (int) RID_REGISTER)
4113 switch (decl_context)
4116 error ("storage class specified for structure field `%s'", name);
4119 error ("storage class specified for parameter `%s'", name);
4122 error ("storage class specified for typename");
4125 specbits &= ~ ((1 << (int) RID_TYPEDEF) | (1 << (int) RID_REGISTER)
4126 | (1 << (int) RID_AUTO) | (1 << (int) RID_STATIC)
4127 | (1 << (int) RID_EXTERN));
4130 else if (specbits & 1 << (int) RID_EXTERN && initialized && ! funcdef_flag)
4132 /* `extern' with initialization is invalid if not at top level. */
4133 if (current_binding_level == global_binding_level)
4134 warning ("`%s' initialized and declared `extern'", name);
4136 error ("`%s' has both `extern' and initializer", name);
4138 else if (specbits & 1 << (int) RID_EXTERN && funcdef_flag
4139 && current_binding_level != global_binding_level)
4140 error ("nested function `%s' declared `extern'", name);
4141 else if (current_binding_level == global_binding_level
4142 && specbits & (1 << (int) RID_AUTO))
4143 error ("top-level declaration of `%s' specifies `auto'", name);
4144 else if ((specbits & 1 << (int) RID_ITERATOR)
4145 && TREE_CODE (declarator) != IDENTIFIER_NODE)
4147 error ("iterator `%s' has derived type", name);
4148 type = error_mark_node;
4150 else if ((specbits & 1 << (int) RID_ITERATOR)
4151 && TREE_CODE (type) != INTEGER_TYPE)
4153 error ("iterator `%s' has noninteger type", name);
4154 type = error_mark_node;
4158 /* Now figure out the structure of the declarator proper.
4159 Descend through it, creating more complex types, until we reach
4160 the declared identifier (or NULL_TREE, in an absolute declarator). */
4162 while (declarator && TREE_CODE (declarator) != IDENTIFIER_NODE)
4164 if (type == error_mark_node)
4166 declarator = TREE_OPERAND (declarator, 0);
4170 /* Each level of DECLARATOR is either an ARRAY_REF (for ...[..]),
4171 an INDIRECT_REF (for *...),
4172 a CALL_EXPR (for ...(...)),
4173 an identifier (for the name being declared)
4174 or a null pointer (for the place in an absolute declarator
4175 where the name was omitted).
4176 For the last two cases, we have just exited the loop.
4178 At this point, TYPE is the type of elements of an array,
4179 or for a function to return, or for a pointer to point to.
4180 After this sequence of ifs, TYPE is the type of the
4181 array or function or pointer, and DECLARATOR has had its
4182 outermost layer removed. */
4184 if (TREE_CODE (declarator) == ARRAY_REF)
4186 register tree itype = NULL_TREE;
4187 register tree size = TREE_OPERAND (declarator, 1);
4188 /* The index is a signed object `sizetype' bits wide. */
4189 tree index_type = signed_type (sizetype);
4191 declarator = TREE_OPERAND (declarator, 0);
4193 /* Check for some types that there cannot be arrays of. */
4195 if (TYPE_MAIN_VARIANT (type) == void_type_node)
4197 error ("declaration of `%s' as array of voids", name);
4198 type = error_mark_node;
4201 if (TREE_CODE (type) == FUNCTION_TYPE)
4203 error ("declaration of `%s' as array of functions", name);
4204 type = error_mark_node;
4207 if (size == error_mark_node)
4208 type = error_mark_node;
4210 if (type == error_mark_node)
4213 /* If size was specified, set ITYPE to a range-type for that size.
4214 Otherwise, ITYPE remains null. finish_decl may figure it out
4215 from an initial value. */
4219 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue. */
4220 STRIP_TYPE_NOPS (size);
4222 if (TREE_CODE (TREE_TYPE (size)) != INTEGER_TYPE
4223 && TREE_CODE (TREE_TYPE (size)) != ENUMERAL_TYPE)
4225 error ("size of array `%s' has non-integer type", name);
4226 size = integer_one_node;
4229 if (pedantic && integer_zerop (size))
4230 pedwarn ("ANSI C forbids zero-size array `%s'", name);
4232 if (TREE_CODE (size) == INTEGER_CST)
4234 constant_expression_warning (size);
4235 if (tree_int_cst_sgn (size) < 0)
4237 error ("size of array `%s' is negative", name);
4238 size = integer_one_node;
4243 /* Make sure the array size remains visibly nonconstant
4244 even if it is (eg) a const variable with known value. */
4249 if (TREE_CONSTANT (size))
4250 pedwarn ("ANSI C forbids array `%s' whose size can't be evaluated", name);
4252 pedwarn ("ANSI C forbids variable-size array `%s'", name);
4256 /* Convert size to index_type, so that if it is a variable
4257 the computations will be done in the proper mode. */
4258 itype = fold (build (MINUS_EXPR, index_type,
4259 convert (index_type, size),
4260 convert (index_type, size_one_node)));
4262 /* If that overflowed, the array is too big.
4263 ??? While a size of INT_MAX+1 technically shouldn't cause
4264 an overflow (because we subtract 1), the overflow is recorded
4265 during the conversion to index_type, before the subtraction.
4266 Handling this case seems like an unnecessary complication. */
4267 if (TREE_OVERFLOW (itype))
4269 error ("size of array `%s' is too large", name);
4270 type = error_mark_node;
4275 itype = variable_size (itype);
4276 itype = build_index_type (itype);
4279 #if 0 /* This had bad results for pointers to arrays, as in
4280 union incomplete (*foo)[4]; */
4281 /* Complain about arrays of incomplete types, except in typedefs. */
4283 if (TYPE_SIZE (type) == 0
4284 /* Avoid multiple warnings for nested array types. */
4285 && TREE_CODE (type) != ARRAY_TYPE
4286 && !(specbits & (1 << (int) RID_TYPEDEF))
4287 && !C_TYPE_BEING_DEFINED (type))
4288 warning ("array type has incomplete element type");
4291 #if 0 /* We shouldn't have a function type here at all!
4292 Functions aren't allowed as array elements. */
4293 if (pedantic && TREE_CODE (type) == FUNCTION_TYPE
4294 && (constp || volatilep))
4295 pedwarn ("ANSI C forbids const or volatile function types");
4298 /* Build the array type itself, then merge any constancy or
4299 volatility into the target type. We must do it in this order
4300 to ensure that the TYPE_MAIN_VARIANT field of the array type
4301 is set correctly. */
4303 type = build_array_type (type, itype);
4305 type = c_build_qualified_type (type, type_quals);
4307 #if 0 /* don't clear these; leave them set so that the array type
4308 or the variable is itself const or volatile. */
4309 type_quals = TYPE_UNQUALIFIED;
4313 C_TYPE_VARIABLE_SIZE (type) = 1;
4315 else if (TREE_CODE (declarator) == CALL_EXPR)
4319 /* Declaring a function type.
4320 Make sure we have a valid type for the function to return. */
4321 if (type == error_mark_node)
4326 /* Warn about some types functions can't return. */
4328 if (TREE_CODE (type) == FUNCTION_TYPE)
4330 error ("`%s' declared as function returning a function", name);
4331 type = integer_type_node;
4333 if (TREE_CODE (type) == ARRAY_TYPE)
4335 error ("`%s' declared as function returning an array", name);
4336 type = integer_type_node;
4339 #ifndef TRADITIONAL_RETURN_FLOAT
4340 /* Traditionally, declaring return type float means double. */
4342 if (flag_traditional && TYPE_MAIN_VARIANT (type) == float_type_node)
4343 type = double_type_node;
4344 #endif /* TRADITIONAL_RETURN_FLOAT */
4346 /* Construct the function type and go to the next
4347 inner layer of declarator. */
4349 arg_types = grokparms (TREE_OPERAND (declarator, 1),
4351 /* Say it's a definition
4352 only for the CALL_EXPR
4353 closest to the identifier. */
4354 && TREE_CODE (TREE_OPERAND (declarator, 0)) == IDENTIFIER_NODE);
4355 /* Type qualifiers before the return type of the function
4356 qualify the return type, not the function type. */
4358 type = c_build_qualified_type (type, type_quals);
4359 type_quals = TYPE_UNQUALIFIED;
4361 type = build_function_type (type, arg_types);
4362 declarator = TREE_OPERAND (declarator, 0);
4364 /* Set the TYPE_CONTEXTs for each tagged type which is local to
4365 the formal parameter list of this FUNCTION_TYPE to point to
4366 the FUNCTION_TYPE node itself. */
4371 for (link = last_function_parm_tags;
4373 link = TREE_CHAIN (link))
4374 TYPE_CONTEXT (TREE_VALUE (link)) = type;
4377 else if (TREE_CODE (declarator) == INDIRECT_REF)
4379 /* Merge any constancy or volatility into the target type
4382 if (pedantic && TREE_CODE (type) == FUNCTION_TYPE
4384 pedwarn ("ANSI C forbids qualified function types");
4386 type = c_build_qualified_type (type, type_quals);
4387 type_quals = TYPE_UNQUALIFIED;
4390 type = build_pointer_type (type);
4392 /* Process a list of type modifier keywords
4393 (such as const or volatile) that were given inside the `*'. */
4395 if (TREE_TYPE (declarator))
4397 register tree typemodlist;
4403 for (typemodlist = TREE_TYPE (declarator); typemodlist;
4404 typemodlist = TREE_CHAIN (typemodlist))
4406 tree qualifier = TREE_VALUE (typemodlist);
4408 if (qualifier == ridpointers[(int) RID_CONST])
4410 else if (qualifier == ridpointers[(int) RID_VOLATILE])
4412 else if (qualifier == ridpointers[(int) RID_RESTRICT])
4417 error ("invalid type modifier within pointer declarator");
4421 pedwarn ("duplicate `const'");
4423 pedwarn ("duplicate `volatile'");
4425 pedwarn ("duplicate `restrict'");
4427 type_quals = ((constp ? TYPE_QUAL_CONST : 0)
4428 | (restrictp ? TYPE_QUAL_RESTRICT : 0)
4429 | (volatilep ? TYPE_QUAL_VOLATILE : 0));
4432 declarator = TREE_OPERAND (declarator, 0);
4439 /* Now TYPE has the actual type. */
4441 /* Did array size calculations overflow? */
4443 if (TREE_CODE (type) == ARRAY_TYPE
4445 && TREE_OVERFLOW (TYPE_SIZE (type)))
4446 error ("size of array `%s' is too large", name);
4448 /* If this is declaring a typedef name, return a TYPE_DECL. */
4450 if (specbits & (1 << (int) RID_TYPEDEF))
4453 /* Note that the grammar rejects storage classes
4454 in typenames, fields or parameters */
4455 if (pedantic && TREE_CODE (type) == FUNCTION_TYPE
4457 pedwarn ("ANSI C forbids qualified function types");
4459 type = c_build_qualified_type (type, type_quals);
4460 decl = build_decl (TYPE_DECL, declarator, type);
4461 if ((specbits & (1 << (int) RID_SIGNED))
4462 || (typedef_decl && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl)))
4463 C_TYPEDEF_EXPLICITLY_SIGNED (decl) = 1;
4467 /* Detect the case of an array type of unspecified size
4468 which came, as such, direct from a typedef name.
4469 We must copy the type, so that each identifier gets
4470 a distinct type, so that each identifier's size can be
4471 controlled separately by its own initializer. */
4473 if (type != 0 && typedef_type != 0
4474 && TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (typedef_type)
4475 && TREE_CODE (type) == ARRAY_TYPE && TYPE_DOMAIN (type) == 0)
4477 type = build_array_type (TREE_TYPE (type), 0);
4479 C_TYPE_VARIABLE_SIZE (type) = 1;
4482 /* If this is a type name (such as, in a cast or sizeof),
4483 compute the type and return it now. */
4485 if (decl_context == TYPENAME)
4487 /* Note that the grammar rejects storage classes
4488 in typenames, fields or parameters */
4489 if (pedantic && TREE_CODE (type) == FUNCTION_TYPE
4491 pedwarn ("ANSI C forbids const or volatile function types");
4493 type = c_build_qualified_type (type, type_quals);
4497 /* Aside from typedefs and type names (handle above),
4498 `void' at top level (not within pointer)
4499 is allowed only in public variables.
4500 We don't complain about parms either, but that is because
4501 a better error message can be made later. */
4503 if (TYPE_MAIN_VARIANT (type) == void_type_node && decl_context != PARM
4504 && ! ((decl_context != FIELD && TREE_CODE (type) != FUNCTION_TYPE)
4505 && ((specbits & (1 << (int) RID_EXTERN))
4506 || (current_binding_level == global_binding_level
4508 & ((1 << (int) RID_STATIC) | (1 << (int) RID_REGISTER)))))))
4510 error ("variable or field `%s' declared void", name);
4511 type = integer_type_node;
4514 /* Now create the decl, which may be a VAR_DECL, a PARM_DECL
4515 or a FUNCTION_DECL, depending on DECL_CONTEXT and TYPE. */
4520 if (decl_context == PARM)
4522 tree type_as_written = type;
4525 /* A parameter declared as an array of T is really a pointer to T.
4526 One declared as a function is really a pointer to a function. */
4528 if (TREE_CODE (type) == ARRAY_TYPE)
4530 /* Transfer const-ness of array into that of type pointed to. */
4531 type = TREE_TYPE (type);
4533 type = c_build_qualified_type (type, type_quals);
4534 type = build_pointer_type (type);
4535 type_quals = TYPE_UNQUALIFIED;
4538 else if (TREE_CODE (type) == FUNCTION_TYPE)
4540 if (pedantic && type_quals)
4541 pedwarn ("ANSI C forbids qualified function types");
4543 type = c_build_qualified_type (type, type_quals);
4544 type = build_pointer_type (type);
4545 type_quals = TYPE_UNQUALIFIED;
4548 decl = build_decl (PARM_DECL, declarator, type);
4550 C_DECL_VARIABLE_SIZE (decl) = 1;
4552 /* Compute the type actually passed in the parmlist,
4553 for the case where there is no prototype.
4554 (For example, shorts and chars are passed as ints.)
4555 When there is a prototype, this is overridden later. */
4557 if (type == error_mark_node)
4558 promoted_type = type;
4561 promoted_type = simple_type_promotes_to (type);
4562 if (! promoted_type)
4563 promoted_type = type;
4566 DECL_ARG_TYPE (decl) = promoted_type;
4567 DECL_ARG_TYPE_AS_WRITTEN (decl) = type_as_written;
4569 else if (decl_context == FIELD)
4571 /* Structure field. It may not be a function. */
4573 if (TREE_CODE (type) == FUNCTION_TYPE)
4575 error ("field `%s' declared as a function", name);
4576 type = build_pointer_type (type);
4578 else if (TREE_CODE (type) != ERROR_MARK && TYPE_SIZE (type) == 0)
4580 error ("field `%s' has incomplete type", name);
4581 type = error_mark_node;
4583 /* Move type qualifiers down to element of an array. */
4584 if (TREE_CODE (type) == ARRAY_TYPE && type_quals)
4586 type = build_array_type (c_build_qualified_type (TREE_TYPE (type),
4588 TYPE_DOMAIN (type));
4589 #if 0 /* Leave the field const or volatile as well. */
4590 type_quals = TYPE_UNQUALIFIED;
4593 decl = build_decl (FIELD_DECL, declarator, type);
4595 C_DECL_VARIABLE_SIZE (decl) = 1;
4597 else if (TREE_CODE (type) == FUNCTION_TYPE)
4599 /* Every function declaration is "external"
4600 except for those which are inside a function body
4601 in which `auto' is used.
4602 That is a case not specified by ANSI C,
4603 and we use it for forward declarations for nested functions. */
4604 int extern_ref = (!(specbits & (1 << (int) RID_AUTO))
4605 || current_binding_level == global_binding_level);
4607 if (specbits & (1 << (int) RID_AUTO)
4608 && (pedantic || current_binding_level == global_binding_level))
4609 pedwarn ("invalid storage class for function `%s'", name);
4610 if (specbits & (1 << (int) RID_REGISTER))
4611 error ("invalid storage class for function `%s'", name);
4612 /* Function declaration not at top level.
4613 Storage classes other than `extern' are not allowed
4614 and `extern' makes no difference. */
4615 if (current_binding_level != global_binding_level
4616 && (specbits & ((1 << (int) RID_STATIC) | (1 << (int) RID_INLINE)))
4618 pedwarn ("invalid storage class for function `%s'", name);
4620 decl = build_decl (FUNCTION_DECL, declarator, type);
4621 decl = build_decl_attribute_variant (decl, decl_machine_attr);
4623 if (pedantic && type_quals && ! DECL_IN_SYSTEM_HEADER (decl))
4624 pedwarn ("ANSI C forbids qualified function types");
4627 && TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (decl))) == void_type_node
4628 && TYPE_QUALS (TREE_TYPE (TREE_TYPE (decl)))
4629 && ! DECL_IN_SYSTEM_HEADER (decl))
4630 pedwarn ("ANSI C forbids qualified void function return type");
4632 /* GNU C interprets a `volatile void' return type to indicate
4633 that the function does not return. */
4634 if ((type_quals & TYPE_QUAL_VOLATILE)
4635 && TREE_TYPE (TREE_TYPE (decl)) != void_type_node)
4636 warning ("`noreturn' function returns non-void value");
4639 DECL_EXTERNAL (decl) = 1;
4640 /* Record absence of global scope for `static' or `auto'. */
4642 = !(specbits & ((1 << (int) RID_STATIC) | (1 << (int) RID_AUTO)));
4644 /* Record presence of `inline', if it is reasonable. */
4647 if (! strcmp (IDENTIFIER_POINTER (declarator), "main"))
4648 warning ("cannot inline function `main'");
4650 /* Assume that otherwise the function can be inlined. */
4651 DECL_INLINE (decl) = 1;
4653 if (specbits & (1 << (int) RID_EXTERN))
4654 current_extern_inline = 1;
4659 /* It's a variable. */
4660 /* An uninitialized decl with `extern' is a reference. */
4661 int extern_ref = !initialized && (specbits & (1 << (int) RID_EXTERN));
4663 /* Move type qualifiers down to element of an array. */
4664 if (TREE_CODE (type) == ARRAY_TYPE && type_quals)
4666 type = build_array_type (c_build_qualified_type (TREE_TYPE (type),
4668 TYPE_DOMAIN (type));
4669 #if 0 /* Leave the variable const or volatile as well. */
4670 type_quals = TYPE_UNQUALIFIED;
4674 decl = build_decl (VAR_DECL, declarator, type);
4676 C_DECL_VARIABLE_SIZE (decl) = 1;
4679 pedwarn_with_decl (decl, "variable `%s' declared `inline'");
4681 DECL_EXTERNAL (decl) = extern_ref;
4682 /* At top level, the presence of a `static' or `register' storage
4683 class specifier, or the absence of all storage class specifiers
4684 makes this declaration a definition (perhaps tentative). Also,
4685 the absence of both `static' and `register' makes it public. */
4686 if (current_binding_level == global_binding_level)
4690 & ((1 << (int) RID_STATIC) | (1 << (int) RID_REGISTER)));
4691 TREE_STATIC (decl) = ! DECL_EXTERNAL (decl);
4693 /* Not at top level, only `static' makes a static definition. */
4696 TREE_STATIC (decl) = (specbits & (1 << (int) RID_STATIC)) != 0;
4697 TREE_PUBLIC (decl) = DECL_EXTERNAL (decl);
4700 if (specbits & 1 << (int) RID_ITERATOR)
4701 ITERATOR_P (decl) = 1;
4704 /* Record `register' declaration for warnings on &
4705 and in case doing stupid register allocation. */
4707 if (specbits & (1 << (int) RID_REGISTER))
4708 DECL_REGISTER (decl) = 1;
4710 /* Record constancy and volatility. */
4711 c_apply_type_quals_to_decl (type_quals, decl);
4713 /* If a type has volatile components, it should be stored in memory.
4714 Otherwise, the fact that those components are volatile
4715 will be ignored, and would even crash the compiler. */
4716 if (C_TYPE_FIELDS_VOLATILE (TREE_TYPE (decl)))
4717 mark_addressable (decl);
4723 /* Decode the parameter-list info for a function type or function definition.
4724 The argument is the value returned by `get_parm_info' (or made in parse.y
4725 if there is an identifier list instead of a parameter decl list).
4726 These two functions are separate because when a function returns
4727 or receives functions then each is called multiple times but the order
4728 of calls is different. The last call to `grokparms' is always the one
4729 that contains the formal parameter names of a function definition.
4731 Store in `last_function_parms' a chain of the decls of parms.
4732 Also store in `last_function_parm_tags' a chain of the struct, union,
4733 and enum tags declared among the parms.
4735 Return a list of arg types to use in the FUNCTION_TYPE for this function.
4737 FUNCDEF_FLAG is nonzero for a function definition, 0 for
4738 a mere declaration. A nonempty identifier-list gets an error message
4739 when FUNCDEF_FLAG is zero. */
4742 grokparms (parms_info, funcdef_flag)
4746 tree first_parm = TREE_CHAIN (parms_info);
4748 last_function_parms = TREE_PURPOSE (parms_info);
4749 last_function_parm_tags = TREE_VALUE (parms_info);
4751 if (warn_strict_prototypes && first_parm == 0 && !funcdef_flag
4752 && !in_system_header)
4753 warning ("function declaration isn't a prototype");
4756 && TREE_CODE (TREE_VALUE (first_parm)) == IDENTIFIER_NODE)
4759 pedwarn ("parameter names (without types) in function declaration");
4761 last_function_parms = first_parm;
4768 /* We no longer test FUNCDEF_FLAG.
4769 If the arg types are incomplete in a declaration,
4770 they must include undefined tags.
4771 These tags can never be defined in the scope of the declaration,
4772 so the types can never be completed,
4773 and no call can be compiled successfully. */
4775 /* In a fcn definition, arg types must be complete. */
4778 for (parm = last_function_parms, typelt = first_parm;
4780 parm = TREE_CHAIN (parm))
4781 /* Skip over any enumeration constants declared here. */
4782 if (TREE_CODE (parm) == PARM_DECL)
4784 /* Barf if the parameter itself has an incomplete type. */
4785 tree type = TREE_VALUE (typelt);
4786 if (TYPE_SIZE (type) == 0)
4788 if (funcdef_flag && DECL_NAME (parm) != 0)
4789 error ("parameter `%s' has incomplete type",
4790 IDENTIFIER_POINTER (DECL_NAME (parm)));
4792 warning ("parameter has incomplete type");
4795 TREE_VALUE (typelt) = error_mark_node;
4796 TREE_TYPE (parm) = error_mark_node;
4799 #if 0 /* This has been replaced by parm_tags_warning
4800 which uses a more accurate criterion for what to warn about. */
4803 /* Now warn if is a pointer to an incomplete type. */
4804 while (TREE_CODE (type) == POINTER_TYPE
4805 || TREE_CODE (type) == REFERENCE_TYPE)
4806 type = TREE_TYPE (type);
4807 type = TYPE_MAIN_VARIANT (type);
4808 if (TYPE_SIZE (type) == 0)
4810 if (DECL_NAME (parm) != 0)
4811 warning ("parameter `%s' points to incomplete type",
4812 IDENTIFIER_POINTER (DECL_NAME (parm)));
4814 warning ("parameter points to incomplete type");
4818 typelt = TREE_CHAIN (typelt);
4826 /* Return a tree_list node with info on a parameter list just parsed.
4827 The TREE_PURPOSE is a chain of decls of those parms.
4828 The TREE_VALUE is a list of structure, union and enum tags defined.
4829 The TREE_CHAIN is a list of argument types to go in the FUNCTION_TYPE.
4830 This tree_list node is later fed to `grokparms'.
4832 VOID_AT_END nonzero means append `void' to the end of the type-list.
4833 Zero means the parmlist ended with an ellipsis so don't append `void'. */
4836 get_parm_info (void_at_end)
4839 register tree decl, t;
4840 register tree types = 0;
4842 tree tags = gettags ();
4843 tree parms = getdecls ();
4845 tree order = current_binding_level->parm_order;
4847 /* Just `void' (and no ellipsis) is special. There are really no parms. */
4848 if (void_at_end && parms != 0
4849 && TREE_CHAIN (parms) == 0
4850 && TYPE_MAIN_VARIANT (TREE_TYPE (parms)) == void_type_node
4851 && DECL_NAME (parms) == 0)
4854 storedecls (NULL_TREE);
4855 return tree_cons (NULL_TREE, NULL_TREE,
4856 tree_cons (NULL_TREE, void_type_node, NULL_TREE));
4859 /* Extract enumerator values and other non-parms declared with the parms.
4860 Likewise any forward parm decls that didn't have real parm decls. */
4861 for (decl = parms; decl; )
4863 tree next = TREE_CHAIN (decl);
4865 if (TREE_CODE (decl) != PARM_DECL)
4867 TREE_CHAIN (decl) = new_parms;
4870 else if (TREE_ASM_WRITTEN (decl))
4872 error_with_decl (decl, "parameter `%s' has just a forward declaration");
4873 TREE_CHAIN (decl) = new_parms;
4879 /* Put the parm decls back in the order they were in in the parm list. */
4880 for (t = order; t; t = TREE_CHAIN (t))
4883 TREE_CHAIN (TREE_VALUE (t)) = TREE_VALUE (TREE_CHAIN (t));
4885 TREE_CHAIN (TREE_VALUE (t)) = 0;
4888 new_parms = chainon (order ? nreverse (TREE_VALUE (order)) : 0,
4891 /* Store the parmlist in the binding level since the old one
4892 is no longer a valid list. (We have changed the chain pointers.) */
4893 storedecls (new_parms);
4895 for (decl = new_parms; decl; decl = TREE_CHAIN (decl))
4896 /* There may also be declarations for enumerators if an enumeration
4897 type is declared among the parms. Ignore them here. */
4898 if (TREE_CODE (decl) == PARM_DECL)
4900 /* Since there is a prototype,
4901 args are passed in their declared types. */
4902 tree type = TREE_TYPE (decl);
4903 DECL_ARG_TYPE (decl) = type;
4904 if (PROMOTE_PROTOTYPES
4905 && (TREE_CODE (type) == INTEGER_TYPE
4906 || TREE_CODE (type) == ENUMERAL_TYPE)
4907 && TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node))
4908 DECL_ARG_TYPE (decl) = integer_type_node;
4910 types = tree_cons (NULL_TREE, TREE_TYPE (decl), types);
4911 if (TYPE_MAIN_VARIANT (TREE_VALUE (types)) == void_type_node && ! erred
4912 && DECL_NAME (decl) == 0)
4914 error ("`void' in parameter list must be the entire list");
4920 return tree_cons (new_parms, tags,
4921 nreverse (tree_cons (NULL_TREE, void_type_node, types)));
4923 return tree_cons (new_parms, tags, nreverse (types));
4926 /* At end of parameter list, warn about any struct, union or enum tags
4927 defined within. Do so because these types cannot ever become complete. */
4930 parmlist_tags_warning ()
4935 for (elt = current_binding_level->tags; elt; elt = TREE_CHAIN (elt))
4937 enum tree_code code = TREE_CODE (TREE_VALUE (elt));
4938 /* An anonymous union parm type is meaningful as a GNU extension.
4939 So don't warn for that. */
4940 if (code == UNION_TYPE && TREE_PURPOSE (elt) == 0 && !pedantic)
4942 if (TREE_PURPOSE (elt) != 0)
4943 warning ("`%s %s' declared inside parameter list",
4944 (code == RECORD_TYPE ? "struct"
4945 : code == UNION_TYPE ? "union"
4947 IDENTIFIER_POINTER (TREE_PURPOSE (elt)));
4949 warning ("anonymous %s declared inside parameter list",
4950 (code == RECORD_TYPE ? "struct"
4951 : code == UNION_TYPE ? "union"
4956 warning ("its scope is only this definition or declaration, which is probably not what you want.");
4962 /* Get the struct, enum or union (CODE says which) with tag NAME.
4963 Define the tag as a forward-reference if it is not defined. */
4966 xref_tag (code, name)
4967 enum tree_code code;
4970 /* If a cross reference is requested, look up the type
4971 already defined for this tag and return it. */
4973 register tree ref = lookup_tag (code, name, current_binding_level, 0);
4974 /* Even if this is the wrong type of tag, return what we found.
4975 There will be an error message anyway, from pending_xref_error.
4976 If we create an empty xref just for an invalid use of the type,
4977 the main result is to create lots of superfluous error messages. */
4981 /* If no such tag is yet defined, create a forward-reference node
4982 and record it as the "definition".
4983 When a real declaration of this type is found,
4984 the forward-reference will be altered into a real type. */
4986 ref = make_node (code);
4987 if (code == ENUMERAL_TYPE)
4989 /* (In ANSI, Enums can be referred to only if already defined.) */
4991 pedwarn ("ANSI C forbids forward references to `enum' types");
4992 /* Give the type a default layout like unsigned int
4993 to avoid crashing if it does not get defined. */
4994 TYPE_MODE (ref) = TYPE_MODE (unsigned_type_node);
4995 TYPE_ALIGN (ref) = TYPE_ALIGN (unsigned_type_node);
4996 TREE_UNSIGNED (ref) = 1;
4997 TYPE_PRECISION (ref) = TYPE_PRECISION (unsigned_type_node);
4998 TYPE_MIN_VALUE (ref) = TYPE_MIN_VALUE (unsigned_type_node);
4999 TYPE_MAX_VALUE (ref) = TYPE_MAX_VALUE (unsigned_type_node);
5002 pushtag (name, ref);
5007 /* Make sure that the tag NAME is defined *in the current binding level*
5008 at least as a forward reference.
5009 CODE says which kind of tag NAME ought to be. */
5012 start_struct (code, name)
5013 enum tree_code code;
5016 /* If there is already a tag defined at this binding level
5017 (as a forward reference), just return it. */
5019 register tree ref = 0;
5022 ref = lookup_tag (code, name, current_binding_level, 1);
5023 if (ref && TREE_CODE (ref) == code)
5025 C_TYPE_BEING_DEFINED (ref) = 1;
5026 TYPE_PACKED (ref) = flag_pack_struct;
5027 if (TYPE_FIELDS (ref))
5028 error ("redefinition of `%s %s'",
5029 code == UNION_TYPE ? "union" : "struct",
5030 IDENTIFIER_POINTER (name));
5035 /* Otherwise create a forward-reference just so the tag is in scope. */
5037 ref = make_node (code);
5038 pushtag (name, ref);
5039 C_TYPE_BEING_DEFINED (ref) = 1;
5040 TYPE_PACKED (ref) = flag_pack_struct;
5044 /* Process the specs, declarator (NULL if omitted) and width (NULL if omitted)
5045 of a structure component, returning a FIELD_DECL node.
5046 WIDTH is non-NULL for bit fields only, and is an INTEGER_CST node.
5048 This is done during the parsing of the struct declaration.
5049 The FIELD_DECL nodes are chained together and the lot of them
5050 are ultimately passed to `build_struct' to make the RECORD_TYPE node. */
5053 grokfield (filename, line, declarator, declspecs, width)
5054 const char *filename ATTRIBUTE_UNUSED;
5055 int line ATTRIBUTE_UNUSED;
5056 tree declarator, declspecs, width;
5060 value = grokdeclarator (declarator, declspecs, width ? BITFIELD : FIELD, 0);
5062 finish_decl (value, NULL_TREE, NULL_TREE);
5063 DECL_INITIAL (value) = width;
5065 maybe_objc_check_decl (value);
5069 /* Fill in the fields of a RECORD_TYPE or UNION_TYPE node, T.
5070 FIELDLIST is a chain of FIELD_DECL nodes for the fields.
5071 ATTRIBUTES are attributes to be applied to the structure. */
5074 finish_struct (t, fieldlist, attributes)
5080 int toplevel = global_binding_level == current_binding_level;
5082 /* If this type was previously laid out as a forward reference,
5083 make sure we lay it out again. */
5087 decl_attributes (t, attributes, NULL_TREE);
5089 /* Nameless union parm types are useful as GCC extension. */
5090 if (! (TREE_CODE (t) == UNION_TYPE && TYPE_NAME (t) == 0) && !pedantic)
5091 /* Otherwise, warn about any struct or union def. in parmlist. */
5092 if (in_parm_level_p ())
5095 pedwarn ("%s defined inside parms",
5096 TREE_CODE (t) == UNION_TYPE ? "union" : "structure");
5097 else if (! flag_traditional)
5098 warning ("%s defined inside parms",
5099 TREE_CODE (t) == UNION_TYPE ? "union" : "structure");
5104 for (x = fieldlist; x; x = TREE_CHAIN (x))
5105 if (DECL_NAME (x) != 0)
5109 pedwarn ("%s has no %smembers",
5110 TREE_CODE (t) == UNION_TYPE ? "union" : "struct",
5111 fieldlist ? "named " : "");
5114 /* Install struct as DECL_CONTEXT of each field decl.
5115 Also process specified field sizes.
5116 Set DECL_FIELD_SIZE to the specified size, or 0 if none specified.
5117 The specified size is found in the DECL_INITIAL.
5118 Store 0 there, except for ": 0" fields (so we can find them
5119 and delete them, below). */
5121 for (x = fieldlist; x; x = TREE_CHAIN (x))
5123 DECL_CONTEXT (x) = t;
5124 DECL_PACKED (x) |= TYPE_PACKED (t);
5125 DECL_FIELD_SIZE (x) = 0;
5127 /* If any field is const, the structure type is pseudo-const. */
5128 if (TREE_READONLY (x))
5129 C_TYPE_FIELDS_READONLY (t) = 1;
5132 /* A field that is pseudo-const makes the structure likewise. */
5133 tree t1 = TREE_TYPE (x);
5134 while (TREE_CODE (t1) == ARRAY_TYPE)
5135 t1 = TREE_TYPE (t1);
5136 if ((TREE_CODE (t1) == RECORD_TYPE || TREE_CODE (t1) == UNION_TYPE)
5137 && C_TYPE_FIELDS_READONLY (t1))
5138 C_TYPE_FIELDS_READONLY (t) = 1;
5141 /* Any field that is volatile means variables of this type must be
5142 treated in some ways as volatile. */
5143 if (TREE_THIS_VOLATILE (x))
5144 C_TYPE_FIELDS_VOLATILE (t) = 1;
5146 /* Any field of nominal variable size implies structure is too. */
5147 if (C_DECL_VARIABLE_SIZE (x))
5148 C_TYPE_VARIABLE_SIZE (t) = 1;
5150 /* Detect invalid nested redefinition. */
5151 if (TREE_TYPE (x) == t)
5152 error ("nested redefinition of `%s'",
5153 IDENTIFIER_POINTER (TYPE_NAME (t)));
5155 /* Detect invalid bit-field size. */
5156 if (DECL_INITIAL (x))
5157 STRIP_NOPS (DECL_INITIAL (x));
5158 if (DECL_INITIAL (x))
5160 if (TREE_CODE (DECL_INITIAL (x)) == INTEGER_CST)
5161 constant_expression_warning (DECL_INITIAL (x));
5164 error_with_decl (x, "bit-field `%s' width not an integer constant");
5165 DECL_INITIAL (x) = NULL;
5169 /* Detect invalid bit-field type. */
5170 if (DECL_INITIAL (x)
5171 && TREE_CODE (TREE_TYPE (x)) != INTEGER_TYPE
5172 && TREE_CODE (TREE_TYPE (x)) != ENUMERAL_TYPE)
5174 error_with_decl (x, "bit-field `%s' has invalid type");
5175 DECL_INITIAL (x) = NULL;
5177 if (DECL_INITIAL (x) && pedantic
5178 && TYPE_MAIN_VARIANT (TREE_TYPE (x)) != integer_type_node
5179 && TYPE_MAIN_VARIANT (TREE_TYPE (x)) != unsigned_type_node
5180 /* Accept an enum that's equivalent to int or unsigned int. */
5181 && !(TREE_CODE (TREE_TYPE (x)) == ENUMERAL_TYPE
5182 && (TYPE_PRECISION (TREE_TYPE (x))
5183 == TYPE_PRECISION (integer_type_node))))
5184 pedwarn_with_decl (x, "bit-field `%s' type invalid in ANSI C");
5186 /* Detect and ignore out of range field width. */
5187 if (DECL_INITIAL (x))
5189 unsigned HOST_WIDE_INT width = TREE_INT_CST_LOW (DECL_INITIAL (x));
5191 if (tree_int_cst_sgn (DECL_INITIAL (x)) < 0)
5193 DECL_INITIAL (x) = NULL;
5194 error_with_decl (x, "negative width in bit-field `%s'");
5196 else if (TREE_INT_CST_HIGH (DECL_INITIAL (x)) != 0
5197 || width > TYPE_PRECISION (TREE_TYPE (x)))
5199 DECL_INITIAL (x) = NULL;
5200 pedwarn_with_decl (x, "width of `%s' exceeds its type");
5202 else if (width == 0 && DECL_NAME (x) != 0)
5204 error_with_decl (x, "zero width for bit-field `%s'");
5205 DECL_INITIAL (x) = NULL;
5209 /* Process valid field width. */
5210 if (DECL_INITIAL (x))
5212 register int width = TREE_INT_CST_LOW (DECL_INITIAL (x));
5214 if (TREE_CODE (TREE_TYPE (x)) == ENUMERAL_TYPE
5215 && (width < min_precision (TYPE_MIN_VALUE (TREE_TYPE (x)),
5216 TREE_UNSIGNED (TREE_TYPE (x)))
5217 || width < min_precision (TYPE_MAX_VALUE (TREE_TYPE (x)),
5218 TREE_UNSIGNED (TREE_TYPE (x)))))
5219 warning_with_decl (x, "`%s' is narrower than values of its type");
5221 DECL_FIELD_SIZE (x) = width;
5222 DECL_BIT_FIELD (x) = DECL_C_BIT_FIELD (x) = 1;
5223 DECL_INITIAL (x) = NULL;
5227 /* field size 0 => force desired amount of alignment. */
5228 #ifdef EMPTY_FIELD_BOUNDARY
5229 DECL_ALIGN (x) = MAX (DECL_ALIGN (x), EMPTY_FIELD_BOUNDARY);
5231 #ifdef PCC_BITFIELD_TYPE_MATTERS
5232 if (PCC_BITFIELD_TYPE_MATTERS)
5233 DECL_ALIGN (x) = MAX (DECL_ALIGN (x),
5234 TYPE_ALIGN (TREE_TYPE (x)));
5238 else if (TREE_TYPE (x) != error_mark_node)
5240 unsigned int min_align = (DECL_PACKED (x) ? BITS_PER_UNIT
5241 : TYPE_ALIGN (TREE_TYPE (x)));
5242 /* Non-bit-fields are aligned for their type, except packed
5243 fields which require only BITS_PER_UNIT alignment. */
5244 DECL_ALIGN (x) = MAX (DECL_ALIGN (x), min_align);
5248 /* Now DECL_INITIAL is null on all members. */
5250 /* Delete all duplicate fields from the fieldlist */
5251 for (x = fieldlist; x && TREE_CHAIN (x);)
5252 /* Anonymous fields aren't duplicates. */
5253 if (DECL_NAME (TREE_CHAIN (x)) == 0)
5257 register tree y = fieldlist;
5261 if (DECL_NAME (y) == DECL_NAME (TREE_CHAIN (x)))
5267 if (DECL_NAME (y) == DECL_NAME (TREE_CHAIN (x)))
5269 error_with_decl (TREE_CHAIN (x), "duplicate member `%s'");
5270 TREE_CHAIN (x) = TREE_CHAIN (TREE_CHAIN (x));
5272 else x = TREE_CHAIN (x);
5275 /* Now we have the nearly final fieldlist. Record it,
5276 then lay out the structure or union (including the fields). */
5278 TYPE_FIELDS (t) = fieldlist;
5282 /* Delete all zero-width bit-fields from the fieldlist */
5284 tree *fieldlistp = &fieldlist;
5286 if (TREE_CODE (*fieldlistp) == FIELD_DECL && DECL_INITIAL (*fieldlistp))
5287 *fieldlistp = TREE_CHAIN (*fieldlistp);
5289 fieldlistp = &TREE_CHAIN (*fieldlistp);
5292 /* Now we have the truly final field list.
5293 Store it in this type and in the variants. */
5295 TYPE_FIELDS (t) = fieldlist;
5297 for (x = TYPE_MAIN_VARIANT (t); x; x = TYPE_NEXT_VARIANT (x))
5299 TYPE_FIELDS (x) = TYPE_FIELDS (t);
5300 TYPE_LANG_SPECIFIC (x) = TYPE_LANG_SPECIFIC (t);
5301 TYPE_ALIGN (x) = TYPE_ALIGN (t);
5304 /* If this was supposed to be a transparent union, but we can't
5305 make it one, warn and turn off the flag. */
5306 if (TREE_CODE (t) == UNION_TYPE
5307 && TYPE_TRANSPARENT_UNION (t)
5308 && TYPE_MODE (t) != DECL_MODE (TYPE_FIELDS (t)))
5310 TYPE_TRANSPARENT_UNION (t) = 0;
5311 warning ("union cannot be made transparent");
5314 /* If this structure or union completes the type of any previous
5315 variable declaration, lay it out and output its rtl. */
5317 if (current_binding_level->n_incomplete != 0)
5320 for (decl = current_binding_level->names; decl; decl = TREE_CHAIN (decl))
5322 if (TREE_TYPE (decl) == t
5323 && TREE_CODE (decl) != TYPE_DECL)
5325 layout_decl (decl, 0);
5326 /* This is a no-op in c-lang.c or something real in objc-actions.c. */
5327 maybe_objc_check_decl (decl);
5328 rest_of_decl_compilation (decl, NULL_PTR, toplevel, 0);
5331 --current_binding_level->n_incomplete;
5333 else if (TYPE_SIZE (TREE_TYPE (decl)) == 0
5334 && TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE)
5336 tree element = TREE_TYPE (decl);
5337 while (TREE_CODE (element) == ARRAY_TYPE)
5338 element = TREE_TYPE (element);
5340 layout_array_type (TREE_TYPE (decl));
5345 /* Finish debugging output for this type. */
5346 rest_of_type_compilation (t, toplevel);
5351 /* Lay out the type T, and its element type, and so on. */
5354 layout_array_type (t)
5357 if (TREE_CODE (TREE_TYPE (t)) == ARRAY_TYPE)
5358 layout_array_type (TREE_TYPE (t));
5362 /* Begin compiling the definition of an enumeration type.
5363 NAME is its name (or null if anonymous).
5364 Returns the type object, as yet incomplete.
5365 Also records info about it so that build_enumerator
5366 may be used to declare the individual values as they are read. */
5372 register tree enumtype = 0;
5374 /* If this is the real definition for a previous forward reference,
5375 fill in the contents in the same object that used to be the
5376 forward reference. */
5379 enumtype = lookup_tag (ENUMERAL_TYPE, name, current_binding_level, 1);
5381 if (enumtype == 0 || TREE_CODE (enumtype) != ENUMERAL_TYPE)
5383 enumtype = make_node (ENUMERAL_TYPE);
5384 pushtag (name, enumtype);
5387 C_TYPE_BEING_DEFINED (enumtype) = 1;
5389 if (TYPE_VALUES (enumtype) != 0)
5391 /* This enum is a named one that has been declared already. */
5392 error ("redeclaration of `enum %s'", IDENTIFIER_POINTER (name));
5394 /* Completely replace its old definition.
5395 The old enumerators remain defined, however. */
5396 TYPE_VALUES (enumtype) = 0;
5399 enum_next_value = integer_zero_node;
5402 if (flag_short_enums)
5403 TYPE_PACKED (enumtype) = 1;
5408 /* After processing and defining all the values of an enumeration type,
5409 install their decls in the enumeration type and finish it off.
5410 ENUMTYPE is the type object, VALUES a list of decl-value pairs,
5411 and ATTRIBUTES are the specified attributes.
5412 Returns ENUMTYPE. */
5415 finish_enum (enumtype, values, attributes)
5420 register tree pair, tem;
5421 tree minnode = 0, maxnode = 0;
5422 int precision, unsign;
5423 int toplevel = (global_binding_level == current_binding_level);
5425 if (in_parm_level_p ())
5426 warning ("enum defined inside parms");
5428 decl_attributes (enumtype, attributes, NULL_TREE);
5430 /* Calculate the maximum value of any enumerator in this type. */
5432 if (values == error_mark_node)
5433 minnode = maxnode = integer_zero_node;
5436 minnode = maxnode = TREE_VALUE (values);
5437 for (pair = TREE_CHAIN (values); pair; pair = TREE_CHAIN (pair))
5439 tree value = TREE_VALUE (pair);
5440 if (tree_int_cst_lt (maxnode, value))
5442 if (tree_int_cst_lt (value, minnode))
5447 /* Construct the final type of this enumeration. It is the same
5448 as one of the integral types - the narrowest one that fits, except
5449 that normally we only go as narrow as int - and signed iff any of
5450 the values are negative. */
5451 unsign = (tree_int_cst_sgn (minnode) >= 0);
5452 precision = MAX (min_precision (minnode, unsign),
5453 min_precision (maxnode, unsign));
5454 if (!TYPE_PACKED (enumtype))
5455 precision = MAX (precision, TYPE_PRECISION (integer_type_node));
5456 if (type_for_size (precision, unsign) == 0)
5458 warning ("enumeration values exceed range of largest integer");
5459 precision = TYPE_PRECISION (long_long_integer_type_node);
5462 TYPE_MIN_VALUE (enumtype) = minnode;
5463 TYPE_MAX_VALUE (enumtype) = maxnode;
5464 TYPE_PRECISION (enumtype) = precision;
5465 TREE_UNSIGNED (enumtype) = unsign;
5466 TYPE_SIZE (enumtype) = 0;
5467 layout_type (enumtype);
5469 if (values != error_mark_node)
5471 /* Change the type of the enumerators to be the enum type. We
5472 need to do this irrespective of the size of the enum, for
5473 proper type checking. Replace the DECL_INITIALs of the
5474 enumerators, and the value slots of the list, with copies
5475 that have the enum type; they cannot be modified in place
5476 because they may be shared (e.g. integer_zero_node) Finally,
5477 change the purpose slots to point to the names of the decls. */
5478 for (pair = values; pair; pair = TREE_CHAIN (pair))
5480 tree enu = TREE_PURPOSE (pair);
5482 TREE_TYPE (enu) = enumtype;
5483 DECL_SIZE (enu) = TYPE_SIZE (enumtype);
5484 DECL_SIZE_UNIT (enu) = TYPE_SIZE_UNIT (enumtype);
5485 DECL_ALIGN (enu) = TYPE_ALIGN (enumtype);
5486 DECL_MODE (enu) = TYPE_MODE (enumtype);
5487 DECL_INITIAL (enu) = convert (enumtype, DECL_INITIAL (enu));
5489 TREE_PURPOSE (pair) = DECL_NAME (enu);
5490 TREE_VALUE (pair) = DECL_INITIAL (enu);
5493 TYPE_VALUES (enumtype) = values;
5496 /* Fix up all variant types of this enum type. */
5497 for (tem = TYPE_MAIN_VARIANT (enumtype); tem; tem = TYPE_NEXT_VARIANT (tem))
5499 if (tem == enumtype)
5501 TYPE_VALUES (tem) = TYPE_VALUES (enumtype);
5502 TYPE_MIN_VALUE (tem) = TYPE_MIN_VALUE (enumtype);
5503 TYPE_MAX_VALUE (tem) = TYPE_MAX_VALUE (enumtype);
5504 TYPE_SIZE (tem) = TYPE_SIZE (enumtype);
5505 TYPE_SIZE_UNIT (tem) = TYPE_SIZE_UNIT (enumtype);
5506 TYPE_MODE (tem) = TYPE_MODE (enumtype);
5507 TYPE_PRECISION (tem) = TYPE_PRECISION (enumtype);
5508 TYPE_ALIGN (tem) = TYPE_ALIGN (enumtype);
5509 TREE_UNSIGNED (tem) = TREE_UNSIGNED (enumtype);
5512 /* Finish debugging output for this type. */
5513 rest_of_type_compilation (enumtype, toplevel);
5518 /* Build and install a CONST_DECL for one value of the
5519 current enumeration type (one that was begun with start_enum).
5520 Return a tree-list containing the CONST_DECL and its value.
5521 Assignment of sequential values by default is handled here. */
5524 build_enumerator (name, value)
5527 register tree decl, type;
5529 /* Validate and default VALUE. */
5531 /* Remove no-op casts from the value. */
5533 STRIP_TYPE_NOPS (value);
5537 if (TREE_CODE (value) == INTEGER_CST)
5539 value = default_conversion (value);
5540 constant_expression_warning (value);
5544 error ("enumerator value for `%s' not integer constant",
5545 IDENTIFIER_POINTER (name));
5550 /* Default based on previous value. */
5551 /* It should no longer be possible to have NON_LVALUE_EXPR
5555 value = enum_next_value;
5557 error ("overflow in enumeration values");
5560 if (pedantic && ! int_fits_type_p (value, integer_type_node))
5562 pedwarn ("ANSI C restricts enumerator values to range of `int'");
5563 value = integer_zero_node;
5566 /* Set basis for default for next value. */
5567 enum_next_value = build_binary_op (PLUS_EXPR, value, integer_one_node, 0);
5568 enum_overflow = tree_int_cst_lt (enum_next_value, value);
5570 /* Now create a declaration for the enum value name. */
5572 type = TREE_TYPE (value);
5573 type = type_for_size (MAX (TYPE_PRECISION (type),
5574 TYPE_PRECISION (integer_type_node)),
5576 || TYPE_PRECISION (type) >= TYPE_PRECISION (integer_type_node))
5577 && TREE_UNSIGNED (type)));
5579 decl = build_decl (CONST_DECL, name, type);
5580 DECL_INITIAL (decl) = value;
5581 TREE_TYPE (value) = type;
5584 return tree_cons (decl, value, NULL_TREE);
5587 /* Create the FUNCTION_DECL for a function definition.
5588 DECLSPECS, DECLARATOR, PREFIX_ATTRIBUTES and ATTRIBUTES are the parts of
5589 the declaration; they describe the function's name and the type it returns,
5590 but twisted together in a fashion that parallels the syntax of C.
5592 This function creates a binding context for the function body
5593 as well as setting up the FUNCTION_DECL in current_function_decl.
5595 Returns 1 on success. If the DECLARATOR is not suitable for a function
5596 (it defines a datum instead), we return 0, which tells
5597 yyparse to report a parse error. */
5600 start_function (declspecs, declarator, prefix_attributes, attributes)
5601 tree declarator, declspecs, prefix_attributes, attributes;
5603 tree decl1, old_decl;
5605 int old_immediate_size_expand = immediate_size_expand;
5607 current_function_returns_value = 0; /* Assume, until we see it does. */
5608 current_function_returns_null = 0;
5609 warn_about_return_type = 0;
5610 current_extern_inline = 0;
5611 c_function_varargs = 0;
5613 shadowed_labels = 0;
5615 /* Don't expand any sizes in the return type of the function. */
5616 immediate_size_expand = 0;
5618 decl1 = grokdeclarator (declarator, declspecs, FUNCDEF, 1);
5620 /* If the declarator is not suitable for a function definition,
5621 cause a syntax error. */
5624 immediate_size_expand = old_immediate_size_expand;
5628 decl_attributes (decl1, prefix_attributes, attributes);
5630 announce_function (decl1);
5632 if (TYPE_SIZE (TREE_TYPE (TREE_TYPE (decl1))) == 0)
5634 error ("return-type is an incomplete type");
5635 /* Make it return void instead. */
5637 = build_function_type (void_type_node,
5638 TYPE_ARG_TYPES (TREE_TYPE (decl1)));
5641 if (warn_about_return_type)
5642 warning ("return-type defaults to `int'");
5644 /* Save the parm names or decls from this function's declarator
5645 where store_parm_decls will find them. */
5646 current_function_parms = last_function_parms;
5647 current_function_parm_tags = last_function_parm_tags;
5649 /* Make the init_value nonzero so pushdecl knows this is not tentative.
5650 error_mark_node is replaced below (in poplevel) with the BLOCK. */
5651 DECL_INITIAL (decl1) = error_mark_node;
5653 /* If this definition isn't a prototype and we had a prototype declaration
5654 before, copy the arg type info from that prototype.
5655 But not if what we had before was a builtin function. */
5656 old_decl = lookup_name_current_level (DECL_NAME (decl1));
5657 if (old_decl != 0 && TREE_CODE (TREE_TYPE (old_decl)) == FUNCTION_TYPE
5658 && !DECL_BUILT_IN (old_decl)
5659 && (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (decl1)))
5660 == TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (old_decl))))
5661 && TYPE_ARG_TYPES (TREE_TYPE (decl1)) == 0)
5663 TREE_TYPE (decl1) = TREE_TYPE (old_decl);
5664 current_function_prototype_file = DECL_SOURCE_FILE (old_decl);
5665 current_function_prototype_line = DECL_SOURCE_LINE (old_decl);
5668 /* If there is no explicit declaration, look for any out-of-scope implicit
5671 old_decl = IDENTIFIER_IMPLICIT_DECL (DECL_NAME (decl1));
5673 /* Optionally warn of old-fashioned def with no previous prototype. */
5674 if (warn_strict_prototypes
5675 && TYPE_ARG_TYPES (TREE_TYPE (decl1)) == 0
5676 && !(old_decl != 0 && TYPE_ARG_TYPES (TREE_TYPE (old_decl)) != 0))
5677 warning ("function declaration isn't a prototype");
5678 /* Optionally warn of any global def with no previous prototype. */
5679 else if (warn_missing_prototypes
5680 && TREE_PUBLIC (decl1)
5681 && !(old_decl != 0 && TYPE_ARG_TYPES (TREE_TYPE (old_decl)) != 0)
5682 && strcmp ("main", IDENTIFIER_POINTER (DECL_NAME (decl1))))
5683 warning_with_decl (decl1, "no previous prototype for `%s'");
5684 /* Optionally warn of any def with no previous prototype
5685 if the function has already been used. */
5686 else if (warn_missing_prototypes
5687 && old_decl != 0 && TREE_USED (old_decl)
5688 && TYPE_ARG_TYPES (TREE_TYPE (old_decl)) == 0)
5689 warning_with_decl (decl1,
5690 "`%s' was used with no prototype before its definition");
5691 /* Optionally warn of any global def with no previous declaration. */
5692 else if (warn_missing_declarations
5693 && TREE_PUBLIC (decl1)
5695 && strcmp ("main", IDENTIFIER_POINTER (DECL_NAME (decl1))))
5696 warning_with_decl (decl1, "no previous declaration for `%s'");
5697 /* Optionally warn of any def with no previous declaration
5698 if the function has already been used. */
5699 else if (warn_missing_declarations
5700 && old_decl != 0 && TREE_USED (old_decl)
5701 && old_decl == IDENTIFIER_IMPLICIT_DECL (DECL_NAME (decl1)))
5702 warning_with_decl (decl1,
5703 "`%s' was used with no declaration before its definition");
5705 /* This is a definition, not a reference.
5706 So normally clear DECL_EXTERNAL.
5707 However, `extern inline' acts like a declaration
5708 except for defining how to inline. So set DECL_EXTERNAL in that case. */
5709 DECL_EXTERNAL (decl1) = current_extern_inline;
5711 #ifdef SET_DEFAULT_DECL_ATTRIBUTES
5712 SET_DEFAULT_DECL_ATTRIBUTES (decl1, attributes);
5715 /* This function exists in static storage.
5716 (This does not mean `static' in the C sense!) */
5717 TREE_STATIC (decl1) = 1;
5719 /* A nested function is not global. */
5720 if (current_function_decl != 0)
5721 TREE_PUBLIC (decl1) = 0;
5723 /* Warn for unlikely, improbable, or stupid declarations of `main'. */
5725 && strcmp ("main", IDENTIFIER_POINTER (DECL_NAME (decl1))) == 0)
5730 if (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (decl1)))
5731 != integer_type_node)
5732 pedwarn_with_decl (decl1, "return type of `%s' is not `int'");
5734 for (args = TYPE_ARG_TYPES (TREE_TYPE (decl1)); args;
5735 args = TREE_CHAIN (args))
5737 tree type = args ? TREE_VALUE (args) : 0;
5739 if (type == void_type_node)
5746 if (TYPE_MAIN_VARIANT (type) != integer_type_node)
5747 pedwarn_with_decl (decl1,
5748 "first argument of `%s' should be `int'");
5752 if (TREE_CODE (type) != POINTER_TYPE
5753 || TREE_CODE (TREE_TYPE (type)) != POINTER_TYPE
5754 || (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (type)))
5756 pedwarn_with_decl (decl1,
5757 "second argument of `%s' should be `char **'");
5761 if (TREE_CODE (type) != POINTER_TYPE
5762 || TREE_CODE (TREE_TYPE (type)) != POINTER_TYPE
5763 || (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (type)))
5765 pedwarn_with_decl (decl1,
5766 "third argument of `%s' should probably be `char **'");
5771 /* It is intentional that this message does not mention the third
5772 argument, which is warned for only pedantically, because it's
5773 blessed by mention in an appendix of the standard. */
5774 if (argct > 0 && (argct < 2 || argct > 3))
5775 pedwarn_with_decl (decl1, "`%s' takes only zero or two arguments");
5777 if (argct == 3 && pedantic)
5778 pedwarn_with_decl (decl1, "third argument of `%s' is deprecated");
5780 if (! TREE_PUBLIC (decl1))
5781 pedwarn_with_decl (decl1, "`%s' is normally a non-static function");
5784 /* Record the decl so that the function name is defined.
5785 If we already have a decl for this name, and it is a FUNCTION_DECL,
5786 use the old decl. */
5788 current_function_decl = pushdecl (decl1);
5791 declare_parm_level (1);
5792 current_binding_level->subblocks_tag_transparent = 1;
5794 make_function_rtl (current_function_decl);
5796 restype = TREE_TYPE (TREE_TYPE (current_function_decl));
5797 /* Promote the value to int before returning it. */
5798 if (C_PROMOTING_INTEGER_TYPE_P (restype))
5800 /* It retains unsignedness if traditional
5801 or if not really getting wider. */
5802 if (TREE_UNSIGNED (restype)
5803 && (flag_traditional
5804 || (TYPE_PRECISION (restype)
5805 == TYPE_PRECISION (integer_type_node))))
5806 restype = unsigned_type_node;
5808 restype = integer_type_node;
5810 DECL_RESULT (current_function_decl)
5811 = build_decl (RESULT_DECL, NULL_TREE, restype);
5813 /* If this fcn was already referenced via a block-scope `extern' decl
5814 (or an implicit decl), propagate certain information about the usage. */
5815 if (TREE_ADDRESSABLE (DECL_ASSEMBLER_NAME (current_function_decl)))
5816 TREE_ADDRESSABLE (current_function_decl) = 1;
5818 immediate_size_expand = old_immediate_size_expand;
5823 /* Record that this function is going to be a varargs function.
5824 This is called before store_parm_decls, which is too early
5825 to call mark_varargs directly. */
5830 c_function_varargs = 1;
5833 /* Store the parameter declarations into the current function declaration.
5834 This is called after parsing the parameter declarations, before
5835 digesting the body of the function.
5837 For an old-style definition, modify the function's type
5838 to specify at least the number of arguments. */
5843 register tree fndecl = current_function_decl;
5846 /* This is either a chain of PARM_DECLs (if a prototype was used)
5847 or a list of IDENTIFIER_NODEs (for an old-fashioned C definition). */
5848 tree specparms = current_function_parms;
5850 /* This is a list of types declared among parms in a prototype. */
5851 tree parmtags = current_function_parm_tags;
5853 /* This is a chain of PARM_DECLs from old-style parm declarations. */
5854 register tree parmdecls = getdecls ();
5856 /* This is a chain of any other decls that came in among the parm
5857 declarations. If a parm is declared with enum {foo, bar} x;
5858 then CONST_DECLs for foo and bar are put here. */
5861 /* Nonzero if this definition is written with a prototype. */
5864 if (specparms != 0 && TREE_CODE (specparms) != TREE_LIST)
5866 /* This case is when the function was defined with an ANSI prototype.
5867 The parms already have decls, so we need not do anything here
5868 except record them as in effect
5869 and complain if any redundant old-style parm decls were written. */
5880 error_with_decl (fndecl,
5881 "parm types given both in parmlist and separately");
5882 /* Get rid of the erroneous decls; don't keep them on
5883 the list of parms, since they might not be PARM_DECLs. */
5884 for (decl = current_binding_level->names;
5885 decl; decl = TREE_CHAIN (decl))
5886 if (DECL_NAME (decl))
5887 IDENTIFIER_LOCAL_VALUE (DECL_NAME (decl)) = 0;
5888 for (link = current_binding_level->shadowed;
5889 link; link = TREE_CHAIN (link))
5890 IDENTIFIER_LOCAL_VALUE (TREE_PURPOSE (link)) = TREE_VALUE (link);
5891 current_binding_level->names = 0;
5892 current_binding_level->shadowed = 0;
5895 specparms = nreverse (specparms);
5896 for (parm = specparms; parm; parm = next)
5898 next = TREE_CHAIN (parm);
5899 if (TREE_CODE (parm) == PARM_DECL)
5901 if (DECL_NAME (parm) == 0)
5902 error_with_decl (parm, "parameter name omitted");
5903 else if (TYPE_MAIN_VARIANT (TREE_TYPE (parm)) == void_type_node)
5905 error_with_decl (parm, "parameter `%s' declared void");
5906 /* Change the type to error_mark_node so this parameter
5907 will be ignored by assign_parms. */
5908 TREE_TYPE (parm) = error_mark_node;
5914 /* If we find an enum constant or a type tag,
5915 put it aside for the moment. */
5916 TREE_CHAIN (parm) = 0;
5917 others = chainon (others, parm);
5921 /* Get the decls in their original chain order
5922 and record in the function. */
5923 DECL_ARGUMENTS (fndecl) = getdecls ();
5926 /* If this function takes a variable number of arguments,
5927 add a phony parameter to the end of the parm list,
5928 to represent the position of the first unnamed argument. */
5929 if (TREE_VALUE (tree_last (TYPE_ARG_TYPES (TREE_TYPE (fndecl))))
5932 tree dummy = build_decl (PARM_DECL, NULL_TREE, void_type_node);
5933 /* Let's hope the address of the unnamed parm
5934 won't depend on its type. */
5935 TREE_TYPE (dummy) = integer_type_node;
5936 DECL_ARG_TYPE (dummy) = integer_type_node;
5937 DECL_ARGUMENTS (fndecl)
5938 = chainon (DECL_ARGUMENTS (fndecl), dummy);
5942 /* Now pushdecl the enum constants. */
5943 for (parm = others; parm; parm = next)
5945 next = TREE_CHAIN (parm);
5946 if (DECL_NAME (parm) == 0)
5948 else if (TYPE_MAIN_VARIANT (TREE_TYPE (parm)) == void_type_node)
5950 else if (TREE_CODE (parm) != PARM_DECL)
5954 storetags (chainon (parmtags, gettags ()));
5958 /* SPECPARMS is an identifier list--a chain of TREE_LIST nodes
5959 each with a parm name as the TREE_VALUE.
5961 PARMDECLS is a chain of declarations for parameters.
5962 Warning! It can also contain CONST_DECLs which are not parameters
5963 but are names of enumerators of any enum types
5964 declared among the parameters.
5966 First match each formal parameter name with its declaration.
5967 Associate decls with the names and store the decls
5968 into the TREE_PURPOSE slots. */
5970 for (parm = parmdecls; parm; parm = TREE_CHAIN (parm))
5971 DECL_RESULT (parm) = 0;
5973 for (parm = specparms; parm; parm = TREE_CHAIN (parm))
5975 register tree tail, found = NULL;
5977 if (TREE_VALUE (parm) == 0)
5979 error_with_decl (fndecl, "parameter name missing from parameter list");
5980 TREE_PURPOSE (parm) = 0;
5984 /* See if any of the parmdecls specifies this parm by name.
5985 Ignore any enumerator decls. */
5986 for (tail = parmdecls; tail; tail = TREE_CHAIN (tail))
5987 if (DECL_NAME (tail) == TREE_VALUE (parm)
5988 && TREE_CODE (tail) == PARM_DECL)
5994 /* If declaration already marked, we have a duplicate name.
5995 Complain, and don't use this decl twice. */
5996 if (found && DECL_RESULT (found) != 0)
5998 error_with_decl (found, "multiple parameters named `%s'");
6002 /* If the declaration says "void", complain and ignore it. */
6003 if (found && TYPE_MAIN_VARIANT (TREE_TYPE (found)) == void_type_node)
6005 error_with_decl (found, "parameter `%s' declared void");
6006 TREE_TYPE (found) = integer_type_node;
6007 DECL_ARG_TYPE (found) = integer_type_node;
6008 layout_decl (found, 0);
6011 /* Traditionally, a parm declared float is actually a double. */
6012 if (found && flag_traditional
6013 && TYPE_MAIN_VARIANT (TREE_TYPE (found)) == float_type_node)
6015 TREE_TYPE (found) = double_type_node;
6016 DECL_ARG_TYPE (found) = double_type_node;
6017 layout_decl (found, 0);
6020 /* If no declaration found, default to int. */
6023 found = build_decl (PARM_DECL, TREE_VALUE (parm),
6025 DECL_ARG_TYPE (found) = TREE_TYPE (found);
6026 DECL_SOURCE_LINE (found) = DECL_SOURCE_LINE (fndecl);
6027 DECL_SOURCE_FILE (found) = DECL_SOURCE_FILE (fndecl);
6029 warning_with_decl (found, "type of `%s' defaults to `int'");
6033 TREE_PURPOSE (parm) = found;
6035 /* Mark this decl as "already found" -- see test, above.
6036 It is safe to use DECL_RESULT for this
6037 since it is not used in PARM_DECLs or CONST_DECLs. */
6038 DECL_RESULT (found) = error_mark_node;
6041 /* Put anything which is on the parmdecls chain and which is
6042 not a PARM_DECL onto the list NONPARMS. (The types of
6043 non-parm things which might appear on the list include
6044 enumerators and NULL-named TYPE_DECL nodes.) Complain about
6045 any actual PARM_DECLs not matched with any names. */
6048 for (parm = parmdecls; parm; )
6050 tree next = TREE_CHAIN (parm);
6051 TREE_CHAIN (parm) = 0;
6053 if (TREE_CODE (parm) != PARM_DECL)
6054 nonparms = chainon (nonparms, parm);
6057 /* Complain about args with incomplete types. */
6058 if (TYPE_SIZE (TREE_TYPE (parm)) == 0)
6060 error_with_decl (parm, "parameter `%s' has incomplete type");
6061 TREE_TYPE (parm) = error_mark_node;
6064 if (DECL_RESULT (parm) == 0)
6066 error_with_decl (parm,
6067 "declaration for parameter `%s' but no such parameter");
6068 /* Pretend the parameter was not missing.
6069 This gets us to a standard state and minimizes
6070 further error messages. */
6072 = chainon (specparms,
6073 tree_cons (parm, NULL_TREE, NULL_TREE));
6080 /* Chain the declarations together in the order of the list of names. */
6081 /* Store that chain in the function decl, replacing the list of names. */
6083 DECL_ARGUMENTS (fndecl) = 0;
6086 for (last = 0; parm; parm = TREE_CHAIN (parm))
6087 if (TREE_PURPOSE (parm))
6090 DECL_ARGUMENTS (fndecl) = TREE_PURPOSE (parm);
6092 TREE_CHAIN (last) = TREE_PURPOSE (parm);
6093 last = TREE_PURPOSE (parm);
6094 TREE_CHAIN (last) = 0;
6098 /* If there was a previous prototype,
6099 set the DECL_ARG_TYPE of each argument according to
6100 the type previously specified, and report any mismatches. */
6102 if (TYPE_ARG_TYPES (TREE_TYPE (fndecl)))
6105 for (parm = DECL_ARGUMENTS (fndecl),
6106 type = TYPE_ARG_TYPES (TREE_TYPE (fndecl));
6107 parm || (type && (TYPE_MAIN_VARIANT (TREE_VALUE (type))
6108 != void_type_node));
6109 parm = TREE_CHAIN (parm), type = TREE_CHAIN (type))
6111 if (parm == 0 || type == 0
6112 || TYPE_MAIN_VARIANT (TREE_VALUE (type)) == void_type_node)
6114 error ("number of arguments doesn't match prototype");
6115 error_with_file_and_line (current_function_prototype_file,
6116 current_function_prototype_line,
6117 "prototype declaration");
6120 /* Type for passing arg must be consistent
6121 with that declared for the arg. */
6122 if (! comptypes (DECL_ARG_TYPE (parm), TREE_VALUE (type)))
6124 if (TYPE_MAIN_VARIANT (TREE_TYPE (parm))
6125 == TYPE_MAIN_VARIANT (TREE_VALUE (type)))
6127 /* Adjust argument to match prototype. E.g. a previous
6128 `int foo(float);' prototype causes
6129 `int foo(x) float x; {...}' to be treated like
6130 `int foo(float x) {...}'. This is particularly
6131 useful for argument types like uid_t. */
6132 DECL_ARG_TYPE (parm) = TREE_TYPE (parm);
6134 if (PROMOTE_PROTOTYPES
6135 && (TREE_CODE (TREE_TYPE (parm)) == INTEGER_TYPE
6136 || TREE_CODE (TREE_TYPE (parm)) == ENUMERAL_TYPE)
6137 && TYPE_PRECISION (TREE_TYPE (parm))
6138 < TYPE_PRECISION (integer_type_node))
6139 DECL_ARG_TYPE (parm) = integer_type_node;
6143 pedwarn ("promoted argument `%s' doesn't match prototype",
6144 IDENTIFIER_POINTER (DECL_NAME (parm)));
6145 warning_with_file_and_line
6146 (current_function_prototype_file,
6147 current_function_prototype_line,
6148 "prototype declaration");
6151 /* If -traditional, allow `int' argument to match
6152 `unsigned' prototype. */
6153 else if (! (flag_traditional
6154 && TYPE_MAIN_VARIANT (TREE_TYPE (parm)) == integer_type_node
6155 && TYPE_MAIN_VARIANT (TREE_VALUE (type)) == unsigned_type_node))
6157 error ("argument `%s' doesn't match prototype",
6158 IDENTIFIER_POINTER (DECL_NAME (parm)));
6159 error_with_file_and_line (current_function_prototype_file,
6160 current_function_prototype_line,
6161 "prototype declaration");
6165 TYPE_ACTUAL_ARG_TYPES (TREE_TYPE (fndecl)) = 0;
6168 /* Otherwise, create a prototype that would match. */
6172 tree actual = 0, last = 0, type;
6174 for (parm = DECL_ARGUMENTS (fndecl); parm; parm = TREE_CHAIN (parm))
6176 type = tree_cons (NULL_TREE, DECL_ARG_TYPE (parm), NULL_TREE);
6178 TREE_CHAIN (last) = type;
6183 type = tree_cons (NULL_TREE, void_type_node, NULL_TREE);
6185 TREE_CHAIN (last) = type;
6189 /* We are going to assign a new value for the TYPE_ACTUAL_ARG_TYPES
6190 of the type of this function, but we need to avoid having this
6191 affect the types of other similarly-typed functions, so we must
6192 first force the generation of an identical (but separate) type
6193 node for the relevant function type. The new node we create
6194 will be a variant of the main variant of the original function
6197 TREE_TYPE (fndecl) = build_type_copy (TREE_TYPE (fndecl));
6199 TYPE_ACTUAL_ARG_TYPES (TREE_TYPE (fndecl)) = actual;
6202 /* Now store the final chain of decls for the arguments
6203 as the decl-chain of the current lexical scope.
6204 Put the enumerators in as well, at the front so that
6205 DECL_ARGUMENTS is not modified. */
6207 storedecls (chainon (nonparms, DECL_ARGUMENTS (fndecl)));
6210 /* Make sure the binding level for the top of the function body
6211 gets a BLOCK if there are any in the function.
6212 Otherwise, the dbx output is wrong. */
6214 keep_next_if_subblocks = 1;
6216 /* ??? This might be an improvement,
6217 but needs to be thought about some more. */
6219 keep_next_level_flag = 1;
6222 /* Write a record describing this function definition to the prototypes
6223 file (if requested). */
6225 gen_aux_info_record (fndecl, 1, 0, prototype);
6227 /* Initialize the RTL code for the function. */
6229 init_function_start (fndecl, input_filename, lineno);
6231 /* If this is a varargs function, inform function.c. */
6233 if (c_function_varargs)
6236 /* Declare __FUNCTION__ and __PRETTY_FUNCTION__ for this function. */
6238 declare_function_name ();
6240 /* Set up parameters and prepare for return, for the function. */
6242 expand_function_start (fndecl, 0);
6244 /* If this function is `main', emit a call to `__main'
6245 to run global initializers, etc. */
6246 if (DECL_NAME (fndecl)
6247 && strcmp (IDENTIFIER_POINTER (DECL_NAME (fndecl)), "main") == 0
6248 && DECL_CONTEXT (fndecl) == NULL_TREE)
6249 expand_main_function ();
6252 /* SPECPARMS is an identifier list--a chain of TREE_LIST nodes
6253 each with a parm name as the TREE_VALUE. A null pointer as TREE_VALUE
6254 stands for an ellipsis in the identifier list.
6256 PARMLIST is the data returned by get_parm_info for the
6257 parmlist that follows the semicolon.
6259 We return a value of the same sort that get_parm_info returns,
6260 except that it describes the combination of identifiers and parmlist. */
6263 combine_parm_decls (specparms, parmlist, void_at_end)
6264 tree specparms, parmlist;
6267 register tree fndecl = current_function_decl;
6270 tree parmdecls = TREE_PURPOSE (parmlist);
6272 /* This is a chain of any other decls that came in among the parm
6273 declarations. They were separated already by get_parm_info,
6274 so we just need to keep them separate. */
6275 tree nonparms = TREE_VALUE (parmlist);
6279 for (parm = parmdecls; parm; parm = TREE_CHAIN (parm))
6280 DECL_RESULT (parm) = 0;
6282 for (parm = specparms; parm; parm = TREE_CHAIN (parm))
6284 register tree tail, found = NULL;
6286 /* See if any of the parmdecls specifies this parm by name. */
6287 for (tail = parmdecls; tail; tail = TREE_CHAIN (tail))
6288 if (DECL_NAME (tail) == TREE_VALUE (parm))
6294 /* If declaration already marked, we have a duplicate name.
6295 Complain, and don't use this decl twice. */
6296 if (found && DECL_RESULT (found) != 0)
6298 error_with_decl (found, "multiple parameters named `%s'");
6302 /* If the declaration says "void", complain and ignore it. */
6303 if (found && TYPE_MAIN_VARIANT (TREE_TYPE (found)) == void_type_node)
6305 error_with_decl (found, "parameter `%s' declared void");
6306 TREE_TYPE (found) = integer_type_node;
6307 DECL_ARG_TYPE (found) = integer_type_node;
6308 layout_decl (found, 0);
6311 /* Traditionally, a parm declared float is actually a double. */
6312 if (found && flag_traditional
6313 && TYPE_MAIN_VARIANT (TREE_TYPE (found)) == float_type_node)
6315 TREE_TYPE (found) = double_type_node;
6316 DECL_ARG_TYPE (found) = double_type_node;
6317 layout_decl (found, 0);
6320 /* If no declaration found, default to int. */
6323 found = build_decl (PARM_DECL, TREE_VALUE (parm),
6325 DECL_ARG_TYPE (found) = TREE_TYPE (found);
6326 DECL_SOURCE_LINE (found) = DECL_SOURCE_LINE (fndecl);
6327 DECL_SOURCE_FILE (found) = DECL_SOURCE_FILE (fndecl);
6328 error_with_decl (found, "type of parameter `%s' is not declared");
6332 TREE_PURPOSE (parm) = found;
6334 /* Mark this decl as "already found" -- see test, above.
6335 It is safe to use DECL_RESULT for this
6336 since it is not used in PARM_DECLs or CONST_DECLs. */
6337 DECL_RESULT (found) = error_mark_node;
6340 /* Complain about any actual PARM_DECLs not matched with any names. */
6342 for (parm = parmdecls; parm; )
6344 tree next = TREE_CHAIN (parm);
6345 TREE_CHAIN (parm) = 0;
6347 /* Complain about args with incomplete types. */
6348 if (TYPE_SIZE (TREE_TYPE (parm)) == 0)
6350 error_with_decl (parm, "parameter `%s' has incomplete type");
6351 TREE_TYPE (parm) = error_mark_node;
6354 if (DECL_RESULT (parm) == 0)
6356 error_with_decl (parm,
6357 "declaration for parameter `%s' but no such parameter");
6358 /* Pretend the parameter was not missing.
6359 This gets us to a standard state and minimizes
6360 further error messages. */
6362 = chainon (specparms,
6363 tree_cons (parm, NULL_TREE, NULL_TREE));
6369 /* Chain the declarations together in the order of the list of names.
6370 At the same time, build up a list of their types, in reverse order. */
6376 for (last = 0; parm; parm = TREE_CHAIN (parm))
6377 if (TREE_PURPOSE (parm))
6380 parmdecls = TREE_PURPOSE (parm);
6382 TREE_CHAIN (last) = TREE_PURPOSE (parm);
6383 last = TREE_PURPOSE (parm);
6384 TREE_CHAIN (last) = 0;
6386 types = tree_cons (NULL_TREE, TREE_TYPE (parm), types);
6391 return tree_cons (parmdecls, nonparms,
6392 nreverse (tree_cons (NULL_TREE, void_type_node, types)));
6394 return tree_cons (parmdecls, nonparms, nreverse (types));
6397 /* Finish up a function declaration and compile that function
6398 all the way to assembler language output. The free the storage
6399 for the function definition.
6401 This is called after parsing the body of the function definition.
6403 NESTED is nonzero if the function being finished is nested in another. */
6406 finish_function (nested)
6409 register tree fndecl = current_function_decl;
6411 /* TREE_READONLY (fndecl) = 1;
6412 This caused &foo to be of type ptr-to-const-function
6413 which then got a warning when stored in a ptr-to-function variable. */
6416 BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl)) = fndecl;
6418 /* Must mark the RESULT_DECL as being in this function. */
6420 DECL_CONTEXT (DECL_RESULT (fndecl)) = fndecl;
6422 /* Obey `register' declarations if `setjmp' is called in this fn. */
6423 if (flag_traditional && current_function_calls_setjmp)
6425 setjmp_protect (DECL_INITIAL (fndecl));
6426 setjmp_protect_args ();
6429 if (! strcmp (IDENTIFIER_POINTER (DECL_NAME (fndecl)), "main"))
6431 if (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (fndecl)))
6432 != integer_type_node)
6434 /* If warn_main is 1 (-Wmain) or 2 (-Wall), we have already warned.
6435 If warn_main is -1 (-Wno-main) we don't want to be warned. */
6437 pedwarn_with_decl (fndecl, "return type of `%s' is not `int'");
6441 #ifdef DEFAULT_MAIN_RETURN
6442 /* Make it so that `main' always returns success by default. */
6443 DEFAULT_MAIN_RETURN;
6448 /* Generate rtl for function exit. */
6449 expand_function_end (input_filename, lineno, 0);
6451 /* So we can tell if jump_optimize sets it to 1. */
6454 /* If this is a nested function, protect the local variables in the stack
6455 above us from being collected while we're compiling this function. */
6457 ggc_push_context ();
6459 /* Run the optimizers and output the assembler code for this function. */
6460 rest_of_compilation (fndecl);
6462 /* Undo the GC context switch. */
6466 current_function_returns_null |= can_reach_end;
6468 if (warn_missing_noreturn
6469 && !TREE_THIS_VOLATILE (fndecl)
6470 && !current_function_returns_null
6471 && !current_function_returns_value)
6472 warning ("function might be possible candidate for attribute `noreturn'");
6474 if (TREE_THIS_VOLATILE (fndecl) && current_function_returns_null)
6475 warning ("`noreturn' function does return");
6476 else if (warn_return_type && can_reach_end
6477 && TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (fndecl))) != void_type_node)
6478 /* If this function returns non-void and control can drop through,
6480 warning ("control reaches end of non-void function");
6481 /* With just -W, complain only if function returns both with
6482 and without a value. */
6483 else if (extra_warnings
6484 && current_function_returns_value && current_function_returns_null)
6485 warning ("this function may return with or without a value");
6487 /* If requested, warn about function definitions where the function will
6488 return a value (usually of some struct or union type) which itself will
6489 take up a lot of stack space. */
6491 if (warn_larger_than && !DECL_EXTERNAL (fndecl) && TREE_TYPE (fndecl))
6493 register tree ret_type = TREE_TYPE (TREE_TYPE (fndecl));
6497 register tree ret_type_size = TYPE_SIZE (ret_type);
6499 if (TREE_CODE (ret_type_size) == INTEGER_CST)
6502 = TREE_INT_CST_LOW (ret_type_size) / BITS_PER_UNIT;
6504 if (units > larger_than_size)
6505 warning_with_decl (fndecl,
6506 "size of return value of `%s' is %u bytes",
6512 if (DECL_SAVED_INSNS (fndecl) == 0 && ! nested)
6514 /* Stop pointing to the local nodes about to be freed. */
6515 /* But DECL_INITIAL must remain nonzero so we know this
6516 was an actual function definition. */
6517 /* For a nested function, this is done in pop_c_function_context. */
6518 /* If rest_of_compilation set this to 0, leave it 0. */
6519 if (DECL_INITIAL (fndecl) != 0)
6520 DECL_INITIAL (fndecl) = error_mark_node;
6521 DECL_ARGUMENTS (fndecl) = 0;
6524 if (DECL_STATIC_CONSTRUCTOR (fndecl))
6526 #ifndef ASM_OUTPUT_CONSTRUCTOR
6527 if (! flag_gnu_linker)
6528 static_ctors = tree_cons (NULL_TREE, fndecl, static_ctors);
6531 assemble_constructor (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (fndecl)));
6534 if (DECL_STATIC_DESTRUCTOR (fndecl))
6536 #ifndef ASM_OUTPUT_DESTRUCTOR
6537 if (! flag_gnu_linker)
6538 static_dtors = tree_cons (NULL_TREE, fndecl, static_dtors);
6541 assemble_destructor (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (fndecl)));
6546 /* Let the error reporting routines know that we're outside a
6547 function. For a nested function, this value is used in
6548 pop_c_function_context and then reset via pop_function_context. */
6549 current_function_decl = NULL;
6553 /* Save and restore the variables in this file and elsewhere
6554 that keep track of the progress of compilation of the current function.
6555 Used for nested functions. */
6557 struct language_function
6560 tree shadowed_labels;
6563 int warn_about_return_type;
6565 struct binding_level *binding_level;
6568 /* Save and reinitialize the variables
6569 used during compilation of a C function. */
6572 push_c_function_context (f)
6575 struct language_function *p;
6576 p = (struct language_function *) xmalloc (sizeof (struct language_function));
6579 p->named_labels = named_labels;
6580 p->shadowed_labels = shadowed_labels;
6581 p->returns_value = current_function_returns_value;
6582 p->returns_null = current_function_returns_null;
6583 p->warn_about_return_type = warn_about_return_type;
6584 p->extern_inline = current_extern_inline;
6585 p->binding_level = current_binding_level;
6588 /* Restore the variables used during compilation of a C function. */
6591 pop_c_function_context (f)
6594 struct language_function *p = f->language;
6597 /* Bring back all the labels that were shadowed. */
6598 for (link = shadowed_labels; link; link = TREE_CHAIN (link))
6599 if (DECL_NAME (TREE_VALUE (link)) != 0)
6600 IDENTIFIER_LABEL_VALUE (DECL_NAME (TREE_VALUE (link)))
6601 = TREE_VALUE (link);
6603 if (DECL_SAVED_INSNS (current_function_decl) == 0)
6605 /* Stop pointing to the local nodes about to be freed. */
6606 /* But DECL_INITIAL must remain nonzero so we know this
6607 was an actual function definition. */
6608 DECL_INITIAL (current_function_decl) = error_mark_node;
6609 DECL_ARGUMENTS (current_function_decl) = 0;
6612 named_labels = p->named_labels;
6613 shadowed_labels = p->shadowed_labels;
6614 current_function_returns_value = p->returns_value;
6615 current_function_returns_null = p->returns_null;
6616 warn_about_return_type = p->warn_about_return_type;
6617 current_extern_inline = p->extern_inline;
6618 current_binding_level = p->binding_level;
6624 /* Mark the language specific parts of F for GC. */
6626 mark_c_function_context (f)
6629 struct language_function *p = f->language;
6634 ggc_mark_tree (p->shadowed_labels);
6635 ggc_mark_tree (p->named_labels);
6636 mark_binding_level (&p->binding_level);
6639 /* integrate_decl_tree calls this function, but since we don't use the
6640 DECL_LANG_SPECIFIC field, this is a no-op. */
6643 copy_lang_decl (node)
6644 tree node ATTRIBUTE_UNUSED;
6648 /* Mark ARG for GC. */
6650 lang_mark_false_label_stack (arg)
6651 struct label_node *arg;
6653 /* C doesn't use false_label_stack. It better be NULL. */
6658 /* Mark the language specific bits in T for GC. */
6663 if (TREE_CODE (t) == IDENTIFIER_NODE)
6665 struct lang_identifier *i = (struct lang_identifier *) t;
6666 ggc_mark_tree (i->global_value);
6667 ggc_mark_tree (i->local_value);
6668 ggc_mark_tree (i->label_value);
6669 ggc_mark_tree (i->implicit_decl);
6670 ggc_mark_tree (i->error_locus);
6671 ggc_mark_tree (i->limbo_value);
6673 else if (TYPE_P (t) && TYPE_LANG_SPECIFIC (t))
6674 ggc_mark (TYPE_LANG_SPECIFIC (t));