1 /* Process declarations and variables for C compiler.
2 Copyright (C) 1988, 92, 93, 94, 95, 96, 1997 Free Software Foundation, Inc.
4 This file is part of GNU CC.
6 GNU CC is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2, or (at your option)
11 GNU CC is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with GNU CC; see the file COPYING. If not, write to
18 the Free Software Foundation, 59 Temple Place - Suite 330,
19 Boston, MA 02111-1307, USA. */
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. */
37 /* In grokdeclarator, distinguish syntactic contexts of declarators. */
39 { NORMAL, /* Ordinary declaration */
40 FUNCDEF, /* Function definition */
41 PARM, /* Declaration of parm before function body */
42 FIELD, /* Declaration inside struct or union */
43 BITFIELD, /* Likewise but with specified width */
44 TYPENAME}; /* Typename (inside cast or sizeof) */
46 #ifndef CHAR_TYPE_SIZE
47 #define CHAR_TYPE_SIZE BITS_PER_UNIT
50 #ifndef SHORT_TYPE_SIZE
51 #define SHORT_TYPE_SIZE (BITS_PER_UNIT * MIN ((UNITS_PER_WORD + 1) / 2, 2))
55 #define INT_TYPE_SIZE BITS_PER_WORD
58 #ifndef LONG_TYPE_SIZE
59 #define LONG_TYPE_SIZE BITS_PER_WORD
62 #ifndef LONG_LONG_TYPE_SIZE
63 #define LONG_LONG_TYPE_SIZE (BITS_PER_WORD * 2)
66 #ifndef WCHAR_UNSIGNED
67 #define WCHAR_UNSIGNED 0
70 #ifndef FLOAT_TYPE_SIZE
71 #define FLOAT_TYPE_SIZE BITS_PER_WORD
74 #ifndef DOUBLE_TYPE_SIZE
75 #define DOUBLE_TYPE_SIZE (BITS_PER_WORD * 2)
78 #ifndef LONG_DOUBLE_TYPE_SIZE
79 #define LONG_DOUBLE_TYPE_SIZE (BITS_PER_WORD * 2)
82 /* We let tm.h override the types used here, to handle trivial differences
83 such as the choice of unsigned int or long unsigned int for size_t.
84 When machines start needing nontrivial differences in the size type,
85 it would be best to do something here to figure out automatically
86 from other information what type to use. */
89 #define SIZE_TYPE "long unsigned int"
93 #define PTRDIFF_TYPE "long int"
97 #define WCHAR_TYPE "int"
100 /* a node which has tree code ERROR_MARK, and whose type is itself.
101 All erroneous expressions are replaced with this node. All functions
102 that accept nodes as arguments should avoid generating error messages
103 if this node is one of the arguments, since it is undesirable to get
104 multiple error messages from one error in the input. */
106 tree error_mark_node;
108 /* INTEGER_TYPE and REAL_TYPE nodes for the standard data types */
110 tree short_integer_type_node;
111 tree integer_type_node;
112 tree long_integer_type_node;
113 tree long_long_integer_type_node;
115 tree short_unsigned_type_node;
116 tree unsigned_type_node;
117 tree long_unsigned_type_node;
118 tree long_long_unsigned_type_node;
120 tree boolean_type_node;
121 tree boolean_false_node;
122 tree boolean_true_node;
124 tree ptrdiff_type_node;
126 tree unsigned_char_type_node;
127 tree signed_char_type_node;
129 tree wchar_type_node;
130 tree signed_wchar_type_node;
131 tree unsigned_wchar_type_node;
133 tree float_type_node;
134 tree double_type_node;
135 tree long_double_type_node;
137 tree complex_integer_type_node;
138 tree complex_float_type_node;
139 tree complex_double_type_node;
140 tree complex_long_double_type_node;
142 tree intQI_type_node;
143 tree intHI_type_node;
144 tree intSI_type_node;
145 tree intDI_type_node;
147 tree unsigned_intQI_type_node;
148 tree unsigned_intHI_type_node;
149 tree unsigned_intSI_type_node;
150 tree unsigned_intDI_type_node;
152 /* a VOID_TYPE node. */
156 /* Nodes for types `void *' and `const void *'. */
158 tree ptr_type_node, const_ptr_type_node;
160 /* Nodes for types `char *' and `const char *'. */
162 tree string_type_node, const_string_type_node;
164 /* Type `char[SOMENUMBER]'.
165 Used when an array of char is needed and the size is irrelevant. */
167 tree char_array_type_node;
169 /* Type `int[SOMENUMBER]' or something like it.
170 Used when an array of int needed and the size is irrelevant. */
172 tree int_array_type_node;
174 /* Type `wchar_t[SOMENUMBER]' or something like it.
175 Used when a wide string literal is created. */
177 tree wchar_array_type_node;
179 /* type `int ()' -- used for implicit declaration of functions. */
181 tree default_function_type;
183 /* function types `double (double)' and `double (double, double)', etc. */
185 tree double_ftype_double, double_ftype_double_double;
186 tree int_ftype_int, long_ftype_long;
187 tree float_ftype_float;
188 tree ldouble_ftype_ldouble;
190 /* Function type `void (void *, void *, int)' and similar ones */
192 tree void_ftype_ptr_ptr_int, int_ftype_ptr_ptr_int, void_ftype_ptr_int_int;
194 /* Function type `char *(char *, char *)' and similar ones */
195 tree string_ftype_ptr_ptr, int_ftype_string_string;
197 /* Function type `int (const void *, const void *, size_t)' */
198 tree int_ftype_cptr_cptr_sizet;
200 /* Two expressions that are constants with value zero.
201 The first is of type `int', the second of type `void *'. */
203 tree integer_zero_node;
204 tree null_pointer_node;
206 /* A node for the integer constant 1. */
208 tree integer_one_node;
210 /* Nonzero if we have seen an invalid cross reference
211 to a struct, union, or enum, but not yet printed the message. */
213 tree pending_invalid_xref;
214 /* File and line to appear in the eventual error message. */
215 char *pending_invalid_xref_file;
216 int pending_invalid_xref_line;
218 /* While defining an enum type, this is 1 plus the last enumerator
219 constant value. Note that will do not have to save this or `enum_overflow'
220 around nested function definition since such a definition could only
221 occur in an enum value expression and we don't use these variables in
224 static tree enum_next_value;
226 /* Nonzero means that there was overflow computing enum_next_value. */
228 static int enum_overflow;
230 /* Parsing a function declarator leaves a list of parameter names
231 or a chain or parameter decls here. */
233 static tree last_function_parms;
235 /* Parsing a function declarator leaves here a chain of structure
236 and enum types declared in the parmlist. */
238 static tree last_function_parm_tags;
240 /* After parsing the declarator that starts a function definition,
241 `start_function' puts here the list of parameter names or chain of decls.
242 `store_parm_decls' finds it here. */
244 static tree current_function_parms;
246 /* Similar, for last_function_parm_tags. */
247 static tree current_function_parm_tags;
249 /* Similar, for the file and line that the prototype came from if this is
250 an old-style definition. */
251 static char *current_function_prototype_file;
252 static int current_function_prototype_line;
254 /* A list (chain of TREE_LIST nodes) of all LABEL_DECLs in the function
255 that have names. Here so we can clear out their names' definitions
256 at the end of the function. */
258 static tree named_labels;
260 /* A list of LABEL_DECLs from outer contexts that are currently shadowed. */
262 static tree shadowed_labels;
264 /* Nonzero when store_parm_decls is called indicates a varargs function.
265 Value not meaningful after store_parm_decls. */
267 static int c_function_varargs;
269 /* The FUNCTION_DECL for the function currently being compiled,
270 or 0 if between functions. */
271 tree current_function_decl;
273 /* Set to 0 at beginning of a function definition, set to 1 if
274 a return statement that specifies a return value is seen. */
276 int current_function_returns_value;
278 /* Set to 0 at beginning of a function definition, set to 1 if
279 a return statement with no argument is seen. */
281 int current_function_returns_null;
283 /* Set to nonzero by `grokdeclarator' for a function
284 whose return type is defaulted, if warnings for this are desired. */
286 static int warn_about_return_type;
288 /* Nonzero when starting a function declared `extern inline'. */
290 static int current_extern_inline;
292 /* For each binding contour we allocate a binding_level structure
293 * which records the names defined in that contour.
296 * 1) one for each function definition,
297 * where internal declarations of the parameters appear.
298 * 2) one for each compound statement,
299 * to record its declarations.
301 * The current meaning of a name can be found by searching the levels from
302 * the current one out to the global one.
305 /* Note that the information in the `names' component of the global contour
306 is duplicated in the IDENTIFIER_GLOBAL_VALUEs of all identifiers. */
310 /* A chain of _DECL nodes for all variables, constants, functions,
311 and typedef types. These are in the reverse of the order supplied.
315 /* A list of structure, union and enum definitions,
316 * for looking up tag names.
317 * It is a chain of TREE_LIST nodes, each of whose TREE_PURPOSE is a name,
318 * or NULL_TREE; and whose TREE_VALUE is a RECORD_TYPE, UNION_TYPE,
319 * or ENUMERAL_TYPE node.
323 /* For each level, a list of shadowed outer-level local definitions
324 to be restored when this level is popped.
325 Each link is a TREE_LIST whose TREE_PURPOSE is an identifier and
326 whose TREE_VALUE is its old definition (a kind of ..._DECL node). */
329 /* For each level (except not the global one),
330 a chain of BLOCK nodes for all the levels
331 that were entered and exited one level down. */
334 /* The BLOCK node for this level, if one has been preallocated.
335 If 0, the BLOCK is allocated (if needed) when the level is popped. */
338 /* The binding level which this one is contained in (inherits from). */
339 struct binding_level *level_chain;
341 /* Nonzero for the level that holds the parameters of a function. */
344 /* Nonzero if this level "doesn't exist" for tags. */
345 char tag_transparent;
347 /* Nonzero if sublevels of this level "don't exist" for tags.
348 This is set in the parm level of a function definition
349 while reading the function body, so that the outermost block
350 of the function body will be tag-transparent. */
351 char subblocks_tag_transparent;
353 /* Nonzero means make a BLOCK for this level regardless of all else. */
356 /* Nonzero means make a BLOCK if this level has any subblocks. */
357 char keep_if_subblocks;
359 /* Number of decls in `names' that have incomplete
360 structure or union types. */
363 /* A list of decls giving the (reversed) specified order of parms,
364 not including any forward-decls in the parmlist.
365 This is so we can put the parms in proper order for assign_parms. */
369 #define NULL_BINDING_LEVEL (struct binding_level *) NULL
371 /* The binding level currently in effect. */
373 static struct binding_level *current_binding_level;
375 /* A chain of binding_level structures awaiting reuse. */
377 static struct binding_level *free_binding_level;
379 /* The outermost binding level, for names of file scope.
380 This is created when the compiler is started and exists
381 through the entire run. */
383 static struct binding_level *global_binding_level;
385 /* Binding level structures are initialized by copying this one. */
387 static struct binding_level clear_binding_level
388 = {NULL, NULL, NULL, NULL, NULL, NULL_BINDING_LEVEL, 0, 0, 0, 0, 0, 0,
391 /* Nonzero means unconditionally make a BLOCK for the next level pushed. */
393 static int keep_next_level_flag;
395 /* Nonzero means make a BLOCK for the next level pushed
396 if it has subblocks. */
398 static int keep_next_if_subblocks;
400 /* The chain of outer levels of label scopes.
401 This uses the same data structure used for binding levels,
402 but it works differently: each link in the chain records
403 saved values of named_labels and shadowed_labels for
404 a label binding level outside the current one. */
406 static struct binding_level *label_level_chain;
408 /* Functions called automatically at the beginning and end of execution. */
410 tree static_ctors, static_dtors;
412 /* Forward declarations. */
414 static struct binding_level * make_binding_level PROTO((void));
415 static void clear_limbo_values PROTO((tree));
416 static int duplicate_decls PROTO((tree, tree, int));
417 static char *redeclaration_error_message PROTO((tree, tree));
418 static void storedecls PROTO((tree));
419 static void storetags PROTO((tree));
420 static tree lookup_tag PROTO((enum tree_code, tree,
421 struct binding_level *, int));
422 static tree lookup_tag_reverse PROTO((tree));
423 static tree grokdeclarator PROTO((tree, tree, enum decl_context,
425 static tree grokparms PROTO((tree, int));
426 static int field_decl_cmp PROTO((const GENERIC_PTR, const GENERIC_PTR));
427 static void layout_array_type PROTO((tree));
429 /* C-specific option variables. */
431 /* Nonzero means allow type mismatches in conditional expressions;
432 just make their values `void'. */
434 int flag_cond_mismatch;
436 /* Nonzero means give `double' the same size as `float'. */
438 int flag_short_double;
440 /* Nonzero means don't recognize the keyword `asm'. */
444 /* Nonzero means don't recognize any builtin functions. */
448 /* Nonzero means don't recognize the non-ANSI builtin functions.
451 int flag_no_nonansi_builtin;
453 /* Nonzero means do some things the same way PCC does. */
455 int flag_traditional;
457 /* Nonzero means that we have builtin functions, and main is an int */
461 /* Nonzero means to allow single precision math even if we're generally
462 being traditional. */
463 int flag_allow_single_precision = 0;
465 /* Nonzero means to treat bitfields as signed unless they say `unsigned'. */
467 int flag_signed_bitfields = 1;
468 int explicit_flag_signed_bitfields = 0;
470 /* Nonzero means handle `#ident' directives. 0 means ignore them. */
472 int flag_no_ident = 0;
474 /* Nonzero means warn about implicit declarations. */
478 /* Nonzero means give string constants the type `const char *'
479 to get extra warnings from them. These warnings will be too numerous
480 to be useful, except in thoroughly ANSIfied programs. */
482 int warn_write_strings;
484 /* Nonzero means warn about pointer casts that can drop a type qualifier
485 from the pointer target type. */
489 /* Nonzero means warn when casting a function call to a type that does
490 not match the return type (e.g. (float)sqrt() or (anything*)malloc()
491 when there is no previous declaration of sqrt or malloc. */
493 int warn_bad_function_cast;
495 /* Warn about traditional constructs whose meanings changed in ANSI C. */
497 int warn_traditional;
499 /* Nonzero means warn about sizeof(function) or addition/subtraction
500 of function pointers. */
502 int warn_pointer_arith;
504 /* Nonzero means warn for non-prototype function decls
505 or non-prototyped defs without previous prototype. */
507 int warn_strict_prototypes;
509 /* Nonzero means warn for any global function def
510 without separate previous prototype decl. */
512 int warn_missing_prototypes;
514 /* Nonzero means warn for any global function def
515 without separate previous decl. */
517 int warn_missing_declarations;
519 /* Nonzero means warn about multiple (redundant) decls for the same single
520 variable or function. */
522 int warn_redundant_decls = 0;
524 /* Nonzero means warn about extern declarations of objects not at
525 file-scope level and about *all* declarations of functions (whether
526 extern or static) not at file-scope level. Note that we exclude
527 implicit function declarations. To get warnings about those, use
530 int warn_nested_externs = 0;
532 /* Warn about *printf or *scanf format/argument anomalies. */
536 /* Warn about a subscript that has type char. */
538 int warn_char_subscripts = 0;
540 /* Warn if a type conversion is done that might have confusing results. */
544 /* Warn if adding () is suggested. */
546 int warn_parentheses;
548 /* Warn if initializer is not completely bracketed. */
550 int warn_missing_braces;
552 /* Warn if main is suspicious. */
556 /* Warn about comparison of signed and unsigned values. */
558 int warn_sign_compare;
560 /* Nonzero means `$' can be in an identifier. */
562 #ifndef DOLLARS_IN_IDENTIFIERS
563 #define DOLLARS_IN_IDENTIFIERS 1
565 int dollars_in_ident = DOLLARS_IN_IDENTIFIERS;
567 /* Decode the string P as a language-specific option for C.
568 Return 1 if it is recognized (and handle it);
569 return 0 if not recognized. */
575 if (!strcmp (p, "-ftraditional") || !strcmp (p, "-traditional"))
577 flag_traditional = 1;
578 flag_writable_strings = 1;
580 else if (!strcmp (p, "-fallow-single-precision"))
581 flag_allow_single_precision = 1;
582 else if (!strcmp (p, "-fhosted") || !strcmp (p, "-fno-freestanding"))
587 else if (!strcmp (p, "-ffreestanding") || !strcmp (p, "-fno-hosted"))
591 /* warn_main will be 2 if set by -Wall, 1 if set by -Wmain */
595 else if (!strcmp (p, "-fnotraditional") || !strcmp (p, "-fno-traditional"))
597 flag_traditional = 0;
598 flag_writable_strings = 0;
600 else if (!strcmp (p, "-fdollars-in-identifiers"))
601 dollars_in_ident = 1;
602 else if (!strcmp (p, "-fno-dollars-in-identifiers"))
603 dollars_in_ident = 0;
604 else if (!strcmp (p, "-fsigned-char"))
605 flag_signed_char = 1;
606 else if (!strcmp (p, "-funsigned-char"))
607 flag_signed_char = 0;
608 else if (!strcmp (p, "-fno-signed-char"))
609 flag_signed_char = 0;
610 else if (!strcmp (p, "-fno-unsigned-char"))
611 flag_signed_char = 1;
612 else if (!strcmp (p, "-fsigned-bitfields")
613 || !strcmp (p, "-fno-unsigned-bitfields"))
615 flag_signed_bitfields = 1;
616 explicit_flag_signed_bitfields = 1;
618 else if (!strcmp (p, "-funsigned-bitfields")
619 || !strcmp (p, "-fno-signed-bitfields"))
621 flag_signed_bitfields = 0;
622 explicit_flag_signed_bitfields = 1;
624 else if (!strcmp (p, "-fshort-enums"))
625 flag_short_enums = 1;
626 else if (!strcmp (p, "-fno-short-enums"))
627 flag_short_enums = 0;
628 else if (!strcmp (p, "-fcond-mismatch"))
629 flag_cond_mismatch = 1;
630 else if (!strcmp (p, "-fno-cond-mismatch"))
631 flag_cond_mismatch = 0;
632 else if (!strcmp (p, "-fshort-double"))
633 flag_short_double = 1;
634 else if (!strcmp (p, "-fno-short-double"))
635 flag_short_double = 0;
636 else if (!strcmp (p, "-fasm"))
638 else if (!strcmp (p, "-fno-asm"))
640 else if (!strcmp (p, "-fbuiltin"))
642 else if (!strcmp (p, "-fno-builtin"))
644 else if (!strcmp (p, "-fno-ident"))
646 else if (!strcmp (p, "-fident"))
648 else if (!strcmp (p, "-ansi"))
649 flag_no_asm = 1, flag_no_nonansi_builtin = 1;
650 else if (!strcmp (p, "-Wimplicit"))
652 else if (!strcmp (p, "-Wno-implicit"))
654 else if (!strcmp (p, "-Wwrite-strings"))
655 warn_write_strings = 1;
656 else if (!strcmp (p, "-Wno-write-strings"))
657 warn_write_strings = 0;
658 else if (!strcmp (p, "-Wcast-qual"))
660 else if (!strcmp (p, "-Wno-cast-qual"))
662 else if (!strcmp (p, "-Wbad-function-cast"))
663 warn_bad_function_cast = 1;
664 else if (!strcmp (p, "-Wno-bad-function-cast"))
665 warn_bad_function_cast = 0;
666 else if (!strcmp (p, "-Wpointer-arith"))
667 warn_pointer_arith = 1;
668 else if (!strcmp (p, "-Wno-pointer-arith"))
669 warn_pointer_arith = 0;
670 else if (!strcmp (p, "-Wstrict-prototypes"))
671 warn_strict_prototypes = 1;
672 else if (!strcmp (p, "-Wno-strict-prototypes"))
673 warn_strict_prototypes = 0;
674 else if (!strcmp (p, "-Wmissing-prototypes"))
675 warn_missing_prototypes = 1;
676 else if (!strcmp (p, "-Wno-missing-prototypes"))
677 warn_missing_prototypes = 0;
678 else if (!strcmp (p, "-Wmissing-declarations"))
679 warn_missing_declarations = 1;
680 else if (!strcmp (p, "-Wno-missing-declarations"))
681 warn_missing_declarations = 0;
682 else if (!strcmp (p, "-Wredundant-decls"))
683 warn_redundant_decls = 1;
684 else if (!strcmp (p, "-Wno-redundant-decls"))
685 warn_redundant_decls = 0;
686 else if (!strcmp (p, "-Wnested-externs"))
687 warn_nested_externs = 1;
688 else if (!strcmp (p, "-Wno-nested-externs"))
689 warn_nested_externs = 0;
690 else if (!strcmp (p, "-Wtraditional"))
691 warn_traditional = 1;
692 else if (!strcmp (p, "-Wno-traditional"))
693 warn_traditional = 0;
694 else if (!strcmp (p, "-Wformat"))
696 else if (!strcmp (p, "-Wno-format"))
698 else if (!strcmp (p, "-Wchar-subscripts"))
699 warn_char_subscripts = 1;
700 else if (!strcmp (p, "-Wno-char-subscripts"))
701 warn_char_subscripts = 0;
702 else if (!strcmp (p, "-Wconversion"))
704 else if (!strcmp (p, "-Wno-conversion"))
706 else if (!strcmp (p, "-Wparentheses"))
707 warn_parentheses = 1;
708 else if (!strcmp (p, "-Wno-parentheses"))
709 warn_parentheses = 0;
710 else if (!strcmp (p, "-Wreturn-type"))
711 warn_return_type = 1;
712 else if (!strcmp (p, "-Wno-return-type"))
713 warn_return_type = 0;
714 else if (!strcmp (p, "-Wcomment"))
715 ; /* cpp handles this one. */
716 else if (!strcmp (p, "-Wno-comment"))
717 ; /* cpp handles this one. */
718 else if (!strcmp (p, "-Wcomments"))
719 ; /* cpp handles this one. */
720 else if (!strcmp (p, "-Wno-comments"))
721 ; /* cpp handles this one. */
722 else if (!strcmp (p, "-Wtrigraphs"))
723 ; /* cpp handles this one. */
724 else if (!strcmp (p, "-Wno-trigraphs"))
725 ; /* cpp handles this one. */
726 else if (!strcmp (p, "-Wundef"))
727 ; /* cpp handles this one. */
728 else if (!strcmp (p, "-Wno-undef"))
729 ; /* cpp handles this one. */
730 else if (!strcmp (p, "-Wimport"))
731 ; /* cpp handles this one. */
732 else if (!strcmp (p, "-Wno-import"))
733 ; /* cpp handles this one. */
734 else if (!strcmp (p, "-Wmissing-braces"))
735 warn_missing_braces = 1;
736 else if (!strcmp (p, "-Wno-missing-braces"))
737 warn_missing_braces = 0;
738 else if (!strcmp (p, "-Wmain"))
740 else if (!strcmp (p, "-Wno-main"))
742 else if (!strcmp (p, "-Wsign-compare"))
743 warn_sign_compare = 1;
744 else if (!strcmp (p, "-Wno-sign-compare"))
745 warn_sign_compare = 0;
746 else if (!strcmp (p, "-Wall"))
748 /* We save the value of warn_uninitialized, since if they put
749 -Wuninitialized on the command line, we need to generate a
750 warning about not using it without also specifying -O. */
751 if (warn_uninitialized != 1)
752 warn_uninitialized = 2;
754 warn_return_type = 1;
758 warn_char_subscripts = 1;
759 warn_parentheses = 1;
760 warn_missing_braces = 1;
761 warn_sign_compare = 1;
762 /* We set this to 2 here, but 1 in -Wmain, so -ffreestanding can turn
763 it off only if it's not explicit. */
772 /* Hooks for print_node. */
775 print_lang_decl (file, node, indent)
783 print_lang_type (file, node, indent)
791 print_lang_identifier (file, node, indent)
796 print_node (file, "global", IDENTIFIER_GLOBAL_VALUE (node), indent + 4);
797 print_node (file, "local", IDENTIFIER_LOCAL_VALUE (node), indent + 4);
798 print_node (file, "label", IDENTIFIER_LABEL_VALUE (node), indent + 4);
799 print_node (file, "implicit", IDENTIFIER_IMPLICIT_DECL (node), indent + 4);
800 print_node (file, "error locus", IDENTIFIER_ERROR_LOCUS (node), indent + 4);
801 print_node (file, "limbo value", IDENTIFIER_LIMBO_VALUE (node), indent + 4);
804 /* Hook called at end of compilation to assume 1 elt
805 for a top-level array decl that wasn't complete before. */
808 finish_incomplete_decl (decl)
811 if (TREE_CODE (decl) == VAR_DECL)
813 tree type = TREE_TYPE (decl);
814 if (type != error_mark_node
815 && TREE_CODE (type) == ARRAY_TYPE
816 && TYPE_DOMAIN (type) == 0)
818 if (! DECL_EXTERNAL (decl))
819 warning_with_decl (decl, "array `%s' assumed to have one element");
821 complete_array_type (type, NULL_TREE, 1);
823 layout_decl (decl, 0);
828 /* Create a new `struct binding_level'. */
831 struct binding_level *
832 make_binding_level ()
835 return (struct binding_level *) xmalloc (sizeof (struct binding_level));
838 /* Nonzero if we are currently in the global binding level. */
843 return current_binding_level == global_binding_level;
849 keep_next_level_flag = 1;
852 /* Nonzero if the current level needs to have a BLOCK made. */
857 return ((current_binding_level->keep_if_subblocks
858 && current_binding_level->blocks != 0)
859 || current_binding_level->keep
860 || current_binding_level->names != 0
861 || (current_binding_level->tags != 0
862 && !current_binding_level->tag_transparent));
865 /* Identify this binding level as a level of parameters.
866 DEFINITION_FLAG is 1 for a definition, 0 for a declaration.
867 But it turns out there is no way to pass the right value for
868 DEFINITION_FLAG, so we ignore it. */
871 declare_parm_level (definition_flag)
874 current_binding_level->parm_flag = 1;
877 /* Nonzero if currently making parm declarations. */
882 return current_binding_level->parm_flag;
885 /* Enter a new binding level.
886 If TAG_TRANSPARENT is nonzero, do so only for the name space of variables,
887 not for that of tags. */
890 pushlevel (tag_transparent)
893 register struct binding_level *newlevel = NULL_BINDING_LEVEL;
895 /* If this is the top level of a function,
896 just make sure that NAMED_LABELS is 0. */
898 if (current_binding_level == global_binding_level)
903 /* Reuse or create a struct for this binding level. */
905 if (free_binding_level)
907 newlevel = free_binding_level;
908 free_binding_level = free_binding_level->level_chain;
912 newlevel = make_binding_level ();
915 /* Add this level to the front of the chain (stack) of levels that
918 *newlevel = clear_binding_level;
919 newlevel->tag_transparent
921 || (current_binding_level
922 ? current_binding_level->subblocks_tag_transparent
924 newlevel->level_chain = current_binding_level;
925 current_binding_level = newlevel;
926 newlevel->keep = keep_next_level_flag;
927 keep_next_level_flag = 0;
928 newlevel->keep_if_subblocks = keep_next_if_subblocks;
929 keep_next_if_subblocks = 0;
932 /* Clear the limbo values of all identifiers defined in BLOCK or a subblock. */
935 clear_limbo_values (block)
940 for (tem = BLOCK_VARS (block); tem; tem = TREE_CHAIN (tem))
941 if (DECL_NAME (tem) != 0)
942 IDENTIFIER_LIMBO_VALUE (DECL_NAME (tem)) = 0;
944 for (tem = BLOCK_SUBBLOCKS (block); tem; tem = TREE_CHAIN (tem))
945 clear_limbo_values (tem);
948 /* Exit a binding level.
949 Pop the level off, and restore the state of the identifier-decl mappings
950 that were in effect when this level was entered.
952 If KEEP is nonzero, this level had explicit declarations, so
953 and create a "block" (a BLOCK node) for the level
954 to record its declarations and subblocks for symbol table output.
956 If FUNCTIONBODY is nonzero, this level is the body of a function,
957 so create a block as if KEEP were set and also clear out all
960 If REVERSE is nonzero, reverse the order of decls before putting
961 them into the BLOCK. */
964 poplevel (keep, reverse, functionbody)
970 /* The chain of decls was accumulated in reverse order.
971 Put it into forward order, just for cleanliness. */
973 tree tags = current_binding_level->tags;
974 tree subblocks = current_binding_level->blocks;
977 int block_previously_created;
979 keep |= current_binding_level->keep;
981 /* This warning is turned off because it causes warnings for
982 declarations like `extern struct foo *x'. */
984 /* Warn about incomplete structure types in this level. */
985 for (link = tags; link; link = TREE_CHAIN (link))
986 if (TYPE_SIZE (TREE_VALUE (link)) == 0)
988 tree type = TREE_VALUE (link);
990 switch (TREE_CODE (type))
993 errmsg = "`struct %s' incomplete in scope ending here";
996 errmsg = "`union %s' incomplete in scope ending here";
999 errmsg = "`enum %s' incomplete in scope ending here";
1002 if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE)
1003 error (errmsg, IDENTIFIER_POINTER (TYPE_NAME (type)));
1005 /* If this type has a typedef-name, the TYPE_NAME is a TYPE_DECL. */
1006 error (errmsg, IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type))));
1010 /* Get the decls in the order they were written.
1011 Usually current_binding_level->names is in reverse order.
1012 But parameter decls were previously put in forward order. */
1015 current_binding_level->names
1016 = decls = nreverse (current_binding_level->names);
1018 decls = current_binding_level->names;
1020 /* Output any nested inline functions within this block
1021 if they weren't already output. */
1023 for (decl = decls; decl; decl = TREE_CHAIN (decl))
1024 if (TREE_CODE (decl) == FUNCTION_DECL
1025 && ! TREE_ASM_WRITTEN (decl)
1026 && DECL_INITIAL (decl) != 0
1027 && TREE_ADDRESSABLE (decl))
1029 /* If this decl was copied from a file-scope decl
1030 on account of a block-scope extern decl,
1031 propagate TREE_ADDRESSABLE to the file-scope decl.
1033 DECL_ABSTRACT_ORIGIN can be set to itself if warn_return_type is
1034 true, since then the decl goes through save_for_inline_copying. */
1035 if (DECL_ABSTRACT_ORIGIN (decl) != 0
1036 && DECL_ABSTRACT_ORIGIN (decl) != decl)
1037 TREE_ADDRESSABLE (DECL_ABSTRACT_ORIGIN (decl)) = 1;
1038 else if (DECL_SAVED_INSNS (decl) != 0)
1040 push_function_context ();
1041 output_inline_function (decl);
1042 pop_function_context ();
1046 /* If there were any declarations or structure tags in that level,
1047 or if this level is a function body,
1048 create a BLOCK to record them for the life of this function. */
1051 block_previously_created = (current_binding_level->this_block != 0);
1052 if (block_previously_created)
1053 block = current_binding_level->this_block;
1054 else if (keep || functionbody
1055 || (current_binding_level->keep_if_subblocks && subblocks != 0))
1056 block = make_node (BLOCK);
1059 BLOCK_VARS (block) = decls;
1060 BLOCK_TYPE_TAGS (block) = tags;
1061 BLOCK_SUBBLOCKS (block) = subblocks;
1062 remember_end_note (block);
1065 /* In each subblock, record that this is its superior. */
1067 for (link = subblocks; link; link = TREE_CHAIN (link))
1068 BLOCK_SUPERCONTEXT (link) = block;
1070 /* Clear out the meanings of the local variables of this level. */
1072 for (link = decls; link; link = TREE_CHAIN (link))
1074 if (DECL_NAME (link) != 0)
1076 /* If the ident. was used or addressed via a local extern decl,
1077 don't forget that fact. */
1078 if (DECL_EXTERNAL (link))
1080 if (TREE_USED (link))
1081 TREE_USED (DECL_NAME (link)) = 1;
1082 if (TREE_ADDRESSABLE (link))
1083 TREE_ADDRESSABLE (DECL_ASSEMBLER_NAME (link)) = 1;
1085 IDENTIFIER_LOCAL_VALUE (DECL_NAME (link)) = 0;
1089 /* Restore all name-meanings of the outer levels
1090 that were shadowed by this level. */
1092 for (link = current_binding_level->shadowed; link; link = TREE_CHAIN (link))
1093 IDENTIFIER_LOCAL_VALUE (TREE_PURPOSE (link)) = TREE_VALUE (link);
1095 /* If the level being exited is the top level of a function,
1096 check over all the labels, and clear out the current
1097 (function local) meanings of their names. */
1101 clear_limbo_values (block);
1103 /* If this is the top level block of a function,
1104 the vars are the function's parameters.
1105 Don't leave them in the BLOCK because they are
1106 found in the FUNCTION_DECL instead. */
1108 BLOCK_VARS (block) = 0;
1110 /* Clear out the definitions of all label names,
1111 since their scopes end here,
1112 and add them to BLOCK_VARS. */
1114 for (link = named_labels; link; link = TREE_CHAIN (link))
1116 register tree label = TREE_VALUE (link);
1118 if (DECL_INITIAL (label) == 0)
1120 error_with_decl (label, "label `%s' used but not defined");
1121 /* Avoid crashing later. */
1122 define_label (input_filename, lineno,
1125 else if (warn_unused && !TREE_USED (label))
1126 warning_with_decl (label, "label `%s' defined but not used");
1127 IDENTIFIER_LABEL_VALUE (DECL_NAME (label)) = 0;
1129 /* Put the labels into the "variables" of the
1130 top-level block, so debugger can see them. */
1131 TREE_CHAIN (label) = BLOCK_VARS (block);
1132 BLOCK_VARS (block) = label;
1136 /* Pop the current level, and free the structure for reuse. */
1139 register struct binding_level *level = current_binding_level;
1140 current_binding_level = current_binding_level->level_chain;
1142 level->level_chain = free_binding_level;
1143 free_binding_level = level;
1146 /* Dispose of the block that we just made inside some higher level. */
1148 DECL_INITIAL (current_function_decl) = block;
1151 if (!block_previously_created)
1152 current_binding_level->blocks
1153 = chainon (current_binding_level->blocks, block);
1155 /* If we did not make a block for the level just exited,
1156 any blocks made for inner levels
1157 (since they cannot be recorded as subblocks in that level)
1158 must be carried forward so they will later become subblocks
1159 of something else. */
1161 current_binding_level->blocks
1162 = chainon (current_binding_level->blocks, subblocks);
1164 /* Set the TYPE_CONTEXTs for all of the tagged types belonging to this
1165 binding contour so that they point to the appropriate construct, i.e.
1166 either to the current FUNCTION_DECL node, or else to the BLOCK node
1167 we just constructed.
1169 Note that for tagged types whose scope is just the formal parameter
1170 list for some function type specification, we can't properly set
1171 their TYPE_CONTEXTs here, because we don't have a pointer to the
1172 appropriate FUNCTION_TYPE node readily available to us. For those
1173 cases, the TYPE_CONTEXTs of the relevant tagged type nodes get set
1174 in `grokdeclarator' as soon as we have created the FUNCTION_TYPE
1175 node which will represent the "scope" for these "parameter list local"
1180 for (link = tags; link; link = TREE_CHAIN (link))
1181 TYPE_CONTEXT (TREE_VALUE (link)) = current_function_decl;
1183 for (link = tags; link; link = TREE_CHAIN (link))
1184 TYPE_CONTEXT (TREE_VALUE (link)) = block;
1187 TREE_USED (block) = 1;
1191 /* Delete the node BLOCK from the current binding level.
1192 This is used for the block inside a stmt expr ({...})
1193 so that the block can be reinserted where appropriate. */
1196 delete_block (block)
1200 if (current_binding_level->blocks == block)
1201 current_binding_level->blocks = TREE_CHAIN (block);
1202 for (t = current_binding_level->blocks; t;)
1204 if (TREE_CHAIN (t) == block)
1205 TREE_CHAIN (t) = TREE_CHAIN (block);
1209 TREE_CHAIN (block) = NULL;
1210 /* Clear TREE_USED which is always set by poplevel.
1211 The flag is set again if insert_block is called. */
1212 TREE_USED (block) = 0;
1215 /* Insert BLOCK at the end of the list of subblocks of the
1216 current binding level. This is used when a BIND_EXPR is expanded,
1217 to handle the BLOCK node inside the BIND_EXPR. */
1220 insert_block (block)
1223 TREE_USED (block) = 1;
1224 current_binding_level->blocks
1225 = chainon (current_binding_level->blocks, block);
1228 /* Set the BLOCK node for the innermost scope
1229 (the one we are currently in). */
1233 register tree block;
1235 current_binding_level->this_block = block;
1241 register struct binding_level *newlevel;
1243 /* Reuse or create a struct for this binding level. */
1245 if (free_binding_level)
1247 newlevel = free_binding_level;
1248 free_binding_level = free_binding_level->level_chain;
1252 newlevel = make_binding_level ();
1255 /* Add this level to the front of the chain (stack) of label levels. */
1257 newlevel->level_chain = label_level_chain;
1258 label_level_chain = newlevel;
1260 newlevel->names = named_labels;
1261 newlevel->shadowed = shadowed_labels;
1263 shadowed_labels = 0;
1269 register struct binding_level *level = label_level_chain;
1272 /* Clear out the definitions of the declared labels in this level.
1273 Leave in the list any ordinary, non-declared labels. */
1274 for (link = named_labels, prev = 0; link;)
1276 if (C_DECLARED_LABEL_FLAG (TREE_VALUE (link)))
1278 if (DECL_SOURCE_LINE (TREE_VALUE (link)) == 0)
1280 error_with_decl (TREE_VALUE (link),
1281 "label `%s' used but not defined");
1282 /* Avoid crashing later. */
1283 define_label (input_filename, lineno,
1284 DECL_NAME (TREE_VALUE (link)));
1286 else if (warn_unused && !TREE_USED (TREE_VALUE (link)))
1287 warning_with_decl (TREE_VALUE (link),
1288 "label `%s' defined but not used");
1289 IDENTIFIER_LABEL_VALUE (DECL_NAME (TREE_VALUE (link))) = 0;
1291 /* Delete this element from the list. */
1292 link = TREE_CHAIN (link);
1294 TREE_CHAIN (prev) = link;
1296 named_labels = link;
1301 link = TREE_CHAIN (link);
1305 /* Bring back all the labels that were shadowed. */
1306 for (link = shadowed_labels; link; link = TREE_CHAIN (link))
1307 if (DECL_NAME (TREE_VALUE (link)) != 0)
1308 IDENTIFIER_LABEL_VALUE (DECL_NAME (TREE_VALUE (link)))
1309 = TREE_VALUE (link);
1311 named_labels = chainon (named_labels, level->names);
1312 shadowed_labels = level->shadowed;
1314 /* Pop the current level, and free the structure for reuse. */
1315 label_level_chain = label_level_chain->level_chain;
1316 level->level_chain = free_binding_level;
1317 free_binding_level = level;
1320 /* Push a definition or a declaration of struct, union or enum tag "name".
1321 "type" should be the type node.
1322 We assume that the tag "name" is not already defined.
1324 Note that the definition may really be just a forward reference.
1325 In that case, the TYPE_SIZE will be zero. */
1328 pushtag (name, type)
1331 register struct binding_level *b;
1333 /* Find the proper binding level for this type tag. */
1335 for (b = current_binding_level; b->tag_transparent; b = b->level_chain)
1340 /* Record the identifier as the type's name if it has none. */
1342 if (TYPE_NAME (type) == 0)
1343 TYPE_NAME (type) = name;
1346 if (b == global_binding_level)
1347 b->tags = perm_tree_cons (name, type, b->tags);
1349 b->tags = saveable_tree_cons (name, type, b->tags);
1351 /* Create a fake NULL-named TYPE_DECL node whose TREE_TYPE will be the
1352 tagged type we just added to the current binding level. This fake
1353 NULL-named TYPE_DECL node helps dwarfout.c to know when it needs
1354 to output a representation of a tagged type, and it also gives
1355 us a convenient place to record the "scope start" address for the
1358 TYPE_STUB_DECL (type) = pushdecl (build_decl (TYPE_DECL, NULL_TREE, type));
1360 /* An approximation for now, so we can tell this is a function-scope tag.
1361 This will be updated in poplevel. */
1362 TYPE_CONTEXT (type) = DECL_CONTEXT (TYPE_STUB_DECL (type));
1365 /* Handle when a new declaration NEWDECL
1366 has the same name as an old one OLDDECL
1367 in the same binding contour.
1368 Prints an error message if appropriate.
1370 If safely possible, alter OLDDECL to look like NEWDECL, and return 1.
1371 Otherwise, return 0.
1373 When DIFFERENT_BINDING_LEVEL is true, NEWDECL is an external declaration,
1374 and OLDDECL is in an outer binding level and should thus not be changed. */
1377 duplicate_decls (newdecl, olddecl, different_binding_level)
1378 register tree newdecl, olddecl;
1379 int different_binding_level;
1381 int types_match = comptypes (TREE_TYPE (newdecl), TREE_TYPE (olddecl));
1382 int new_is_definition = (TREE_CODE (newdecl) == FUNCTION_DECL
1383 && DECL_INITIAL (newdecl) != 0);
1384 tree oldtype = TREE_TYPE (olddecl);
1385 tree newtype = TREE_TYPE (newdecl);
1388 if (TREE_CODE_CLASS (TREE_CODE (olddecl)) == 'd')
1389 DECL_MACHINE_ATTRIBUTES (newdecl) = DECL_MACHINE_ATTRIBUTES (olddecl);
1391 if (TREE_CODE (newtype) == ERROR_MARK
1392 || TREE_CODE (oldtype) == ERROR_MARK)
1395 /* New decl is completely inconsistent with the old one =>
1396 tell caller to replace the old one.
1397 This is always an error except in the case of shadowing a builtin. */
1398 if (TREE_CODE (olddecl) != TREE_CODE (newdecl))
1400 if (TREE_CODE (olddecl) == FUNCTION_DECL
1401 && (DECL_BUILT_IN (olddecl)
1402 || DECL_BUILT_IN_NONANSI (olddecl)))
1404 /* If you declare a built-in or predefined function name as static,
1405 the old definition is overridden,
1406 but optionally warn this was a bad choice of name. */
1407 if (!TREE_PUBLIC (newdecl))
1411 else if (DECL_BUILT_IN (olddecl))
1412 warning_with_decl (newdecl, "shadowing built-in function `%s'");
1414 warning_with_decl (newdecl, "shadowing library function `%s'");
1416 /* Likewise, if the built-in is not ansi, then programs can
1417 override it even globally without an error. */
1418 else if (! DECL_BUILT_IN (olddecl))
1419 warning_with_decl (newdecl,
1420 "library function `%s' declared as non-function");
1422 else if (DECL_BUILT_IN_NONANSI (olddecl))
1423 warning_with_decl (newdecl,
1424 "built-in function `%s' declared as non-function");
1426 warning_with_decl (newdecl,
1427 "built-in function `%s' declared as non-function");
1431 error_with_decl (newdecl, "`%s' redeclared as different kind of symbol");
1432 error_with_decl (olddecl, "previous declaration of `%s'");
1438 /* For real parm decl following a forward decl,
1439 return 1 so old decl will be reused. */
1440 if (types_match && TREE_CODE (newdecl) == PARM_DECL
1441 && TREE_ASM_WRITTEN (olddecl) && ! TREE_ASM_WRITTEN (newdecl))
1444 /* The new declaration is the same kind of object as the old one.
1445 The declarations may partially match. Print warnings if they don't
1446 match enough. Ultimately, copy most of the information from the new
1447 decl to the old one, and keep using the old one. */
1449 if (flag_traditional && TREE_CODE (newdecl) == FUNCTION_DECL
1450 && IDENTIFIER_IMPLICIT_DECL (DECL_NAME (newdecl)) == olddecl
1451 && DECL_INITIAL (olddecl) == 0)
1452 /* If -traditional, avoid error for redeclaring fcn
1453 after implicit decl. */
1455 else if (TREE_CODE (olddecl) == FUNCTION_DECL
1456 && DECL_BUILT_IN (olddecl))
1458 /* A function declaration for a built-in function. */
1459 if (!TREE_PUBLIC (newdecl))
1461 /* If you declare a built-in function name as static, the
1462 built-in definition is overridden,
1463 but optionally warn this was a bad choice of name. */
1465 warning_with_decl (newdecl, "shadowing built-in function `%s'");
1466 /* Discard the old built-in function. */
1469 else if (!types_match)
1471 /* Accept the return type of the new declaration if same modes. */
1472 tree oldreturntype = TREE_TYPE (oldtype);
1473 tree newreturntype = TREE_TYPE (newtype);
1475 /* Make sure we put the new type in the same obstack as the old ones.
1476 If the old types are not both in the same obstack, use the
1478 if (TYPE_OBSTACK (oldtype) == TYPE_OBSTACK (newtype))
1479 push_obstacks (TYPE_OBSTACK (oldtype), TYPE_OBSTACK (oldtype));
1482 push_obstacks_nochange ();
1483 end_temporary_allocation ();
1486 if (TYPE_MODE (oldreturntype) == TYPE_MODE (newreturntype))
1488 /* Function types may be shared, so we can't just modify
1489 the return type of olddecl's function type. */
1491 = build_function_type (newreturntype,
1492 TYPE_ARG_TYPES (oldtype));
1494 types_match = comptypes (newtype, trytype);
1498 /* Accept harmless mismatch in first argument type also.
1500 if (TYPE_ARG_TYPES (TREE_TYPE (newdecl)) != 0
1501 && TYPE_ARG_TYPES (oldtype) != 0
1502 && TREE_VALUE (TYPE_ARG_TYPES (newtype)) != 0
1503 && TREE_VALUE (TYPE_ARG_TYPES (oldtype)) != 0
1504 && (TYPE_MODE (TREE_VALUE (TYPE_ARG_TYPES (newtype)))
1505 == TYPE_MODE (TREE_VALUE (TYPE_ARG_TYPES (oldtype)))))
1507 /* Function types may be shared, so we can't just modify
1508 the return type of olddecl's function type. */
1510 = build_function_type (TREE_TYPE (oldtype),
1511 tree_cons (NULL_TREE,
1512 TREE_VALUE (TYPE_ARG_TYPES (newtype)),
1513 TREE_CHAIN (TYPE_ARG_TYPES (oldtype))));
1515 types_match = comptypes (newtype, trytype);
1519 if (! different_binding_level)
1520 TREE_TYPE (olddecl) = oldtype;
1526 /* If types don't match for a built-in, throw away the built-in. */
1527 warning_with_decl (newdecl, "conflicting types for built-in function `%s'");
1531 else if (TREE_CODE (olddecl) == FUNCTION_DECL
1532 && DECL_SOURCE_LINE (olddecl) == 0)
1534 /* A function declaration for a predeclared function
1535 that isn't actually built in. */
1536 if (!TREE_PUBLIC (newdecl))
1538 /* If you declare it as static, the
1539 default definition is overridden. */
1542 else if (!types_match)
1544 /* If the types don't match, preserve volatility indication.
1545 Later on, we will discard everything else about the
1546 default declaration. */
1547 TREE_THIS_VOLATILE (newdecl) |= TREE_THIS_VOLATILE (olddecl);
1550 /* Permit char *foo () to match void *foo (...) if not pedantic,
1551 if one of them came from a system header file. */
1552 else if (!types_match
1553 && TREE_CODE (olddecl) == FUNCTION_DECL
1554 && TREE_CODE (newdecl) == FUNCTION_DECL
1555 && TREE_CODE (TREE_TYPE (oldtype)) == POINTER_TYPE
1556 && TREE_CODE (TREE_TYPE (newtype)) == POINTER_TYPE
1557 && (DECL_IN_SYSTEM_HEADER (olddecl)
1558 || DECL_IN_SYSTEM_HEADER (newdecl))
1559 && ((TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (newtype))) == void_type_node
1560 && TYPE_ARG_TYPES (oldtype) == 0
1561 && self_promoting_args_p (TYPE_ARG_TYPES (newtype))
1562 && TREE_TYPE (TREE_TYPE (oldtype)) == char_type_node)
1564 (TREE_TYPE (TREE_TYPE (newtype)) == char_type_node
1565 && TYPE_ARG_TYPES (newtype) == 0
1566 && self_promoting_args_p (TYPE_ARG_TYPES (oldtype))
1567 && TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (oldtype))) == void_type_node)))
1570 pedwarn_with_decl (newdecl, "conflicting types for `%s'");
1571 /* Make sure we keep void * as ret type, not char *. */
1572 if (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (oldtype))) == void_type_node)
1573 TREE_TYPE (newdecl) = newtype = oldtype;
1575 /* Set DECL_IN_SYSTEM_HEADER, so that if we see another declaration
1576 we will come back here again. */
1577 DECL_IN_SYSTEM_HEADER (newdecl) = 1;
1579 else if (!types_match
1580 /* Permit char *foo (int, ...); followed by char *foo ();
1582 && ! (TREE_CODE (olddecl) == FUNCTION_DECL
1584 /* Return types must still match. */
1585 && comptypes (TREE_TYPE (oldtype),
1586 TREE_TYPE (newtype))
1587 && TYPE_ARG_TYPES (newtype) == 0))
1589 error_with_decl (newdecl, "conflicting types for `%s'");
1590 /* Check for function type mismatch
1591 involving an empty arglist vs a nonempty one. */
1592 if (TREE_CODE (olddecl) == FUNCTION_DECL
1593 && comptypes (TREE_TYPE (oldtype),
1594 TREE_TYPE (newtype))
1595 && ((TYPE_ARG_TYPES (oldtype) == 0
1596 && DECL_INITIAL (olddecl) == 0)
1598 (TYPE_ARG_TYPES (newtype) == 0
1599 && DECL_INITIAL (newdecl) == 0)))
1601 /* Classify the problem further. */
1602 register tree t = TYPE_ARG_TYPES (oldtype);
1604 t = TYPE_ARG_TYPES (newtype);
1605 for (; t; t = TREE_CHAIN (t))
1607 register tree type = TREE_VALUE (t);
1609 if (TREE_CHAIN (t) == 0
1610 && TYPE_MAIN_VARIANT (type) != void_type_node)
1612 error ("A parameter list with an ellipsis can't match");
1613 error ("an empty parameter name list declaration.");
1617 if (TYPE_MAIN_VARIANT (type) == float_type_node
1618 || C_PROMOTING_INTEGER_TYPE_P (type))
1620 error ("An argument type that has a default promotion");
1621 error ("can't match an empty parameter name list declaration.");
1626 error_with_decl (olddecl, "previous declaration of `%s'");
1630 errmsg = redeclaration_error_message (newdecl, olddecl);
1633 error_with_decl (newdecl, errmsg);
1634 error_with_decl (olddecl,
1635 ((DECL_INITIAL (olddecl)
1636 && current_binding_level == global_binding_level)
1637 ? "`%s' previously defined here"
1638 : "`%s' previously declared here"));
1640 else if (TREE_CODE (newdecl) == TYPE_DECL
1641 && (DECL_IN_SYSTEM_HEADER (olddecl)
1642 || DECL_IN_SYSTEM_HEADER (newdecl)))
1644 warning_with_decl (newdecl, "redefinition of `%s'");
1647 ((DECL_INITIAL (olddecl)
1648 && current_binding_level == global_binding_level)
1649 ? "`%s' previously defined here"
1650 : "`%s' previously declared here"));
1652 else if (TREE_CODE (olddecl) == FUNCTION_DECL
1653 && DECL_INITIAL (olddecl) != 0
1654 && TYPE_ARG_TYPES (oldtype) == 0
1655 && TYPE_ARG_TYPES (newtype) != 0
1656 && TYPE_ACTUAL_ARG_TYPES (oldtype) != 0)
1658 register tree type, parm;
1660 /* Prototype decl follows defn w/o prototype. */
1662 for (parm = TYPE_ACTUAL_ARG_TYPES (oldtype),
1663 type = TYPE_ARG_TYPES (newtype),
1665 (TYPE_MAIN_VARIANT (TREE_VALUE (parm)) != void_type_node
1666 || TYPE_MAIN_VARIANT (TREE_VALUE (type)) != void_type_node);
1667 parm = TREE_CHAIN (parm), type = TREE_CHAIN (type), nargs++)
1669 if (TYPE_MAIN_VARIANT (TREE_VALUE (parm)) == void_type_node
1670 || TYPE_MAIN_VARIANT (TREE_VALUE (type)) == void_type_node)
1672 errmsg = "prototype for `%s' follows and number of arguments";
1675 /* Type for passing arg must be consistent
1676 with that declared for the arg. */
1677 if (! comptypes (TREE_VALUE (parm), TREE_VALUE (type))
1678 /* If -traditional, allow `unsigned int' instead of `int'
1679 in the prototype. */
1680 && (! (flag_traditional
1681 && TYPE_MAIN_VARIANT (TREE_VALUE (parm)) == integer_type_node
1682 && TYPE_MAIN_VARIANT (TREE_VALUE (type)) == unsigned_type_node)))
1684 errmsg = "prototype for `%s' follows and argument %d";
1690 error_with_decl (newdecl, errmsg, nargs);
1691 error_with_decl (olddecl,
1692 "doesn't match non-prototype definition here");
1696 warning_with_decl (newdecl, "prototype for `%s' follows");
1697 warning_with_decl (olddecl, "non-prototype definition here");
1700 /* Warn about mismatches in various flags. */
1703 /* Warn if function is now inline
1704 but was previously declared not inline and has been called. */
1705 if (TREE_CODE (olddecl) == FUNCTION_DECL
1706 && ! DECL_INLINE (olddecl) && DECL_INLINE (newdecl)
1707 && TREE_USED (olddecl))
1708 warning_with_decl (newdecl,
1709 "`%s' declared inline after being called");
1710 if (TREE_CODE (olddecl) == FUNCTION_DECL
1711 && ! DECL_INLINE (olddecl) && DECL_INLINE (newdecl)
1712 && DECL_INITIAL (olddecl) != 0)
1713 warning_with_decl (newdecl,
1714 "`%s' declared inline after its definition");
1716 /* If pedantic, warn when static declaration follows a non-static
1717 declaration. Otherwise, do so only for functions. */
1718 if ((pedantic || TREE_CODE (olddecl) == FUNCTION_DECL)
1719 && TREE_PUBLIC (olddecl)
1720 && !TREE_PUBLIC (newdecl))
1721 warning_with_decl (newdecl, "static declaration for `%s' follows non-static");
1723 /* Warn when const declaration follows a non-const
1724 declaration, but not for functions. */
1725 if (TREE_CODE (olddecl) != FUNCTION_DECL
1726 && !TREE_READONLY (olddecl)
1727 && TREE_READONLY (newdecl))
1728 warning_with_decl (newdecl, "const declaration for `%s' follows non-const");
1729 /* These bits are logically part of the type, for variables.
1730 But not for functions
1731 (where qualifiers are not valid ANSI anyway). */
1732 else if (pedantic && TREE_CODE (olddecl) != FUNCTION_DECL
1733 && (TREE_READONLY (newdecl) != TREE_READONLY (olddecl)
1734 || TREE_THIS_VOLATILE (newdecl) != TREE_THIS_VOLATILE (olddecl)))
1735 pedwarn_with_decl (newdecl, "type qualifiers for `%s' conflict with previous decl");
1739 /* Optionally warn about more than one declaration for the same name. */
1740 if (errmsg == 0 && warn_redundant_decls && DECL_SOURCE_LINE (olddecl) != 0
1741 /* Dont warn about a function declaration
1742 followed by a definition. */
1743 && !(TREE_CODE (newdecl) == FUNCTION_DECL && DECL_INITIAL (newdecl) != 0
1744 && DECL_INITIAL (olddecl) == 0)
1745 /* Don't warn about extern decl followed by (tentative) definition. */
1746 && !(DECL_EXTERNAL (olddecl) && ! DECL_EXTERNAL (newdecl)))
1748 warning_with_decl (newdecl, "redundant redeclaration of `%s' in same scope");
1749 warning_with_decl (olddecl, "previous declaration of `%s'");
1752 /* Copy all the DECL_... slots specified in the new decl
1753 except for any that we copy here from the old type.
1755 Past this point, we don't change OLDTYPE and NEWTYPE
1756 even if we change the types of NEWDECL and OLDDECL. */
1760 /* When copying info to olddecl, we store into write_olddecl
1761 instead. This allows us to avoid modifying olddecl when
1762 different_binding_level is true. */
1763 tree write_olddecl = different_binding_level ? newdecl : olddecl;
1765 /* Make sure we put the new type in the same obstack as the old ones.
1766 If the old types are not both in the same obstack, use the permanent
1768 if (TYPE_OBSTACK (oldtype) == TYPE_OBSTACK (newtype))
1769 push_obstacks (TYPE_OBSTACK (oldtype), TYPE_OBSTACK (oldtype));
1772 push_obstacks_nochange ();
1773 end_temporary_allocation ();
1776 /* Merge the data types specified in the two decls. */
1777 if (TREE_CODE (newdecl) != FUNCTION_DECL || !DECL_BUILT_IN (olddecl))
1779 if (different_binding_level)
1781 = build_type_attribute_variant
1783 merge_attributes (TYPE_ATTRIBUTES (newtype),
1784 TYPE_ATTRIBUTES (oldtype)));
1787 = TREE_TYPE (olddecl)
1788 = common_type (newtype, oldtype);
1791 /* Lay the type out, unless already done. */
1792 if (oldtype != TREE_TYPE (newdecl))
1794 if (TREE_TYPE (newdecl) != error_mark_node)
1795 layout_type (TREE_TYPE (newdecl));
1796 if (TREE_CODE (newdecl) != FUNCTION_DECL
1797 && TREE_CODE (newdecl) != TYPE_DECL
1798 && TREE_CODE (newdecl) != CONST_DECL)
1799 layout_decl (newdecl, 0);
1803 /* Since the type is OLDDECL's, make OLDDECL's size go with. */
1804 DECL_SIZE (newdecl) = DECL_SIZE (olddecl);
1805 if (TREE_CODE (olddecl) != FUNCTION_DECL)
1806 if (DECL_ALIGN (olddecl) > DECL_ALIGN (newdecl))
1807 DECL_ALIGN (newdecl) = DECL_ALIGN (olddecl);
1810 /* Keep the old rtl since we can safely use it. */
1811 DECL_RTL (newdecl) = DECL_RTL (olddecl);
1813 /* Merge the type qualifiers. */
1814 if (DECL_BUILT_IN_NONANSI (olddecl) && TREE_THIS_VOLATILE (olddecl)
1815 && !TREE_THIS_VOLATILE (newdecl))
1816 TREE_THIS_VOLATILE (write_olddecl) = 0;
1817 if (TREE_READONLY (newdecl))
1818 TREE_READONLY (write_olddecl) = 1;
1819 if (TREE_THIS_VOLATILE (newdecl))
1821 TREE_THIS_VOLATILE (write_olddecl) = 1;
1822 if (TREE_CODE (newdecl) == VAR_DECL)
1823 make_var_volatile (newdecl);
1826 /* Keep source location of definition rather than declaration. */
1827 /* When called with different_binding_level set, keep the old
1828 information so that meaningful diagnostics can be given. */
1829 if (DECL_INITIAL (newdecl) == 0 && DECL_INITIAL (olddecl) != 0
1830 && ! different_binding_level)
1832 DECL_SOURCE_LINE (newdecl) = DECL_SOURCE_LINE (olddecl);
1833 DECL_SOURCE_FILE (newdecl) = DECL_SOURCE_FILE (olddecl);
1836 /* Merge the unused-warning information. */
1837 if (DECL_IN_SYSTEM_HEADER (olddecl))
1838 DECL_IN_SYSTEM_HEADER (newdecl) = 1;
1839 else if (DECL_IN_SYSTEM_HEADER (newdecl))
1840 DECL_IN_SYSTEM_HEADER (write_olddecl) = 1;
1842 /* Merge the initialization information. */
1843 /* When called with different_binding_level set, don't copy over
1844 DECL_INITIAL, so that we don't accidentally change function
1845 declarations into function definitions. */
1846 if (DECL_INITIAL (newdecl) == 0 && ! different_binding_level)
1847 DECL_INITIAL (newdecl) = DECL_INITIAL (olddecl);
1849 /* Merge the section attribute.
1850 We want to issue an error if the sections conflict but that must be
1851 done later in decl_attributes since we are called before attributes
1853 if (DECL_SECTION_NAME (newdecl) == NULL_TREE)
1854 DECL_SECTION_NAME (newdecl) = DECL_SECTION_NAME (olddecl);
1856 if (TREE_CODE (newdecl) == FUNCTION_DECL)
1858 DECL_STATIC_CONSTRUCTOR(newdecl) |= DECL_STATIC_CONSTRUCTOR(olddecl);
1859 DECL_STATIC_DESTRUCTOR (newdecl) |= DECL_STATIC_DESTRUCTOR (olddecl);
1864 /* If cannot merge, then use the new type and qualifiers,
1865 and don't preserve the old rtl. */
1866 else if (! different_binding_level)
1868 TREE_TYPE (olddecl) = TREE_TYPE (newdecl);
1869 TREE_READONLY (olddecl) = TREE_READONLY (newdecl);
1870 TREE_THIS_VOLATILE (olddecl) = TREE_THIS_VOLATILE (newdecl);
1871 TREE_SIDE_EFFECTS (olddecl) = TREE_SIDE_EFFECTS (newdecl);
1874 /* Merge the storage class information. */
1875 DECL_WEAK (newdecl) |= DECL_WEAK (olddecl);
1876 /* For functions, static overrides non-static. */
1877 if (TREE_CODE (newdecl) == FUNCTION_DECL)
1879 TREE_PUBLIC (newdecl) &= TREE_PUBLIC (olddecl);
1880 /* This is since we don't automatically
1881 copy the attributes of NEWDECL into OLDDECL. */
1882 /* No need to worry about different_binding_level here because
1883 then TREE_PUBLIC (newdecl) was true. */
1884 TREE_PUBLIC (olddecl) = TREE_PUBLIC (newdecl);
1885 /* If this clears `static', clear it in the identifier too. */
1886 if (! TREE_PUBLIC (olddecl))
1887 TREE_PUBLIC (DECL_NAME (olddecl)) = 0;
1889 if (DECL_EXTERNAL (newdecl))
1891 TREE_STATIC (newdecl) = TREE_STATIC (olddecl);
1892 DECL_EXTERNAL (newdecl) = DECL_EXTERNAL (olddecl);
1893 /* An extern decl does not override previous storage class. */
1894 TREE_PUBLIC (newdecl) = TREE_PUBLIC (olddecl);
1895 if (! DECL_EXTERNAL (newdecl))
1896 DECL_CONTEXT (newdecl) = DECL_CONTEXT (olddecl);
1900 TREE_STATIC (olddecl) = TREE_STATIC (newdecl);
1901 TREE_PUBLIC (olddecl) = TREE_PUBLIC (newdecl);
1904 /* If either decl says `inline', this fn is inline,
1905 unless its definition was passed already. */
1906 if (DECL_INLINE (newdecl) && DECL_INITIAL (olddecl) == 0)
1907 DECL_INLINE (olddecl) = 1;
1908 DECL_INLINE (newdecl) = DECL_INLINE (olddecl);
1910 if (TREE_CODE (newdecl) == FUNCTION_DECL)
1912 if (DECL_BUILT_IN (olddecl))
1914 /* Get rid of any built-in function if new arg types don't match it
1915 or if we have a function definition. */
1916 if (! types_match || new_is_definition)
1918 if (! different_binding_level)
1920 TREE_TYPE (olddecl) = TREE_TYPE (newdecl);
1921 DECL_BUILT_IN (olddecl) = 0;
1926 /* If redeclaring a builtin function, and not a definition,
1927 it stays built in. */
1928 DECL_BUILT_IN (newdecl) = 1;
1929 DECL_FUNCTION_CODE (newdecl) = DECL_FUNCTION_CODE (olddecl);
1932 /* Also preserve various other info from the definition. */
1933 else if (! new_is_definition)
1934 DECL_FRAME_SIZE (newdecl) = DECL_FRAME_SIZE (olddecl);
1935 if (! new_is_definition)
1937 DECL_RESULT (newdecl) = DECL_RESULT (olddecl);
1938 /* When called with different_binding_level set, don't copy over
1939 DECL_INITIAL, so that we don't accidentally change function
1940 declarations into function definitions. */
1941 if (! different_binding_level)
1942 DECL_INITIAL (newdecl) = DECL_INITIAL (olddecl);
1943 DECL_SAVED_INSNS (newdecl) = DECL_SAVED_INSNS (olddecl);
1944 DECL_ARGUMENTS (newdecl) = DECL_ARGUMENTS (olddecl);
1947 if (different_binding_level)
1949 /* Don't output a duplicate symbol for this declaration. */
1950 TREE_ASM_WRITTEN (newdecl) = 1;
1954 /* Copy most of the decl-specific fields of NEWDECL into OLDDECL.
1955 But preserve OLDdECL's DECL_UID. */
1957 register unsigned olddecl_uid = DECL_UID (olddecl);
1959 bcopy ((char *) newdecl + sizeof (struct tree_common),
1960 (char *) olddecl + sizeof (struct tree_common),
1961 sizeof (struct tree_decl) - sizeof (struct tree_common));
1962 DECL_UID (olddecl) = olddecl_uid;
1968 /* Record a decl-node X as belonging to the current lexical scope.
1969 Check for errors (such as an incompatible declaration for the same
1970 name already seen in the same scope).
1972 Returns either X or an old decl for the same name.
1973 If an old decl is returned, it may have been smashed
1974 to agree with what X says. */
1981 register tree name = DECL_NAME (x);
1982 register struct binding_level *b = current_binding_level;
1984 DECL_CONTEXT (x) = current_function_decl;
1985 /* A local extern declaration for a function doesn't constitute nesting.
1986 A local auto declaration does, since it's a forward decl
1987 for a nested function coming later. */
1988 if (TREE_CODE (x) == FUNCTION_DECL && DECL_INITIAL (x) == 0
1989 && DECL_EXTERNAL (x))
1990 DECL_CONTEXT (x) = 0;
1992 if (warn_nested_externs && DECL_EXTERNAL (x) && b != global_binding_level
1993 && x != IDENTIFIER_IMPLICIT_DECL (name)
1994 /* Don't print error messages for __FUNCTION__ and __PRETTY_FUNCTION__ */
1995 && !DECL_IN_SYSTEM_HEADER (x))
1996 warning ("nested extern declaration of `%s'", IDENTIFIER_POINTER (name));
2002 int different_binding_level = 0;
2004 t = lookup_name_current_level (name);
2005 /* Don't type check externs here when -traditional. This is so that
2006 code with conflicting declarations inside blocks will get warnings
2007 not errors. X11 for instance depends on this. */
2008 if (! t && DECL_EXTERNAL (x) && TREE_PUBLIC (x) && ! flag_traditional)
2010 t = IDENTIFIER_GLOBAL_VALUE (name);
2011 /* Type decls at global scope don't conflict with externs declared
2012 inside lexical blocks. */
2013 if (t && TREE_CODE (t) == TYPE_DECL)
2015 different_binding_level = 1;
2017 if (t != 0 && t == error_mark_node)
2018 /* error_mark_node is 0 for a while during initialization! */
2021 error_with_decl (x, "`%s' used prior to declaration");
2026 file = DECL_SOURCE_FILE (t);
2027 line = DECL_SOURCE_LINE (t);
2030 /* If this decl is `static' and an implicit decl was seen previously,
2031 warn. But don't complain if -traditional,
2032 since traditional compilers don't complain. */
2033 if (! flag_traditional && TREE_PUBLIC (name)
2034 /* Don't test for DECL_EXTERNAL, because grokdeclarator
2035 sets this for all functions. */
2036 && ! TREE_PUBLIC (x)
2037 && (TREE_CODE (x) == FUNCTION_DECL || b == global_binding_level)
2038 /* We used to warn also for explicit extern followed by static,
2039 but sometimes you need to do it that way. */
2040 && IDENTIFIER_IMPLICIT_DECL (name) != 0)
2042 pedwarn ("`%s' was declared implicitly `extern' and later `static'",
2043 IDENTIFIER_POINTER (name));
2044 pedwarn_with_file_and_line
2045 (DECL_SOURCE_FILE (IDENTIFIER_IMPLICIT_DECL (name)),
2046 DECL_SOURCE_LINE (IDENTIFIER_IMPLICIT_DECL (name)),
2047 "previous declaration of `%s'",
2048 IDENTIFIER_POINTER (name));
2051 if (t != 0 && duplicate_decls (x, t, different_binding_level))
2053 if (TREE_CODE (t) == PARM_DECL)
2055 /* Don't allow more than one "real" duplicate
2056 of a forward parm decl. */
2057 TREE_ASM_WRITTEN (t) = TREE_ASM_WRITTEN (x);
2063 /* If we are processing a typedef statement, generate a whole new
2064 ..._TYPE node (which will be just an variant of the existing
2065 ..._TYPE node with identical properties) and then install the
2066 TYPE_DECL node generated to represent the typedef name as the
2067 TYPE_NAME of this brand new (duplicate) ..._TYPE node.
2069 The whole point here is to end up with a situation where each
2070 and every ..._TYPE node the compiler creates will be uniquely
2071 associated with AT MOST one node representing a typedef name.
2072 This way, even though the compiler substitutes corresponding
2073 ..._TYPE nodes for TYPE_DECL (i.e. "typedef name") nodes very
2074 early on, later parts of the compiler can always do the reverse
2075 translation and get back the corresponding typedef name. For
2078 typedef struct S MY_TYPE;
2081 Later parts of the compiler might only know that `object' was of
2082 type `struct S' if if were not for code just below. With this
2083 code however, later parts of the compiler see something like:
2085 struct S' == struct S
2086 typedef struct S' MY_TYPE;
2089 And they can then deduce (from the node for type struct S') that
2090 the original object declaration was:
2094 Being able to do this is important for proper support of protoize,
2095 and also for generating precise symbolic debugging information
2096 which takes full account of the programmer's (typedef) vocabulary.
2098 Obviously, we don't want to generate a duplicate ..._TYPE node if
2099 the TYPE_DECL node that we are now processing really represents a
2100 standard built-in type.
2102 Since all standard types are effectively declared at line zero
2103 in the source file, we can easily check to see if we are working
2104 on a standard type by checking the current value of lineno. */
2106 if (TREE_CODE (x) == TYPE_DECL)
2108 if (DECL_SOURCE_LINE (x) == 0)
2110 if (TYPE_NAME (TREE_TYPE (x)) == 0)
2111 TYPE_NAME (TREE_TYPE (x)) = x;
2113 else if (TREE_TYPE (x) != error_mark_node)
2115 tree tt = TREE_TYPE (x);
2116 DECL_ORIGINAL_TYPE (x) = tt;
2117 tt = build_type_copy (tt);
2123 /* Multiple external decls of the same identifier ought to match.
2124 Check against both global declarations (when traditional) and out of
2125 scope (limbo) block level declarations.
2127 We get warnings about inline functions where they are defined.
2128 Avoid duplicate warnings where they are used. */
2129 if (TREE_PUBLIC (x) && ! DECL_INLINE (x))
2133 if (flag_traditional && IDENTIFIER_GLOBAL_VALUE (name) != 0
2134 && (DECL_EXTERNAL (IDENTIFIER_GLOBAL_VALUE (name))
2135 || TREE_PUBLIC (IDENTIFIER_GLOBAL_VALUE (name))))
2136 decl = IDENTIFIER_GLOBAL_VALUE (name);
2137 else if (IDENTIFIER_LIMBO_VALUE (name) != 0)
2138 /* Decls in limbo are always extern, so no need to check that. */
2139 decl = IDENTIFIER_LIMBO_VALUE (name);
2143 if (decl && ! comptypes (TREE_TYPE (x), TREE_TYPE (decl))
2144 /* If old decl is built-in, we already warned if we should. */
2145 && !DECL_BUILT_IN (decl))
2147 pedwarn_with_decl (x,
2148 "type mismatch with previous external decl");
2149 pedwarn_with_decl (decl, "previous external decl of `%s'");
2153 /* If a function has had an implicit declaration, and then is defined,
2154 make sure they are compatible. */
2156 if (IDENTIFIER_IMPLICIT_DECL (name) != 0
2157 && IDENTIFIER_GLOBAL_VALUE (name) == 0
2158 && TREE_CODE (x) == FUNCTION_DECL
2159 && ! comptypes (TREE_TYPE (x),
2160 TREE_TYPE (IDENTIFIER_IMPLICIT_DECL (name))))
2162 warning_with_decl (x, "type mismatch with previous implicit declaration");
2163 warning_with_decl (IDENTIFIER_IMPLICIT_DECL (name),
2164 "previous implicit declaration of `%s'");
2167 /* In PCC-compatibility mode, extern decls of vars with no current decl
2168 take effect at top level no matter where they are. */
2169 if (flag_traditional && DECL_EXTERNAL (x)
2170 && lookup_name (name) == 0)
2172 tree type = TREE_TYPE (x);
2174 /* But don't do this if the type contains temporary nodes. */
2177 if (type == error_mark_node)
2179 if (! TREE_PERMANENT (type))
2181 warning_with_decl (x, "type of external `%s' is not global");
2182 /* By exiting the loop early, we leave TYPE nonzero,
2183 and thus prevent globalization of the decl. */
2186 else if (TREE_CODE (type) == FUNCTION_TYPE
2187 && TYPE_ARG_TYPES (type) != 0)
2188 /* The types might not be truly local,
2189 but the list of arg types certainly is temporary.
2190 Since prototypes are nontraditional,
2191 ok not to do the traditional thing. */
2193 type = TREE_TYPE (type);
2197 b = global_binding_level;
2200 /* This name is new in its binding level.
2201 Install the new declaration and return it. */
2202 if (b == global_binding_level)
2204 /* Install a global value. */
2206 /* If the first global decl has external linkage,
2207 warn if we later see static one. */
2208 if (IDENTIFIER_GLOBAL_VALUE (name) == 0 && TREE_PUBLIC (x))
2209 TREE_PUBLIC (name) = 1;
2211 IDENTIFIER_GLOBAL_VALUE (name) = x;
2213 /* We no longer care about any previous block level declarations. */
2214 IDENTIFIER_LIMBO_VALUE (name) = 0;
2216 /* Don't forget if the function was used via an implicit decl. */
2217 if (IDENTIFIER_IMPLICIT_DECL (name)
2218 && TREE_USED (IDENTIFIER_IMPLICIT_DECL (name)))
2219 TREE_USED (x) = 1, TREE_USED (name) = 1;
2221 /* Don't forget if its address was taken in that way. */
2222 if (IDENTIFIER_IMPLICIT_DECL (name)
2223 && TREE_ADDRESSABLE (IDENTIFIER_IMPLICIT_DECL (name)))
2224 TREE_ADDRESSABLE (x) = 1;
2226 /* Warn about mismatches against previous implicit decl. */
2227 if (IDENTIFIER_IMPLICIT_DECL (name) != 0
2228 /* If this real decl matches the implicit, don't complain. */
2229 && ! (TREE_CODE (x) == FUNCTION_DECL
2230 && (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (x)))
2231 == integer_type_node)))
2232 pedwarn ("`%s' was previously implicitly declared to return `int'",
2233 IDENTIFIER_POINTER (name));
2235 /* If this decl is `static' and an `extern' was seen previously,
2236 that is erroneous. */
2237 if (TREE_PUBLIC (name)
2238 && ! TREE_PUBLIC (x) && ! DECL_EXTERNAL (x))
2240 /* Okay to redeclare an ANSI built-in as static. */
2241 if (t != 0 && DECL_BUILT_IN (t))
2243 /* Okay to declare a non-ANSI built-in as anything. */
2244 else if (t != 0 && DECL_BUILT_IN_NONANSI (t))
2246 /* Okay to have global type decl after an earlier extern
2247 declaration inside a lexical block. */
2248 else if (TREE_CODE (x) == TYPE_DECL)
2250 else if (IDENTIFIER_IMPLICIT_DECL (name))
2251 pedwarn ("`%s' was declared implicitly `extern' and later `static'",
2252 IDENTIFIER_POINTER (name));
2254 pedwarn ("`%s' was declared `extern' and later `static'",
2255 IDENTIFIER_POINTER (name));
2260 /* Here to install a non-global value. */
2261 tree oldlocal = IDENTIFIER_LOCAL_VALUE (name);
2262 tree oldglobal = IDENTIFIER_GLOBAL_VALUE (name);
2263 IDENTIFIER_LOCAL_VALUE (name) = x;
2265 /* If this is an extern function declaration, see if we
2266 have a global definition or declaration for the function. */
2268 && DECL_EXTERNAL (x) && !DECL_INLINE (x)
2270 && TREE_CODE (x) == FUNCTION_DECL
2271 && TREE_CODE (oldglobal) == FUNCTION_DECL)
2273 /* We have one. Their types must agree. */
2274 if (! comptypes (TREE_TYPE (x),
2275 TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (name))))
2276 pedwarn_with_decl (x, "extern declaration of `%s' doesn't match global one");
2279 /* Inner extern decl is inline if global one is.
2280 Copy enough to really inline it. */
2281 if (DECL_INLINE (oldglobal))
2283 DECL_INLINE (x) = DECL_INLINE (oldglobal);
2284 DECL_INITIAL (x) = (current_function_decl == oldglobal
2285 ? 0 : DECL_INITIAL (oldglobal));
2286 DECL_SAVED_INSNS (x) = DECL_SAVED_INSNS (oldglobal);
2287 DECL_FRAME_SIZE (x) = DECL_FRAME_SIZE (oldglobal);
2288 DECL_ARGUMENTS (x) = DECL_ARGUMENTS (oldglobal);
2289 DECL_RESULT (x) = DECL_RESULT (oldglobal);
2290 TREE_ASM_WRITTEN (x) = TREE_ASM_WRITTEN (oldglobal);
2291 DECL_ABSTRACT_ORIGIN (x) = oldglobal;
2293 /* Inner extern decl is built-in if global one is. */
2294 if (DECL_BUILT_IN (oldglobal))
2296 DECL_BUILT_IN (x) = DECL_BUILT_IN (oldglobal);
2297 DECL_FUNCTION_CODE (x) = DECL_FUNCTION_CODE (oldglobal);
2299 /* Keep the arg types from a file-scope fcn defn. */
2300 if (TYPE_ARG_TYPES (TREE_TYPE (oldglobal)) != 0
2301 && DECL_INITIAL (oldglobal)
2302 && TYPE_ARG_TYPES (TREE_TYPE (x)) == 0)
2303 TREE_TYPE (x) = TREE_TYPE (oldglobal);
2307 #if 0 /* This case is probably sometimes the right thing to do. */
2308 /* If we have a local external declaration,
2309 then any file-scope declaration should not
2310 have been static. */
2311 if (oldlocal == 0 && oldglobal != 0
2312 && !TREE_PUBLIC (oldglobal)
2313 && DECL_EXTERNAL (x) && TREE_PUBLIC (x))
2314 warning ("`%s' locally external but globally static",
2315 IDENTIFIER_POINTER (name));
2318 /* If we have a local external declaration,
2319 and no file-scope declaration has yet been seen,
2320 then if we later have a file-scope decl it must not be static. */
2322 && DECL_EXTERNAL (x)
2326 TREE_PUBLIC (name) = 1;
2328 /* Save this decl, so that we can do type checking against
2329 other decls after it falls out of scope.
2331 Only save it once. This prevents temporary decls created in
2332 expand_inline_function from being used here, since this
2333 will have been set when the inline function was parsed.
2334 It also helps give slightly better warnings. */
2335 if (IDENTIFIER_LIMBO_VALUE (name) == 0)
2336 IDENTIFIER_LIMBO_VALUE (name) = x;
2339 /* Warn if shadowing an argument at the top level of the body. */
2340 if (oldlocal != 0 && !DECL_EXTERNAL (x)
2341 /* This warning doesn't apply to the parms of a nested fcn. */
2342 && ! current_binding_level->parm_flag
2343 /* Check that this is one level down from the parms. */
2344 && current_binding_level->level_chain->parm_flag
2345 /* Check that the decl being shadowed
2346 comes from the parm level, one level up. */
2347 && chain_member (oldlocal, current_binding_level->level_chain->names))
2349 if (TREE_CODE (oldlocal) == PARM_DECL)
2350 pedwarn ("declaration of `%s' shadows a parameter",
2351 IDENTIFIER_POINTER (name));
2353 pedwarn ("declaration of `%s' shadows a symbol from the parameter list",
2354 IDENTIFIER_POINTER (name));
2357 /* Maybe warn if shadowing something else. */
2358 else if (warn_shadow && !DECL_EXTERNAL (x)
2359 /* No shadow warnings for internally generated vars. */
2360 && DECL_SOURCE_LINE (x) != 0
2361 /* No shadow warnings for vars made for inlining. */
2362 && ! DECL_FROM_INLINE (x))
2364 char *warnstring = 0;
2366 if (TREE_CODE (x) == PARM_DECL
2367 && current_binding_level->level_chain->parm_flag)
2368 /* Don't warn about the parm names in function declarator
2369 within a function declarator.
2370 It would be nice to avoid warning in any function
2371 declarator in a declaration, as opposed to a definition,
2372 but there is no way to tell it's not a definition. */
2374 else if (oldlocal != 0 && TREE_CODE (oldlocal) == PARM_DECL)
2375 warnstring = "declaration of `%s' shadows a parameter";
2376 else if (oldlocal != 0)
2377 warnstring = "declaration of `%s' shadows previous local";
2378 else if (IDENTIFIER_GLOBAL_VALUE (name) != 0
2379 && IDENTIFIER_GLOBAL_VALUE (name) != error_mark_node)
2380 warnstring = "declaration of `%s' shadows global declaration";
2383 warning (warnstring, IDENTIFIER_POINTER (name));
2386 /* If storing a local value, there may already be one (inherited).
2387 If so, record it for restoration when this binding level ends. */
2389 b->shadowed = tree_cons (name, oldlocal, b->shadowed);
2392 /* Keep count of variables in this level with incomplete type. */
2393 if (TYPE_SIZE (TREE_TYPE (x)) == 0)
2397 /* Put decls on list in reverse order.
2398 We will reverse them later if necessary. */
2399 TREE_CHAIN (x) = b->names;
2405 /* Like pushdecl, only it places X in GLOBAL_BINDING_LEVEL, if appropriate. */
2408 pushdecl_top_level (x)
2412 register struct binding_level *b = current_binding_level;
2414 current_binding_level = global_binding_level;
2416 current_binding_level = b;
2420 /* Generate an implicit declaration for identifier FUNCTIONID
2421 as a function of type int (). Print a warning if appropriate. */
2424 implicitly_declare (functionid)
2428 int traditional_warning = 0;
2429 /* Only one "implicit declaration" warning per identifier. */
2430 int implicit_warning;
2432 /* Save the decl permanently so we can warn if definition follows. */
2433 push_obstacks_nochange ();
2434 end_temporary_allocation ();
2436 /* We used to reuse an old implicit decl here,
2437 but this loses with inline functions because it can clobber
2438 the saved decl chains. */
2439 /* if (IDENTIFIER_IMPLICIT_DECL (functionid) != 0)
2440 decl = IDENTIFIER_IMPLICIT_DECL (functionid);
2442 decl = build_decl (FUNCTION_DECL, functionid, default_function_type);
2444 /* Warn of implicit decl following explicit local extern decl.
2445 This is probably a program designed for traditional C. */
2446 if (TREE_PUBLIC (functionid) && IDENTIFIER_GLOBAL_VALUE (functionid) == 0)
2447 traditional_warning = 1;
2449 /* Warn once of an implicit declaration. */
2450 implicit_warning = (IDENTIFIER_IMPLICIT_DECL (functionid) == 0);
2452 DECL_EXTERNAL (decl) = 1;
2453 TREE_PUBLIC (decl) = 1;
2455 /* Record that we have an implicit decl and this is it. */
2456 IDENTIFIER_IMPLICIT_DECL (functionid) = decl;
2458 /* ANSI standard says implicit declarations are in the innermost block.
2459 So we record the decl in the standard fashion.
2460 If flag_traditional is set, pushdecl does it top-level. */
2463 /* This is a no-op in c-lang.c or something real in objc-actions.c. */
2464 maybe_objc_check_decl (decl);
2466 rest_of_decl_compilation (decl, NULL_PTR, 0, 0);
2468 if (warn_implicit && implicit_warning)
2469 warning ("implicit declaration of function `%s'",
2470 IDENTIFIER_POINTER (functionid));
2471 else if (warn_traditional && traditional_warning)
2472 warning ("function `%s' was previously declared within a block",
2473 IDENTIFIER_POINTER (functionid));
2475 /* Write a record describing this implicit function declaration to the
2476 prototypes file (if requested). */
2478 gen_aux_info_record (decl, 0, 1, 0);
2485 /* Return zero if the declaration NEWDECL is valid
2486 when the declaration OLDDECL (assumed to be for the same name)
2487 has already been seen.
2488 Otherwise return an error message format string with a %s
2489 where the identifier should go. */
2492 redeclaration_error_message (newdecl, olddecl)
2493 tree newdecl, olddecl;
2495 if (TREE_CODE (newdecl) == TYPE_DECL)
2497 if (flag_traditional && TREE_TYPE (newdecl) == TREE_TYPE (olddecl))
2499 /* pushdecl creates distinct types for TYPE_DECLs by calling
2500 build_type_copy, so the above comparison generally fails. We do
2501 another test against the TYPE_MAIN_VARIANT of the olddecl, which
2502 is equivalent to what this code used to do before the build_type_copy
2503 call. The variant type distinction should not matter for traditional
2504 code, because it doesn't have type qualifiers. */
2505 if (flag_traditional
2506 && TYPE_MAIN_VARIANT (TREE_TYPE (olddecl)) == TREE_TYPE (newdecl))
2508 if (DECL_IN_SYSTEM_HEADER (olddecl) || DECL_IN_SYSTEM_HEADER (newdecl))
2510 return "redefinition of `%s'";
2512 else if (TREE_CODE (newdecl) == FUNCTION_DECL)
2514 /* Declarations of functions can insist on internal linkage
2515 but they can't be inconsistent with internal linkage,
2516 so there can be no error on that account.
2517 However defining the same name twice is no good. */
2518 if (DECL_INITIAL (olddecl) != 0 && DECL_INITIAL (newdecl) != 0
2519 /* However, defining once as extern inline and a second
2520 time in another way is ok. */
2521 && !(DECL_INLINE (olddecl) && DECL_EXTERNAL (olddecl)
2522 && !(DECL_INLINE (newdecl) && DECL_EXTERNAL (newdecl))))
2523 return "redefinition of `%s'";
2526 else if (current_binding_level == global_binding_level)
2528 /* Objects declared at top level: */
2529 /* If at least one is a reference, it's ok. */
2530 if (DECL_EXTERNAL (newdecl) || DECL_EXTERNAL (olddecl))
2532 /* Reject two definitions. */
2533 if (DECL_INITIAL (olddecl) != 0 && DECL_INITIAL (newdecl) != 0)
2534 return "redefinition of `%s'";
2535 /* Now we have two tentative defs, or one tentative and one real def. */
2536 /* Insist that the linkage match. */
2537 if (TREE_PUBLIC (olddecl) != TREE_PUBLIC (newdecl))
2538 return "conflicting declarations of `%s'";
2541 else if (current_binding_level->parm_flag
2542 && TREE_ASM_WRITTEN (olddecl) && !TREE_ASM_WRITTEN (newdecl))
2546 /* Newdecl has block scope. If olddecl has block scope also, then
2547 reject two definitions, and reject a definition together with an
2548 external reference. Otherwise, it is OK, because newdecl must
2549 be an extern reference to olddecl. */
2550 if (!(DECL_EXTERNAL (newdecl) && DECL_EXTERNAL (olddecl))
2551 && DECL_CONTEXT (newdecl) == DECL_CONTEXT (olddecl))
2552 return "redeclaration of `%s'";
2557 /* Get the LABEL_DECL corresponding to identifier ID as a label.
2558 Create one if none exists so far for the current function.
2559 This function is called for both label definitions and label references. */
2565 register tree decl = IDENTIFIER_LABEL_VALUE (id);
2567 if (current_function_decl == 0)
2569 error ("label %s referenced outside of any function",
2570 IDENTIFIER_POINTER (id));
2574 /* Use a label already defined or ref'd with this name. */
2577 /* But not if it is inherited and wasn't declared to be inheritable. */
2578 if (DECL_CONTEXT (decl) != current_function_decl
2579 && ! C_DECLARED_LABEL_FLAG (decl))
2580 return shadow_label (id);
2584 decl = build_decl (LABEL_DECL, id, void_type_node);
2586 /* Make sure every label has an rtx. */
2589 /* A label not explicitly declared must be local to where it's ref'd. */
2590 DECL_CONTEXT (decl) = current_function_decl;
2592 DECL_MODE (decl) = VOIDmode;
2594 /* Say where one reference is to the label,
2595 for the sake of the error if it is not defined. */
2596 DECL_SOURCE_LINE (decl) = lineno;
2597 DECL_SOURCE_FILE (decl) = input_filename;
2599 IDENTIFIER_LABEL_VALUE (id) = decl;
2601 named_labels = tree_cons (NULL_TREE, decl, named_labels);
2606 /* Make a label named NAME in the current function,
2607 shadowing silently any that may be inherited from containing functions
2608 or containing scopes.
2610 Note that valid use, if the label being shadowed
2611 comes from another scope in the same function,
2612 requires calling declare_nonlocal_label right away. */
2618 register tree decl = IDENTIFIER_LABEL_VALUE (name);
2624 /* Check to make sure that the label hasn't already been declared
2625 at this label scope */
2626 for (dup = named_labels; dup; dup = TREE_CHAIN (dup))
2627 if (TREE_VALUE (dup) == decl)
2629 error ("duplicate label declaration `%s'",
2630 IDENTIFIER_POINTER (name));
2631 error_with_decl (TREE_VALUE (dup),
2632 "this is a previous declaration");
2633 /* Just use the previous declaration. */
2634 return lookup_label (name);
2637 shadowed_labels = tree_cons (NULL_TREE, decl, shadowed_labels);
2638 IDENTIFIER_LABEL_VALUE (name) = decl = 0;
2641 return lookup_label (name);
2644 /* Define a label, specifying the location in the source file.
2645 Return the LABEL_DECL node for the label, if the definition is valid.
2646 Otherwise return 0. */
2649 define_label (filename, line, name)
2654 tree decl = lookup_label (name);
2656 /* If label with this name is known from an outer context, shadow it. */
2657 if (decl != 0 && DECL_CONTEXT (decl) != current_function_decl)
2659 shadowed_labels = tree_cons (NULL_TREE, decl, shadowed_labels);
2660 IDENTIFIER_LABEL_VALUE (name) = 0;
2661 decl = lookup_label (name);
2664 if (DECL_INITIAL (decl) != 0)
2666 error ("duplicate label `%s'", IDENTIFIER_POINTER (name));
2671 /* Mark label as having been defined. */
2672 DECL_INITIAL (decl) = error_mark_node;
2673 /* Say where in the source. */
2674 DECL_SOURCE_FILE (decl) = filename;
2675 DECL_SOURCE_LINE (decl) = line;
2680 /* Return the list of declarations of the current level.
2681 Note that this list is in reverse order unless/until
2682 you nreverse it; and when you do nreverse it, you must
2683 store the result back using `storedecls' or you will lose. */
2688 return current_binding_level->names;
2691 /* Return the list of type-tags (for structs, etc) of the current level. */
2696 return current_binding_level->tags;
2699 /* Store the list of declarations of the current level.
2700 This is done for the parameter declarations of a function being defined,
2701 after they are modified in the light of any missing parameters. */
2707 current_binding_level->names = decls;
2710 /* Similarly, store the list of tags of the current level. */
2716 current_binding_level->tags = tags;
2719 /* Given NAME, an IDENTIFIER_NODE,
2720 return the structure (or union or enum) definition for that name.
2721 Searches binding levels from BINDING_LEVEL up to the global level.
2722 If THISLEVEL_ONLY is nonzero, searches only the specified context
2723 (but skips any tag-transparent contexts to find one that is
2724 meaningful for tags).
2725 CODE says which kind of type the caller wants;
2726 it is RECORD_TYPE or UNION_TYPE or ENUMERAL_TYPE.
2727 If the wrong kind of type is found, an error is reported. */
2730 lookup_tag (code, name, binding_level, thislevel_only)
2731 enum tree_code code;
2732 struct binding_level *binding_level;
2736 register struct binding_level *level;
2738 for (level = binding_level; level; level = level->level_chain)
2741 for (tail = level->tags; tail; tail = TREE_CHAIN (tail))
2743 if (TREE_PURPOSE (tail) == name)
2745 if (TREE_CODE (TREE_VALUE (tail)) != code)
2747 /* Definition isn't the kind we were looking for. */
2748 pending_invalid_xref = name;
2749 pending_invalid_xref_file = input_filename;
2750 pending_invalid_xref_line = lineno;
2752 return TREE_VALUE (tail);
2755 if (thislevel_only && ! level->tag_transparent)
2761 /* Print an error message now
2762 for a recent invalid struct, union or enum cross reference.
2763 We don't print them immediately because they are not invalid
2764 when used in the `struct foo;' construct for shadowing. */
2767 pending_xref_error ()
2769 if (pending_invalid_xref != 0)
2770 error_with_file_and_line (pending_invalid_xref_file,
2771 pending_invalid_xref_line,
2772 "`%s' defined as wrong kind of tag",
2773 IDENTIFIER_POINTER (pending_invalid_xref));
2774 pending_invalid_xref = 0;
2777 /* Given a type, find the tag that was defined for it and return the tag name.
2778 Otherwise return 0. */
2781 lookup_tag_reverse (type)
2784 register struct binding_level *level;
2786 for (level = current_binding_level; level; level = level->level_chain)
2789 for (tail = level->tags; tail; tail = TREE_CHAIN (tail))
2791 if (TREE_VALUE (tail) == type)
2792 return TREE_PURPOSE (tail);
2798 /* Look up NAME in the current binding level and its superiors
2799 in the namespace of variables, functions and typedefs.
2800 Return a ..._DECL node of some kind representing its definition,
2801 or return 0 if it is undefined. */
2808 if (current_binding_level != global_binding_level
2809 && IDENTIFIER_LOCAL_VALUE (name))
2810 val = IDENTIFIER_LOCAL_VALUE (name);
2812 val = IDENTIFIER_GLOBAL_VALUE (name);
2816 /* Similar to `lookup_name' but look only at current binding level. */
2819 lookup_name_current_level (name)
2824 if (current_binding_level == global_binding_level)
2825 return IDENTIFIER_GLOBAL_VALUE (name);
2827 if (IDENTIFIER_LOCAL_VALUE (name) == 0)
2830 for (t = current_binding_level->names; t; t = TREE_CHAIN (t))
2831 if (DECL_NAME (t) == name)
2837 /* Create the predefined scalar types of C,
2838 and some nodes representing standard constants (0, 1, (void *) 0).
2839 Initialize the global binding level.
2840 Make definitions for built-in primitive functions. */
2843 init_decl_processing ()
2845 register tree endlink;
2846 /* Either char* or void*. */
2847 tree traditional_ptr_type_node;
2848 /* Data types of memcpy and strlen. */
2849 tree memcpy_ftype, memset_ftype, strlen_ftype;
2850 tree void_ftype_any;
2851 int wchar_type_size;
2853 tree array_domain_type;
2855 current_function_decl = NULL;
2856 named_labels = NULL;
2857 current_binding_level = NULL_BINDING_LEVEL;
2858 free_binding_level = NULL_BINDING_LEVEL;
2859 pushlevel (0); /* make the binding_level structure for global names */
2860 global_binding_level = current_binding_level;
2862 /* Define `int' and `char' first so that dbx will output them first. */
2864 integer_type_node = make_signed_type (INT_TYPE_SIZE);
2865 pushdecl (build_decl (TYPE_DECL, ridpointers[(int) RID_INT],
2866 integer_type_node));
2868 /* Define `char', which is like either `signed char' or `unsigned char'
2869 but not the same as either. */
2873 ? make_signed_type (CHAR_TYPE_SIZE)
2874 : make_unsigned_type (CHAR_TYPE_SIZE));
2875 pushdecl (build_decl (TYPE_DECL, get_identifier ("char"),
2878 long_integer_type_node = make_signed_type (LONG_TYPE_SIZE);
2879 pushdecl (build_decl (TYPE_DECL, get_identifier ("long int"),
2880 long_integer_type_node));
2882 unsigned_type_node = make_unsigned_type (INT_TYPE_SIZE);
2883 pushdecl (build_decl (TYPE_DECL, get_identifier ("unsigned int"),
2884 unsigned_type_node));
2886 long_unsigned_type_node = make_unsigned_type (LONG_TYPE_SIZE);
2887 pushdecl (build_decl (TYPE_DECL, get_identifier ("long unsigned int"),
2888 long_unsigned_type_node));
2890 long_long_integer_type_node = make_signed_type (LONG_LONG_TYPE_SIZE);
2891 pushdecl (build_decl (TYPE_DECL, get_identifier ("long long int"),
2892 long_long_integer_type_node));
2894 long_long_unsigned_type_node = make_unsigned_type (LONG_LONG_TYPE_SIZE);
2895 pushdecl (build_decl (TYPE_DECL, get_identifier ("long long unsigned int"),
2896 long_long_unsigned_type_node));
2898 short_integer_type_node = make_signed_type (SHORT_TYPE_SIZE);
2899 pushdecl (build_decl (TYPE_DECL, get_identifier ("short int"),
2900 short_integer_type_node));
2902 short_unsigned_type_node = make_unsigned_type (SHORT_TYPE_SIZE);
2903 pushdecl (build_decl (TYPE_DECL, get_identifier ("short unsigned int"),
2904 short_unsigned_type_node));
2906 /* `unsigned long' is the standard type for sizeof.
2907 Traditionally, use a signed type.
2908 Note that stddef.h uses `unsigned long',
2909 and this must agree, even of long and int are the same size. */
2911 = TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (get_identifier (SIZE_TYPE)));
2912 if (flag_traditional && TREE_UNSIGNED (sizetype))
2913 sizetype = signed_type (sizetype);
2916 = TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (get_identifier (PTRDIFF_TYPE)));
2918 TREE_TYPE (TYPE_SIZE (integer_type_node)) = sizetype;
2919 TREE_TYPE (TYPE_SIZE (char_type_node)) = sizetype;
2920 TREE_TYPE (TYPE_SIZE (unsigned_type_node)) = sizetype;
2921 TREE_TYPE (TYPE_SIZE (long_unsigned_type_node)) = sizetype;
2922 TREE_TYPE (TYPE_SIZE (long_integer_type_node)) = sizetype;
2923 TREE_TYPE (TYPE_SIZE (long_long_integer_type_node)) = sizetype;
2924 TREE_TYPE (TYPE_SIZE (long_long_unsigned_type_node)) = sizetype;
2925 TREE_TYPE (TYPE_SIZE (short_integer_type_node)) = sizetype;
2926 TREE_TYPE (TYPE_SIZE (short_unsigned_type_node)) = sizetype;
2928 error_mark_node = make_node (ERROR_MARK);
2929 TREE_TYPE (error_mark_node) = error_mark_node;
2931 /* Define both `signed char' and `unsigned char'. */
2932 signed_char_type_node = make_signed_type (CHAR_TYPE_SIZE);
2933 pushdecl (build_decl (TYPE_DECL, get_identifier ("signed char"),
2934 signed_char_type_node));
2936 unsigned_char_type_node = make_unsigned_type (CHAR_TYPE_SIZE);
2937 pushdecl (build_decl (TYPE_DECL, get_identifier ("unsigned char"),
2938 unsigned_char_type_node));
2940 intQI_type_node = make_signed_type (GET_MODE_BITSIZE (QImode));
2941 pushdecl (build_decl (TYPE_DECL, NULL_TREE, intQI_type_node));
2943 intHI_type_node = make_signed_type (GET_MODE_BITSIZE (HImode));
2944 pushdecl (build_decl (TYPE_DECL, NULL_TREE, intHI_type_node));
2946 intSI_type_node = make_signed_type (GET_MODE_BITSIZE (SImode));
2947 pushdecl (build_decl (TYPE_DECL, NULL_TREE, intSI_type_node));
2949 intDI_type_node = make_signed_type (GET_MODE_BITSIZE (DImode));
2950 pushdecl (build_decl (TYPE_DECL, NULL_TREE, intDI_type_node));
2952 unsigned_intQI_type_node = make_unsigned_type (GET_MODE_BITSIZE (QImode));
2953 pushdecl (build_decl (TYPE_DECL, NULL_TREE, unsigned_intQI_type_node));
2955 unsigned_intHI_type_node = make_unsigned_type (GET_MODE_BITSIZE (HImode));
2956 pushdecl (build_decl (TYPE_DECL, NULL_TREE, unsigned_intHI_type_node));
2958 unsigned_intSI_type_node = make_unsigned_type (GET_MODE_BITSIZE (SImode));
2959 pushdecl (build_decl (TYPE_DECL, NULL_TREE, unsigned_intSI_type_node));
2961 unsigned_intDI_type_node = make_unsigned_type (GET_MODE_BITSIZE (DImode));
2962 pushdecl (build_decl (TYPE_DECL, NULL_TREE, unsigned_intDI_type_node));
2964 float_type_node = make_node (REAL_TYPE);
2965 TYPE_PRECISION (float_type_node) = FLOAT_TYPE_SIZE;
2966 pushdecl (build_decl (TYPE_DECL, ridpointers[(int) RID_FLOAT],
2968 layout_type (float_type_node);
2970 double_type_node = make_node (REAL_TYPE);
2971 if (flag_short_double)
2972 TYPE_PRECISION (double_type_node) = FLOAT_TYPE_SIZE;
2974 TYPE_PRECISION (double_type_node) = DOUBLE_TYPE_SIZE;
2975 pushdecl (build_decl (TYPE_DECL, ridpointers[(int) RID_DOUBLE],
2977 layout_type (double_type_node);
2979 long_double_type_node = make_node (REAL_TYPE);
2980 TYPE_PRECISION (long_double_type_node) = LONG_DOUBLE_TYPE_SIZE;
2981 pushdecl (build_decl (TYPE_DECL, get_identifier ("long double"),
2982 long_double_type_node));
2983 layout_type (long_double_type_node);
2985 complex_integer_type_node = make_node (COMPLEX_TYPE);
2986 pushdecl (build_decl (TYPE_DECL, get_identifier ("complex int"),
2987 complex_integer_type_node));
2988 TREE_TYPE (complex_integer_type_node) = integer_type_node;
2989 layout_type (complex_integer_type_node);
2991 complex_float_type_node = make_node (COMPLEX_TYPE);
2992 pushdecl (build_decl (TYPE_DECL, get_identifier ("complex float"),
2993 complex_float_type_node));
2994 TREE_TYPE (complex_float_type_node) = float_type_node;
2995 layout_type (complex_float_type_node);
2997 complex_double_type_node = make_node (COMPLEX_TYPE);
2998 pushdecl (build_decl (TYPE_DECL, get_identifier ("complex double"),
2999 complex_double_type_node));
3000 TREE_TYPE (complex_double_type_node) = double_type_node;
3001 layout_type (complex_double_type_node);
3003 complex_long_double_type_node = make_node (COMPLEX_TYPE);
3004 pushdecl (build_decl (TYPE_DECL, get_identifier ("complex long double"),
3005 complex_long_double_type_node));
3006 TREE_TYPE (complex_long_double_type_node) = long_double_type_node;
3007 layout_type (complex_long_double_type_node);
3010 = TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (get_identifier (WCHAR_TYPE)));
3011 wchar_type_size = TYPE_PRECISION (wchar_type_node);
3012 signed_wchar_type_node = signed_type (wchar_type_node);
3013 unsigned_wchar_type_node = unsigned_type (wchar_type_node);
3015 integer_zero_node = build_int_2 (0, 0);
3016 TREE_TYPE (integer_zero_node) = integer_type_node;
3017 integer_one_node = build_int_2 (1, 0);
3018 TREE_TYPE (integer_one_node) = integer_type_node;
3020 boolean_type_node = integer_type_node;
3021 boolean_true_node = integer_one_node;
3022 boolean_false_node = integer_zero_node;
3024 size_zero_node = build_int_2 (0, 0);
3025 TREE_TYPE (size_zero_node) = sizetype;
3026 size_one_node = build_int_2 (1, 0);
3027 TREE_TYPE (size_one_node) = sizetype;
3029 void_type_node = make_node (VOID_TYPE);
3030 pushdecl (build_decl (TYPE_DECL,
3031 ridpointers[(int) RID_VOID], void_type_node));
3032 layout_type (void_type_node); /* Uses integer_zero_node */
3033 /* We are not going to have real types in C with less than byte alignment,
3034 so we might as well not have any types that claim to have it. */
3035 TYPE_ALIGN (void_type_node) = BITS_PER_UNIT;
3037 null_pointer_node = build_int_2 (0, 0);
3038 TREE_TYPE (null_pointer_node) = build_pointer_type (void_type_node);
3039 layout_type (TREE_TYPE (null_pointer_node));
3041 string_type_node = build_pointer_type (char_type_node);
3042 const_string_type_node
3043 = build_pointer_type (build_type_variant (char_type_node, 1, 0));
3045 /* Make a type to be the domain of a few array types
3046 whose domains don't really matter.
3047 200 is small enough that it always fits in size_t
3048 and large enough that it can hold most function names for the
3049 initializations of __FUNCTION__ and __PRETTY_FUNCTION__. */
3050 array_domain_type = build_index_type (build_int_2 (200, 0));
3052 /* make a type for arrays of characters.
3053 With luck nothing will ever really depend on the length of this
3055 char_array_type_node
3056 = build_array_type (char_type_node, array_domain_type);
3057 /* Likewise for arrays of ints. */
3059 = build_array_type (integer_type_node, array_domain_type);
3060 /* This is for wide string constants. */
3061 wchar_array_type_node
3062 = build_array_type (wchar_type_node, array_domain_type);
3064 default_function_type
3065 = build_function_type (integer_type_node, NULL_TREE);
3067 ptr_type_node = build_pointer_type (void_type_node);
3069 = build_pointer_type (build_type_variant (void_type_node, 1, 0));
3071 endlink = tree_cons (NULL_TREE, void_type_node, NULL_TREE);
3074 = build_function_type (void_type_node, NULL_TREE);
3077 = build_function_type (float_type_node,
3078 tree_cons (NULL_TREE, float_type_node, endlink));
3081 = build_function_type (double_type_node,
3082 tree_cons (NULL_TREE, double_type_node, endlink));
3084 ldouble_ftype_ldouble
3085 = build_function_type (long_double_type_node,
3086 tree_cons (NULL_TREE, long_double_type_node,
3089 double_ftype_double_double
3090 = build_function_type (double_type_node,
3091 tree_cons (NULL_TREE, double_type_node,
3092 tree_cons (NULL_TREE,
3093 double_type_node, endlink)));
3096 = build_function_type (integer_type_node,
3097 tree_cons (NULL_TREE, integer_type_node, endlink));
3100 = build_function_type (long_integer_type_node,
3101 tree_cons (NULL_TREE,
3102 long_integer_type_node, endlink));
3104 void_ftype_ptr_ptr_int
3105 = build_function_type (void_type_node,
3106 tree_cons (NULL_TREE, ptr_type_node,
3107 tree_cons (NULL_TREE, ptr_type_node,
3108 tree_cons (NULL_TREE,
3112 int_ftype_cptr_cptr_sizet
3113 = build_function_type (integer_type_node,
3114 tree_cons (NULL_TREE, const_ptr_type_node,
3115 tree_cons (NULL_TREE, const_ptr_type_node,
3116 tree_cons (NULL_TREE,
3120 void_ftype_ptr_int_int
3121 = build_function_type (void_type_node,
3122 tree_cons (NULL_TREE, ptr_type_node,
3123 tree_cons (NULL_TREE, integer_type_node,
3124 tree_cons (NULL_TREE,
3128 string_ftype_ptr_ptr /* strcpy prototype */
3129 = build_function_type (string_type_node,
3130 tree_cons (NULL_TREE, string_type_node,
3131 tree_cons (NULL_TREE,
3132 const_string_type_node,
3135 int_ftype_string_string /* strcmp prototype */
3136 = build_function_type (integer_type_node,
3137 tree_cons (NULL_TREE, const_string_type_node,
3138 tree_cons (NULL_TREE,
3139 const_string_type_node,
3142 strlen_ftype /* strlen prototype */
3143 = build_function_type (flag_traditional ? integer_type_node : sizetype,
3144 tree_cons (NULL_TREE, const_string_type_node,
3147 traditional_ptr_type_node
3148 = (flag_traditional ? string_type_node : ptr_type_node);
3150 memcpy_ftype /* memcpy prototype */
3151 = build_function_type (traditional_ptr_type_node,
3152 tree_cons (NULL_TREE, ptr_type_node,
3153 tree_cons (NULL_TREE, const_ptr_type_node,
3154 tree_cons (NULL_TREE,
3158 memset_ftype /* memset prototype */
3159 = build_function_type (traditional_ptr_type_node,
3160 tree_cons (NULL_TREE, ptr_type_node,
3161 tree_cons (NULL_TREE, integer_type_node,
3162 tree_cons (NULL_TREE,
3166 builtin_function ("__builtin_constant_p", default_function_type,
3167 BUILT_IN_CONSTANT_P, NULL_PTR);
3169 builtin_function ("__builtin_return_address",
3170 build_function_type (ptr_type_node,
3171 tree_cons (NULL_TREE,
3174 BUILT_IN_RETURN_ADDRESS, NULL_PTR);
3176 builtin_function ("__builtin_frame_address",
3177 build_function_type (ptr_type_node,
3178 tree_cons (NULL_TREE,
3181 BUILT_IN_FRAME_ADDRESS, NULL_PTR);
3183 builtin_function ("__builtin_alloca",
3184 build_function_type (ptr_type_node,
3185 tree_cons (NULL_TREE,
3188 BUILT_IN_ALLOCA, "alloca");
3189 builtin_function ("__builtin_ffs", int_ftype_int, BUILT_IN_FFS, NULL_PTR);
3190 /* Define alloca, ffs as builtins.
3191 Declare _exit just to mark it as volatile. */
3192 if (! flag_no_builtin && !flag_no_nonansi_builtin)
3194 temp = builtin_function ("alloca",
3195 build_function_type (ptr_type_node,
3196 tree_cons (NULL_TREE,
3199 BUILT_IN_ALLOCA, NULL_PTR);
3200 /* Suppress error if redefined as a non-function. */
3201 DECL_BUILT_IN_NONANSI (temp) = 1;
3202 temp = builtin_function ("ffs", int_ftype_int, BUILT_IN_FFS, NULL_PTR);
3203 /* Suppress error if redefined as a non-function. */
3204 DECL_BUILT_IN_NONANSI (temp) = 1;
3205 temp = builtin_function ("_exit", void_ftype_any, NOT_BUILT_IN,
3207 TREE_THIS_VOLATILE (temp) = 1;
3208 TREE_SIDE_EFFECTS (temp) = 1;
3209 /* Suppress error if redefined as a non-function. */
3210 DECL_BUILT_IN_NONANSI (temp) = 1;
3213 builtin_function ("__builtin_abs", int_ftype_int, BUILT_IN_ABS, NULL_PTR);
3214 builtin_function ("__builtin_fabsf", float_ftype_float, BUILT_IN_FABS,
3216 builtin_function ("__builtin_fabs", double_ftype_double, BUILT_IN_FABS,
3218 builtin_function ("__builtin_fabsl", ldouble_ftype_ldouble, BUILT_IN_FABS,
3220 builtin_function ("__builtin_labs", long_ftype_long, BUILT_IN_LABS,
3222 builtin_function ("__builtin_saveregs",
3223 build_function_type (ptr_type_node, NULL_TREE),
3224 BUILT_IN_SAVEREGS, NULL_PTR);
3225 /* EXPAND_BUILTIN_VARARGS is obsolete. */
3227 builtin_function ("__builtin_varargs",
3228 build_function_type (ptr_type_node,
3229 tree_cons (NULL_TREE,
3232 BUILT_IN_VARARGS, NULL_PTR);
3234 builtin_function ("__builtin_classify_type", default_function_type,
3235 BUILT_IN_CLASSIFY_TYPE, NULL_PTR);
3236 builtin_function ("__builtin_next_arg",
3237 build_function_type (ptr_type_node, NULL_TREE),
3238 BUILT_IN_NEXT_ARG, NULL_PTR);
3239 builtin_function ("__builtin_args_info",
3240 build_function_type (integer_type_node,
3241 tree_cons (NULL_TREE,
3244 BUILT_IN_ARGS_INFO, NULL_PTR);
3246 /* Untyped call and return. */
3247 builtin_function ("__builtin_apply_args",
3248 build_function_type (ptr_type_node, NULL_TREE),
3249 BUILT_IN_APPLY_ARGS, NULL_PTR);
3251 temp = tree_cons (NULL_TREE,
3252 build_pointer_type (build_function_type (void_type_node,
3254 tree_cons (NULL_TREE,
3256 tree_cons (NULL_TREE,
3259 builtin_function ("__builtin_apply",
3260 build_function_type (ptr_type_node, temp),
3261 BUILT_IN_APPLY, NULL_PTR);
3262 builtin_function ("__builtin_return",
3263 build_function_type (void_type_node,
3264 tree_cons (NULL_TREE,
3267 BUILT_IN_RETURN, NULL_PTR);
3269 /* Currently under experimentation. */
3270 builtin_function ("__builtin_memcpy", memcpy_ftype,
3271 BUILT_IN_MEMCPY, "memcpy");
3272 builtin_function ("__builtin_memcmp", int_ftype_cptr_cptr_sizet,
3273 BUILT_IN_MEMCMP, "memcmp");
3274 builtin_function ("__builtin_memset", memset_ftype,
3275 BUILT_IN_MEMSET, NULL_PTR);
3276 builtin_function ("__builtin_strcmp", int_ftype_string_string,
3277 BUILT_IN_STRCMP, "strcmp");
3278 builtin_function ("__builtin_strcpy", string_ftype_ptr_ptr,
3279 BUILT_IN_STRCPY, "strcpy");
3280 builtin_function ("__builtin_strlen", strlen_ftype,
3281 BUILT_IN_STRLEN, "strlen");
3282 builtin_function ("__builtin_sqrtf", float_ftype_float,
3283 BUILT_IN_FSQRT, "sqrtf");
3284 builtin_function ("__builtin_fsqrt", double_ftype_double,
3285 BUILT_IN_FSQRT, "sqrt");
3286 builtin_function ("__builtin_sqrtl", ldouble_ftype_ldouble,
3287 BUILT_IN_FSQRT, "sqrtl");
3288 builtin_function ("__builtin_sinf", float_ftype_float,
3289 BUILT_IN_SIN, "sinf");
3290 builtin_function ("__builtin_sin", double_ftype_double,
3291 BUILT_IN_SIN, "sin");
3292 builtin_function ("__builtin_sinl", ldouble_ftype_ldouble,
3293 BUILT_IN_SIN, "sinl");
3294 builtin_function ("__builtin_cosf", float_ftype_float,
3295 BUILT_IN_COS, "cosf");
3296 builtin_function ("__builtin_cos", double_ftype_double,
3297 BUILT_IN_COS, "cos");
3298 builtin_function ("__builtin_cosl", ldouble_ftype_ldouble,
3299 BUILT_IN_COS, "cosl");
3300 builtin_function ("__builtin_setjmp",
3301 build_function_type (integer_type_node,
3302 tree_cons (NULL_TREE,
3303 ptr_type_node, endlink)),
3304 BUILT_IN_SETJMP, NULL_PTR);
3305 builtin_function ("__builtin_longjmp",
3308 tree_cons (NULL, ptr_type_node,
3309 tree_cons (NULL_TREE,
3312 BUILT_IN_LONGJMP, NULL_PTR);
3314 /* In an ANSI C program, it is okay to supply built-in meanings
3315 for these functions, since applications cannot validly use them
3316 with any other meaning.
3317 However, honor the -fno-builtin option. */
3318 if (!flag_no_builtin)
3320 builtin_function ("abs", int_ftype_int, BUILT_IN_ABS, NULL_PTR);
3321 builtin_function ("fabsf", float_ftype_float, BUILT_IN_FABS, NULL_PTR);
3322 builtin_function ("fabs", double_ftype_double, BUILT_IN_FABS, NULL_PTR);
3323 builtin_function ("fabsl", ldouble_ftype_ldouble, BUILT_IN_FABS,
3325 builtin_function ("labs", long_ftype_long, BUILT_IN_LABS, NULL_PTR);
3326 builtin_function ("memcpy", memcpy_ftype, BUILT_IN_MEMCPY, NULL_PTR);
3327 builtin_function ("memcmp", int_ftype_cptr_cptr_sizet, BUILT_IN_MEMCMP,
3329 builtin_function ("memset", memset_ftype, BUILT_IN_MEMSET, NULL_PTR);
3330 builtin_function ("strcmp", int_ftype_string_string, BUILT_IN_STRCMP,
3332 builtin_function ("strcpy", string_ftype_ptr_ptr, BUILT_IN_STRCPY,
3334 builtin_function ("strlen", strlen_ftype, BUILT_IN_STRLEN, NULL_PTR);
3335 builtin_function ("sqrtf", float_ftype_float, BUILT_IN_FSQRT, NULL_PTR);
3336 builtin_function ("sqrt", double_ftype_double, BUILT_IN_FSQRT, NULL_PTR);
3337 builtin_function ("sqrtl", ldouble_ftype_ldouble, BUILT_IN_FSQRT,
3339 builtin_function ("sinf", float_ftype_float, BUILT_IN_SIN, NULL_PTR);
3340 builtin_function ("sin", double_ftype_double, BUILT_IN_SIN, NULL_PTR);
3341 builtin_function ("sinl", ldouble_ftype_ldouble, BUILT_IN_SIN, NULL_PTR);
3342 builtin_function ("cosf", float_ftype_float, BUILT_IN_COS, NULL_PTR);
3343 builtin_function ("cos", double_ftype_double, BUILT_IN_COS, NULL_PTR);
3344 builtin_function ("cosl", ldouble_ftype_ldouble, BUILT_IN_COS, NULL_PTR);
3346 /* Declare these functions volatile
3347 to avoid spurious "control drops through" warnings. */
3348 /* Don't specify the argument types, to avoid errors
3349 from certain code which isn't valid in ANSI but which exists. */
3350 temp = builtin_function ("abort", void_ftype_any, NOT_BUILT_IN,
3352 TREE_THIS_VOLATILE (temp) = 1;
3353 TREE_SIDE_EFFECTS (temp) = 1;
3354 temp = builtin_function ("exit", void_ftype_any, NOT_BUILT_IN, NULL_PTR);
3355 TREE_THIS_VOLATILE (temp) = 1;
3356 TREE_SIDE_EFFECTS (temp) = 1;
3360 /* Support for these has not been written in either expand_builtin
3361 or build_function_call. */
3362 builtin_function ("__builtin_div", default_ftype, BUILT_IN_DIV, NULL_PTR);
3363 builtin_function ("__builtin_ldiv", default_ftype, BUILT_IN_LDIV, NULL_PTR);
3364 builtin_function ("__builtin_ffloor", double_ftype_double, BUILT_IN_FFLOOR,
3366 builtin_function ("__builtin_fceil", double_ftype_double, BUILT_IN_FCEIL,
3368 builtin_function ("__builtin_fmod", double_ftype_double_double,
3369 BUILT_IN_FMOD, NULL_PTR);
3370 builtin_function ("__builtin_frem", double_ftype_double_double,
3371 BUILT_IN_FREM, NULL_PTR);
3372 builtin_function ("__builtin_memset", ptr_ftype_ptr_int_int,
3373 BUILT_IN_MEMSET, NULL_PTR);
3374 builtin_function ("__builtin_getexp", double_ftype_double, BUILT_IN_GETEXP,
3376 builtin_function ("__builtin_getman", double_ftype_double, BUILT_IN_GETMAN,
3380 pedantic_lvalues = pedantic;
3382 /* Create the global bindings for __FUNCTION__ and __PRETTY_FUNCTION__. */
3383 declare_function_name ();
3385 start_identifier_warnings ();
3387 /* Prepare to check format strings against argument lists. */
3388 init_function_format_info ();
3392 incomplete_decl_finalize_hook = finish_incomplete_decl;
3395 /* Return a definition for a builtin function named NAME and whose data type
3396 is TYPE. TYPE should be a function type with argument types.
3397 FUNCTION_CODE tells later passes how to compile calls to this function.
3398 See tree.h for its possible values.
3400 If LIBRARY_NAME is nonzero, use that for DECL_ASSEMBLER_NAME,
3401 the name to be called if we can't opencode the function. */
3404 builtin_function (name, type, function_code, library_name)
3407 enum built_in_function function_code;
3410 tree decl = build_decl (FUNCTION_DECL, get_identifier (name), type);
3411 DECL_EXTERNAL (decl) = 1;
3412 TREE_PUBLIC (decl) = 1;
3413 /* If -traditional, permit redefining a builtin function any way you like.
3414 (Though really, if the program redefines these functions,
3415 it probably won't work right unless compiled with -fno-builtin.) */
3416 if (flag_traditional && name[0] != '_')
3417 DECL_BUILT_IN_NONANSI (decl) = 1;
3419 DECL_ASSEMBLER_NAME (decl) = get_identifier (library_name);
3420 make_decl_rtl (decl, NULL_PTR, 1);
3422 if (function_code != NOT_BUILT_IN)
3424 DECL_BUILT_IN (decl) = 1;
3425 DECL_FUNCTION_CODE (decl) = function_code;
3427 /* Warn if a function in the namespace for users
3428 is used without an occasion to consider it declared. */
3429 if (name[0] != '_' || name[1] != '_')
3430 C_DECL_ANTICIPATED (decl) = 1;
3435 /* Called when a declaration is seen that contains no names to declare.
3436 If its type is a reference to a structure, union or enum inherited
3437 from a containing scope, shadow that tag name for the current scope
3438 with a forward reference.
3439 If its type defines a new named structure or union
3440 or defines an enum, it is valid but we need not do anything here.
3441 Otherwise, it is an error. */
3444 shadow_tag (declspecs)
3447 shadow_tag_warned (declspecs, 0);
3451 shadow_tag_warned (declspecs, warned)
3454 /* 1 => we have done a pedwarn. 2 => we have done a warning, but
3460 pending_invalid_xref = 0;
3462 for (link = declspecs; link; link = TREE_CHAIN (link))
3464 register tree value = TREE_VALUE (link);
3465 register enum tree_code code = TREE_CODE (value);
3467 if (code == RECORD_TYPE || code == UNION_TYPE || code == ENUMERAL_TYPE)
3468 /* Used to test also that TYPE_SIZE (value) != 0.
3469 That caused warning for `struct foo;' at top level in the file. */
3471 register tree name = lookup_tag_reverse (value);
3478 if (warned != 1 && code != ENUMERAL_TYPE)
3479 /* Empty unnamed enum OK */
3481 pedwarn ("unnamed struct/union that defines no instances");
3487 t = lookup_tag (code, name, current_binding_level, 1);
3491 t = make_node (code);
3498 if (!warned && ! in_system_header)
3500 warning ("useless keyword or type name in empty declaration");
3507 error ("two types specified in one empty declaration");
3512 pedwarn ("empty declaration");
3516 /* Decode a "typename", such as "int **", returning a ..._TYPE node. */
3519 groktypename (typename)
3522 if (TREE_CODE (typename) != TREE_LIST)
3524 return grokdeclarator (TREE_VALUE (typename),
3525 TREE_PURPOSE (typename),
3529 /* Return a PARM_DECL node for a given pair of specs and declarator. */
3532 groktypename_in_parm_context (typename)
3535 if (TREE_CODE (typename) != TREE_LIST)
3537 return grokdeclarator (TREE_VALUE (typename),
3538 TREE_PURPOSE (typename),
3542 /* Decode a declarator in an ordinary declaration or data definition.
3543 This is called as soon as the type information and variable name
3544 have been parsed, before parsing the initializer if any.
3545 Here we create the ..._DECL node, fill in its type,
3546 and put it on the list of decls for the current context.
3547 The ..._DECL node is returned as the value.
3549 Exception: for arrays where the length is not specified,
3550 the type is left null, to be filled in by `finish_decl'.
3552 Function definitions do not come here; they go to start_function
3553 instead. However, external and forward declarations of functions
3554 do go through here. Structure field declarations are done by
3555 grokfield and not through here. */
3557 /* Set this to zero to debug not using the temporary obstack
3558 to parse initializers. */
3559 int debug_temp_inits = 1;
3562 start_decl (declarator, declspecs, initialized, attributes, prefix_attributes)
3563 tree declarator, declspecs;
3565 tree attributes, prefix_attributes;
3567 register tree decl = grokdeclarator (declarator, declspecs,
3568 NORMAL, initialized);
3570 int init_written = initialized;
3572 /* The corresponding pop_obstacks is in finish_decl. */
3573 push_obstacks_nochange ();
3575 if (warn_main && !strcmp (IDENTIFIER_POINTER (declarator), "main"))
3576 warning_with_decl (decl, "`%s' is usually a function");
3579 /* Is it valid for this decl to have an initializer at all?
3580 If not, set INITIALIZED to zero, which will indirectly
3581 tell `finish_decl' to ignore the initializer once it is parsed. */
3582 switch (TREE_CODE (decl))
3585 /* typedef foo = bar means give foo the same type as bar.
3586 We haven't parsed bar yet, so `finish_decl' will fix that up.
3587 Any other case of an initialization in a TYPE_DECL is an error. */
3588 if (pedantic || list_length (declspecs) > 1)
3590 error ("typedef `%s' is initialized",
3591 IDENTIFIER_POINTER (DECL_NAME (decl)));
3597 error ("function `%s' is initialized like a variable",
3598 IDENTIFIER_POINTER (DECL_NAME (decl)));
3603 /* DECL_INITIAL in a PARM_DECL is really DECL_ARG_TYPE. */
3604 error ("parameter `%s' is initialized",
3605 IDENTIFIER_POINTER (DECL_NAME (decl)));
3610 /* Don't allow initializations for incomplete types
3611 except for arrays which might be completed by the initialization. */
3612 if (TYPE_SIZE (TREE_TYPE (decl)) != 0)
3614 /* A complete type is ok if size is fixed. */
3616 if (TREE_CODE (TYPE_SIZE (TREE_TYPE (decl))) != INTEGER_CST
3617 || C_DECL_VARIABLE_SIZE (decl))
3619 error ("variable-sized object may not be initialized");
3623 else if (TREE_CODE (TREE_TYPE (decl)) != ARRAY_TYPE)
3625 error ("variable `%s' has initializer but incomplete type",
3626 IDENTIFIER_POINTER (DECL_NAME (decl)));
3629 else if (TYPE_SIZE (TREE_TYPE (TREE_TYPE (decl))) == 0)
3631 error ("elements of array `%s' have incomplete type",
3632 IDENTIFIER_POINTER (DECL_NAME (decl)));
3639 #if 0 /* Seems redundant with grokdeclarator. */
3640 if (current_binding_level != global_binding_level
3641 && DECL_EXTERNAL (decl)
3642 && TREE_CODE (decl) != FUNCTION_DECL)
3643 warning ("declaration of `%s' has `extern' and is initialized",
3644 IDENTIFIER_POINTER (DECL_NAME (decl)));
3646 DECL_EXTERNAL (decl) = 0;
3647 if (current_binding_level == global_binding_level)
3648 TREE_STATIC (decl) = 1;
3650 /* Tell `pushdecl' this is an initialized decl
3651 even though we don't yet have the initializer expression.
3652 Also tell `finish_decl' it may store the real initializer. */
3653 DECL_INITIAL (decl) = error_mark_node;
3656 /* If this is a function declaration, write a record describing it to the
3657 prototypes file (if requested). */
3659 if (TREE_CODE (decl) == FUNCTION_DECL)
3660 gen_aux_info_record (decl, 0, 0, TYPE_ARG_TYPES (TREE_TYPE (decl)) != 0);
3662 /* ANSI specifies that a tentative definition which is not merged with
3663 a non-tentative definition behaves exactly like a definition with an
3664 initializer equal to zero. (Section 3.7.2)
3665 -fno-common gives strict ANSI behavior. Usually you don't want it.
3666 This matters only for variables with external linkage. */
3667 if (! flag_no_common || ! TREE_PUBLIC (decl))
3668 DECL_COMMON (decl) = 1;
3670 /* Set attributes here so if duplicate decl, will have proper attributes. */
3671 decl_attributes (decl, attributes, prefix_attributes);
3673 /* Add this decl to the current binding level.
3674 TEM may equal DECL or it may be a previous decl of the same name. */
3675 tem = pushdecl (decl);
3677 /* For a local variable, define the RTL now. */
3678 if (current_binding_level != global_binding_level
3679 /* But not if this is a duplicate decl
3680 and we preserved the rtl from the previous one
3681 (which may or may not happen). */
3682 && DECL_RTL (tem) == 0)
3684 if (TYPE_SIZE (TREE_TYPE (tem)) != 0)
3686 else if (TREE_CODE (TREE_TYPE (tem)) == ARRAY_TYPE
3687 && DECL_INITIAL (tem) != 0)
3693 /* When parsing and digesting the initializer,
3694 use temporary storage. Do this even if we will ignore the value. */
3695 if (current_binding_level == global_binding_level && debug_temp_inits)
3696 temporary_allocation ();
3702 /* Finish processing of a declaration;
3703 install its initial value.
3704 If the length of an array type is not known before,
3705 it must be determined now, from the initial value, or it is an error. */
3708 finish_decl (decl, init, asmspec_tree)
3712 register tree type = TREE_TYPE (decl);
3713 int was_incomplete = (DECL_SIZE (decl) == 0);
3714 int temporary = allocation_temporary_p ();
3717 /* If a name was specified, get the string. */
3719 asmspec = TREE_STRING_POINTER (asmspec_tree);
3721 /* If `start_decl' didn't like having an initialization, ignore it now. */
3723 if (init != 0 && DECL_INITIAL (decl) == 0)
3725 /* Don't crash if parm is initialized. */
3726 if (TREE_CODE (decl) == PARM_DECL)
3729 if (ITERATOR_P (decl))
3732 error_with_decl (decl, "iterator has no initial value");
3734 init = save_expr (init);
3739 if (TREE_CODE (decl) != TYPE_DECL)
3740 store_init_value (decl, init);
3743 /* typedef foo = bar; store the type of bar as the type of foo. */
3744 TREE_TYPE (decl) = TREE_TYPE (init);
3745 DECL_INITIAL (decl) = init = 0;
3749 /* Pop back to the obstack that is current for this binding level.
3750 This is because MAXINDEX, rtl, etc. to be made below
3751 must go in the permanent obstack. But don't discard the
3752 temporary data yet. */
3754 #if 0 /* pop_obstacks was near the end; this is what was here. */
3755 if (current_binding_level == global_binding_level && temporary)
3756 end_temporary_allocation ();
3759 /* Deduce size of array from initialization, if not already known */
3761 if (TREE_CODE (type) == ARRAY_TYPE
3762 && TYPE_DOMAIN (type) == 0
3763 && TREE_CODE (decl) != TYPE_DECL)
3766 = (TREE_STATIC (decl)
3767 /* Even if pedantic, an external linkage array
3768 may have incomplete type at first. */
3769 ? pedantic && !TREE_PUBLIC (decl)
3770 : !DECL_EXTERNAL (decl));
3772 = complete_array_type (type, DECL_INITIAL (decl), do_default);
3774 /* Get the completed type made by complete_array_type. */
3775 type = TREE_TYPE (decl);
3778 error_with_decl (decl, "initializer fails to determine size of `%s'");
3783 error_with_decl (decl, "array size missing in `%s'");
3784 /* If a `static' var's size isn't known,
3785 make it extern as well as static, so it does not get
3787 If it is not `static', then do not mark extern;
3788 finish_incomplete_decl will give it a default size
3789 and it will get allocated. */
3790 else if (!pedantic && TREE_STATIC (decl) && ! TREE_PUBLIC (decl))
3791 DECL_EXTERNAL (decl) = 1;
3794 /* TYPE_MAX_VALUE is always one less than the number of elements
3795 in the array, because we start counting at zero. Therefore,
3796 warn only if the value is less than zero. */
3797 if (pedantic && TYPE_DOMAIN (type) != 0
3798 && tree_int_cst_sgn (TYPE_MAX_VALUE (TYPE_DOMAIN (type))) < 0)
3799 error_with_decl (decl, "zero or negative size array `%s'");
3801 layout_decl (decl, 0);
3804 if (TREE_CODE (decl) == VAR_DECL)
3806 if (DECL_SIZE (decl) == 0
3807 && TYPE_SIZE (TREE_TYPE (decl)) != 0)
3808 layout_decl (decl, 0);
3810 if (DECL_SIZE (decl) == 0
3811 && (TREE_STATIC (decl)
3813 /* A static variable with an incomplete type
3814 is an error if it is initialized.
3815 Also if it is not file scope.
3816 Otherwise, let it through, but if it is not `extern'
3817 then it may cause an error message later. */
3818 /* A duplicate_decls call could have changed an extern
3819 declaration into a file scope one. This can be detected
3820 by TREE_ASM_WRITTEN being set. */
3821 (DECL_INITIAL (decl) != 0
3822 || DECL_CONTEXT (decl) != 0 && ! TREE_ASM_WRITTEN (decl))
3824 /* An automatic variable with an incomplete type
3826 !DECL_EXTERNAL (decl)))
3828 error_with_decl (decl, "storage size of `%s' isn't known");
3829 TREE_TYPE (decl) = error_mark_node;
3832 if ((DECL_EXTERNAL (decl) || TREE_STATIC (decl))
3833 && DECL_SIZE (decl) != 0)
3835 if (TREE_CODE (DECL_SIZE (decl)) == INTEGER_CST)
3836 constant_expression_warning (DECL_SIZE (decl));
3838 error_with_decl (decl, "storage size of `%s' isn't constant");
3842 /* If this is a function and an assembler name is specified, it isn't
3843 builtin any more. Also reset DECL_RTL so we can give it its new
3845 if (TREE_CODE (decl) == FUNCTION_DECL && asmspec)
3847 DECL_BUILT_IN (decl) = 0;
3848 DECL_RTL (decl) = 0;
3851 /* Output the assembler code and/or RTL code for variables and functions,
3852 unless the type is an undefined structure or union.
3853 If not, it will get done when the type is completed. */
3855 if (TREE_CODE (decl) == VAR_DECL || TREE_CODE (decl) == FUNCTION_DECL)
3857 if ((flag_traditional || TREE_PERMANENT (decl))
3858 && allocation_temporary_p ())
3860 push_obstacks_nochange ();
3861 end_temporary_allocation ();
3862 /* This is a no-op in c-lang.c or something real in objc-actions.c. */
3863 maybe_objc_check_decl (decl);
3864 rest_of_decl_compilation (decl, asmspec,
3865 (DECL_CONTEXT (decl) == 0
3866 || TREE_ASM_WRITTEN (decl)),
3872 /* This is a no-op in c-lang.c or something real in objc-actions.c. */
3873 maybe_objc_check_decl (decl);
3874 rest_of_decl_compilation (decl, asmspec, DECL_CONTEXT (decl) == 0,
3877 if (DECL_CONTEXT (decl) != 0)
3879 /* Recompute the RTL of a local array now
3880 if it used to be an incomplete type. */
3882 && ! TREE_STATIC (decl) && ! DECL_EXTERNAL (decl))
3884 /* If we used it already as memory, it must stay in memory. */
3885 TREE_ADDRESSABLE (decl) = TREE_USED (decl);
3886 /* If it's still incomplete now, no init will save it. */
3887 if (DECL_SIZE (decl) == 0)
3888 DECL_INITIAL (decl) = 0;
3891 /* Compute and store the initial value. */
3892 if (TREE_CODE (decl) != FUNCTION_DECL)
3893 expand_decl_init (decl);
3897 if (TREE_CODE (decl) == TYPE_DECL)
3899 /* This is a no-op in c-lang.c or something real in objc-actions.c. */
3900 maybe_objc_check_decl (decl);
3901 rest_of_decl_compilation (decl, NULL_PTR, DECL_CONTEXT (decl) == 0,
3905 /* ??? After 2.3, test (init != 0) instead of TREE_CODE. */
3906 /* This test used to include TREE_PERMANENT, however, we have the same
3907 problem with initializers at the function level. Such initializers get
3908 saved until the end of the function on the momentary_obstack. */
3909 if (!(TREE_CODE (decl) == FUNCTION_DECL && DECL_INLINE (decl))
3911 /* DECL_INITIAL is not defined in PARM_DECLs, since it shares
3912 space with DECL_ARG_TYPE. */
3913 && TREE_CODE (decl) != PARM_DECL)
3915 /* We need to remember that this array HAD an initialization,
3916 but discard the actual temporary nodes,
3917 since we can't have a permanent node keep pointing to them. */
3918 /* We make an exception for inline functions, since it's
3919 normal for a local extern redeclaration of an inline function
3920 to have a copy of the top-level decl's DECL_INLINE. */
3921 if (DECL_INITIAL (decl) != 0 && DECL_INITIAL (decl) != error_mark_node)
3923 /* If this is a const variable, then preserve the
3924 initializer instead of discarding it so that we can optimize
3925 references to it. */
3926 /* This test used to include TREE_STATIC, but this won't be set
3927 for function level initializers. */
3928 if (TREE_READONLY (decl) || ITERATOR_P (decl))
3930 preserve_initializer ();
3931 /* Hack? Set the permanent bit for something that is permanent,
3932 but not on the permanent obstack, so as to convince
3933 output_constant_def to make its rtl on the permanent
3935 TREE_PERMANENT (DECL_INITIAL (decl)) = 1;
3937 /* The initializer and DECL must have the same (or equivalent
3938 types), but if the initializer is a STRING_CST, its type
3939 might not be on the right obstack, so copy the type
3941 TREE_TYPE (DECL_INITIAL (decl)) = type;
3944 DECL_INITIAL (decl) = error_mark_node;
3948 /* If requested, warn about definitions of large data objects. */
3950 if (warn_larger_than
3951 && (TREE_CODE (decl) == VAR_DECL || TREE_CODE (decl) == PARM_DECL)
3952 && !DECL_EXTERNAL (decl))
3954 register tree decl_size = DECL_SIZE (decl);
3956 if (decl_size && TREE_CODE (decl_size) == INTEGER_CST)
3958 unsigned units = TREE_INT_CST_LOW(decl_size) / BITS_PER_UNIT;
3960 if (units > larger_than_size)
3961 warning_with_decl (decl, "size of `%s' is %u bytes", units);
3966 /* Resume permanent allocation, if not within a function. */
3967 /* The corresponding push_obstacks_nochange is in start_decl,
3968 and in push_parm_decl and in grokfield. */
3972 /* If we have gone back from temporary to permanent allocation,
3973 actually free the temporary space that we no longer need. */
3974 if (temporary && !allocation_temporary_p ())
3975 permanent_allocation (0);
3977 /* At the end of a declaration, throw away any variable type sizes
3978 of types defined inside that declaration. There is no use
3979 computing them in the following function definition. */
3980 if (current_binding_level == global_binding_level)
3981 get_pending_sizes ();
3984 /* If DECL has a cleanup, build and return that cleanup here.
3985 This is a callback called by expand_expr. */
3988 maybe_build_cleanup (decl)
3991 /* There are no cleanups in C. */
3995 /* Given a parsed parameter declaration,
3996 decode it into a PARM_DECL and push that on the current binding level.
3997 Also, for the sake of forward parm decls,
3998 record the given order of parms in `parm_order'. */
4001 push_parm_decl (parm)
4005 int old_immediate_size_expand = immediate_size_expand;
4006 /* Don't try computing parm sizes now -- wait till fn is called. */
4007 immediate_size_expand = 0;
4009 /* The corresponding pop_obstacks is in finish_decl. */
4010 push_obstacks_nochange ();
4012 decl = grokdeclarator (TREE_VALUE (TREE_PURPOSE (parm)),
4013 TREE_PURPOSE (TREE_PURPOSE (parm)), PARM, 0);
4014 decl_attributes (decl, TREE_VALUE (TREE_VALUE (parm)),
4015 TREE_PURPOSE (TREE_VALUE (parm)));
4018 if (DECL_NAME (decl))
4021 olddecl = lookup_name (DECL_NAME (decl));
4022 if (pedantic && olddecl != 0 && TREE_CODE (olddecl) == TYPE_DECL)
4023 pedwarn_with_decl (decl, "ANSI C forbids parameter `%s' shadowing typedef");
4027 decl = pushdecl (decl);
4029 immediate_size_expand = old_immediate_size_expand;
4031 current_binding_level->parm_order
4032 = tree_cons (NULL_TREE, decl, current_binding_level->parm_order);
4034 /* Add this decl to the current binding level. */
4035 finish_decl (decl, NULL_TREE, NULL_TREE);
4038 /* Clear the given order of parms in `parm_order'.
4039 Used at start of parm list,
4040 and also at semicolon terminating forward decls. */
4045 current_binding_level->parm_order = NULL_TREE;
4048 /* Make TYPE a complete type based on INITIAL_VALUE.
4049 Return 0 if successful, 1 if INITIAL_VALUE can't be deciphered,
4050 2 if there was no information (in which case assume 1 if DO_DEFAULT). */
4053 complete_array_type (type, initial_value, do_default)
4058 register tree maxindex = NULL_TREE;
4063 /* Note MAXINDEX is really the maximum index,
4064 one less than the size. */
4065 if (TREE_CODE (initial_value) == STRING_CST)
4068 = int_size_in_bytes (TREE_TYPE (TREE_TYPE (initial_value)));
4069 maxindex = build_int_2 ((TREE_STRING_LENGTH (initial_value)
4072 else if (TREE_CODE (initial_value) == CONSTRUCTOR)
4074 tree elts = CONSTRUCTOR_ELTS (initial_value);
4075 maxindex = size_binop (MINUS_EXPR, integer_zero_node, size_one_node);
4076 for (; elts; elts = TREE_CHAIN (elts))
4078 if (TREE_PURPOSE (elts))
4079 maxindex = TREE_PURPOSE (elts);
4081 maxindex = size_binop (PLUS_EXPR, maxindex, size_one_node);
4083 maxindex = copy_node (maxindex);
4087 /* Make an error message unless that happened already. */
4088 if (initial_value != error_mark_node)
4091 /* Prevent further error messages. */
4092 maxindex = build_int_2 (0, 0);
4099 maxindex = build_int_2 (0, 0);
4105 TYPE_DOMAIN (type) = build_index_type (maxindex);
4106 if (!TREE_TYPE (maxindex))
4107 TREE_TYPE (maxindex) = TYPE_DOMAIN (type);
4110 /* Lay out the type now that we can get the real answer. */
4117 /* Given declspecs and a declarator,
4118 determine the name and type of the object declared
4119 and construct a ..._DECL node for it.
4120 (In one case we can return a ..._TYPE node instead.
4121 For invalid input we sometimes return 0.)
4123 DECLSPECS is a chain of tree_list nodes whose value fields
4124 are the storage classes and type specifiers.
4126 DECL_CONTEXT says which syntactic context this declaration is in:
4127 NORMAL for most contexts. Make a VAR_DECL or FUNCTION_DECL or TYPE_DECL.
4128 FUNCDEF for a function definition. Like NORMAL but a few different
4129 error messages in each case. Return value may be zero meaning
4130 this definition is too screwy to try to parse.
4131 PARM for a parameter declaration (either within a function prototype
4132 or before a function body). Make a PARM_DECL, or return void_type_node.
4133 TYPENAME if for a typename (in a cast or sizeof).
4134 Don't make a DECL node; just return the ..._TYPE node.
4135 FIELD for a struct or union field; make a FIELD_DECL.
4136 BITFIELD for a field with specified width.
4137 INITIALIZED is 1 if the decl has an initializer.
4139 In the TYPENAME case, DECLARATOR is really an absolute declarator.
4140 It may also be so in the PARM case, for a prototype where the
4141 argument type is specified but not the name.
4143 This function is where the complicated C meanings of `static'
4144 and `extern' are interpreted. */
4147 grokdeclarator (declarator, declspecs, decl_context, initialized)
4150 enum decl_context decl_context;
4155 tree type = NULL_TREE;
4160 int explicit_int = 0;
4161 int explicit_char = 0;
4162 int defaulted_int = 0;
4163 tree typedef_decl = 0;
4165 tree typedef_type = 0;
4166 int funcdef_flag = 0;
4167 enum tree_code innermost_code = ERROR_MARK;
4169 int size_varies = 0;
4170 tree decl_machine_attr = NULL_TREE;
4172 if (decl_context == BITFIELD)
4173 bitfield = 1, decl_context = FIELD;
4175 if (decl_context == FUNCDEF)
4176 funcdef_flag = 1, decl_context = NORMAL;
4178 push_obstacks_nochange ();
4180 if (flag_traditional && allocation_temporary_p ())
4181 end_temporary_allocation ();
4183 /* Look inside a declarator for the name being declared
4184 and get it as a string, for an error message. */
4186 register tree decl = declarator;
4190 switch (TREE_CODE (decl))
4195 innermost_code = TREE_CODE (decl);
4196 decl = TREE_OPERAND (decl, 0);
4199 case IDENTIFIER_NODE:
4200 name = IDENTIFIER_POINTER (decl);
4211 /* A function definition's declarator must have the form of
4212 a function declarator. */
4214 if (funcdef_flag && innermost_code != CALL_EXPR)
4217 /* Anything declared one level down from the top level
4218 must be one of the parameters of a function
4219 (because the body is at least two levels down). */
4221 /* If this looks like a function definition, make it one,
4222 even if it occurs where parms are expected.
4223 Then store_parm_decls will reject it and not use it as a parm. */
4224 if (decl_context == NORMAL && !funcdef_flag
4225 && current_binding_level->parm_flag)
4226 decl_context = PARM;
4228 /* Look through the decl specs and record which ones appear.
4229 Some typespecs are defined as built-in typenames.
4230 Others, the ones that are modifiers of other types,
4231 are represented by bits in SPECBITS: set the bits for
4232 the modifiers that appear. Storage class keywords are also in SPECBITS.
4234 If there is a typedef name or a type, store the type in TYPE.
4235 This includes builtin typedefs such as `int'.
4237 Set EXPLICIT_INT or EXPLICIT_CHAR if the type is `int' or `char'
4238 and did not come from a user typedef.
4240 Set LONGLONG if `long' is mentioned twice. */
4242 for (spec = declspecs; spec; spec = TREE_CHAIN (spec))
4245 register tree id = TREE_VALUE (spec);
4247 if (id == ridpointers[(int) RID_INT])
4249 if (id == ridpointers[(int) RID_CHAR])
4252 if (TREE_CODE (id) == IDENTIFIER_NODE)
4253 for (i = (int) RID_FIRST_MODIFIER; i < (int) RID_MAX; i++)
4255 if (ridpointers[i] == id)
4257 if (i == (int) RID_LONG && specbits & (1<<i))
4260 error ("`long long long' is too long for GCC");
4263 if (pedantic && ! in_system_header)
4264 pedwarn ("ANSI C does not support `long long'");
4268 else if (specbits & (1 << i))
4269 pedwarn ("duplicate `%s'", IDENTIFIER_POINTER (id));
4275 error ("two or more data types in declaration of `%s'", name);
4276 /* Actual typedefs come to us as TYPE_DECL nodes. */
4277 else if (TREE_CODE (id) == TYPE_DECL)
4279 type = TREE_TYPE (id);
4280 decl_machine_attr = DECL_MACHINE_ATTRIBUTES (id);
4283 /* Built-in types come as identifiers. */
4284 else if (TREE_CODE (id) == IDENTIFIER_NODE)
4286 register tree t = lookup_name (id);
4287 if (TREE_TYPE (t) == error_mark_node)
4289 else if (!t || TREE_CODE (t) != TYPE_DECL)
4290 error ("`%s' fails to be a typedef or built in type",
4291 IDENTIFIER_POINTER (id));
4294 type = TREE_TYPE (t);
4298 else if (TREE_CODE (id) != ERROR_MARK)
4304 typedef_type = type;
4306 size_varies = C_TYPE_VARIABLE_SIZE (type);
4308 /* No type at all: default to `int', and set DEFAULTED_INT
4309 because it was not a user-defined typedef. */
4313 if (! (specbits & ((1 << (int) RID_LONG) | (1 << (int) RID_SHORT)
4314 | (1 << (int) RID_SIGNED)
4315 | (1 << (int) RID_UNSIGNED))))
4317 /* C9x will probably require a diagnostic here.
4318 For now, issue a warning if -Wreturn-type and this is a function,
4319 or if -Wimplicit; prefer the former warning since it is more
4321 if ((warn_implicit || warn_return_type) && funcdef_flag)
4322 warn_about_return_type = 1;
4323 else if (warn_implicit)
4324 warning ("type defaults to `int' in declaration of `%s'", name);
4328 type = integer_type_node;
4331 /* Now process the modifiers that were specified
4332 and check for invalid combinations. */
4334 /* Long double is a special combination. */
4336 if ((specbits & 1 << (int) RID_LONG)
4337 && TYPE_MAIN_VARIANT (type) == double_type_node)
4339 specbits &= ~ (1 << (int) RID_LONG);
4340 type = long_double_type_node;
4343 /* Check all other uses of type modifiers. */
4345 if (specbits & ((1 << (int) RID_LONG) | (1 << (int) RID_SHORT)
4346 | (1 << (int) RID_UNSIGNED) | (1 << (int) RID_SIGNED)))
4350 if (TREE_CODE (type) != INTEGER_TYPE)
4351 error ("long, short, signed or unsigned invalid for `%s'", name);
4352 else if ((specbits & 1 << (int) RID_LONG)
4353 && (specbits & 1 << (int) RID_SHORT))
4354 error ("long and short specified together for `%s'", name);
4355 else if (((specbits & 1 << (int) RID_LONG)
4356 || (specbits & 1 << (int) RID_SHORT))
4358 error ("long or short specified with char for `%s'", name);
4359 else if (((specbits & 1 << (int) RID_LONG)
4360 || (specbits & 1 << (int) RID_SHORT))
4361 && TREE_CODE (type) == REAL_TYPE)
4362 error ("long or short specified with floating type for `%s'", name);
4363 else if ((specbits & 1 << (int) RID_SIGNED)
4364 && (specbits & 1 << (int) RID_UNSIGNED))
4365 error ("signed and unsigned given together for `%s'", name);
4369 if (!explicit_int && !defaulted_int && !explicit_char && pedantic)
4371 pedwarn ("long, short, signed or unsigned used invalidly for `%s'",
4373 if (flag_pedantic_errors)
4378 /* Discard the type modifiers if they are invalid. */
4381 specbits &= ~((1 << (int) RID_LONG) | (1 << (int) RID_SHORT)
4382 | (1 << (int) RID_UNSIGNED) | (1 << (int) RID_SIGNED));
4387 if ((specbits & (1 << (int) RID_COMPLEX))
4388 && TREE_CODE (type) != INTEGER_TYPE && TREE_CODE (type) != REAL_TYPE)
4390 error ("complex invalid for `%s'", name);
4391 specbits &= ~ (1 << (int) RID_COMPLEX);
4394 /* Decide whether an integer type is signed or not.
4395 Optionally treat bitfields as signed by default. */
4396 if (specbits & 1 << (int) RID_UNSIGNED
4397 /* Traditionally, all bitfields are unsigned. */
4398 || (bitfield && flag_traditional
4399 && (! explicit_flag_signed_bitfields || !flag_signed_bitfields))
4400 || (bitfield && ! flag_signed_bitfields
4401 && (explicit_int || defaulted_int || explicit_char
4402 /* A typedef for plain `int' without `signed'
4403 can be controlled just like plain `int'. */
4404 || ! (typedef_decl != 0
4405 && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl)))
4406 && TREE_CODE (type) != ENUMERAL_TYPE
4407 && !(specbits & 1 << (int) RID_SIGNED)))
4410 type = long_long_unsigned_type_node;
4411 else if (specbits & 1 << (int) RID_LONG)
4412 type = long_unsigned_type_node;
4413 else if (specbits & 1 << (int) RID_SHORT)
4414 type = short_unsigned_type_node;
4415 else if (type == char_type_node)
4416 type = unsigned_char_type_node;
4417 else if (typedef_decl)
4418 type = unsigned_type (type);
4420 type = unsigned_type_node;
4422 else if ((specbits & 1 << (int) RID_SIGNED)
4423 && type == char_type_node)
4424 type = signed_char_type_node;
4426 type = long_long_integer_type_node;
4427 else if (specbits & 1 << (int) RID_LONG)
4428 type = long_integer_type_node;
4429 else if (specbits & 1 << (int) RID_SHORT)
4430 type = short_integer_type_node;
4432 if (specbits & 1 << (int) RID_COMPLEX)
4434 /* If we just have "complex", it is equivalent to
4435 "complex double", but if any modifiers at all are specified it is
4436 the complex form of TYPE. E.g, "complex short" is
4437 "complex short int". */
4439 if (defaulted_int && ! longlong
4440 && ! (specbits & ((1 << (int) RID_LONG) | (1 << (int) RID_SHORT)
4441 | (1 << (int) RID_SIGNED)
4442 | (1 << (int) RID_UNSIGNED))))
4443 type = complex_double_type_node;
4444 else if (type == integer_type_node)
4445 type = complex_integer_type_node;
4446 else if (type == float_type_node)
4447 type = complex_float_type_node;
4448 else if (type == double_type_node)
4449 type = complex_double_type_node;
4450 else if (type == long_double_type_node)
4451 type = complex_long_double_type_node;
4453 type = build_complex_type (type);
4456 /* Set CONSTP if this declaration is `const', whether by
4457 explicit specification or via a typedef.
4458 Likewise for VOLATILEP. */
4460 constp = !! (specbits & 1 << (int) RID_CONST) + TYPE_READONLY (type);
4461 volatilep = !! (specbits & 1 << (int) RID_VOLATILE) + TYPE_VOLATILE (type);
4462 inlinep = !! (specbits & (1 << (int) RID_INLINE));
4464 pedwarn ("duplicate `const'");
4466 pedwarn ("duplicate `volatile'");
4467 if (! flag_gen_aux_info && (TYPE_READONLY (type) || TYPE_VOLATILE (type)))
4468 type = TYPE_MAIN_VARIANT (type);
4470 /* Warn if two storage classes are given. Default to `auto'. */
4475 if (specbits & 1 << (int) RID_AUTO) nclasses++;
4476 if (specbits & 1 << (int) RID_STATIC) nclasses++;
4477 if (specbits & 1 << (int) RID_EXTERN) nclasses++;
4478 if (specbits & 1 << (int) RID_REGISTER) nclasses++;
4479 if (specbits & 1 << (int) RID_TYPEDEF) nclasses++;
4480 if (specbits & 1 << (int) RID_ITERATOR) nclasses++;
4482 /* Warn about storage classes that are invalid for certain
4483 kinds of declarations (parameters, typenames, etc.). */
4486 error ("multiple storage classes in declaration of `%s'", name);
4487 else if (funcdef_flag
4489 & ((1 << (int) RID_REGISTER)
4490 | (1 << (int) RID_AUTO)
4491 | (1 << (int) RID_TYPEDEF))))
4493 if (specbits & 1 << (int) RID_AUTO
4494 && (pedantic || current_binding_level == global_binding_level))
4495 pedwarn ("function definition declared `auto'");
4496 if (specbits & 1 << (int) RID_REGISTER)
4497 error ("function definition declared `register'");
4498 if (specbits & 1 << (int) RID_TYPEDEF)
4499 error ("function definition declared `typedef'");
4500 specbits &= ~ ((1 << (int) RID_TYPEDEF) | (1 << (int) RID_REGISTER)
4501 | (1 << (int) RID_AUTO));
4503 else if (decl_context != NORMAL && nclasses > 0)
4505 if (decl_context == PARM && specbits & 1 << (int) RID_REGISTER)
4509 error ((decl_context == FIELD
4510 ? "storage class specified for structure field `%s'"
4511 : (decl_context == PARM
4512 ? "storage class specified for parameter `%s'"
4513 : "storage class specified for typename")),
4515 specbits &= ~ ((1 << (int) RID_TYPEDEF) | (1 << (int) RID_REGISTER)
4516 | (1 << (int) RID_AUTO) | (1 << (int) RID_STATIC)
4517 | (1 << (int) RID_EXTERN));
4520 else if (specbits & 1 << (int) RID_EXTERN && initialized && ! funcdef_flag)
4522 /* `extern' with initialization is invalid if not at top level. */
4523 if (current_binding_level == global_binding_level)
4524 warning ("`%s' initialized and declared `extern'", name);
4526 error ("`%s' has both `extern' and initializer", name);
4528 else if (specbits & 1 << (int) RID_EXTERN && funcdef_flag
4529 && current_binding_level != global_binding_level)
4530 error ("nested function `%s' declared `extern'", name);
4531 else if (current_binding_level == global_binding_level
4532 && specbits & (1 << (int) RID_AUTO))
4533 error ("top-level declaration of `%s' specifies `auto'", name);
4534 else if ((specbits & 1 << (int) RID_ITERATOR)
4535 && TREE_CODE (declarator) != IDENTIFIER_NODE)
4537 error ("iterator `%s' has derived type", name);
4538 type = error_mark_node;
4540 else if ((specbits & 1 << (int) RID_ITERATOR)
4541 && TREE_CODE (type) != INTEGER_TYPE)
4543 error ("iterator `%s' has noninteger type", name);
4544 type = error_mark_node;
4548 /* Now figure out the structure of the declarator proper.
4549 Descend through it, creating more complex types, until we reach
4550 the declared identifier (or NULL_TREE, in an absolute declarator). */
4552 while (declarator && TREE_CODE (declarator) != IDENTIFIER_NODE)
4554 if (type == error_mark_node)
4556 declarator = TREE_OPERAND (declarator, 0);
4560 /* Each level of DECLARATOR is either an ARRAY_REF (for ...[..]),
4561 an INDIRECT_REF (for *...),
4562 a CALL_EXPR (for ...(...)),
4563 an identifier (for the name being declared)
4564 or a null pointer (for the place in an absolute declarator
4565 where the name was omitted).
4566 For the last two cases, we have just exited the loop.
4568 At this point, TYPE is the type of elements of an array,
4569 or for a function to return, or for a pointer to point to.
4570 After this sequence of ifs, TYPE is the type of the
4571 array or function or pointer, and DECLARATOR has had its
4572 outermost layer removed. */
4574 if (TREE_CODE (declarator) == ARRAY_REF)
4576 register tree itype = NULL_TREE;
4577 register tree size = TREE_OPERAND (declarator, 1);
4578 /* An uninitialized decl with `extern' is a reference. */
4579 int extern_ref = !initialized && (specbits & (1 << (int) RID_EXTERN));
4580 /* The index is a signed object `sizetype' bits wide. */
4581 tree index_type = signed_type (sizetype);
4583 declarator = TREE_OPERAND (declarator, 0);
4585 /* Check for some types that there cannot be arrays of. */
4587 if (TYPE_MAIN_VARIANT (type) == void_type_node)
4589 error ("declaration of `%s' as array of voids", name);
4590 type = error_mark_node;
4593 if (TREE_CODE (type) == FUNCTION_TYPE)
4595 error ("declaration of `%s' as array of functions", name);
4596 type = error_mark_node;
4599 if (size == error_mark_node)
4600 type = error_mark_node;
4602 if (type == error_mark_node)
4605 /* If this is a block level extern, it must live past the end
4606 of the function so that we can check it against other extern
4607 declarations (IDENTIFIER_LIMBO_VALUE). */
4608 if (extern_ref && allocation_temporary_p ())
4609 end_temporary_allocation ();
4611 /* If size was specified, set ITYPE to a range-type for that size.
4612 Otherwise, ITYPE remains null. finish_decl may figure it out
4613 from an initial value. */
4617 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue. */
4618 STRIP_TYPE_NOPS (size);
4620 if (TREE_CODE (TREE_TYPE (size)) != INTEGER_TYPE
4621 && TREE_CODE (TREE_TYPE (size)) != ENUMERAL_TYPE)
4623 error ("size of array `%s' has non-integer type", name);
4624 size = integer_one_node;
4627 if (pedantic && integer_zerop (size))
4628 pedwarn ("ANSI C forbids zero-size array `%s'", name);
4630 if (TREE_CODE (size) == INTEGER_CST)
4632 constant_expression_warning (size);
4633 if (tree_int_cst_sgn (size) < 0)
4635 error ("size of array `%s' is negative", name);
4636 size = integer_one_node;
4641 /* Make sure the array size remains visibly nonconstant
4642 even if it is (eg) a const variable with known value. */
4647 if (TREE_CONSTANT (size))
4648 pedwarn ("ANSI C forbids array `%s' whose size can't be evaluated", name);
4650 pedwarn ("ANSI C forbids variable-size array `%s'", name);
4654 /* Convert size to index_type, so that if it is a variable
4655 the computations will be done in the proper mode. */
4656 itype = fold (build (MINUS_EXPR, index_type,
4657 convert (index_type, size),
4658 convert (index_type, size_one_node)));
4661 itype = variable_size (itype);
4662 itype = build_index_type (itype);
4665 #if 0 /* This had bad results for pointers to arrays, as in
4666 union incomplete (*foo)[4]; */
4667 /* Complain about arrays of incomplete types, except in typedefs. */
4669 if (TYPE_SIZE (type) == 0
4670 /* Avoid multiple warnings for nested array types. */
4671 && TREE_CODE (type) != ARRAY_TYPE
4672 && !(specbits & (1 << (int) RID_TYPEDEF))
4673 && !C_TYPE_BEING_DEFINED (type))
4674 warning ("array type has incomplete element type");
4677 #if 0 /* We shouldn't have a function type here at all!
4678 Functions aren't allowed as array elements. */
4679 if (pedantic && TREE_CODE (type) == FUNCTION_TYPE
4680 && (constp || volatilep))
4681 pedwarn ("ANSI C forbids const or volatile function types");
4684 /* Build the array type itself, then merge any constancy or
4685 volatility into the target type. We must do it in this order
4686 to ensure that the TYPE_MAIN_VARIANT field of the array type
4687 is set correctly. */
4689 type = build_array_type (type, itype);
4690 if (constp || volatilep)
4691 type = c_build_type_variant (type, constp, volatilep);
4693 #if 0 /* don't clear these; leave them set so that the array type
4694 or the variable is itself const or volatile. */
4700 C_TYPE_VARIABLE_SIZE (type) = 1;
4702 else if (TREE_CODE (declarator) == CALL_EXPR)
4704 int extern_ref = (!(specbits & (1 << (int) RID_AUTO))
4705 || current_binding_level == global_binding_level);
4708 /* Declaring a function type.
4709 Make sure we have a valid type for the function to return. */
4710 if (type == error_mark_node)
4715 /* Warn about some types functions can't return. */
4717 if (TREE_CODE (type) == FUNCTION_TYPE)
4719 error ("`%s' declared as function returning a function", name);
4720 type = integer_type_node;
4722 if (TREE_CODE (type) == ARRAY_TYPE)
4724 error ("`%s' declared as function returning an array", name);
4725 type = integer_type_node;
4728 #ifndef TRADITIONAL_RETURN_FLOAT
4729 /* Traditionally, declaring return type float means double. */
4731 if (flag_traditional && TYPE_MAIN_VARIANT (type) == float_type_node)
4732 type = double_type_node;
4733 #endif /* TRADITIONAL_RETURN_FLOAT */
4735 /* If this is a block level extern, it must live past the end
4736 of the function so that we can check it against other extern
4737 declarations (IDENTIFIER_LIMBO_VALUE). */
4738 if (extern_ref && allocation_temporary_p ())
4739 end_temporary_allocation ();
4741 /* Construct the function type and go to the next
4742 inner layer of declarator. */
4744 arg_types = grokparms (TREE_OPERAND (declarator, 1),
4746 /* Say it's a definition
4747 only for the CALL_EXPR
4748 closest to the identifier. */
4749 && TREE_CODE (TREE_OPERAND (declarator, 0)) == IDENTIFIER_NODE);
4750 #if 0 /* This seems to be false. We turn off temporary allocation
4751 above in this function if -traditional.
4752 And this code caused inconsistent results with prototypes:
4753 callers would ignore them, and pass arguments wrong. */
4755 /* Omit the arg types if -traditional, since the arg types
4756 and the list links might not be permanent. */
4757 type = build_function_type (type,
4759 ? NULL_TREE : arg_types);
4761 /* ANSI seems to say that `const int foo ();'
4762 does not make the function foo const. */
4763 if (constp || volatilep)
4764 type = c_build_type_variant (type, constp, volatilep);
4768 type = build_function_type (type, arg_types);
4769 declarator = TREE_OPERAND (declarator, 0);
4771 /* Set the TYPE_CONTEXTs for each tagged type which is local to
4772 the formal parameter list of this FUNCTION_TYPE to point to
4773 the FUNCTION_TYPE node itself. */
4778 for (link = current_function_parm_tags;
4780 link = TREE_CHAIN (link))
4781 TYPE_CONTEXT (TREE_VALUE (link)) = type;
4784 else if (TREE_CODE (declarator) == INDIRECT_REF)
4786 /* Merge any constancy or volatility into the target type
4789 if (pedantic && TREE_CODE (type) == FUNCTION_TYPE
4790 && (constp || volatilep))
4791 pedwarn ("ANSI C forbids const or volatile function types");
4792 if (constp || volatilep)
4793 type = c_build_type_variant (type, constp, volatilep);
4798 type = build_pointer_type (type);
4800 /* Process a list of type modifier keywords
4801 (such as const or volatile) that were given inside the `*'. */
4803 if (TREE_TYPE (declarator))
4805 register tree typemodlist;
4807 for (typemodlist = TREE_TYPE (declarator); typemodlist;
4808 typemodlist = TREE_CHAIN (typemodlist))
4810 if (TREE_VALUE (typemodlist) == ridpointers[(int) RID_CONST])
4812 else if (TREE_VALUE (typemodlist) == ridpointers[(int) RID_VOLATILE])
4817 error ("invalid type modifier within pointer declarator");
4821 pedwarn ("duplicate `const'");
4823 pedwarn ("duplicate `volatile'");
4826 declarator = TREE_OPERAND (declarator, 0);
4833 /* Now TYPE has the actual type. */
4835 /* If this is declaring a typedef name, return a TYPE_DECL. */
4837 if (specbits & (1 << (int) RID_TYPEDEF))
4840 /* Note that the grammar rejects storage classes
4841 in typenames, fields or parameters */
4842 if (pedantic && TREE_CODE (type) == FUNCTION_TYPE
4843 && (constp || volatilep))
4844 pedwarn ("ANSI C forbids const or volatile function types");
4845 if (constp || volatilep)
4846 type = c_build_type_variant (type, constp, volatilep);
4847 decl = build_decl (TYPE_DECL, declarator, type);
4848 if ((specbits & (1 << (int) RID_SIGNED))
4849 || (typedef_decl && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl)))
4850 C_TYPEDEF_EXPLICITLY_SIGNED (decl) = 1;
4855 /* Detect the case of an array type of unspecified size
4856 which came, as such, direct from a typedef name.
4857 We must copy the type, so that each identifier gets
4858 a distinct type, so that each identifier's size can be
4859 controlled separately by its own initializer. */
4861 if (type != 0 && typedef_type != 0
4862 && TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (typedef_type)
4863 && TREE_CODE (type) == ARRAY_TYPE && TYPE_DOMAIN (type) == 0)
4865 type = build_array_type (TREE_TYPE (type), 0);
4867 C_TYPE_VARIABLE_SIZE (type) = 1;
4870 /* If this is a type name (such as, in a cast or sizeof),
4871 compute the type and return it now. */
4873 if (decl_context == TYPENAME)
4875 /* Note that the grammar rejects storage classes
4876 in typenames, fields or parameters */
4877 if (pedantic && TREE_CODE (type) == FUNCTION_TYPE
4878 && (constp || volatilep))
4879 pedwarn ("ANSI C forbids const or volatile function types");
4880 if (constp || volatilep)
4881 type = c_build_type_variant (type, constp, volatilep);
4886 /* Aside from typedefs and type names (handle above),
4887 `void' at top level (not within pointer)
4888 is allowed only in public variables.
4889 We don't complain about parms either, but that is because
4890 a better error message can be made later. */
4892 if (TYPE_MAIN_VARIANT (type) == void_type_node && decl_context != PARM
4893 && ! ((decl_context != FIELD && TREE_CODE (type) != FUNCTION_TYPE)
4894 && ((specbits & (1 << (int) RID_EXTERN))
4895 || (current_binding_level == global_binding_level
4897 & ((1 << (int) RID_STATIC) | (1 << (int) RID_REGISTER)))))))
4899 error ("variable or field `%s' declared void", name);
4900 type = integer_type_node;
4903 /* Now create the decl, which may be a VAR_DECL, a PARM_DECL
4904 or a FUNCTION_DECL, depending on DECL_CONTEXT and TYPE. */
4909 if (decl_context == PARM)
4911 tree type_as_written = type;
4914 /* A parameter declared as an array of T is really a pointer to T.
4915 One declared as a function is really a pointer to a function. */
4917 if (TREE_CODE (type) == ARRAY_TYPE)
4919 /* Transfer const-ness of array into that of type pointed to. */
4920 type = TREE_TYPE (type);
4921 if (constp || volatilep)
4922 type = c_build_type_variant (type, constp, volatilep);
4923 type = build_pointer_type (type);
4924 volatilep = constp = 0;
4927 else if (TREE_CODE (type) == FUNCTION_TYPE)
4929 if (pedantic && (constp || volatilep))
4930 pedwarn ("ANSI C forbids const or volatile function types");
4931 if (constp || volatilep)
4932 type = c_build_type_variant (type, constp, volatilep);
4933 type = build_pointer_type (type);
4934 volatilep = constp = 0;
4937 decl = build_decl (PARM_DECL, declarator, type);
4939 C_DECL_VARIABLE_SIZE (decl) = 1;
4941 /* Compute the type actually passed in the parmlist,
4942 for the case where there is no prototype.
4943 (For example, shorts and chars are passed as ints.)
4944 When there is a prototype, this is overridden later. */
4946 DECL_ARG_TYPE (decl) = type;
4947 main_type = (type == error_mark_node
4949 : TYPE_MAIN_VARIANT (type));
4950 if (main_type == float_type_node)
4951 DECL_ARG_TYPE (decl) = double_type_node;
4952 /* Don't use TYPE_PRECISION to decide whether to promote,
4953 because we should convert short if it's the same size as int,
4954 but we should not convert long if it's the same size as int. */
4955 else if (TREE_CODE (main_type) != ERROR_MARK
4956 && C_PROMOTING_INTEGER_TYPE_P (main_type))
4958 if (TYPE_PRECISION (type) == TYPE_PRECISION (integer_type_node)
4959 && TREE_UNSIGNED (type))
4960 DECL_ARG_TYPE (decl) = unsigned_type_node;
4962 DECL_ARG_TYPE (decl) = integer_type_node;
4965 DECL_ARG_TYPE_AS_WRITTEN (decl) = type_as_written;
4967 else if (decl_context == FIELD)
4969 /* Structure field. It may not be a function. */
4971 if (TREE_CODE (type) == FUNCTION_TYPE)
4973 error ("field `%s' declared as a function", name);
4974 type = build_pointer_type (type);
4976 else if (TREE_CODE (type) != ERROR_MARK && TYPE_SIZE (type) == 0)
4978 error ("field `%s' has incomplete type", name);
4979 type = error_mark_node;
4981 /* Move type qualifiers down to element of an array. */
4982 if (TREE_CODE (type) == ARRAY_TYPE && (constp || volatilep))
4984 type = build_array_type (c_build_type_variant (TREE_TYPE (type),
4986 TYPE_DOMAIN (type));
4987 #if 0 /* Leave the field const or volatile as well. */
4988 constp = volatilep = 0;
4991 decl = build_decl (FIELD_DECL, declarator, type);
4993 C_DECL_VARIABLE_SIZE (decl) = 1;
4995 else if (TREE_CODE (type) == FUNCTION_TYPE)
4997 /* Every function declaration is "external"
4998 except for those which are inside a function body
4999 in which `auto' is used.
5000 That is a case not specified by ANSI C,
5001 and we use it for forward declarations for nested functions. */
5002 int extern_ref = (!(specbits & (1 << (int) RID_AUTO))
5003 || current_binding_level == global_binding_level);
5005 if (specbits & (1 << (int) RID_AUTO)
5006 && (pedantic || current_binding_level == global_binding_level))
5007 pedwarn ("invalid storage class for function `%s'", name);
5008 if (specbits & (1 << (int) RID_REGISTER))
5009 error ("invalid storage class for function `%s'", name);
5010 /* Function declaration not at top level.
5011 Storage classes other than `extern' are not allowed
5012 and `extern' makes no difference. */
5013 if (current_binding_level != global_binding_level
5014 && (specbits & ((1 << (int) RID_STATIC) | (1 << (int) RID_INLINE)))
5016 pedwarn ("invalid storage class for function `%s'", name);
5018 /* If this is a block level extern, it must live past the end
5019 of the function so that we can check it against other
5020 extern declarations (IDENTIFIER_LIMBO_VALUE). */
5021 if (extern_ref && allocation_temporary_p ())
5022 end_temporary_allocation ();
5024 decl = build_decl (FUNCTION_DECL, declarator, type);
5025 decl = build_decl_attribute_variant (decl, decl_machine_attr);
5027 if (pedantic && (constp || volatilep)
5028 && ! DECL_IN_SYSTEM_HEADER (decl))
5029 pedwarn ("ANSI C forbids const or volatile functions");
5032 && TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (decl))) == void_type_node
5033 && (TYPE_READONLY (TREE_TYPE (TREE_TYPE (decl)))
5034 || TYPE_VOLATILE (TREE_TYPE (TREE_TYPE (decl))))
5035 && ! DECL_IN_SYSTEM_HEADER (decl))
5036 pedwarn ("ANSI C forbids const or volatile void function return type");
5039 && TREE_TYPE (TREE_TYPE (decl)) != void_type_node)
5040 warning ("`noreturn' function returns non-void value");
5043 DECL_EXTERNAL (decl) = 1;
5044 /* Record absence of global scope for `static' or `auto'. */
5046 = !(specbits & ((1 << (int) RID_STATIC) | (1 << (int) RID_AUTO)));
5048 /* Record presence of `inline', if it is reasonable. */
5051 tree last = tree_last (TYPE_ARG_TYPES (type));
5053 if (! strcmp (IDENTIFIER_POINTER (declarator), "main"))
5054 warning ("cannot inline function `main'");
5055 else if (last && (TYPE_MAIN_VARIANT (TREE_VALUE (last))
5057 warning ("inline declaration ignored for function with `...'");
5059 /* Assume that otherwise the function can be inlined. */
5060 DECL_INLINE (decl) = 1;
5062 if (specbits & (1 << (int) RID_EXTERN))
5063 current_extern_inline = 1;
5068 /* It's a variable. */
5069 /* An uninitialized decl with `extern' is a reference. */
5070 int extern_ref = !initialized && (specbits & (1 << (int) RID_EXTERN));
5072 /* Move type qualifiers down to element of an array. */
5073 if (TREE_CODE (type) == ARRAY_TYPE && (constp || volatilep))
5075 type = build_array_type (c_build_type_variant (TREE_TYPE (type),
5077 TYPE_DOMAIN (type));
5078 #if 0 /* Leave the variable const or volatile as well. */
5079 constp = volatilep = 0;
5083 /* If this is a block level extern, it must live past the end
5084 of the function so that we can check it against other
5085 extern declarations (IDENTIFIER_LIMBO_VALUE). */
5086 if (extern_ref && allocation_temporary_p ())
5087 end_temporary_allocation ();
5089 decl = build_decl (VAR_DECL, declarator, type);
5091 C_DECL_VARIABLE_SIZE (decl) = 1;
5094 pedwarn_with_decl (decl, "variable `%s' declared `inline'");
5096 DECL_EXTERNAL (decl) = extern_ref;
5097 /* At top level, the presence of a `static' or `register' storage
5098 class specifier, or the absence of all storage class specifiers
5099 makes this declaration a definition (perhaps tentative). Also,
5100 the absence of both `static' and `register' makes it public. */
5101 if (current_binding_level == global_binding_level)
5105 & ((1 << (int) RID_STATIC) | (1 << (int) RID_REGISTER)));
5106 TREE_STATIC (decl) = ! DECL_EXTERNAL (decl);
5108 /* Not at top level, only `static' makes a static definition. */
5111 TREE_STATIC (decl) = (specbits & (1 << (int) RID_STATIC)) != 0;
5112 TREE_PUBLIC (decl) = DECL_EXTERNAL (decl);
5115 if (specbits & 1 << (int) RID_ITERATOR)
5116 ITERATOR_P (decl) = 1;
5119 /* Record `register' declaration for warnings on &
5120 and in case doing stupid register allocation. */
5122 if (specbits & (1 << (int) RID_REGISTER))
5123 DECL_REGISTER (decl) = 1;
5125 /* Record constancy and volatility. */
5128 TREE_READONLY (decl) = 1;
5131 TREE_SIDE_EFFECTS (decl) = 1;
5132 TREE_THIS_VOLATILE (decl) = 1;
5134 /* If a type has volatile components, it should be stored in memory.
5135 Otherwise, the fact that those components are volatile
5136 will be ignored, and would even crash the compiler. */
5137 if (C_TYPE_FIELDS_VOLATILE (TREE_TYPE (decl)))
5138 mark_addressable (decl);
5146 /* Decode the parameter-list info for a function type or function definition.
5147 The argument is the value returned by `get_parm_info' (or made in parse.y
5148 if there is an identifier list instead of a parameter decl list).
5149 These two functions are separate because when a function returns
5150 or receives functions then each is called multiple times but the order
5151 of calls is different. The last call to `grokparms' is always the one
5152 that contains the formal parameter names of a function definition.
5154 Store in `last_function_parms' a chain of the decls of parms.
5155 Also store in `last_function_parm_tags' a chain of the struct, union,
5156 and enum tags declared among the parms.
5158 Return a list of arg types to use in the FUNCTION_TYPE for this function.
5160 FUNCDEF_FLAG is nonzero for a function definition, 0 for
5161 a mere declaration. A nonempty identifier-list gets an error message
5162 when FUNCDEF_FLAG is zero. */
5165 grokparms (parms_info, funcdef_flag)
5169 tree first_parm = TREE_CHAIN (parms_info);
5171 last_function_parms = TREE_PURPOSE (parms_info);
5172 last_function_parm_tags = TREE_VALUE (parms_info);
5174 if (warn_strict_prototypes && first_parm == 0 && !funcdef_flag
5175 && !in_system_header)
5176 warning ("function declaration isn't a prototype");
5179 && TREE_CODE (TREE_VALUE (first_parm)) == IDENTIFIER_NODE)
5182 pedwarn ("parameter names (without types) in function declaration");
5184 last_function_parms = first_parm;
5191 /* We no longer test FUNCDEF_FLAG.
5192 If the arg types are incomplete in a declaration,
5193 they must include undefined tags.
5194 These tags can never be defined in the scope of the declaration,
5195 so the types can never be completed,
5196 and no call can be compiled successfully. */
5198 /* In a fcn definition, arg types must be complete. */
5201 for (parm = last_function_parms, typelt = first_parm;
5203 parm = TREE_CHAIN (parm))
5204 /* Skip over any enumeration constants declared here. */
5205 if (TREE_CODE (parm) == PARM_DECL)
5207 /* Barf if the parameter itself has an incomplete type. */
5208 tree type = TREE_VALUE (typelt);
5209 if (TYPE_SIZE (type) == 0)
5211 if (funcdef_flag && DECL_NAME (parm) != 0)
5212 error ("parameter `%s' has incomplete type",
5213 IDENTIFIER_POINTER (DECL_NAME (parm)));
5215 warning ("parameter has incomplete type");
5218 TREE_VALUE (typelt) = error_mark_node;
5219 TREE_TYPE (parm) = error_mark_node;
5222 #if 0 /* This has been replaced by parm_tags_warning
5223 which uses a more accurate criterion for what to warn about. */
5226 /* Now warn if is a pointer to an incomplete type. */
5227 while (TREE_CODE (type) == POINTER_TYPE
5228 || TREE_CODE (type) == REFERENCE_TYPE)
5229 type = TREE_TYPE (type);
5230 type = TYPE_MAIN_VARIANT (type);
5231 if (TYPE_SIZE (type) == 0)
5233 if (DECL_NAME (parm) != 0)
5234 warning ("parameter `%s' points to incomplete type",
5235 IDENTIFIER_POINTER (DECL_NAME (parm)));
5237 warning ("parameter points to incomplete type");
5241 typelt = TREE_CHAIN (typelt);
5244 /* Allocate the list of types the way we allocate a type. */
5245 if (first_parm && ! TREE_PERMANENT (first_parm))
5247 /* Construct a copy of the list of types
5248 on the saveable obstack. */
5250 for (typelt = first_parm; typelt; typelt = TREE_CHAIN (typelt))
5251 result = saveable_tree_cons (NULL_TREE, TREE_VALUE (typelt),
5253 return nreverse (result);
5256 /* The list we have is permanent already. */
5262 /* Return a tree_list node with info on a parameter list just parsed.
5263 The TREE_PURPOSE is a chain of decls of those parms.
5264 The TREE_VALUE is a list of structure, union and enum tags defined.
5265 The TREE_CHAIN is a list of argument types to go in the FUNCTION_TYPE.
5266 This tree_list node is later fed to `grokparms'.
5268 VOID_AT_END nonzero means append `void' to the end of the type-list.
5269 Zero means the parmlist ended with an ellipsis so don't append `void'. */
5272 get_parm_info (void_at_end)
5275 register tree decl, t;
5276 register tree types = 0;
5278 tree tags = gettags ();
5279 tree parms = getdecls ();
5281 tree order = current_binding_level->parm_order;
5283 /* Just `void' (and no ellipsis) is special. There are really no parms. */
5284 if (void_at_end && parms != 0
5285 && TREE_CHAIN (parms) == 0
5286 && TYPE_MAIN_VARIANT (TREE_TYPE (parms)) == void_type_node
5287 && DECL_NAME (parms) == 0)
5290 storedecls (NULL_TREE);
5291 return saveable_tree_cons (NULL_TREE, NULL_TREE,
5292 saveable_tree_cons (NULL_TREE, void_type_node, NULL_TREE));
5295 /* Extract enumerator values and other non-parms declared with the parms.
5296 Likewise any forward parm decls that didn't have real parm decls. */
5297 for (decl = parms; decl; )
5299 tree next = TREE_CHAIN (decl);
5301 if (TREE_CODE (decl) != PARM_DECL)
5303 TREE_CHAIN (decl) = new_parms;
5306 else if (TREE_ASM_WRITTEN (decl))
5308 error_with_decl (decl, "parameter `%s' has just a forward declaration");
5309 TREE_CHAIN (decl) = new_parms;
5315 /* Put the parm decls back in the order they were in in the parm list. */
5316 for (t = order; t; t = TREE_CHAIN (t))
5319 TREE_CHAIN (TREE_VALUE (t)) = TREE_VALUE (TREE_CHAIN (t));
5321 TREE_CHAIN (TREE_VALUE (t)) = 0;
5324 new_parms = chainon (order ? nreverse (TREE_VALUE (order)) : 0,
5327 /* Store the parmlist in the binding level since the old one
5328 is no longer a valid list. (We have changed the chain pointers.) */
5329 storedecls (new_parms);
5331 for (decl = new_parms; decl; decl = TREE_CHAIN (decl))
5332 /* There may also be declarations for enumerators if an enumeration
5333 type is declared among the parms. Ignore them here. */
5334 if (TREE_CODE (decl) == PARM_DECL)
5336 /* Since there is a prototype,
5337 args are passed in their declared types. */
5338 tree type = TREE_TYPE (decl);
5339 DECL_ARG_TYPE (decl) = type;
5340 #ifdef PROMOTE_PROTOTYPES
5341 if ((TREE_CODE (type) == INTEGER_TYPE
5342 || TREE_CODE (type) == ENUMERAL_TYPE)
5343 && TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node))
5344 DECL_ARG_TYPE (decl) = integer_type_node;
5347 types = saveable_tree_cons (NULL_TREE, TREE_TYPE (decl), types);
5348 if (TYPE_MAIN_VARIANT (TREE_VALUE (types)) == void_type_node && ! erred
5349 && DECL_NAME (decl) == 0)
5351 error ("`void' in parameter list must be the entire list");
5357 return saveable_tree_cons (new_parms, tags,
5358 nreverse (saveable_tree_cons (NULL_TREE, void_type_node, types)));
5360 return saveable_tree_cons (new_parms, tags, nreverse (types));
5363 /* At end of parameter list, warn about any struct, union or enum tags
5364 defined within. Do so because these types cannot ever become complete. */
5367 parmlist_tags_warning ()
5372 for (elt = current_binding_level->tags; elt; elt = TREE_CHAIN (elt))
5374 enum tree_code code = TREE_CODE (TREE_VALUE (elt));
5375 /* An anonymous union parm type is meaningful as a GNU extension.
5376 So don't warn for that. */
5377 if (code == UNION_TYPE && !pedantic)
5379 if (TREE_PURPOSE (elt) != 0)
5380 warning ("`%s %s' declared inside parameter list",
5381 (code == RECORD_TYPE ? "struct"
5382 : code == UNION_TYPE ? "union"
5384 IDENTIFIER_POINTER (TREE_PURPOSE (elt)));
5386 warning ("anonymous %s declared inside parameter list",
5387 (code == RECORD_TYPE ? "struct"
5388 : code == UNION_TYPE ? "union"
5393 warning ("its scope is only this definition or declaration,");
5394 warning ("which is probably not what you want.");
5400 /* Get the struct, enum or union (CODE says which) with tag NAME.
5401 Define the tag as a forward-reference if it is not defined. */
5404 xref_tag (code, name)
5405 enum tree_code code;
5408 int temporary = allocation_temporary_p ();
5410 /* If a cross reference is requested, look up the type
5411 already defined for this tag and return it. */
5413 register tree ref = lookup_tag (code, name, current_binding_level, 0);
5414 /* Even if this is the wrong type of tag, return what we found.
5415 There will be an error message anyway, from pending_xref_error.
5416 If we create an empty xref just for an invalid use of the type,
5417 the main result is to create lots of superfluous error messages. */
5421 push_obstacks_nochange ();
5423 if (current_binding_level == global_binding_level && temporary)
5424 end_temporary_allocation ();
5426 /* If no such tag is yet defined, create a forward-reference node
5427 and record it as the "definition".
5428 When a real declaration of this type is found,
5429 the forward-reference will be altered into a real type. */
5431 ref = make_node (code);
5432 if (code == ENUMERAL_TYPE)
5434 /* (In ANSI, Enums can be referred to only if already defined.) */
5436 pedwarn ("ANSI C forbids forward references to `enum' types");
5437 /* Give the type a default layout like unsigned int
5438 to avoid crashing if it does not get defined. */
5439 TYPE_MODE (ref) = TYPE_MODE (unsigned_type_node);
5440 TYPE_ALIGN (ref) = TYPE_ALIGN (unsigned_type_node);
5441 TREE_UNSIGNED (ref) = 1;
5442 TYPE_PRECISION (ref) = TYPE_PRECISION (unsigned_type_node);
5443 TYPE_MIN_VALUE (ref) = TYPE_MIN_VALUE (unsigned_type_node);
5444 TYPE_MAX_VALUE (ref) = TYPE_MAX_VALUE (unsigned_type_node);
5447 pushtag (name, ref);
5454 /* Make sure that the tag NAME is defined *in the current binding level*
5455 at least as a forward reference.
5456 CODE says which kind of tag NAME ought to be.
5458 We also do a push_obstacks_nochange
5459 whose matching pop is in finish_struct. */
5462 start_struct (code, name)
5463 enum tree_code code;
5466 /* If there is already a tag defined at this binding level
5467 (as a forward reference), just return it. */
5469 register tree ref = 0;
5471 push_obstacks_nochange ();
5472 if (current_binding_level == global_binding_level)
5473 end_temporary_allocation ();
5476 ref = lookup_tag (code, name, current_binding_level, 1);
5477 if (ref && TREE_CODE (ref) == code)
5479 C_TYPE_BEING_DEFINED (ref) = 1;
5480 if (TYPE_FIELDS (ref))
5481 error ((code == UNION_TYPE ? "redefinition of `union %s'"
5482 : "redefinition of `struct %s'"),
5483 IDENTIFIER_POINTER (name));
5488 /* Otherwise create a forward-reference just so the tag is in scope. */
5490 ref = make_node (code);
5491 pushtag (name, ref);
5492 C_TYPE_BEING_DEFINED (ref) = 1;
5493 TYPE_PACKED (ref) = flag_pack_struct;
5497 /* Process the specs, declarator (NULL if omitted) and width (NULL if omitted)
5498 of a structure component, returning a FIELD_DECL node.
5499 WIDTH is non-NULL for bit fields only, and is an INTEGER_CST node.
5501 This is done during the parsing of the struct declaration.
5502 The FIELD_DECL nodes are chained together and the lot of them
5503 are ultimately passed to `build_struct' to make the RECORD_TYPE node. */
5506 grokfield (filename, line, declarator, declspecs, width)
5509 tree declarator, declspecs, width;
5513 /* The corresponding pop_obstacks is in finish_decl. */
5514 push_obstacks_nochange ();
5516 value = grokdeclarator (declarator, declspecs, width ? BITFIELD : FIELD, 0);
5518 finish_decl (value, NULL_TREE, NULL_TREE);
5519 DECL_INITIAL (value) = width;
5521 maybe_objc_check_decl (value);
5525 /* Function to help qsort sort FIELD_DECLs by name order. */
5528 field_decl_cmp (xp, yp)
5529 const GENERIC_PTR xp;
5530 const GENERIC_PTR yp;
5532 tree *x = (tree *)xp, *y = (tree *)yp;
5534 if (DECL_NAME (*x) == DECL_NAME (*y))
5536 if (DECL_NAME (*x) == NULL)
5538 if (DECL_NAME (*y) == NULL)
5540 if (DECL_NAME (*x) < DECL_NAME (*y))
5545 /* Fill in the fields of a RECORD_TYPE or UNION_TYPE node, T.
5546 FIELDLIST is a chain of FIELD_DECL nodes for the fields.
5547 ATTRIBUTES are attributes to be applied to the structure.
5549 We also do a pop_obstacks to match the push in start_struct. */
5552 finish_struct (t, fieldlist, attributes)
5559 int toplevel = global_binding_level == current_binding_level;
5561 /* If this type was previously laid out as a forward reference,
5562 make sure we lay it out again. */
5566 decl_attributes (t, attributes, NULL_TREE);
5568 /* Nameless union parm types are useful as GCC extension. */
5569 if (! (TREE_CODE (t) == UNION_TYPE && TYPE_NAME (t) == 0) && !pedantic)
5570 /* Otherwise, warn about any struct or union def. in parmlist. */
5571 if (in_parm_level_p ())
5574 pedwarn ((TREE_CODE (t) == UNION_TYPE ? "union defined inside parms"
5575 : "structure defined inside parms"));
5576 else if (! flag_traditional)
5577 warning ((TREE_CODE (t) == UNION_TYPE ? "union defined inside parms"
5578 : "structure defined inside parms"));
5581 old_momentary = suspend_momentary ();
5585 for (x = fieldlist; x; x = TREE_CHAIN (x))
5586 if (DECL_NAME (x) != 0)
5590 pedwarn ("%s has no %smembers",
5591 (TREE_CODE (t) == UNION_TYPE ? "union" : "structure"),
5592 (fieldlist ? "named " : ""));
5595 /* Install struct as DECL_CONTEXT of each field decl.
5596 Also process specified field sizes.
5597 Set DECL_FIELD_SIZE to the specified size, or 0 if none specified.
5598 The specified size is found in the DECL_INITIAL.
5599 Store 0 there, except for ": 0" fields (so we can find them
5600 and delete them, below). */
5602 for (x = fieldlist; x; x = TREE_CHAIN (x))
5604 DECL_CONTEXT (x) = t;
5605 DECL_PACKED (x) |= TYPE_PACKED (t);
5606 DECL_FIELD_SIZE (x) = 0;
5608 /* If any field is const, the structure type is pseudo-const. */
5609 if (TREE_READONLY (x))
5610 C_TYPE_FIELDS_READONLY (t) = 1;
5613 /* A field that is pseudo-const makes the structure likewise. */
5614 tree t1 = TREE_TYPE (x);
5615 while (TREE_CODE (t1) == ARRAY_TYPE)
5616 t1 = TREE_TYPE (t1);
5617 if ((TREE_CODE (t1) == RECORD_TYPE || TREE_CODE (t1) == UNION_TYPE)
5618 && C_TYPE_FIELDS_READONLY (t1))
5619 C_TYPE_FIELDS_READONLY (t) = 1;
5622 /* Any field that is volatile means variables of this type must be
5623 treated in some ways as volatile. */
5624 if (TREE_THIS_VOLATILE (x))
5625 C_TYPE_FIELDS_VOLATILE (t) = 1;
5627 /* Any field of nominal variable size implies structure is too. */
5628 if (C_DECL_VARIABLE_SIZE (x))
5629 C_TYPE_VARIABLE_SIZE (t) = 1;
5631 /* Detect invalid nested redefinition. */
5632 if (TREE_TYPE (x) == t)
5633 error ("nested redefinition of `%s'",
5634 IDENTIFIER_POINTER (TYPE_NAME (t)));
5636 /* Detect invalid bit-field size. */
5637 if (DECL_INITIAL (x))
5638 STRIP_NOPS (DECL_INITIAL (x));
5639 if (DECL_INITIAL (x))
5641 if (TREE_CODE (DECL_INITIAL (x)) == INTEGER_CST)
5642 constant_expression_warning (DECL_INITIAL (x));
5645 error_with_decl (x, "bit-field `%s' width not an integer constant");
5646 DECL_INITIAL (x) = NULL;
5650 /* Detect invalid bit-field type. */
5651 if (DECL_INITIAL (x)
5652 && TREE_CODE (TREE_TYPE (x)) != INTEGER_TYPE
5653 && TREE_CODE (TREE_TYPE (x)) != ENUMERAL_TYPE)
5655 error_with_decl (x, "bit-field `%s' has invalid type");
5656 DECL_INITIAL (x) = NULL;
5658 if (DECL_INITIAL (x) && pedantic
5659 && TYPE_MAIN_VARIANT (TREE_TYPE (x)) != integer_type_node
5660 && TYPE_MAIN_VARIANT (TREE_TYPE (x)) != unsigned_type_node
5661 /* Accept an enum that's equivalent to int or unsigned int. */
5662 && !(TREE_CODE (TREE_TYPE (x)) == ENUMERAL_TYPE
5663 && (TYPE_PRECISION (TREE_TYPE (x))
5664 == TYPE_PRECISION (integer_type_node))))
5665 pedwarn_with_decl (x, "bit-field `%s' type invalid in ANSI C");
5667 /* Detect and ignore out of range field width. */
5668 if (DECL_INITIAL (x))
5670 unsigned HOST_WIDE_INT width = TREE_INT_CST_LOW (DECL_INITIAL (x));
5672 if (tree_int_cst_sgn (DECL_INITIAL (x)) < 0)
5674 DECL_INITIAL (x) = NULL;
5675 error_with_decl (x, "negative width in bit-field `%s'");
5677 else if (TREE_INT_CST_HIGH (DECL_INITIAL (x)) != 0
5678 || width > TYPE_PRECISION (TREE_TYPE (x)))
5680 DECL_INITIAL (x) = NULL;
5681 pedwarn_with_decl (x, "width of `%s' exceeds its type");
5683 else if (width == 0 && DECL_NAME (x) != 0)
5685 error_with_decl (x, "zero width for bit-field `%s'");
5686 DECL_INITIAL (x) = NULL;
5690 /* Process valid field width. */
5691 if (DECL_INITIAL (x))
5693 register int width = TREE_INT_CST_LOW (DECL_INITIAL (x));
5695 if (TREE_CODE (TREE_TYPE (x)) == ENUMERAL_TYPE
5696 && (width < min_precision (TYPE_MIN_VALUE (TREE_TYPE (x)),
5697 TREE_UNSIGNED (TREE_TYPE (x)))
5698 || width < min_precision (TYPE_MAX_VALUE (TREE_TYPE (x)),
5699 TREE_UNSIGNED (TREE_TYPE (x)))))
5700 warning_with_decl (x, "`%s' is narrower than values of its type");
5702 DECL_FIELD_SIZE (x) = width;
5703 DECL_BIT_FIELD (x) = DECL_C_BIT_FIELD (x) = 1;
5704 DECL_INITIAL (x) = NULL;
5708 /* field size 0 => force desired amount of alignment. */
5709 #ifdef EMPTY_FIELD_BOUNDARY
5710 DECL_ALIGN (x) = MAX (DECL_ALIGN (x), EMPTY_FIELD_BOUNDARY);
5712 #ifdef PCC_BITFIELD_TYPE_MATTERS
5713 if (PCC_BITFIELD_TYPE_MATTERS)
5714 DECL_ALIGN (x) = MAX (DECL_ALIGN (x),
5715 TYPE_ALIGN (TREE_TYPE (x)));
5719 else if (TREE_TYPE (x) != error_mark_node)
5721 int min_align = (DECL_PACKED (x) ? BITS_PER_UNIT
5722 : TYPE_ALIGN (TREE_TYPE (x)));
5723 /* Non-bit-fields are aligned for their type, except packed
5724 fields which require only BITS_PER_UNIT alignment. */
5725 DECL_ALIGN (x) = MAX (DECL_ALIGN (x), min_align);
5729 /* Now DECL_INITIAL is null on all members. */
5731 /* Delete all duplicate fields from the fieldlist */
5732 for (x = fieldlist; x && TREE_CHAIN (x);)
5733 /* Anonymous fields aren't duplicates. */
5734 if (DECL_NAME (TREE_CHAIN (x)) == 0)
5738 register tree y = fieldlist;
5742 if (DECL_NAME (y) == DECL_NAME (TREE_CHAIN (x)))
5748 if (DECL_NAME (y) == DECL_NAME (TREE_CHAIN (x)))
5750 error_with_decl (TREE_CHAIN (x), "duplicate member `%s'");
5751 TREE_CHAIN (x) = TREE_CHAIN (TREE_CHAIN (x));
5753 else x = TREE_CHAIN (x);
5756 /* Now we have the nearly final fieldlist. Record it,
5757 then lay out the structure or union (including the fields). */
5759 TYPE_FIELDS (t) = fieldlist;
5763 /* Delete all zero-width bit-fields from the front of the fieldlist */
5765 && DECL_INITIAL (fieldlist))
5766 fieldlist = TREE_CHAIN (fieldlist);
5767 /* Delete all such members from the rest of the fieldlist */
5768 for (x = fieldlist; x;)
5770 if (TREE_CHAIN (x) && DECL_INITIAL (TREE_CHAIN (x)))
5771 TREE_CHAIN (x) = TREE_CHAIN (TREE_CHAIN (x));
5772 else x = TREE_CHAIN (x);
5775 /* Now we have the truly final field list.
5776 Store it in this type and in the variants. */
5778 TYPE_FIELDS (t) = fieldlist;
5780 /* If there are lots of fields, sort so we can look through them fast.
5781 We arbitrarily consider 16 or more elts to be "a lot". */
5785 for (x = fieldlist; x; x = TREE_CHAIN (x))
5796 len += list_length (x);
5797 /* Use the same allocation policy here that make_node uses, to
5798 ensure that this lives as long as the rest of the struct decl.
5799 All decls in an inline function need to be saved. */
5800 if (allocation_temporary_p ())
5801 space = savealloc (sizeof (struct lang_type) + len * sizeof (tree));
5803 space = oballoc (sizeof (struct lang_type) + len * sizeof (tree));
5805 TYPE_LANG_SPECIFIC (t) = (struct lang_type *) space;
5806 TYPE_LANG_SPECIFIC (t)->len = len;
5808 field_array = &TYPE_LANG_SPECIFIC (t)->elts[0];
5810 for (x = fieldlist; x; x = TREE_CHAIN (x))
5811 field_array[len++] = x;
5813 qsort (field_array, len, sizeof (tree), field_decl_cmp);
5817 for (x = TYPE_MAIN_VARIANT (t); x; x = TYPE_NEXT_VARIANT (x))
5819 TYPE_FIELDS (x) = TYPE_FIELDS (t);
5820 TYPE_LANG_SPECIFIC (x) = TYPE_LANG_SPECIFIC (t);
5821 TYPE_ALIGN (x) = TYPE_ALIGN (t);
5824 /* If this was supposed to be a transparent union, but we can't
5825 make it one, warn and turn off the flag. */
5826 if (TREE_CODE (t) == UNION_TYPE
5827 && TYPE_TRANSPARENT_UNION (t)
5828 && TYPE_MODE (t) != DECL_MODE (TYPE_FIELDS (t)))
5830 TYPE_TRANSPARENT_UNION (t) = 0;
5831 warning ("union cannot be made transparent");
5834 /* If this structure or union completes the type of any previous
5835 variable declaration, lay it out and output its rtl. */
5837 if (current_binding_level->n_incomplete != 0)
5840 for (decl = current_binding_level->names; decl; decl = TREE_CHAIN (decl))
5842 if (TREE_TYPE (decl) == t
5843 && TREE_CODE (decl) != TYPE_DECL)
5845 layout_decl (decl, 0);
5846 /* This is a no-op in c-lang.c or something real in objc-actions.c. */
5847 maybe_objc_check_decl (decl);
5848 rest_of_decl_compilation (decl, NULL_PTR, toplevel, 0);
5851 --current_binding_level->n_incomplete;
5853 else if (TYPE_SIZE (TREE_TYPE (decl)) == 0
5854 && TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE)
5856 tree element = TREE_TYPE (decl);
5857 while (TREE_CODE (element) == ARRAY_TYPE)
5858 element = TREE_TYPE (element);
5860 layout_array_type (TREE_TYPE (decl));
5865 resume_momentary (old_momentary);
5867 /* Finish debugging output for this type. */
5868 rest_of_type_compilation (t, toplevel);
5870 /* The matching push is in start_struct. */
5876 /* Lay out the type T, and its element type, and so on. */
5879 layout_array_type (t)
5882 if (TREE_CODE (TREE_TYPE (t)) == ARRAY_TYPE)
5883 layout_array_type (TREE_TYPE (t));
5887 /* Begin compiling the definition of an enumeration type.
5888 NAME is its name (or null if anonymous).
5889 Returns the type object, as yet incomplete.
5890 Also records info about it so that build_enumerator
5891 may be used to declare the individual values as they are read. */
5897 register tree enumtype = 0;
5899 /* If this is the real definition for a previous forward reference,
5900 fill in the contents in the same object that used to be the
5901 forward reference. */
5904 enumtype = lookup_tag (ENUMERAL_TYPE, name, current_binding_level, 1);
5906 /* The corresponding pop_obstacks is in finish_enum. */
5907 push_obstacks_nochange ();
5908 /* If these symbols and types are global, make them permanent. */
5909 if (current_binding_level == global_binding_level)
5910 end_temporary_allocation ();
5912 if (enumtype == 0 || TREE_CODE (enumtype) != ENUMERAL_TYPE)
5914 enumtype = make_node (ENUMERAL_TYPE);
5915 pushtag (name, enumtype);
5918 C_TYPE_BEING_DEFINED (enumtype) = 1;
5920 if (TYPE_VALUES (enumtype) != 0)
5922 /* This enum is a named one that has been declared already. */
5923 error ("redeclaration of `enum %s'", IDENTIFIER_POINTER (name));
5925 /* Completely replace its old definition.
5926 The old enumerators remain defined, however. */
5927 TYPE_VALUES (enumtype) = 0;
5930 enum_next_value = integer_zero_node;
5933 if (flag_short_enums)
5934 TYPE_PACKED (enumtype) = 1;
5939 /* After processing and defining all the values of an enumeration type,
5940 install their decls in the enumeration type and finish it off.
5941 ENUMTYPE is the type object, VALUES a list of decl-value pairs,
5942 and ATTRIBUTES are the specified attributes.
5943 Returns ENUMTYPE. */
5946 finish_enum (enumtype, values, attributes)
5951 register tree pair, tem;
5952 tree minnode = 0, maxnode = 0;
5953 int lowprec, highprec, precision;
5954 int toplevel = global_binding_level == current_binding_level;
5956 if (in_parm_level_p ())
5957 warning ("enum defined inside parms");
5959 decl_attributes (enumtype, attributes, NULL_TREE);
5961 /* Calculate the maximum value of any enumerator in this type. */
5963 if (values == error_mark_node)
5964 minnode = maxnode = integer_zero_node;
5966 for (pair = values; pair; pair = TREE_CHAIN (pair))
5968 tree value = TREE_VALUE (pair);
5970 minnode = maxnode = TREE_VALUE (pair);
5973 if (tree_int_cst_lt (maxnode, value))
5975 if (tree_int_cst_lt (value, minnode))
5980 TYPE_MIN_VALUE (enumtype) = minnode;
5981 TYPE_MAX_VALUE (enumtype) = maxnode;
5983 /* An enum can have some negative values; then it is signed. */
5984 TREE_UNSIGNED (enumtype) = tree_int_cst_sgn (minnode) >= 0;
5986 /* Determine the precision this type needs. */
5988 lowprec = min_precision (minnode, TREE_UNSIGNED (enumtype));
5989 highprec = min_precision (maxnode, TREE_UNSIGNED (enumtype));
5990 precision = MAX (lowprec, highprec);
5992 if (TYPE_PACKED (enumtype) || precision > TYPE_PRECISION (integer_type_node))
5994 tree narrowest = type_for_size (precision, 1);
5997 warning ("enumeration values exceed range of largest integer");
5998 narrowest = long_long_integer_type_node;
6001 TYPE_PRECISION (enumtype) = TYPE_PRECISION (narrowest);
6004 TYPE_PRECISION (enumtype) = TYPE_PRECISION (integer_type_node);
6006 TYPE_SIZE (enumtype) = 0;
6007 layout_type (enumtype);
6009 if (values != error_mark_node)
6011 /* Change the type of the enumerators to be the enum type.
6012 Formerly this was done only for enums that fit in an int,
6013 but the comment said it was done only for enums wider than int.
6014 It seems necessary to do this for wide enums,
6015 and best not to change what's done for ordinary narrower ones. */
6016 for (pair = values; pair; pair = TREE_CHAIN (pair))
6018 TREE_TYPE (TREE_PURPOSE (pair)) = enumtype;
6019 DECL_SIZE (TREE_PURPOSE (pair)) = TYPE_SIZE (enumtype);
6020 if (TREE_CODE (TREE_PURPOSE (pair)) != FUNCTION_DECL)
6021 DECL_ALIGN (TREE_PURPOSE (pair)) = TYPE_ALIGN (enumtype);
6024 /* Replace the decl nodes in VALUES with their names. */
6025 for (pair = values; pair; pair = TREE_CHAIN (pair))
6026 TREE_PURPOSE (pair) = DECL_NAME (TREE_PURPOSE (pair));
6028 TYPE_VALUES (enumtype) = values;
6031 /* Fix up all variant types of this enum type. */
6032 for (tem = TYPE_MAIN_VARIANT (enumtype); tem; tem = TYPE_NEXT_VARIANT (tem))
6034 TYPE_VALUES (tem) = TYPE_VALUES (enumtype);
6035 TYPE_MIN_VALUE (tem) = TYPE_MIN_VALUE (enumtype);
6036 TYPE_MAX_VALUE (tem) = TYPE_MAX_VALUE (enumtype);
6037 TYPE_SIZE (tem) = TYPE_SIZE (enumtype);
6038 TYPE_MODE (tem) = TYPE_MODE (enumtype);
6039 TYPE_PRECISION (tem) = TYPE_PRECISION (enumtype);
6040 TYPE_ALIGN (tem) = TYPE_ALIGN (enumtype);
6041 TREE_UNSIGNED (tem) = TREE_UNSIGNED (enumtype);
6044 /* Finish debugging output for this type. */
6045 rest_of_type_compilation (enumtype, toplevel);
6047 /* This matches a push in start_enum. */
6053 /* Build and install a CONST_DECL for one value of the
6054 current enumeration type (one that was begun with start_enum).
6055 Return a tree-list containing the CONST_DECL and its value.
6056 Assignment of sequential values by default is handled here. */
6059 build_enumerator (name, value)
6062 register tree decl, type;
6064 /* Validate and default VALUE. */
6066 /* Remove no-op casts from the value. */
6068 STRIP_TYPE_NOPS (value);
6072 if (TREE_CODE (value) == INTEGER_CST)
6074 value = default_conversion (value);
6075 constant_expression_warning (value);
6079 error ("enumerator value for `%s' not integer constant",
6080 IDENTIFIER_POINTER (name));
6085 /* Default based on previous value. */
6086 /* It should no longer be possible to have NON_LVALUE_EXPR
6090 value = enum_next_value;
6092 error ("overflow in enumeration values");
6095 if (pedantic && ! int_fits_type_p (value, integer_type_node))
6097 pedwarn ("ANSI C restricts enumerator values to range of `int'");
6098 value = integer_zero_node;
6101 /* Set basis for default for next value. */
6102 enum_next_value = build_binary_op (PLUS_EXPR, value, integer_one_node, 0);
6103 enum_overflow = tree_int_cst_lt (enum_next_value, value);
6105 /* Now create a declaration for the enum value name. */
6107 type = TREE_TYPE (value);
6108 type = type_for_size (MAX (TYPE_PRECISION (type),
6109 TYPE_PRECISION (integer_type_node)),
6111 || TYPE_PRECISION (type) >= TYPE_PRECISION (integer_type_node))
6112 && TREE_UNSIGNED (type)));
6114 decl = build_decl (CONST_DECL, name, type);
6115 DECL_INITIAL (decl) = value;
6116 TREE_TYPE (value) = type;
6119 return saveable_tree_cons (decl, value, NULL_TREE);
6122 /* Create the FUNCTION_DECL for a function definition.
6123 DECLSPECS, DECLARATOR, PREFIX_ATTRIBUTES and ATTRIBUTES are the parts of
6124 the declaration; they describe the function's name and the type it returns,
6125 but twisted together in a fashion that parallels the syntax of C.
6127 This function creates a binding context for the function body
6128 as well as setting up the FUNCTION_DECL in current_function_decl.
6130 Returns 1 on success. If the DECLARATOR is not suitable for a function
6131 (it defines a datum instead), we return 0, which tells
6132 yyparse to report a parse error.
6134 NESTED is nonzero for a function nested within another function. */
6137 start_function (declspecs, declarator, prefix_attributes, attributes, nested)
6138 tree declarator, declspecs, prefix_attributes, attributes;
6141 tree decl1, old_decl;
6143 int old_immediate_size_expand = immediate_size_expand;
6145 current_function_returns_value = 0; /* Assume, until we see it does. */
6146 current_function_returns_null = 0;
6147 warn_about_return_type = 0;
6148 current_extern_inline = 0;
6149 c_function_varargs = 0;
6151 shadowed_labels = 0;
6153 /* Don't expand any sizes in the return type of the function. */
6154 immediate_size_expand = 0;
6156 decl1 = grokdeclarator (declarator, declspecs, FUNCDEF, 1);
6158 /* If the declarator is not suitable for a function definition,
6159 cause a syntax error. */
6163 decl_attributes (decl1, prefix_attributes, attributes);
6165 announce_function (decl1);
6167 if (TYPE_SIZE (TREE_TYPE (TREE_TYPE (decl1))) == 0)
6169 error ("return-type is an incomplete type");
6170 /* Make it return void instead. */
6172 = build_function_type (void_type_node,
6173 TYPE_ARG_TYPES (TREE_TYPE (decl1)));
6176 if (warn_about_return_type)
6177 warning ("return-type defaults to `int'");
6179 /* Save the parm names or decls from this function's declarator
6180 where store_parm_decls will find them. */
6181 current_function_parms = last_function_parms;
6182 current_function_parm_tags = last_function_parm_tags;
6184 /* Make the init_value nonzero so pushdecl knows this is not tentative.
6185 error_mark_node is replaced below (in poplevel) with the BLOCK. */
6186 DECL_INITIAL (decl1) = error_mark_node;
6188 /* If this definition isn't a prototype and we had a prototype declaration
6189 before, copy the arg type info from that prototype.
6190 But not if what we had before was a builtin function. */
6191 old_decl = lookup_name_current_level (DECL_NAME (decl1));
6192 if (old_decl != 0 && TREE_CODE (TREE_TYPE (old_decl)) == FUNCTION_TYPE
6193 && !DECL_BUILT_IN (old_decl)
6194 && (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (decl1)))
6195 == TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (old_decl))))
6196 && TYPE_ARG_TYPES (TREE_TYPE (decl1)) == 0)
6198 TREE_TYPE (decl1) = TREE_TYPE (old_decl);
6199 current_function_prototype_file = DECL_SOURCE_FILE (old_decl);
6200 current_function_prototype_line = DECL_SOURCE_LINE (old_decl);
6203 /* If there is no explicit declaration, look for any out-of-scope implicit
6206 old_decl = IDENTIFIER_IMPLICIT_DECL (DECL_NAME (decl1));
6208 /* Optionally warn of old-fashioned def with no previous prototype. */
6209 if (warn_strict_prototypes
6210 && TYPE_ARG_TYPES (TREE_TYPE (decl1)) == 0
6211 && !(old_decl != 0 && TYPE_ARG_TYPES (TREE_TYPE (old_decl)) != 0))
6212 warning ("function declaration isn't a prototype");
6213 /* Optionally warn of any global def with no previous prototype. */
6214 else if (warn_missing_prototypes
6215 && TREE_PUBLIC (decl1)
6216 && !(old_decl != 0 && TYPE_ARG_TYPES (TREE_TYPE (old_decl)) != 0)
6217 && strcmp ("main", IDENTIFIER_POINTER (DECL_NAME (decl1))))
6218 warning_with_decl (decl1, "no previous prototype for `%s'");
6219 /* Optionally warn of any def with no previous prototype
6220 if the function has already been used. */
6221 else if (warn_missing_prototypes
6222 && old_decl != 0 && TREE_USED (old_decl)
6223 && TYPE_ARG_TYPES (TREE_TYPE (old_decl)) == 0)
6224 warning_with_decl (decl1,
6225 "`%s' was used with no prototype before its definition");
6226 /* Optionally warn of any global def with no previous declaration. */
6227 else if (warn_missing_declarations
6228 && TREE_PUBLIC (decl1)
6230 && strcmp ("main", IDENTIFIER_POINTER (DECL_NAME (decl1))))
6231 warning_with_decl (decl1, "no previous declaration for `%s'");
6232 /* Optionally warn of any def with no previous declaration
6233 if the function has already been used. */
6234 else if (warn_missing_declarations
6235 && old_decl != 0 && TREE_USED (old_decl)
6236 && old_decl == IDENTIFIER_IMPLICIT_DECL (DECL_NAME (decl1)))
6237 warning_with_decl (decl1,
6238 "`%s' was used with no declaration before its definition");
6240 /* This is a definition, not a reference.
6241 So normally clear DECL_EXTERNAL.
6242 However, `extern inline' acts like a declaration
6243 except for defining how to inline. So set DECL_EXTERNAL in that case. */
6244 DECL_EXTERNAL (decl1) = current_extern_inline;
6246 /* This function exists in static storage.
6247 (This does not mean `static' in the C sense!) */
6248 TREE_STATIC (decl1) = 1;
6250 /* A nested function is not global. */
6251 if (current_function_decl != 0)
6252 TREE_PUBLIC (decl1) = 0;
6254 /* Warn for unlikely, improbable, or stupid declarations of `main'. */
6256 && strcmp ("main", IDENTIFIER_POINTER (DECL_NAME (decl1))) == 0)
6261 if (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (decl1)))
6262 != integer_type_node)
6263 pedwarn_with_decl (decl1, "return type of `%s' is not `int'");
6265 for (args = TYPE_ARG_TYPES (TREE_TYPE (decl1)); args;
6266 args = TREE_CHAIN (args))
6268 tree type = args ? TREE_VALUE (args) : 0;
6270 if (type == void_type_node)
6277 if (TYPE_MAIN_VARIANT (type) != integer_type_node)
6278 pedwarn_with_decl (decl1,
6279 "first argument of `%s' should be `int'");
6283 if (TREE_CODE (type) != POINTER_TYPE
6284 || TREE_CODE (TREE_TYPE (type)) != POINTER_TYPE
6285 || (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (type)))
6287 pedwarn_with_decl (decl1,
6288 "second argument of `%s' should be `char **'");
6292 if (TREE_CODE (type) != POINTER_TYPE
6293 || TREE_CODE (TREE_TYPE (type)) != POINTER_TYPE
6294 || (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (type)))
6296 pedwarn_with_decl (decl1,
6297 "third argument of `%s' should probably be `char **'");
6302 /* It is intentional that this message does not mention the third
6303 argument, which is warned for only pedantically, because it's
6304 blessed by mention in an appendix of the standard. */
6305 if (argct > 0 && (argct < 2 || argct > 3))
6306 pedwarn_with_decl (decl1, "`%s' takes only zero or two arguments");
6308 if (argct == 3 && pedantic)
6309 pedwarn_with_decl (decl1, "third argument of `%s' is deprecated");
6311 if (! TREE_PUBLIC (decl1))
6312 pedwarn_with_decl (decl1, "`%s' is normally a non-static function");
6315 /* Record the decl so that the function name is defined.
6316 If we already have a decl for this name, and it is a FUNCTION_DECL,
6317 use the old decl. */
6319 current_function_decl = pushdecl (decl1);
6322 declare_parm_level (1);
6323 current_binding_level->subblocks_tag_transparent = 1;
6325 make_function_rtl (current_function_decl);
6327 restype = TREE_TYPE (TREE_TYPE (current_function_decl));
6328 /* Promote the value to int before returning it. */
6329 if (C_PROMOTING_INTEGER_TYPE_P (restype))
6331 /* It retains unsignedness if traditional
6332 or if not really getting wider. */
6333 if (TREE_UNSIGNED (restype)
6334 && (flag_traditional
6335 || (TYPE_PRECISION (restype)
6336 == TYPE_PRECISION (integer_type_node))))
6337 restype = unsigned_type_node;
6339 restype = integer_type_node;
6341 DECL_RESULT (current_function_decl)
6342 = build_decl (RESULT_DECL, NULL_TREE, restype);
6345 /* Allocate further tree nodes temporarily during compilation
6346 of this function only. */
6347 temporary_allocation ();
6349 /* If this fcn was already referenced via a block-scope `extern' decl
6350 (or an implicit decl), propagate certain information about the usage. */
6351 if (TREE_ADDRESSABLE (DECL_ASSEMBLER_NAME (current_function_decl)))
6352 TREE_ADDRESSABLE (current_function_decl) = 1;
6354 immediate_size_expand = old_immediate_size_expand;
6359 /* Record that this function is going to be a varargs function.
6360 This is called before store_parm_decls, which is too early
6361 to call mark_varargs directly. */
6366 c_function_varargs = 1;
6369 /* Store the parameter declarations into the current function declaration.
6370 This is called after parsing the parameter declarations, before
6371 digesting the body of the function.
6373 For an old-style definition, modify the function's type
6374 to specify at least the number of arguments. */
6379 register tree fndecl = current_function_decl;
6382 /* This is either a chain of PARM_DECLs (if a prototype was used)
6383 or a list of IDENTIFIER_NODEs (for an old-fashioned C definition). */
6384 tree specparms = current_function_parms;
6386 /* This is a list of types declared among parms in a prototype. */
6387 tree parmtags = current_function_parm_tags;
6389 /* This is a chain of PARM_DECLs from old-style parm declarations. */
6390 register tree parmdecls = getdecls ();
6392 /* This is a chain of any other decls that came in among the parm
6393 declarations. If a parm is declared with enum {foo, bar} x;
6394 then CONST_DECLs for foo and bar are put here. */
6397 /* Nonzero if this definition is written with a prototype. */
6400 if (specparms != 0 && TREE_CODE (specparms) != TREE_LIST)
6402 /* This case is when the function was defined with an ANSI prototype.
6403 The parms already have decls, so we need not do anything here
6404 except record them as in effect
6405 and complain if any redundant old-style parm decls were written. */
6416 error_with_decl (fndecl,
6417 "parm types given both in parmlist and separately");
6418 /* Get rid of the erroneous decls; don't keep them on
6419 the list of parms, since they might not be PARM_DECLs. */
6420 for (decl = current_binding_level->names;
6421 decl; decl = TREE_CHAIN (decl))
6422 if (DECL_NAME (decl))
6423 IDENTIFIER_LOCAL_VALUE (DECL_NAME (decl)) = 0;
6424 for (link = current_binding_level->shadowed;
6425 link; link = TREE_CHAIN (link))
6426 IDENTIFIER_LOCAL_VALUE (TREE_PURPOSE (link)) = TREE_VALUE (link);
6427 current_binding_level->names = 0;
6428 current_binding_level->shadowed = 0;
6431 specparms = nreverse (specparms);
6432 for (parm = specparms; parm; parm = next)
6434 next = TREE_CHAIN (parm);
6435 if (TREE_CODE (parm) == PARM_DECL)
6437 if (DECL_NAME (parm) == 0)
6438 error_with_decl (parm, "parameter name omitted");
6439 else if (TYPE_MAIN_VARIANT (TREE_TYPE (parm)) == void_type_node)
6441 error_with_decl (parm, "parameter `%s' declared void");
6442 /* Change the type to error_mark_node so this parameter
6443 will be ignored by assign_parms. */
6444 TREE_TYPE (parm) = error_mark_node;
6450 /* If we find an enum constant or a type tag,
6451 put it aside for the moment. */
6452 TREE_CHAIN (parm) = 0;
6453 others = chainon (others, parm);
6457 /* Get the decls in their original chain order
6458 and record in the function. */
6459 DECL_ARGUMENTS (fndecl) = getdecls ();
6462 /* If this function takes a variable number of arguments,
6463 add a phony parameter to the end of the parm list,
6464 to represent the position of the first unnamed argument. */
6465 if (TREE_VALUE (tree_last (TYPE_ARG_TYPES (TREE_TYPE (fndecl))))
6468 tree dummy = build_decl (PARM_DECL, NULL_TREE, void_type_node);
6469 /* Let's hope the address of the unnamed parm
6470 won't depend on its type. */
6471 TREE_TYPE (dummy) = integer_type_node;
6472 DECL_ARG_TYPE (dummy) = integer_type_node;
6473 DECL_ARGUMENTS (fndecl)
6474 = chainon (DECL_ARGUMENTS (fndecl), dummy);
6478 /* Now pushdecl the enum constants. */
6479 for (parm = others; parm; parm = next)
6481 next = TREE_CHAIN (parm);
6482 if (DECL_NAME (parm) == 0)
6484 else if (TYPE_MAIN_VARIANT (TREE_TYPE (parm)) == void_type_node)
6486 else if (TREE_CODE (parm) != PARM_DECL)
6490 storetags (chainon (parmtags, gettags ()));
6494 /* SPECPARMS is an identifier list--a chain of TREE_LIST nodes
6495 each with a parm name as the TREE_VALUE.
6497 PARMDECLS is a chain of declarations for parameters.
6498 Warning! It can also contain CONST_DECLs which are not parameters
6499 but are names of enumerators of any enum types
6500 declared among the parameters.
6502 First match each formal parameter name with its declaration.
6503 Associate decls with the names and store the decls
6504 into the TREE_PURPOSE slots. */
6506 for (parm = parmdecls; parm; parm = TREE_CHAIN (parm))
6507 DECL_RESULT (parm) = 0;
6509 for (parm = specparms; parm; parm = TREE_CHAIN (parm))
6511 register tree tail, found = NULL;
6513 if (TREE_VALUE (parm) == 0)
6515 error_with_decl (fndecl, "parameter name missing from parameter list");
6516 TREE_PURPOSE (parm) = 0;
6520 /* See if any of the parmdecls specifies this parm by name.
6521 Ignore any enumerator decls. */
6522 for (tail = parmdecls; tail; tail = TREE_CHAIN (tail))
6523 if (DECL_NAME (tail) == TREE_VALUE (parm)
6524 && TREE_CODE (tail) == PARM_DECL)
6530 /* If declaration already marked, we have a duplicate name.
6531 Complain, and don't use this decl twice. */
6532 if (found && DECL_RESULT (found) != 0)
6534 error_with_decl (found, "multiple parameters named `%s'");
6538 /* If the declaration says "void", complain and ignore it. */
6539 if (found && TYPE_MAIN_VARIANT (TREE_TYPE (found)) == void_type_node)
6541 error_with_decl (found, "parameter `%s' declared void");
6542 TREE_TYPE (found) = integer_type_node;
6543 DECL_ARG_TYPE (found) = integer_type_node;
6544 layout_decl (found, 0);
6547 /* Traditionally, a parm declared float is actually a double. */
6548 if (found && flag_traditional
6549 && TYPE_MAIN_VARIANT (TREE_TYPE (found)) == float_type_node)
6551 TREE_TYPE (found) = double_type_node;
6552 DECL_ARG_TYPE (found) = double_type_node;
6553 layout_decl (found, 0);
6556 /* If no declaration found, default to int. */
6559 found = build_decl (PARM_DECL, TREE_VALUE (parm),
6561 DECL_ARG_TYPE (found) = TREE_TYPE (found);
6562 DECL_SOURCE_LINE (found) = DECL_SOURCE_LINE (fndecl);
6563 DECL_SOURCE_FILE (found) = DECL_SOURCE_FILE (fndecl);
6565 warning_with_decl (found, "type of `%s' defaults to `int'");
6569 TREE_PURPOSE (parm) = found;
6571 /* Mark this decl as "already found" -- see test, above.
6572 It is safe to use DECL_RESULT for this
6573 since it is not used in PARM_DECLs or CONST_DECLs. */
6574 DECL_RESULT (found) = error_mark_node;
6577 /* Put anything which is on the parmdecls chain and which is
6578 not a PARM_DECL onto the list NONPARMS. (The types of
6579 non-parm things which might appear on the list include
6580 enumerators and NULL-named TYPE_DECL nodes.) Complain about
6581 any actual PARM_DECLs not matched with any names. */
6584 for (parm = parmdecls; parm; )
6586 tree next = TREE_CHAIN (parm);
6587 TREE_CHAIN (parm) = 0;
6589 if (TREE_CODE (parm) != PARM_DECL)
6590 nonparms = chainon (nonparms, parm);
6593 /* Complain about args with incomplete types. */
6594 if (TYPE_SIZE (TREE_TYPE (parm)) == 0)
6596 error_with_decl (parm, "parameter `%s' has incomplete type");
6597 TREE_TYPE (parm) = error_mark_node;
6600 if (DECL_RESULT (parm) == 0)
6602 error_with_decl (parm,
6603 "declaration for parameter `%s' but no such parameter");
6604 /* Pretend the parameter was not missing.
6605 This gets us to a standard state and minimizes
6606 further error messages. */
6608 = chainon (specparms,
6609 tree_cons (parm, NULL_TREE, NULL_TREE));
6616 /* Chain the declarations together in the order of the list of names. */
6617 /* Store that chain in the function decl, replacing the list of names. */
6619 DECL_ARGUMENTS (fndecl) = 0;
6622 for (last = 0; parm; parm = TREE_CHAIN (parm))
6623 if (TREE_PURPOSE (parm))
6626 DECL_ARGUMENTS (fndecl) = TREE_PURPOSE (parm);
6628 TREE_CHAIN (last) = TREE_PURPOSE (parm);
6629 last = TREE_PURPOSE (parm);
6630 TREE_CHAIN (last) = 0;
6634 /* If there was a previous prototype,
6635 set the DECL_ARG_TYPE of each argument according to
6636 the type previously specified, and report any mismatches. */
6638 if (TYPE_ARG_TYPES (TREE_TYPE (fndecl)))
6641 for (parm = DECL_ARGUMENTS (fndecl),
6642 type = TYPE_ARG_TYPES (TREE_TYPE (fndecl));
6643 parm || (type && (TYPE_MAIN_VARIANT (TREE_VALUE (type))
6644 != void_type_node));
6645 parm = TREE_CHAIN (parm), type = TREE_CHAIN (type))
6647 if (parm == 0 || type == 0
6648 || TYPE_MAIN_VARIANT (TREE_VALUE (type)) == void_type_node)
6650 error ("number of arguments doesn't match prototype");
6651 error_with_file_and_line (current_function_prototype_file,
6652 current_function_prototype_line,
6653 "prototype declaration");
6656 /* Type for passing arg must be consistent
6657 with that declared for the arg. */
6658 if (! comptypes (DECL_ARG_TYPE (parm), TREE_VALUE (type)))
6660 if (TYPE_MAIN_VARIANT (TREE_TYPE (parm))
6661 == TYPE_MAIN_VARIANT (TREE_VALUE (type)))
6663 /* Adjust argument to match prototype. E.g. a previous
6664 `int foo(float);' prototype causes
6665 `int foo(x) float x; {...}' to be treated like
6666 `int foo(float x) {...}'. This is particularly
6667 useful for argument types like uid_t. */
6668 DECL_ARG_TYPE (parm) = TREE_TYPE (parm);
6669 #ifdef PROMOTE_PROTOTYPES
6670 if ((TREE_CODE (TREE_TYPE (parm)) == INTEGER_TYPE
6671 || TREE_CODE (TREE_TYPE (parm)) == ENUMERAL_TYPE)
6672 && TYPE_PRECISION (TREE_TYPE (parm))
6673 < TYPE_PRECISION (integer_type_node))
6674 DECL_ARG_TYPE (parm) = integer_type_node;
6678 pedwarn ("promoted argument `%s' doesn't match prototype",
6679 IDENTIFIER_POINTER (DECL_NAME (parm)));
6680 warning_with_file_and_line
6681 (current_function_prototype_file,
6682 current_function_prototype_line,
6683 "prototype declaration");
6686 /* If -traditional, allow `int' argument to match
6687 `unsigned' prototype. */
6688 else if (! (flag_traditional
6689 && TYPE_MAIN_VARIANT (TREE_TYPE (parm)) == integer_type_node
6690 && TYPE_MAIN_VARIANT (TREE_VALUE (type)) == unsigned_type_node))
6692 error ("argument `%s' doesn't match prototype",
6693 IDENTIFIER_POINTER (DECL_NAME (parm)));
6694 error_with_file_and_line (current_function_prototype_file,
6695 current_function_prototype_line,
6696 "prototype declaration");
6700 TYPE_ACTUAL_ARG_TYPES (TREE_TYPE (fndecl)) = 0;
6703 /* Otherwise, create a prototype that would match. */
6707 tree actual = 0, last = 0, type;
6709 for (parm = DECL_ARGUMENTS (fndecl); parm; parm = TREE_CHAIN (parm))
6711 type = perm_tree_cons (NULL_TREE, DECL_ARG_TYPE (parm),
6714 TREE_CHAIN (last) = type;
6719 type = perm_tree_cons (NULL_TREE, void_type_node, NULL_TREE);
6721 TREE_CHAIN (last) = type;
6725 /* We are going to assign a new value for the TYPE_ACTUAL_ARG_TYPES
6726 of the type of this function, but we need to avoid having this
6727 affect the types of other similarly-typed functions, so we must
6728 first force the generation of an identical (but separate) type
6729 node for the relevant function type. The new node we create
6730 will be a variant of the main variant of the original function
6733 TREE_TYPE (fndecl) = build_type_copy (TREE_TYPE (fndecl));
6735 TYPE_ACTUAL_ARG_TYPES (TREE_TYPE (fndecl)) = actual;
6738 /* Now store the final chain of decls for the arguments
6739 as the decl-chain of the current lexical scope.
6740 Put the enumerators in as well, at the front so that
6741 DECL_ARGUMENTS is not modified. */
6743 storedecls (chainon (nonparms, DECL_ARGUMENTS (fndecl)));
6746 /* Make sure the binding level for the top of the function body
6747 gets a BLOCK if there are any in the function.
6748 Otherwise, the dbx output is wrong. */
6750 keep_next_if_subblocks = 1;
6752 /* ??? This might be an improvement,
6753 but needs to be thought about some more. */
6755 keep_next_level_flag = 1;
6758 /* Write a record describing this function definition to the prototypes
6759 file (if requested). */
6761 gen_aux_info_record (fndecl, 1, 0, prototype);
6763 /* Initialize the RTL code for the function. */
6765 init_function_start (fndecl, input_filename, lineno);
6767 /* If this is a varargs function, inform function.c. */
6769 if (c_function_varargs)
6772 /* Declare __FUNCTION__ and __PRETTY_FUNCTION__ for this function. */
6774 declare_function_name ();
6776 /* Set up parameters and prepare for return, for the function. */
6778 expand_function_start (fndecl, 0);
6780 /* If this function is `main', emit a call to `__main'
6781 to run global initializers, etc. */
6782 if (DECL_NAME (fndecl)
6783 && strcmp (IDENTIFIER_POINTER (DECL_NAME (fndecl)), "main") == 0
6784 && DECL_CONTEXT (fndecl) == NULL_TREE)
6785 expand_main_function ();
6788 /* SPECPARMS is an identifier list--a chain of TREE_LIST nodes
6789 each with a parm name as the TREE_VALUE. A null pointer as TREE_VALUE
6790 stands for an ellipsis in the identifier list.
6792 PARMLIST is the data returned by get_parm_info for the
6793 parmlist that follows the semicolon.
6795 We return a value of the same sort that get_parm_info returns,
6796 except that it describes the combination of identifiers and parmlist. */
6799 combine_parm_decls (specparms, parmlist, void_at_end)
6800 tree specparms, parmlist;
6803 register tree fndecl = current_function_decl;
6806 tree parmdecls = TREE_PURPOSE (parmlist);
6808 /* This is a chain of any other decls that came in among the parm
6809 declarations. They were separated already by get_parm_info,
6810 so we just need to keep them separate. */
6811 tree nonparms = TREE_VALUE (parmlist);
6815 for (parm = parmdecls; parm; parm = TREE_CHAIN (parm))
6816 DECL_RESULT (parm) = 0;
6818 for (parm = specparms; parm; parm = TREE_CHAIN (parm))
6820 register tree tail, found = NULL;
6822 /* See if any of the parmdecls specifies this parm by name. */
6823 for (tail = parmdecls; tail; tail = TREE_CHAIN (tail))
6824 if (DECL_NAME (tail) == TREE_VALUE (parm))
6830 /* If declaration already marked, we have a duplicate name.
6831 Complain, and don't use this decl twice. */
6832 if (found && DECL_RESULT (found) != 0)
6834 error_with_decl (found, "multiple parameters named `%s'");
6838 /* If the declaration says "void", complain and ignore it. */
6839 if (found && TYPE_MAIN_VARIANT (TREE_TYPE (found)) == void_type_node)
6841 error_with_decl (found, "parameter `%s' declared void");
6842 TREE_TYPE (found) = integer_type_node;
6843 DECL_ARG_TYPE (found) = integer_type_node;
6844 layout_decl (found, 0);
6847 /* Traditionally, a parm declared float is actually a double. */
6848 if (found && flag_traditional
6849 && TYPE_MAIN_VARIANT (TREE_TYPE (found)) == float_type_node)
6851 TREE_TYPE (found) = double_type_node;
6852 DECL_ARG_TYPE (found) = double_type_node;
6853 layout_decl (found, 0);
6856 /* If no declaration found, default to int. */
6859 found = build_decl (PARM_DECL, TREE_VALUE (parm),
6861 DECL_ARG_TYPE (found) = TREE_TYPE (found);
6862 DECL_SOURCE_LINE (found) = DECL_SOURCE_LINE (fndecl);
6863 DECL_SOURCE_FILE (found) = DECL_SOURCE_FILE (fndecl);
6864 error_with_decl (found, "type of parameter `%s' is not declared");
6868 TREE_PURPOSE (parm) = found;
6870 /* Mark this decl as "already found" -- see test, above.
6871 It is safe to use DECL_RESULT for this
6872 since it is not used in PARM_DECLs or CONST_DECLs. */
6873 DECL_RESULT (found) = error_mark_node;
6876 /* Complain about any actual PARM_DECLs not matched with any names. */
6878 for (parm = parmdecls; parm; )
6880 tree next = TREE_CHAIN (parm);
6881 TREE_CHAIN (parm) = 0;
6883 /* Complain about args with incomplete types. */
6884 if (TYPE_SIZE (TREE_TYPE (parm)) == 0)
6886 error_with_decl (parm, "parameter `%s' has incomplete type");
6887 TREE_TYPE (parm) = error_mark_node;
6890 if (DECL_RESULT (parm) == 0)
6892 error_with_decl (parm,
6893 "declaration for parameter `%s' but no such parameter");
6894 /* Pretend the parameter was not missing.
6895 This gets us to a standard state and minimizes
6896 further error messages. */
6898 = chainon (specparms,
6899 tree_cons (parm, NULL_TREE, NULL_TREE));
6905 /* Chain the declarations together in the order of the list of names.
6906 At the same time, build up a list of their types, in reverse order. */
6912 for (last = 0; parm; parm = TREE_CHAIN (parm))
6913 if (TREE_PURPOSE (parm))
6916 parmdecls = TREE_PURPOSE (parm);
6918 TREE_CHAIN (last) = TREE_PURPOSE (parm);
6919 last = TREE_PURPOSE (parm);
6920 TREE_CHAIN (last) = 0;
6922 types = saveable_tree_cons (NULL_TREE, TREE_TYPE (parm), types);
6927 return saveable_tree_cons (parmdecls, nonparms,
6928 nreverse (saveable_tree_cons (NULL_TREE,
6932 return saveable_tree_cons (parmdecls, nonparms, nreverse (types));
6935 /* Finish up a function declaration and compile that function
6936 all the way to assembler language output. The free the storage
6937 for the function definition.
6939 This is called after parsing the body of the function definition.
6941 NESTED is nonzero if the function being finished is nested in another. */
6944 finish_function (nested)
6947 register tree fndecl = current_function_decl;
6949 /* TREE_READONLY (fndecl) = 1;
6950 This caused &foo to be of type ptr-to-const-function
6951 which then got a warning when stored in a ptr-to-function variable. */
6954 BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl)) = fndecl;
6956 /* Must mark the RESULT_DECL as being in this function. */
6958 DECL_CONTEXT (DECL_RESULT (fndecl)) = fndecl;
6960 /* Obey `register' declarations if `setjmp' is called in this fn. */
6961 if (flag_traditional && current_function_calls_setjmp)
6963 setjmp_protect (DECL_INITIAL (fndecl));
6964 setjmp_protect_args ();
6967 if (! strcmp (IDENTIFIER_POINTER (DECL_NAME (fndecl)), "main"))
6969 if (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (fndecl)))
6970 != integer_type_node)
6972 /* You would expect the sense of this test to be the other way
6973 around, but if warn_main is set, we will already have warned,
6974 so this would be a duplicate. This is the warning you get
6975 in some environments even if you *don't* ask for it, because
6976 these are environments where it may be more of a problem than
6979 pedwarn_with_decl (fndecl, "return type of `%s' is not `int'");
6983 #ifdef DEFAULT_MAIN_RETURN
6984 /* Make it so that `main' always returns success by default. */
6985 DEFAULT_MAIN_RETURN;
6990 /* Generate rtl for function exit. */
6991 expand_function_end (input_filename, lineno, 0);
6993 /* So we can tell if jump_optimize sets it to 1. */
6996 /* Run the optimizers and output the assembler code for this function. */
6997 rest_of_compilation (fndecl);
6999 current_function_returns_null |= can_reach_end;
7001 if (TREE_THIS_VOLATILE (fndecl) && current_function_returns_null)
7002 warning ("`noreturn' function does return");
7003 else if (warn_return_type && can_reach_end
7004 && TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (fndecl))) != void_type_node)
7005 /* If this function returns non-void and control can drop through,
7007 warning ("control reaches end of non-void function");
7008 /* With just -W, complain only if function returns both with
7009 and without a value. */
7010 else if (extra_warnings
7011 && current_function_returns_value && current_function_returns_null)
7012 warning ("this function may return with or without a value");
7014 /* If requested, warn about function definitions where the function will
7015 return a value (usually of some struct or union type) which itself will
7016 take up a lot of stack space. */
7018 if (warn_larger_than && !DECL_EXTERNAL (fndecl) && TREE_TYPE (fndecl))
7020 register tree ret_type = TREE_TYPE (TREE_TYPE (fndecl));
7024 register tree ret_type_size = TYPE_SIZE (ret_type);
7026 if (TREE_CODE (ret_type_size) == INTEGER_CST)
7029 = TREE_INT_CST_LOW (ret_type_size) / BITS_PER_UNIT;
7031 if (units > larger_than_size)
7032 warning_with_decl (fndecl,
7033 "size of return value of `%s' is %u bytes",
7039 /* Free all the tree nodes making up this function. */
7040 /* Switch back to allocating nodes permanently
7041 until we start another function. */
7043 permanent_allocation (1);
7045 if (DECL_SAVED_INSNS (fndecl) == 0 && ! nested)
7047 /* Stop pointing to the local nodes about to be freed. */
7048 /* But DECL_INITIAL must remain nonzero so we know this
7049 was an actual function definition. */
7050 /* For a nested function, this is done in pop_c_function_context. */
7051 /* If rest_of_compilation set this to 0, leave it 0. */
7052 if (DECL_INITIAL (fndecl) != 0)
7053 DECL_INITIAL (fndecl) = error_mark_node;
7054 DECL_ARGUMENTS (fndecl) = 0;
7057 if (DECL_STATIC_CONSTRUCTOR (fndecl))
7059 #ifndef ASM_OUTPUT_CONSTRUCTOR
7060 if (! flag_gnu_linker)
7061 static_ctors = perm_tree_cons (NULL_TREE, fndecl, static_ctors);
7064 assemble_constructor (IDENTIFIER_POINTER (DECL_NAME (fndecl)));
7066 if (DECL_STATIC_DESTRUCTOR (fndecl))
7068 #ifndef ASM_OUTPUT_DESTRUCTOR
7069 if (! flag_gnu_linker)
7070 static_dtors = perm_tree_cons (NULL_TREE, fndecl, static_dtors);
7073 assemble_destructor (IDENTIFIER_POINTER (DECL_NAME (fndecl)));
7078 /* Let the error reporting routines know that we're outside a
7079 function. For a nested function, this value is used in
7080 pop_c_function_context and then reset via pop_function_context. */
7081 current_function_decl = NULL;
7085 /* Save and restore the variables in this file and elsewhere
7086 that keep track of the progress of compilation of the current function.
7087 Used for nested functions. */
7091 struct c_function *next;
7093 tree shadowed_labels;
7096 int warn_about_return_type;
7098 struct binding_level *binding_level;
7101 struct c_function *c_function_chain;
7103 /* Save and reinitialize the variables
7104 used during compilation of a C function. */
7107 push_c_function_context ()
7109 struct c_function *p
7110 = (struct c_function *) xmalloc (sizeof (struct c_function));
7113 pedwarn ("ANSI C forbids nested functions");
7115 push_function_context ();
7117 p->next = c_function_chain;
7118 c_function_chain = p;
7120 p->named_labels = named_labels;
7121 p->shadowed_labels = shadowed_labels;
7122 p->returns_value = current_function_returns_value;
7123 p->returns_null = current_function_returns_null;
7124 p->warn_about_return_type = warn_about_return_type;
7125 p->extern_inline = current_extern_inline;
7126 p->binding_level = current_binding_level;
7129 /* Restore the variables used during compilation of a C function. */
7132 pop_c_function_context ()
7134 struct c_function *p = c_function_chain;
7137 /* Bring back all the labels that were shadowed. */
7138 for (link = shadowed_labels; link; link = TREE_CHAIN (link))
7139 if (DECL_NAME (TREE_VALUE (link)) != 0)
7140 IDENTIFIER_LABEL_VALUE (DECL_NAME (TREE_VALUE (link)))
7141 = TREE_VALUE (link);
7143 if (DECL_SAVED_INSNS (current_function_decl) == 0)
7145 /* Stop pointing to the local nodes about to be freed. */
7146 /* But DECL_INITIAL must remain nonzero so we know this
7147 was an actual function definition. */
7148 DECL_INITIAL (current_function_decl) = error_mark_node;
7149 DECL_ARGUMENTS (current_function_decl) = 0;
7152 pop_function_context ();
7154 c_function_chain = p->next;
7156 named_labels = p->named_labels;
7157 shadowed_labels = p->shadowed_labels;
7158 current_function_returns_value = p->returns_value;
7159 current_function_returns_null = p->returns_null;
7160 warn_about_return_type = p->warn_about_return_type;
7161 current_extern_inline = p->extern_inline;
7162 current_binding_level = p->binding_level;
7167 /* integrate_decl_tree calls this function, but since we don't use the
7168 DECL_LANG_SPECIFIC field, this is a no-op. */
7171 copy_lang_decl (node)