1 /* Process declarations and variables for C compiler.
2 Copyright (C) 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
3 2001, 2002 Free Software Foundation, Inc.
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify it under
8 the terms of the GNU General Public License as published by the Free
9 Software Foundation; either version 2, or (at your option) any later
12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING. If not, write to the Free
19 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
22 /* Process declarations and symbol lookup for C front end.
23 Also constructs types; the standard scalar types at initialization,
24 and structure, union, array and enum types when they are declared. */
26 /* ??? not all decl nodes are given the most useful possible
27 line numbers. For example, the CONST_DECLs for enum values. */
33 #include "tree-inline.h"
51 /* In grokdeclarator, distinguish syntactic contexts of declarators. */
53 { NORMAL, /* Ordinary declaration */
54 FUNCDEF, /* Function definition */
55 PARM, /* Declaration of parm before function body */
56 FIELD, /* Declaration inside struct or union */
57 BITFIELD, /* Likewise but with specified width */
58 TYPENAME}; /* Typename (inside cast or sizeof) */
61 /* Nonzero if we have seen an invalid cross reference
62 to a struct, union, or enum, but not yet printed the message. */
64 tree pending_invalid_xref;
65 /* File and line to appear in the eventual error message. */
66 const char *pending_invalid_xref_file;
67 int pending_invalid_xref_line;
69 /* While defining an enum type, this is 1 plus the last enumerator
70 constant value. Note that will do not have to save this or `enum_overflow'
71 around nested function definition since such a definition could only
72 occur in an enum value expression and we don't use these variables in
75 static tree enum_next_value;
77 /* Nonzero means that there was overflow computing enum_next_value. */
79 static int enum_overflow;
81 /* Parsing a function declarator leaves a list of parameter names
82 or a chain or parameter decls here. */
84 static tree last_function_parms;
86 /* Parsing a function declarator leaves here a chain of structure
87 and enum types declared in the parmlist. */
89 static tree last_function_parm_tags;
91 /* After parsing the declarator that starts a function definition,
92 `start_function' puts here the list of parameter names or chain of decls.
93 `store_parm_decls' finds it here. */
95 static tree current_function_parms;
97 /* Similar, for last_function_parm_tags. */
98 static tree current_function_parm_tags;
100 /* Similar, for the file and line that the prototype came from if this is
101 an old-style definition. */
102 static const char *current_function_prototype_file;
103 static int current_function_prototype_line;
105 /* The current statement tree. */
107 static struct stmt_tree_s c_stmt_tree;
109 /* The current scope statement stack. */
111 static tree c_scope_stmt_stack;
113 /* A list (chain of TREE_LIST nodes) of all LABEL_DECLs in the function
114 that have names. Here so we can clear out their names' definitions
115 at the end of the function. */
117 static tree named_labels;
119 /* A list of LABEL_DECLs from outer contexts that are currently shadowed. */
121 static tree shadowed_labels;
123 /* Nonzero when store_parm_decls is called indicates a varargs function.
124 Value not meaningful after store_parm_decls. */
126 static int c_function_varargs;
128 /* Set to 0 at beginning of a function definition, set to 1 if
129 a return statement that specifies a return value is seen. */
131 int current_function_returns_value;
133 /* Set to 0 at beginning of a function definition, set to 1 if
134 a return statement with no argument is seen. */
136 int current_function_returns_null;
138 /* Set to 0 at beginning of a function definition, set to 1 if
139 a call to a noreturn function is seen. */
141 int current_function_returns_abnormally;
143 /* Set to nonzero by `grokdeclarator' for a function
144 whose return type is defaulted, if warnings for this are desired. */
146 static int warn_about_return_type;
148 /* Nonzero when starting a function declared `extern inline'. */
150 static int current_extern_inline;
152 /* For each binding contour we allocate a binding_level structure
153 * which records the names defined in that contour.
156 * 1) one for each function definition,
157 * where internal declarations of the parameters appear.
158 * 2) one for each compound statement,
159 * to record its declarations.
161 * The current meaning of a name can be found by searching the levels from
162 * the current one out to the global one.
165 /* Note that the information in the `names' component of the global contour
166 is duplicated in the IDENTIFIER_GLOBAL_VALUEs of all identifiers. */
170 /* A chain of _DECL nodes for all variables, constants, functions,
171 and typedef types. These are in the reverse of the order supplied.
175 /* A list of structure, union and enum definitions,
176 * for looking up tag names.
177 * It is a chain of TREE_LIST nodes, each of whose TREE_PURPOSE is a name,
178 * or NULL_TREE; and whose TREE_VALUE is a RECORD_TYPE, UNION_TYPE,
179 * or ENUMERAL_TYPE node.
183 /* For each level, a list of shadowed outer-level local definitions
184 to be restored when this level is popped.
185 Each link is a TREE_LIST whose TREE_PURPOSE is an identifier and
186 whose TREE_VALUE is its old definition (a kind of ..._DECL node). */
189 /* For each level (except not the global one),
190 a chain of BLOCK nodes for all the levels
191 that were entered and exited one level down. */
194 /* The BLOCK node for this level, if one has been preallocated.
195 If 0, the BLOCK is allocated (if needed) when the level is popped. */
198 /* The binding level which this one is contained in (inherits from). */
199 struct binding_level *level_chain;
201 /* Nonzero for the level that holds the parameters of a function. */
204 /* Nonzero if this level "doesn't exist" for tags. */
205 char tag_transparent;
207 /* Nonzero if sublevels of this level "don't exist" for tags.
208 This is set in the parm level of a function definition
209 while reading the function body, so that the outermost block
210 of the function body will be tag-transparent. */
211 char subblocks_tag_transparent;
213 /* Nonzero means make a BLOCK for this level regardless of all else. */
216 /* Nonzero means make a BLOCK if this level has any subblocks. */
217 char keep_if_subblocks;
219 /* Number of decls in `names' that have incomplete
220 structure or union types. */
223 /* A list of decls giving the (reversed) specified order of parms,
224 not including any forward-decls in the parmlist.
225 This is so we can put the parms in proper order for assign_parms. */
229 #define NULL_BINDING_LEVEL (struct binding_level *) NULL
231 /* The binding level currently in effect. */
233 static struct binding_level *current_binding_level;
235 /* A chain of binding_level structures awaiting reuse. */
237 static struct binding_level *free_binding_level;
239 /* The outermost binding level, for names of file scope.
240 This is created when the compiler is started and exists
241 through the entire run. */
243 static struct binding_level *global_binding_level;
245 /* Binding level structures are initialized by copying this one. */
247 static struct binding_level clear_binding_level
248 = {NULL, NULL, NULL, NULL, NULL, NULL_BINDING_LEVEL, 0, 0, 0, 0, 0, 0,
251 /* Nonzero means unconditionally make a BLOCK for the next level pushed. */
253 static int keep_next_level_flag;
255 /* Nonzero means make a BLOCK for the next level pushed
256 if it has subblocks. */
258 static int keep_next_if_subblocks;
260 /* The chain of outer levels of label scopes.
261 This uses the same data structure used for binding levels,
262 but it works differently: each link in the chain records
263 saved values of named_labels and shadowed_labels for
264 a label binding level outside the current one. */
266 static struct binding_level *label_level_chain;
268 /* Functions called automatically at the beginning and end of execution. */
270 tree static_ctors, static_dtors;
272 /* Forward declarations. */
274 static struct binding_level * make_binding_level PARAMS ((void));
275 static void mark_binding_level PARAMS ((void *));
276 static void clear_limbo_values PARAMS ((tree));
277 static int duplicate_decls PARAMS ((tree, tree, int));
278 static int redeclaration_error_message PARAMS ((tree, tree));
279 static void storedecls PARAMS ((tree));
280 static void storetags PARAMS ((tree));
281 static tree lookup_tag PARAMS ((enum tree_code, tree,
282 struct binding_level *, int));
283 static tree lookup_tag_reverse PARAMS ((tree));
284 static tree grokdeclarator PARAMS ((tree, tree, enum decl_context,
286 static tree grokparms PARAMS ((tree, int));
287 static void layout_array_type PARAMS ((tree));
288 static tree c_make_fname_decl PARAMS ((tree, int));
289 static void c_expand_body PARAMS ((tree, int, int));
290 static void warn_if_shadowing PARAMS ((tree, tree));
292 /* C-specific option variables. */
294 /* Nonzero means allow type mismatches in conditional expressions;
295 just make their values `void'. */
297 int flag_cond_mismatch;
299 /* Nonzero means don't recognize the keyword `asm'. */
303 /* Nonzero means enable C89 Amendment 1 features. */
307 /* Nonzero means use the ISO C99 dialect of C. */
311 /* Nonzero means that we have builtin functions, and main is an int */
315 /* Nonzero means add default format_arg attributes for functions not
318 int flag_noniso_default_format_attributes = 1;
320 /* Nonzero means to treat bitfields as signed unless they say `unsigned'. */
322 int flag_signed_bitfields = 1;
323 int explicit_flag_signed_bitfields = 0;
325 /* Nonzero means warn about use of implicit int. */
327 int warn_implicit_int;
329 /* Nonzero means warn about usage of long long when `-pedantic'. */
331 int warn_long_long = 1;
333 /* Nonzero means message about use of implicit function declarations;
334 1 means warning; 2 means error. */
336 int mesg_implicit_function_declaration = -1;
338 /* Nonzero means give string constants the type `const char *'
339 to get extra warnings from them. These warnings will be too numerous
340 to be useful, except in thoroughly ANSIfied programs. */
342 int flag_const_strings;
344 /* Nonzero means warn about pointer casts that can drop a type qualifier
345 from the pointer target type. */
349 /* Nonzero means warn when casting a function call to a type that does
350 not match the return type (e.g. (float)sqrt() or (anything*)malloc()
351 when there is no previous declaration of sqrt or malloc. */
353 int warn_bad_function_cast;
355 /* Warn about functions which might be candidates for format attributes. */
357 int warn_missing_format_attribute;
359 /* Warn about traditional constructs whose meanings changed in ANSI C. */
361 int warn_traditional;
363 /* Nonzero means warn about sizeof(function) or addition/subtraction
364 of function pointers. */
366 int warn_pointer_arith;
368 /* Nonzero means warn for non-prototype function decls
369 or non-prototyped defs without previous prototype. */
371 int warn_strict_prototypes;
373 /* Nonzero means warn for any global function def
374 without separate previous prototype decl. */
376 int warn_missing_prototypes;
378 /* Nonzero means warn for any global function def
379 without separate previous decl. */
381 int warn_missing_declarations;
383 /* Nonzero means warn about multiple (redundant) decls for the same single
384 variable or function. */
386 int warn_redundant_decls = 0;
388 /* Nonzero means warn about extern declarations of objects not at
389 file-scope level and about *all* declarations of functions (whether
390 extern or static) not at file-scope level. Note that we exclude
391 implicit function declarations. To get warnings about those, use
394 int warn_nested_externs = 0;
396 /* Warn about a subscript that has type char. */
398 int warn_char_subscripts = 0;
400 /* Warn if a type conversion is done that might have confusing results. */
404 /* Warn if adding () is suggested. */
406 int warn_parentheses;
408 /* Warn if initializer is not completely bracketed. */
410 int warn_missing_braces;
412 /* Warn if main is suspicious. */
416 /* Warn about #pragma directives that are not recognised. */
418 int warn_unknown_pragmas = 0; /* Tri state variable. */
420 /* Warn about comparison of signed and unsigned values.
421 If -1, neither -Wsign-compare nor -Wno-sign-compare has been specified. */
423 int warn_sign_compare = -1;
425 /* Warn about testing equality of floating point numbers. */
427 int warn_float_equal = 0;
429 /* Nonzero means warn about use of multicharacter literals. */
431 int warn_multichar = 1;
433 /* Nonzero means `$' can be in an identifier. */
435 #ifndef DOLLARS_IN_IDENTIFIERS
436 #define DOLLARS_IN_IDENTIFIERS 1
438 int dollars_in_ident = DOLLARS_IN_IDENTIFIERS;
440 /* States indicating how grokdeclarator() should handle declspecs marked
441 with __attribute__((deprecated)). An object declared as
442 __attribute__((deprecated)) suppresses warnings of uses of other
445 enum deprecated_states {
450 static enum deprecated_states deprecated_state = DEPRECATED_NORMAL;
452 /* Decode the string P as a language-specific option for C.
453 Return the number of strings consumed. Should not complain
454 if it does not recognise the option. */
457 c_decode_option (argc, argv)
458 int argc ATTRIBUTE_UNUSED;
461 int strings_processed;
464 static const struct {
465 /* The name of the option. */
467 /* If non-NULL, a flag variable to set to 0 or 1. If NULL,
468 this means that cpp handles this option. */
471 /* This list is in alphabetical order. Keep it like that. */
472 { "bad-function-cast", &warn_bad_function_cast },
473 { "cast-qual", &warn_cast_qual },
474 { "char-subscripts", &warn_char_subscripts },
476 { "comments", NULL },
477 { "conversion", &warn_conversion },
478 { "div-by-zero", &warn_div_by_zero },
479 { "float-equal", &warn_float_equal },
480 { "format-extra-args", &warn_format_extra_args },
481 { "format-nonliteral", &warn_format_nonliteral },
482 { "format-security", &warn_format_security },
483 { "format-y2k", &warn_format_y2k },
484 { "implicit-function-declaration", &mesg_implicit_function_declaration },
485 { "implicit-int", &warn_implicit_int },
487 { "long-long", &warn_long_long },
488 { "main", &warn_main },
489 { "missing-braces", &warn_missing_braces },
490 { "missing-declarations", &warn_missing_declarations },
491 { "missing-format-attribute", &warn_missing_format_attribute },
492 { "missing-prototypes", &warn_missing_prototypes },
493 { "multichar", &warn_multichar },
494 { "nested-externs", &warn_nested_externs },
495 { "parentheses", &warn_parentheses },
496 { "pointer-arith", &warn_pointer_arith },
497 { "redundant-decls", &warn_redundant_decls },
498 { "return-type", &warn_return_type },
499 { "sequence-point", &warn_sequence_point },
500 { "sign-compare", &warn_sign_compare },
501 { "strict-prototypes", &warn_strict_prototypes },
502 { "traditional", &warn_traditional },
503 { "trigraphs", NULL },
505 { "write-strings", &flag_const_strings }
508 strings_processed = cpp_handle_option (parse_in, argc, argv, 0);
510 if (!strcmp (p, "-fhosted") || !strcmp (p, "-fno-freestanding"))
515 else if (!strcmp (p, "-ffreestanding") || !strcmp (p, "-fno-hosted"))
519 /* warn_main will be 2 if set by -Wall, 1 if set by -Wmain */
523 else if (!strncmp (p, "-std=", 5))
525 /* Select the appropriate language standard. We currently
527 -std=iso9899:1990 same as -ansi
528 -std=iso9899:199409 ISO C as modified in amend. 1
529 -std=iso9899:1999 ISO C 99
530 -std=c89 same as -std=iso9899:1990
531 -std=c99 same as -std=iso9899:1999
532 -std=gnu89 default, iso9899:1990 + gnu extensions
533 -std=gnu99 iso9899:1999 + gnu extensions
535 const char *const argstart = &p[5];
537 if (!strcmp (argstart, "iso9899:1990")
538 || !strcmp (argstart, "c89"))
543 flag_writable_strings = 0;
545 flag_no_nonansi_builtin = 1;
546 flag_noniso_default_format_attributes = 0;
549 else if (!strcmp (argstart, "iso9899:199409"))
554 else if (!strcmp (argstart, "iso9899:199x")
555 || !strcmp (argstart, "iso9899:1999")
556 || !strcmp (argstart, "c9x")
557 || !strcmp (argstart, "c99"))
559 flag_writable_strings = 0;
561 flag_no_nonansi_builtin = 1;
562 flag_noniso_default_format_attributes = 0;
566 else if (!strcmp (argstart, "gnu89"))
568 flag_writable_strings = 0;
570 flag_no_nonansi_builtin = 0;
571 flag_noniso_default_format_attributes = 1;
575 else if (!strcmp (argstart, "gnu9x") || !strcmp (argstart, "gnu99"))
577 flag_writable_strings = 0;
579 flag_no_nonansi_builtin = 0;
580 flag_noniso_default_format_attributes = 1;
584 else if (!strcmp (argstart, "c++98"))
585 ; /* Handled by cpplib. */
587 error ("unknown C standard `%s'", argstart);
589 else if (!strcmp (p, "-fdollars-in-identifiers"))
590 dollars_in_ident = 1;
591 else if (!strcmp (p, "-fno-dollars-in-identifiers"))
592 dollars_in_ident = 0;
593 else if (!strcmp (p, "-fsigned-char"))
594 flag_signed_char = 1;
595 else if (!strcmp (p, "-funsigned-char"))
596 flag_signed_char = 0;
597 else if (!strcmp (p, "-fno-signed-char"))
598 flag_signed_char = 0;
599 else if (!strcmp (p, "-fno-unsigned-char"))
600 flag_signed_char = 1;
601 else if (!strcmp (p, "-fsigned-bitfields")
602 || !strcmp (p, "-fno-unsigned-bitfields"))
604 flag_signed_bitfields = 1;
605 explicit_flag_signed_bitfields = 1;
607 else if (!strcmp (p, "-funsigned-bitfields")
608 || !strcmp (p, "-fno-signed-bitfields"))
610 flag_signed_bitfields = 0;
611 explicit_flag_signed_bitfields = 1;
613 else if (!strcmp (p, "-fshort-enums"))
614 flag_short_enums = 1;
615 else if (!strcmp (p, "-fno-short-enums"))
616 flag_short_enums = 0;
617 else if (!strcmp (p, "-fshort-wchar"))
618 flag_short_wchar = 1;
619 else if (!strcmp (p, "-fno-short-wchar"))
620 flag_short_wchar = 0;
621 else if (!strcmp (p, "-fcond-mismatch"))
622 flag_cond_mismatch = 1;
623 else if (!strcmp (p, "-fno-cond-mismatch"))
624 flag_cond_mismatch = 0;
625 else if (!strcmp (p, "-fshort-double"))
626 flag_short_double = 1;
627 else if (!strcmp (p, "-fno-short-double"))
628 flag_short_double = 0;
629 else if (!strcmp (p, "-fasm"))
631 else if (!strcmp (p, "-fno-asm"))
633 else if (!strcmp (p, "-fbuiltin"))
635 else if (!strcmp (p, "-fno-builtin"))
637 else if (!strncmp (p, "-fno-builtin-", strlen ("-fno-builtin-")))
638 disable_builtin_function (p + strlen ("-fno-builtin-"));
639 else if (p[0] == '-' && p[1] == 'f' && dump_switch_p (p + 2))
641 else if (!strcmp (p, "-ansi"))
643 else if (!strcmp (p, "-Werror-implicit-function-declaration"))
644 mesg_implicit_function_declaration = 2;
645 else if (!strncmp (p, "-Wformat=", 9))
646 set_Wformat (atoi (p + 9));
647 else if (!strcmp (p, "-Wformat"))
649 else if (!strcmp (p, "-Wno-format"))
651 else if (!strcmp (p, "-Wimplicit"))
653 warn_implicit_int = 1;
654 if (mesg_implicit_function_declaration != 2)
655 mesg_implicit_function_declaration = 1;
657 else if (!strcmp (p, "-Wno-implicit"))
658 warn_implicit_int = 0, mesg_implicit_function_declaration = 0;
659 else if (!strcmp (p, "-Wno-main"))
661 else if (!strcmp (p, "-Wunknown-pragmas"))
662 /* Set to greater than 1, so that even unknown pragmas in system
663 headers will be warned about. */
664 warn_unknown_pragmas = 2;
665 else if (!strcmp (p, "-Wno-unknown-pragmas"))
666 warn_unknown_pragmas = 0;
667 else if (!strcmp (p, "-Wall"))
669 /* We save the value of warn_uninitialized, since if they put
670 -Wuninitialized on the command line, we need to generate a
671 warning about not using it without also specifying -O. */
672 if (warn_uninitialized != 1)
673 warn_uninitialized = 2;
674 warn_implicit_int = 1;
675 mesg_implicit_function_declaration = 1;
676 warn_return_type = 1;
680 warn_char_subscripts = 1;
681 warn_parentheses = 1;
682 warn_sequence_point = 1;
683 warn_missing_braces = 1;
684 /* We set this to 2 here, but 1 in -Wmain, so -ffreestanding can turn
685 it off only if it's not explicit. */
687 /* Only warn about unknown pragmas that are not in system headers. */
688 warn_unknown_pragmas = 1;
690 else if (!strcmp (p, "-E"))
691 flag_preprocess_only = 1;
695 for (i = 0; i < sizeof (warn_options) / sizeof (warn_options[0]); i++)
696 if (strncmp (p, "-W", 2) == 0
697 && warn_options[i].flag
698 && (strcmp (p+2, warn_options[i].option) == 0
699 || (strncmp (p+2, "no-", 3) == 0
700 && strcmp (p+5, warn_options[i].option) == 0)))
702 *(warn_options[i].flag) = strncmp (p+2, "no-", 3) != 0;
705 return strings_processed;
712 c_print_identifier (file, node, indent)
717 print_node (file, "global", IDENTIFIER_GLOBAL_VALUE (node), indent + 4);
718 print_node (file, "local", IDENTIFIER_LOCAL_VALUE (node), indent + 4);
719 print_node (file, "label", IDENTIFIER_LABEL_VALUE (node), indent + 4);
720 print_node (file, "implicit", IDENTIFIER_IMPLICIT_DECL (node), indent + 4);
721 print_node (file, "error locus", IDENTIFIER_ERROR_LOCUS (node), indent + 4);
722 print_node (file, "limbo value", IDENTIFIER_LIMBO_VALUE (node), indent + 4);
723 if (C_IS_RESERVED_WORD (node))
725 tree rid = ridpointers[C_RID_CODE (node)];
726 indent_to (file, indent + 4);
727 fprintf (file, "rid ");
728 fprintf (file, HOST_PTR_PRINTF, (void *)rid);
729 fprintf (file, " \"%s\"", IDENTIFIER_POINTER (rid));
733 /* Hook called at end of compilation to assume 1 elt
734 for a top-level tentative array defn that wasn't complete before. */
737 c_finish_incomplete_decl (decl)
740 if (TREE_CODE (decl) == VAR_DECL)
742 tree type = TREE_TYPE (decl);
743 if (type != error_mark_node
744 && TREE_CODE (type) == ARRAY_TYPE
745 && ! DECL_EXTERNAL (decl)
746 && TYPE_DOMAIN (type) == 0)
748 warning_with_decl (decl, "array `%s' assumed to have one element");
750 complete_array_type (type, NULL_TREE, 1);
752 layout_decl (decl, 0);
757 /* Create a new `struct binding_level'. */
759 static struct binding_level *
760 make_binding_level ()
763 return (struct binding_level *) xmalloc (sizeof (struct binding_level));
766 /* Nonzero if we are currently in the global binding level. */
771 return current_binding_level == global_binding_level;
777 keep_next_level_flag = 1;
780 /* Nonzero if the current level needs to have a BLOCK made. */
785 return ((current_binding_level->keep_if_subblocks
786 && current_binding_level->blocks != 0)
787 || current_binding_level->keep
788 || current_binding_level->names != 0
789 || (current_binding_level->tags != 0
790 && !current_binding_level->tag_transparent));
793 /* Identify this binding level as a level of parameters.
794 DEFINITION_FLAG is 1 for a definition, 0 for a declaration.
795 But it turns out there is no way to pass the right value for
796 DEFINITION_FLAG, so we ignore it. */
799 declare_parm_level (definition_flag)
800 int definition_flag ATTRIBUTE_UNUSED;
802 current_binding_level->parm_flag = 1;
805 /* Nonzero if currently making parm declarations. */
810 return current_binding_level->parm_flag;
813 /* Enter a new binding level.
814 If TAG_TRANSPARENT is nonzero, do so only for the name space of variables,
815 not for that of tags. */
818 pushlevel (tag_transparent)
821 struct binding_level *newlevel = NULL_BINDING_LEVEL;
823 /* If this is the top level of a function,
824 just make sure that NAMED_LABELS is 0. */
826 if (current_binding_level == global_binding_level)
831 /* Reuse or create a struct for this binding level. */
833 if (free_binding_level)
835 newlevel = free_binding_level;
836 free_binding_level = free_binding_level->level_chain;
840 newlevel = make_binding_level ();
843 /* Add this level to the front of the chain (stack) of levels that
846 *newlevel = clear_binding_level;
847 newlevel->tag_transparent
849 || (current_binding_level
850 ? current_binding_level->subblocks_tag_transparent
852 newlevel->level_chain = current_binding_level;
853 current_binding_level = newlevel;
854 newlevel->keep = keep_next_level_flag;
855 keep_next_level_flag = 0;
856 newlevel->keep_if_subblocks = keep_next_if_subblocks;
857 keep_next_if_subblocks = 0;
860 /* Clear the limbo values of all identifiers defined in BLOCK or a subblock. */
863 clear_limbo_values (block)
868 for (tem = BLOCK_VARS (block); tem; tem = TREE_CHAIN (tem))
869 if (DECL_NAME (tem) != 0)
870 IDENTIFIER_LIMBO_VALUE (DECL_NAME (tem)) = 0;
872 for (tem = BLOCK_SUBBLOCKS (block); tem; tem = TREE_CHAIN (tem))
873 clear_limbo_values (tem);
876 /* Exit a binding level.
877 Pop the level off, and restore the state of the identifier-decl mappings
878 that were in effect when this level was entered.
880 If KEEP is nonzero, this level had explicit declarations, so
881 and create a "block" (a BLOCK node) for the level
882 to record its declarations and subblocks for symbol table output.
884 If FUNCTIONBODY is nonzero, this level is the body of a function,
885 so create a block as if KEEP were set and also clear out all
888 If REVERSE is nonzero, reverse the order of decls before putting
889 them into the BLOCK. */
892 poplevel (keep, reverse, functionbody)
898 /* The chain of decls was accumulated in reverse order.
899 Put it into forward order, just for cleanliness. */
901 tree tags = current_binding_level->tags;
902 tree subblocks = current_binding_level->blocks;
905 int block_previously_created;
907 keep |= current_binding_level->keep;
909 /* This warning is turned off because it causes warnings for
910 declarations like `extern struct foo *x'. */
912 /* Warn about incomplete structure types in this level. */
913 for (link = tags; link; link = TREE_CHAIN (link))
914 if (!COMPLETE_TYPE_P (TREE_VALUE (link)))
916 tree type = TREE_VALUE (link);
917 tree type_name = TYPE_NAME (type);
918 char *id = IDENTIFIER_POINTER (TREE_CODE (type_name) == IDENTIFIER_NODE
920 : DECL_NAME (type_name));
921 switch (TREE_CODE (type))
924 error ("`struct %s' incomplete in scope ending here", id);
927 error ("`union %s' incomplete in scope ending here", id);
930 error ("`enum %s' incomplete in scope ending here", id);
936 /* Get the decls in the order they were written.
937 Usually current_binding_level->names is in reverse order.
938 But parameter decls were previously put in forward order. */
941 current_binding_level->names
942 = decls = nreverse (current_binding_level->names);
944 decls = current_binding_level->names;
946 /* Output any nested inline functions within this block
947 if they weren't already output. */
949 for (decl = decls; decl; decl = TREE_CHAIN (decl))
950 if (TREE_CODE (decl) == FUNCTION_DECL
951 && ! TREE_ASM_WRITTEN (decl)
952 && DECL_INITIAL (decl) != 0
953 && TREE_ADDRESSABLE (decl))
955 /* If this decl was copied from a file-scope decl
956 on account of a block-scope extern decl,
957 propagate TREE_ADDRESSABLE to the file-scope decl.
959 DECL_ABSTRACT_ORIGIN can be set to itself if warn_return_type is
960 true, since then the decl goes through save_for_inline_copying. */
961 if (DECL_ABSTRACT_ORIGIN (decl) != 0
962 && DECL_ABSTRACT_ORIGIN (decl) != decl)
963 TREE_ADDRESSABLE (DECL_ABSTRACT_ORIGIN (decl)) = 1;
966 /* We used to warn about unused variables in expand_end_bindings,
967 i.e. while generating RTL. But in function-at-a-time mode we may
968 choose to never expand a function at all (e.g. auto inlining), so
969 we do this explicitly now. */
970 warn_about_unused_variables (getdecls ());
972 /* If there were any declarations or structure tags in that level,
973 or if this level is a function body,
974 create a BLOCK to record them for the life of this function. */
977 block_previously_created = (current_binding_level->this_block != 0);
978 if (block_previously_created)
979 block = current_binding_level->this_block;
980 else if (keep || functionbody
981 || (current_binding_level->keep_if_subblocks && subblocks != 0))
982 block = make_node (BLOCK);
985 BLOCK_VARS (block) = decls;
986 BLOCK_SUBBLOCKS (block) = subblocks;
989 /* In each subblock, record that this is its superior. */
991 for (link = subblocks; link; link = TREE_CHAIN (link))
992 BLOCK_SUPERCONTEXT (link) = block;
994 /* Clear out the meanings of the local variables of this level. */
996 for (link = decls; link; link = TREE_CHAIN (link))
998 if (DECL_NAME (link) != 0)
1000 /* If the ident. was used or addressed via a local extern decl,
1001 don't forget that fact. */
1002 if (DECL_EXTERNAL (link))
1004 if (TREE_USED (link))
1005 TREE_USED (DECL_NAME (link)) = 1;
1006 if (TREE_ADDRESSABLE (link))
1007 TREE_ADDRESSABLE (DECL_ASSEMBLER_NAME (link)) = 1;
1009 IDENTIFIER_LOCAL_VALUE (DECL_NAME (link)) = 0;
1013 /* Restore all name-meanings of the outer levels
1014 that were shadowed by this level. */
1016 for (link = current_binding_level->shadowed; link; link = TREE_CHAIN (link))
1017 IDENTIFIER_LOCAL_VALUE (TREE_PURPOSE (link)) = TREE_VALUE (link);
1019 /* If the level being exited is the top level of a function,
1020 check over all the labels, and clear out the current
1021 (function local) meanings of their names. */
1025 clear_limbo_values (block);
1027 /* If this is the top level block of a function,
1028 the vars are the function's parameters.
1029 Don't leave them in the BLOCK because they are
1030 found in the FUNCTION_DECL instead. */
1032 BLOCK_VARS (block) = 0;
1034 /* Clear out the definitions of all label names,
1035 since their scopes end here,
1036 and add them to BLOCK_VARS. */
1038 for (link = named_labels; link; link = TREE_CHAIN (link))
1040 tree label = TREE_VALUE (link);
1042 if (DECL_INITIAL (label) == 0)
1044 error_with_decl (label, "label `%s' used but not defined");
1045 /* Avoid crashing later. */
1046 define_label (input_filename, lineno,
1049 else if (warn_unused_label && !TREE_USED (label))
1050 warning_with_decl (label, "label `%s' defined but not used");
1051 IDENTIFIER_LABEL_VALUE (DECL_NAME (label)) = 0;
1053 /* Put the labels into the "variables" of the
1054 top-level block, so debugger can see them. */
1055 TREE_CHAIN (label) = BLOCK_VARS (block);
1056 BLOCK_VARS (block) = label;
1060 /* Pop the current level, and free the structure for reuse. */
1063 struct binding_level *level = current_binding_level;
1064 current_binding_level = current_binding_level->level_chain;
1066 level->level_chain = free_binding_level;
1067 free_binding_level = level;
1070 /* Dispose of the block that we just made inside some higher level. */
1072 DECL_INITIAL (current_function_decl) = block;
1075 if (!block_previously_created)
1076 current_binding_level->blocks
1077 = chainon (current_binding_level->blocks, block);
1079 /* If we did not make a block for the level just exited,
1080 any blocks made for inner levels
1081 (since they cannot be recorded as subblocks in that level)
1082 must be carried forward so they will later become subblocks
1083 of something else. */
1085 current_binding_level->blocks
1086 = chainon (current_binding_level->blocks, subblocks);
1088 /* Set the TYPE_CONTEXTs for all of the tagged types belonging to this
1089 binding contour so that they point to the appropriate construct, i.e.
1090 either to the current FUNCTION_DECL node, or else to the BLOCK node
1091 we just constructed.
1093 Note that for tagged types whose scope is just the formal parameter
1094 list for some function type specification, we can't properly set
1095 their TYPE_CONTEXTs here, because we don't have a pointer to the
1096 appropriate FUNCTION_TYPE node readily available to us. For those
1097 cases, the TYPE_CONTEXTs of the relevant tagged type nodes get set
1098 in `grokdeclarator' as soon as we have created the FUNCTION_TYPE
1099 node which will represent the "scope" for these "parameter list local"
1103 for (link = tags; link; link = TREE_CHAIN (link))
1104 TYPE_CONTEXT (TREE_VALUE (link)) = current_function_decl;
1106 for (link = tags; link; link = TREE_CHAIN (link))
1107 TYPE_CONTEXT (TREE_VALUE (link)) = block;
1110 TREE_USED (block) = 1;
1115 /* Insert BLOCK at the end of the list of subblocks of the
1116 current binding level. This is used when a BIND_EXPR is expanded,
1117 to handle the BLOCK node inside the BIND_EXPR. */
1120 insert_block (block)
1123 TREE_USED (block) = 1;
1124 current_binding_level->blocks
1125 = chainon (current_binding_level->blocks, block);
1128 /* Set the BLOCK node for the innermost scope
1129 (the one we are currently in). */
1135 current_binding_level->this_block = block;
1136 current_binding_level->names = chainon (current_binding_level->names,
1137 BLOCK_VARS (block));
1138 current_binding_level->blocks = chainon (current_binding_level->blocks,
1139 BLOCK_SUBBLOCKS (block));
1145 struct binding_level *newlevel;
1147 /* Reuse or create a struct for this binding level. */
1149 if (free_binding_level)
1151 newlevel = free_binding_level;
1152 free_binding_level = free_binding_level->level_chain;
1156 newlevel = make_binding_level ();
1159 /* Add this level to the front of the chain (stack) of label levels. */
1161 newlevel->level_chain = label_level_chain;
1162 label_level_chain = newlevel;
1164 newlevel->names = named_labels;
1165 newlevel->shadowed = shadowed_labels;
1167 shadowed_labels = 0;
1173 struct binding_level *level = label_level_chain;
1176 /* Clear out the definitions of the declared labels in this level.
1177 Leave in the list any ordinary, non-declared labels. */
1178 for (link = named_labels, prev = 0; link;)
1180 if (C_DECLARED_LABEL_FLAG (TREE_VALUE (link)))
1182 if (DECL_SOURCE_LINE (TREE_VALUE (link)) == 0)
1184 error_with_decl (TREE_VALUE (link),
1185 "label `%s' used but not defined");
1186 /* Avoid crashing later. */
1187 define_label (input_filename, lineno,
1188 DECL_NAME (TREE_VALUE (link)));
1190 else if (warn_unused_label && !TREE_USED (TREE_VALUE (link)))
1191 warning_with_decl (TREE_VALUE (link),
1192 "label `%s' defined but not used");
1193 IDENTIFIER_LABEL_VALUE (DECL_NAME (TREE_VALUE (link))) = 0;
1195 /* Delete this element from the list. */
1196 link = TREE_CHAIN (link);
1198 TREE_CHAIN (prev) = link;
1200 named_labels = link;
1205 link = TREE_CHAIN (link);
1209 /* Bring back all the labels that were shadowed. */
1210 for (link = shadowed_labels; link; link = TREE_CHAIN (link))
1211 if (DECL_NAME (TREE_VALUE (link)) != 0)
1212 IDENTIFIER_LABEL_VALUE (DECL_NAME (TREE_VALUE (link)))
1213 = TREE_VALUE (link);
1215 named_labels = chainon (named_labels, level->names);
1216 shadowed_labels = level->shadowed;
1218 /* Pop the current level, and free the structure for reuse. */
1219 label_level_chain = label_level_chain->level_chain;
1220 level->level_chain = free_binding_level;
1221 free_binding_level = level;
1224 /* Push a definition or a declaration of struct, union or enum tag "name".
1225 "type" should be the type node.
1226 We assume that the tag "name" is not already defined.
1228 Note that the definition may really be just a forward reference.
1229 In that case, the TYPE_SIZE will be zero. */
1232 pushtag (name, type)
1235 struct binding_level *b;
1237 /* Find the proper binding level for this type tag. */
1239 for (b = current_binding_level; b->tag_transparent; b = b->level_chain)
1244 /* Record the identifier as the type's name if it has none. */
1246 if (TYPE_NAME (type) == 0)
1247 TYPE_NAME (type) = name;
1250 b->tags = tree_cons (name, type, b->tags);
1252 /* Create a fake NULL-named TYPE_DECL node whose TREE_TYPE will be the
1253 tagged type we just added to the current binding level. This fake
1254 NULL-named TYPE_DECL node helps dwarfout.c to know when it needs
1255 to output a representation of a tagged type, and it also gives
1256 us a convenient place to record the "scope start" address for the
1259 TYPE_STUB_DECL (type) = pushdecl (build_decl (TYPE_DECL, NULL_TREE, type));
1261 /* An approximation for now, so we can tell this is a function-scope tag.
1262 This will be updated in poplevel. */
1263 TYPE_CONTEXT (type) = DECL_CONTEXT (TYPE_STUB_DECL (type));
1266 /* Handle when a new declaration NEWDECL
1267 has the same name as an old one OLDDECL
1268 in the same binding contour.
1269 Prints an error message if appropriate.
1271 If safely possible, alter OLDDECL to look like NEWDECL, and return 1.
1272 Otherwise, return 0.
1274 When DIFFERENT_BINDING_LEVEL is true, NEWDECL is an external declaration,
1275 and OLDDECL is in an outer binding level and should thus not be changed. */
1278 duplicate_decls (newdecl, olddecl, different_binding_level)
1279 tree newdecl, olddecl;
1280 int different_binding_level;
1282 int types_match = comptypes (TREE_TYPE (newdecl), TREE_TYPE (olddecl));
1283 int new_is_definition = (TREE_CODE (newdecl) == FUNCTION_DECL
1284 && DECL_INITIAL (newdecl) != 0);
1285 tree oldtype = TREE_TYPE (olddecl);
1286 tree newtype = TREE_TYPE (newdecl);
1289 if (DECL_P (olddecl))
1291 if (TREE_CODE (newdecl) == FUNCTION_DECL
1292 && TREE_CODE (olddecl) == FUNCTION_DECL
1293 && (DECL_UNINLINABLE (newdecl) || DECL_UNINLINABLE (olddecl)))
1295 if (DECL_DECLARED_INLINE_P (newdecl)
1296 && DECL_UNINLINABLE (newdecl)
1297 && lookup_attribute ("noinline", DECL_ATTRIBUTES (newdecl)))
1298 /* Already warned elsewhere. */;
1299 else if (DECL_DECLARED_INLINE_P (olddecl)
1300 && DECL_UNINLINABLE (olddecl)
1301 && lookup_attribute ("noinline", DECL_ATTRIBUTES (olddecl)))
1302 /* Already warned. */;
1303 else if (DECL_DECLARED_INLINE_P (newdecl)
1304 && ! DECL_DECLARED_INLINE_P (olddecl)
1305 && DECL_UNINLINABLE (olddecl)
1306 && lookup_attribute ("noinline", DECL_ATTRIBUTES (olddecl)))
1308 warning_with_decl (newdecl,
1309 "function `%s' redeclared as inline");
1310 warning_with_decl (olddecl,
1311 "previous declaration of function `%s' with attribute noinline");
1313 else if (DECL_DECLARED_INLINE_P (olddecl)
1314 && DECL_UNINLINABLE (newdecl)
1315 && lookup_attribute ("noinline", DECL_ATTRIBUTES (newdecl)))
1317 warning_with_decl (newdecl,
1318 "function `%s' redeclared with attribute noinline");
1319 warning_with_decl (olddecl,
1320 "previous declaration of function `%s' was inline");
1324 DECL_ATTRIBUTES (newdecl)
1325 = (*targetm.merge_decl_attributes) (olddecl, newdecl);
1328 if (TREE_CODE (newtype) == ERROR_MARK
1329 || TREE_CODE (oldtype) == ERROR_MARK)
1332 /* New decl is completely inconsistent with the old one =>
1333 tell caller to replace the old one.
1334 This is always an error except in the case of shadowing a builtin. */
1335 if (TREE_CODE (olddecl) != TREE_CODE (newdecl))
1337 if (TREE_CODE (olddecl) == FUNCTION_DECL
1338 && (DECL_BUILT_IN (olddecl)
1339 || DECL_BUILT_IN_NONANSI (olddecl)))
1341 /* If you declare a built-in or predefined function name as static,
1342 the old definition is overridden,
1343 but optionally warn this was a bad choice of name. */
1344 if (!TREE_PUBLIC (newdecl))
1348 else if (DECL_BUILT_IN (olddecl))
1349 warning_with_decl (newdecl, "shadowing built-in function `%s'");
1351 warning_with_decl (newdecl, "shadowing library function `%s'");
1353 /* Likewise, if the built-in is not ansi, then programs can
1354 override it even globally without an error. */
1355 else if (! DECL_BUILT_IN (olddecl))
1356 warning_with_decl (newdecl,
1357 "library function `%s' declared as non-function");
1359 else if (DECL_BUILT_IN_NONANSI (olddecl))
1360 warning_with_decl (newdecl,
1361 "built-in function `%s' declared as non-function");
1363 warning_with_decl (newdecl,
1364 "built-in function `%s' declared as non-function");
1368 error_with_decl (newdecl, "`%s' redeclared as different kind of symbol");
1369 error_with_decl (olddecl, "previous declaration of `%s'");
1375 /* For real parm decl following a forward decl,
1376 return 1 so old decl will be reused. */
1377 if (types_match && TREE_CODE (newdecl) == PARM_DECL
1378 && TREE_ASM_WRITTEN (olddecl) && ! TREE_ASM_WRITTEN (newdecl))
1381 /* The new declaration is the same kind of object as the old one.
1382 The declarations may partially match. Print warnings if they don't
1383 match enough. Ultimately, copy most of the information from the new
1384 decl to the old one, and keep using the old one. */
1386 if (TREE_CODE (olddecl) == FUNCTION_DECL && DECL_BUILT_IN (olddecl))
1388 /* A function declaration for a built-in function. */
1389 if (!TREE_PUBLIC (newdecl))
1391 /* If you declare a built-in function name as static, the
1392 built-in definition is overridden,
1393 but optionally warn this was a bad choice of name. */
1395 warning_with_decl (newdecl, "shadowing built-in function `%s'");
1396 /* Discard the old built-in function. */
1399 else if (!types_match)
1401 /* Accept the return type of the new declaration if same modes. */
1402 tree oldreturntype = TREE_TYPE (oldtype);
1403 tree newreturntype = TREE_TYPE (newtype);
1405 if (TYPE_MODE (oldreturntype) == TYPE_MODE (newreturntype))
1407 /* Function types may be shared, so we can't just modify
1408 the return type of olddecl's function type. */
1410 = build_function_type (newreturntype,
1411 TYPE_ARG_TYPES (oldtype));
1412 trytype = build_type_attribute_variant (trytype,
1413 TYPE_ATTRIBUTES (oldtype));
1415 types_match = comptypes (newtype, trytype);
1419 /* Accept harmless mismatch in first argument type also.
1420 This is for the ffs and fprintf builtins. */
1421 if (TYPE_ARG_TYPES (TREE_TYPE (newdecl)) != 0
1422 && TYPE_ARG_TYPES (oldtype) != 0
1423 && TREE_VALUE (TYPE_ARG_TYPES (newtype)) != 0
1424 && TREE_VALUE (TYPE_ARG_TYPES (oldtype)) != 0
1425 && (TYPE_MODE (TREE_VALUE (TYPE_ARG_TYPES (newtype)))
1426 == TYPE_MODE (TREE_VALUE (TYPE_ARG_TYPES (oldtype)))))
1428 /* Function types may be shared, so we can't just modify
1429 the return type of olddecl's function type. */
1431 = build_function_type (TREE_TYPE (oldtype),
1432 tree_cons (NULL_TREE,
1433 TREE_VALUE (TYPE_ARG_TYPES (newtype)),
1434 TREE_CHAIN (TYPE_ARG_TYPES (oldtype))));
1435 trytype = build_type_attribute_variant (trytype,
1436 TYPE_ATTRIBUTES (oldtype));
1438 types_match = comptypes (newtype, trytype);
1442 if (! different_binding_level)
1443 TREE_TYPE (olddecl) = oldtype;
1445 else if (TYPE_ARG_TYPES (oldtype) == NULL
1446 && TYPE_ARG_TYPES (newtype) != NULL)
1448 /* For bcmp, bzero, fputs the builtin type has arguments not
1449 specified. Use the ones from the prototype so that type checking
1450 is done for them. */
1452 = build_function_type (TREE_TYPE (oldtype),
1453 TYPE_ARG_TYPES (newtype));
1454 trytype = build_type_attribute_variant (trytype,
1455 TYPE_ATTRIBUTES (oldtype));
1458 if (! different_binding_level)
1459 TREE_TYPE (olddecl) = oldtype;
1463 /* If types don't match for a built-in, throw away the built-in. */
1464 warning_with_decl (newdecl, "conflicting types for built-in function `%s'");
1468 else if (TREE_CODE (olddecl) == FUNCTION_DECL
1469 && DECL_SOURCE_LINE (olddecl) == 0)
1471 /* A function declaration for a predeclared function
1472 that isn't actually built in. */
1473 if (!TREE_PUBLIC (newdecl))
1475 /* If you declare it as static, the
1476 default definition is overridden. */
1479 else if (!types_match)
1481 /* If the types don't match, preserve volatility indication.
1482 Later on, we will discard everything else about the
1483 default declaration. */
1484 TREE_THIS_VOLATILE (newdecl) |= TREE_THIS_VOLATILE (olddecl);
1487 /* Permit char *foo () to match void *foo (...) if not pedantic,
1488 if one of them came from a system header file. */
1489 else if (!types_match
1490 && TREE_CODE (olddecl) == FUNCTION_DECL
1491 && TREE_CODE (newdecl) == FUNCTION_DECL
1492 && TREE_CODE (TREE_TYPE (oldtype)) == POINTER_TYPE
1493 && TREE_CODE (TREE_TYPE (newtype)) == POINTER_TYPE
1494 && (DECL_IN_SYSTEM_HEADER (olddecl)
1495 || DECL_IN_SYSTEM_HEADER (newdecl))
1496 && ((TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (newtype))) == void_type_node
1497 && TYPE_ARG_TYPES (oldtype) == 0
1498 && self_promoting_args_p (TYPE_ARG_TYPES (newtype))
1499 && TREE_TYPE (TREE_TYPE (oldtype)) == char_type_node)
1501 (TREE_TYPE (TREE_TYPE (newtype)) == char_type_node
1502 && TYPE_ARG_TYPES (newtype) == 0
1503 && self_promoting_args_p (TYPE_ARG_TYPES (oldtype))
1504 && TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (oldtype))) == void_type_node)))
1507 pedwarn_with_decl (newdecl, "conflicting types for `%s'");
1508 /* Make sure we keep void * as ret type, not char *. */
1509 if (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (oldtype))) == void_type_node)
1510 TREE_TYPE (newdecl) = newtype = oldtype;
1512 /* Set DECL_IN_SYSTEM_HEADER, so that if we see another declaration
1513 we will come back here again. */
1514 DECL_IN_SYSTEM_HEADER (newdecl) = 1;
1516 else if (!types_match
1517 /* Permit char *foo (int, ...); followed by char *foo ();
1519 && ! (TREE_CODE (olddecl) == FUNCTION_DECL
1521 /* Return types must still match. */
1522 && comptypes (TREE_TYPE (oldtype),
1523 TREE_TYPE (newtype))
1524 && TYPE_ARG_TYPES (newtype) == 0))
1526 error_with_decl (newdecl, "conflicting types for `%s'");
1527 /* Check for function type mismatch
1528 involving an empty arglist vs a nonempty one. */
1529 if (TREE_CODE (olddecl) == FUNCTION_DECL
1530 && comptypes (TREE_TYPE (oldtype),
1531 TREE_TYPE (newtype))
1532 && ((TYPE_ARG_TYPES (oldtype) == 0
1533 && DECL_INITIAL (olddecl) == 0)
1535 (TYPE_ARG_TYPES (newtype) == 0
1536 && DECL_INITIAL (newdecl) == 0)))
1538 /* Classify the problem further. */
1539 tree t = TYPE_ARG_TYPES (oldtype);
1541 t = TYPE_ARG_TYPES (newtype);
1542 for (; t; t = TREE_CHAIN (t))
1544 tree type = TREE_VALUE (t);
1546 if (TREE_CHAIN (t) == 0
1547 && TYPE_MAIN_VARIANT (type) != void_type_node)
1549 error ("a parameter list with an ellipsis can't match an empty parameter name list declaration");
1553 if (c_type_promotes_to (type) != type)
1555 error ("an argument type that has a default promotion can't match an empty parameter name list declaration");
1560 error_with_decl (olddecl, "previous declaration of `%s'");
1564 errmsg = redeclaration_error_message (newdecl, olddecl);
1570 error_with_decl (newdecl, "redefinition of `%s'");
1573 error_with_decl (newdecl, "redeclaration of `%s'");
1576 error_with_decl (newdecl, "conflicting declarations of `%s'");
1582 error_with_decl (olddecl,
1583 ((DECL_INITIAL (olddecl)
1584 && current_binding_level == global_binding_level)
1585 ? "`%s' previously defined here"
1586 : "`%s' previously declared here"));
1589 else if (TREE_CODE (newdecl) == TYPE_DECL
1590 && (DECL_IN_SYSTEM_HEADER (olddecl)
1591 || DECL_IN_SYSTEM_HEADER (newdecl)))
1593 warning_with_decl (newdecl, "redefinition of `%s'");
1596 ((DECL_INITIAL (olddecl)
1597 && current_binding_level == global_binding_level)
1598 ? "`%s' previously defined here"
1599 : "`%s' previously declared here"));
1601 else if (TREE_CODE (olddecl) == FUNCTION_DECL
1602 && DECL_INITIAL (olddecl) != 0
1603 && TYPE_ARG_TYPES (oldtype) == 0
1604 && TYPE_ARG_TYPES (newtype) != 0
1605 && TYPE_ACTUAL_ARG_TYPES (oldtype) != 0)
1609 /* Prototype decl follows defn w/o prototype. */
1611 for (parm = TYPE_ACTUAL_ARG_TYPES (oldtype),
1612 type = TYPE_ARG_TYPES (newtype),
1615 parm = TREE_CHAIN (parm), type = TREE_CHAIN (type), nargs++)
1617 if (TYPE_MAIN_VARIANT (TREE_VALUE (parm)) == void_type_node
1618 && TYPE_MAIN_VARIANT (TREE_VALUE (type)) == void_type_node)
1620 warning_with_decl (newdecl, "prototype for `%s' follows");
1621 warning_with_decl (olddecl, "non-prototype definition here");
1624 if (TYPE_MAIN_VARIANT (TREE_VALUE (parm)) == void_type_node
1625 || TYPE_MAIN_VARIANT (TREE_VALUE (type)) == void_type_node)
1627 error_with_decl (newdecl,
1628 "prototype for `%s' follows and number of arguments doesn't match");
1629 error_with_decl (olddecl, "non-prototype definition here");
1633 /* Type for passing arg must be consistent
1634 with that declared for the arg. */
1635 if (! comptypes (TREE_VALUE (parm), TREE_VALUE (type)))
1637 error_with_decl (newdecl,
1638 "prototype for `%s' follows and argument %d doesn't match",
1640 error_with_decl (olddecl, "non-prototype definition here");
1646 /* Warn about mismatches in various flags. */
1649 /* Warn if function is now inline
1650 but was previously declared not inline and has been called. */
1651 if (TREE_CODE (olddecl) == FUNCTION_DECL
1652 && ! DECL_DECLARED_INLINE_P (olddecl)
1653 && DECL_DECLARED_INLINE_P (newdecl)
1654 && TREE_USED (olddecl))
1655 warning_with_decl (newdecl,
1656 "`%s' declared inline after being called");
1657 if (TREE_CODE (olddecl) == FUNCTION_DECL
1658 && ! DECL_DECLARED_INLINE_P (olddecl)
1659 && DECL_DECLARED_INLINE_P (newdecl)
1660 && DECL_INITIAL (olddecl) != 0)
1661 warning_with_decl (newdecl,
1662 "`%s' declared inline after its definition");
1664 /* If pedantic, warn when static declaration follows a non-static
1665 declaration. Otherwise, do so only for functions. */
1666 if ((pedantic || TREE_CODE (olddecl) == FUNCTION_DECL)
1667 && TREE_PUBLIC (olddecl)
1668 && !TREE_PUBLIC (newdecl))
1669 warning_with_decl (newdecl, "static declaration for `%s' follows non-static");
1671 /* If warn_traditional, warn when a non-static function
1672 declaration follows a static one. */
1673 if (warn_traditional && !in_system_header
1674 && TREE_CODE (olddecl) == FUNCTION_DECL
1675 && !TREE_PUBLIC (olddecl)
1676 && TREE_PUBLIC (newdecl))
1677 warning_with_decl (newdecl, "non-static declaration for `%s' follows static");
1679 /* Warn when const declaration follows a non-const
1680 declaration, but not for functions. */
1681 if (TREE_CODE (olddecl) != FUNCTION_DECL
1682 && !TREE_READONLY (olddecl)
1683 && TREE_READONLY (newdecl))
1684 warning_with_decl (newdecl, "const declaration for `%s' follows non-const");
1685 /* These bits are logically part of the type, for variables.
1686 But not for functions
1687 (where qualifiers are not valid ANSI anyway). */
1688 else if (pedantic && TREE_CODE (olddecl) != FUNCTION_DECL
1689 && (TREE_READONLY (newdecl) != TREE_READONLY (olddecl)
1690 || TREE_THIS_VOLATILE (newdecl) != TREE_THIS_VOLATILE (olddecl)))
1691 pedwarn_with_decl (newdecl, "type qualifiers for `%s' conflict with previous decl");
1695 /* Optionally warn about more than one declaration for the same name. */
1696 if (errmsg == 0 && warn_redundant_decls && DECL_SOURCE_LINE (olddecl) != 0
1697 /* Don't warn about a function declaration
1698 followed by a definition. */
1699 && !(TREE_CODE (newdecl) == FUNCTION_DECL && DECL_INITIAL (newdecl) != 0
1700 && DECL_INITIAL (olddecl) == 0)
1701 /* Don't warn about extern decl followed by (tentative) definition. */
1702 && !(DECL_EXTERNAL (olddecl) && ! DECL_EXTERNAL (newdecl)))
1704 warning_with_decl (newdecl, "redundant redeclaration of `%s' in same scope");
1705 warning_with_decl (olddecl, "previous declaration of `%s'");
1708 /* Copy all the DECL_... slots specified in the new decl
1709 except for any that we copy here from the old type.
1711 Past this point, we don't change OLDTYPE and NEWTYPE
1712 even if we change the types of NEWDECL and OLDDECL. */
1716 /* When copying info to olddecl, we store into write_olddecl
1717 instead. This allows us to avoid modifying olddecl when
1718 different_binding_level is true. */
1719 tree write_olddecl = different_binding_level ? newdecl : olddecl;
1721 /* Merge the data types specified in the two decls. */
1722 if (TREE_CODE (newdecl) != FUNCTION_DECL || !DECL_BUILT_IN (olddecl))
1724 if (different_binding_level)
1726 if (TYPE_ARG_TYPES (oldtype) != 0
1727 && TYPE_ARG_TYPES (newtype) == 0)
1728 TREE_TYPE (newdecl) = common_type (newtype, oldtype);
1731 = build_type_attribute_variant
1733 merge_attributes (TYPE_ATTRIBUTES (newtype),
1734 TYPE_ATTRIBUTES (oldtype)));
1738 = TREE_TYPE (olddecl)
1739 = common_type (newtype, oldtype);
1742 /* Lay the type out, unless already done. */
1743 if (oldtype != TREE_TYPE (newdecl))
1745 if (TREE_TYPE (newdecl) != error_mark_node)
1746 layout_type (TREE_TYPE (newdecl));
1747 if (TREE_CODE (newdecl) != FUNCTION_DECL
1748 && TREE_CODE (newdecl) != TYPE_DECL
1749 && TREE_CODE (newdecl) != CONST_DECL)
1750 layout_decl (newdecl, 0);
1754 /* Since the type is OLDDECL's, make OLDDECL's size go with. */
1755 DECL_SIZE (newdecl) = DECL_SIZE (olddecl);
1756 DECL_SIZE_UNIT (newdecl) = DECL_SIZE_UNIT (olddecl);
1757 DECL_MODE (newdecl) = DECL_MODE (olddecl);
1758 if (TREE_CODE (olddecl) != FUNCTION_DECL)
1759 if (DECL_ALIGN (olddecl) > DECL_ALIGN (newdecl))
1761 DECL_ALIGN (newdecl) = DECL_ALIGN (olddecl);
1762 DECL_USER_ALIGN (newdecl) |= DECL_ALIGN (olddecl);
1766 /* Keep the old rtl since we can safely use it. */
1767 COPY_DECL_RTL (olddecl, newdecl);
1769 /* Merge the type qualifiers. */
1770 if (TREE_CODE (olddecl) == FUNCTION_DECL
1771 && DECL_BUILT_IN_NONANSI (olddecl) && TREE_THIS_VOLATILE (olddecl)
1772 && ! TREE_THIS_VOLATILE (newdecl))
1773 TREE_THIS_VOLATILE (write_olddecl) = 0;
1775 if (TREE_READONLY (newdecl))
1776 TREE_READONLY (write_olddecl) = 1;
1778 if (TREE_THIS_VOLATILE (newdecl))
1780 TREE_THIS_VOLATILE (write_olddecl) = 1;
1781 if (TREE_CODE (newdecl) == VAR_DECL
1782 /* If an automatic variable is re-declared in the same
1783 function scope, but the old declaration was not
1784 volatile, make_var_volatile() would crash because the
1785 variable would have been assigned to a pseudo, not a
1786 MEM. Since this duplicate declaration is invalid
1787 anyway, we just skip the call. */
1789 make_var_volatile (newdecl);
1792 /* Keep source location of definition rather than declaration. */
1793 /* When called with different_binding_level set, keep the old
1794 information so that meaningful diagnostics can be given. */
1795 if (DECL_INITIAL (newdecl) == 0 && DECL_INITIAL (olddecl) != 0
1796 && ! different_binding_level)
1798 DECL_SOURCE_LINE (newdecl) = DECL_SOURCE_LINE (olddecl);
1799 DECL_SOURCE_FILE (newdecl) = DECL_SOURCE_FILE (olddecl);
1802 /* Merge the unused-warning information. */
1803 if (DECL_IN_SYSTEM_HEADER (olddecl))
1804 DECL_IN_SYSTEM_HEADER (newdecl) = 1;
1805 else if (DECL_IN_SYSTEM_HEADER (newdecl))
1806 DECL_IN_SYSTEM_HEADER (write_olddecl) = 1;
1808 /* Merge the initialization information. */
1809 /* When called with different_binding_level set, don't copy over
1810 DECL_INITIAL, so that we don't accidentally change function
1811 declarations into function definitions. */
1812 if (DECL_INITIAL (newdecl) == 0 && ! different_binding_level)
1813 DECL_INITIAL (newdecl) = DECL_INITIAL (olddecl);
1815 /* Merge the section attribute.
1816 We want to issue an error if the sections conflict but that must be
1817 done later in decl_attributes since we are called before attributes
1819 if (DECL_SECTION_NAME (newdecl) == NULL_TREE)
1820 DECL_SECTION_NAME (newdecl) = DECL_SECTION_NAME (olddecl);
1822 /* Copy the assembler name.
1823 Currently, it can only be defined in the prototype. */
1824 COPY_DECL_ASSEMBLER_NAME (olddecl, newdecl);
1826 if (TREE_CODE (newdecl) == FUNCTION_DECL)
1828 DECL_STATIC_CONSTRUCTOR(newdecl) |= DECL_STATIC_CONSTRUCTOR(olddecl);
1829 DECL_STATIC_DESTRUCTOR (newdecl) |= DECL_STATIC_DESTRUCTOR (olddecl);
1830 DECL_NO_LIMIT_STACK (newdecl) |= DECL_NO_LIMIT_STACK (olddecl);
1831 DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (newdecl)
1832 |= DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (olddecl);
1835 /* If cannot merge, then use the new type and qualifiers,
1836 and don't preserve the old rtl. */
1837 else if (! different_binding_level)
1839 TREE_TYPE (olddecl) = TREE_TYPE (newdecl);
1840 TREE_READONLY (olddecl) = TREE_READONLY (newdecl);
1841 TREE_THIS_VOLATILE (olddecl) = TREE_THIS_VOLATILE (newdecl);
1842 TREE_SIDE_EFFECTS (olddecl) = TREE_SIDE_EFFECTS (newdecl);
1845 /* Merge the storage class information. */
1846 DECL_WEAK (newdecl) |= DECL_WEAK (olddecl);
1847 /* For functions, static overrides non-static. */
1848 if (TREE_CODE (newdecl) == FUNCTION_DECL)
1850 TREE_PUBLIC (newdecl) &= TREE_PUBLIC (olddecl);
1851 /* This is since we don't automatically
1852 copy the attributes of NEWDECL into OLDDECL. */
1853 /* No need to worry about different_binding_level here because
1854 then TREE_PUBLIC (newdecl) was true. */
1855 TREE_PUBLIC (olddecl) = TREE_PUBLIC (newdecl);
1856 /* If this clears `static', clear it in the identifier too. */
1857 if (! TREE_PUBLIC (olddecl))
1858 TREE_PUBLIC (DECL_NAME (olddecl)) = 0;
1860 if (DECL_EXTERNAL (newdecl))
1862 if (! different_binding_level)
1864 /* Don't mess with these flags on local externs; they remain
1865 external even if there's a declaration at file scope which
1867 TREE_STATIC (newdecl) = TREE_STATIC (olddecl);
1868 DECL_EXTERNAL (newdecl) = DECL_EXTERNAL (olddecl);
1870 /* An extern decl does not override previous storage class. */
1871 TREE_PUBLIC (newdecl) = TREE_PUBLIC (olddecl);
1872 if (! DECL_EXTERNAL (newdecl))
1873 DECL_CONTEXT (newdecl) = DECL_CONTEXT (olddecl);
1877 TREE_STATIC (olddecl) = TREE_STATIC (newdecl);
1878 TREE_PUBLIC (olddecl) = TREE_PUBLIC (newdecl);
1881 if (TREE_CODE (newdecl) == FUNCTION_DECL)
1883 /* If we're redefining a function previously defined as extern
1884 inline, make sure we emit debug info for the inline before we
1885 throw it away, in case it was inlined into a function that hasn't
1886 been written out yet. */
1887 if (new_is_definition && DECL_INITIAL (olddecl) && TREE_USED (olddecl))
1889 (*debug_hooks->outlining_inline_function) (olddecl);
1891 /* The new defn must not be inline. */
1892 DECL_INLINE (newdecl) = 0;
1893 DECL_UNINLINABLE (newdecl) = 1;
1897 /* If either decl says `inline', this fn is inline,
1898 unless its definition was passed already. */
1899 if (DECL_DECLARED_INLINE_P (newdecl)
1900 || DECL_DECLARED_INLINE_P (olddecl))
1901 DECL_DECLARED_INLINE_P (newdecl) = 1;
1903 DECL_UNINLINABLE (newdecl) = DECL_UNINLINABLE (olddecl)
1904 = (DECL_UNINLINABLE (newdecl) || DECL_UNINLINABLE (olddecl));
1907 if (DECL_BUILT_IN (olddecl))
1909 /* Get rid of any built-in function if new arg types don't match it
1910 or if we have a function definition. */
1911 if (! types_match || new_is_definition)
1913 if (! different_binding_level)
1915 TREE_TYPE (olddecl) = TREE_TYPE (newdecl);
1916 DECL_BUILT_IN_CLASS (olddecl) = NOT_BUILT_IN;
1921 /* If redeclaring a builtin function, and not a definition,
1922 it stays built in. */
1923 DECL_BUILT_IN_CLASS (newdecl) = DECL_BUILT_IN_CLASS (olddecl);
1924 DECL_FUNCTION_CODE (newdecl) = DECL_FUNCTION_CODE (olddecl);
1928 /* Also preserve various other info from the definition. */
1929 if (! new_is_definition)
1931 DECL_RESULT (newdecl) = DECL_RESULT (olddecl);
1932 /* When called with different_binding_level set, don't copy over
1933 DECL_INITIAL, so that we don't accidentally change function
1934 declarations into function definitions. */
1935 if (! different_binding_level)
1936 DECL_INITIAL (newdecl) = DECL_INITIAL (olddecl);
1937 DECL_SAVED_INSNS (newdecl) = DECL_SAVED_INSNS (olddecl);
1938 DECL_SAVED_TREE (newdecl) = DECL_SAVED_TREE (olddecl);
1939 DECL_NUM_STMTS (newdecl) = DECL_NUM_STMTS (olddecl);
1940 DECL_ARGUMENTS (newdecl) = DECL_ARGUMENTS (olddecl);
1942 /* Set DECL_INLINE on the declaration if we've got a body
1943 from which to instantiate. */
1944 if (DECL_INLINE (olddecl) && ! DECL_UNINLINABLE (newdecl))
1946 DECL_INLINE (newdecl) = 1;
1947 DECL_ABSTRACT_ORIGIN (newdecl)
1948 = (different_binding_level
1949 ? DECL_ORIGIN (olddecl)
1950 : DECL_ABSTRACT_ORIGIN (olddecl));
1955 /* If a previous declaration said inline, mark the
1956 definition as inlinable. */
1957 if (DECL_DECLARED_INLINE_P (newdecl)
1958 && ! DECL_UNINLINABLE (newdecl))
1959 DECL_INLINE (newdecl) = 1;
1962 if (different_binding_level)
1965 /* Copy most of the decl-specific fields of NEWDECL into OLDDECL.
1966 But preserve OLDDECL's DECL_UID. */
1968 unsigned olddecl_uid = DECL_UID (olddecl);
1970 memcpy ((char *) olddecl + sizeof (struct tree_common),
1971 (char *) newdecl + sizeof (struct tree_common),
1972 sizeof (struct tree_decl) - sizeof (struct tree_common));
1973 DECL_UID (olddecl) = olddecl_uid;
1976 /* NEWDECL contains the merged attribute lists.
1977 Update OLDDECL to be the same. */
1978 DECL_ATTRIBUTES (olddecl) = DECL_ATTRIBUTES (newdecl);
1983 /* Check whether decl-node X shadows an existing declaration.
1984 OLDLOCAL is the old IDENTIFIER_LOCAL_VALUE of the DECL_NAME of X,
1985 which might be a NULL_TREE. */
1987 warn_if_shadowing (x, oldlocal)
1992 if (DECL_EXTERNAL (x))
1995 name = DECL_NAME (x);
1997 /* Warn if shadowing an argument at the top level of the body. */
1999 /* This warning doesn't apply to the parms of a nested fcn. */
2000 && ! current_binding_level->parm_flag
2001 /* Check that this is one level down from the parms. */
2002 && current_binding_level->level_chain->parm_flag
2003 /* Check that the decl being shadowed
2004 comes from the parm level, one level up. */
2005 && chain_member (oldlocal, current_binding_level->level_chain->names))
2007 if (TREE_CODE (oldlocal) == PARM_DECL)
2008 pedwarn ("declaration of `%s' shadows a parameter",
2009 IDENTIFIER_POINTER (name));
2011 pedwarn ("declaration of `%s' shadows a symbol from the parameter list",
2012 IDENTIFIER_POINTER (name));
2014 /* Maybe warn if shadowing something else. */
2015 else if (warn_shadow
2016 /* No shadow warnings for internally generated vars. */
2017 && DECL_SOURCE_LINE (x) != 0
2018 /* No shadow warnings for vars made for inlining. */
2019 && ! DECL_FROM_INLINE (x))
2021 if (TREE_CODE (x) == PARM_DECL
2022 && current_binding_level->level_chain->parm_flag)
2023 /* Don't warn about the parm names in function declarator
2024 within a function declarator.
2025 It would be nice to avoid warning in any function
2026 declarator in a declaration, as opposed to a definition,
2027 but there is no way to tell it's not a definition. */
2031 if (TREE_CODE (oldlocal) == PARM_DECL)
2032 shadow_warning ("a parameter", name, oldlocal);
2034 shadow_warning ("a previous local", name, oldlocal);
2036 else if (IDENTIFIER_GLOBAL_VALUE (name) != 0
2037 && IDENTIFIER_GLOBAL_VALUE (name) != error_mark_node)
2038 shadow_warning ("a global declaration", name,
2039 IDENTIFIER_GLOBAL_VALUE (name));
2043 /* Record a decl-node X as belonging to the current lexical scope.
2044 Check for errors (such as an incompatible declaration for the same
2045 name already seen in the same scope).
2047 Returns either X or an old decl for the same name.
2048 If an old decl is returned, it may have been smashed
2049 to agree with what X says. */
2056 tree name = DECL_NAME (x);
2057 struct binding_level *b = current_binding_level;
2059 /* Functions need the lang_decl data. */
2060 if (TREE_CODE (x) == FUNCTION_DECL && ! DECL_LANG_SPECIFIC (x))
2061 DECL_LANG_SPECIFIC (x) = (struct lang_decl *)
2062 ggc_alloc_cleared (sizeof (struct lang_decl));
2064 DECL_CONTEXT (x) = current_function_decl;
2065 /* A local extern declaration for a function doesn't constitute nesting.
2066 A local auto declaration does, since it's a forward decl
2067 for a nested function coming later. */
2068 if ((TREE_CODE (x) == FUNCTION_DECL || TREE_CODE (x) == VAR_DECL)
2069 && DECL_INITIAL (x) == 0 && DECL_EXTERNAL (x))
2070 DECL_CONTEXT (x) = 0;
2074 int different_binding_level = 0;
2076 if (warn_nested_externs
2077 && DECL_EXTERNAL (x)
2078 && b != global_binding_level
2079 && x != IDENTIFIER_IMPLICIT_DECL (name)
2080 /* No error messages for __FUNCTION__ and __PRETTY_FUNCTION__. */
2081 && !DECL_IN_SYSTEM_HEADER (x))
2082 warning ("nested extern declaration of `%s'",
2083 IDENTIFIER_POINTER (name));
2085 t = lookup_name_current_level (name);
2086 if (! t && DECL_EXTERNAL (x) && TREE_PUBLIC (x))
2088 t = IDENTIFIER_GLOBAL_VALUE (name);
2089 /* Type decls at global scope don't conflict with externs declared
2090 inside lexical blocks. */
2091 if (! t || TREE_CODE (t) == TYPE_DECL)
2092 /* If there's no visible global declaration, try for an
2094 t = IDENTIFIER_LIMBO_VALUE (name);
2095 different_binding_level = 1;
2097 if (t != 0 && t == error_mark_node)
2098 /* error_mark_node is 0 for a while during initialization! */
2101 error_with_decl (x, "`%s' used prior to declaration");
2104 /* If this decl is `static' and an implicit decl was seen previously,
2106 if (TREE_PUBLIC (name)
2107 /* Don't test for DECL_EXTERNAL, because grokdeclarator
2108 sets this for all functions. */
2109 && ! TREE_PUBLIC (x)
2110 && (TREE_CODE (x) == FUNCTION_DECL || b == global_binding_level)
2111 /* We used to warn also for explicit extern followed by static,
2112 but sometimes you need to do it that way. */
2113 && IDENTIFIER_IMPLICIT_DECL (name) != 0)
2115 pedwarn ("`%s' was declared implicitly `extern' and later `static'",
2116 IDENTIFIER_POINTER (name));
2117 pedwarn_with_file_and_line
2118 (DECL_SOURCE_FILE (IDENTIFIER_IMPLICIT_DECL (name)),
2119 DECL_SOURCE_LINE (IDENTIFIER_IMPLICIT_DECL (name)),
2120 "previous declaration of `%s'",
2121 IDENTIFIER_POINTER (name));
2122 TREE_THIS_VOLATILE (name) = 1;
2125 if (t != 0 && duplicate_decls (x, t, different_binding_level))
2127 if (TREE_CODE (t) == PARM_DECL)
2129 /* Don't allow more than one "real" duplicate
2130 of a forward parm decl. */
2131 TREE_ASM_WRITTEN (t) = TREE_ASM_WRITTEN (x);
2137 /* If we are processing a typedef statement, generate a whole new
2138 ..._TYPE node (which will be just an variant of the existing
2139 ..._TYPE node with identical properties) and then install the
2140 TYPE_DECL node generated to represent the typedef name as the
2141 TYPE_NAME of this brand new (duplicate) ..._TYPE node.
2143 The whole point here is to end up with a situation where each
2144 and every ..._TYPE node the compiler creates will be uniquely
2145 associated with AT MOST one node representing a typedef name.
2146 This way, even though the compiler substitutes corresponding
2147 ..._TYPE nodes for TYPE_DECL (i.e. "typedef name") nodes very
2148 early on, later parts of the compiler can always do the reverse
2149 translation and get back the corresponding typedef name. For
2152 typedef struct S MY_TYPE;
2155 Later parts of the compiler might only know that `object' was of
2156 type `struct S' if it were not for code just below. With this
2157 code however, later parts of the compiler see something like:
2159 struct S' == struct S
2160 typedef struct S' MY_TYPE;
2163 And they can then deduce (from the node for type struct S') that
2164 the original object declaration was:
2168 Being able to do this is important for proper support of protoize,
2169 and also for generating precise symbolic debugging information
2170 which takes full account of the programmer's (typedef) vocabulary.
2172 Obviously, we don't want to generate a duplicate ..._TYPE node if
2173 the TYPE_DECL node that we are now processing really represents a
2174 standard built-in type.
2176 Since all standard types are effectively declared at line zero
2177 in the source file, we can easily check to see if we are working
2178 on a standard type by checking the current value of lineno. */
2180 if (TREE_CODE (x) == TYPE_DECL)
2182 if (DECL_SOURCE_LINE (x) == 0)
2184 if (TYPE_NAME (TREE_TYPE (x)) == 0)
2185 TYPE_NAME (TREE_TYPE (x)) = x;
2187 else if (TREE_TYPE (x) != error_mark_node
2188 && DECL_ORIGINAL_TYPE (x) == NULL_TREE)
2190 tree tt = TREE_TYPE (x);
2191 DECL_ORIGINAL_TYPE (x) = tt;
2192 tt = build_type_copy (tt);
2194 TREE_USED (tt) = TREE_USED (x);
2199 /* Multiple external decls of the same identifier ought to match.
2200 We get warnings about inline functions where they are defined.
2201 Avoid duplicate warnings where they are used. */
2203 && ! (TREE_CODE (x) == FUNCTION_DECL && DECL_INLINE (x)))
2207 if (IDENTIFIER_LIMBO_VALUE (name) != 0)
2208 /* Decls in limbo are always extern, so no need to check that. */
2209 decl = IDENTIFIER_LIMBO_VALUE (name);
2213 if (decl && ! comptypes (TREE_TYPE (x), TREE_TYPE (decl))
2214 /* If old decl is built-in, we already warned if we should. */
2215 && !DECL_BUILT_IN (decl))
2217 pedwarn_with_decl (x,
2218 "type mismatch with previous external decl");
2219 pedwarn_with_decl (decl, "previous external decl of `%s'");
2223 /* If a function has had an implicit declaration, and then is defined,
2224 make sure they are compatible. */
2226 if (IDENTIFIER_IMPLICIT_DECL (name) != 0
2227 && IDENTIFIER_GLOBAL_VALUE (name) == 0
2228 && TREE_CODE (x) == FUNCTION_DECL
2229 && ! comptypes (TREE_TYPE (x),
2230 TREE_TYPE (IDENTIFIER_IMPLICIT_DECL (name))))
2232 warning_with_decl (x, "type mismatch with previous implicit declaration");
2233 warning_with_decl (IDENTIFIER_IMPLICIT_DECL (name),
2234 "previous implicit declaration of `%s'");
2237 /* This name is new in its binding level.
2238 Install the new declaration and return it. */
2239 if (b == global_binding_level)
2241 /* Install a global value. */
2243 /* If the first global decl has external linkage,
2244 warn if we later see static one. */
2245 if (IDENTIFIER_GLOBAL_VALUE (name) == 0 && TREE_PUBLIC (x))
2246 TREE_PUBLIC (name) = 1;
2248 IDENTIFIER_GLOBAL_VALUE (name) = x;
2250 /* We no longer care about any previous block level declarations. */
2251 IDENTIFIER_LIMBO_VALUE (name) = 0;
2253 /* Don't forget if the function was used via an implicit decl. */
2254 if (IDENTIFIER_IMPLICIT_DECL (name)
2255 && TREE_USED (IDENTIFIER_IMPLICIT_DECL (name)))
2256 TREE_USED (x) = 1, TREE_USED (name) = 1;
2258 /* Don't forget if its address was taken in that way. */
2259 if (IDENTIFIER_IMPLICIT_DECL (name)
2260 && TREE_ADDRESSABLE (IDENTIFIER_IMPLICIT_DECL (name)))
2261 TREE_ADDRESSABLE (x) = 1;
2263 /* Warn about mismatches against previous implicit decl. */
2264 if (IDENTIFIER_IMPLICIT_DECL (name) != 0
2265 /* If this real decl matches the implicit, don't complain. */
2266 && ! (TREE_CODE (x) == FUNCTION_DECL
2267 && (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (x)))
2268 == integer_type_node)))
2269 pedwarn ("`%s' was previously implicitly declared to return `int'",
2270 IDENTIFIER_POINTER (name));
2272 /* If this decl is `static' and an `extern' was seen previously,
2273 that is erroneous. */
2274 if (TREE_PUBLIC (name)
2275 && ! TREE_PUBLIC (x) && ! DECL_EXTERNAL (x))
2277 /* Okay to redeclare an ANSI built-in as static. */
2278 if (t != 0 && DECL_BUILT_IN (t))
2280 /* Okay to declare a non-ANSI built-in as anything. */
2281 else if (t != 0 && DECL_BUILT_IN_NONANSI (t))
2283 /* Okay to have global type decl after an earlier extern
2284 declaration inside a lexical block. */
2285 else if (TREE_CODE (x) == TYPE_DECL)
2287 else if (IDENTIFIER_IMPLICIT_DECL (name))
2289 if (! TREE_THIS_VOLATILE (name))
2290 pedwarn ("`%s' was declared implicitly `extern' and later `static'",
2291 IDENTIFIER_POINTER (name));
2294 pedwarn ("`%s' was declared `extern' and later `static'",
2295 IDENTIFIER_POINTER (name));
2300 /* Here to install a non-global value. */
2301 tree oldlocal = IDENTIFIER_LOCAL_VALUE (name);
2302 tree oldglobal = IDENTIFIER_GLOBAL_VALUE (name);
2304 IDENTIFIER_LOCAL_VALUE (name) = x;
2306 /* If this is an extern function declaration, see if we
2307 have a global definition or declaration for the function. */
2310 && TREE_CODE (x) == FUNCTION_DECL
2311 && TREE_CODE (oldglobal) == FUNCTION_DECL
2312 && DECL_EXTERNAL (x)
2313 && ! DECL_DECLARED_INLINE_P (x))
2315 /* We have one. Their types must agree. */
2316 if (! comptypes (TREE_TYPE (x),
2317 TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (name))))
2318 pedwarn_with_decl (x, "extern declaration of `%s' doesn't match global one");
2321 /* Inner extern decl is inline if global one is.
2322 Copy enough to really inline it. */
2323 if (DECL_DECLARED_INLINE_P (oldglobal))
2325 DECL_DECLARED_INLINE_P (x)
2326 = DECL_DECLARED_INLINE_P (oldglobal);
2327 DECL_INLINE (x) = DECL_INLINE (oldglobal);
2328 DECL_INITIAL (x) = (current_function_decl == oldglobal
2329 ? 0 : DECL_INITIAL (oldglobal));
2330 DECL_SAVED_INSNS (x) = DECL_SAVED_INSNS (oldglobal);
2331 DECL_NUM_STMTS (x) = DECL_NUM_STMTS (oldglobal);
2332 DECL_ARGUMENTS (x) = DECL_ARGUMENTS (oldglobal);
2333 DECL_RESULT (x) = DECL_RESULT (oldglobal);
2334 TREE_ASM_WRITTEN (x) = TREE_ASM_WRITTEN (oldglobal);
2335 DECL_ABSTRACT_ORIGIN (x)
2336 = DECL_ABSTRACT_ORIGIN (oldglobal);
2338 /* Inner extern decl is built-in if global one is. */
2339 if (DECL_BUILT_IN (oldglobal))
2341 DECL_BUILT_IN_CLASS (x) = DECL_BUILT_IN_CLASS (oldglobal);
2342 DECL_FUNCTION_CODE (x) = DECL_FUNCTION_CODE (oldglobal);
2344 /* Keep the arg types from a file-scope fcn defn. */
2345 if (TYPE_ARG_TYPES (TREE_TYPE (oldglobal)) != 0
2346 && DECL_INITIAL (oldglobal)
2347 && TYPE_ARG_TYPES (TREE_TYPE (x)) == 0)
2348 TREE_TYPE (x) = TREE_TYPE (oldglobal);
2353 /* This case is probably sometimes the right thing to do. */
2354 /* If we have a local external declaration,
2355 then any file-scope declaration should not
2356 have been static. */
2357 if (oldlocal == 0 && oldglobal != 0
2358 && !TREE_PUBLIC (oldglobal)
2359 && DECL_EXTERNAL (x) && TREE_PUBLIC (x))
2360 warning ("`%s' locally external but globally static",
2361 IDENTIFIER_POINTER (name));
2364 /* If we have a local external declaration,
2365 and no file-scope declaration has yet been seen,
2366 then if we later have a file-scope decl it must not be static. */
2368 && DECL_EXTERNAL (x)
2372 TREE_PUBLIC (name) = 1;
2374 /* Save this decl, so that we can do type checking against
2375 other decls after it falls out of scope.
2377 Only save it once. This prevents temporary decls created in
2378 expand_inline_function from being used here, since this
2379 will have been set when the inline function was parsed.
2380 It also helps give slightly better warnings. */
2381 if (IDENTIFIER_LIMBO_VALUE (name) == 0)
2382 IDENTIFIER_LIMBO_VALUE (name) = x;
2385 warn_if_shadowing (x, oldlocal);
2387 /* If storing a local value, there may already be one (inherited).
2388 If so, record it for restoration when this binding level ends. */
2390 b->shadowed = tree_cons (name, oldlocal, b->shadowed);
2393 /* Keep count of variables in this level with incomplete type.
2394 If the input is erroneous, we can have error_mark in the type
2395 slot (e.g. "f(void a, ...)") - that doesn't count as an
2397 if (TREE_TYPE (x) != error_mark_node
2398 && !COMPLETE_TYPE_P (TREE_TYPE (x)))
2400 tree element = TREE_TYPE (x);
2402 while (TREE_CODE (element) == ARRAY_TYPE)
2403 element = TREE_TYPE (element);
2404 if (TREE_CODE (element) == RECORD_TYPE
2405 || TREE_CODE (element) == UNION_TYPE)
2410 /* Put decls on list in reverse order.
2411 We will reverse them later if necessary. */
2412 TREE_CHAIN (x) = b->names;
2418 /* Like pushdecl, only it places X in GLOBAL_BINDING_LEVEL, if appropriate. */
2421 pushdecl_top_level (x)
2425 struct binding_level *b = current_binding_level;
2427 current_binding_level = global_binding_level;
2429 current_binding_level = b;
2433 /* Generate an implicit declaration for identifier FUNCTIONID
2434 as a function of type int (). Print a warning if appropriate. */
2437 implicitly_declare (functionid)
2441 int traditional_warning = 0;
2442 /* Only one "implicit declaration" warning per identifier. */
2443 int implicit_warning;
2445 /* We used to reuse an old implicit decl here,
2446 but this loses with inline functions because it can clobber
2447 the saved decl chains. */
2449 if (IDENTIFIER_IMPLICIT_DECL (functionid) != 0)
2450 decl = IDENTIFIER_IMPLICIT_DECL (functionid);
2453 decl = build_decl (FUNCTION_DECL, functionid, default_function_type);
2455 /* Warn of implicit decl following explicit local extern decl.
2456 This is probably a program designed for traditional C. */
2457 if (TREE_PUBLIC (functionid) && IDENTIFIER_GLOBAL_VALUE (functionid) == 0)
2458 traditional_warning = 1;
2460 /* Warn once of an implicit declaration. */
2461 implicit_warning = (IDENTIFIER_IMPLICIT_DECL (functionid) == 0);
2463 DECL_EXTERNAL (decl) = 1;
2464 TREE_PUBLIC (decl) = 1;
2466 /* Record that we have an implicit decl and this is it. */
2467 IDENTIFIER_IMPLICIT_DECL (functionid) = decl;
2469 /* ANSI standard says implicit declarations are in the innermost block.
2470 So we record the decl in the standard fashion. */
2473 /* This is a no-op in c-lang.c or something real in objc-actions.c. */
2474 maybe_objc_check_decl (decl);
2476 rest_of_decl_compilation (decl, NULL, 0, 0);
2478 if (implicit_warning)
2479 implicit_decl_warning (functionid);
2480 else if (warn_traditional && traditional_warning)
2481 warning ("function `%s' was previously declared within a block",
2482 IDENTIFIER_POINTER (functionid));
2484 /* Write a record describing this implicit function declaration to the
2485 prototypes file (if requested). */
2487 gen_aux_info_record (decl, 0, 1, 0);
2489 /* Possibly apply some default attributes to this implicit declaration. */
2490 decl_attributes (&decl, NULL_TREE, 0);
2496 implicit_decl_warning (id)
2499 const char *name = IDENTIFIER_POINTER (id);
2500 if (mesg_implicit_function_declaration == 2)
2501 error ("implicit declaration of function `%s'", name);
2502 else if (mesg_implicit_function_declaration == 1)
2503 warning ("implicit declaration of function `%s'", name);
2506 /* Return zero if the declaration NEWDECL is valid
2507 when the declaration OLDDECL (assumed to be for the same name)
2508 has already been seen.
2509 Otherwise return 1 if NEWDECL is a redefinition, 2 if it is a redeclaration,
2510 and 3 if it is a conflicting declaration. */
2513 redeclaration_error_message (newdecl, olddecl)
2514 tree newdecl, olddecl;
2516 if (TREE_CODE (newdecl) == TYPE_DECL)
2518 /* Do not complain about type redeclarations where at least one
2519 declaration was in a system header. */
2520 if (DECL_IN_SYSTEM_HEADER (olddecl) || DECL_IN_SYSTEM_HEADER (newdecl))
2524 else if (TREE_CODE (newdecl) == FUNCTION_DECL)
2526 /* Declarations of functions can insist on internal linkage
2527 but they can't be inconsistent with internal linkage,
2528 so there can be no error on that account.
2529 However defining the same name twice is no good. */
2530 if (DECL_INITIAL (olddecl) != 0 && DECL_INITIAL (newdecl) != 0
2531 /* However, defining once as extern inline and a second
2532 time in another way is ok. */
2533 && ! (DECL_DECLARED_INLINE_P (olddecl) && DECL_EXTERNAL (olddecl)
2534 && ! (DECL_DECLARED_INLINE_P (newdecl)
2535 && DECL_EXTERNAL (newdecl))))
2539 else if (DECL_CONTEXT (newdecl) == NULL_TREE)
2541 /* Objects declared at top level: */
2542 /* If at least one is a reference, it's ok. */
2543 if (DECL_EXTERNAL (newdecl) || DECL_EXTERNAL (olddecl))
2545 /* Reject two definitions. */
2546 if (DECL_INITIAL (olddecl) != 0 && DECL_INITIAL (newdecl) != 0)
2548 /* Now we have two tentative defs, or one tentative and one real def. */
2549 /* Insist that the linkage match. */
2550 if (TREE_PUBLIC (olddecl) != TREE_PUBLIC (newdecl))
2554 else if (current_binding_level->parm_flag
2555 && TREE_ASM_WRITTEN (olddecl) && !TREE_ASM_WRITTEN (newdecl))
2559 /* Newdecl has block scope. If olddecl has block scope also, then
2560 reject two definitions, and reject a definition together with an
2561 external reference. Otherwise, it is OK, because newdecl must
2562 be an extern reference to olddecl. */
2563 if (!(DECL_EXTERNAL (newdecl) && DECL_EXTERNAL (olddecl))
2564 && DECL_CONTEXT (newdecl) == DECL_CONTEXT (olddecl))
2570 /* Get the LABEL_DECL corresponding to identifier ID as a label.
2571 Create one if none exists so far for the current function.
2572 This function is called for both label definitions and label references. */
2578 tree decl = IDENTIFIER_LABEL_VALUE (id);
2580 if (current_function_decl == 0)
2582 error ("label %s referenced outside of any function",
2583 IDENTIFIER_POINTER (id));
2587 /* Use a label already defined or ref'd with this name. */
2590 /* But not if it is inherited and wasn't declared to be inheritable. */
2591 if (DECL_CONTEXT (decl) != current_function_decl
2592 && ! C_DECLARED_LABEL_FLAG (decl))
2593 return shadow_label (id);
2597 decl = build_decl (LABEL_DECL, id, void_type_node);
2599 /* A label not explicitly declared must be local to where it's ref'd. */
2600 DECL_CONTEXT (decl) = current_function_decl;
2602 DECL_MODE (decl) = VOIDmode;
2604 /* Say where one reference is to the label,
2605 for the sake of the error if it is not defined. */
2606 DECL_SOURCE_LINE (decl) = lineno;
2607 DECL_SOURCE_FILE (decl) = input_filename;
2609 IDENTIFIER_LABEL_VALUE (id) = decl;
2611 named_labels = tree_cons (NULL_TREE, decl, named_labels);
2616 /* Make a label named NAME in the current function,
2617 shadowing silently any that may be inherited from containing functions
2618 or containing scopes.
2620 Note that valid use, if the label being shadowed
2621 comes from another scope in the same function,
2622 requires calling declare_nonlocal_label right away. */
2628 tree decl = IDENTIFIER_LABEL_VALUE (name);
2634 /* Check to make sure that the label hasn't already been declared
2635 at this label scope */
2636 for (dup = named_labels; dup; dup = TREE_CHAIN (dup))
2637 if (TREE_VALUE (dup) == decl)
2639 error ("duplicate label declaration `%s'",
2640 IDENTIFIER_POINTER (name));
2641 error_with_decl (TREE_VALUE (dup),
2642 "this is a previous declaration");
2643 /* Just use the previous declaration. */
2644 return lookup_label (name);
2647 shadowed_labels = tree_cons (NULL_TREE, decl, shadowed_labels);
2648 IDENTIFIER_LABEL_VALUE (name) = decl = 0;
2651 return lookup_label (name);
2654 /* Define a label, specifying the location in the source file.
2655 Return the LABEL_DECL node for the label, if the definition is valid.
2656 Otherwise return 0. */
2659 define_label (filename, line, name)
2660 const char *filename;
2664 tree decl = lookup_label (name);
2666 /* If label with this name is known from an outer context, shadow it. */
2667 if (decl != 0 && DECL_CONTEXT (decl) != current_function_decl)
2669 shadowed_labels = tree_cons (NULL_TREE, decl, shadowed_labels);
2670 IDENTIFIER_LABEL_VALUE (name) = 0;
2671 decl = lookup_label (name);
2674 if (warn_traditional && !in_system_header && lookup_name (name))
2675 warning_with_file_and_line (filename, line,
2676 "traditional C lacks a separate namespace for labels, identifier `%s' conflicts",
2677 IDENTIFIER_POINTER (name));
2679 if (DECL_INITIAL (decl) != 0)
2681 error_with_file_and_line (filename, line, "duplicate label `%s'",
2682 IDENTIFIER_POINTER (name));
2687 /* Mark label as having been defined. */
2688 DECL_INITIAL (decl) = error_mark_node;
2689 /* Say where in the source. */
2690 DECL_SOURCE_FILE (decl) = filename;
2691 DECL_SOURCE_LINE (decl) = line;
2696 /* Return the list of declarations of the current level.
2697 Note that this list is in reverse order unless/until
2698 you nreverse it; and when you do nreverse it, you must
2699 store the result back using `storedecls' or you will lose. */
2704 return current_binding_level->names;
2707 /* Return the list of type-tags (for structs, etc) of the current level. */
2712 return current_binding_level->tags;
2715 /* Store the list of declarations of the current level.
2716 This is done for the parameter declarations of a function being defined,
2717 after they are modified in the light of any missing parameters. */
2723 current_binding_level->names = decls;
2726 /* Similarly, store the list of tags of the current level. */
2732 current_binding_level->tags = tags;
2735 /* Given NAME, an IDENTIFIER_NODE,
2736 return the structure (or union or enum) definition for that name.
2737 Searches binding levels from BINDING_LEVEL up to the global level.
2738 If THISLEVEL_ONLY is nonzero, searches only the specified context
2739 (but skips any tag-transparent contexts to find one that is
2740 meaningful for tags).
2741 CODE says which kind of type the caller wants;
2742 it is RECORD_TYPE or UNION_TYPE or ENUMERAL_TYPE.
2743 If the wrong kind of type is found, an error is reported. */
2746 lookup_tag (code, name, binding_level, thislevel_only)
2747 enum tree_code code;
2748 struct binding_level *binding_level;
2752 struct binding_level *level;
2755 for (level = binding_level; level; level = level->level_chain)
2758 for (tail = level->tags; tail; tail = TREE_CHAIN (tail))
2760 if (TREE_PURPOSE (tail) == name)
2762 if (TREE_CODE (TREE_VALUE (tail)) != code)
2764 /* Definition isn't the kind we were looking for. */
2765 pending_invalid_xref = name;
2766 pending_invalid_xref_file = input_filename;
2767 pending_invalid_xref_line = lineno;
2768 /* If in the same binding level as a declaration as a tag
2769 of a different type, this must not be allowed to
2770 shadow that tag, so give the error immediately.
2771 (For example, "struct foo; union foo;" is invalid.) */
2773 pending_xref_error ();
2775 return TREE_VALUE (tail);
2778 if (! level->tag_transparent)
2788 /* Print an error message now
2789 for a recent invalid struct, union or enum cross reference.
2790 We don't print them immediately because they are not invalid
2791 when used in the `struct foo;' construct for shadowing. */
2794 pending_xref_error ()
2796 if (pending_invalid_xref != 0)
2797 error_with_file_and_line (pending_invalid_xref_file,
2798 pending_invalid_xref_line,
2799 "`%s' defined as wrong kind of tag",
2800 IDENTIFIER_POINTER (pending_invalid_xref));
2801 pending_invalid_xref = 0;
2804 /* Given a type, find the tag that was defined for it and return the tag name.
2805 Otherwise return 0. */
2808 lookup_tag_reverse (type)
2811 struct binding_level *level;
2813 for (level = current_binding_level; level; level = level->level_chain)
2816 for (tail = level->tags; tail; tail = TREE_CHAIN (tail))
2818 if (TREE_VALUE (tail) == type)
2819 return TREE_PURPOSE (tail);
2825 /* Look up NAME in the current binding level and its superiors
2826 in the namespace of variables, functions and typedefs.
2827 Return a ..._DECL node of some kind representing its definition,
2828 or return 0 if it is undefined. */
2836 if (current_binding_level != global_binding_level
2837 && IDENTIFIER_LOCAL_VALUE (name))
2838 val = IDENTIFIER_LOCAL_VALUE (name);
2840 val = IDENTIFIER_GLOBAL_VALUE (name);
2844 /* Similar to `lookup_name' but look only at current binding level. */
2847 lookup_name_current_level (name)
2852 if (current_binding_level == global_binding_level)
2853 return IDENTIFIER_GLOBAL_VALUE (name);
2855 if (IDENTIFIER_LOCAL_VALUE (name) == 0)
2858 for (t = current_binding_level->names; t; t = TREE_CHAIN (t))
2859 if (DECL_NAME (t) == name)
2865 /* Mark ARG for GC. */
2868 mark_binding_level (arg)
2871 struct binding_level *level = *(struct binding_level **) arg;
2873 for (; level != 0; level = level->level_chain)
2875 ggc_mark_tree (level->names);
2876 ggc_mark_tree (level->tags);
2877 ggc_mark_tree (level->shadowed);
2878 ggc_mark_tree (level->blocks);
2879 ggc_mark_tree (level->this_block);
2880 ggc_mark_tree (level->parm_order);
2884 /* Create the predefined scalar types of C,
2885 and some nodes representing standard constants (0, 1, (void *) 0).
2886 Initialize the global binding level.
2887 Make definitions for built-in primitive functions. */
2890 c_init_decl_processing ()
2893 tree ptr_ftype_void, ptr_ftype_ptr;
2895 /* Adds some ggc roots, and reserved words for c-parse.in. */
2898 current_function_decl = NULL;
2899 named_labels = NULL;
2900 current_binding_level = NULL_BINDING_LEVEL;
2901 free_binding_level = NULL_BINDING_LEVEL;
2903 /* Make the binding_level structure for global names. */
2905 global_binding_level = current_binding_level;
2907 build_common_tree_nodes (flag_signed_char);
2909 c_common_nodes_and_builtins ();
2911 boolean_type_node = integer_type_node;
2912 boolean_true_node = integer_one_node;
2913 boolean_false_node = integer_zero_node;
2915 /* With GCC, C99's _Bool is always of size 1. */
2916 c_bool_type_node = make_unsigned_type (CHAR_TYPE_SIZE);
2917 TREE_SET_CODE (c_bool_type_node, BOOLEAN_TYPE);
2918 TYPE_MAX_VALUE (c_bool_type_node) = build_int_2 (1, 0);
2919 TREE_TYPE (TYPE_MAX_VALUE (c_bool_type_node)) = c_bool_type_node;
2920 TYPE_PRECISION (c_bool_type_node) = 1;
2921 pushdecl (build_decl (TYPE_DECL, get_identifier ("_Bool"),
2923 c_bool_false_node = build_int_2 (0, 0);
2924 TREE_TYPE (c_bool_false_node) = c_bool_type_node;
2925 c_bool_true_node = build_int_2 (1, 0);
2926 TREE_TYPE (c_bool_true_node) = c_bool_type_node;
2928 endlink = void_list_node;
2929 ptr_ftype_void = build_function_type (ptr_type_node, endlink);
2931 = build_function_type (ptr_type_node,
2932 tree_cons (NULL_TREE, ptr_type_node, endlink));
2934 pedantic_lvalues = pedantic;
2936 make_fname_decl = c_make_fname_decl;
2937 start_fname_decls ();
2939 /* Record our roots. */
2941 ggc_add_tree_root (c_global_trees, CTI_MAX);
2942 ggc_add_root (&c_stmt_tree, 1, sizeof c_stmt_tree, mark_stmt_tree);
2943 ggc_add_tree_root (&c_scope_stmt_stack, 1);
2944 ggc_add_tree_root (&named_labels, 1);
2945 ggc_add_tree_root (&shadowed_labels, 1);
2946 ggc_add_root (¤t_binding_level, 1, sizeof current_binding_level,
2947 mark_binding_level);
2948 ggc_add_root (&label_level_chain, 1, sizeof label_level_chain,
2949 mark_binding_level);
2950 ggc_add_tree_root (&static_ctors, 1);
2951 ggc_add_tree_root (&static_dtors, 1);
2954 /* Create the VAR_DECL for __FUNCTION__ etc. ID is the name to give the
2955 decl, NAME is the initialization string and TYPE_DEP indicates whether
2956 NAME depended on the type of the function. As we don't yet implement
2957 delayed emission of static data, we mark the decl as emitted
2958 so it is not placed in the output. Anything using it must therefore pull
2959 out the STRING_CST initializer directly. This does mean that these names
2960 are string merging candidates, which is wrong for C99's __func__. FIXME. */
2963 c_make_fname_decl (id, type_dep)
2967 const char *name = fname_as_string (type_dep);
2968 tree decl, type, init;
2969 size_t length = strlen (name);
2971 type = build_array_type
2972 (build_qualified_type (char_type_node, TYPE_QUAL_CONST),
2973 build_index_type (size_int (length)));
2975 decl = build_decl (VAR_DECL, id, type);
2976 /* We don't push the decl, so have to set its context here. */
2977 DECL_CONTEXT (decl) = current_function_decl;
2979 TREE_STATIC (decl) = 1;
2980 TREE_READONLY (decl) = 1;
2981 DECL_ARTIFICIAL (decl) = 1;
2983 init = build_string (length + 1, name);
2984 TREE_TYPE (init) = type;
2985 DECL_INITIAL (decl) = init;
2987 TREE_USED (decl) = 1;
2989 finish_decl (decl, init, NULL_TREE);
2994 /* Return a definition for a builtin function named NAME and whose data type
2995 is TYPE. TYPE should be a function type with argument types.
2996 FUNCTION_CODE tells later passes how to compile calls to this function.
2997 See tree.h for its possible values.
2999 If LIBRARY_NAME is nonzero, use that for DECL_ASSEMBLER_NAME,
3000 the name to be called if we can't opencode the function. */
3003 builtin_function (name, type, function_code, class, library_name)
3007 enum built_in_class class;
3008 const char *library_name;
3010 tree decl = build_decl (FUNCTION_DECL, get_identifier (name), type);
3011 DECL_EXTERNAL (decl) = 1;
3012 TREE_PUBLIC (decl) = 1;
3014 SET_DECL_ASSEMBLER_NAME (decl, get_identifier (library_name));
3015 make_decl_rtl (decl, NULL);
3017 DECL_BUILT_IN_CLASS (decl) = class;
3018 DECL_FUNCTION_CODE (decl) = function_code;
3020 /* The return builtins leave the current function. */
3021 if (function_code == BUILT_IN_RETURN || function_code == BUILT_IN_EH_RETURN)
3022 TREE_THIS_VOLATILE (decl) = 1;
3024 /* Warn if a function in the namespace for users
3025 is used without an occasion to consider it declared. */
3026 if (name[0] != '_' || name[1] != '_')
3027 C_DECL_ANTICIPATED (decl) = 1;
3029 /* Possibly apply some default attributes to this built-in function. */
3030 decl_attributes (&decl, NULL_TREE, 0);
3035 /* Apply default attributes to a function, if a system function with default
3039 c_insert_default_attributes (decl)
3042 if (!TREE_PUBLIC (decl))
3044 c_common_insert_default_attributes (decl);
3047 /* Called when a declaration is seen that contains no names to declare.
3048 If its type is a reference to a structure, union or enum inherited
3049 from a containing scope, shadow that tag name for the current scope
3050 with a forward reference.
3051 If its type defines a new named structure or union
3052 or defines an enum, it is valid but we need not do anything here.
3053 Otherwise, it is an error. */
3056 shadow_tag (declspecs)
3059 shadow_tag_warned (declspecs, 0);
3063 shadow_tag_warned (declspecs, warned)
3066 /* 1 => we have done a pedwarn. 2 => we have done a warning, but
3073 pending_invalid_xref = 0;
3075 /* Remove the attributes from declspecs, since they will confuse the
3077 split_specs_attrs (declspecs, &specs, &attrs);
3079 for (link = specs; link; link = TREE_CHAIN (link))
3081 tree value = TREE_VALUE (link);
3082 enum tree_code code = TREE_CODE (value);
3084 if (code == RECORD_TYPE || code == UNION_TYPE || code == ENUMERAL_TYPE)
3085 /* Used to test also that TYPE_SIZE (value) != 0.
3086 That caused warning for `struct foo;' at top level in the file. */
3088 tree name = lookup_tag_reverse (value);
3095 if (warned != 1 && code != ENUMERAL_TYPE)
3096 /* Empty unnamed enum OK */
3098 pedwarn ("unnamed struct/union that defines no instances");
3104 t = lookup_tag (code, name, current_binding_level, 1);
3108 t = make_node (code);
3115 if (!warned && ! in_system_header)
3117 warning ("useless keyword or type name in empty declaration");
3124 error ("two types specified in one empty declaration");
3129 pedwarn ("empty declaration");
3133 /* Construct an array declarator. EXPR is the expression inside [], or
3134 NULL_TREE. QUALS are the type qualifiers inside the [] (to be applied
3135 to the pointer to which a parameter array is converted). STATIC_P is
3136 non-zero if "static" is inside the [], zero otherwise. VLA_UNSPEC_P
3137 is non-zero is the array is [*], a VLA of unspecified length which is
3138 nevertheless a complete type (not currently implemented by GCC),
3139 zero otherwise. The declarator is constructed as an ARRAY_REF
3140 (to be decoded by grokdeclarator), whose operand 0 is what's on the
3141 left of the [] (filled by in set_array_declarator_type) and operand 1
3142 is the expression inside; whose TREE_TYPE is the type qualifiers and
3143 which has TREE_STATIC set if "static" is used. */
3146 build_array_declarator (expr, quals, static_p, vla_unspec_p)
3153 decl = build_nt (ARRAY_REF, NULL_TREE, expr);
3154 TREE_TYPE (decl) = quals;
3155 TREE_STATIC (decl) = (static_p ? 1 : 0);
3156 if (pedantic && !flag_isoc99)
3158 if (static_p || quals != NULL_TREE)
3159 pedwarn ("ISO C89 does not support `static' or type qualifiers in parameter array declarators");
3161 pedwarn ("ISO C89 does not support `[*]' array declarators");
3164 warning ("GCC does not yet properly implement `[*]' array declarators");
3168 /* Set the type of an array declarator. DECL is the declarator, as
3169 constructed by build_array_declarator; TYPE is what appears on the left
3170 of the [] and goes in operand 0. ABSTRACT_P is non-zero if it is an
3171 abstract declarator, zero otherwise; this is used to reject static and
3172 type qualifiers in abstract declarators, where they are not in the
3176 set_array_declarator_type (decl, type, abstract_p)
3181 TREE_OPERAND (decl, 0) = type;
3182 if (abstract_p && (TREE_TYPE (decl) != NULL_TREE || TREE_STATIC (decl)))
3183 error ("static or type qualifiers in abstract declarator");
3187 /* Decode a "typename", such as "int **", returning a ..._TYPE node. */
3190 groktypename (typename)
3195 if (TREE_CODE (typename) != TREE_LIST)
3198 split_specs_attrs (TREE_PURPOSE (typename), &specs, &attrs);
3200 typename = grokdeclarator (TREE_VALUE (typename), specs, TYPENAME, 0);
3202 /* Apply attributes. */
3203 decl_attributes (&typename, attrs, 0);
3208 /* Return a PARM_DECL node for a given pair of specs and declarator. */
3211 groktypename_in_parm_context (typename)
3214 if (TREE_CODE (typename) != TREE_LIST)
3216 return grokdeclarator (TREE_VALUE (typename),
3217 TREE_PURPOSE (typename),
3221 /* Decode a declarator in an ordinary declaration or data definition.
3222 This is called as soon as the type information and variable name
3223 have been parsed, before parsing the initializer if any.
3224 Here we create the ..._DECL node, fill in its type,
3225 and put it on the list of decls for the current context.
3226 The ..._DECL node is returned as the value.
3228 Exception: for arrays where the length is not specified,
3229 the type is left null, to be filled in by `finish_decl'.
3231 Function definitions do not come here; they go to start_function
3232 instead. However, external and forward declarations of functions
3233 do go through here. Structure field declarations are done by
3234 grokfield and not through here. */
3237 start_decl (declarator, declspecs, initialized, attributes)
3238 tree declarator, declspecs;
3245 /* An object declared as __attribute__((deprecated)) suppresses
3246 warnings of uses of other deprecated items. */
3247 if (lookup_attribute ("deprecated", attributes))
3248 deprecated_state = DEPRECATED_SUPPRESS;
3250 decl = grokdeclarator (declarator, declspecs,
3251 NORMAL, initialized);
3253 deprecated_state = DEPRECATED_NORMAL;
3255 if (warn_main > 0 && TREE_CODE (decl) != FUNCTION_DECL
3256 && MAIN_NAME_P (DECL_NAME (decl)))
3257 warning_with_decl (decl, "`%s' is usually a function");
3260 /* Is it valid for this decl to have an initializer at all?
3261 If not, set INITIALIZED to zero, which will indirectly
3262 tell `finish_decl' to ignore the initializer once it is parsed. */
3263 switch (TREE_CODE (decl))
3266 /* typedef foo = bar means give foo the same type as bar.
3267 We haven't parsed bar yet, so `finish_decl' will fix that up.
3268 Any other case of an initialization in a TYPE_DECL is an error. */
3269 if (pedantic || list_length (declspecs) > 1)
3271 error ("typedef `%s' is initialized",
3272 IDENTIFIER_POINTER (DECL_NAME (decl)));
3278 error ("function `%s' is initialized like a variable",
3279 IDENTIFIER_POINTER (DECL_NAME (decl)));
3284 /* DECL_INITIAL in a PARM_DECL is really DECL_ARG_TYPE. */
3285 error ("parameter `%s' is initialized",
3286 IDENTIFIER_POINTER (DECL_NAME (decl)));
3291 /* Don't allow initializations for incomplete types
3292 except for arrays which might be completed by the initialization. */
3294 /* This can happen if the array size is an undefined macro. We already
3295 gave a warning, so we don't need another one. */
3296 if (TREE_TYPE (decl) == error_mark_node)
3298 else if (COMPLETE_TYPE_P (TREE_TYPE (decl)))
3300 /* A complete type is ok if size is fixed. */
3302 if (TREE_CODE (TYPE_SIZE (TREE_TYPE (decl))) != INTEGER_CST
3303 || C_DECL_VARIABLE_SIZE (decl))
3305 error ("variable-sized object may not be initialized");
3309 else if (TREE_CODE (TREE_TYPE (decl)) != ARRAY_TYPE)
3311 error ("variable `%s' has initializer but incomplete type",
3312 IDENTIFIER_POINTER (DECL_NAME (decl)));
3315 else if (!COMPLETE_TYPE_P (TREE_TYPE (TREE_TYPE (decl))))
3317 error ("elements of array `%s' have incomplete type",
3318 IDENTIFIER_POINTER (DECL_NAME (decl)));
3326 /* Seems redundant with grokdeclarator. */
3327 if (current_binding_level != global_binding_level
3328 && DECL_EXTERNAL (decl)
3329 && TREE_CODE (decl) != FUNCTION_DECL)
3330 warning ("declaration of `%s' has `extern' and is initialized",
3331 IDENTIFIER_POINTER (DECL_NAME (decl)));
3333 DECL_EXTERNAL (decl) = 0;
3334 if (current_binding_level == global_binding_level)
3335 TREE_STATIC (decl) = 1;
3337 /* Tell `pushdecl' this is an initialized decl
3338 even though we don't yet have the initializer expression.
3339 Also tell `finish_decl' it may store the real initializer. */
3340 DECL_INITIAL (decl) = error_mark_node;
3343 /* If this is a function declaration, write a record describing it to the
3344 prototypes file (if requested). */
3346 if (TREE_CODE (decl) == FUNCTION_DECL)
3347 gen_aux_info_record (decl, 0, 0, TYPE_ARG_TYPES (TREE_TYPE (decl)) != 0);
3349 /* ANSI specifies that a tentative definition which is not merged with
3350 a non-tentative definition behaves exactly like a definition with an
3351 initializer equal to zero. (Section 3.7.2)
3352 -fno-common gives strict ANSI behavior. Usually you don't want it.
3353 This matters only for variables with external linkage. */
3354 if (!initialized && (! flag_no_common || ! TREE_PUBLIC (decl)))
3355 DECL_COMMON (decl) = 1;
3357 /* Set attributes here so if duplicate decl, will have proper attributes. */
3358 decl_attributes (&decl, attributes, 0);
3360 /* If #pragma weak was used, mark the decl weak now. */
3361 if (current_binding_level == global_binding_level)
3362 maybe_apply_pragma_weak (decl);
3364 if (TREE_CODE (decl) == FUNCTION_DECL
3365 && DECL_DECLARED_INLINE_P (decl)
3366 && DECL_UNINLINABLE (decl)
3367 && lookup_attribute ("noinline", DECL_ATTRIBUTES (decl)))
3368 warning_with_decl (decl,
3369 "inline function `%s' given attribute noinline");
3371 /* Add this decl to the current binding level.
3372 TEM may equal DECL or it may be a previous decl of the same name. */
3373 tem = pushdecl (decl);
3375 /* For a local variable, define the RTL now. */
3376 if (current_binding_level != global_binding_level
3377 /* But not if this is a duplicate decl
3378 and we preserved the rtl from the previous one
3379 (which may or may not happen). */
3380 && !DECL_RTL_SET_P (tem)
3381 && !DECL_CONTEXT (tem))
3383 if (TREE_TYPE (tem) != error_mark_node
3384 && COMPLETE_TYPE_P (TREE_TYPE (tem)))
3386 else if (TREE_CODE (TREE_TYPE (tem)) == ARRAY_TYPE
3387 && DECL_INITIAL (tem) != 0)
3394 /* Finish processing of a declaration;
3395 install its initial value.
3396 If the length of an array type is not known before,
3397 it must be determined now, from the initial value, or it is an error. */
3400 finish_decl (decl, init, asmspec_tree)
3404 tree type = TREE_TYPE (decl);
3405 int was_incomplete = (DECL_SIZE (decl) == 0);
3406 const char *asmspec = 0;
3408 /* If a name was specified, get the string. */
3409 if (current_binding_level == global_binding_level)
3410 asmspec_tree = maybe_apply_renaming_pragma (decl, asmspec_tree);
3412 asmspec = TREE_STRING_POINTER (asmspec_tree);
3414 /* If `start_decl' didn't like having an initialization, ignore it now. */
3415 if (init != 0 && DECL_INITIAL (decl) == 0)
3418 /* Don't crash if parm is initialized. */
3419 if (TREE_CODE (decl) == PARM_DECL)
3424 if (TREE_CODE (decl) != TYPE_DECL)
3425 store_init_value (decl, init);
3428 /* typedef foo = bar; store the type of bar as the type of foo. */
3429 TREE_TYPE (decl) = TREE_TYPE (init);
3430 DECL_INITIAL (decl) = init = 0;
3434 /* Deduce size of array from initialization, if not already known */
3435 if (TREE_CODE (type) == ARRAY_TYPE
3436 && TYPE_DOMAIN (type) == 0
3437 && TREE_CODE (decl) != TYPE_DECL)
3440 = (TREE_STATIC (decl)
3441 /* Even if pedantic, an external linkage array
3442 may have incomplete type at first. */
3443 ? pedantic && !TREE_PUBLIC (decl)
3444 : !DECL_EXTERNAL (decl));
3446 = complete_array_type (type, DECL_INITIAL (decl), do_default);
3448 /* Get the completed type made by complete_array_type. */
3449 type = TREE_TYPE (decl);
3452 error_with_decl (decl, "initializer fails to determine size of `%s'");
3454 else if (failure == 2)
3457 error_with_decl (decl, "array size missing in `%s'");
3458 /* If a `static' var's size isn't known,
3459 make it extern as well as static, so it does not get
3461 If it is not `static', then do not mark extern;
3462 finish_incomplete_decl will give it a default size
3463 and it will get allocated. */
3464 else if (!pedantic && TREE_STATIC (decl) && ! TREE_PUBLIC (decl))
3465 DECL_EXTERNAL (decl) = 1;
3468 /* TYPE_MAX_VALUE is always one less than the number of elements
3469 in the array, because we start counting at zero. Therefore,
3470 warn only if the value is less than zero. */
3471 else if (pedantic && TYPE_DOMAIN (type) != 0
3472 && tree_int_cst_sgn (TYPE_MAX_VALUE (TYPE_DOMAIN (type))) < 0)
3473 error_with_decl (decl, "zero or negative size array `%s'");
3475 layout_decl (decl, 0);
3478 if (TREE_CODE (decl) == VAR_DECL)
3480 if (DECL_SIZE (decl) == 0 && TREE_TYPE (decl) != error_mark_node
3481 && COMPLETE_TYPE_P (TREE_TYPE (decl)))
3482 layout_decl (decl, 0);
3484 if (DECL_SIZE (decl) == 0
3485 /* Don't give an error if we already gave one earlier. */
3486 && TREE_TYPE (decl) != error_mark_node
3487 && (TREE_STATIC (decl)
3489 /* A static variable with an incomplete type
3490 is an error if it is initialized.
3491 Also if it is not file scope.
3492 Otherwise, let it through, but if it is not `extern'
3493 then it may cause an error message later. */
3494 (DECL_INITIAL (decl) != 0
3495 || DECL_CONTEXT (decl) != 0)
3497 /* An automatic variable with an incomplete type
3499 !DECL_EXTERNAL (decl)))
3501 error_with_decl (decl, "storage size of `%s' isn't known");
3502 TREE_TYPE (decl) = error_mark_node;
3505 if ((DECL_EXTERNAL (decl) || TREE_STATIC (decl))
3506 && DECL_SIZE (decl) != 0)
3508 if (TREE_CODE (DECL_SIZE (decl)) == INTEGER_CST)
3509 constant_expression_warning (DECL_SIZE (decl));
3511 error_with_decl (decl, "storage size of `%s' isn't constant");
3514 if (TREE_USED (type))
3515 TREE_USED (decl) = 1;
3518 /* If this is a function and an assembler name is specified, it isn't
3519 builtin any more. Also reset DECL_RTL so we can give it its new
3521 if (TREE_CODE (decl) == FUNCTION_DECL && asmspec)
3523 DECL_BUILT_IN_CLASS (decl) = NOT_BUILT_IN;
3524 SET_DECL_RTL (decl, NULL_RTX);
3525 SET_DECL_ASSEMBLER_NAME (decl, get_identifier (asmspec));
3528 /* Output the assembler code and/or RTL code for variables and functions,
3529 unless the type is an undefined structure or union.
3530 If not, it will get done when the type is completed. */
3532 if (TREE_CODE (decl) == VAR_DECL || TREE_CODE (decl) == FUNCTION_DECL)
3534 /* This is a no-op in c-lang.c or something real in objc-actions.c. */
3535 maybe_objc_check_decl (decl);
3537 if (!DECL_CONTEXT (decl))
3539 if (DECL_INITIAL (decl) == NULL_TREE
3540 || DECL_INITIAL (decl) == error_mark_node)
3541 /* Don't output anything
3542 when a tentative file-scope definition is seen.
3543 But at end of compilation, do output code for them. */
3544 DECL_DEFER_OUTPUT (decl) = 1;
3545 rest_of_decl_compilation (decl, asmspec,
3546 (DECL_CONTEXT (decl) == 0
3547 || TREE_ASM_WRITTEN (decl)), 0);
3551 /* This is a local variable. If there is an ASMSPEC, the
3552 user has requested that we handle it specially. */
3555 /* In conjunction with an ASMSPEC, the `register'
3556 keyword indicates that we should place the variable
3557 in a particular register. */
3558 if (DECL_REGISTER (decl))
3559 DECL_C_HARD_REGISTER (decl) = 1;
3561 /* If this is not a static variable, issue a warning.
3562 It doesn't make any sense to give an ASMSPEC for an
3563 ordinary, non-register local variable. Historically,
3564 GCC has accepted -- but ignored -- the ASMSPEC in
3566 if (TREE_CODE (decl) == VAR_DECL
3567 && !DECL_REGISTER (decl)
3568 && !TREE_STATIC (decl))
3569 warning_with_decl (decl,
3570 "ignoring asm-specifier for non-static local variable `%s'");
3572 SET_DECL_ASSEMBLER_NAME (decl, get_identifier (asmspec));
3575 if (TREE_CODE (decl) != FUNCTION_DECL)
3576 add_decl_stmt (decl);
3579 if (DECL_CONTEXT (decl) != 0)
3581 /* Recompute the RTL of a local array now
3582 if it used to be an incomplete type. */
3584 && ! TREE_STATIC (decl) && ! DECL_EXTERNAL (decl))
3586 /* If we used it already as memory, it must stay in memory. */
3587 TREE_ADDRESSABLE (decl) = TREE_USED (decl);
3588 /* If it's still incomplete now, no init will save it. */
3589 if (DECL_SIZE (decl) == 0)
3590 DECL_INITIAL (decl) = 0;
3595 if (TREE_CODE (decl) == TYPE_DECL)
3597 /* This is a no-op in c-lang.c or something real in objc-actions.c. */
3598 maybe_objc_check_decl (decl);
3599 rest_of_decl_compilation (decl, NULL, DECL_CONTEXT (decl) == 0, 0);
3602 /* At the end of a declaration, throw away any variable type sizes
3603 of types defined inside that declaration. There is no use
3604 computing them in the following function definition. */
3605 if (current_binding_level == global_binding_level)
3606 get_pending_sizes ();
3609 /* Given a parsed parameter declaration,
3610 decode it into a PARM_DECL and push that on the current binding level.
3611 Also, for the sake of forward parm decls,
3612 record the given order of parms in `parm_order'. */
3615 push_parm_decl (parm)
3619 int old_immediate_size_expand = immediate_size_expand;
3620 /* Don't try computing parm sizes now -- wait till fn is called. */
3621 immediate_size_expand = 0;
3623 decl = grokdeclarator (TREE_VALUE (TREE_PURPOSE (parm)),
3624 TREE_PURPOSE (TREE_PURPOSE (parm)), PARM, 0);
3625 decl_attributes (&decl, TREE_VALUE (parm), 0);
3628 if (DECL_NAME (decl))
3631 olddecl = lookup_name (DECL_NAME (decl));
3632 if (pedantic && olddecl != 0 && TREE_CODE (olddecl) == TYPE_DECL)
3633 pedwarn_with_decl (decl,
3634 "ISO C forbids parameter `%s' shadowing typedef");
3638 decl = pushdecl (decl);
3640 immediate_size_expand = old_immediate_size_expand;
3642 current_binding_level->parm_order
3643 = tree_cons (NULL_TREE, decl, current_binding_level->parm_order);
3645 /* Add this decl to the current binding level. */
3646 finish_decl (decl, NULL_TREE, NULL_TREE);
3649 /* Clear the given order of parms in `parm_order'.
3650 Used at start of parm list,
3651 and also at semicolon terminating forward decls. */
3656 current_binding_level->parm_order = NULL_TREE;
3659 /* Build a COMPOUND_LITERAL_EXPR. TYPE is the type given in the compound
3660 literal, which may be an incomplete array type completed by the
3661 initializer; INIT is a CONSTRUCTOR that initializes the compound
3665 build_compound_literal (type, init)
3669 /* We do not use start_decl here because we have a type, not a declarator;
3670 and do not use finish_decl because the decl should be stored inside
3671 the COMPOUND_LITERAL_EXPR rather than added elsewhere as a DECL_STMT. */
3672 tree decl = build_decl (VAR_DECL, NULL_TREE, type);
3675 DECL_EXTERNAL (decl) = 0;
3676 TREE_PUBLIC (decl) = 0;
3677 TREE_STATIC (decl) = (current_binding_level == global_binding_level);
3678 DECL_CONTEXT (decl) = current_function_decl;
3679 TREE_USED (decl) = 1;
3680 TREE_TYPE (decl) = type;
3681 store_init_value (decl, init);
3683 if (TREE_CODE (type) == ARRAY_TYPE && !COMPLETE_TYPE_P (type))
3685 int failure = complete_array_type (type, DECL_INITIAL (decl), 1);
3690 type = TREE_TYPE (decl);
3691 if (type == error_mark_node || !COMPLETE_TYPE_P (type))
3692 return error_mark_node;
3694 stmt = build_stmt (DECL_STMT, decl);
3695 complit = build1 (COMPOUND_LITERAL_EXPR, TREE_TYPE (decl), stmt);
3696 TREE_SIDE_EFFECTS (complit) = 1;
3698 layout_decl (decl, 0);
3700 if (TREE_STATIC (decl))
3702 /* This decl needs a name for the assembler output. We also need
3703 a unique suffix to be added to the name, for which DECL_CONTEXT
3705 DECL_NAME (decl) = get_identifier ("__compound_literal");
3706 DECL_CONTEXT (decl) = complit;
3707 rest_of_decl_compilation (decl, NULL, 1, 0);
3708 DECL_CONTEXT (decl) = NULL_TREE;
3714 /* Make TYPE a complete type based on INITIAL_VALUE.
3715 Return 0 if successful, 1 if INITIAL_VALUE can't be deciphered,
3716 2 if there was no information (in which case assume 1 if DO_DEFAULT). */
3719 complete_array_type (type, initial_value, do_default)
3724 tree maxindex = NULL_TREE;
3729 /* Note MAXINDEX is really the maximum index,
3730 one less than the size. */
3731 if (TREE_CODE (initial_value) == STRING_CST)
3734 = int_size_in_bytes (TREE_TYPE (TREE_TYPE (initial_value)));
3735 maxindex = build_int_2 ((TREE_STRING_LENGTH (initial_value)
3738 else if (TREE_CODE (initial_value) == CONSTRUCTOR)
3740 tree elts = CONSTRUCTOR_ELTS (initial_value);
3741 maxindex = build_int_2 (-1, -1);
3742 for (; elts; elts = TREE_CHAIN (elts))
3744 if (TREE_PURPOSE (elts))
3745 maxindex = TREE_PURPOSE (elts);
3747 maxindex = fold (build (PLUS_EXPR, integer_type_node,
3748 maxindex, integer_one_node));
3750 maxindex = copy_node (maxindex);
3754 /* Make an error message unless that happened already. */
3755 if (initial_value != error_mark_node)
3758 /* Prevent further error messages. */
3759 maxindex = build_int_2 (0, 0);
3766 maxindex = build_int_2 (0, 0);
3772 TYPE_DOMAIN (type) = build_index_type (maxindex);
3773 if (!TREE_TYPE (maxindex))
3774 TREE_TYPE (maxindex) = TYPE_DOMAIN (type);
3777 /* Lay out the type now that we can get the real answer. */
3784 /* Given declspecs and a declarator,
3785 determine the name and type of the object declared
3786 and construct a ..._DECL node for it.
3787 (In one case we can return a ..._TYPE node instead.
3788 For invalid input we sometimes return 0.)
3790 DECLSPECS is a chain of tree_list nodes whose value fields
3791 are the storage classes and type specifiers.
3793 DECL_CONTEXT says which syntactic context this declaration is in:
3794 NORMAL for most contexts. Make a VAR_DECL or FUNCTION_DECL or TYPE_DECL.
3795 FUNCDEF for a function definition. Like NORMAL but a few different
3796 error messages in each case. Return value may be zero meaning
3797 this definition is too screwy to try to parse.
3798 PARM for a parameter declaration (either within a function prototype
3799 or before a function body). Make a PARM_DECL, or return void_type_node.
3800 TYPENAME if for a typename (in a cast or sizeof).
3801 Don't make a DECL node; just return the ..._TYPE node.
3802 FIELD for a struct or union field; make a FIELD_DECL.
3803 BITFIELD for a field with specified width.
3804 INITIALIZED is 1 if the decl has an initializer.
3806 In the TYPENAME case, DECLARATOR is really an absolute declarator.
3807 It may also be so in the PARM case, for a prototype where the
3808 argument type is specified but not the name.
3810 This function is where the complicated C meanings of `static'
3811 and `extern' are interpreted. */
3814 grokdeclarator (declarator, declspecs, decl_context, initialized)
3817 enum decl_context decl_context;
3822 tree type = NULL_TREE;
3827 int type_quals = TYPE_UNQUALIFIED;
3829 int explicit_int = 0;
3830 int explicit_char = 0;
3831 int defaulted_int = 0;
3832 tree typedef_decl = 0;
3834 tree typedef_type = 0;
3835 int funcdef_flag = 0;
3836 enum tree_code innermost_code = ERROR_MARK;
3838 int size_varies = 0;
3839 tree decl_attr = NULL_TREE;
3840 tree array_ptr_quals = NULL_TREE;
3841 int array_parm_static = 0;
3842 tree returned_attrs = NULL_TREE;
3844 if (decl_context == BITFIELD)
3845 bitfield = 1, decl_context = FIELD;
3847 if (decl_context == FUNCDEF)
3848 funcdef_flag = 1, decl_context = NORMAL;
3850 /* Look inside a declarator for the name being declared
3851 and get it as a string, for an error message. */
3853 tree decl = declarator;
3857 switch (TREE_CODE (decl))
3862 innermost_code = TREE_CODE (decl);
3863 decl = TREE_OPERAND (decl, 0);
3867 decl = TREE_VALUE (decl);
3870 case IDENTIFIER_NODE:
3871 name = IDENTIFIER_POINTER (decl);
3882 /* A function definition's declarator must have the form of
3883 a function declarator. */
3885 if (funcdef_flag && innermost_code != CALL_EXPR)
3888 /* Anything declared one level down from the top level
3889 must be one of the parameters of a function
3890 (because the body is at least two levels down). */
3892 /* If this looks like a function definition, make it one,
3893 even if it occurs where parms are expected.
3894 Then store_parm_decls will reject it and not use it as a parm. */
3895 if (decl_context == NORMAL && !funcdef_flag
3896 && current_binding_level->parm_flag)
3897 decl_context = PARM;
3899 /* Look through the decl specs and record which ones appear.
3900 Some typespecs are defined as built-in typenames.
3901 Others, the ones that are modifiers of other types,
3902 are represented by bits in SPECBITS: set the bits for
3903 the modifiers that appear. Storage class keywords are also in SPECBITS.
3905 If there is a typedef name or a type, store the type in TYPE.
3906 This includes builtin typedefs such as `int'.
3908 Set EXPLICIT_INT or EXPLICIT_CHAR if the type is `int' or `char'
3909 and did not come from a user typedef.
3911 Set LONGLONG if `long' is mentioned twice. */
3913 for (spec = declspecs; spec; spec = TREE_CHAIN (spec))
3915 tree id = TREE_VALUE (spec);
3917 /* If the entire declaration is itself tagged as deprecated then
3918 suppress reports of deprecated items. */
3919 if (id && TREE_DEPRECATED (id))
3921 if (deprecated_state != DEPRECATED_SUPPRESS)
3922 warn_deprecated_use (id);
3925 if (id == ridpointers[(int) RID_INT])
3927 if (id == ridpointers[(int) RID_CHAR])
3930 if (TREE_CODE (id) == IDENTIFIER_NODE && C_IS_RESERVED_WORD (id))
3932 enum rid i = C_RID_CODE (id);
3933 if ((int) i <= (int) RID_LAST_MODIFIER)
3935 if (i == RID_LONG && (specbits & (1 << (int) i)))
3938 error ("`long long long' is too long for GCC");
3941 if (pedantic && !flag_isoc99 && ! in_system_header
3943 pedwarn ("ISO C89 does not support `long long'");
3947 else if (specbits & (1 << (int) i))
3948 pedwarn ("duplicate `%s'", IDENTIFIER_POINTER (id));
3949 specbits |= 1 << (int) i;
3954 error ("two or more data types in declaration of `%s'", name);
3955 /* Actual typedefs come to us as TYPE_DECL nodes. */
3956 else if (TREE_CODE (id) == TYPE_DECL)
3958 if (TREE_TYPE (id) == error_mark_node)
3959 ; /* Allow the type to default to int to avoid cascading errors. */
3962 type = TREE_TYPE (id);
3963 decl_attr = DECL_ATTRIBUTES (id);
3967 /* Built-in types come as identifiers. */
3968 else if (TREE_CODE (id) == IDENTIFIER_NODE)
3970 tree t = lookup_name (id);
3971 if (TREE_TYPE (t) == error_mark_node)
3973 else if (!t || TREE_CODE (t) != TYPE_DECL)
3974 error ("`%s' fails to be a typedef or built in type",
3975 IDENTIFIER_POINTER (id));
3978 type = TREE_TYPE (t);
3982 else if (TREE_CODE (id) != ERROR_MARK)
3989 typedef_type = type;
3991 size_varies = C_TYPE_VARIABLE_SIZE (type);
3993 /* No type at all: default to `int', and set DEFAULTED_INT
3994 because it was not a user-defined typedef. */
3998 if ((! (specbits & ((1 << (int) RID_LONG) | (1 << (int) RID_SHORT)
3999 | (1 << (int) RID_SIGNED)
4000 | (1 << (int) RID_UNSIGNED)
4001 | (1 << (int) RID_COMPLEX))))
4002 /* Don't warn about typedef foo = bar. */
4003 && ! (specbits & (1 << (int) RID_TYPEDEF) && initialized)
4004 && ! in_system_header)
4006 /* Issue a warning if this is an ISO C 99 program or if -Wreturn-type
4007 and this is a function, or if -Wimplicit; prefer the former
4008 warning since it is more explicit. */
4009 if ((warn_implicit_int || warn_return_type || flag_isoc99)
4011 warn_about_return_type = 1;
4012 else if (warn_implicit_int || flag_isoc99)
4013 pedwarn_c99 ("type defaults to `int' in declaration of `%s'",
4018 type = integer_type_node;
4021 /* Now process the modifiers that were specified
4022 and check for invalid combinations. */
4024 /* Long double is a special combination. */
4026 if ((specbits & 1 << (int) RID_LONG) && ! longlong
4027 && TYPE_MAIN_VARIANT (type) == double_type_node)
4029 specbits &= ~(1 << (int) RID_LONG);
4030 type = long_double_type_node;
4033 /* Check all other uses of type modifiers. */
4035 if (specbits & ((1 << (int) RID_LONG) | (1 << (int) RID_SHORT)
4036 | (1 << (int) RID_UNSIGNED) | (1 << (int) RID_SIGNED)))
4040 if ((specbits & 1 << (int) RID_LONG)
4041 && (specbits & 1 << (int) RID_SHORT))
4042 error ("both long and short specified for `%s'", name);
4043 else if (((specbits & 1 << (int) RID_LONG)
4044 || (specbits & 1 << (int) RID_SHORT))
4046 error ("long or short specified with char for `%s'", name);
4047 else if (((specbits & 1 << (int) RID_LONG)
4048 || (specbits & 1 << (int) RID_SHORT))
4049 && TREE_CODE (type) == REAL_TYPE)
4051 static int already = 0;
4053 error ("long or short specified with floating type for `%s'", name);
4054 if (! already && ! pedantic)
4056 error ("the only valid combination is `long double'");
4060 else if ((specbits & 1 << (int) RID_SIGNED)
4061 && (specbits & 1 << (int) RID_UNSIGNED))
4062 error ("both signed and unsigned specified for `%s'", name);
4063 else if (TREE_CODE (type) != INTEGER_TYPE)
4064 error ("long, short, signed or unsigned invalid for `%s'", name);
4068 if (!explicit_int && !defaulted_int && !explicit_char && pedantic)
4070 pedwarn ("long, short, signed or unsigned used invalidly for `%s'",
4072 if (flag_pedantic_errors)
4077 /* Discard the type modifiers if they are invalid. */
4080 specbits &= ~((1 << (int) RID_LONG) | (1 << (int) RID_SHORT)
4081 | (1 << (int) RID_UNSIGNED) | (1 << (int) RID_SIGNED));
4086 if ((specbits & (1 << (int) RID_COMPLEX))
4087 && TREE_CODE (type) != INTEGER_TYPE && TREE_CODE (type) != REAL_TYPE)
4089 error ("complex invalid for `%s'", name);
4090 specbits &= ~(1 << (int) RID_COMPLEX);
4093 /* Decide whether an integer type is signed or not.
4094 Optionally treat bitfields as signed by default. */
4095 if (specbits & 1 << (int) RID_UNSIGNED
4096 || (bitfield && ! flag_signed_bitfields
4097 && (explicit_int || defaulted_int || explicit_char
4098 /* A typedef for plain `int' without `signed'
4099 can be controlled just like plain `int'. */
4100 || ! (typedef_decl != 0
4101 && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl)))
4102 && TREE_CODE (type) != ENUMERAL_TYPE
4103 && !(specbits & 1 << (int) RID_SIGNED)))
4106 type = long_long_unsigned_type_node;
4107 else if (specbits & 1 << (int) RID_LONG)
4108 type = long_unsigned_type_node;
4109 else if (specbits & 1 << (int) RID_SHORT)
4110 type = short_unsigned_type_node;
4111 else if (type == char_type_node)
4112 type = unsigned_char_type_node;
4113 else if (typedef_decl)
4114 type = c_common_unsigned_type (type);
4116 type = unsigned_type_node;
4118 else if ((specbits & 1 << (int) RID_SIGNED)
4119 && type == char_type_node)
4120 type = signed_char_type_node;
4122 type = long_long_integer_type_node;
4123 else if (specbits & 1 << (int) RID_LONG)
4124 type = long_integer_type_node;
4125 else if (specbits & 1 << (int) RID_SHORT)
4126 type = short_integer_type_node;
4128 if (specbits & 1 << (int) RID_COMPLEX)
4130 if (pedantic && !flag_isoc99)
4131 pedwarn ("ISO C89 does not support complex types");
4132 /* If we just have "complex", it is equivalent to
4133 "complex double", but if any modifiers at all are specified it is
4134 the complex form of TYPE. E.g, "complex short" is
4135 "complex short int". */
4137 if (defaulted_int && ! longlong
4138 && ! (specbits & ((1 << (int) RID_LONG) | (1 << (int) RID_SHORT)
4139 | (1 << (int) RID_SIGNED)
4140 | (1 << (int) RID_UNSIGNED))))
4143 pedwarn ("ISO C does not support plain `complex' meaning `double complex'");
4144 type = complex_double_type_node;
4146 else if (type == integer_type_node)
4149 pedwarn ("ISO C does not support complex integer types");
4150 type = complex_integer_type_node;
4152 else if (type == float_type_node)
4153 type = complex_float_type_node;
4154 else if (type == double_type_node)
4155 type = complex_double_type_node;
4156 else if (type == long_double_type_node)
4157 type = complex_long_double_type_node;
4161 pedwarn ("ISO C does not support complex integer types");
4162 type = build_complex_type (type);
4166 /* Figure out the type qualifiers for the declaration. There are
4167 two ways a declaration can become qualified. One is something
4168 like `const int i' where the `const' is explicit. Another is
4169 something like `typedef const int CI; CI i' where the type of the
4170 declaration contains the `const'. */
4171 constp = !! (specbits & 1 << (int) RID_CONST) + TYPE_READONLY (type);
4172 restrictp = !! (specbits & 1 << (int) RID_RESTRICT) + TYPE_RESTRICT (type);
4173 volatilep = !! (specbits & 1 << (int) RID_VOLATILE) + TYPE_VOLATILE (type);
4174 inlinep = !! (specbits & (1 << (int) RID_INLINE));
4175 if (constp > 1 && ! flag_isoc99)
4176 pedwarn ("duplicate `const'");
4177 if (restrictp > 1 && ! flag_isoc99)
4178 pedwarn ("duplicate `restrict'");
4179 if (volatilep > 1 && ! flag_isoc99)
4180 pedwarn ("duplicate `volatile'");
4181 if (! flag_gen_aux_info && (TYPE_QUALS (type)))
4182 type = TYPE_MAIN_VARIANT (type);
4183 type_quals = ((constp ? TYPE_QUAL_CONST : 0)
4184 | (restrictp ? TYPE_QUAL_RESTRICT : 0)
4185 | (volatilep ? TYPE_QUAL_VOLATILE : 0));
4187 /* Warn if two storage classes are given. Default to `auto'. */
4192 if (specbits & 1 << (int) RID_AUTO) nclasses++;
4193 if (specbits & 1 << (int) RID_STATIC) nclasses++;
4194 if (specbits & 1 << (int) RID_EXTERN) nclasses++;
4195 if (specbits & 1 << (int) RID_REGISTER) nclasses++;
4196 if (specbits & 1 << (int) RID_TYPEDEF) nclasses++;
4198 /* Warn about storage classes that are invalid for certain
4199 kinds of declarations (parameters, typenames, etc.). */
4202 error ("multiple storage classes in declaration of `%s'", name);
4203 else if (funcdef_flag
4205 & ((1 << (int) RID_REGISTER)
4206 | (1 << (int) RID_AUTO)
4207 | (1 << (int) RID_TYPEDEF))))
4209 if (specbits & 1 << (int) RID_AUTO
4210 && (pedantic || current_binding_level == global_binding_level))
4211 pedwarn ("function definition declared `auto'");
4212 if (specbits & 1 << (int) RID_REGISTER)
4213 error ("function definition declared `register'");
4214 if (specbits & 1 << (int) RID_TYPEDEF)
4215 error ("function definition declared `typedef'");
4216 specbits &= ~((1 << (int) RID_TYPEDEF) | (1 << (int) RID_REGISTER)
4217 | (1 << (int) RID_AUTO));
4219 else if (decl_context != NORMAL && nclasses > 0)
4221 if (decl_context == PARM && specbits & 1 << (int) RID_REGISTER)
4225 switch (decl_context)
4228 error ("storage class specified for structure field `%s'",
4232 error ("storage class specified for parameter `%s'", name);
4235 error ("storage class specified for typename");
4238 specbits &= ~((1 << (int) RID_TYPEDEF) | (1 << (int) RID_REGISTER)
4239 | (1 << (int) RID_AUTO) | (1 << (int) RID_STATIC)
4240 | (1 << (int) RID_EXTERN));
4243 else if (specbits & 1 << (int) RID_EXTERN && initialized && ! funcdef_flag)
4245 /* `extern' with initialization is invalid if not at top level. */
4246 if (current_binding_level == global_binding_level)
4247 warning ("`%s' initialized and declared `extern'", name);
4249 error ("`%s' has both `extern' and initializer", name);
4251 else if (specbits & 1 << (int) RID_EXTERN && funcdef_flag
4252 && current_binding_level != global_binding_level)
4253 error ("nested function `%s' declared `extern'", name);
4254 else if (current_binding_level == global_binding_level
4255 && specbits & (1 << (int) RID_AUTO))
4256 error ("top-level declaration of `%s' specifies `auto'", name);
4259 /* Now figure out the structure of the declarator proper.
4260 Descend through it, creating more complex types, until we reach
4261 the declared identifier (or NULL_TREE, in an absolute declarator). */
4263 while (declarator && TREE_CODE (declarator) != IDENTIFIER_NODE)
4265 if (type == error_mark_node)
4267 declarator = TREE_OPERAND (declarator, 0);
4271 /* Each level of DECLARATOR is either an ARRAY_REF (for ...[..]),
4272 an INDIRECT_REF (for *...),
4273 a CALL_EXPR (for ...(...)),
4274 a TREE_LIST (for nested attributes),
4275 an identifier (for the name being declared)
4276 or a null pointer (for the place in an absolute declarator
4277 where the name was omitted).
4278 For the last two cases, we have just exited the loop.
4280 At this point, TYPE is the type of elements of an array,
4281 or for a function to return, or for a pointer to point to.
4282 After this sequence of ifs, TYPE is the type of the
4283 array or function or pointer, and DECLARATOR has had its
4284 outermost layer removed. */
4286 if (array_ptr_quals != NULL_TREE || array_parm_static)
4288 /* Only the innermost declarator (making a parameter be of
4289 array type which is converted to pointer type)
4290 may have static or type qualifiers. */
4291 error ("static or type qualifiers in non-parameter array declarator");
4292 array_ptr_quals = NULL_TREE;
4293 array_parm_static = 0;
4296 if (TREE_CODE (declarator) == TREE_LIST)
4298 /* We encode a declarator with embedded attributes using
4300 tree attrs = TREE_PURPOSE (declarator);
4303 declarator = TREE_VALUE (declarator);
4304 inner_decl = declarator;
4305 while (inner_decl != NULL_TREE
4306 && TREE_CODE (inner_decl) == TREE_LIST)
4307 inner_decl = TREE_VALUE (inner_decl);
4308 if (inner_decl == NULL_TREE
4309 || TREE_CODE (inner_decl) == IDENTIFIER_NODE)
4310 attr_flags |= (int) ATTR_FLAG_DECL_NEXT;
4311 else if (TREE_CODE (inner_decl) == CALL_EXPR)
4312 attr_flags |= (int) ATTR_FLAG_FUNCTION_NEXT;
4313 else if (TREE_CODE (inner_decl) == ARRAY_REF)
4314 attr_flags |= (int) ATTR_FLAG_ARRAY_NEXT;
4315 returned_attrs = decl_attributes (&type,
4316 chainon (returned_attrs, attrs),
4319 else if (TREE_CODE (declarator) == ARRAY_REF)
4321 tree itype = NULL_TREE;
4322 tree size = TREE_OPERAND (declarator, 1);
4323 /* The index is a signed object `sizetype' bits wide. */
4324 tree index_type = c_common_signed_type (sizetype);
4326 array_ptr_quals = TREE_TYPE (declarator);
4327 array_parm_static = TREE_STATIC (declarator);
4329 declarator = TREE_OPERAND (declarator, 0);
4331 /* Check for some types that there cannot be arrays of. */
4333 if (VOID_TYPE_P (type))
4335 error ("declaration of `%s' as array of voids", name);
4336 type = error_mark_node;
4339 if (TREE_CODE (type) == FUNCTION_TYPE)
4341 error ("declaration of `%s' as array of functions", name);
4342 type = error_mark_node;
4345 if (size == error_mark_node)
4346 type = error_mark_node;
4348 if (type == error_mark_node)
4351 /* If size was specified, set ITYPE to a range-type for that size.
4352 Otherwise, ITYPE remains null. finish_decl may figure it out
4353 from an initial value. */
4357 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue. */
4358 STRIP_TYPE_NOPS (size);
4360 if (! INTEGRAL_TYPE_P (TREE_TYPE (size)))
4362 error ("size of array `%s' has non-integer type", name);
4363 size = integer_one_node;
4366 if (pedantic && integer_zerop (size))
4367 pedwarn ("ISO C forbids zero-size array `%s'", name);
4369 if (TREE_CODE (size) == INTEGER_CST)
4371 constant_expression_warning (size);
4372 if (tree_int_cst_sgn (size) < 0)
4374 error ("size of array `%s' is negative", name);
4375 size = integer_one_node;
4380 /* Make sure the array size remains visibly nonconstant
4381 even if it is (eg) a const variable with known value. */
4386 if (TREE_CONSTANT (size))
4387 pedwarn ("ISO C89 forbids array `%s' whose size can't be evaluated",
4390 pedwarn ("ISO C89 forbids variable-size array `%s'",
4395 if (integer_zerop (size))
4397 /* A zero-length array cannot be represented with an
4398 unsigned index type, which is what we'll get with
4399 build_index_type. Create an open-ended range instead. */
4400 itype = build_range_type (sizetype, size, NULL_TREE);
4404 /* Compute the maximum valid index, that is, size - 1.
4405 Do the calculation in index_type, so that if it is
4406 a variable the computations will be done in the
4408 itype = fold (build (MINUS_EXPR, index_type,
4409 convert (index_type, size),
4410 convert (index_type, size_one_node)));
4412 /* If that overflowed, the array is too big.
4413 ??? While a size of INT_MAX+1 technically shouldn't
4414 cause an overflow (because we subtract 1), the overflow
4415 is recorded during the conversion to index_type, before
4416 the subtraction. Handling this case seems like an
4417 unnecessary complication. */
4418 if (TREE_OVERFLOW (itype))
4420 error ("size of array `%s' is too large", name);
4421 type = error_mark_node;
4426 itype = variable_size (itype);
4427 itype = build_index_type (itype);
4430 else if (decl_context == FIELD)
4432 /* ??? Need to check somewhere that this is a structure
4433 and not a union, that this field is last, and that
4434 this structure has at least one other named member. */
4436 if (pedantic && !flag_isoc99 && !in_system_header)
4437 pedwarn ("ISO C89 does not support flexible array members");
4439 /* ISO C99 Flexible array members are effectively identical
4440 to GCC's zero-length array extension. */
4441 itype = build_range_type (sizetype, size_zero_node, NULL_TREE);
4444 /* If pedantic, complain about arrays of incomplete types. */
4446 if (pedantic && !COMPLETE_TYPE_P (type))
4447 pedwarn ("array type has incomplete element type");
4450 /* We shouldn't have a function type here at all!
4451 Functions aren't allowed as array elements. */
4452 if (pedantic && TREE_CODE (type) == FUNCTION_TYPE
4453 && (constp || volatilep))
4454 pedwarn ("ISO C forbids const or volatile function types");
4457 /* Build the array type itself, then merge any constancy or
4458 volatility into the target type. We must do it in this order
4459 to ensure that the TYPE_MAIN_VARIANT field of the array type
4460 is set correctly. */
4462 type = build_array_type (type, itype);
4464 type = c_build_qualified_type (type, type_quals);
4467 C_TYPE_VARIABLE_SIZE (type) = 1;
4469 /* The GCC extension for zero-length arrays differs from
4470 ISO flexible array members in that sizeof yields zero. */
4471 if (size && integer_zerop (size))
4474 TYPE_SIZE (type) = bitsize_zero_node;
4475 TYPE_SIZE_UNIT (type) = size_zero_node;
4477 if (decl_context != PARM
4478 && (array_ptr_quals != NULL_TREE || array_parm_static))
4480 error ("static or type qualifiers in non-parameter array declarator");
4481 array_ptr_quals = NULL_TREE;
4482 array_parm_static = 0;
4485 else if (TREE_CODE (declarator) == CALL_EXPR)
4489 /* Declaring a function type.
4490 Make sure we have a valid type for the function to return. */
4491 if (type == error_mark_node)
4496 /* Warn about some types functions can't return. */
4498 if (TREE_CODE (type) == FUNCTION_TYPE)
4500 error ("`%s' declared as function returning a function", name);
4501 type = integer_type_node;
4503 if (TREE_CODE (type) == ARRAY_TYPE)
4505 error ("`%s' declared as function returning an array", name);
4506 type = integer_type_node;
4509 /* Construct the function type and go to the next
4510 inner layer of declarator. */
4512 arg_types = grokparms (TREE_OPERAND (declarator, 1),
4514 /* Say it's a definition
4515 only for the CALL_EXPR
4516 closest to the identifier. */
4517 && TREE_CODE (TREE_OPERAND (declarator, 0)) == IDENTIFIER_NODE);
4518 /* Type qualifiers before the return type of the function
4519 qualify the return type, not the function type. */
4522 /* Type qualifiers on a function return type are normally
4523 permitted by the standard but have no effect, so give a
4524 warning at -W. Qualifiers on a void return type have
4525 meaning as a GNU extension, and are banned on function
4526 definitions in ISO C. FIXME: strictly we shouldn't
4527 pedwarn for qualified void return types except on function
4528 definitions, but not doing so could lead to the undesirable
4529 state of a "volatile void" function return type not being
4530 warned about, and a use of the function being compiled
4531 with GNU semantics, with no diagnostics under -pedantic. */
4532 if (VOID_TYPE_P (type) && pedantic && !in_system_header)
4533 pedwarn ("ISO C forbids qualified void function return type");
4534 else if (extra_warnings
4535 && !(VOID_TYPE_P (type)
4536 && type_quals == TYPE_QUAL_VOLATILE))
4537 warning ("type qualifiers ignored on function return type");
4539 type = c_build_qualified_type (type, type_quals);
4541 type_quals = TYPE_UNQUALIFIED;
4543 type = build_function_type (type, arg_types);
4544 declarator = TREE_OPERAND (declarator, 0);
4546 /* Set the TYPE_CONTEXTs for each tagged type which is local to
4547 the formal parameter list of this FUNCTION_TYPE to point to
4548 the FUNCTION_TYPE node itself. */
4553 for (link = last_function_parm_tags;
4555 link = TREE_CHAIN (link))
4556 TYPE_CONTEXT (TREE_VALUE (link)) = type;
4559 else if (TREE_CODE (declarator) == INDIRECT_REF)
4561 /* Merge any constancy or volatility into the target type
4564 if (pedantic && TREE_CODE (type) == FUNCTION_TYPE
4566 pedwarn ("ISO C forbids qualified function types");
4568 type = c_build_qualified_type (type, type_quals);
4569 type_quals = TYPE_UNQUALIFIED;
4572 type = build_pointer_type (type);
4574 /* Process a list of type modifier keywords
4575 (such as const or volatile) that were given inside the `*'. */
4577 if (TREE_TYPE (declarator))
4585 for (typemodlist = TREE_TYPE (declarator); typemodlist;
4586 typemodlist = TREE_CHAIN (typemodlist))
4588 tree qualifier = TREE_VALUE (typemodlist);
4590 if (C_IS_RESERVED_WORD (qualifier))
4592 if (C_RID_CODE (qualifier) == RID_CONST)
4594 else if (C_RID_CODE (qualifier) == RID_VOLATILE)
4596 else if (C_RID_CODE (qualifier) == RID_RESTRICT)
4606 error ("invalid type modifier within pointer declarator");
4607 if (constp > 1 && ! flag_isoc99)
4608 pedwarn ("duplicate `const'");
4609 if (volatilep > 1 && ! flag_isoc99)
4610 pedwarn ("duplicate `volatile'");
4611 if (restrictp > 1 && ! flag_isoc99)
4612 pedwarn ("duplicate `restrict'");
4614 type_quals = ((constp ? TYPE_QUAL_CONST : 0)
4615 | (restrictp ? TYPE_QUAL_RESTRICT : 0)
4616 | (volatilep ? TYPE_QUAL_VOLATILE : 0));
4619 declarator = TREE_OPERAND (declarator, 0);
4626 /* Now TYPE has the actual type. */
4628 /* Did array size calculations overflow? */
4630 if (TREE_CODE (type) == ARRAY_TYPE
4631 && COMPLETE_TYPE_P (type)
4632 && TREE_OVERFLOW (TYPE_SIZE (type)))
4634 error ("size of array `%s' is too large", name);
4635 /* If we proceed with the array type as it is, we'll eventually
4636 crash in tree_low_cst(). */
4637 type = error_mark_node;
4640 /* If this is declaring a typedef name, return a TYPE_DECL. */
4642 if (specbits & (1 << (int) RID_TYPEDEF))
4645 /* Note that the grammar rejects storage classes
4646 in typenames, fields or parameters */
4647 if (pedantic && TREE_CODE (type) == FUNCTION_TYPE
4649 pedwarn ("ISO C forbids qualified function types");
4651 type = c_build_qualified_type (type, type_quals);
4652 decl = build_decl (TYPE_DECL, declarator, type);
4653 if ((specbits & (1 << (int) RID_SIGNED))
4654 || (typedef_decl && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl)))
4655 C_TYPEDEF_EXPLICITLY_SIGNED (decl) = 1;
4656 decl_attributes (&decl, returned_attrs, 0);
4660 /* Detect the case of an array type of unspecified size
4661 which came, as such, direct from a typedef name.
4662 We must copy the type, so that each identifier gets
4663 a distinct type, so that each identifier's size can be
4664 controlled separately by its own initializer. */
4666 if (type != 0 && typedef_type != 0
4667 && TREE_CODE (type) == ARRAY_TYPE && TYPE_DOMAIN (type) == 0
4668 && TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (typedef_type))
4670 type = build_array_type (TREE_TYPE (type), 0);
4672 C_TYPE_VARIABLE_SIZE (type) = 1;
4675 /* If this is a type name (such as, in a cast or sizeof),
4676 compute the type and return it now. */
4678 if (decl_context == TYPENAME)
4680 /* Note that the grammar rejects storage classes
4681 in typenames, fields or parameters */
4682 if (pedantic && TREE_CODE (type) == FUNCTION_TYPE
4684 pedwarn ("ISO C forbids const or volatile function types");
4686 type = c_build_qualified_type (type, type_quals);
4687 decl_attributes (&type, returned_attrs, 0);
4691 /* Aside from typedefs and type names (handle above),
4692 `void' at top level (not within pointer)
4693 is allowed only in public variables.
4694 We don't complain about parms either, but that is because
4695 a better error message can be made later. */
4697 if (VOID_TYPE_P (type) && decl_context != PARM
4698 && ! ((decl_context != FIELD && TREE_CODE (type) != FUNCTION_TYPE)
4699 && ((specbits & (1 << (int) RID_EXTERN))
4700 || (current_binding_level == global_binding_level
4702 & ((1 << (int) RID_STATIC) | (1 << (int) RID_REGISTER)))))))
4704 error ("variable or field `%s' declared void", name);
4705 type = integer_type_node;
4708 /* Now create the decl, which may be a VAR_DECL, a PARM_DECL
4709 or a FUNCTION_DECL, depending on DECL_CONTEXT and TYPE. */
4714 if (decl_context == PARM)
4716 tree type_as_written;
4719 /* A parameter declared as an array of T is really a pointer to T.
4720 One declared as a function is really a pointer to a function. */
4722 if (TREE_CODE (type) == ARRAY_TYPE)
4724 /* Transfer const-ness of array into that of type pointed to. */
4725 type = TREE_TYPE (type);
4727 type = c_build_qualified_type (type, type_quals);
4728 type = build_pointer_type (type);
4729 type_quals = TYPE_UNQUALIFIED;
4730 if (array_ptr_quals)
4732 tree new_ptr_quals, new_ptr_attrs;
4734 split_specs_attrs (array_ptr_quals, &new_ptr_quals, &new_ptr_attrs);
4735 /* We don't yet implement attributes in this context. */
4736 if (new_ptr_attrs != NULL_TREE)
4737 warning ("attributes in parameter array declarator ignored");
4742 for (; new_ptr_quals; new_ptr_quals = TREE_CHAIN (new_ptr_quals))
4744 tree qualifier = TREE_VALUE (new_ptr_quals);
4746 if (C_IS_RESERVED_WORD (qualifier))
4748 if (C_RID_CODE (qualifier) == RID_CONST)
4750 else if (C_RID_CODE (qualifier) == RID_VOLATILE)
4752 else if (C_RID_CODE (qualifier) == RID_RESTRICT)
4762 error ("invalid type modifier within array declarator");
4764 type_quals = ((constp ? TYPE_QUAL_CONST : 0)
4765 | (restrictp ? TYPE_QUAL_RESTRICT : 0)
4766 | (volatilep ? TYPE_QUAL_VOLATILE : 0));
4770 else if (TREE_CODE (type) == FUNCTION_TYPE)
4772 if (pedantic && type_quals)
4773 pedwarn ("ISO C forbids qualified function types");
4775 type = c_build_qualified_type (type, type_quals);
4776 type = build_pointer_type (type);
4777 type_quals = TYPE_UNQUALIFIED;
4779 else if (type_quals)
4780 type = c_build_qualified_type (type, type_quals);
4782 type_as_written = type;
4784 decl = build_decl (PARM_DECL, declarator, type);
4786 C_DECL_VARIABLE_SIZE (decl) = 1;
4788 /* Compute the type actually passed in the parmlist,
4789 for the case where there is no prototype.
4790 (For example, shorts and chars are passed as ints.)
4791 When there is a prototype, this is overridden later. */
4793 if (type == error_mark_node)
4794 promoted_type = type;
4796 promoted_type = c_type_promotes_to (type);
4798 DECL_ARG_TYPE (decl) = promoted_type;
4799 DECL_ARG_TYPE_AS_WRITTEN (decl) = type_as_written;
4801 else if (decl_context == FIELD)
4803 /* Structure field. It may not be a function. */
4805 if (TREE_CODE (type) == FUNCTION_TYPE)
4807 error ("field `%s' declared as a function", name);
4808 type = build_pointer_type (type);
4810 else if (TREE_CODE (type) != ERROR_MARK
4811 && !COMPLETE_OR_UNBOUND_ARRAY_TYPE_P (type))
4813 error ("field `%s' has incomplete type", name);
4814 type = error_mark_node;
4816 /* Move type qualifiers down to element of an array. */
4817 if (TREE_CODE (type) == ARRAY_TYPE && type_quals)
4819 type = build_array_type (c_build_qualified_type (TREE_TYPE (type),
4821 TYPE_DOMAIN (type));
4823 /* Leave the field const or volatile as well. */
4824 type_quals = TYPE_UNQUALIFIED;
4827 decl = build_decl (FIELD_DECL, declarator, type);
4828 DECL_NONADDRESSABLE_P (decl) = bitfield;
4831 C_DECL_VARIABLE_SIZE (decl) = 1;
4833 else if (TREE_CODE (type) == FUNCTION_TYPE)
4835 /* Every function declaration is "external"
4836 except for those which are inside a function body
4837 in which `auto' is used.
4838 That is a case not specified by ANSI C,
4839 and we use it for forward declarations for nested functions. */
4840 int extern_ref = (!(specbits & (1 << (int) RID_AUTO))
4841 || current_binding_level == global_binding_level);
4843 if (specbits & (1 << (int) RID_AUTO)
4844 && (pedantic || current_binding_level == global_binding_level))
4845 pedwarn ("invalid storage class for function `%s'", name);
4846 if (specbits & (1 << (int) RID_REGISTER))
4847 error ("invalid storage class for function `%s'", name);
4848 /* Function declaration not at top level.
4849 Storage classes other than `extern' are not allowed
4850 and `extern' makes no difference. */
4851 if (current_binding_level != global_binding_level
4852 && (specbits & ((1 << (int) RID_STATIC) | (1 << (int) RID_INLINE)))
4854 pedwarn ("invalid storage class for function `%s'", name);
4856 decl = build_decl (FUNCTION_DECL, declarator, type);
4857 decl = build_decl_attribute_variant (decl, decl_attr);
4859 DECL_LANG_SPECIFIC (decl) = (struct lang_decl *)
4860 ggc_alloc_cleared (sizeof (struct lang_decl));
4862 if (pedantic && type_quals && ! DECL_IN_SYSTEM_HEADER (decl))
4863 pedwarn ("ISO C forbids qualified function types");
4865 /* GNU C interprets a `volatile void' return type to indicate
4866 that the function does not return. */
4867 if ((type_quals & TYPE_QUAL_VOLATILE)
4868 && !VOID_TYPE_P (TREE_TYPE (TREE_TYPE (decl))))
4869 warning ("`noreturn' function returns non-void value");
4872 DECL_EXTERNAL (decl) = 1;
4873 /* Record absence of global scope for `static' or `auto'. */
4875 = !(specbits & ((1 << (int) RID_STATIC) | (1 << (int) RID_AUTO)));
4878 C_FUNCTION_IMPLICIT_INT (decl) = 1;
4880 /* Record presence of `inline', if it is reasonable. */
4881 if (MAIN_NAME_P (declarator))
4884 warning ("cannot inline function `main'");
4888 /* Assume that otherwise the function can be inlined. */
4889 DECL_DECLARED_INLINE_P (decl) = 1;
4891 /* Do not mark bare declarations as DECL_INLINE. Doing so
4892 in the presence of multiple declarations can result in
4893 the abstract origin pointing between the declarations,
4894 which will confuse dwarf2out. */
4897 DECL_INLINE (decl) = 1;
4898 if (specbits & (1 << (int) RID_EXTERN))
4899 current_extern_inline = 1;
4902 /* If -finline-functions, assume it can be inlined. This does
4903 two things: let the function be deferred until it is actually
4904 needed, and let dwarf2 know that the function is inlinable. */
4905 else if (flag_inline_trees == 2 && initialized)
4907 DECL_INLINE (decl) = 1;
4908 DECL_DECLARED_INLINE_P (decl) = 0;
4913 /* It's a variable. */
4914 /* An uninitialized decl with `extern' is a reference. */
4915 int extern_ref = !initialized && (specbits & (1 << (int) RID_EXTERN));
4917 /* Move type qualifiers down to element of an array. */
4918 if (TREE_CODE (type) == ARRAY_TYPE && type_quals)
4920 int saved_align = TYPE_ALIGN(type);
4921 type = build_array_type (c_build_qualified_type (TREE_TYPE (type),
4923 TYPE_DOMAIN (type));
4924 TYPE_ALIGN (type) = saved_align;
4925 #if 0 /* Leave the variable const or volatile as well. */
4926 type_quals = TYPE_UNQUALIFIED;
4929 else if (type_quals)
4930 type = c_build_qualified_type (type, type_quals);
4932 decl = build_decl (VAR_DECL, declarator, type);
4934 C_DECL_VARIABLE_SIZE (decl) = 1;
4937 pedwarn_with_decl (decl, "variable `%s' declared `inline'");
4939 DECL_EXTERNAL (decl) = extern_ref;
4940 /* At top level, the presence of a `static' or `register' storage
4941 class specifier, or the absence of all storage class specifiers
4942 makes this declaration a definition (perhaps tentative). Also,
4943 the absence of both `static' and `register' makes it public. */
4944 if (current_binding_level == global_binding_level)
4948 & ((1 << (int) RID_STATIC) | (1 << (int) RID_REGISTER)));
4949 TREE_STATIC (decl) = ! DECL_EXTERNAL (decl);
4951 /* Not at top level, only `static' makes a static definition. */
4954 TREE_STATIC (decl) = (specbits & (1 << (int) RID_STATIC)) != 0;
4955 TREE_PUBLIC (decl) = DECL_EXTERNAL (decl);
4959 /* Record `register' declaration for warnings on &
4960 and in case doing stupid register allocation. */
4962 if (specbits & (1 << (int) RID_REGISTER))
4963 DECL_REGISTER (decl) = 1;
4965 /* Record constancy and volatility. */
4966 c_apply_type_quals_to_decl (type_quals, decl);
4968 /* If a type has volatile components, it should be stored in memory.
4969 Otherwise, the fact that those components are volatile
4970 will be ignored, and would even crash the compiler. */
4971 if (C_TYPE_FIELDS_VOLATILE (TREE_TYPE (decl)))
4972 c_mark_addressable (decl);
4974 decl_attributes (&decl, returned_attrs, 0);
4980 /* Decode the parameter-list info for a function type or function definition.
4981 The argument is the value returned by `get_parm_info' (or made in parse.y
4982 if there is an identifier list instead of a parameter decl list).
4983 These two functions are separate because when a function returns
4984 or receives functions then each is called multiple times but the order
4985 of calls is different. The last call to `grokparms' is always the one
4986 that contains the formal parameter names of a function definition.
4988 Store in `last_function_parms' a chain of the decls of parms.
4989 Also store in `last_function_parm_tags' a chain of the struct, union,
4990 and enum tags declared among the parms.
4992 Return a list of arg types to use in the FUNCTION_TYPE for this function.
4994 FUNCDEF_FLAG is nonzero for a function definition, 0 for
4995 a mere declaration. A nonempty identifier-list gets an error message
4996 when FUNCDEF_FLAG is zero. */
4999 grokparms (parms_info, funcdef_flag)
5003 tree first_parm = TREE_CHAIN (parms_info);
5005 last_function_parms = TREE_PURPOSE (parms_info);
5006 last_function_parm_tags = TREE_VALUE (parms_info);
5008 if (warn_strict_prototypes && first_parm == 0 && !funcdef_flag
5009 && !in_system_header)
5010 warning ("function declaration isn't a prototype");
5013 && TREE_CODE (TREE_VALUE (first_parm)) == IDENTIFIER_NODE)
5016 pedwarn ("parameter names (without types) in function declaration");
5018 last_function_parms = first_parm;
5025 /* We no longer test FUNCDEF_FLAG.
5026 If the arg types are incomplete in a declaration,
5027 they must include undefined tags.
5028 These tags can never be defined in the scope of the declaration,
5029 so the types can never be completed,
5030 and no call can be compiled successfully. */
5032 /* In a fcn definition, arg types must be complete. */
5035 for (parm = last_function_parms, typelt = first_parm;
5037 parm = TREE_CHAIN (parm))
5038 /* Skip over any enumeration constants declared here. */
5039 if (TREE_CODE (parm) == PARM_DECL)
5041 /* Barf if the parameter itself has an incomplete type. */
5042 tree type = TREE_VALUE (typelt);
5043 if (type == error_mark_node)
5045 if (!COMPLETE_TYPE_P (type))
5047 if (funcdef_flag && DECL_NAME (parm) != 0)
5048 error ("parameter `%s' has incomplete type",
5049 IDENTIFIER_POINTER (DECL_NAME (parm)));
5051 warning ("parameter has incomplete type");
5054 TREE_VALUE (typelt) = error_mark_node;
5055 TREE_TYPE (parm) = error_mark_node;
5059 /* This has been replaced by parm_tags_warning, which
5060 uses a more accurate criterion for what to warn
5064 /* Now warn if is a pointer to an incomplete type. */
5065 while (TREE_CODE (type) == POINTER_TYPE
5066 || TREE_CODE (type) == REFERENCE_TYPE)
5067 type = TREE_TYPE (type);
5068 type = TYPE_MAIN_VARIANT (type);
5069 if (!COMPLETE_TYPE_P (type))
5071 if (DECL_NAME (parm) != 0)
5072 warning ("parameter `%s' points to incomplete type",
5073 IDENTIFIER_POINTER (DECL_NAME (parm)));
5075 warning ("parameter points to incomplete type");
5079 typelt = TREE_CHAIN (typelt);
5086 /* Return a tree_list node with info on a parameter list just parsed.
5087 The TREE_PURPOSE is a chain of decls of those parms.
5088 The TREE_VALUE is a list of structure, union and enum tags defined.
5089 The TREE_CHAIN is a list of argument types to go in the FUNCTION_TYPE.
5090 This tree_list node is later fed to `grokparms'.
5092 VOID_AT_END nonzero means append `void' to the end of the type-list.
5093 Zero means the parmlist ended with an ellipsis so don't append `void'. */
5096 get_parm_info (void_at_end)
5102 tree tags = gettags ();
5103 tree parms = getdecls ();
5105 tree order = current_binding_level->parm_order;
5107 /* Just `void' (and no ellipsis) is special. There are really no parms.
5108 But if the `void' is qualified (by `const' or `volatile') or has a
5109 storage class specifier (`register'), then the behavior is undefined;
5110 by not counting it as the special case of `void' we will cause an
5111 error later. Typedefs for `void' are OK (see DR#157). */
5112 if (void_at_end && parms != 0
5113 && TREE_CHAIN (parms) == 0
5114 && VOID_TYPE_P (TREE_TYPE (parms))
5115 && ! TREE_THIS_VOLATILE (parms)
5116 && ! TREE_READONLY (parms)
5117 && ! DECL_REGISTER (parms)
5118 && DECL_NAME (parms) == 0)
5121 storedecls (NULL_TREE);
5122 return tree_cons (NULL_TREE, NULL_TREE,
5123 tree_cons (NULL_TREE, void_type_node, NULL_TREE));
5126 /* Extract enumerator values and other non-parms declared with the parms.
5127 Likewise any forward parm decls that didn't have real parm decls. */
5128 for (decl = parms; decl;)
5130 tree next = TREE_CHAIN (decl);
5132 if (TREE_CODE (decl) != PARM_DECL)
5134 TREE_CHAIN (decl) = new_parms;
5137 else if (TREE_ASM_WRITTEN (decl))
5139 error_with_decl (decl,
5140 "parameter `%s' has just a forward declaration");
5141 TREE_CHAIN (decl) = new_parms;
5147 /* Put the parm decls back in the order they were in in the parm list. */
5148 for (t = order; t; t = TREE_CHAIN (t))
5151 TREE_CHAIN (TREE_VALUE (t)) = TREE_VALUE (TREE_CHAIN (t));
5153 TREE_CHAIN (TREE_VALUE (t)) = 0;
5156 new_parms = chainon (order ? nreverse (TREE_VALUE (order)) : 0,
5159 /* Store the parmlist in the binding level since the old one
5160 is no longer a valid list. (We have changed the chain pointers.) */
5161 storedecls (new_parms);
5163 for (decl = new_parms; decl; decl = TREE_CHAIN (decl))
5164 /* There may also be declarations for enumerators if an enumeration
5165 type is declared among the parms. Ignore them here. */
5166 if (TREE_CODE (decl) == PARM_DECL)
5168 /* Since there is a prototype,
5169 args are passed in their declared types. */
5170 tree type = TREE_TYPE (decl);
5171 DECL_ARG_TYPE (decl) = type;
5172 if (PROMOTE_PROTOTYPES
5173 && INTEGRAL_TYPE_P (type)
5174 && TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node))
5175 DECL_ARG_TYPE (decl) = integer_type_node;
5177 types = tree_cons (NULL_TREE, TREE_TYPE (decl), types);
5178 if (VOID_TYPE_P (TREE_VALUE (types)) && ! erred
5179 && DECL_NAME (decl) == 0)
5181 error ("`void' in parameter list must be the entire list");
5187 return tree_cons (new_parms, tags,
5188 nreverse (tree_cons (NULL_TREE, void_type_node, types)));
5190 return tree_cons (new_parms, tags, nreverse (types));
5193 /* At end of parameter list, warn about any struct, union or enum tags
5194 defined within. Do so because these types cannot ever become complete. */
5197 parmlist_tags_warning ()
5202 for (elt = current_binding_level->tags; elt; elt = TREE_CHAIN (elt))
5204 enum tree_code code = TREE_CODE (TREE_VALUE (elt));
5205 /* An anonymous union parm type is meaningful as a GNU extension.
5206 So don't warn for that. */
5207 if (code == UNION_TYPE && TREE_PURPOSE (elt) == 0 && !pedantic)
5209 if (TREE_PURPOSE (elt) != 0)
5211 if (code == RECORD_TYPE)
5212 warning ("`struct %s' declared inside parameter list",
5213 IDENTIFIER_POINTER (TREE_PURPOSE (elt)));
5214 else if (code == UNION_TYPE)
5215 warning ("`union %s' declared inside parameter list",
5216 IDENTIFIER_POINTER (TREE_PURPOSE (elt)));
5218 warning ("`enum %s' declared inside parameter list",
5219 IDENTIFIER_POINTER (TREE_PURPOSE (elt)));
5223 /* For translation these need to be separate warnings */
5224 if (code == RECORD_TYPE)
5225 warning ("anonymous struct declared inside parameter list");
5226 else if (code == UNION_TYPE)
5227 warning ("anonymous union declared inside parameter list");
5229 warning ("anonymous enum declared inside parameter list");
5233 warning ("its scope is only this definition or declaration, which is probably not what you want");
5239 /* Get the struct, enum or union (CODE says which) with tag NAME.
5240 Define the tag as a forward-reference if it is not defined. */
5243 xref_tag (code, name)
5244 enum tree_code code;
5247 /* If a cross reference is requested, look up the type
5248 already defined for this tag and return it. */
5250 tree ref = lookup_tag (code, name, current_binding_level, 0);
5251 /* If this is the right type of tag, return what we found.
5252 (This reference will be shadowed by shadow_tag later if appropriate.)
5253 If this is the wrong type of tag, do not return it. If it was the
5254 wrong type in the same binding level, we will have had an error
5255 message already; if in a different binding level and declaring
5256 a name, pending_xref_error will give an error message; but if in a
5257 different binding level and not declaring a name, this tag should
5258 shadow the previous declaration of a different type of tag, and
5259 this would not work properly if we return the reference found.
5260 (For example, with "struct foo" in an outer scope, "union foo;"
5261 must shadow that tag with a new one of union type.) */
5262 if (ref && TREE_CODE (ref) == code)
5265 /* If no such tag is yet defined, create a forward-reference node
5266 and record it as the "definition".
5267 When a real declaration of this type is found,
5268 the forward-reference will be altered into a real type. */
5270 ref = make_node (code);
5271 if (code == ENUMERAL_TYPE)
5273 /* Give the type a default layout like unsigned int
5274 to avoid crashing if it does not get defined. */
5275 TYPE_MODE (ref) = TYPE_MODE (unsigned_type_node);
5276 TYPE_ALIGN (ref) = TYPE_ALIGN (unsigned_type_node);
5277 TYPE_USER_ALIGN (ref) = 0;
5278 TREE_UNSIGNED (ref) = 1;
5279 TYPE_PRECISION (ref) = TYPE_PRECISION (unsigned_type_node);
5280 TYPE_MIN_VALUE (ref) = TYPE_MIN_VALUE (unsigned_type_node);
5281 TYPE_MAX_VALUE (ref) = TYPE_MAX_VALUE (unsigned_type_node);
5284 pushtag (name, ref);
5289 /* Make sure that the tag NAME is defined *in the current binding level*
5290 at least as a forward reference.
5291 CODE says which kind of tag NAME ought to be. */
5294 start_struct (code, name)
5295 enum tree_code code;
5298 /* If there is already a tag defined at this binding level
5299 (as a forward reference), just return it. */
5304 ref = lookup_tag (code, name, current_binding_level, 1);
5305 if (ref && TREE_CODE (ref) == code)
5307 C_TYPE_BEING_DEFINED (ref) = 1;
5308 TYPE_PACKED (ref) = flag_pack_struct;
5309 if (TYPE_FIELDS (ref))
5311 if (code == UNION_TYPE)
5312 error ("redefinition of `union %s'",
5313 IDENTIFIER_POINTER (name));
5315 error ("redefinition of `struct %s'",
5316 IDENTIFIER_POINTER (name));
5322 /* Otherwise create a forward-reference just so the tag is in scope. */
5324 ref = make_node (code);
5325 pushtag (name, ref);
5326 C_TYPE_BEING_DEFINED (ref) = 1;
5327 TYPE_PACKED (ref) = flag_pack_struct;
5331 /* Process the specs, declarator (NULL if omitted) and width (NULL if omitted)
5332 of a structure component, returning a FIELD_DECL node.
5333 WIDTH is non-NULL for bit fields only, and is an INTEGER_CST node.
5335 This is done during the parsing of the struct declaration.
5336 The FIELD_DECL nodes are chained together and the lot of them
5337 are ultimately passed to `build_struct' to make the RECORD_TYPE node. */
5340 grokfield (filename, line, declarator, declspecs, width)
5341 const char *filename ATTRIBUTE_UNUSED;
5342 int line ATTRIBUTE_UNUSED;
5343 tree declarator, declspecs, width;
5347 if (declarator == NULL_TREE && width == NULL_TREE)
5349 /* This is an unnamed decl. We only support unnamed
5350 structs/unions, so check for other things and refuse them. */
5351 if (TREE_CODE (TREE_VALUE (declspecs)) != RECORD_TYPE
5352 && TREE_CODE (TREE_VALUE (declspecs)) != UNION_TYPE)
5354 error ("unnamed fields of type other than struct or union are not allowed");
5359 value = grokdeclarator (declarator, declspecs, width ? BITFIELD : FIELD, 0);
5361 finish_decl (value, NULL_TREE, NULL_TREE);
5362 DECL_INITIAL (value) = width;
5364 maybe_objc_check_decl (value);
5368 /* Fill in the fields of a RECORD_TYPE or UNION_TYPE node, T.
5369 FIELDLIST is a chain of FIELD_DECL nodes for the fields.
5370 ATTRIBUTES are attributes to be applied to the structure. */
5373 finish_struct (t, fieldlist, attributes)
5379 int toplevel = global_binding_level == current_binding_level;
5380 int saw_named_field;
5382 /* If this type was previously laid out as a forward reference,
5383 make sure we lay it out again. */
5387 decl_attributes (&t, attributes, (int) ATTR_FLAG_TYPE_IN_PLACE);
5389 /* Nameless union parm types are useful as GCC extension. */
5390 if (! (TREE_CODE (t) == UNION_TYPE && TYPE_NAME (t) == 0) && !pedantic)
5391 /* Otherwise, warn about any struct or union def. in parmlist. */
5392 if (in_parm_level_p ())
5395 pedwarn ("%s defined inside parms",
5396 TREE_CODE (t) == UNION_TYPE ? _("union") : _("structure"));
5398 warning ("%s defined inside parms",
5399 TREE_CODE (t) == UNION_TYPE ? _("union") : _("structure"));
5404 for (x = fieldlist; x; x = TREE_CHAIN (x))
5405 if (DECL_NAME (x) != 0)
5409 pedwarn ("%s has no %s",
5410 TREE_CODE (t) == UNION_TYPE ? _("union") : _("struct"),
5411 fieldlist ? _("named members") : _("members"));
5414 /* Install struct as DECL_CONTEXT of each field decl.
5415 Also process specified field sizes,m which is found in the DECL_INITIAL.
5416 Store 0 there, except for ": 0" fields (so we can find them
5417 and delete them, below). */
5419 saw_named_field = 0;
5420 for (x = fieldlist; x; x = TREE_CHAIN (x))
5422 DECL_CONTEXT (x) = t;
5423 DECL_PACKED (x) |= TYPE_PACKED (t);
5425 /* If any field is const, the structure type is pseudo-const. */
5426 if (TREE_READONLY (x))
5427 C_TYPE_FIELDS_READONLY (t) = 1;
5430 /* A field that is pseudo-const makes the structure likewise. */
5431 tree t1 = TREE_TYPE (x);
5432 while (TREE_CODE (t1) == ARRAY_TYPE)
5433 t1 = TREE_TYPE (t1);
5434 if ((TREE_CODE (t1) == RECORD_TYPE || TREE_CODE (t1) == UNION_TYPE)
5435 && C_TYPE_FIELDS_READONLY (t1))
5436 C_TYPE_FIELDS_READONLY (t) = 1;
5439 /* Any field that is volatile means variables of this type must be
5440 treated in some ways as volatile. */
5441 if (TREE_THIS_VOLATILE (x))
5442 C_TYPE_FIELDS_VOLATILE (t) = 1;
5444 /* Any field of nominal variable size implies structure is too. */
5445 if (C_DECL_VARIABLE_SIZE (x))
5446 C_TYPE_VARIABLE_SIZE (t) = 1;
5448 /* Detect invalid nested redefinition. */
5449 if (TREE_TYPE (x) == t)
5450 error ("nested redefinition of `%s'",
5451 IDENTIFIER_POINTER (TYPE_NAME (t)));
5453 /* Detect invalid bit-field size. */
5454 if (DECL_INITIAL (x))
5455 STRIP_NOPS (DECL_INITIAL (x));
5456 if (DECL_INITIAL (x))
5458 if (TREE_CODE (DECL_INITIAL (x)) == INTEGER_CST)
5459 constant_expression_warning (DECL_INITIAL (x));
5463 "bit-field `%s' width not an integer constant");
5464 DECL_INITIAL (x) = NULL;
5468 /* Detect invalid bit-field type. */
5469 if (DECL_INITIAL (x)
5470 && TREE_CODE (TREE_TYPE (x)) != INTEGER_TYPE
5471 && TREE_CODE (TREE_TYPE (x)) != BOOLEAN_TYPE
5472 && TREE_CODE (TREE_TYPE (x)) != ENUMERAL_TYPE)
5474 error_with_decl (x, "bit-field `%s' has invalid type");
5475 DECL_INITIAL (x) = NULL;
5478 if (DECL_INITIAL (x) && pedantic
5479 && TYPE_MAIN_VARIANT (TREE_TYPE (x)) != integer_type_node
5480 && TYPE_MAIN_VARIANT (TREE_TYPE (x)) != unsigned_type_node
5481 && TYPE_MAIN_VARIANT (TREE_TYPE (x)) != c_bool_type_node
5482 /* Accept an enum that's equivalent to int or unsigned int. */
5483 && !(TREE_CODE (TREE_TYPE (x)) == ENUMERAL_TYPE
5484 && (TYPE_PRECISION (TREE_TYPE (x))
5485 == TYPE_PRECISION (integer_type_node))))
5486 pedwarn_with_decl (x, "bit-field `%s' type invalid in ISO C");
5488 /* Detect and ignore out of range field width and process valid
5490 if (DECL_INITIAL (x))
5493 = (TYPE_MAIN_VARIANT (TREE_TYPE (x)) == c_bool_type_node
5494 ? CHAR_TYPE_SIZE : TYPE_PRECISION (TREE_TYPE (x)));
5496 if (tree_int_cst_sgn (DECL_INITIAL (x)) < 0)
5497 error_with_decl (x, "negative width in bit-field `%s'");
5498 else if (0 < compare_tree_int (DECL_INITIAL (x), max_width))
5499 pedwarn_with_decl (x, "width of `%s' exceeds its type");
5500 else if (integer_zerop (DECL_INITIAL (x)) && DECL_NAME (x) != 0)
5501 error_with_decl (x, "zero width for bit-field `%s'");
5504 /* The test above has assured us that TREE_INT_CST_HIGH is 0. */
5505 unsigned HOST_WIDE_INT width
5506 = tree_low_cst (DECL_INITIAL (x), 1);
5508 if (TREE_CODE (TREE_TYPE (x)) == ENUMERAL_TYPE
5509 && (width < min_precision (TYPE_MIN_VALUE (TREE_TYPE (x)),
5510 TREE_UNSIGNED (TREE_TYPE (x)))
5512 < min_precision (TYPE_MAX_VALUE (TREE_TYPE (x)),
5513 TREE_UNSIGNED (TREE_TYPE (x))))))
5514 warning_with_decl (x,
5515 "`%s' is narrower than values of its type");
5517 DECL_SIZE (x) = bitsize_int (width);
5518 DECL_BIT_FIELD (x) = 1;
5519 SET_DECL_C_BIT_FIELD (x);
5522 && ! (* targetm.ms_bitfield_layout_p) (t))
5524 /* field size 0 => force desired amount of alignment. */
5525 #ifdef EMPTY_FIELD_BOUNDARY
5526 DECL_ALIGN (x) = MAX (DECL_ALIGN (x), EMPTY_FIELD_BOUNDARY);
5528 #ifdef PCC_BITFIELD_TYPE_MATTERS
5529 if (PCC_BITFIELD_TYPE_MATTERS)
5531 DECL_ALIGN (x) = MAX (DECL_ALIGN (x),
5532 TYPE_ALIGN (TREE_TYPE (x)));
5533 DECL_USER_ALIGN (x) |= TYPE_USER_ALIGN (TREE_TYPE (x));
5540 else if (TREE_TYPE (x) != error_mark_node)
5542 unsigned int min_align = (DECL_PACKED (x) ? BITS_PER_UNIT
5543 : TYPE_ALIGN (TREE_TYPE (x)));
5545 /* Non-bit-fields are aligned for their type, except packed
5546 fields which require only BITS_PER_UNIT alignment. */
5547 DECL_ALIGN (x) = MAX (DECL_ALIGN (x), min_align);
5548 if (! DECL_PACKED (x))
5549 DECL_USER_ALIGN (x) |= TYPE_USER_ALIGN (TREE_TYPE (x));
5552 DECL_INITIAL (x) = 0;
5554 /* Detect flexible array member in an invalid context. */
5555 if (TREE_CODE (TREE_TYPE (x)) == ARRAY_TYPE
5556 && TYPE_SIZE (TREE_TYPE (x)) == NULL_TREE
5557 && TYPE_DOMAIN (TREE_TYPE (x)) != NULL_TREE
5558 && TYPE_MAX_VALUE (TYPE_DOMAIN (TREE_TYPE (x))) == NULL_TREE)
5560 if (TREE_CODE (t) == UNION_TYPE)
5561 error_with_decl (x, "flexible array member in union");
5562 else if (TREE_CHAIN (x) != NULL_TREE)
5563 error_with_decl (x, "flexible array member not at end of struct");
5564 else if (! saw_named_field)
5565 error_with_decl (x, "flexible array member in otherwise empty struct");
5568 saw_named_field = 1;
5571 /* Delete all duplicate fields from the fieldlist */
5572 for (x = fieldlist; x && TREE_CHAIN (x);)
5573 /* Anonymous fields aren't duplicates. */
5574 if (DECL_NAME (TREE_CHAIN (x)) == 0)
5582 if (DECL_NAME (y) == DECL_NAME (TREE_CHAIN (x)))
5588 if (DECL_NAME (y) == DECL_NAME (TREE_CHAIN (x)))
5590 error_with_decl (TREE_CHAIN (x), "duplicate member `%s'");
5591 TREE_CHAIN (x) = TREE_CHAIN (TREE_CHAIN (x));
5597 /* Now we have the nearly final fieldlist. Record it,
5598 then lay out the structure or union (including the fields). */
5600 TYPE_FIELDS (t) = fieldlist;
5604 /* Delete all zero-width bit-fields from the fieldlist */
5606 tree *fieldlistp = &fieldlist;
5608 if (TREE_CODE (*fieldlistp) == FIELD_DECL && DECL_INITIAL (*fieldlistp))
5609 *fieldlistp = TREE_CHAIN (*fieldlistp);
5611 fieldlistp = &TREE_CHAIN (*fieldlistp);
5614 /* Now we have the truly final field list.
5615 Store it in this type and in the variants. */
5617 TYPE_FIELDS (t) = fieldlist;
5619 for (x = TYPE_MAIN_VARIANT (t); x; x = TYPE_NEXT_VARIANT (x))
5621 TYPE_FIELDS (x) = TYPE_FIELDS (t);
5622 TYPE_LANG_SPECIFIC (x) = TYPE_LANG_SPECIFIC (t);
5623 TYPE_ALIGN (x) = TYPE_ALIGN (t);
5624 TYPE_USER_ALIGN (x) = TYPE_USER_ALIGN (t);
5627 /* If this was supposed to be a transparent union, but we can't
5628 make it one, warn and turn off the flag. */
5629 if (TREE_CODE (t) == UNION_TYPE
5630 && TYPE_TRANSPARENT_UNION (t)
5631 && TYPE_MODE (t) != DECL_MODE (TYPE_FIELDS (t)))
5633 TYPE_TRANSPARENT_UNION (t) = 0;
5634 warning ("union cannot be made transparent");
5637 /* If this structure or union completes the type of any previous
5638 variable declaration, lay it out and output its rtl. */
5640 if (current_binding_level->n_incomplete != 0)
5643 for (decl = current_binding_level->names; decl; decl = TREE_CHAIN (decl))
5645 if (TYPE_MAIN_VARIANT (TREE_TYPE (decl)) == TYPE_MAIN_VARIANT (t)
5646 && TREE_CODE (decl) != TYPE_DECL)
5648 layout_decl (decl, 0);
5649 /* This is a no-op in c-lang.c or something real in objc-actions.c. */
5650 maybe_objc_check_decl (decl);
5651 rest_of_decl_compilation (decl, NULL, toplevel, 0);
5654 if (--current_binding_level->n_incomplete == 0)
5657 else if (!COMPLETE_TYPE_P (TREE_TYPE (decl))
5658 && TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE)
5660 tree element = TREE_TYPE (decl);
5661 while (TREE_CODE (element) == ARRAY_TYPE)
5662 element = TREE_TYPE (element);
5665 layout_array_type (TREE_TYPE (decl));
5666 if (TREE_CODE (decl) != TYPE_DECL)
5668 layout_decl (decl, 0);
5669 maybe_objc_check_decl (decl);
5670 rest_of_decl_compilation (decl, NULL, toplevel, 0);
5674 if (--current_binding_level->n_incomplete == 0)
5681 /* Finish debugging output for this type. */
5682 rest_of_type_compilation (t, toplevel);
5687 /* Lay out the type T, and its element type, and so on. */
5690 layout_array_type (t)
5693 if (TREE_CODE (TREE_TYPE (t)) == ARRAY_TYPE)
5694 layout_array_type (TREE_TYPE (t));
5698 /* Begin compiling the definition of an enumeration type.
5699 NAME is its name (or null if anonymous).
5700 Returns the type object, as yet incomplete.
5701 Also records info about it so that build_enumerator
5702 may be used to declare the individual values as they are read. */
5710 /* If this is the real definition for a previous forward reference,
5711 fill in the contents in the same object that used to be the
5712 forward reference. */
5715 enumtype = lookup_tag (ENUMERAL_TYPE, name, current_binding_level, 1);
5717 if (enumtype == 0 || TREE_CODE (enumtype) != ENUMERAL_TYPE)
5719 enumtype = make_node (ENUMERAL_TYPE);
5720 pushtag (name, enumtype);
5723 C_TYPE_BEING_DEFINED (enumtype) = 1;
5725 if (TYPE_VALUES (enumtype) != 0)
5727 /* This enum is a named one that has been declared already. */
5728 error ("redeclaration of `enum %s'", IDENTIFIER_POINTER (name));
5730 /* Completely replace its old definition.
5731 The old enumerators remain defined, however. */
5732 TYPE_VALUES (enumtype) = 0;
5735 enum_next_value = integer_zero_node;
5738 if (flag_short_enums)
5739 TYPE_PACKED (enumtype) = 1;
5744 /* After processing and defining all the values of an enumeration type,
5745 install their decls in the enumeration type and finish it off.
5746 ENUMTYPE is the type object, VALUES a list of decl-value pairs,
5747 and ATTRIBUTES are the specified attributes.
5748 Returns ENUMTYPE. */
5751 finish_enum (enumtype, values, attributes)
5757 tree minnode = 0, maxnode = 0, enum_value_type;
5758 int precision, unsign;
5759 int toplevel = (global_binding_level == current_binding_level);
5761 if (in_parm_level_p ())
5762 warning ("enum defined inside parms");
5764 decl_attributes (&enumtype, attributes, (int) ATTR_FLAG_TYPE_IN_PLACE);
5766 /* Calculate the maximum value of any enumerator in this type. */
5768 if (values == error_mark_node)
5769 minnode = maxnode = integer_zero_node;
5772 minnode = maxnode = TREE_VALUE (values);
5773 for (pair = TREE_CHAIN (values); pair; pair = TREE_CHAIN (pair))
5775 tree value = TREE_VALUE (pair);
5776 if (tree_int_cst_lt (maxnode, value))
5778 if (tree_int_cst_lt (value, minnode))
5783 /* Construct the final type of this enumeration. It is the same
5784 as one of the integral types - the narrowest one that fits, except
5785 that normally we only go as narrow as int - and signed iff any of
5786 the values are negative. */
5787 unsign = (tree_int_cst_sgn (minnode) >= 0);
5788 precision = MAX (min_precision (minnode, unsign),
5789 min_precision (maxnode, unsign));
5790 if (TYPE_PACKED (enumtype) || precision > TYPE_PRECISION (integer_type_node))
5792 tree narrowest = c_common_type_for_size (precision, unsign);
5795 warning ("enumeration values exceed range of largest integer");
5796 narrowest = long_long_integer_type_node;
5799 precision = TYPE_PRECISION (narrowest);
5802 precision = TYPE_PRECISION (integer_type_node);
5804 if (precision == TYPE_PRECISION (integer_type_node))
5805 enum_value_type = c_common_type_for_size (precision, 0);
5807 enum_value_type = enumtype;
5809 TYPE_MIN_VALUE (enumtype) = minnode;
5810 TYPE_MAX_VALUE (enumtype) = maxnode;
5811 TYPE_PRECISION (enumtype) = precision;
5812 TREE_UNSIGNED (enumtype) = unsign;
5813 TYPE_SIZE (enumtype) = 0;
5814 layout_type (enumtype);
5816 if (values != error_mark_node)
5818 /* Change the type of the enumerators to be the enum type. We
5819 need to do this irrespective of the size of the enum, for
5820 proper type checking. Replace the DECL_INITIALs of the
5821 enumerators, and the value slots of the list, with copies
5822 that have the enum type; they cannot be modified in place
5823 because they may be shared (e.g. integer_zero_node) Finally,
5824 change the purpose slots to point to the names of the decls. */
5825 for (pair = values; pair; pair = TREE_CHAIN (pair))
5827 tree enu = TREE_PURPOSE (pair);
5829 TREE_TYPE (enu) = enumtype;
5830 DECL_SIZE (enu) = TYPE_SIZE (enumtype);
5831 DECL_SIZE_UNIT (enu) = TYPE_SIZE_UNIT (enumtype);
5832 DECL_ALIGN (enu) = TYPE_ALIGN (enumtype);
5833 DECL_USER_ALIGN (enu) = TYPE_USER_ALIGN (enumtype);
5834 DECL_MODE (enu) = TYPE_MODE (enumtype);
5836 /* The ISO C Standard mandates enumerators to have type int,
5837 even though the underlying type of an enum type is
5838 unspecified. Here we convert any enumerators that fit in
5839 an int to type int, to avoid promotions to unsigned types
5840 when comparing integers with enumerators that fit in the
5841 int range. When -pedantic is given, build_enumerator()
5842 would have already taken care of those that don't fit. */
5843 if (int_fits_type_p (DECL_INITIAL (enu), enum_value_type))
5844 DECL_INITIAL (enu) = convert (enum_value_type, DECL_INITIAL (enu));
5846 DECL_INITIAL (enu) = convert (enumtype, DECL_INITIAL (enu));
5848 TREE_PURPOSE (pair) = DECL_NAME (enu);
5849 TREE_VALUE (pair) = DECL_INITIAL (enu);
5852 TYPE_VALUES (enumtype) = values;
5855 /* Fix up all variant types of this enum type. */
5856 for (tem = TYPE_MAIN_VARIANT (enumtype); tem; tem = TYPE_NEXT_VARIANT (tem))
5858 if (tem == enumtype)
5860 TYPE_VALUES (tem) = TYPE_VALUES (enumtype);
5861 TYPE_MIN_VALUE (tem) = TYPE_MIN_VALUE (enumtype);
5862 TYPE_MAX_VALUE (tem) = TYPE_MAX_VALUE (enumtype);
5863 TYPE_SIZE (tem) = TYPE_SIZE (enumtype);
5864 TYPE_SIZE_UNIT (tem) = TYPE_SIZE_UNIT (enumtype);
5865 TYPE_MODE (tem) = TYPE_MODE (enumtype);
5866 TYPE_PRECISION (tem) = TYPE_PRECISION (enumtype);
5867 TYPE_ALIGN (tem) = TYPE_ALIGN (enumtype);
5868 TYPE_USER_ALIGN (tem) = TYPE_USER_ALIGN (enumtype);
5869 TREE_UNSIGNED (tem) = TREE_UNSIGNED (enumtype);
5872 /* Finish debugging output for this type. */
5873 rest_of_type_compilation (enumtype, toplevel);
5878 /* Build and install a CONST_DECL for one value of the
5879 current enumeration type (one that was begun with start_enum).
5880 Return a tree-list containing the CONST_DECL and its value.
5881 Assignment of sequential values by default is handled here. */
5884 build_enumerator (name, value)
5889 /* Validate and default VALUE. */
5891 /* Remove no-op casts from the value. */
5893 STRIP_TYPE_NOPS (value);
5897 if (TREE_CODE (value) == INTEGER_CST)
5899 value = default_conversion (value);
5900 constant_expression_warning (value);
5904 error ("enumerator value for `%s' not integer constant",
5905 IDENTIFIER_POINTER (name));
5910 /* Default based on previous value. */
5911 /* It should no longer be possible to have NON_LVALUE_EXPR
5915 value = enum_next_value;
5917 error ("overflow in enumeration values");
5920 if (pedantic && ! int_fits_type_p (value, integer_type_node))
5922 pedwarn ("ISO C restricts enumerator values to range of `int'");
5923 value = convert (integer_type_node, value);
5926 /* Set basis for default for next value. */
5927 enum_next_value = build_binary_op (PLUS_EXPR, value, integer_one_node, 0);
5928 enum_overflow = tree_int_cst_lt (enum_next_value, value);
5930 /* Now create a declaration for the enum value name. */
5932 type = TREE_TYPE (value);
5933 type = c_common_type_for_size (MAX (TYPE_PRECISION (type),
5934 TYPE_PRECISION (integer_type_node)),
5935 (TYPE_PRECISION (type)
5936 >= TYPE_PRECISION (integer_type_node)
5937 && TREE_UNSIGNED (type)));
5939 decl = build_decl (CONST_DECL, name, type);
5940 DECL_INITIAL (decl) = convert (type, value);
5943 return tree_cons (decl, value, NULL_TREE);
5947 /* Create the FUNCTION_DECL for a function definition.
5948 DECLSPECS, DECLARATOR and ATTRIBUTES are the parts of
5949 the declaration; they describe the function's name and the type it returns,
5950 but twisted together in a fashion that parallels the syntax of C.
5952 This function creates a binding context for the function body
5953 as well as setting up the FUNCTION_DECL in current_function_decl.
5955 Returns 1 on success. If the DECLARATOR is not suitable for a function
5956 (it defines a datum instead), we return 0, which tells
5957 yyparse to report a parse error. */
5960 start_function (declspecs, declarator, attributes)
5961 tree declarator, declspecs, attributes;
5963 tree decl1, old_decl;
5965 int old_immediate_size_expand = immediate_size_expand;
5967 current_function_returns_value = 0; /* Assume, until we see it does. */
5968 current_function_returns_null = 0;
5969 current_function_returns_abnormally = 0;
5970 warn_about_return_type = 0;
5971 current_extern_inline = 0;
5972 c_function_varargs = 0;
5974 shadowed_labels = 0;
5976 /* Don't expand any sizes in the return type of the function. */
5977 immediate_size_expand = 0;
5979 decl1 = grokdeclarator (declarator, declspecs, FUNCDEF, 1);
5981 /* If the declarator is not suitable for a function definition,
5982 cause a syntax error. */
5985 immediate_size_expand = old_immediate_size_expand;
5989 decl_attributes (&decl1, attributes, 0);
5991 /* If #pragma weak was used, mark the decl weak now. */
5992 if (current_binding_level == global_binding_level)
5993 maybe_apply_pragma_weak (decl1);
5995 if (DECL_DECLARED_INLINE_P (decl1)
5996 && DECL_UNINLINABLE (decl1)
5997 && lookup_attribute ("noinline", DECL_ATTRIBUTES (decl1)))
5998 warning_with_decl (decl1,
5999 "inline function `%s' given attribute noinline");
6001 announce_function (decl1);
6003 if (!COMPLETE_OR_VOID_TYPE_P (TREE_TYPE (TREE_TYPE (decl1))))
6005 error ("return type is an incomplete type");
6006 /* Make it return void instead. */
6008 = build_function_type (void_type_node,
6009 TYPE_ARG_TYPES (TREE_TYPE (decl1)));
6012 if (warn_about_return_type)
6013 pedwarn_c99 ("return type defaults to `int'");
6015 /* Save the parm names or decls from this function's declarator
6016 where store_parm_decls will find them. */
6017 current_function_parms = last_function_parms;
6018 current_function_parm_tags = last_function_parm_tags;
6020 /* Make the init_value nonzero so pushdecl knows this is not tentative.
6021 error_mark_node is replaced below (in poplevel) with the BLOCK. */
6022 DECL_INITIAL (decl1) = error_mark_node;
6024 /* If this definition isn't a prototype and we had a prototype declaration
6025 before, copy the arg type info from that prototype.
6026 But not if what we had before was a builtin function. */
6027 old_decl = lookup_name_current_level (DECL_NAME (decl1));
6028 if (old_decl != 0 && TREE_CODE (TREE_TYPE (old_decl)) == FUNCTION_TYPE
6029 && !DECL_BUILT_IN (old_decl)
6030 && (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (decl1)))
6031 == TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (old_decl))))
6032 && TYPE_ARG_TYPES (TREE_TYPE (decl1)) == 0)
6034 TREE_TYPE (decl1) = TREE_TYPE (old_decl);
6035 current_function_prototype_file = DECL_SOURCE_FILE (old_decl);
6036 current_function_prototype_line = DECL_SOURCE_LINE (old_decl);
6039 /* If there is no explicit declaration, look for any out-of-scope implicit
6042 old_decl = IDENTIFIER_IMPLICIT_DECL (DECL_NAME (decl1));
6044 /* Optionally warn of old-fashioned def with no previous prototype. */
6045 if (warn_strict_prototypes
6046 && TYPE_ARG_TYPES (TREE_TYPE (decl1)) == 0
6048 && (TYPE_ARG_TYPES (TREE_TYPE (old_decl)) != 0
6049 || (DECL_BUILT_IN (old_decl)
6050 && ! C_DECL_ANTICIPATED (old_decl)))))
6051 warning ("function declaration isn't a prototype");
6052 /* Optionally warn of any global def with no previous prototype. */
6053 else if (warn_missing_prototypes
6054 && TREE_PUBLIC (decl1)
6056 && (TYPE_ARG_TYPES (TREE_TYPE (old_decl)) != 0
6057 || (DECL_BUILT_IN (old_decl)
6058 && ! C_DECL_ANTICIPATED (old_decl))))
6059 && ! MAIN_NAME_P (DECL_NAME (decl1)))
6060 warning_with_decl (decl1, "no previous prototype for `%s'");
6061 /* Optionally warn of any def with no previous prototype
6062 if the function has already been used. */
6063 else if (warn_missing_prototypes
6064 && old_decl != 0 && TREE_USED (old_decl)
6065 && TYPE_ARG_TYPES (TREE_TYPE (old_decl)) == 0)
6066 warning_with_decl (decl1,
6067 "`%s' was used with no prototype before its definition");
6068 /* Optionally warn of any global def with no previous declaration. */
6069 else if (warn_missing_declarations
6070 && TREE_PUBLIC (decl1)
6072 && ! MAIN_NAME_P (DECL_NAME (decl1)))
6073 warning_with_decl (decl1, "no previous declaration for `%s'");
6074 /* Optionally warn of any def with no previous declaration
6075 if the function has already been used. */
6076 else if (warn_missing_declarations
6077 && old_decl != 0 && TREE_USED (old_decl)
6078 && old_decl == IDENTIFIER_IMPLICIT_DECL (DECL_NAME (decl1)))
6079 warning_with_decl (decl1,
6080 "`%s' was used with no declaration before its definition");
6082 /* This is a definition, not a reference.
6083 So normally clear DECL_EXTERNAL.
6084 However, `extern inline' acts like a declaration
6085 except for defining how to inline. So set DECL_EXTERNAL in that case. */
6086 DECL_EXTERNAL (decl1) = current_extern_inline;
6088 /* This function exists in static storage.
6089 (This does not mean `static' in the C sense!) */
6090 TREE_STATIC (decl1) = 1;
6092 /* A nested function is not global. */
6093 if (current_function_decl != 0)
6094 TREE_PUBLIC (decl1) = 0;
6096 /* Warn for unlikely, improbable, or stupid declarations of `main'. */
6097 if (warn_main > 0 && MAIN_NAME_P (DECL_NAME (decl1)))
6102 if (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (decl1)))
6103 != integer_type_node)
6104 pedwarn_with_decl (decl1, "return type of `%s' is not `int'");
6106 for (args = TYPE_ARG_TYPES (TREE_TYPE (decl1)); args;
6107 args = TREE_CHAIN (args))
6109 tree type = args ? TREE_VALUE (args) : 0;
6111 if (type == void_type_node)
6118 if (TYPE_MAIN_VARIANT (type) != integer_type_node)
6119 pedwarn_with_decl (decl1,
6120 "first argument of `%s' should be `int'");
6124 if (TREE_CODE (type) != POINTER_TYPE
6125 || TREE_CODE (TREE_TYPE (type)) != POINTER_TYPE
6126 || (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (type)))
6128 pedwarn_with_decl (decl1,
6129 "second argument of `%s' should be `char **'");
6133 if (TREE_CODE (type) != POINTER_TYPE
6134 || TREE_CODE (TREE_TYPE (type)) != POINTER_TYPE
6135 || (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (type)))
6137 pedwarn_with_decl (decl1,
6138 "third argument of `%s' should probably be `char **'");
6143 /* It is intentional that this message does not mention the third
6144 argument because it's only mentioned in an appendix of the
6146 if (argct > 0 && (argct < 2 || argct > 3))
6147 pedwarn_with_decl (decl1, "`%s' takes only zero or two arguments");
6149 if (! TREE_PUBLIC (decl1))
6150 pedwarn_with_decl (decl1, "`%s' is normally a non-static function");
6153 /* Record the decl so that the function name is defined.
6154 If we already have a decl for this name, and it is a FUNCTION_DECL,
6155 use the old decl. */
6157 current_function_decl = pushdecl (decl1);
6160 declare_parm_level (1);
6161 current_binding_level->subblocks_tag_transparent = 1;
6163 make_decl_rtl (current_function_decl, NULL);
6165 restype = TREE_TYPE (TREE_TYPE (current_function_decl));
6166 /* Promote the value to int before returning it. */
6167 if (c_promoting_integer_type_p (restype))
6169 /* It retains unsignedness if not really getting wider. */
6170 if (TREE_UNSIGNED (restype)
6171 && (TYPE_PRECISION (restype)
6172 == TYPE_PRECISION (integer_type_node)))
6173 restype = unsigned_type_node;
6175 restype = integer_type_node;
6177 DECL_RESULT (current_function_decl)
6178 = build_decl (RESULT_DECL, NULL_TREE, restype);
6180 /* If this fcn was already referenced via a block-scope `extern' decl
6181 (or an implicit decl), propagate certain information about the usage. */
6182 if (TREE_ADDRESSABLE (DECL_ASSEMBLER_NAME (current_function_decl)))
6183 TREE_ADDRESSABLE (current_function_decl) = 1;
6185 immediate_size_expand = old_immediate_size_expand;
6187 start_fname_decls ();
6192 /* Record that this function is going to be a varargs function.
6193 This is called before store_parm_decls, which is too early
6194 to call mark_varargs directly. */
6199 c_function_varargs = 1;
6202 /* Store the parameter declarations into the current function declaration.
6203 This is called after parsing the parameter declarations, before
6204 digesting the body of the function.
6206 For an old-style definition, modify the function's type
6207 to specify at least the number of arguments. */
6212 tree fndecl = current_function_decl;
6215 /* This is either a chain of PARM_DECLs (if a prototype was used)
6216 or a list of IDENTIFIER_NODEs (for an old-fashioned C definition). */
6217 tree specparms = current_function_parms;
6219 /* This is a list of types declared among parms in a prototype. */
6220 tree parmtags = current_function_parm_tags;
6222 /* This is a chain of PARM_DECLs from old-style parm declarations. */
6223 tree parmdecls = getdecls ();
6225 /* This is a chain of any other decls that came in among the parm
6226 declarations. If a parm is declared with enum {foo, bar} x;
6227 then CONST_DECLs for foo and bar are put here. */
6230 /* The function containing FNDECL, if any. */
6231 tree context = decl_function_context (fndecl);
6233 /* Nonzero if this definition is written with a prototype. */
6236 int saved_warn_shadow = warn_shadow;
6238 /* Don't re-emit shadow warnings. */
6241 if (specparms != 0 && TREE_CODE (specparms) != TREE_LIST)
6243 /* This case is when the function was defined with an ANSI prototype.
6244 The parms already have decls, so we need not do anything here
6245 except record them as in effect
6246 and complain if any redundant old-style parm decls were written. */
6257 error_with_decl (fndecl,
6258 "parm types given both in parmlist and separately");
6259 /* Get rid of the erroneous decls; don't keep them on
6260 the list of parms, since they might not be PARM_DECLs. */
6261 for (decl = current_binding_level->names;
6262 decl; decl = TREE_CHAIN (decl))
6263 if (DECL_NAME (decl))
6264 IDENTIFIER_LOCAL_VALUE (DECL_NAME (decl)) = 0;
6265 for (link = current_binding_level->shadowed;
6266 link; link = TREE_CHAIN (link))
6267 IDENTIFIER_LOCAL_VALUE (TREE_PURPOSE (link)) = TREE_VALUE (link);
6268 current_binding_level->names = 0;
6269 current_binding_level->shadowed = 0;
6272 specparms = nreverse (specparms);
6273 for (parm = specparms; parm; parm = next)
6275 next = TREE_CHAIN (parm);
6276 if (TREE_CODE (parm) == PARM_DECL)
6278 if (DECL_NAME (parm) == 0)
6279 error_with_decl (parm, "parameter name omitted");
6280 else if (TREE_CODE (TREE_TYPE (parm)) != ERROR_MARK
6281 && VOID_TYPE_P (TREE_TYPE (parm)))
6283 error_with_decl (parm, "parameter `%s' declared void");
6284 /* Change the type to error_mark_node so this parameter
6285 will be ignored by assign_parms. */
6286 TREE_TYPE (parm) = error_mark_node;
6292 /* If we find an enum constant or a type tag,
6293 put it aside for the moment. */
6294 TREE_CHAIN (parm) = 0;
6295 others = chainon (others, parm);
6299 /* Get the decls in their original chain order
6300 and record in the function. */
6301 DECL_ARGUMENTS (fndecl) = getdecls ();
6304 /* If this function takes a variable number of arguments,
6305 add a phony parameter to the end of the parm list,
6306 to represent the position of the first unnamed argument. */
6307 if (TREE_VALUE (tree_last (TYPE_ARG_TYPES (TREE_TYPE (fndecl))))
6310 tree dummy = build_decl (PARM_DECL, NULL_TREE, void_type_node);
6311 /* Let's hope the address of the unnamed parm
6312 won't depend on its type. */
6313 TREE_TYPE (dummy) = integer_type_node;
6314 DECL_ARG_TYPE (dummy) = integer_type_node;
6315 DECL_ARGUMENTS (fndecl) = chainon (DECL_ARGUMENTS (fndecl), dummy);
6319 /* Now pushdecl the enum constants. */
6320 for (parm = others; parm; parm = next)
6322 next = TREE_CHAIN (parm);
6323 if (DECL_NAME (parm) == 0)
6325 else if (TYPE_MAIN_VARIANT (TREE_TYPE (parm)) == void_type_node)
6327 else if (TREE_CODE (parm) != PARM_DECL)
6331 storetags (chainon (parmtags, gettags ()));
6335 /* SPECPARMS is an identifier list--a chain of TREE_LIST nodes
6336 each with a parm name as the TREE_VALUE.
6338 PARMDECLS is a chain of declarations for parameters.
6339 Warning! It can also contain CONST_DECLs which are not parameters
6340 but are names of enumerators of any enum types
6341 declared among the parameters.
6343 First match each formal parameter name with its declaration.
6344 Associate decls with the names and store the decls
6345 into the TREE_PURPOSE slots. */
6347 /* We use DECL_WEAK as a flag to show which parameters have been
6348 seen already since it is not used on PARM_DECL or CONST_DECL. */
6349 for (parm = parmdecls; parm; parm = TREE_CHAIN (parm))
6350 DECL_WEAK (parm) = 0;
6352 for (parm = specparms; parm; parm = TREE_CHAIN (parm))
6354 tree tail, found = NULL;
6356 if (TREE_VALUE (parm) == 0)
6358 error_with_decl (fndecl,
6359 "parameter name missing from parameter list");
6360 TREE_PURPOSE (parm) = 0;
6364 /* See if any of the parmdecls specifies this parm by name.
6365 Ignore any enumerator decls. */
6366 for (tail = parmdecls; tail; tail = TREE_CHAIN (tail))
6367 if (DECL_NAME (tail) == TREE_VALUE (parm)
6368 && TREE_CODE (tail) == PARM_DECL)
6374 /* If declaration already marked, we have a duplicate name.
6375 Complain, and don't use this decl twice. */
6376 if (found && DECL_WEAK (found))
6378 error_with_decl (found, "multiple parameters named `%s'");
6382 /* If the declaration says "void", complain and ignore it. */
6383 if (found && VOID_TYPE_P (TREE_TYPE (found)))
6385 error_with_decl (found, "parameter `%s' declared void");
6386 TREE_TYPE (found) = integer_type_node;
6387 DECL_ARG_TYPE (found) = integer_type_node;
6388 layout_decl (found, 0);
6391 /* If no declaration found, default to int. */
6394 found = build_decl (PARM_DECL, TREE_VALUE (parm),
6396 DECL_ARG_TYPE (found) = TREE_TYPE (found);
6397 DECL_SOURCE_LINE (found) = DECL_SOURCE_LINE (fndecl);
6398 DECL_SOURCE_FILE (found) = DECL_SOURCE_FILE (fndecl);
6400 pedwarn_with_decl (found, "type of `%s' defaults to `int'");
6401 else if (extra_warnings)
6402 warning_with_decl (found, "type of `%s' defaults to `int'");
6406 TREE_PURPOSE (parm) = found;
6408 /* Mark this decl as "already found". */
6409 DECL_WEAK (found) = 1;
6412 /* Put anything which is on the parmdecls chain and which is
6413 not a PARM_DECL onto the list NONPARMS. (The types of
6414 non-parm things which might appear on the list include
6415 enumerators and NULL-named TYPE_DECL nodes.) Complain about
6416 any actual PARM_DECLs not matched with any names. */
6419 for (parm = parmdecls; parm;)
6421 tree next = TREE_CHAIN (parm);
6422 TREE_CHAIN (parm) = 0;
6424 if (TREE_CODE (parm) != PARM_DECL)
6425 nonparms = chainon (nonparms, parm);
6428 /* Complain about args with incomplete types. */
6429 if (!COMPLETE_TYPE_P (TREE_TYPE (parm)))
6431 error_with_decl (parm, "parameter `%s' has incomplete type");
6432 TREE_TYPE (parm) = error_mark_node;
6435 if (! DECL_WEAK (parm))
6437 error_with_decl (parm,
6438 "declaration for parameter `%s' but no such parameter");
6439 /* Pretend the parameter was not missing.
6440 This gets us to a standard state and minimizes
6441 further error messages. */
6443 = chainon (specparms,
6444 tree_cons (parm, NULL_TREE, NULL_TREE));
6451 /* Chain the declarations together in the order of the list of
6452 names. Store that chain in the function decl, replacing the
6455 DECL_ARGUMENTS (fndecl) = 0;
6458 for (last = 0; parm; parm = TREE_CHAIN (parm))
6459 if (TREE_PURPOSE (parm))
6462 DECL_ARGUMENTS (fndecl) = TREE_PURPOSE (parm);
6464 TREE_CHAIN (last) = TREE_PURPOSE (parm);
6465 last = TREE_PURPOSE (parm);
6466 TREE_CHAIN (last) = 0;
6470 /* If there was a previous prototype,
6471 set the DECL_ARG_TYPE of each argument according to
6472 the type previously specified, and report any mismatches. */
6474 if (TYPE_ARG_TYPES (TREE_TYPE (fndecl)))
6477 for (parm = DECL_ARGUMENTS (fndecl),
6478 type = TYPE_ARG_TYPES (TREE_TYPE (fndecl));
6479 parm || (type && (TYPE_MAIN_VARIANT (TREE_VALUE (type))
6480 != void_type_node));
6481 parm = TREE_CHAIN (parm), type = TREE_CHAIN (type))
6483 if (parm == 0 || type == 0
6484 || TYPE_MAIN_VARIANT (TREE_VALUE (type)) == void_type_node)
6486 error ("number of arguments doesn't match prototype");
6487 error_with_file_and_line (current_function_prototype_file,
6488 current_function_prototype_line,
6489 "prototype declaration");
6492 /* Type for passing arg must be consistent with that
6493 declared for the arg. ISO C says we take the unqualified
6494 type for parameters declared with qualified type. */
6495 if (! comptypes (TYPE_MAIN_VARIANT (DECL_ARG_TYPE (parm)),
6496 TYPE_MAIN_VARIANT (TREE_VALUE (type))))
6498 if (TYPE_MAIN_VARIANT (TREE_TYPE (parm))
6499 == TYPE_MAIN_VARIANT (TREE_VALUE (type)))
6501 /* Adjust argument to match prototype. E.g. a previous
6502 `int foo(float);' prototype causes
6503 `int foo(x) float x; {...}' to be treated like
6504 `int foo(float x) {...}'. This is particularly
6505 useful for argument types like uid_t. */
6506 DECL_ARG_TYPE (parm) = TREE_TYPE (parm);
6508 if (PROMOTE_PROTOTYPES
6509 && INTEGRAL_TYPE_P (TREE_TYPE (parm))
6510 && TYPE_PRECISION (TREE_TYPE (parm))
6511 < TYPE_PRECISION (integer_type_node))
6512 DECL_ARG_TYPE (parm) = integer_type_node;
6516 pedwarn ("promoted argument `%s' doesn't match prototype",
6517 IDENTIFIER_POINTER (DECL_NAME (parm)));
6518 warning_with_file_and_line
6519 (current_function_prototype_file,
6520 current_function_prototype_line,
6521 "prototype declaration");
6526 error ("argument `%s' doesn't match prototype",
6527 IDENTIFIER_POINTER (DECL_NAME (parm)));
6528 error_with_file_and_line (current_function_prototype_file,
6529 current_function_prototype_line,
6530 "prototype declaration");
6534 TYPE_ACTUAL_ARG_TYPES (TREE_TYPE (fndecl)) = 0;
6537 /* Otherwise, create a prototype that would match. */
6541 tree actual = 0, last = 0, type;
6543 for (parm = DECL_ARGUMENTS (fndecl); parm; parm = TREE_CHAIN (parm))
6545 type = tree_cons (NULL_TREE, DECL_ARG_TYPE (parm), NULL_TREE);
6547 TREE_CHAIN (last) = type;
6552 type = tree_cons (NULL_TREE, void_type_node, NULL_TREE);
6554 TREE_CHAIN (last) = type;
6558 /* We are going to assign a new value for the TYPE_ACTUAL_ARG_TYPES
6559 of the type of this function, but we need to avoid having this
6560 affect the types of other similarly-typed functions, so we must
6561 first force the generation of an identical (but separate) type
6562 node for the relevant function type. The new node we create
6563 will be a variant of the main variant of the original function
6566 TREE_TYPE (fndecl) = build_type_copy (TREE_TYPE (fndecl));
6568 TYPE_ACTUAL_ARG_TYPES (TREE_TYPE (fndecl)) = actual;
6571 /* Now store the final chain of decls for the arguments
6572 as the decl-chain of the current lexical scope.
6573 Put the enumerators in as well, at the front so that
6574 DECL_ARGUMENTS is not modified. */
6576 storedecls (chainon (nonparms, DECL_ARGUMENTS (fndecl)));
6579 /* Make sure the binding level for the top of the function body
6580 gets a BLOCK if there are any in the function.
6581 Otherwise, the dbx output is wrong. */
6583 keep_next_if_subblocks = 1;
6585 /* ??? This might be an improvement,
6586 but needs to be thought about some more. */
6588 keep_next_level_flag = 1;
6591 /* Write a record describing this function definition to the prototypes
6592 file (if requested). */
6594 gen_aux_info_record (fndecl, 1, 0, prototype);
6596 /* Initialize the RTL code for the function. */
6597 init_function_start (fndecl, input_filename, lineno);
6599 /* Begin the statement tree for this function. */
6600 begin_stmt_tree (&DECL_SAVED_TREE (current_function_decl));
6602 /* If this is a nested function, save away the sizes of any
6603 variable-size types so that we can expand them when generating
6609 DECL_LANG_SPECIFIC (fndecl)->pending_sizes
6610 = nreverse (get_pending_sizes ());
6611 for (t = DECL_LANG_SPECIFIC (fndecl)->pending_sizes;
6614 SAVE_EXPR_CONTEXT (TREE_VALUE (t)) = context;
6617 /* This function is being processed in whole-function mode. */
6618 cfun->x_whole_function_mode_p = 1;
6620 /* Even though we're inside a function body, we still don't want to
6621 call expand_expr to calculate the size of a variable-sized array.
6622 We haven't necessarily assigned RTL to all variables yet, so it's
6623 not safe to try to expand expressions involving them. */
6624 immediate_size_expand = 0;
6625 cfun->x_dont_save_pending_sizes_p = 1;
6627 warn_shadow = saved_warn_shadow;
6630 /* Finish up a function declaration and compile that function
6631 all the way to assembler language output. The free the storage
6632 for the function definition.
6634 This is called after parsing the body of the function definition.
6636 NESTED is nonzero if the function being finished is nested in another.
6637 CAN_DEFER_P is nonzero if the function may be deferred. */
6640 finish_function (nested, can_defer_p)
6644 tree fndecl = current_function_decl;
6647 /* This caused &foo to be of type ptr-to-const-function which then
6648 got a warning when stored in a ptr-to-function variable. */
6649 TREE_READONLY (fndecl) = 1;
6653 BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl)) = fndecl;
6655 /* Must mark the RESULT_DECL as being in this function. */
6657 DECL_CONTEXT (DECL_RESULT (fndecl)) = fndecl;
6659 if (MAIN_NAME_P (DECL_NAME (fndecl)) && flag_hosted)
6661 if (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (fndecl)))
6662 != integer_type_node)
6664 /* If warn_main is 1 (-Wmain) or 2 (-Wall), we have already warned.
6665 If warn_main is -1 (-Wno-main) we don't want to be warned. */
6667 pedwarn_with_decl (fndecl, "return type of `%s' is not `int'");
6671 #ifdef DEFAULT_MAIN_RETURN
6672 /* Make it so that `main' always returns success by default. */
6673 DEFAULT_MAIN_RETURN;
6676 c_expand_return (integer_zero_node);
6681 finish_fname_decls ();
6683 /* Tie off the statement tree for this function. */
6684 finish_stmt_tree (&DECL_SAVED_TREE (fndecl));
6686 /* Complain if there's just no return statement. */
6687 if (warn_return_type
6688 && TREE_CODE (TREE_TYPE (TREE_TYPE (fndecl))) != VOID_TYPE
6689 && !current_function_returns_value && !current_function_returns_null
6690 /* Don't complain if we abort. */
6691 && !current_function_returns_abnormally
6692 /* Don't warn for main(). */
6693 && !MAIN_NAME_P (DECL_NAME (fndecl))
6694 /* Or if they didn't actually specify a return type. */
6695 && !C_FUNCTION_IMPLICIT_INT (fndecl)
6696 /* Normally, with -Wreturn-type, flow will complain. Unless we're an
6697 inline function, as we might never be compiled separately. */
6698 && DECL_INLINE (fndecl))
6699 warning ("no return statement in function returning non-void");
6701 /* Clear out memory we no longer need. */
6702 free_after_parsing (cfun);
6703 /* Since we never call rest_of_compilation, we never clear
6704 CFUN. Do so explicitly. */
6705 free_after_compilation (cfun);
6710 /* Generate RTL for the body of this function. */
6711 c_expand_body (fndecl, nested, can_defer_p);
6713 /* Let the error reporting routines know that we're outside a
6714 function. For a nested function, this value is used in
6715 c_pop_function_context and then reset via pop_function_context. */
6716 current_function_decl = NULL;
6720 /* Generate the RTL for a deferred function FNDECL. */
6723 c_expand_deferred_function (fndecl)
6726 /* DECL_INLINE or DECL_RESULT might got cleared after the inline
6727 function was deferred, e.g. in duplicate_decls. */
6728 if (DECL_INLINE (fndecl) && DECL_RESULT (fndecl))
6730 c_expand_body (fndecl, 0, 0);
6731 current_function_decl = NULL;
6735 /* Generate the RTL for the body of FNDECL. If NESTED_P is non-zero,
6736 then we are already in the process of generating RTL for another
6737 function. If can_defer_p is zero, we won't attempt to defer the
6738 generation of RTL. */
6741 c_expand_body (fndecl, nested_p, can_defer_p)
6743 int nested_p, can_defer_p;
6745 int uninlinable = 1;
6747 /* There's no reason to do any of the work here if we're only doing
6748 semantic analysis; this code just generates RTL. */
6749 if (flag_syntax_only)
6752 if (flag_inline_trees)
6754 /* First, cache whether the current function is inlinable. Some
6755 predicates depend on cfun and current_function_decl to
6756 function completely. */
6757 timevar_push (TV_INTEGRATION);
6758 uninlinable = ! tree_inlinable_function_p (fndecl);
6760 if (! uninlinable && can_defer_p
6761 /* Save function tree for inlining. Should return 0 if the
6762 language does not support function deferring or the
6763 function could not be deferred. */
6764 && defer_fn (fndecl))
6766 /* Let the back-end know that this function exists. */
6767 (*debug_hooks->deferred_inline_function) (fndecl);
6768 timevar_pop (TV_INTEGRATION);
6772 /* Then, inline any functions called in it. */
6773 optimize_inline_calls (fndecl);
6774 timevar_pop (TV_INTEGRATION);
6777 timevar_push (TV_EXPAND);
6781 /* Make sure that we will evaluate variable-sized types involved
6782 in our function's type. */
6783 expand_pending_sizes (DECL_LANG_SPECIFIC (fndecl)->pending_sizes);
6784 /* Squirrel away our current state. */
6785 push_function_context ();
6788 /* Initialize the RTL code for the function. */
6789 current_function_decl = fndecl;
6790 input_filename = DECL_SOURCE_FILE (fndecl);
6791 init_function_start (fndecl, input_filename, DECL_SOURCE_LINE (fndecl));
6793 /* This function is being processed in whole-function mode. */
6794 cfun->x_whole_function_mode_p = 1;
6796 /* Even though we're inside a function body, we still don't want to
6797 call expand_expr to calculate the size of a variable-sized array.
6798 We haven't necessarily assigned RTL to all variables yet, so it's
6799 not safe to try to expand expressions involving them. */
6800 immediate_size_expand = 0;
6801 cfun->x_dont_save_pending_sizes_p = 1;
6803 /* If this is a varargs function, inform function.c. */
6804 if (c_function_varargs)
6807 /* Set up parameters and prepare for return, for the function. */
6808 expand_function_start (fndecl, 0);
6810 /* If this function is `main', emit a call to `__main'
6811 to run global initializers, etc. */
6812 if (DECL_NAME (fndecl)
6813 && MAIN_NAME_P (DECL_NAME (fndecl))
6814 && DECL_CONTEXT (fndecl) == NULL_TREE)
6815 expand_main_function ();
6817 /* Generate the RTL for this function. */
6818 expand_stmt (DECL_SAVED_TREE (fndecl));
6821 /* Allow the body of the function to be garbage collected. */
6822 DECL_SAVED_TREE (fndecl) = NULL_TREE;
6825 /* We hard-wired immediate_size_expand to zero above.
6826 expand_function_end will decrement this variable. So, we set the
6827 variable to one here, so that after the decrement it will remain
6829 immediate_size_expand = 1;
6831 /* Allow language dialects to perform special processing. */
6832 if (lang_expand_function_end)
6833 (*lang_expand_function_end) ();
6835 /* Generate rtl for function exit. */
6836 expand_function_end (input_filename, lineno, 0);
6838 /* If this is a nested function, protect the local variables in the stack
6839 above us from being collected while we're compiling this function. */
6841 ggc_push_context ();
6843 /* Run the optimizers and output the assembler code for this function. */
6844 rest_of_compilation (fndecl);
6846 /* Undo the GC context switch. */
6850 /* With just -W, complain only if function returns both with
6851 and without a value. */
6853 && current_function_returns_value
6854 && current_function_returns_null)
6855 warning ("this function may return with or without a value");
6857 /* If requested, warn about function definitions where the function will
6858 return a value (usually of some struct or union type) which itself will
6859 take up a lot of stack space. */
6861 if (warn_larger_than && !DECL_EXTERNAL (fndecl) && TREE_TYPE (fndecl))
6863 tree ret_type = TREE_TYPE (TREE_TYPE (fndecl));
6865 if (ret_type && TYPE_SIZE_UNIT (ret_type)
6866 && TREE_CODE (TYPE_SIZE_UNIT (ret_type)) == INTEGER_CST
6867 && 0 < compare_tree_int (TYPE_SIZE_UNIT (ret_type),
6870 unsigned int size_as_int
6871 = TREE_INT_CST_LOW (TYPE_SIZE_UNIT (ret_type));
6873 if (compare_tree_int (TYPE_SIZE_UNIT (ret_type), size_as_int) == 0)
6874 warning_with_decl (fndecl,
6875 "size of return value of `%s' is %u bytes",
6878 warning_with_decl (fndecl,
6879 "size of return value of `%s' is larger than %d bytes",
6884 if (DECL_SAVED_INSNS (fndecl) == 0 && ! nested_p
6885 && ! flag_inline_trees)
6887 /* Stop pointing to the local nodes about to be freed.
6888 But DECL_INITIAL must remain nonzero so we know this
6889 was an actual function definition.
6890 For a nested function, this is done in c_pop_function_context.
6891 If rest_of_compilation set this to 0, leave it 0. */
6892 if (DECL_INITIAL (fndecl) != 0)
6893 DECL_INITIAL (fndecl) = error_mark_node;
6895 DECL_ARGUMENTS (fndecl) = 0;
6898 if (DECL_STATIC_CONSTRUCTOR (fndecl))
6900 if (targetm.have_ctors_dtors)
6901 (* targetm.asm_out.constructor) (XEXP (DECL_RTL (fndecl), 0),
6902 DEFAULT_INIT_PRIORITY);
6904 static_ctors = tree_cons (NULL_TREE, fndecl, static_ctors);
6907 if (DECL_STATIC_DESTRUCTOR (fndecl))
6909 if (targetm.have_ctors_dtors)
6910 (* targetm.asm_out.destructor) (XEXP (DECL_RTL (fndecl), 0),
6911 DEFAULT_INIT_PRIORITY);
6913 static_dtors = tree_cons (NULL_TREE, fndecl, static_dtors);
6917 /* Return to the enclosing function. */
6918 pop_function_context ();
6919 timevar_pop (TV_EXPAND);
6922 /* Check the declarations given in a for-loop for satisfying the C99
6925 check_for_loop_decls ()
6931 /* If we get here, declarations have been used in a for loop without
6932 the C99 for loop scope. This doesn't make much sense, so don't
6934 error ("`for' loop initial declaration used outside C99 mode");
6937 /* C99 subclause 6.8.5 paragraph 3:
6939 [#3] The declaration part of a for statement shall only
6940 declare identifiers for objects having storage class auto or
6943 It isn't clear whether, in this sentence, "identifiers" binds to
6944 "shall only declare" or to "objects" - that is, whether all identifiers
6945 declared must be identifiers for objects, or whether the restriction
6946 only applies to those that are. (A question on this in comp.std.c
6947 in November 2000 received no answer.) We implement the strictest
6948 interpretation, to avoid creating an extension which later causes
6951 for (t = gettags (); t; t = TREE_CHAIN (t))
6953 if (TREE_PURPOSE (t) != 0)
6955 enum tree_code code = TREE_CODE (TREE_VALUE (t));
6957 if (code == RECORD_TYPE)
6958 error ("`struct %s' declared in `for' loop initial declaration",
6959 IDENTIFIER_POINTER (TREE_PURPOSE (t)));
6960 else if (code == UNION_TYPE)
6961 error ("`union %s' declared in `for' loop initial declaration",
6962 IDENTIFIER_POINTER (TREE_PURPOSE (t)));
6964 error ("`enum %s' declared in `for' loop initial declaration",
6965 IDENTIFIER_POINTER (TREE_PURPOSE (t)));
6969 for (t = getdecls (); t; t = TREE_CHAIN (t))
6971 if (TREE_CODE (t) != VAR_DECL && DECL_NAME (t))
6972 error_with_decl (t, "declaration of non-variable `%s' in `for' loop initial declaration");
6973 else if (TREE_STATIC (t))
6974 error_with_decl (t, "declaration of static variable `%s' in `for' loop initial declaration");
6975 else if (DECL_EXTERNAL (t))
6976 error_with_decl (t, "declaration of `extern' variable `%s' in `for' loop initial declaration");
6980 /* Save and restore the variables in this file and elsewhere
6981 that keep track of the progress of compilation of the current function.
6982 Used for nested functions. */
6984 struct c_language_function
6986 struct language_function base;
6988 tree shadowed_labels;
6991 int returns_abnormally;
6992 int warn_about_return_type;
6994 struct binding_level *binding_level;
6997 /* Save and reinitialize the variables
6998 used during compilation of a C function. */
7001 c_push_function_context (f)
7004 struct c_language_function *p;
7005 p = ((struct c_language_function *)
7006 xmalloc (sizeof (struct c_language_function)));
7007 f->language = (struct language_function *) p;
7009 p->base.x_stmt_tree = c_stmt_tree;
7010 p->base.x_scope_stmt_stack = c_scope_stmt_stack;
7011 p->named_labels = named_labels;
7012 p->shadowed_labels = shadowed_labels;
7013 p->returns_value = current_function_returns_value;
7014 p->returns_null = current_function_returns_null;
7015 p->returns_abnormally = current_function_returns_abnormally;
7016 p->warn_about_return_type = warn_about_return_type;
7017 p->extern_inline = current_extern_inline;
7018 p->binding_level = current_binding_level;
7021 /* Restore the variables used during compilation of a C function. */
7024 c_pop_function_context (f)
7027 struct c_language_function *p
7028 = (struct c_language_function *) f->language;
7031 /* Bring back all the labels that were shadowed. */
7032 for (link = shadowed_labels; link; link = TREE_CHAIN (link))
7033 if (DECL_NAME (TREE_VALUE (link)) != 0)
7034 IDENTIFIER_LABEL_VALUE (DECL_NAME (TREE_VALUE (link)))
7035 = TREE_VALUE (link);
7037 if (DECL_SAVED_INSNS (current_function_decl) == 0
7038 && DECL_SAVED_TREE (current_function_decl) == NULL_TREE)
7040 /* Stop pointing to the local nodes about to be freed. */
7041 /* But DECL_INITIAL must remain nonzero so we know this
7042 was an actual function definition. */
7043 DECL_INITIAL (current_function_decl) = error_mark_node;
7044 DECL_ARGUMENTS (current_function_decl) = 0;
7047 c_stmt_tree = p->base.x_stmt_tree;
7048 c_scope_stmt_stack = p->base.x_scope_stmt_stack;
7049 named_labels = p->named_labels;
7050 shadowed_labels = p->shadowed_labels;
7051 current_function_returns_value = p->returns_value;
7052 current_function_returns_null = p->returns_null;
7053 current_function_returns_abnormally = p->returns_abnormally;
7054 warn_about_return_type = p->warn_about_return_type;
7055 current_extern_inline = p->extern_inline;
7056 current_binding_level = p->binding_level;
7062 /* Mark the language specific parts of F for GC. */
7065 c_mark_function_context (f)
7068 struct c_language_function *p
7069 = (struct c_language_function *) f->language;
7074 mark_c_language_function (&p->base);
7075 ggc_mark_tree (p->shadowed_labels);
7076 ggc_mark_tree (p->named_labels);
7077 mark_binding_level (&p->binding_level);
7080 /* Copy the DECL_LANG_SPECIFIC data associated with DECL. */
7083 c_dup_lang_specific_decl (decl)
7086 struct lang_decl *ld;
7088 if (!DECL_LANG_SPECIFIC (decl))
7091 ld = (struct lang_decl *) ggc_alloc (sizeof (struct lang_decl));
7092 memcpy ((char *) ld, (char *) DECL_LANG_SPECIFIC (decl),
7093 sizeof (struct lang_decl));
7094 DECL_LANG_SPECIFIC (decl) = ld;
7097 /* Mark the language specific bits in T for GC. */
7103 if (TREE_CODE (t) == IDENTIFIER_NODE)
7105 struct lang_identifier *i = (struct lang_identifier *) t;
7106 ggc_mark_tree (i->global_value);
7107 ggc_mark_tree (i->local_value);
7108 ggc_mark_tree (i->label_value);
7109 ggc_mark_tree (i->implicit_decl);
7110 ggc_mark_tree (i->error_locus);
7111 ggc_mark_tree (i->limbo_value);
7113 else if (TYPE_P (t) && TYPE_LANG_SPECIFIC (t))
7114 ggc_mark (TYPE_LANG_SPECIFIC (t));
7115 else if (DECL_P (t) && DECL_LANG_SPECIFIC (t))
7117 ggc_mark (DECL_LANG_SPECIFIC (t));
7118 c_mark_lang_decl (&DECL_LANG_SPECIFIC (t)->base);
7119 ggc_mark_tree (DECL_LANG_SPECIFIC (t)->pending_sizes);
7123 /* The functions below are required for functionality of doing
7124 function at once processing in the C front end. Currently these
7125 functions are not called from anywhere in the C front end, but as
7126 these changes continue, that will change. */
7128 /* Returns non-zero if the current statement is a full expression,
7129 i.e. temporaries created during that statement should be destroyed
7130 at the end of the statement. */
7133 stmts_are_full_exprs_p ()
7138 /* Returns the stmt_tree (if any) to which statements are currently
7139 being added. If there is no active statement-tree, NULL is
7143 current_stmt_tree ()
7145 return &c_stmt_tree;
7148 /* Returns the stack of SCOPE_STMTs for the current function. */
7151 current_scope_stmt_stack ()
7153 return &c_scope_stmt_stack;
7156 /* Nonzero if TYPE is an anonymous union or struct type. Always 0 in
7160 anon_aggr_type_p (node)
7161 tree node ATTRIBUTE_UNUSED;
7166 /* Dummy function in place of callback used by C++. */
7169 extract_interface_info ()
7173 /* Return a new COMPOUND_STMT, after adding it to the current
7177 c_begin_compound_stmt ()
7181 /* Create the COMPOUND_STMT. */
7182 stmt = add_stmt (build_stmt (COMPOUND_STMT, NULL_TREE));
7187 /* Expand T (a DECL_STMT) if it declares an entity not handled by the
7191 c_expand_decl_stmt (t)
7194 tree decl = DECL_STMT_DECL (t);
7196 /* Expand nested functions. */
7197 if (TREE_CODE (decl) == FUNCTION_DECL
7198 && DECL_CONTEXT (decl) == current_function_decl
7199 && DECL_SAVED_TREE (decl))
7200 c_expand_body (decl, /*nested_p=*/1, /*can_defer_p=*/0);
7203 /* Return the IDENTIFIER_GLOBAL_VALUE of T, for use in common code, since
7204 the definition of IDENTIFIER_GLOBAL_VALUE is different for C and C++. */
7207 identifier_global_value (t)
7210 return IDENTIFIER_GLOBAL_VALUE (t);
7213 /* Record a builtin type for C. If NAME is non-NULL, it is the name used;
7214 otherwise the name is found in ridpointers from RID_INDEX. */
7217 record_builtin_type (rid_index, name, type)
7224 id = ridpointers[(int) rid_index];
7226 id = get_identifier (name);
7227 pushdecl (build_decl (TYPE_DECL, id, type));
7230 /* Build the void_list_node (void_type_node having been created). */
7232 build_void_list_node ()
7234 tree t = build_tree_list (NULL_TREE, void_type_node);