1 /* Process declarations and variables for C compiler.
2 Copyright (C) 1988, 1992, 1993, 1994, 1995 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, 675 Mass Ave, Cambridge, MA 02139, USA. */
21 /* Process declarations and symbol lookup for C front end.
22 Also constructs types; the standard scalar types at initialization,
23 and structure, union, array and enum types when they are declared. */
25 /* ??? not all decl nodes are given the most useful possible
26 line numbers. For example, the CONST_DECLs for enum values. */
36 /* In grokdeclarator, distinguish syntactic contexts of declarators. */
38 { NORMAL
, /* Ordinary declaration */
39 FUNCDEF
, /* Function definition */
40 PARM
, /* Declaration of parm before function body */
41 FIELD
, /* Declaration inside struct or union */
42 BITFIELD
, /* Likewise but with specified width */
43 TYPENAME
}; /* Typename (inside cast or sizeof) */
45 #ifndef CHAR_TYPE_SIZE
46 #define CHAR_TYPE_SIZE BITS_PER_UNIT
49 #ifndef SHORT_TYPE_SIZE
50 #define SHORT_TYPE_SIZE (BITS_PER_UNIT * MIN ((UNITS_PER_WORD + 1) / 2, 2))
54 #define INT_TYPE_SIZE BITS_PER_WORD
57 #ifndef LONG_TYPE_SIZE
58 #define LONG_TYPE_SIZE BITS_PER_WORD
61 #ifndef LONG_LONG_TYPE_SIZE
62 #define LONG_LONG_TYPE_SIZE (BITS_PER_WORD * 2)
65 #ifndef WCHAR_UNSIGNED
66 #define WCHAR_UNSIGNED 0
69 #ifndef FLOAT_TYPE_SIZE
70 #define FLOAT_TYPE_SIZE BITS_PER_WORD
73 #ifndef DOUBLE_TYPE_SIZE
74 #define DOUBLE_TYPE_SIZE (BITS_PER_WORD * 2)
77 #ifndef LONG_DOUBLE_TYPE_SIZE
78 #define LONG_DOUBLE_TYPE_SIZE (BITS_PER_WORD * 2)
81 /* We let tm.h override the types used here, to handle trivial differences
82 such as the choice of unsigned int or long unsigned int for size_t.
83 When machines start needing nontrivial differences in the size type,
84 it would be best to do something here to figure out automatically
85 from other information what type to use. */
88 #define SIZE_TYPE "long unsigned int"
92 #define PTRDIFF_TYPE "long int"
96 #define WCHAR_TYPE "int"
99 /* a node which has tree code ERROR_MARK, and whose type is itself.
100 All erroneous expressions are replaced with this node. All functions
101 that accept nodes as arguments should avoid generating error messages
102 if this node is one of the arguments, since it is undesirable to get
103 multiple error messages from one error in the input. */
105 tree error_mark_node
;
107 /* INTEGER_TYPE and REAL_TYPE nodes for the standard data types */
109 tree short_integer_type_node
;
110 tree integer_type_node
;
111 tree long_integer_type_node
;
112 tree long_long_integer_type_node
;
114 tree short_unsigned_type_node
;
115 tree unsigned_type_node
;
116 tree long_unsigned_type_node
;
117 tree long_long_unsigned_type_node
;
119 tree boolean_type_node
;
120 tree boolean_false_node
;
121 tree boolean_true_node
;
123 tree ptrdiff_type_node
;
125 tree unsigned_char_type_node
;
126 tree signed_char_type_node
;
128 tree wchar_type_node
;
129 tree signed_wchar_type_node
;
130 tree unsigned_wchar_type_node
;
132 tree float_type_node
;
133 tree double_type_node
;
134 tree long_double_type_node
;
136 tree complex_integer_type_node
;
137 tree complex_float_type_node
;
138 tree complex_double_type_node
;
139 tree complex_long_double_type_node
;
141 tree intQI_type_node
;
142 tree intHI_type_node
;
143 tree intSI_type_node
;
144 tree intDI_type_node
;
146 tree unsigned_intQI_type_node
;
147 tree unsigned_intHI_type_node
;
148 tree unsigned_intSI_type_node
;
149 tree unsigned_intDI_type_node
;
151 /* a VOID_TYPE node. */
155 /* Nodes for types `void *' and `const void *'. */
157 tree ptr_type_node
, const_ptr_type_node
;
159 /* Nodes for types `char *' and `const char *'. */
161 tree string_type_node
, const_string_type_node
;
163 /* Type `char[SOMENUMBER]'.
164 Used when an array of char is needed and the size is irrelevant. */
166 tree char_array_type_node
;
168 /* Type `int[SOMENUMBER]' or something like it.
169 Used when an array of int needed and the size is irrelevant. */
171 tree int_array_type_node
;
173 /* Type `wchar_t[SOMENUMBER]' or something like it.
174 Used when a wide string literal is created. */
176 tree wchar_array_type_node
;
178 /* type `int ()' -- used for implicit declaration of functions. */
180 tree default_function_type
;
182 /* function types `double (double)' and `double (double, double)', etc. */
184 tree double_ftype_double
, double_ftype_double_double
;
185 tree int_ftype_int
, long_ftype_long
;
186 tree float_ftype_float
;
187 tree ldouble_ftype_ldouble
;
189 /* Function type `void (void *, void *, int)' and similar ones */
191 tree void_ftype_ptr_ptr_int
, int_ftype_ptr_ptr_int
, void_ftype_ptr_int_int
;
193 /* Function type `char *(char *, char *)' and similar ones */
194 tree string_ftype_ptr_ptr
, int_ftype_string_string
;
196 /* Function type `int (const void *, const void *, size_t)' */
197 tree int_ftype_cptr_cptr_sizet
;
199 /* Two expressions that are constants with value zero.
200 The first is of type `int', the second of type `void *'. */
202 tree integer_zero_node
;
203 tree null_pointer_node
;
205 /* A node for the integer constant 1. */
207 tree integer_one_node
;
209 /* Nonzero if we have seen an invalid cross reference
210 to a struct, union, or enum, but not yet printed the message. */
212 tree pending_invalid_xref
;
213 /* File and line to appear in the eventual error message. */
214 char *pending_invalid_xref_file
;
215 int pending_invalid_xref_line
;
217 /* While defining an enum type, this is 1 plus the last enumerator
218 constant value. Note that will do not have to save this or `enum_overflow'
219 around nested function definition since such a definition could only
220 occur in an enum value expression and we don't use these variables in
223 static tree enum_next_value
;
225 /* Nonzero means that there was overflow computing enum_next_value. */
227 static int enum_overflow
;
229 /* Parsing a function declarator leaves a list of parameter names
230 or a chain or parameter decls here. */
232 static tree last_function_parms
;
234 /* Parsing a function declarator leaves here a chain of structure
235 and enum types declared in the parmlist. */
237 static tree last_function_parm_tags
;
239 /* After parsing the declarator that starts a function definition,
240 `start_function' puts here the list of parameter names or chain of decls.
241 `store_parm_decls' finds it here. */
243 static tree current_function_parms
;
245 /* Similar, for last_function_parm_tags. */
246 static tree current_function_parm_tags
;
248 /* Similar, for the file and line that the prototype came from if this is
249 an old-style definition. */
250 static char *current_function_prototype_file
;
251 static int current_function_prototype_line
;
253 /* A list (chain of TREE_LIST nodes) of all LABEL_DECLs in the function
254 that have names. Here so we can clear out their names' definitions
255 at the end of the function. */
257 static tree named_labels
;
259 /* A list of LABEL_DECLs from outer contexts that are currently shadowed. */
261 static tree shadowed_labels
;
263 /* Nonzero when store_parm_decls is called indicates a varargs function.
264 Value not meaningful after store_parm_decls. */
266 static int c_function_varargs
;
268 /* The FUNCTION_DECL for the function currently being compiled,
269 or 0 if between functions. */
270 tree current_function_decl
;
272 /* Set to 0 at beginning of a function definition, set to 1 if
273 a return statement that specifies a return value is seen. */
275 int current_function_returns_value
;
277 /* Set to 0 at beginning of a function definition, set to 1 if
278 a return statement with no argument is seen. */
280 int current_function_returns_null
;
282 /* Set to nonzero by `grokdeclarator' for a function
283 whose return type is defaulted, if warnings for this are desired. */
285 static int warn_about_return_type
;
287 /* Nonzero when starting a function declared `extern inline'. */
289 static int current_extern_inline
;
291 /* For each binding contour we allocate a binding_level structure
292 * which records the names defined in that contour.
295 * 1) one for each function definition,
296 * where internal declarations of the parameters appear.
297 * 2) one for each compound statement,
298 * to record its declarations.
300 * The current meaning of a name can be found by searching the levels from
301 * the current one out to the global one.
304 /* Note that the information in the `names' component of the global contour
305 is duplicated in the IDENTIFIER_GLOBAL_VALUEs of all identifiers. */
309 /* A chain of _DECL nodes for all variables, constants, functions,
310 and typedef types. These are in the reverse of the order supplied.
314 /* A list of structure, union and enum definitions,
315 * for looking up tag names.
316 * It is a chain of TREE_LIST nodes, each of whose TREE_PURPOSE is a name,
317 * or NULL_TREE; and whose TREE_VALUE is a RECORD_TYPE, UNION_TYPE,
318 * or ENUMERAL_TYPE node.
322 /* For each level, a list of shadowed outer-level local definitions
323 to be restored when this level is popped.
324 Each link is a TREE_LIST whose TREE_PURPOSE is an identifier and
325 whose TREE_VALUE is its old definition (a kind of ..._DECL node). */
328 /* For each level (except not the global one),
329 a chain of BLOCK nodes for all the levels
330 that were entered and exited one level down. */
333 /* The BLOCK node for this level, if one has been preallocated.
334 If 0, the BLOCK is allocated (if needed) when the level is popped. */
337 /* The binding level which this one is contained in (inherits from). */
338 struct binding_level
*level_chain
;
340 /* Nonzero for the level that holds the parameters of a function. */
343 /* Nonzero if this level "doesn't exist" for tags. */
344 char tag_transparent
;
346 /* Nonzero if sublevels of this level "don't exist" for tags.
347 This is set in the parm level of a function definition
348 while reading the function body, so that the outermost block
349 of the function body will be tag-transparent. */
350 char subblocks_tag_transparent
;
352 /* Nonzero means make a BLOCK for this level regardless of all else. */
355 /* Nonzero means make a BLOCK if this level has any subblocks. */
356 char keep_if_subblocks
;
358 /* Number of decls in `names' that have incomplete
359 structure or union types. */
362 /* A list of decls giving the (reversed) specified order of parms,
363 not including any forward-decls in the parmlist.
364 This is so we can put the parms in proper order for assign_parms. */
368 #define NULL_BINDING_LEVEL (struct binding_level *) NULL
370 /* The binding level currently in effect. */
372 static struct binding_level
*current_binding_level
;
374 /* A chain of binding_level structures awaiting reuse. */
376 static struct binding_level
*free_binding_level
;
378 /* The outermost binding level, for names of file scope.
379 This is created when the compiler is started and exists
380 through the entire run. */
382 static struct binding_level
*global_binding_level
;
384 /* Binding level structures are initialized by copying this one. */
386 static struct binding_level clear_binding_level
387 = {NULL
, NULL
, NULL
, NULL
, NULL
, NULL_BINDING_LEVEL
, 0, 0, 0, 0, 0, 0,
390 /* Nonzero means unconditionally make a BLOCK for the next level pushed. */
392 static int keep_next_level_flag
;
394 /* Nonzero means make a BLOCK for the next level pushed
395 if it has subblocks. */
397 static int keep_next_if_subblocks
;
399 /* The chain of outer levels of label scopes.
400 This uses the same data structure used for binding levels,
401 but it works differently: each link in the chain records
402 saved values of named_labels and shadowed_labels for
403 a label binding level outside the current one. */
405 static struct binding_level
*label_level_chain
;
407 /* Functions called automatically at the beginning and end of execution. */
409 tree static_ctors
, static_dtors
;
411 /* Forward declarations. */
413 static tree
grokparms (), grokdeclarator ();
415 tree
builtin_function ();
416 void shadow_tag_warned ();
418 static tree
lookup_tag ();
419 static tree
lookup_tag_reverse ();
420 tree
lookup_name_current_level ();
421 static char *redeclaration_error_message ();
422 static void layout_array_type ();
424 /* C-specific option variables. */
426 /* Nonzero means allow type mismatches in conditional expressions;
427 just make their values `void'. */
429 int flag_cond_mismatch
;
431 /* Nonzero means give `double' the same size as `float'. */
433 int flag_short_double
;
435 /* Nonzero means don't recognize the keyword `asm'. */
439 /* Nonzero means don't recognize any builtin functions. */
443 /* Nonzero means don't recognize the non-ANSI builtin functions.
446 int flag_no_nonansi_builtin
;
448 /* Nonzero means do some things the same way PCC does. */
450 int flag_traditional
;
452 /* Nonzero means to allow single precision math even if we're generally
453 being traditional. */
454 int flag_allow_single_precision
= 0;
456 /* Nonzero means to treat bitfields as signed unless they say `unsigned'. */
458 int flag_signed_bitfields
= 1;
459 int explicit_flag_signed_bitfields
= 0;
461 /* Nonzero means handle `#ident' directives. 0 means ignore them. */
463 int flag_no_ident
= 0;
465 /* Nonzero means warn about implicit declarations. */
469 /* Nonzero means give string constants the type `const char *'
470 to get extra warnings from them. These warnings will be too numerous
471 to be useful, except in thoroughly ANSIfied programs. */
473 int warn_write_strings
;
475 /* Nonzero means warn about pointer casts that can drop a type qualifier
476 from the pointer target type. */
480 /* Nonzero means warn when casting a function call to a type that does
481 not match the return type (e.g. (float)sqrt() or (anything*)malloc()
482 when there is no previous declaration of sqrt or malloc. */
484 int warn_bad_function_cast
;
486 /* Warn about traditional constructs whose meanings changed in ANSI C. */
488 int warn_traditional
;
490 /* Nonzero means warn about sizeof(function) or addition/subtraction
491 of function pointers. */
493 int warn_pointer_arith
;
495 /* Nonzero means warn for non-prototype function decls
496 or non-prototyped defs without previous prototype. */
498 int warn_strict_prototypes
;
500 /* Nonzero means warn for any global function def
501 without separate previous prototype decl. */
503 int warn_missing_prototypes
;
505 /* Nonzero means warn for any global function def
506 without separate previous decl. */
508 int warn_missing_declarations
;
510 /* Nonzero means warn about multiple (redundant) decls for the same single
511 variable or function. */
513 int warn_redundant_decls
= 0;
515 /* Nonzero means warn about extern declarations of objects not at
516 file-scope level and about *all* declarations of functions (whether
517 extern or static) not at file-scope level. Note that we exclude
518 implicit function declarations. To get warnings about those, use
521 int warn_nested_externs
= 0;
523 /* Warn about *printf or *scanf format/argument anomalies. */
527 /* Warn about a subscript that has type char. */
529 int warn_char_subscripts
= 0;
531 /* Warn if a type conversion is done that might have confusing results. */
535 /* Warn if adding () is suggested. */
537 int warn_parentheses
;
539 /* Warn if initializer is not completely bracketed. */
541 int warn_missing_braces
;
543 /* Nonzero means `$' can be in an identifier.
544 See cccp.c for reasons why this breaks some obscure ANSI C programs. */
546 #ifndef DOLLARS_IN_IDENTIFIERS
547 #define DOLLARS_IN_IDENTIFIERS 1
549 int dollars_in_ident
= DOLLARS_IN_IDENTIFIERS
> 1;
551 /* Decode the string P as a language-specific option for C.
552 Return 1 if it is recognized (and handle it);
553 return 0 if not recognized. */
559 if (!strcmp (p
, "-ftraditional") || !strcmp (p
, "-traditional"))
561 flag_traditional
= 1;
562 flag_writable_strings
= 1;
563 #if DOLLARS_IN_IDENTIFIERS > 0
564 dollars_in_ident
= 1;
567 else if (!strcmp (p
, "-fallow-single-precision"))
568 flag_allow_single_precision
= 1;
569 else if (!strcmp (p
, "-fnotraditional") || !strcmp (p
, "-fno-traditional"))
571 flag_traditional
= 0;
572 flag_writable_strings
= 0;
573 dollars_in_ident
= DOLLARS_IN_IDENTIFIERS
> 1;
575 else if (!strcmp (p
, "-fdollars-in-identifiers"))
577 #if DOLLARS_IN_IDENTIFIERS > 0
578 dollars_in_ident
= 1;
581 else if (!strcmp (p
, "-fno-dollars-in-identifiers"))
582 dollars_in_ident
= 0;
583 else if (!strcmp (p
, "-fsigned-char"))
584 flag_signed_char
= 1;
585 else if (!strcmp (p
, "-funsigned-char"))
586 flag_signed_char
= 0;
587 else if (!strcmp (p
, "-fno-signed-char"))
588 flag_signed_char
= 0;
589 else if (!strcmp (p
, "-fno-unsigned-char"))
590 flag_signed_char
= 1;
591 else if (!strcmp (p
, "-fsigned-bitfields")
592 || !strcmp (p
, "-fno-unsigned-bitfields"))
594 flag_signed_bitfields
= 1;
595 explicit_flag_signed_bitfields
= 1;
597 else if (!strcmp (p
, "-funsigned-bitfields")
598 || !strcmp (p
, "-fno-signed-bitfields"))
600 flag_signed_bitfields
= 0;
601 explicit_flag_signed_bitfields
= 1;
603 else if (!strcmp (p
, "-fshort-enums"))
604 flag_short_enums
= 1;
605 else if (!strcmp (p
, "-fno-short-enums"))
606 flag_short_enums
= 0;
607 else if (!strcmp (p
, "-fcond-mismatch"))
608 flag_cond_mismatch
= 1;
609 else if (!strcmp (p
, "-fno-cond-mismatch"))
610 flag_cond_mismatch
= 0;
611 else if (!strcmp (p
, "-fshort-double"))
612 flag_short_double
= 1;
613 else if (!strcmp (p
, "-fno-short-double"))
614 flag_short_double
= 0;
615 else if (!strcmp (p
, "-fasm"))
617 else if (!strcmp (p
, "-fno-asm"))
619 else if (!strcmp (p
, "-fbuiltin"))
621 else if (!strcmp (p
, "-fno-builtin"))
623 else if (!strcmp (p
, "-fno-ident"))
625 else if (!strcmp (p
, "-fident"))
627 else if (!strcmp (p
, "-ansi"))
628 flag_no_asm
= 1, flag_no_nonansi_builtin
= 1, dollars_in_ident
= 0;
629 else if (!strcmp (p
, "-Wimplicit"))
631 else if (!strcmp (p
, "-Wno-implicit"))
633 else if (!strcmp (p
, "-Wwrite-strings"))
634 warn_write_strings
= 1;
635 else if (!strcmp (p
, "-Wno-write-strings"))
636 warn_write_strings
= 0;
637 else if (!strcmp (p
, "-Wcast-qual"))
639 else if (!strcmp (p
, "-Wno-cast-qual"))
641 else if (!strcmp (p
, "-Wbad-function-cast"))
642 warn_bad_function_cast
= 1;
643 else if (!strcmp (p
, "-Wno-bad-function-cast"))
644 warn_bad_function_cast
= 0;
645 else if (!strcmp (p
, "-Wpointer-arith"))
646 warn_pointer_arith
= 1;
647 else if (!strcmp (p
, "-Wno-pointer-arith"))
648 warn_pointer_arith
= 0;
649 else if (!strcmp (p
, "-Wstrict-prototypes"))
650 warn_strict_prototypes
= 1;
651 else if (!strcmp (p
, "-Wno-strict-prototypes"))
652 warn_strict_prototypes
= 0;
653 else if (!strcmp (p
, "-Wmissing-prototypes"))
654 warn_missing_prototypes
= 1;
655 else if (!strcmp (p
, "-Wno-missing-prototypes"))
656 warn_missing_prototypes
= 0;
657 else if (!strcmp (p
, "-Wmissing-declarations"))
658 warn_missing_declarations
= 1;
659 else if (!strcmp (p
, "-Wno-missing-declarations"))
660 warn_missing_declarations
= 0;
661 else if (!strcmp (p
, "-Wredundant-decls"))
662 warn_redundant_decls
= 1;
663 else if (!strcmp (p
, "-Wno-redundant-decls"))
664 warn_redundant_decls
= 0;
665 else if (!strcmp (p
, "-Wnested-externs"))
666 warn_nested_externs
= 1;
667 else if (!strcmp (p
, "-Wno-nested-externs"))
668 warn_nested_externs
= 0;
669 else if (!strcmp (p
, "-Wtraditional"))
670 warn_traditional
= 1;
671 else if (!strcmp (p
, "-Wno-traditional"))
672 warn_traditional
= 0;
673 else if (!strcmp (p
, "-Wformat"))
675 else if (!strcmp (p
, "-Wno-format"))
677 else if (!strcmp (p
, "-Wchar-subscripts"))
678 warn_char_subscripts
= 1;
679 else if (!strcmp (p
, "-Wno-char-subscripts"))
680 warn_char_subscripts
= 0;
681 else if (!strcmp (p
, "-Wconversion"))
683 else if (!strcmp (p
, "-Wno-conversion"))
685 else if (!strcmp (p
, "-Wparentheses"))
686 warn_parentheses
= 1;
687 else if (!strcmp (p
, "-Wno-parentheses"))
688 warn_parentheses
= 0;
689 else if (!strcmp (p
, "-Wreturn-type"))
690 warn_return_type
= 1;
691 else if (!strcmp (p
, "-Wno-return-type"))
692 warn_return_type
= 0;
693 else if (!strcmp (p
, "-Wcomment"))
694 ; /* cpp handles this one. */
695 else if (!strcmp (p
, "-Wno-comment"))
696 ; /* cpp handles this one. */
697 else if (!strcmp (p
, "-Wcomments"))
698 ; /* cpp handles this one. */
699 else if (!strcmp (p
, "-Wno-comments"))
700 ; /* cpp handles this one. */
701 else if (!strcmp (p
, "-Wtrigraphs"))
702 ; /* cpp handles this one. */
703 else if (!strcmp (p
, "-Wno-trigraphs"))
704 ; /* cpp handles this one. */
705 else if (!strcmp (p
, "-Wimport"))
706 ; /* cpp handles this one. */
707 else if (!strcmp (p
, "-Wno-import"))
708 ; /* cpp handles this one. */
709 else if (!strcmp (p
, "-Wmissing-braces"))
710 warn_missing_braces
= 1;
711 else if (!strcmp (p
, "-Wno-missing-braces"))
712 warn_missing_braces
= 0;
713 else if (!strcmp (p
, "-Wall"))
716 /* We save the value of warn_uninitialized, since if they put
717 -Wuninitialized on the command line, we need to generate a
718 warning about not using it without also specifying -O. */
719 if (warn_uninitialized
!= 1)
720 warn_uninitialized
= 2;
722 warn_return_type
= 1;
726 warn_char_subscripts
= 1;
727 warn_parentheses
= 1;
728 warn_missing_braces
= 1;
736 /* Hooks for print_node. */
739 print_lang_decl (file
, node
, indent
)
747 print_lang_type (file
, node
, indent
)
755 print_lang_identifier (file
, node
, indent
)
760 print_node (file
, "global", IDENTIFIER_GLOBAL_VALUE (node
), indent
+ 4);
761 print_node (file
, "local", IDENTIFIER_LOCAL_VALUE (node
), indent
+ 4);
762 print_node (file
, "label", IDENTIFIER_LABEL_VALUE (node
), indent
+ 4);
763 print_node (file
, "implicit", IDENTIFIER_IMPLICIT_DECL (node
), indent
+ 4);
764 print_node (file
, "error locus", IDENTIFIER_ERROR_LOCUS (node
), indent
+ 4);
765 print_node (file
, "limbo value", IDENTIFIER_LIMBO_VALUE (node
), indent
+ 4);
768 /* Hook called at end of compilation to assume 1 elt
769 for a top-level array decl that wasn't complete before. */
772 finish_incomplete_decl (decl
)
775 if (TREE_CODE (decl
) == VAR_DECL
&& TREE_TYPE (decl
) != error_mark_node
)
777 tree type
= TREE_TYPE (decl
);
778 if (TREE_CODE (type
) == ARRAY_TYPE
779 && TYPE_DOMAIN (type
) == 0
780 && TREE_CODE (decl
) != TYPE_DECL
)
782 complete_array_type (type
, NULL_TREE
, 1);
784 layout_decl (decl
, 0);
789 /* Create a new `struct binding_level'. */
792 struct binding_level
*
793 make_binding_level ()
796 return (struct binding_level
*) xmalloc (sizeof (struct binding_level
));
799 /* Nonzero if we are currently in the global binding level. */
804 return current_binding_level
== global_binding_level
;
810 keep_next_level_flag
= 1;
813 /* Nonzero if the current level needs to have a BLOCK made. */
818 return ((current_binding_level
->keep_if_subblocks
819 && current_binding_level
->blocks
!= 0)
820 || current_binding_level
->keep
821 || current_binding_level
->names
!= 0
822 || (current_binding_level
->tags
!= 0
823 && !current_binding_level
->tag_transparent
));
826 /* Identify this binding level as a level of parameters.
827 DEFINITION_FLAG is 1 for a definition, 0 for a declaration.
828 But it turns out there is no way to pass the right value for
829 DEFINITION_FLAG, so we ignore it. */
832 declare_parm_level (definition_flag
)
835 current_binding_level
->parm_flag
= 1;
838 /* Nonzero if currently making parm declarations. */
843 return current_binding_level
->parm_flag
;
846 /* Enter a new binding level.
847 If TAG_TRANSPARENT is nonzero, do so only for the name space of variables,
848 not for that of tags. */
851 pushlevel (tag_transparent
)
854 register struct binding_level
*newlevel
= NULL_BINDING_LEVEL
;
856 /* If this is the top level of a function,
857 just make sure that NAMED_LABELS is 0. */
859 if (current_binding_level
== global_binding_level
)
864 /* Reuse or create a struct for this binding level. */
866 if (free_binding_level
)
868 newlevel
= free_binding_level
;
869 free_binding_level
= free_binding_level
->level_chain
;
873 newlevel
= make_binding_level ();
876 /* Add this level to the front of the chain (stack) of levels that
879 *newlevel
= clear_binding_level
;
880 newlevel
->tag_transparent
882 || (current_binding_level
883 ? current_binding_level
->subblocks_tag_transparent
885 newlevel
->level_chain
= current_binding_level
;
886 current_binding_level
= newlevel
;
887 newlevel
->keep
= keep_next_level_flag
;
888 keep_next_level_flag
= 0;
889 newlevel
->keep_if_subblocks
= keep_next_if_subblocks
;
890 keep_next_if_subblocks
= 0;
893 /* Exit a binding level.
894 Pop the level off, and restore the state of the identifier-decl mappings
895 that were in effect when this level was entered.
897 If KEEP is nonzero, this level had explicit declarations, so
898 and create a "block" (a BLOCK node) for the level
899 to record its declarations and subblocks for symbol table output.
901 If FUNCTIONBODY is nonzero, this level is the body of a function,
902 so create a block as if KEEP were set and also clear out all
905 If REVERSE is nonzero, reverse the order of decls before putting
906 them into the BLOCK. */
909 poplevel (keep
, reverse
, functionbody
)
915 /* The chain of decls was accumulated in reverse order.
916 Put it into forward order, just for cleanliness. */
918 tree tags
= current_binding_level
->tags
;
919 tree subblocks
= current_binding_level
->blocks
;
922 int block_previously_created
;
924 keep
|= current_binding_level
->keep
;
926 /* This warning is turned off because it causes warnings for
927 declarations like `extern struct foo *x'. */
929 /* Warn about incomplete structure types in this level. */
930 for (link
= tags
; link
; link
= TREE_CHAIN (link
))
931 if (TYPE_SIZE (TREE_VALUE (link
)) == 0)
933 tree type
= TREE_VALUE (link
);
935 switch (TREE_CODE (type
))
938 errmsg
= "`struct %s' incomplete in scope ending here";
941 errmsg
= "`union %s' incomplete in scope ending here";
944 errmsg
= "`enum %s' incomplete in scope ending here";
947 if (TREE_CODE (TYPE_NAME (type
)) == IDENTIFIER_NODE
)
948 error (errmsg
, IDENTIFIER_POINTER (TYPE_NAME (type
)));
950 /* If this type has a typedef-name, the TYPE_NAME is a TYPE_DECL. */
951 error (errmsg
, IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type
))));
955 /* Get the decls in the order they were written.
956 Usually current_binding_level->names is in reverse order.
957 But parameter decls were previously put in forward order. */
960 current_binding_level
->names
961 = decls
= nreverse (current_binding_level
->names
);
963 decls
= current_binding_level
->names
;
965 /* Output any nested inline functions within this block
966 if they weren't already output. */
968 for (decl
= decls
; decl
; decl
= TREE_CHAIN (decl
))
969 if (TREE_CODE (decl
) == FUNCTION_DECL
970 && ! TREE_ASM_WRITTEN (decl
)
971 && DECL_INITIAL (decl
) != 0
972 && TREE_ADDRESSABLE (decl
))
974 /* If this decl was copied from a file-scope decl
975 on account of a block-scope extern decl,
976 propagate TREE_ADDRESSABLE to the file-scope decl.
978 DECL_ABSTRACT_ORIGIN can be set to itself if warn_return_type is
979 true, since then the decl goes through save_for_inline_copying. */
980 if (DECL_ABSTRACT_ORIGIN (decl
) != 0
981 && DECL_ABSTRACT_ORIGIN (decl
) != decl
)
982 TREE_ADDRESSABLE (DECL_ABSTRACT_ORIGIN (decl
)) = 1;
985 push_function_context ();
986 output_inline_function (decl
);
987 pop_function_context ();
991 /* If there were any declarations or structure tags in that level,
992 or if this level is a function body,
993 create a BLOCK to record them for the life of this function. */
996 block_previously_created
= (current_binding_level
->this_block
!= 0);
997 if (block_previously_created
)
998 block
= current_binding_level
->this_block
;
999 else if (keep
|| functionbody
1000 || (current_binding_level
->keep_if_subblocks
&& subblocks
!= 0))
1001 block
= make_node (BLOCK
);
1004 BLOCK_VARS (block
) = decls
;
1005 BLOCK_TYPE_TAGS (block
) = tags
;
1006 BLOCK_SUBBLOCKS (block
) = subblocks
;
1007 remember_end_note (block
);
1010 /* In each subblock, record that this is its superior. */
1012 for (link
= subblocks
; link
; link
= TREE_CHAIN (link
))
1013 BLOCK_SUPERCONTEXT (link
) = block
;
1015 /* Clear out the meanings of the local variables of this level. */
1017 for (link
= decls
; link
; link
= TREE_CHAIN (link
))
1019 if (DECL_NAME (link
) != 0)
1021 /* If the ident. was used or addressed via a local extern decl,
1022 don't forget that fact. */
1023 if (DECL_EXTERNAL (link
))
1025 if (TREE_USED (link
))
1026 TREE_USED (DECL_NAME (link
)) = 1;
1027 if (TREE_ADDRESSABLE (link
))
1028 TREE_ADDRESSABLE (DECL_ASSEMBLER_NAME (link
)) = 1;
1030 IDENTIFIER_LOCAL_VALUE (DECL_NAME (link
)) = 0;
1034 /* Restore all name-meanings of the outer levels
1035 that were shadowed by this level. */
1037 for (link
= current_binding_level
->shadowed
; link
; link
= TREE_CHAIN (link
))
1038 IDENTIFIER_LOCAL_VALUE (TREE_PURPOSE (link
)) = TREE_VALUE (link
);
1040 /* If the level being exited is the top level of a function,
1041 check over all the labels, and clear out the current
1042 (function local) meanings of their names. */
1046 /* If this is the top level block of a function,
1047 the vars are the function's parameters.
1048 Don't leave them in the BLOCK because they are
1049 found in the FUNCTION_DECL instead. */
1051 BLOCK_VARS (block
) = 0;
1053 /* Clear out the definitions of all label names,
1054 since their scopes end here,
1055 and add them to BLOCK_VARS. */
1057 for (link
= named_labels
; link
; link
= TREE_CHAIN (link
))
1059 register tree label
= TREE_VALUE (link
);
1061 if (DECL_INITIAL (label
) == 0)
1063 error_with_decl (label
, "label `%s' used but not defined");
1064 /* Avoid crashing later. */
1065 define_label (input_filename
, lineno
,
1068 else if (warn_unused
&& !TREE_USED (label
))
1069 warning_with_decl (label
, "label `%s' defined but not used");
1070 IDENTIFIER_LABEL_VALUE (DECL_NAME (label
)) = 0;
1072 /* Put the labels into the "variables" of the
1073 top-level block, so debugger can see them. */
1074 TREE_CHAIN (label
) = BLOCK_VARS (block
);
1075 BLOCK_VARS (block
) = label
;
1079 /* Pop the current level, and free the structure for reuse. */
1082 register struct binding_level
*level
= current_binding_level
;
1083 current_binding_level
= current_binding_level
->level_chain
;
1085 level
->level_chain
= free_binding_level
;
1086 free_binding_level
= level
;
1089 /* Dispose of the block that we just made inside some higher level. */
1091 DECL_INITIAL (current_function_decl
) = block
;
1094 if (!block_previously_created
)
1095 current_binding_level
->blocks
1096 = chainon (current_binding_level
->blocks
, block
);
1098 /* If we did not make a block for the level just exited,
1099 any blocks made for inner levels
1100 (since they cannot be recorded as subblocks in that level)
1101 must be carried forward so they will later become subblocks
1102 of something else. */
1104 current_binding_level
->blocks
1105 = chainon (current_binding_level
->blocks
, subblocks
);
1107 /* Set the TYPE_CONTEXTs for all of the tagged types belonging to this
1108 binding contour so that they point to the appropriate construct, i.e.
1109 either to the current FUNCTION_DECL node, or else to the BLOCK node
1110 we just constructed.
1112 Note that for tagged types whose scope is just the formal parameter
1113 list for some function type specification, we can't properly set
1114 their TYPE_CONTEXTs here, because we don't have a pointer to the
1115 appropriate FUNCTION_TYPE node readily available to us. For those
1116 cases, the TYPE_CONTEXTs of the relevant tagged type nodes get set
1117 in `grokdeclarator' as soon as we have created the FUNCTION_TYPE
1118 node which will represent the "scope" for these "parameter list local"
1123 for (link
= tags
; link
; link
= TREE_CHAIN (link
))
1124 TYPE_CONTEXT (TREE_VALUE (link
)) = current_function_decl
;
1126 for (link
= tags
; link
; link
= TREE_CHAIN (link
))
1127 TYPE_CONTEXT (TREE_VALUE (link
)) = block
;
1130 TREE_USED (block
) = 1;
1134 /* Delete the node BLOCK from the current binding level.
1135 This is used for the block inside a stmt expr ({...})
1136 so that the block can be reinserted where appropriate. */
1139 delete_block (block
)
1143 if (current_binding_level
->blocks
== block
)
1144 current_binding_level
->blocks
= TREE_CHAIN (block
);
1145 for (t
= current_binding_level
->blocks
; t
;)
1147 if (TREE_CHAIN (t
) == block
)
1148 TREE_CHAIN (t
) = TREE_CHAIN (block
);
1152 TREE_CHAIN (block
) = NULL
;
1153 /* Clear TREE_USED which is always set by poplevel.
1154 The flag is set again if insert_block is called. */
1155 TREE_USED (block
) = 0;
1158 /* Insert BLOCK at the end of the list of subblocks of the
1159 current binding level. This is used when a BIND_EXPR is expanded,
1160 to handle the BLOCK node inside the BIND_EXPR. */
1163 insert_block (block
)
1166 TREE_USED (block
) = 1;
1167 current_binding_level
->blocks
1168 = chainon (current_binding_level
->blocks
, block
);
1171 /* Set the BLOCK node for the innermost scope
1172 (the one we are currently in). */
1176 register tree block
;
1178 current_binding_level
->this_block
= block
;
1184 register struct binding_level
*newlevel
;
1186 /* Reuse or create a struct for this binding level. */
1188 if (free_binding_level
)
1190 newlevel
= free_binding_level
;
1191 free_binding_level
= free_binding_level
->level_chain
;
1195 newlevel
= make_binding_level ();
1198 /* Add this level to the front of the chain (stack) of label levels. */
1200 newlevel
->level_chain
= label_level_chain
;
1201 label_level_chain
= newlevel
;
1203 newlevel
->names
= named_labels
;
1204 newlevel
->shadowed
= shadowed_labels
;
1206 shadowed_labels
= 0;
1212 register struct binding_level
*level
= label_level_chain
;
1215 /* Clear out the definitions of the declared labels in this level.
1216 Leave in the list any ordinary, non-declared labels. */
1217 for (link
= named_labels
, prev
= 0; link
;)
1219 if (C_DECLARED_LABEL_FLAG (TREE_VALUE (link
)))
1221 if (DECL_SOURCE_LINE (TREE_VALUE (link
)) == 0)
1223 error_with_decl (TREE_VALUE (link
),
1224 "label `%s' used but not defined");
1225 /* Avoid crashing later. */
1226 define_label (input_filename
, lineno
,
1227 DECL_NAME (TREE_VALUE (link
)));
1229 else if (warn_unused
&& !TREE_USED (TREE_VALUE (link
)))
1230 warning_with_decl (TREE_VALUE (link
),
1231 "label `%s' defined but not used");
1232 IDENTIFIER_LABEL_VALUE (DECL_NAME (TREE_VALUE (link
))) = 0;
1234 /* Delete this element from the list. */
1235 link
= TREE_CHAIN (link
);
1237 TREE_CHAIN (prev
) = link
;
1239 named_labels
= link
;
1244 link
= TREE_CHAIN (link
);
1248 /* Bring back all the labels that were shadowed. */
1249 for (link
= shadowed_labels
; link
; link
= TREE_CHAIN (link
))
1250 if (DECL_NAME (TREE_VALUE (link
)) != 0)
1251 IDENTIFIER_LABEL_VALUE (DECL_NAME (TREE_VALUE (link
)))
1252 = TREE_VALUE (link
);
1254 named_labels
= chainon (named_labels
, level
->names
);
1255 shadowed_labels
= level
->shadowed
;
1257 /* Pop the current level, and free the structure for reuse. */
1258 label_level_chain
= label_level_chain
->level_chain
;
1259 level
->level_chain
= free_binding_level
;
1260 free_binding_level
= level
;
1263 /* Push a definition or a declaration of struct, union or enum tag "name".
1264 "type" should be the type node.
1265 We assume that the tag "name" is not already defined.
1267 Note that the definition may really be just a forward reference.
1268 In that case, the TYPE_SIZE will be zero. */
1271 pushtag (name
, type
)
1274 register struct binding_level
*b
;
1276 /* Find the proper binding level for this type tag. */
1278 for (b
= current_binding_level
; b
->tag_transparent
; b
= b
->level_chain
)
1283 /* Record the identifier as the type's name if it has none. */
1285 if (TYPE_NAME (type
) == 0)
1286 TYPE_NAME (type
) = name
;
1289 if (b
== global_binding_level
)
1290 b
->tags
= perm_tree_cons (name
, type
, b
->tags
);
1292 b
->tags
= saveable_tree_cons (name
, type
, b
->tags
);
1294 /* Create a fake NULL-named TYPE_DECL node whose TREE_TYPE will be the
1295 tagged type we just added to the current binding level. This fake
1296 NULL-named TYPE_DECL node helps dwarfout.c to know when it needs
1297 to output a representation of a tagged type, and it also gives
1298 us a convenient place to record the "scope start" address for the
1301 TYPE_STUB_DECL (type
) = pushdecl (build_decl (TYPE_DECL
, NULL_TREE
, type
));
1304 /* Handle when a new declaration NEWDECL
1305 has the same name as an old one OLDDECL
1306 in the same binding contour.
1307 Prints an error message if appropriate.
1309 If safely possible, alter OLDDECL to look like NEWDECL, and return 1.
1310 Otherwise, return 0. */
1313 duplicate_decls (newdecl
, olddecl
)
1314 register tree newdecl
, olddecl
;
1316 int types_match
= comptypes (TREE_TYPE (newdecl
), TREE_TYPE (olddecl
));
1317 int new_is_definition
= (TREE_CODE (newdecl
) == FUNCTION_DECL
1318 && DECL_INITIAL (newdecl
) != 0);
1319 tree oldtype
= TREE_TYPE (olddecl
);
1320 tree newtype
= TREE_TYPE (newdecl
);
1323 if (TREE_CODE_CLASS (TREE_CODE (olddecl
)) == 'd')
1324 DECL_MACHINE_ATTRIBUTES (newdecl
) = DECL_MACHINE_ATTRIBUTES (olddecl
);
1326 if (TREE_CODE (newtype
) == ERROR_MARK
1327 || TREE_CODE (oldtype
) == ERROR_MARK
)
1330 /* New decl is completely inconsistent with the old one =>
1331 tell caller to replace the old one.
1332 This is always an error except in the case of shadowing a builtin. */
1333 if (TREE_CODE (olddecl
) != TREE_CODE (newdecl
))
1335 if (TREE_CODE (olddecl
) == FUNCTION_DECL
1336 && (DECL_BUILT_IN (olddecl
)
1337 || DECL_BUILT_IN_NONANSI (olddecl
)))
1339 /* If you declare a built-in or predefined function name as static,
1340 the old definition is overridden,
1341 but optionally warn this was a bad choice of name. */
1342 if (!TREE_PUBLIC (newdecl
))
1346 else if (DECL_BUILT_IN (olddecl
))
1347 warning_with_decl (newdecl
, "shadowing built-in function `%s'");
1349 warning_with_decl (newdecl
, "shadowing library function `%s'");
1351 /* Likewise, if the built-in is not ansi, then programs can
1352 override it even globally without an error. */
1353 else if (! DECL_BUILT_IN (olddecl
))
1354 warning_with_decl (newdecl
,
1355 "library function `%s' declared as non-function");
1357 else if (DECL_BUILT_IN_NONANSI (olddecl
))
1358 warning_with_decl (newdecl
,
1359 "built-in function `%s' declared as non-function");
1361 warning_with_decl (newdecl
,
1362 "built-in function `%s' declared as non-function");
1366 error_with_decl (newdecl
, "`%s' redeclared as different kind of symbol");
1367 error_with_decl (olddecl
, "previous declaration of `%s'");
1373 /* For real parm decl following a forward decl,
1374 return 1 so old decl will be reused. */
1375 if (types_match
&& TREE_CODE (newdecl
) == PARM_DECL
1376 && TREE_ASM_WRITTEN (olddecl
) && ! TREE_ASM_WRITTEN (newdecl
))
1379 /* The new declaration is the same kind of object as the old one.
1380 The declarations may partially match. Print warnings if they don't
1381 match enough. Ultimately, copy most of the information from the new
1382 decl to the old one, and keep using the old one. */
1384 if (flag_traditional
&& TREE_CODE (newdecl
) == FUNCTION_DECL
1385 && IDENTIFIER_IMPLICIT_DECL (DECL_NAME (newdecl
)) == olddecl
1386 && DECL_INITIAL (olddecl
) == 0)
1387 /* If -traditional, avoid error for redeclaring fcn
1388 after implicit decl. */
1390 else if (TREE_CODE (olddecl
) == FUNCTION_DECL
1391 && DECL_BUILT_IN (olddecl
))
1393 /* A function declaration for a built-in function. */
1394 if (!TREE_PUBLIC (newdecl
))
1396 /* If you declare a built-in function name as static, the
1397 built-in definition is overridden,
1398 but optionally warn this was a bad choice of name. */
1400 warning_with_decl (newdecl
, "shadowing built-in function `%s'");
1401 /* Discard the old built-in function. */
1404 else if (!types_match
)
1406 /* Accept the return type of the new declaration if same modes. */
1407 tree oldreturntype
= TREE_TYPE (TREE_TYPE (olddecl
));
1408 tree newreturntype
= TREE_TYPE (TREE_TYPE (newdecl
));
1410 /* Make sure we put the new type in the same obstack as the old ones.
1411 If the old types are not both in the same obstack, use the
1413 if (TYPE_OBSTACK (oldtype
) == TYPE_OBSTACK (newtype
))
1414 push_obstacks (TYPE_OBSTACK (oldtype
), TYPE_OBSTACK (oldtype
));
1417 push_obstacks_nochange ();
1418 end_temporary_allocation ();
1421 if (TYPE_MODE (oldreturntype
) == TYPE_MODE (newreturntype
))
1423 /* Function types may be shared, so we can't just modify
1424 the return type of olddecl's function type. */
1426 = build_function_type (newreturntype
,
1427 TYPE_ARG_TYPES (TREE_TYPE (olddecl
)));
1429 types_match
= comptypes (TREE_TYPE (newdecl
), newtype
);
1431 TREE_TYPE (olddecl
) = newtype
;
1433 /* Accept harmless mismatch in first argument type also.
1435 if (TYPE_ARG_TYPES (TREE_TYPE (newdecl
)) != 0
1436 && TYPE_ARG_TYPES (TREE_TYPE (olddecl
)) != 0
1437 && TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (newdecl
))) != 0
1438 && TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (olddecl
))) != 0
1439 && (TYPE_MODE (TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (newdecl
))))
1441 TYPE_MODE (TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (olddecl
))))))
1443 /* Function types may be shared, so we can't just modify
1444 the return type of olddecl's function type. */
1446 = build_function_type (TREE_TYPE (TREE_TYPE (olddecl
)),
1447 tree_cons (NULL_TREE
,
1448 TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (newdecl
))),
1449 TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (olddecl
)))));
1451 types_match
= comptypes (TREE_TYPE (newdecl
), newtype
);
1453 TREE_TYPE (olddecl
) = newtype
;
1460 /* If types don't match for a built-in, throw away the built-in. */
1461 warning_with_decl (newdecl
, "conflicting types for built-in function `%s'");
1465 else if (TREE_CODE (olddecl
) == FUNCTION_DECL
1466 && DECL_SOURCE_LINE (olddecl
) == 0)
1468 /* A function declaration for a predeclared function
1469 that isn't actually built in. */
1470 if (!TREE_PUBLIC (newdecl
))
1472 /* If you declare it as static, the
1473 default definition is overridden. */
1476 else if (!types_match
)
1478 /* If the types don't match, preserve volatility indication.
1479 Later on, we will discard everything else about the
1480 default declaration. */
1481 TREE_THIS_VOLATILE (newdecl
) |= TREE_THIS_VOLATILE (olddecl
);
1484 /* Permit char *foo () to match void *foo (...) if not pedantic,
1485 if one of them came from a system header file. */
1486 else if (!types_match
1487 && TREE_CODE (olddecl
) == FUNCTION_DECL
1488 && TREE_CODE (newdecl
) == FUNCTION_DECL
1489 && TREE_CODE (TREE_TYPE (oldtype
)) == POINTER_TYPE
1490 && TREE_CODE (TREE_TYPE (newtype
)) == POINTER_TYPE
1491 && (DECL_IN_SYSTEM_HEADER (olddecl
)
1492 || DECL_IN_SYSTEM_HEADER (newdecl
))
1493 && ((TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (newtype
))) == void_type_node
1494 && TYPE_ARG_TYPES (oldtype
) == 0
1495 && self_promoting_args_p (TYPE_ARG_TYPES (newtype
))
1496 && TREE_TYPE (TREE_TYPE (oldtype
)) == char_type_node
)
1498 (TREE_TYPE (TREE_TYPE (newtype
)) == char_type_node
1499 && TYPE_ARG_TYPES (newtype
) == 0
1500 && self_promoting_args_p (TYPE_ARG_TYPES (oldtype
))
1501 && TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (oldtype
))) == void_type_node
)))
1504 pedwarn_with_decl (newdecl
, "conflicting types for `%s'");
1505 /* Make sure we keep void * as ret type, not char *. */
1506 if (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (oldtype
))) == void_type_node
)
1507 TREE_TYPE (newdecl
) = newtype
= oldtype
;
1509 /* Set DECL_IN_SYSTEM_HEADER, so that if we see another declaration
1510 we will come back here again. */
1511 DECL_IN_SYSTEM_HEADER (newdecl
) = 1;
1513 else if (!types_match
1514 /* Permit char *foo (int, ...); followed by char *foo ();
1516 && ! (TREE_CODE (olddecl
) == FUNCTION_DECL
1518 /* Return types must still match. */
1519 && comptypes (TREE_TYPE (oldtype
),
1520 TREE_TYPE (newtype
))
1521 && TYPE_ARG_TYPES (newtype
) == 0))
1523 error_with_decl (newdecl
, "conflicting types for `%s'");
1524 /* Check for function type mismatch
1525 involving an empty arglist vs a nonempty one. */
1526 if (TREE_CODE (olddecl
) == FUNCTION_DECL
1527 && comptypes (TREE_TYPE (oldtype
),
1528 TREE_TYPE (newtype
))
1529 && ((TYPE_ARG_TYPES (oldtype
) == 0
1530 && DECL_INITIAL (olddecl
) == 0)
1532 (TYPE_ARG_TYPES (newtype
) == 0
1533 && DECL_INITIAL (newdecl
) == 0)))
1535 /* Classify the problem further. */
1536 register tree t
= TYPE_ARG_TYPES (oldtype
);
1538 t
= TYPE_ARG_TYPES (newtype
);
1539 for (; t
; t
= TREE_CHAIN (t
))
1541 register tree type
= TREE_VALUE (t
);
1543 if (TREE_CHAIN (t
) == 0
1544 && TYPE_MAIN_VARIANT (type
) != void_type_node
)
1546 error ("A parameter list with an ellipsis can't match");
1547 error ("an empty parameter name list declaration.");
1551 if (TYPE_MAIN_VARIANT (type
) == float_type_node
1552 || C_PROMOTING_INTEGER_TYPE_P (type
))
1554 error ("An argument type that has a default promotion");
1555 error ("can't match an empty parameter name list declaration.");
1560 error_with_decl (olddecl
, "previous declaration of `%s'");
1564 errmsg
= redeclaration_error_message (newdecl
, olddecl
);
1567 error_with_decl (newdecl
, errmsg
);
1568 error_with_decl (olddecl
,
1569 ((DECL_INITIAL (olddecl
)
1570 && current_binding_level
== global_binding_level
)
1571 ? "`%s' previously defined here"
1572 : "`%s' previously declared here"));
1574 else if (TREE_CODE (newdecl
) == TYPE_DECL
1575 && (DECL_IN_SYSTEM_HEADER (olddecl
)
1576 || DECL_IN_SYSTEM_HEADER (newdecl
)))
1578 warning_with_decl (newdecl
, "redefinition of `%s'");
1581 ((DECL_INITIAL (olddecl
)
1582 && current_binding_level
== global_binding_level
)
1583 ? "`%s' previously defined here"
1584 : "`%s' previously declared here"));
1586 else if (TREE_CODE (olddecl
) == FUNCTION_DECL
1587 && DECL_INITIAL (olddecl
) != 0
1588 && TYPE_ARG_TYPES (oldtype
) == 0
1589 && TYPE_ARG_TYPES (newtype
) != 0
1590 && TYPE_ACTUAL_ARG_TYPES (oldtype
) != 0)
1592 register tree type
, parm
;
1594 /* Prototype decl follows defn w/o prototype. */
1596 for (parm
= TYPE_ACTUAL_ARG_TYPES (oldtype
),
1597 type
= TYPE_ARG_TYPES (newtype
),
1599 (TYPE_MAIN_VARIANT (TREE_VALUE (parm
)) != void_type_node
1600 || TYPE_MAIN_VARIANT (TREE_VALUE (type
)) != void_type_node
);
1601 parm
= TREE_CHAIN (parm
), type
= TREE_CHAIN (type
), nargs
++)
1603 if (TYPE_MAIN_VARIANT (TREE_VALUE (parm
)) == void_type_node
1604 || TYPE_MAIN_VARIANT (TREE_VALUE (type
)) == void_type_node
)
1606 errmsg
= "prototype for `%s' follows and number of arguments";
1609 /* Type for passing arg must be consistent
1610 with that declared for the arg. */
1611 if (! comptypes (TREE_VALUE (parm
), TREE_VALUE (type
))
1612 /* If -traditional, allow `unsigned int' instead of `int'
1613 in the prototype. */
1614 && (! (flag_traditional
1615 && TYPE_MAIN_VARIANT (TREE_VALUE (parm
)) == integer_type_node
1616 && TYPE_MAIN_VARIANT (TREE_VALUE (type
)) == unsigned_type_node
)))
1618 errmsg
= "prototype for `%s' follows and argument %d";
1624 error_with_decl (newdecl
, errmsg
, nargs
);
1625 error_with_decl (olddecl
,
1626 "doesn't match non-prototype definition here");
1630 warning_with_decl (newdecl
, "prototype for `%s' follows");
1631 warning_with_decl (olddecl
, "non-prototype definition here");
1634 /* Warn about mismatches in various flags. */
1637 /* Warn if function is now inline
1638 but was previously declared not inline and has been called. */
1639 if (TREE_CODE (olddecl
) == FUNCTION_DECL
1640 && ! DECL_INLINE (olddecl
) && DECL_INLINE (newdecl
)
1641 && TREE_USED (olddecl
))
1642 warning_with_decl (newdecl
,
1643 "`%s' declared inline after being called");
1644 if (TREE_CODE (olddecl
) == FUNCTION_DECL
1645 && ! DECL_INLINE (olddecl
) && DECL_INLINE (newdecl
)
1646 && DECL_INITIAL (olddecl
) != 0)
1647 warning_with_decl (newdecl
,
1648 "`%s' declared inline after its definition");
1650 /* If pedantic, warn when static declaration follows a non-static
1651 declaration. Otherwise, do so only for functions. */
1652 if ((pedantic
|| TREE_CODE (olddecl
) == FUNCTION_DECL
)
1653 && TREE_PUBLIC (olddecl
)
1654 && !TREE_PUBLIC (newdecl
))
1655 warning_with_decl (newdecl
, "static declaration for `%s' follows non-static");
1657 /* Warn when const declaration follows a non-const
1658 declaration, but not for functions. */
1659 if (TREE_CODE (olddecl
) != FUNCTION_DECL
1660 && !TREE_READONLY (olddecl
)
1661 && TREE_READONLY (newdecl
))
1662 warning_with_decl (newdecl
, "const declaration for `%s' follows non-const");
1663 /* These bits are logically part of the type, for variables.
1664 But not for functions
1665 (where qualifiers are not valid ANSI anyway). */
1666 else if (pedantic
&& TREE_CODE (olddecl
) != FUNCTION_DECL
1667 && (TREE_READONLY (newdecl
) != TREE_READONLY (olddecl
)
1668 || TREE_THIS_VOLATILE (newdecl
) != TREE_THIS_VOLATILE (olddecl
)))
1669 pedwarn_with_decl (newdecl
, "type qualifiers for `%s' conflict with previous decl");
1673 /* Optionally warn about more than one declaration for the same name. */
1674 if (errmsg
== 0 && warn_redundant_decls
&& DECL_SOURCE_LINE (olddecl
) != 0
1675 /* Dont warn about a function declaration
1676 followed by a definition. */
1677 && !(TREE_CODE (newdecl
) == FUNCTION_DECL
&& DECL_INITIAL (newdecl
) != 0
1678 && DECL_INITIAL (olddecl
) == 0)
1679 /* Don't warn about extern decl followed by (tentative) definition. */
1680 && !(DECL_EXTERNAL (olddecl
) && ! DECL_EXTERNAL (newdecl
)))
1682 warning_with_decl (newdecl
, "redundant redeclaration of `%s' in same scope");
1683 warning_with_decl (olddecl
, "previous declaration of `%s'");
1686 /* Copy all the DECL_... slots specified in the new decl
1687 except for any that we copy here from the old type.
1689 Past this point, we don't change OLDTYPE and NEWTYPE
1690 even if we change the types of NEWDECL and OLDDECL. */
1694 /* Make sure we put the new type in the same obstack as the old ones.
1695 If the old types are not both in the same obstack, use the permanent
1697 if (TYPE_OBSTACK (oldtype
) == TYPE_OBSTACK (newtype
))
1698 push_obstacks (TYPE_OBSTACK (oldtype
), TYPE_OBSTACK (oldtype
));
1701 push_obstacks_nochange ();
1702 end_temporary_allocation ();
1705 /* Merge the data types specified in the two decls. */
1706 if (TREE_CODE (newdecl
) != FUNCTION_DECL
|| !DECL_BUILT_IN (olddecl
))
1708 = TREE_TYPE (olddecl
)
1709 = common_type (newtype
, oldtype
);
1711 /* Lay the type out, unless already done. */
1712 if (oldtype
!= TREE_TYPE (newdecl
))
1714 if (TREE_TYPE (newdecl
) != error_mark_node
)
1715 layout_type (TREE_TYPE (newdecl
));
1716 if (TREE_CODE (newdecl
) != FUNCTION_DECL
1717 && TREE_CODE (newdecl
) != TYPE_DECL
1718 && TREE_CODE (newdecl
) != CONST_DECL
)
1719 layout_decl (newdecl
, 0);
1723 /* Since the type is OLDDECL's, make OLDDECL's size go with. */
1724 DECL_SIZE (newdecl
) = DECL_SIZE (olddecl
);
1725 if (TREE_CODE (olddecl
) != FUNCTION_DECL
)
1726 if (DECL_ALIGN (olddecl
) > DECL_ALIGN (newdecl
))
1727 DECL_ALIGN (newdecl
) = DECL_ALIGN (olddecl
);
1730 /* Keep the old rtl since we can safely use it. */
1731 DECL_RTL (newdecl
) = DECL_RTL (olddecl
);
1733 /* Merge the type qualifiers. */
1734 if (DECL_BUILT_IN_NONANSI (olddecl
) && TREE_THIS_VOLATILE (olddecl
)
1735 && !TREE_THIS_VOLATILE (newdecl
))
1736 TREE_THIS_VOLATILE (olddecl
) = 0;
1737 if (TREE_READONLY (newdecl
))
1738 TREE_READONLY (olddecl
) = 1;
1739 if (TREE_THIS_VOLATILE (newdecl
))
1741 TREE_THIS_VOLATILE (olddecl
) = 1;
1742 if (TREE_CODE (newdecl
) == VAR_DECL
)
1743 make_var_volatile (newdecl
);
1746 /* Keep source location of definition rather than declaration.
1747 Likewise, keep decl at outer scope. */
1748 if ((DECL_INITIAL (newdecl
) == 0 && DECL_INITIAL (olddecl
) != 0)
1749 || (DECL_CONTEXT (newdecl
) != 0 && DECL_CONTEXT (olddecl
) == 0))
1751 DECL_SOURCE_LINE (newdecl
) = DECL_SOURCE_LINE (olddecl
);
1752 DECL_SOURCE_FILE (newdecl
) = DECL_SOURCE_FILE (olddecl
);
1754 if (DECL_CONTEXT (olddecl
) == 0)
1755 DECL_CONTEXT (newdecl
) = 0;
1758 /* Merge the unused-warning information. */
1759 if (DECL_IN_SYSTEM_HEADER (olddecl
))
1760 DECL_IN_SYSTEM_HEADER (newdecl
) = 1;
1761 else if (DECL_IN_SYSTEM_HEADER (newdecl
))
1762 DECL_IN_SYSTEM_HEADER (olddecl
) = 1;
1764 /* Merge the initialization information. */
1765 if (DECL_INITIAL (newdecl
) == 0)
1766 DECL_INITIAL (newdecl
) = DECL_INITIAL (olddecl
);
1768 /* Merge the section attribute.
1769 We want to issue an error if the sections conflict but that must be
1770 done later in decl_attributes since we are called before attributes
1772 if (DECL_SECTION_NAME (newdecl
) == NULL_TREE
)
1773 DECL_SECTION_NAME (newdecl
) = DECL_SECTION_NAME (olddecl
);
1775 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
1777 DECL_STATIC_CONSTRUCTOR(newdecl
) |= DECL_STATIC_CONSTRUCTOR(olddecl
);
1778 DECL_STATIC_DESTRUCTOR (newdecl
) |= DECL_STATIC_DESTRUCTOR (olddecl
);
1783 /* If cannot merge, then use the new type and qualifiers,
1784 and don't preserve the old rtl. */
1787 TREE_TYPE (olddecl
) = TREE_TYPE (newdecl
);
1788 TREE_READONLY (olddecl
) = TREE_READONLY (newdecl
);
1789 TREE_THIS_VOLATILE (olddecl
) = TREE_THIS_VOLATILE (newdecl
);
1790 TREE_SIDE_EFFECTS (olddecl
) = TREE_SIDE_EFFECTS (newdecl
);
1793 /* Merge the storage class information. */
1794 /* For functions, static overrides non-static. */
1795 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
1797 TREE_PUBLIC (newdecl
) &= TREE_PUBLIC (olddecl
);
1798 /* This is since we don't automatically
1799 copy the attributes of NEWDECL into OLDDECL. */
1800 TREE_PUBLIC (olddecl
) = TREE_PUBLIC (newdecl
);
1801 /* If this clears `static', clear it in the identifier too. */
1802 if (! TREE_PUBLIC (olddecl
))
1803 TREE_PUBLIC (DECL_NAME (olddecl
)) = 0;
1805 if (DECL_EXTERNAL (newdecl
))
1807 TREE_STATIC (newdecl
) = TREE_STATIC (olddecl
);
1808 DECL_EXTERNAL (newdecl
) = DECL_EXTERNAL (olddecl
);
1809 /* An extern decl does not override previous storage class. */
1810 TREE_PUBLIC (newdecl
) = TREE_PUBLIC (olddecl
);
1814 TREE_STATIC (olddecl
) = TREE_STATIC (newdecl
);
1815 TREE_PUBLIC (olddecl
) = TREE_PUBLIC (newdecl
);
1818 /* If either decl says `inline', this fn is inline,
1819 unless its definition was passed already. */
1820 if (DECL_INLINE (newdecl
) && DECL_INITIAL (olddecl
) == 0)
1821 DECL_INLINE (olddecl
) = 1;
1822 DECL_INLINE (newdecl
) = DECL_INLINE (olddecl
);
1824 /* Get rid of any built-in function if new arg types don't match it
1825 or if we have a function definition. */
1826 if (TREE_CODE (newdecl
) == FUNCTION_DECL
1827 && DECL_BUILT_IN (olddecl
)
1828 && (!types_match
|| new_is_definition
))
1830 TREE_TYPE (olddecl
) = TREE_TYPE (newdecl
);
1831 DECL_BUILT_IN (olddecl
) = 0;
1834 /* If redeclaring a builtin function, and not a definition,
1836 Also preserve various other info from the definition. */
1837 if (TREE_CODE (newdecl
) == FUNCTION_DECL
&& !new_is_definition
)
1839 if (DECL_BUILT_IN (olddecl
))
1841 DECL_BUILT_IN (newdecl
) = 1;
1842 DECL_FUNCTION_CODE (newdecl
) = DECL_FUNCTION_CODE (olddecl
);
1845 DECL_FRAME_SIZE (newdecl
) = DECL_FRAME_SIZE (olddecl
);
1847 DECL_RESULT (newdecl
) = DECL_RESULT (olddecl
);
1848 DECL_INITIAL (newdecl
) = DECL_INITIAL (olddecl
);
1849 DECL_SAVED_INSNS (newdecl
) = DECL_SAVED_INSNS (olddecl
);
1850 DECL_ARGUMENTS (newdecl
) = DECL_ARGUMENTS (olddecl
);
1853 /* Copy most of the decl-specific fields of NEWDECL into OLDDECL.
1854 But preserve OLDdECL's DECL_UID. */
1856 register unsigned olddecl_uid
= DECL_UID (olddecl
);
1858 bcopy ((char *) newdecl
+ sizeof (struct tree_common
),
1859 (char *) olddecl
+ sizeof (struct tree_common
),
1860 sizeof (struct tree_decl
) - sizeof (struct tree_common
));
1861 DECL_UID (olddecl
) = olddecl_uid
;
1867 /* Record a decl-node X as belonging to the current lexical scope.
1868 Check for errors (such as an incompatible declaration for the same
1869 name already seen in the same scope).
1871 Returns either X or an old decl for the same name.
1872 If an old decl is returned, it may have been smashed
1873 to agree with what X says. */
1880 register tree name
= DECL_NAME (x
);
1881 register struct binding_level
*b
= current_binding_level
;
1883 DECL_CONTEXT (x
) = current_function_decl
;
1884 /* A local extern declaration for a function doesn't constitute nesting.
1885 A local auto declaration does, since it's a forward decl
1886 for a nested function coming later. */
1887 if (TREE_CODE (x
) == FUNCTION_DECL
&& DECL_INITIAL (x
) == 0
1888 && DECL_EXTERNAL (x
))
1889 DECL_CONTEXT (x
) = 0;
1891 if (warn_nested_externs
&& DECL_EXTERNAL (x
) && b
!= global_binding_level
1892 && x
!= IDENTIFIER_IMPLICIT_DECL (name
)
1893 /* Don't print error messages for __FUNCTION__ and __PRETTY_FUNCTION__ */
1894 && !DECL_IN_SYSTEM_HEADER (x
))
1895 warning ("nested extern declaration of `%s'", IDENTIFIER_POINTER (name
));
1902 /* Don't type check externs here when -traditional. This is so that
1903 code with conflicting declarations inside blocks will get warnings
1904 not errors. X11 for instance depends on this. */
1905 if (DECL_EXTERNAL (x
) && TREE_PUBLIC (x
) && ! flag_traditional
)
1906 t
= lookup_name_current_level_global (name
);
1908 t
= lookup_name_current_level (name
);
1909 if (t
!= 0 && t
== error_mark_node
)
1910 /* error_mark_node is 0 for a while during initialization! */
1913 error_with_decl (x
, "`%s' used prior to declaration");
1918 file
= DECL_SOURCE_FILE (t
);
1919 line
= DECL_SOURCE_LINE (t
);
1922 if (t
!= 0 && duplicate_decls (x
, t
))
1924 if (TREE_CODE (t
) == PARM_DECL
)
1926 /* Don't allow more than one "real" duplicate
1927 of a forward parm decl. */
1928 TREE_ASM_WRITTEN (t
) = TREE_ASM_WRITTEN (x
);
1931 /* If this decl is `static' and an implicit decl was seen previously,
1932 warn. But don't complain if -traditional,
1933 since traditional compilers don't complain. */
1934 if (!flag_traditional
&& TREE_PUBLIC (name
)
1935 && ! TREE_PUBLIC (x
) && ! DECL_EXTERNAL (x
)
1936 /* We used to warn also for explicit extern followed by static,
1937 but sometimes you need to do it that way. */
1938 && IDENTIFIER_IMPLICIT_DECL (name
) != 0)
1940 pedwarn ("`%s' was declared implicitly `extern' and later `static'",
1941 IDENTIFIER_POINTER (name
));
1942 pedwarn_with_file_and_line (file
, line
,
1943 "previous declaration of `%s'",
1944 IDENTIFIER_POINTER (name
));
1947 /* If this is a global decl, and there exists a conflicting local
1948 decl in a parent block, then we can't return as yet, because we
1949 need to register this decl in the current binding block. */
1950 if (! DECL_EXTERNAL (x
) || ! TREE_PUBLIC (x
)
1951 || lookup_name (name
) == t
)
1955 /* If we are processing a typedef statement, generate a whole new
1956 ..._TYPE node (which will be just an variant of the existing
1957 ..._TYPE node with identical properties) and then install the
1958 TYPE_DECL node generated to represent the typedef name as the
1959 TYPE_NAME of this brand new (duplicate) ..._TYPE node.
1961 The whole point here is to end up with a situation where each
1962 and every ..._TYPE node the compiler creates will be uniquely
1963 associated with AT MOST one node representing a typedef name.
1964 This way, even though the compiler substitutes corresponding
1965 ..._TYPE nodes for TYPE_DECL (i.e. "typedef name") nodes very
1966 early on, later parts of the compiler can always do the reverse
1967 translation and get back the corresponding typedef name. For
1970 typedef struct S MY_TYPE;
1973 Later parts of the compiler might only know that `object' was of
1974 type `struct S' if if were not for code just below. With this
1975 code however, later parts of the compiler see something like:
1977 struct S' == struct S
1978 typedef struct S' MY_TYPE;
1981 And they can then deduce (from the node for type struct S') that
1982 the original object declaration was:
1986 Being able to do this is important for proper support of protoize,
1987 and also for generating precise symbolic debugging information
1988 which takes full account of the programmer's (typedef) vocabulary.
1990 Obviously, we don't want to generate a duplicate ..._TYPE node if
1991 the TYPE_DECL node that we are now processing really represents a
1992 standard built-in type.
1994 Since all standard types are effectively declared at line zero
1995 in the source file, we can easily check to see if we are working
1996 on a standard type by checking the current value of lineno. */
1998 if (TREE_CODE (x
) == TYPE_DECL
)
2000 if (DECL_SOURCE_LINE (x
) == 0)
2002 if (TYPE_NAME (TREE_TYPE (x
)) == 0)
2003 TYPE_NAME (TREE_TYPE (x
)) = x
;
2005 else if (TREE_TYPE (x
) != error_mark_node
)
2007 tree tt
= TREE_TYPE (x
);
2009 tt
= build_type_copy (tt
);
2015 /* Multiple external decls of the same identifier ought to match.
2016 Check against both global declarations (when traditional) and out of
2017 scope (limbo) block level declarations.
2019 We get warnings about inline functions where they are defined.
2020 Avoid duplicate warnings where they are used. */
2021 if (TREE_PUBLIC (x
) && ! DECL_INLINE (x
))
2025 if (flag_traditional
&& IDENTIFIER_GLOBAL_VALUE (name
) != 0
2026 && (DECL_EXTERNAL (IDENTIFIER_GLOBAL_VALUE (name
))
2027 || TREE_PUBLIC (IDENTIFIER_GLOBAL_VALUE (name
))))
2028 decl
= IDENTIFIER_GLOBAL_VALUE (name
);
2029 else if (IDENTIFIER_LIMBO_VALUE (name
) != 0)
2030 /* Decls in limbo are always extern, so no need to check that. */
2031 decl
= IDENTIFIER_LIMBO_VALUE (name
);
2035 if (decl
&& ! comptypes (TREE_TYPE (x
), TREE_TYPE (decl
))
2036 /* If old decl is built-in, we already warned if we should. */
2037 && !DECL_BUILT_IN (decl
))
2039 pedwarn_with_decl (x
,
2040 "type mismatch with previous external decl");
2041 pedwarn_with_decl (decl
, "previous external decl of `%s'");
2045 /* If a function has had an implicit declaration, and then is defined,
2046 make sure they are compatible. */
2048 if (IDENTIFIER_IMPLICIT_DECL (name
) != 0
2049 && IDENTIFIER_GLOBAL_VALUE (name
) == 0
2050 && TREE_CODE (x
) == FUNCTION_DECL
2051 && ! comptypes (TREE_TYPE (x
),
2052 TREE_TYPE (IDENTIFIER_IMPLICIT_DECL (name
))))
2054 warning_with_decl (x
, "type mismatch with previous implicit declaration");
2055 warning_with_decl (IDENTIFIER_IMPLICIT_DECL (name
),
2056 "previous implicit declaration of `%s'");
2059 /* In PCC-compatibility mode, extern decls of vars with no current decl
2060 take effect at top level no matter where they are. */
2061 if (flag_traditional
&& DECL_EXTERNAL (x
)
2062 && lookup_name (name
) == 0)
2064 tree type
= TREE_TYPE (x
);
2066 /* But don't do this if the type contains temporary nodes. */
2069 if (type
== error_mark_node
)
2071 if (! TREE_PERMANENT (type
))
2073 warning_with_decl (x
, "type of external `%s' is not global");
2074 /* By exiting the loop early, we leave TYPE nonzero,
2075 and thus prevent globalization of the decl. */
2078 else if (TREE_CODE (type
) == FUNCTION_TYPE
2079 && TYPE_ARG_TYPES (type
) != 0)
2080 /* The types might not be truly local,
2081 but the list of arg types certainly is temporary.
2082 Since prototypes are nontraditional,
2083 ok not to do the traditional thing. */
2085 type
= TREE_TYPE (type
);
2089 b
= global_binding_level
;
2092 /* This name is new in its binding level.
2093 Install the new declaration and return it. */
2094 if (b
== global_binding_level
)
2096 /* Install a global value. */
2098 /* If the first global decl has external linkage,
2099 warn if we later see static one. */
2100 if (IDENTIFIER_GLOBAL_VALUE (name
) == 0 && TREE_PUBLIC (x
))
2101 TREE_PUBLIC (name
) = 1;
2103 IDENTIFIER_GLOBAL_VALUE (name
) = x
;
2105 /* We no longer care about any previous block level declarations. */
2106 IDENTIFIER_LIMBO_VALUE (name
) = 0;
2108 /* Don't forget if the function was used via an implicit decl. */
2109 if (IDENTIFIER_IMPLICIT_DECL (name
)
2110 && TREE_USED (IDENTIFIER_IMPLICIT_DECL (name
)))
2111 TREE_USED (x
) = 1, TREE_USED (name
) = 1;
2113 /* Don't forget if its address was taken in that way. */
2114 if (IDENTIFIER_IMPLICIT_DECL (name
)
2115 && TREE_ADDRESSABLE (IDENTIFIER_IMPLICIT_DECL (name
)))
2116 TREE_ADDRESSABLE (x
) = 1;
2118 /* Warn about mismatches against previous implicit decl. */
2119 if (IDENTIFIER_IMPLICIT_DECL (name
) != 0
2120 /* If this real decl matches the implicit, don't complain. */
2121 && ! (TREE_CODE (x
) == FUNCTION_DECL
2122 && (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (x
)))
2123 == integer_type_node
)))
2124 pedwarn ("`%s' was previously implicitly declared to return `int'",
2125 IDENTIFIER_POINTER (name
));
2127 /* If this decl is `static' and an `extern' was seen previously,
2128 that is erroneous. */
2129 if (TREE_PUBLIC (name
)
2130 && ! TREE_PUBLIC (x
) && ! DECL_EXTERNAL (x
))
2132 /* Okay to redeclare an ANSI built-in as static. */
2133 if (t
!= 0 && DECL_BUILT_IN (t
))
2135 /* Okay to declare a non-ANSI built-in as anything. */
2136 else if (t
!= 0 && DECL_BUILT_IN_NONANSI (t
))
2138 else if (IDENTIFIER_IMPLICIT_DECL (name
))
2139 pedwarn ("`%s' was declared implicitly `extern' and later `static'",
2140 IDENTIFIER_POINTER (name
));
2142 pedwarn ("`%s' was declared `extern' and later `static'",
2143 IDENTIFIER_POINTER (name
));
2148 /* Here to install a non-global value. */
2149 tree oldlocal
= IDENTIFIER_LOCAL_VALUE (name
);
2150 tree oldglobal
= IDENTIFIER_GLOBAL_VALUE (name
);
2151 IDENTIFIER_LOCAL_VALUE (name
) = x
;
2153 /* If this is an extern function declaration, see if we
2154 have a global definition or declaration for the function. */
2156 && DECL_EXTERNAL (x
) && !DECL_INLINE (x
)
2158 && TREE_CODE (x
) == FUNCTION_DECL
2159 && TREE_CODE (oldglobal
) == FUNCTION_DECL
)
2161 /* We have one. Their types must agree. */
2162 if (! comptypes (TREE_TYPE (x
),
2163 TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (name
))))
2164 pedwarn_with_decl (x
, "extern declaration of `%s' doesn't match global one");
2167 /* Inner extern decl is inline if global one is.
2168 Copy enough to really inline it. */
2169 if (DECL_INLINE (oldglobal
))
2171 DECL_INLINE (x
) = DECL_INLINE (oldglobal
);
2172 DECL_INITIAL (x
) = (current_function_decl
== oldglobal
2173 ? 0 : DECL_INITIAL (oldglobal
));
2174 DECL_SAVED_INSNS (x
) = DECL_SAVED_INSNS (oldglobal
);
2175 DECL_FRAME_SIZE (x
) = DECL_FRAME_SIZE (oldglobal
);
2176 DECL_ARGUMENTS (x
) = DECL_ARGUMENTS (oldglobal
);
2177 DECL_RESULT (x
) = DECL_RESULT (oldglobal
);
2178 TREE_ASM_WRITTEN (x
) = TREE_ASM_WRITTEN (oldglobal
);
2179 DECL_ABSTRACT_ORIGIN (x
) = oldglobal
;
2181 /* Inner extern decl is built-in if global one is. */
2182 if (DECL_BUILT_IN (oldglobal
))
2184 DECL_BUILT_IN (x
) = DECL_BUILT_IN (oldglobal
);
2185 DECL_FUNCTION_CODE (x
) = DECL_FUNCTION_CODE (oldglobal
);
2187 /* Keep the arg types from a file-scope fcn defn. */
2188 if (TYPE_ARG_TYPES (TREE_TYPE (oldglobal
)) != 0
2189 && DECL_INITIAL (oldglobal
)
2190 && TYPE_ARG_TYPES (TREE_TYPE (x
)) == 0)
2191 TREE_TYPE (x
) = TREE_TYPE (oldglobal
);
2195 #if 0 /* This case is probably sometimes the right thing to do. */
2196 /* If we have a local external declaration,
2197 then any file-scope declaration should not
2198 have been static. */
2199 if (oldlocal
== 0 && oldglobal
!= 0
2200 && !TREE_PUBLIC (oldglobal
)
2201 && DECL_EXTERNAL (x
) && TREE_PUBLIC (x
))
2202 warning ("`%s' locally external but globally static",
2203 IDENTIFIER_POINTER (name
));
2206 /* If we have a local external declaration,
2207 and no file-scope declaration has yet been seen,
2208 then if we later have a file-scope decl it must not be static. */
2211 && DECL_EXTERNAL (x
)
2214 TREE_PUBLIC (name
) = 1;
2216 /* Save this decl, so that we can do type checking against
2217 other decls after it falls out of scope.
2219 Only save it once. This prevents temporary decls created in
2220 expand_inline_function from being used here, since this
2221 will have been set when the inline function was parsed.
2222 It also helps give slightly better warnings. */
2223 if (IDENTIFIER_LIMBO_VALUE (name
) == 0)
2224 IDENTIFIER_LIMBO_VALUE (name
) = x
;
2227 /* Warn if shadowing an argument at the top level of the body. */
2228 if (oldlocal
!= 0 && !DECL_EXTERNAL (x
)
2229 /* This warning doesn't apply to the parms of a nested fcn. */
2230 && ! current_binding_level
->parm_flag
2231 /* Check that this is one level down from the parms. */
2232 && current_binding_level
->level_chain
->parm_flag
2233 /* Check that the decl being shadowed
2234 comes from the parm level, one level up. */
2235 && chain_member (oldlocal
, current_binding_level
->level_chain
->names
))
2237 if (TREE_CODE (oldlocal
) == PARM_DECL
)
2238 pedwarn ("declaration of `%s' shadows a parameter",
2239 IDENTIFIER_POINTER (name
));
2241 pedwarn ("declaration of `%s' shadows a symbol from the parameter list",
2242 IDENTIFIER_POINTER (name
));
2245 /* Maybe warn if shadowing something else. */
2246 else if (warn_shadow
&& !DECL_EXTERNAL (x
)
2247 /* No shadow warnings for internally generated vars. */
2248 && DECL_SOURCE_LINE (x
) != 0
2249 /* No shadow warnings for vars made for inlining. */
2250 && ! DECL_FROM_INLINE (x
))
2252 char *warnstring
= 0;
2254 if (TREE_CODE (x
) == PARM_DECL
2255 && current_binding_level
->level_chain
->parm_flag
)
2256 /* Don't warn about the parm names in function declarator
2257 within a function declarator.
2258 It would be nice to avoid warning in any function
2259 declarator in a declaration, as opposed to a definition,
2260 but there is no way to tell it's not a definition. */
2262 else if (oldlocal
!= 0 && TREE_CODE (oldlocal
) == PARM_DECL
)
2263 warnstring
= "declaration of `%s' shadows a parameter";
2264 else if (oldlocal
!= 0)
2265 warnstring
= "declaration of `%s' shadows previous local";
2266 else if (IDENTIFIER_GLOBAL_VALUE (name
) != 0
2267 && IDENTIFIER_GLOBAL_VALUE (name
) != error_mark_node
)
2268 warnstring
= "declaration of `%s' shadows global declaration";
2271 warning (warnstring
, IDENTIFIER_POINTER (name
));
2274 /* If storing a local value, there may already be one (inherited).
2275 If so, record it for restoration when this binding level ends. */
2277 b
->shadowed
= tree_cons (name
, oldlocal
, b
->shadowed
);
2280 /* Keep count of variables in this level with incomplete type. */
2281 if (TYPE_SIZE (TREE_TYPE (x
)) == 0)
2285 /* Put decls on list in reverse order.
2286 We will reverse them later if necessary. */
2287 TREE_CHAIN (x
) = b
->names
;
2293 /* Like pushdecl, only it places X in GLOBAL_BINDING_LEVEL, if appropriate. */
2296 pushdecl_top_level (x
)
2300 register struct binding_level
*b
= current_binding_level
;
2302 current_binding_level
= global_binding_level
;
2304 current_binding_level
= b
;
2308 /* Generate an implicit declaration for identifier FUNCTIONID
2309 as a function of type int (). Print a warning if appropriate. */
2312 implicitly_declare (functionid
)
2316 int traditional_warning
= 0;
2317 /* Only one "implicit declaration" warning per identifier. */
2318 int implicit_warning
;
2320 /* Save the decl permanently so we can warn if definition follows. */
2321 push_obstacks_nochange ();
2322 end_temporary_allocation ();
2324 /* We used to reuse an old implicit decl here,
2325 but this loses with inline functions because it can clobber
2326 the saved decl chains. */
2327 /* if (IDENTIFIER_IMPLICIT_DECL (functionid) != 0)
2328 decl = IDENTIFIER_IMPLICIT_DECL (functionid);
2330 decl
= build_decl (FUNCTION_DECL
, functionid
, default_function_type
);
2332 /* Warn of implicit decl following explicit local extern decl.
2333 This is probably a program designed for traditional C. */
2334 if (TREE_PUBLIC (functionid
) && IDENTIFIER_GLOBAL_VALUE (functionid
) == 0)
2335 traditional_warning
= 1;
2337 /* Warn once of an implicit declaration. */
2338 implicit_warning
= (IDENTIFIER_IMPLICIT_DECL (functionid
) == 0);
2340 DECL_EXTERNAL (decl
) = 1;
2341 TREE_PUBLIC (decl
) = 1;
2343 /* Record that we have an implicit decl and this is it. */
2344 IDENTIFIER_IMPLICIT_DECL (functionid
) = decl
;
2346 /* ANSI standard says implicit declarations are in the innermost block.
2347 So we record the decl in the standard fashion.
2348 If flag_traditional is set, pushdecl does it top-level. */
2351 /* This is a no-op in c-lang.c or something real in objc-actions.c. */
2352 maybe_objc_check_decl (decl
);
2354 rest_of_decl_compilation (decl
, NULL_PTR
, 0, 0);
2356 if (warn_implicit
&& implicit_warning
)
2357 warning ("implicit declaration of function `%s'",
2358 IDENTIFIER_POINTER (functionid
));
2359 else if (warn_traditional
&& traditional_warning
)
2360 warning ("function `%s' was previously declared within a block",
2361 IDENTIFIER_POINTER (functionid
));
2363 /* Write a record describing this implicit function declaration to the
2364 prototypes file (if requested). */
2366 gen_aux_info_record (decl
, 0, 1, 0);
2373 /* Return zero if the declaration NEWDECL is valid
2374 when the declaration OLDDECL (assumed to be for the same name)
2375 has already been seen.
2376 Otherwise return an error message format string with a %s
2377 where the identifier should go. */
2380 redeclaration_error_message (newdecl
, olddecl
)
2381 tree newdecl
, olddecl
;
2383 if (TREE_CODE (newdecl
) == TYPE_DECL
)
2385 if (flag_traditional
&& TREE_TYPE (newdecl
) == TREE_TYPE (olddecl
))
2387 if (DECL_IN_SYSTEM_HEADER (olddecl
) || DECL_IN_SYSTEM_HEADER (newdecl
))
2389 return "redefinition of `%s'";
2391 else if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
2393 /* Declarations of functions can insist on internal linkage
2394 but they can't be inconsistent with internal linkage,
2395 so there can be no error on that account.
2396 However defining the same name twice is no good. */
2397 if (DECL_INITIAL (olddecl
) != 0 && DECL_INITIAL (newdecl
) != 0
2398 /* However, defining once as extern inline and a second
2399 time in another way is ok. */
2400 && !(DECL_INLINE (olddecl
) && DECL_EXTERNAL (olddecl
)
2401 && !(DECL_INLINE (newdecl
) && DECL_EXTERNAL (newdecl
))))
2402 return "redefinition of `%s'";
2405 else if (current_binding_level
== global_binding_level
)
2407 /* Objects declared at top level: */
2408 /* If at least one is a reference, it's ok. */
2409 if (DECL_EXTERNAL (newdecl
) || DECL_EXTERNAL (olddecl
))
2411 /* Reject two definitions. */
2412 if (DECL_INITIAL (olddecl
) != 0 && DECL_INITIAL (newdecl
) != 0)
2413 return "redefinition of `%s'";
2414 /* Now we have two tentative defs, or one tentative and one real def. */
2415 /* Insist that the linkage match. */
2416 if (TREE_PUBLIC (olddecl
) != TREE_PUBLIC (newdecl
))
2417 return "conflicting declarations of `%s'";
2420 else if (current_binding_level
->parm_flag
2421 && TREE_ASM_WRITTEN (olddecl
) && !TREE_ASM_WRITTEN (newdecl
))
2425 /* Newdecl has block scope. If olddecl has block scope also, then
2426 reject two definitions, and reject a definition together with an
2427 external reference. Otherwise, it is OK, because newdecl must
2428 be an extern reference to olddecl. */
2429 if (!(DECL_EXTERNAL (newdecl
) && DECL_EXTERNAL (olddecl
))
2430 && DECL_CONTEXT (newdecl
) == DECL_CONTEXT (olddecl
))
2431 return "redeclaration of `%s'";
2436 /* Get the LABEL_DECL corresponding to identifier ID as a label.
2437 Create one if none exists so far for the current function.
2438 This function is called for both label definitions and label references. */
2444 register tree decl
= IDENTIFIER_LABEL_VALUE (id
);
2446 if (current_function_decl
== 0)
2448 error ("label %s referenced outside of any function",
2449 IDENTIFIER_POINTER (id
));
2453 /* Use a label already defined or ref'd with this name. */
2456 /* But not if it is inherited and wasn't declared to be inheritable. */
2457 if (DECL_CONTEXT (decl
) != current_function_decl
2458 && ! C_DECLARED_LABEL_FLAG (decl
))
2459 return shadow_label (id
);
2463 decl
= build_decl (LABEL_DECL
, id
, void_type_node
);
2465 /* Make sure every label has an rtx. */
2468 /* A label not explicitly declared must be local to where it's ref'd. */
2469 DECL_CONTEXT (decl
) = current_function_decl
;
2471 DECL_MODE (decl
) = VOIDmode
;
2473 /* Say where one reference is to the label,
2474 for the sake of the error if it is not defined. */
2475 DECL_SOURCE_LINE (decl
) = lineno
;
2476 DECL_SOURCE_FILE (decl
) = input_filename
;
2478 IDENTIFIER_LABEL_VALUE (id
) = decl
;
2480 named_labels
= tree_cons (NULL_TREE
, decl
, named_labels
);
2485 /* Make a label named NAME in the current function,
2486 shadowing silently any that may be inherited from containing functions
2487 or containing scopes.
2489 Note that valid use, if the label being shadowed
2490 comes from another scope in the same function,
2491 requires calling declare_nonlocal_label right away. */
2497 register tree decl
= IDENTIFIER_LABEL_VALUE (name
);
2503 /* Check to make sure that the label hasn't already been declared
2504 at this label scope */
2505 for (dup
= named_labels
; dup
; dup
= TREE_CHAIN (dup
))
2506 if (TREE_VALUE (dup
) == decl
)
2508 error ("duplicate label declaration `%s'",
2509 IDENTIFIER_POINTER (name
));
2510 error_with_decl (TREE_VALUE (dup
),
2511 "this is a previous declaration");
2512 /* Just use the previous declaration. */
2513 return lookup_label (name
);
2516 shadowed_labels
= tree_cons (NULL_TREE
, decl
, shadowed_labels
);
2517 IDENTIFIER_LABEL_VALUE (name
) = decl
= 0;
2520 return lookup_label (name
);
2523 /* Define a label, specifying the location in the source file.
2524 Return the LABEL_DECL node for the label, if the definition is valid.
2525 Otherwise return 0. */
2528 define_label (filename
, line
, name
)
2533 tree decl
= lookup_label (name
);
2535 /* If label with this name is known from an outer context, shadow it. */
2536 if (decl
!= 0 && DECL_CONTEXT (decl
) != current_function_decl
)
2538 shadowed_labels
= tree_cons (NULL_TREE
, decl
, shadowed_labels
);
2539 IDENTIFIER_LABEL_VALUE (name
) = 0;
2540 decl
= lookup_label (name
);
2543 if (DECL_INITIAL (decl
) != 0)
2545 error ("duplicate label `%s'", IDENTIFIER_POINTER (name
));
2550 /* Mark label as having been defined. */
2551 DECL_INITIAL (decl
) = error_mark_node
;
2552 /* Say where in the source. */
2553 DECL_SOURCE_FILE (decl
) = filename
;
2554 DECL_SOURCE_LINE (decl
) = line
;
2559 /* Return the list of declarations of the current level.
2560 Note that this list is in reverse order unless/until
2561 you nreverse it; and when you do nreverse it, you must
2562 store the result back using `storedecls' or you will lose. */
2567 return current_binding_level
->names
;
2570 /* Return the list of type-tags (for structs, etc) of the current level. */
2575 return current_binding_level
->tags
;
2578 /* Store the list of declarations of the current level.
2579 This is done for the parameter declarations of a function being defined,
2580 after they are modified in the light of any missing parameters. */
2586 current_binding_level
->names
= decls
;
2589 /* Similarly, store the list of tags of the current level. */
2595 current_binding_level
->tags
= tags
;
2598 /* Given NAME, an IDENTIFIER_NODE,
2599 return the structure (or union or enum) definition for that name.
2600 Searches binding levels from BINDING_LEVEL up to the global level.
2601 If THISLEVEL_ONLY is nonzero, searches only the specified context
2602 (but skips any tag-transparent contexts to find one that is
2603 meaningful for tags).
2604 CODE says which kind of type the caller wants;
2605 it is RECORD_TYPE or UNION_TYPE or ENUMERAL_TYPE.
2606 If the wrong kind of type is found, an error is reported. */
2609 lookup_tag (code
, name
, binding_level
, thislevel_only
)
2610 enum tree_code code
;
2611 struct binding_level
*binding_level
;
2615 register struct binding_level
*level
;
2617 for (level
= binding_level
; level
; level
= level
->level_chain
)
2620 for (tail
= level
->tags
; tail
; tail
= TREE_CHAIN (tail
))
2622 if (TREE_PURPOSE (tail
) == name
)
2624 if (TREE_CODE (TREE_VALUE (tail
)) != code
)
2626 /* Definition isn't the kind we were looking for. */
2627 pending_invalid_xref
= name
;
2628 pending_invalid_xref_file
= input_filename
;
2629 pending_invalid_xref_line
= lineno
;
2631 return TREE_VALUE (tail
);
2634 if (thislevel_only
&& ! level
->tag_transparent
)
2640 /* Print an error message now
2641 for a recent invalid struct, union or enum cross reference.
2642 We don't print them immediately because they are not invalid
2643 when used in the `struct foo;' construct for shadowing. */
2646 pending_xref_error ()
2648 if (pending_invalid_xref
!= 0)
2649 error_with_file_and_line (pending_invalid_xref_file
,
2650 pending_invalid_xref_line
,
2651 "`%s' defined as wrong kind of tag",
2652 IDENTIFIER_POINTER (pending_invalid_xref
));
2653 pending_invalid_xref
= 0;
2656 /* Given a type, find the tag that was defined for it and return the tag name.
2657 Otherwise return 0. */
2660 lookup_tag_reverse (type
)
2663 register struct binding_level
*level
;
2665 for (level
= current_binding_level
; level
; level
= level
->level_chain
)
2668 for (tail
= level
->tags
; tail
; tail
= TREE_CHAIN (tail
))
2670 if (TREE_VALUE (tail
) == type
)
2671 return TREE_PURPOSE (tail
);
2677 /* Look up NAME in the current binding level and its superiors
2678 in the namespace of variables, functions and typedefs.
2679 Return a ..._DECL node of some kind representing its definition,
2680 or return 0 if it is undefined. */
2687 if (current_binding_level
!= global_binding_level
2688 && IDENTIFIER_LOCAL_VALUE (name
))
2689 val
= IDENTIFIER_LOCAL_VALUE (name
);
2691 val
= IDENTIFIER_GLOBAL_VALUE (name
);
2695 /* Similar to `lookup_name' but look only at current binding level. */
2698 lookup_name_current_level (name
)
2703 if (current_binding_level
== global_binding_level
)
2704 return IDENTIFIER_GLOBAL_VALUE (name
);
2706 if (IDENTIFIER_LOCAL_VALUE (name
) == 0)
2709 for (t
= current_binding_level
->names
; t
; t
= TREE_CHAIN (t
))
2710 if (DECL_NAME (t
) == name
)
2716 /* Similar to `lookup_name_current_level' but also look at the global binding
2720 lookup_name_current_level_global (name
)
2723 register tree t
= 0;
2725 if (current_binding_level
== global_binding_level
)
2726 return IDENTIFIER_GLOBAL_VALUE (name
);
2728 if (IDENTIFIER_LOCAL_VALUE (name
) != 0)
2729 for (t
= current_binding_level
->names
; t
; t
= TREE_CHAIN (t
))
2730 if (DECL_NAME (t
) == name
)
2734 t
= IDENTIFIER_GLOBAL_VALUE (name
);
2739 /* Create the predefined scalar types of C,
2740 and some nodes representing standard constants (0, 1, (void *)0).
2741 Initialize the global binding level.
2742 Make definitions for built-in primitive functions. */
2745 init_decl_processing ()
2747 register tree endlink
;
2748 /* Either char* or void*. */
2749 tree traditional_ptr_type_node
;
2750 /* Data types of memcpy and strlen. */
2751 tree memcpy_ftype
, strlen_ftype
;
2752 tree void_ftype_any
;
2753 int wchar_type_size
;
2755 tree array_domain_type
;
2757 current_function_decl
= NULL
;
2758 named_labels
= NULL
;
2759 current_binding_level
= NULL_BINDING_LEVEL
;
2760 free_binding_level
= NULL_BINDING_LEVEL
;
2761 pushlevel (0); /* make the binding_level structure for global names */
2762 global_binding_level
= current_binding_level
;
2764 /* Define `int' and `char' first so that dbx will output them first. */
2766 integer_type_node
= make_signed_type (INT_TYPE_SIZE
);
2767 pushdecl (build_decl (TYPE_DECL
, ridpointers
[(int) RID_INT
],
2768 integer_type_node
));
2770 /* Define `char', which is like either `signed char' or `unsigned char'
2771 but not the same as either. */
2775 ? make_signed_type (CHAR_TYPE_SIZE
)
2776 : make_unsigned_type (CHAR_TYPE_SIZE
));
2777 pushdecl (build_decl (TYPE_DECL
, get_identifier ("char"),
2780 long_integer_type_node
= make_signed_type (LONG_TYPE_SIZE
);
2781 pushdecl (build_decl (TYPE_DECL
, get_identifier ("long int"),
2782 long_integer_type_node
));
2784 unsigned_type_node
= make_unsigned_type (INT_TYPE_SIZE
);
2785 pushdecl (build_decl (TYPE_DECL
, get_identifier ("unsigned int"),
2786 unsigned_type_node
));
2788 long_unsigned_type_node
= make_unsigned_type (LONG_TYPE_SIZE
);
2789 pushdecl (build_decl (TYPE_DECL
, get_identifier ("long unsigned int"),
2790 long_unsigned_type_node
));
2792 long_long_integer_type_node
= make_signed_type (LONG_LONG_TYPE_SIZE
);
2793 pushdecl (build_decl (TYPE_DECL
, get_identifier ("long long int"),
2794 long_long_integer_type_node
));
2796 long_long_unsigned_type_node
= make_unsigned_type (LONG_LONG_TYPE_SIZE
);
2797 pushdecl (build_decl (TYPE_DECL
, get_identifier ("long long unsigned int"),
2798 long_long_unsigned_type_node
));
2800 /* `unsigned long' is the standard type for sizeof.
2801 Traditionally, use a signed type.
2802 Note that stddef.h uses `unsigned long',
2803 and this must agree, even of long and int are the same size. */
2805 = TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (get_identifier (SIZE_TYPE
)));
2806 if (flag_traditional
&& TREE_UNSIGNED (sizetype
))
2807 sizetype
= signed_type (sizetype
);
2810 = TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (get_identifier (PTRDIFF_TYPE
)));
2812 TREE_TYPE (TYPE_SIZE (integer_type_node
)) = sizetype
;
2813 TREE_TYPE (TYPE_SIZE (char_type_node
)) = sizetype
;
2814 TREE_TYPE (TYPE_SIZE (unsigned_type_node
)) = sizetype
;
2815 TREE_TYPE (TYPE_SIZE (long_unsigned_type_node
)) = sizetype
;
2816 TREE_TYPE (TYPE_SIZE (long_integer_type_node
)) = sizetype
;
2817 TREE_TYPE (TYPE_SIZE (long_long_integer_type_node
)) = sizetype
;
2818 TREE_TYPE (TYPE_SIZE (long_long_unsigned_type_node
)) = sizetype
;
2820 error_mark_node
= make_node (ERROR_MARK
);
2821 TREE_TYPE (error_mark_node
) = error_mark_node
;
2823 short_integer_type_node
= make_signed_type (SHORT_TYPE_SIZE
);
2824 pushdecl (build_decl (TYPE_DECL
, get_identifier ("short int"),
2825 short_integer_type_node
));
2827 short_unsigned_type_node
= make_unsigned_type (SHORT_TYPE_SIZE
);
2828 pushdecl (build_decl (TYPE_DECL
, get_identifier ("short unsigned int"),
2829 short_unsigned_type_node
));
2831 /* Define both `signed char' and `unsigned char'. */
2832 signed_char_type_node
= make_signed_type (CHAR_TYPE_SIZE
);
2833 pushdecl (build_decl (TYPE_DECL
, get_identifier ("signed char"),
2834 signed_char_type_node
));
2836 unsigned_char_type_node
= make_unsigned_type (CHAR_TYPE_SIZE
);
2837 pushdecl (build_decl (TYPE_DECL
, get_identifier ("unsigned char"),
2838 unsigned_char_type_node
));
2840 intQI_type_node
= make_signed_type (GET_MODE_BITSIZE (QImode
));
2841 pushdecl (build_decl (TYPE_DECL
, NULL_TREE
, intQI_type_node
));
2843 intHI_type_node
= make_signed_type (GET_MODE_BITSIZE (HImode
));
2844 pushdecl (build_decl (TYPE_DECL
, NULL_TREE
, intHI_type_node
));
2846 intSI_type_node
= make_signed_type (GET_MODE_BITSIZE (SImode
));
2847 pushdecl (build_decl (TYPE_DECL
, NULL_TREE
, intSI_type_node
));
2849 intDI_type_node
= make_signed_type (GET_MODE_BITSIZE (DImode
));
2850 pushdecl (build_decl (TYPE_DECL
, NULL_TREE
, intDI_type_node
));
2852 unsigned_intQI_type_node
= make_unsigned_type (GET_MODE_BITSIZE (QImode
));
2853 pushdecl (build_decl (TYPE_DECL
, NULL_TREE
, unsigned_intQI_type_node
));
2855 unsigned_intHI_type_node
= make_unsigned_type (GET_MODE_BITSIZE (HImode
));
2856 pushdecl (build_decl (TYPE_DECL
, NULL_TREE
, unsigned_intHI_type_node
));
2858 unsigned_intSI_type_node
= make_unsigned_type (GET_MODE_BITSIZE (SImode
));
2859 pushdecl (build_decl (TYPE_DECL
, NULL_TREE
, unsigned_intSI_type_node
));
2861 unsigned_intDI_type_node
= make_unsigned_type (GET_MODE_BITSIZE (DImode
));
2862 pushdecl (build_decl (TYPE_DECL
, NULL_TREE
, unsigned_intDI_type_node
));
2864 float_type_node
= make_node (REAL_TYPE
);
2865 TYPE_PRECISION (float_type_node
) = FLOAT_TYPE_SIZE
;
2866 pushdecl (build_decl (TYPE_DECL
, ridpointers
[(int) RID_FLOAT
],
2868 layout_type (float_type_node
);
2870 double_type_node
= make_node (REAL_TYPE
);
2871 if (flag_short_double
)
2872 TYPE_PRECISION (double_type_node
) = FLOAT_TYPE_SIZE
;
2874 TYPE_PRECISION (double_type_node
) = DOUBLE_TYPE_SIZE
;
2875 pushdecl (build_decl (TYPE_DECL
, ridpointers
[(int) RID_DOUBLE
],
2877 layout_type (double_type_node
);
2879 long_double_type_node
= make_node (REAL_TYPE
);
2880 TYPE_PRECISION (long_double_type_node
) = LONG_DOUBLE_TYPE_SIZE
;
2881 pushdecl (build_decl (TYPE_DECL
, get_identifier ("long double"),
2882 long_double_type_node
));
2883 layout_type (long_double_type_node
);
2885 complex_integer_type_node
= make_node (COMPLEX_TYPE
);
2886 pushdecl (build_decl (TYPE_DECL
, get_identifier ("complex int"),
2887 complex_integer_type_node
));
2888 TREE_TYPE (complex_integer_type_node
) = integer_type_node
;
2889 layout_type (complex_integer_type_node
);
2891 complex_float_type_node
= make_node (COMPLEX_TYPE
);
2892 pushdecl (build_decl (TYPE_DECL
, get_identifier ("complex float"),
2893 complex_float_type_node
));
2894 TREE_TYPE (complex_float_type_node
) = float_type_node
;
2895 layout_type (complex_float_type_node
);
2897 complex_double_type_node
= make_node (COMPLEX_TYPE
);
2898 pushdecl (build_decl (TYPE_DECL
, get_identifier ("complex double"),
2899 complex_double_type_node
));
2900 TREE_TYPE (complex_double_type_node
) = double_type_node
;
2901 layout_type (complex_double_type_node
);
2903 complex_long_double_type_node
= make_node (COMPLEX_TYPE
);
2904 pushdecl (build_decl (TYPE_DECL
, get_identifier ("complex long double"),
2905 complex_long_double_type_node
));
2906 TREE_TYPE (complex_long_double_type_node
) = long_double_type_node
;
2907 layout_type (complex_long_double_type_node
);
2910 = TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (get_identifier (WCHAR_TYPE
)));
2911 wchar_type_size
= TYPE_PRECISION (wchar_type_node
);
2912 signed_wchar_type_node
= signed_type (wchar_type_node
);
2913 unsigned_wchar_type_node
= unsigned_type (wchar_type_node
);
2915 integer_zero_node
= build_int_2 (0, 0);
2916 TREE_TYPE (integer_zero_node
) = integer_type_node
;
2917 integer_one_node
= build_int_2 (1, 0);
2918 TREE_TYPE (integer_one_node
) = integer_type_node
;
2920 boolean_type_node
= integer_type_node
;
2921 boolean_true_node
= integer_one_node
;
2922 boolean_false_node
= integer_zero_node
;
2924 size_zero_node
= build_int_2 (0, 0);
2925 TREE_TYPE (size_zero_node
) = sizetype
;
2926 size_one_node
= build_int_2 (1, 0);
2927 TREE_TYPE (size_one_node
) = sizetype
;
2929 void_type_node
= make_node (VOID_TYPE
);
2930 pushdecl (build_decl (TYPE_DECL
,
2931 ridpointers
[(int) RID_VOID
], void_type_node
));
2932 layout_type (void_type_node
); /* Uses integer_zero_node */
2933 /* We are not going to have real types in C with less than byte alignment,
2934 so we might as well not have any types that claim to have it. */
2935 TYPE_ALIGN (void_type_node
) = BITS_PER_UNIT
;
2937 null_pointer_node
= build_int_2 (0, 0);
2938 TREE_TYPE (null_pointer_node
) = build_pointer_type (void_type_node
);
2939 layout_type (TREE_TYPE (null_pointer_node
));
2941 string_type_node
= build_pointer_type (char_type_node
);
2942 const_string_type_node
2943 = build_pointer_type (build_type_variant (char_type_node
, 1, 0));
2945 /* Make a type to be the domain of a few array types
2946 whose domains don't really matter.
2947 200 is small enough that it always fits in size_t
2948 and large enough that it can hold most function names for the
2949 initializations of __FUNCTION__ and __PRETTY_FUNCTION__. */
2950 array_domain_type
= build_index_type (build_int_2 (200, 0));
2952 /* make a type for arrays of characters.
2953 With luck nothing will ever really depend on the length of this
2955 char_array_type_node
2956 = build_array_type (char_type_node
, array_domain_type
);
2957 /* Likewise for arrays of ints. */
2959 = build_array_type (integer_type_node
, array_domain_type
);
2960 /* This is for wide string constants. */
2961 wchar_array_type_node
2962 = build_array_type (wchar_type_node
, array_domain_type
);
2964 default_function_type
2965 = build_function_type (integer_type_node
, NULL_TREE
);
2967 ptr_type_node
= build_pointer_type (void_type_node
);
2969 = build_pointer_type (build_type_variant (void_type_node
, 1, 0));
2971 endlink
= tree_cons (NULL_TREE
, void_type_node
, NULL_TREE
);
2974 = build_function_type (void_type_node
, NULL_TREE
);
2977 = build_function_type (float_type_node
,
2978 tree_cons (NULL_TREE
, float_type_node
, endlink
));
2981 = build_function_type (double_type_node
,
2982 tree_cons (NULL_TREE
, double_type_node
, endlink
));
2984 ldouble_ftype_ldouble
2985 = build_function_type (long_double_type_node
,
2986 tree_cons (NULL_TREE
, long_double_type_node
,
2989 double_ftype_double_double
2990 = build_function_type (double_type_node
,
2991 tree_cons (NULL_TREE
, double_type_node
,
2992 tree_cons (NULL_TREE
,
2993 double_type_node
, endlink
)));
2996 = build_function_type (integer_type_node
,
2997 tree_cons (NULL_TREE
, integer_type_node
, endlink
));
3000 = build_function_type (long_integer_type_node
,
3001 tree_cons (NULL_TREE
,
3002 long_integer_type_node
, endlink
));
3004 void_ftype_ptr_ptr_int
3005 = build_function_type (void_type_node
,
3006 tree_cons (NULL_TREE
, ptr_type_node
,
3007 tree_cons (NULL_TREE
, ptr_type_node
,
3008 tree_cons (NULL_TREE
,
3012 int_ftype_cptr_cptr_sizet
3013 = build_function_type (integer_type_node
,
3014 tree_cons (NULL_TREE
, const_ptr_type_node
,
3015 tree_cons (NULL_TREE
, const_ptr_type_node
,
3016 tree_cons (NULL_TREE
,
3020 void_ftype_ptr_int_int
3021 = build_function_type (void_type_node
,
3022 tree_cons (NULL_TREE
, ptr_type_node
,
3023 tree_cons (NULL_TREE
, integer_type_node
,
3024 tree_cons (NULL_TREE
,
3028 string_ftype_ptr_ptr
/* strcpy prototype */
3029 = build_function_type (string_type_node
,
3030 tree_cons (NULL_TREE
, string_type_node
,
3031 tree_cons (NULL_TREE
,
3032 const_string_type_node
,
3035 int_ftype_string_string
/* strcmp prototype */
3036 = build_function_type (integer_type_node
,
3037 tree_cons (NULL_TREE
, const_string_type_node
,
3038 tree_cons (NULL_TREE
,
3039 const_string_type_node
,
3042 strlen_ftype
/* strlen prototype */
3043 = build_function_type (flag_traditional
? integer_type_node
: sizetype
,
3044 tree_cons (NULL_TREE
, const_string_type_node
,
3047 traditional_ptr_type_node
3048 = (flag_traditional
? string_type_node
: ptr_type_node
);
3050 memcpy_ftype
/* memcpy prototype */
3051 = build_function_type (traditional_ptr_type_node
,
3052 tree_cons (NULL_TREE
, ptr_type_node
,
3053 tree_cons (NULL_TREE
, const_ptr_type_node
,
3054 tree_cons (NULL_TREE
,
3058 builtin_function ("__builtin_constant_p", int_ftype_int
,
3059 BUILT_IN_CONSTANT_P
, NULL_PTR
);
3061 builtin_function ("__builtin_return_address",
3062 build_function_type (ptr_type_node
,
3063 tree_cons (NULL_TREE
,
3066 BUILT_IN_RETURN_ADDRESS
, NULL_PTR
);
3068 builtin_function ("__builtin_frame_address",
3069 build_function_type (ptr_type_node
,
3070 tree_cons (NULL_TREE
,
3073 BUILT_IN_FRAME_ADDRESS
, NULL_PTR
);
3075 builtin_function ("__builtin_alloca",
3076 build_function_type (ptr_type_node
,
3077 tree_cons (NULL_TREE
,
3080 BUILT_IN_ALLOCA
, "alloca");
3081 builtin_function ("__builtin_ffs", int_ftype_int
, BUILT_IN_FFS
, NULL_PTR
);
3082 /* Define alloca, ffs as builtins.
3083 Declare _exit just to mark it as volatile. */
3084 if (! flag_no_builtin
&& !flag_no_nonansi_builtin
)
3086 temp
= builtin_function ("alloca",
3087 build_function_type (ptr_type_node
,
3088 tree_cons (NULL_TREE
,
3091 BUILT_IN_ALLOCA
, NULL_PTR
);
3092 /* Suppress error if redefined as a non-function. */
3093 DECL_BUILT_IN_NONANSI (temp
) = 1;
3094 temp
= builtin_function ("ffs", int_ftype_int
, BUILT_IN_FFS
, NULL_PTR
);
3095 /* Suppress error if redefined as a non-function. */
3096 DECL_BUILT_IN_NONANSI (temp
) = 1;
3097 temp
= builtin_function ("_exit", void_ftype_any
, NOT_BUILT_IN
,
3099 TREE_THIS_VOLATILE (temp
) = 1;
3100 TREE_SIDE_EFFECTS (temp
) = 1;
3101 /* Suppress error if redefined as a non-function. */
3102 DECL_BUILT_IN_NONANSI (temp
) = 1;
3105 builtin_function ("__builtin_abs", int_ftype_int
, BUILT_IN_ABS
, NULL_PTR
);
3106 builtin_function ("__builtin_fabsf", float_ftype_float
, BUILT_IN_FABS
,
3108 builtin_function ("__builtin_fabs", double_ftype_double
, BUILT_IN_FABS
,
3110 builtin_function ("__builtin_fabsl", ldouble_ftype_ldouble
, BUILT_IN_FABS
,
3112 builtin_function ("__builtin_labs", long_ftype_long
, BUILT_IN_LABS
,
3114 builtin_function ("__builtin_saveregs",
3115 build_function_type (ptr_type_node
, NULL_TREE
),
3116 BUILT_IN_SAVEREGS
, NULL_PTR
);
3117 /* EXPAND_BUILTIN_VARARGS is obsolete. */
3119 builtin_function ("__builtin_varargs",
3120 build_function_type (ptr_type_node
,
3121 tree_cons (NULL_TREE
,
3124 BUILT_IN_VARARGS
, NULL_PTR
);
3126 builtin_function ("__builtin_classify_type", default_function_type
,
3127 BUILT_IN_CLASSIFY_TYPE
, NULL_PTR
);
3128 builtin_function ("__builtin_next_arg",
3129 build_function_type (ptr_type_node
, NULL_TREE
),
3130 BUILT_IN_NEXT_ARG
, NULL_PTR
);
3131 builtin_function ("__builtin_args_info",
3132 build_function_type (integer_type_node
,
3133 tree_cons (NULL_TREE
,
3136 BUILT_IN_ARGS_INFO
, NULL_PTR
);
3138 /* Untyped call and return. */
3139 builtin_function ("__builtin_apply_args",
3140 build_function_type (ptr_type_node
, NULL_TREE
),
3141 BUILT_IN_APPLY_ARGS
, NULL_PTR
);
3143 temp
= tree_cons (NULL_TREE
,
3144 build_pointer_type (build_function_type (void_type_node
,
3146 tree_cons (NULL_TREE
,
3148 tree_cons (NULL_TREE
,
3151 builtin_function ("__builtin_apply",
3152 build_function_type (ptr_type_node
, temp
),
3153 BUILT_IN_APPLY
, NULL_PTR
);
3154 builtin_function ("__builtin_return",
3155 build_function_type (void_type_node
,
3156 tree_cons (NULL_TREE
,
3159 BUILT_IN_RETURN
, NULL_PTR
);
3161 /* Currently under experimentation. */
3162 builtin_function ("__builtin_memcpy", memcpy_ftype
,
3163 BUILT_IN_MEMCPY
, "memcpy");
3164 builtin_function ("__builtin_memcmp", int_ftype_cptr_cptr_sizet
,
3165 BUILT_IN_MEMCMP
, "memcmp");
3166 builtin_function ("__builtin_strcmp", int_ftype_string_string
,
3167 BUILT_IN_STRCMP
, "strcmp");
3168 builtin_function ("__builtin_strcpy", string_ftype_ptr_ptr
,
3169 BUILT_IN_STRCPY
, "strcpy");
3170 builtin_function ("__builtin_strlen", strlen_ftype
,
3171 BUILT_IN_STRLEN
, "strlen");
3172 builtin_function ("__builtin_sqrtf", float_ftype_float
,
3173 BUILT_IN_FSQRT
, "sqrtf");
3174 builtin_function ("__builtin_fsqrt", double_ftype_double
,
3175 BUILT_IN_FSQRT
, "sqrt");
3176 builtin_function ("__builtin_sqrtl", ldouble_ftype_ldouble
,
3177 BUILT_IN_FSQRT
, "sqrtl");
3178 builtin_function ("__builtin_sinf", float_ftype_float
,
3179 BUILT_IN_SIN
, "sinf");
3180 builtin_function ("__builtin_sin", double_ftype_double
,
3181 BUILT_IN_SIN
, "sin");
3182 builtin_function ("__builtin_sinl", ldouble_ftype_ldouble
,
3183 BUILT_IN_SIN
, "sinl");
3184 builtin_function ("__builtin_cosf", float_ftype_float
,
3185 BUILT_IN_COS
, "cosf");
3186 builtin_function ("__builtin_cos", double_ftype_double
,
3187 BUILT_IN_COS
, "cos");
3188 builtin_function ("__builtin_cosl", ldouble_ftype_ldouble
,
3189 BUILT_IN_COS
, "cosl");
3191 /* In an ANSI C program, it is okay to supply built-in meanings
3192 for these functions, since applications cannot validly use them
3193 with any other meaning.
3194 However, honor the -fno-builtin option. */
3195 if (!flag_no_builtin
)
3197 builtin_function ("abs", int_ftype_int
, BUILT_IN_ABS
, NULL_PTR
);
3198 builtin_function ("fabsf", float_ftype_float
, BUILT_IN_FABS
, NULL_PTR
);
3199 builtin_function ("fabs", double_ftype_double
, BUILT_IN_FABS
, NULL_PTR
);
3200 builtin_function ("fabsl", ldouble_ftype_ldouble
, BUILT_IN_FABS
,
3202 builtin_function ("labs", long_ftype_long
, BUILT_IN_LABS
, NULL_PTR
);
3203 builtin_function ("memcpy", memcpy_ftype
, BUILT_IN_MEMCPY
, NULL_PTR
);
3204 builtin_function ("memcmp", int_ftype_cptr_cptr_sizet
, BUILT_IN_MEMCMP
,
3206 builtin_function ("strcmp", int_ftype_string_string
, BUILT_IN_STRCMP
,
3208 builtin_function ("strcpy", string_ftype_ptr_ptr
, BUILT_IN_STRCPY
,
3210 builtin_function ("strlen", strlen_ftype
, BUILT_IN_STRLEN
, NULL_PTR
);
3211 builtin_function ("sqrtf", float_ftype_float
, BUILT_IN_FSQRT
, NULL_PTR
);
3212 builtin_function ("sqrt", double_ftype_double
, BUILT_IN_FSQRT
, NULL_PTR
);
3213 builtin_function ("sqrtl", ldouble_ftype_ldouble
, BUILT_IN_FSQRT
,
3215 builtin_function ("sinf", float_ftype_float
, BUILT_IN_SIN
, NULL_PTR
);
3216 builtin_function ("sin", double_ftype_double
, BUILT_IN_SIN
, NULL_PTR
);
3217 builtin_function ("sinl", ldouble_ftype_ldouble
, BUILT_IN_SIN
, NULL_PTR
);
3218 builtin_function ("cosf", float_ftype_float
, BUILT_IN_COS
, NULL_PTR
);
3219 builtin_function ("cos", double_ftype_double
, BUILT_IN_COS
, NULL_PTR
);
3220 builtin_function ("cosl", ldouble_ftype_ldouble
, BUILT_IN_COS
, NULL_PTR
);
3222 /* Declare these functions volatile
3223 to avoid spurious "control drops through" warnings. */
3224 /* Don't specify the argument types, to avoid errors
3225 from certain code which isn't valid in ANSI but which exists. */
3226 temp
= builtin_function ("abort", void_ftype_any
, NOT_BUILT_IN
,
3228 TREE_THIS_VOLATILE (temp
) = 1;
3229 TREE_SIDE_EFFECTS (temp
) = 1;
3230 temp
= builtin_function ("exit", void_ftype_any
, NOT_BUILT_IN
, NULL_PTR
);
3231 TREE_THIS_VOLATILE (temp
) = 1;
3232 TREE_SIDE_EFFECTS (temp
) = 1;
3236 /* Support for these has not been written in either expand_builtin
3237 or build_function_call. */
3238 builtin_function ("__builtin_div", default_ftype
, BUILT_IN_DIV
, NULL_PTR
);
3239 builtin_function ("__builtin_ldiv", default_ftype
, BUILT_IN_LDIV
, NULL_PTR
);
3240 builtin_function ("__builtin_ffloor", double_ftype_double
, BUILT_IN_FFLOOR
,
3242 builtin_function ("__builtin_fceil", double_ftype_double
, BUILT_IN_FCEIL
,
3244 builtin_function ("__builtin_fmod", double_ftype_double_double
,
3245 BUILT_IN_FMOD
, NULL_PTR
);
3246 builtin_function ("__builtin_frem", double_ftype_double_double
,
3247 BUILT_IN_FREM
, NULL_PTR
);
3248 builtin_function ("__builtin_memset", ptr_ftype_ptr_int_int
,
3249 BUILT_IN_MEMSET
, NULL_PTR
);
3250 builtin_function ("__builtin_getexp", double_ftype_double
, BUILT_IN_GETEXP
,
3252 builtin_function ("__builtin_getman", double_ftype_double
, BUILT_IN_GETMAN
,
3256 pedantic_lvalues
= pedantic
;
3258 /* Create the global bindings for __FUNCTION__ and __PRETTY_FUNCTION__. */
3259 declare_function_name ();
3261 start_identifier_warnings ();
3263 /* Prepare to check format strings against argument lists. */
3264 init_function_format_info ();
3268 incomplete_decl_finalize_hook
= finish_incomplete_decl
;
3271 /* Return a definition for a builtin function named NAME and whose data type
3272 is TYPE. TYPE should be a function type with argument types.
3273 FUNCTION_CODE tells later passes how to compile calls to this function.
3274 See tree.h for its possible values.
3276 If LIBRARY_NAME is nonzero, use that for DECL_ASSEMBLER_NAME,
3277 the name to be called if we can't opencode the function. */
3280 builtin_function (name
, type
, function_code
, library_name
)
3283 enum built_in_function function_code
;
3286 tree decl
= build_decl (FUNCTION_DECL
, get_identifier (name
), type
);
3287 DECL_EXTERNAL (decl
) = 1;
3288 TREE_PUBLIC (decl
) = 1;
3289 /* If -traditional, permit redefining a builtin function any way you like.
3290 (Though really, if the program redefines these functions,
3291 it probably won't work right unless compiled with -fno-builtin.) */
3292 if (flag_traditional
&& name
[0] != '_')
3293 DECL_BUILT_IN_NONANSI (decl
) = 1;
3295 DECL_ASSEMBLER_NAME (decl
) = get_identifier (library_name
);
3296 make_decl_rtl (decl
, NULL_PTR
, 1);
3298 if (function_code
!= NOT_BUILT_IN
)
3300 DECL_BUILT_IN (decl
) = 1;
3301 DECL_FUNCTION_CODE (decl
) = function_code
;
3303 /* Warn if a function in the namespace for users
3304 is used without an occasion to consider it declared. */
3305 if (name
[0] != '_' || name
[1] != '_')
3306 C_DECL_ANTICIPATED (decl
) = 1;
3311 /* Called when a declaration is seen that contains no names to declare.
3312 If its type is a reference to a structure, union or enum inherited
3313 from a containing scope, shadow that tag name for the current scope
3314 with a forward reference.
3315 If its type defines a new named structure or union
3316 or defines an enum, it is valid but we need not do anything here.
3317 Otherwise, it is an error. */
3320 shadow_tag (declspecs
)
3323 shadow_tag_warned (declspecs
, 0);
3327 shadow_tag_warned (declspecs
, warned
)
3330 /* 1 => we have done a pedwarn. 2 => we have done a warning, but
3336 pending_invalid_xref
= 0;
3338 for (link
= declspecs
; link
; link
= TREE_CHAIN (link
))
3340 register tree value
= TREE_VALUE (link
);
3341 register enum tree_code code
= TREE_CODE (value
);
3343 if (code
== RECORD_TYPE
|| code
== UNION_TYPE
|| code
== ENUMERAL_TYPE
)
3344 /* Used to test also that TYPE_SIZE (value) != 0.
3345 That caused warning for `struct foo;' at top level in the file. */
3347 register tree name
= lookup_tag_reverse (value
);
3354 if (warned
!= 1 && code
!= ENUMERAL_TYPE
)
3355 /* Empty unnamed enum OK */
3357 pedwarn ("unnamed struct/union that defines no instances");
3363 t
= lookup_tag (code
, name
, current_binding_level
, 1);
3367 t
= make_node (code
);
3376 warning ("useless keyword or type name in empty declaration");
3383 error ("two types specified in one empty declaration");
3388 pedwarn ("empty declaration");
3392 /* Decode a "typename", such as "int **", returning a ..._TYPE node. */
3395 groktypename (typename
)
3398 if (TREE_CODE (typename
) != TREE_LIST
)
3400 return grokdeclarator (TREE_VALUE (typename
),
3401 TREE_PURPOSE (typename
),
3405 /* Return a PARM_DECL node for a given pair of specs and declarator. */
3408 groktypename_in_parm_context (typename
)
3411 if (TREE_CODE (typename
) != TREE_LIST
)
3413 return grokdeclarator (TREE_VALUE (typename
),
3414 TREE_PURPOSE (typename
),
3418 /* Decode a declarator in an ordinary declaration or data definition.
3419 This is called as soon as the type information and variable name
3420 have been parsed, before parsing the initializer if any.
3421 Here we create the ..._DECL node, fill in its type,
3422 and put it on the list of decls for the current context.
3423 The ..._DECL node is returned as the value.
3425 Exception: for arrays where the length is not specified,
3426 the type is left null, to be filled in by `finish_decl'.
3428 Function definitions do not come here; they go to start_function
3429 instead. However, external and forward declarations of functions
3430 do go through here. Structure field declarations are done by
3431 grokfield and not through here. */
3433 /* Set this to zero to debug not using the temporary obstack
3434 to parse initializers. */
3435 int debug_temp_inits
= 1;
3438 start_decl (declarator
, declspecs
, initialized
)
3439 tree declarator
, declspecs
;
3442 register tree decl
= grokdeclarator (declarator
, declspecs
,
3443 NORMAL
, initialized
);
3445 int init_written
= initialized
;
3447 /* The corresponding pop_obstacks is in finish_decl. */
3448 push_obstacks_nochange ();
3451 /* Is it valid for this decl to have an initializer at all?
3452 If not, set INITIALIZED to zero, which will indirectly
3453 tell `finish_decl' to ignore the initializer once it is parsed. */
3454 switch (TREE_CODE (decl
))
3457 /* typedef foo = bar means give foo the same type as bar.
3458 We haven't parsed bar yet, so `finish_decl' will fix that up.
3459 Any other case of an initialization in a TYPE_DECL is an error. */
3460 if (pedantic
|| list_length (declspecs
) > 1)
3462 error ("typedef `%s' is initialized",
3463 IDENTIFIER_POINTER (DECL_NAME (decl
)));
3469 error ("function `%s' is initialized like a variable",
3470 IDENTIFIER_POINTER (DECL_NAME (decl
)));
3475 /* DECL_INITIAL in a PARM_DECL is really DECL_ARG_TYPE. */
3476 error ("parameter `%s' is initialized",
3477 IDENTIFIER_POINTER (DECL_NAME (decl
)));
3482 /* Don't allow initializations for incomplete types
3483 except for arrays which might be completed by the initialization. */
3484 if (TYPE_SIZE (TREE_TYPE (decl
)) != 0)
3486 /* A complete type is ok if size is fixed. */
3488 if (TREE_CODE (TYPE_SIZE (TREE_TYPE (decl
))) != INTEGER_CST
3489 || C_DECL_VARIABLE_SIZE (decl
))
3491 error ("variable-sized object may not be initialized");
3495 else if (TREE_CODE (TREE_TYPE (decl
)) != ARRAY_TYPE
)
3497 error ("variable `%s' has initializer but incomplete type",
3498 IDENTIFIER_POINTER (DECL_NAME (decl
)));
3501 else if (TYPE_SIZE (TREE_TYPE (TREE_TYPE (decl
))) == 0)
3503 error ("elements of array `%s' have incomplete type",
3504 IDENTIFIER_POINTER (DECL_NAME (decl
)));
3511 #if 0 /* Seems redundant with grokdeclarator. */
3512 if (current_binding_level
!= global_binding_level
3513 && DECL_EXTERNAL (decl
)
3514 && TREE_CODE (decl
) != FUNCTION_DECL
)
3515 warning ("declaration of `%s' has `extern' and is initialized",
3516 IDENTIFIER_POINTER (DECL_NAME (decl
)));
3518 DECL_EXTERNAL (decl
) = 0;
3519 if (current_binding_level
== global_binding_level
)
3520 TREE_STATIC (decl
) = 1;
3522 /* Tell `pushdecl' this is an initialized decl
3523 even though we don't yet have the initializer expression.
3524 Also tell `finish_decl' it may store the real initializer. */
3525 DECL_INITIAL (decl
) = error_mark_node
;
3528 /* If this is a function declaration, write a record describing it to the
3529 prototypes file (if requested). */
3531 if (TREE_CODE (decl
) == FUNCTION_DECL
)
3532 gen_aux_info_record (decl
, 0, 0, TYPE_ARG_TYPES (TREE_TYPE (decl
)) != 0);
3534 /* Add this decl to the current binding level.
3535 TEM may equal DECL or it may be a previous decl of the same name. */
3536 tem
= pushdecl (decl
);
3538 /* For C and Obective-C, we by default put things in .common when
3540 DECL_COMMON (tem
) = 1;
3542 /* For a local variable, define the RTL now. */
3543 if (current_binding_level
!= global_binding_level
3544 /* But not if this is a duplicate decl
3545 and we preserved the rtl from the previous one
3546 (which may or may not happen). */
3547 && DECL_RTL (tem
) == 0)
3549 if (TYPE_SIZE (TREE_TYPE (tem
)) != 0)
3551 else if (TREE_CODE (TREE_TYPE (tem
)) == ARRAY_TYPE
3552 && DECL_INITIAL (tem
) != 0)
3558 /* When parsing and digesting the initializer,
3559 use temporary storage. Do this even if we will ignore the value. */
3560 if (current_binding_level
== global_binding_level
&& debug_temp_inits
)
3561 temporary_allocation ();
3567 /* Finish processing of a declaration;
3568 install its initial value.
3569 If the length of an array type is not known before,
3570 it must be determined now, from the initial value, or it is an error. */
3573 finish_decl (decl
, init
, asmspec_tree
)
3577 register tree type
= TREE_TYPE (decl
);
3578 int was_incomplete
= (DECL_SIZE (decl
) == 0);
3579 int temporary
= allocation_temporary_p ();
3582 /* If a name was specified, get the string. */
3584 asmspec
= TREE_STRING_POINTER (asmspec_tree
);
3586 /* If `start_decl' didn't like having an initialization, ignore it now. */
3588 if (init
!= 0 && DECL_INITIAL (decl
) == 0)
3590 /* Don't crash if parm is initialized. */
3591 if (TREE_CODE (decl
) == PARM_DECL
)
3594 if (ITERATOR_P (decl
))
3597 error_with_decl (decl
, "iterator has no initial value");
3599 init
= save_expr (init
);
3604 if (TREE_CODE (decl
) != TYPE_DECL
)
3605 store_init_value (decl
, init
);
3608 /* typedef foo = bar; store the type of bar as the type of foo. */
3609 TREE_TYPE (decl
) = TREE_TYPE (init
);
3610 DECL_INITIAL (decl
) = init
= 0;
3614 /* Pop back to the obstack that is current for this binding level.
3615 This is because MAXINDEX, rtl, etc. to be made below
3616 must go in the permanent obstack. But don't discard the
3617 temporary data yet. */
3619 #if 0 /* pop_obstacks was near the end; this is what was here. */
3620 if (current_binding_level
== global_binding_level
&& temporary
)
3621 end_temporary_allocation ();
3624 /* Deduce size of array from initialization, if not already known */
3626 if (TREE_CODE (type
) == ARRAY_TYPE
3627 && TYPE_DOMAIN (type
) == 0
3628 && TREE_CODE (decl
) != TYPE_DECL
)
3631 = (TREE_STATIC (decl
)
3632 /* Even if pedantic, an external linkage array
3633 may have incomplete type at first. */
3634 ? pedantic
&& !TREE_PUBLIC (decl
)
3635 : !DECL_EXTERNAL (decl
));
3637 = complete_array_type (type
, DECL_INITIAL (decl
), do_default
);
3639 /* Get the completed type made by complete_array_type. */
3640 type
= TREE_TYPE (decl
);
3643 error_with_decl (decl
, "initializer fails to determine size of `%s'");
3648 error_with_decl (decl
, "array size missing in `%s'");
3649 /* If a `static' var's size isn't known,
3650 make it extern as well as static, so it does not get
3652 If it is not `static', then do not mark extern;
3653 finish_incomplete_decl will give it a default size
3654 and it will get allocated. */
3655 else if (!pedantic
&& TREE_STATIC (decl
) && ! TREE_PUBLIC (decl
))
3656 DECL_EXTERNAL (decl
) = 1;
3659 /* TYPE_MAX_VALUE is always one less than the number of elements
3660 in the array, because we start counting at zero. Therefore,
3661 warn only if the value is less than zero. */
3662 if (pedantic
&& TYPE_DOMAIN (type
) != 0
3663 && tree_int_cst_sgn (TYPE_MAX_VALUE (TYPE_DOMAIN (type
))) < 0)
3664 error_with_decl (decl
, "zero or negative size array `%s'");
3666 layout_decl (decl
, 0);
3669 if (TREE_CODE (decl
) == VAR_DECL
)
3671 if (DECL_SIZE (decl
) == 0
3672 && TYPE_SIZE (TREE_TYPE (decl
)) != 0)
3673 layout_decl (decl
, 0);
3675 if (DECL_SIZE (decl
) == 0
3676 && (TREE_STATIC (decl
)
3678 /* A static variable with an incomplete type
3679 is an error if it is initialized.
3680 Also if it is not file scope.
3681 Otherwise, let it through, but if it is not `extern'
3682 then it may cause an error message later. */
3683 /* We must use DECL_CONTEXT instead of current_binding_level,
3684 because a duplicate_decls call could have changed the binding
3685 level of this decl. */
3686 (DECL_INITIAL (decl
) != 0 || DECL_CONTEXT (decl
) != 0)
3688 /* An automatic variable with an incomplete type
3690 !DECL_EXTERNAL (decl
)))
3692 error_with_decl (decl
, "storage size of `%s' isn't known");
3693 TREE_TYPE (decl
) = error_mark_node
;
3696 if ((DECL_EXTERNAL (decl
) || TREE_STATIC (decl
))
3697 && DECL_SIZE (decl
) != 0)
3699 if (TREE_CODE (DECL_SIZE (decl
)) == INTEGER_CST
)
3700 constant_expression_warning (DECL_SIZE (decl
));
3702 error_with_decl (decl
, "storage size of `%s' isn't constant");
3706 /* If this is a function and an assembler name is specified, it isn't
3707 builtin any more. Also reset DECL_RTL so we can give it its new
3709 if (TREE_CODE (decl
) == FUNCTION_DECL
&& asmspec
)
3711 DECL_BUILT_IN (decl
) = 0;
3712 DECL_RTL (decl
) = 0;
3715 /* Output the assembler code and/or RTL code for variables and functions,
3716 unless the type is an undefined structure or union.
3717 If not, it will get done when the type is completed. */
3719 if (TREE_CODE (decl
) == VAR_DECL
|| TREE_CODE (decl
) == FUNCTION_DECL
)
3721 if ((flag_traditional
|| TREE_PERMANENT (decl
))
3722 && allocation_temporary_p ())
3724 push_obstacks_nochange ();
3725 end_temporary_allocation ();
3726 /* This is a no-op in c-lang.c or something real in objc-actions.c. */
3727 maybe_objc_check_decl (decl
);
3728 rest_of_decl_compilation (decl
, asmspec
, DECL_CONTEXT (decl
) == 0,
3734 /* This is a no-op in c-lang.c or something real in objc-actions.c. */
3735 maybe_objc_check_decl (decl
);
3736 rest_of_decl_compilation (decl
, asmspec
, DECL_CONTEXT (decl
) == 0,
3739 if (DECL_CONTEXT (decl
) != 0)
3741 /* Recompute the RTL of a local array now
3742 if it used to be an incomplete type. */
3744 && ! TREE_STATIC (decl
) && ! DECL_EXTERNAL (decl
))
3746 /* If we used it already as memory, it must stay in memory. */
3747 TREE_ADDRESSABLE (decl
) = TREE_USED (decl
);
3748 /* If it's still incomplete now, no init will save it. */
3749 if (DECL_SIZE (decl
) == 0)
3750 DECL_INITIAL (decl
) = 0;
3753 /* Compute and store the initial value. */
3754 if (TREE_CODE (decl
) != FUNCTION_DECL
)
3755 expand_decl_init (decl
);
3759 if (TREE_CODE (decl
) == TYPE_DECL
)
3761 /* This is a no-op in c-lang.c or something real in objc-actions.c. */
3762 maybe_objc_check_decl (decl
);
3763 rest_of_decl_compilation (decl
, NULL_PTR
, DECL_CONTEXT (decl
) == 0,
3767 /* ??? After 2.3, test (init != 0) instead of TREE_CODE. */
3768 /* This test used to include TREE_PERMANENT, however, we have the same
3769 problem with initializers at the function level. Such initializers get
3770 saved until the end of the function on the momentary_obstack. */
3771 if (!(TREE_CODE (decl
) == FUNCTION_DECL
&& DECL_INLINE (decl
))
3773 /* DECL_INITIAL is not defined in PARM_DECLs, since it shares
3774 space with DECL_ARG_TYPE. */
3775 && TREE_CODE (decl
) != PARM_DECL
)
3777 /* We need to remember that this array HAD an initialization,
3778 but discard the actual temporary nodes,
3779 since we can't have a permanent node keep pointing to them. */
3780 /* We make an exception for inline functions, since it's
3781 normal for a local extern redeclaration of an inline function
3782 to have a copy of the top-level decl's DECL_INLINE. */
3783 if (DECL_INITIAL (decl
) != 0 && DECL_INITIAL (decl
) != error_mark_node
)
3785 /* If this is a const variable, then preserve the
3786 initializer instead of discarding it so that we can optimize
3787 references to it. */
3788 /* This test used to include TREE_STATIC, but this won't be set
3789 for function level initializers. */
3790 if (TREE_READONLY (decl
) || ITERATOR_P (decl
))
3792 preserve_initializer ();
3793 /* Hack? Set the permanent bit for something that is permanent,
3794 but not on the permenent obstack, so as to convince
3795 output_constant_def to make its rtl on the permanent
3797 TREE_PERMANENT (DECL_INITIAL (decl
)) = 1;
3799 /* The initializer and DECL must have the same (or equivalent
3800 types), but if the initializer is a STRING_CST, its type
3801 might not be on the right obstack, so copy the type
3803 TREE_TYPE (DECL_INITIAL (decl
)) = type
;
3806 DECL_INITIAL (decl
) = error_mark_node
;
3810 /* If requested, warn about definitions of large data objects. */
3812 if (warn_larger_than
3813 && (TREE_CODE (decl
) == VAR_DECL
|| TREE_CODE (decl
) == PARM_DECL
)
3814 && !DECL_EXTERNAL (decl
))
3816 register tree decl_size
= DECL_SIZE (decl
);
3818 if (decl_size
&& TREE_CODE (decl_size
) == INTEGER_CST
)
3820 unsigned units
= TREE_INT_CST_LOW(decl_size
) / BITS_PER_UNIT
;
3822 if (units
> larger_than_size
)
3823 warning_with_decl (decl
, "size of `%s' is %u bytes", units
);
3828 /* Resume permanent allocation, if not within a function. */
3829 /* The corresponding push_obstacks_nochange is in start_decl,
3830 and in push_parm_decl and in grokfield. */
3834 /* If we have gone back from temporary to permanent allocation,
3835 actually free the temporary space that we no longer need. */
3836 if (temporary
&& !allocation_temporary_p ())
3837 permanent_allocation (0);
3839 /* At the end of a declaration, throw away any variable type sizes
3840 of types defined inside that declaration. There is no use
3841 computing them in the following function definition. */
3842 if (current_binding_level
== global_binding_level
)
3843 get_pending_sizes ();
3846 /* If DECL has a cleanup, build and return that cleanup here.
3847 This is a callback called by expand_expr. */
3850 maybe_build_cleanup (decl
)
3853 /* There are no cleanups in C. */
3857 /* Given a parsed parameter declaration,
3858 decode it into a PARM_DECL and push that on the current binding level.
3859 Also, for the sake of forward parm decls,
3860 record the given order of parms in `parm_order'. */
3863 push_parm_decl (parm
)
3867 int old_immediate_size_expand
= immediate_size_expand
;
3868 /* Don't try computing parm sizes now -- wait till fn is called. */
3869 immediate_size_expand
= 0;
3871 /* The corresponding pop_obstacks is in finish_decl. */
3872 push_obstacks_nochange ();
3874 decl
= grokdeclarator (TREE_VALUE (parm
), TREE_PURPOSE (parm
), PARM
, 0);
3877 if (DECL_NAME (decl
))
3880 olddecl
= lookup_name (DECL_NAME (decl
));
3881 if (pedantic
&& olddecl
!= 0 && TREE_CODE (olddecl
) == TYPE_DECL
)
3882 pedwarn_with_decl (decl
, "ANSI C forbids parameter `%s' shadowing typedef");
3886 decl
= pushdecl (decl
);
3888 immediate_size_expand
= old_immediate_size_expand
;
3890 current_binding_level
->parm_order
3891 = tree_cons (NULL_TREE
, decl
, current_binding_level
->parm_order
);
3893 /* Add this decl to the current binding level. */
3894 finish_decl (decl
, NULL_TREE
, NULL_TREE
);
3897 /* Clear the given order of parms in `parm_order'.
3898 Used at start of parm list,
3899 and also at semicolon terminating forward decls. */
3904 current_binding_level
->parm_order
= NULL_TREE
;
3907 /* Make TYPE a complete type based on INITIAL_VALUE.
3908 Return 0 if successful, 1 if INITIAL_VALUE can't be deciphered,
3909 2 if there was no information (in which case assume 1 if DO_DEFAULT). */
3912 complete_array_type (type
, initial_value
, do_default
)
3917 register tree maxindex
= NULL_TREE
;
3922 /* Note MAXINDEX is really the maximum index,
3923 one less than the size. */
3924 if (TREE_CODE (initial_value
) == STRING_CST
)
3927 = int_size_in_bytes (TREE_TYPE (TREE_TYPE (initial_value
)));
3928 maxindex
= build_int_2 ((TREE_STRING_LENGTH (initial_value
)
3931 else if (TREE_CODE (initial_value
) == CONSTRUCTOR
)
3933 tree elts
= CONSTRUCTOR_ELTS (initial_value
);
3934 maxindex
= size_binop (MINUS_EXPR
, integer_zero_node
, size_one_node
);
3935 for (; elts
; elts
= TREE_CHAIN (elts
))
3937 if (TREE_PURPOSE (elts
))
3938 maxindex
= TREE_PURPOSE (elts
);
3940 maxindex
= size_binop (PLUS_EXPR
, maxindex
, size_one_node
);
3942 maxindex
= copy_node (maxindex
);
3946 /* Make an error message unless that happened already. */
3947 if (initial_value
!= error_mark_node
)
3950 /* Prevent further error messages. */
3951 maxindex
= build_int_2 (0, 0);
3958 maxindex
= build_int_2 (0, 0);
3964 TYPE_DOMAIN (type
) = build_index_type (maxindex
);
3965 if (!TREE_TYPE (maxindex
))
3966 TREE_TYPE (maxindex
) = TYPE_DOMAIN (type
);
3967 #if 0 /* I took out this change
3968 together with the change in build_array_type. --rms */
3969 change_main_variant (type
,
3970 build_array_type (TREE_TYPE (type
),
3971 TYPE_DOMAIN (type
)));
3975 /* Lay out the type now that we can get the real answer. */
3982 /* Given declspecs and a declarator,
3983 determine the name and type of the object declared
3984 and construct a ..._DECL node for it.
3985 (In one case we can return a ..._TYPE node instead.
3986 For invalid input we sometimes return 0.)
3988 DECLSPECS is a chain of tree_list nodes whose value fields
3989 are the storage classes and type specifiers.
3991 DECL_CONTEXT says which syntactic context this declaration is in:
3992 NORMAL for most contexts. Make a VAR_DECL or FUNCTION_DECL or TYPE_DECL.
3993 FUNCDEF for a function definition. Like NORMAL but a few different
3994 error messages in each case. Return value may be zero meaning
3995 this definition is too screwy to try to parse.
3996 PARM for a parameter declaration (either within a function prototype
3997 or before a function body). Make a PARM_DECL, or return void_type_node.
3998 TYPENAME if for a typename (in a cast or sizeof).
3999 Don't make a DECL node; just return the ..._TYPE node.
4000 FIELD for a struct or union field; make a FIELD_DECL.
4001 BITFIELD for a field with specified width.
4002 INITIALIZED is 1 if the decl has an initializer.
4004 In the TYPENAME case, DECLARATOR is really an absolute declarator.
4005 It may also be so in the PARM case, for a prototype where the
4006 argument type is specified but not the name.
4008 This function is where the complicated C meanings of `static'
4009 and `extern' are interpreted. */
4012 grokdeclarator (declarator
, declspecs
, decl_context
, initialized
)
4015 enum decl_context decl_context
;
4020 tree type
= NULL_TREE
;
4025 int explicit_int
= 0;
4026 int explicit_char
= 0;
4027 int defaulted_int
= 0;
4028 tree typedef_decl
= 0;
4030 tree typedef_type
= 0;
4031 int funcdef_flag
= 0;
4032 enum tree_code innermost_code
= ERROR_MARK
;
4034 int size_varies
= 0;
4035 tree decl_machine_attr
= NULL_TREE
;
4037 if (decl_context
== BITFIELD
)
4038 bitfield
= 1, decl_context
= FIELD
;
4040 if (decl_context
== FUNCDEF
)
4041 funcdef_flag
= 1, decl_context
= NORMAL
;
4043 push_obstacks_nochange ();
4045 if (flag_traditional
&& allocation_temporary_p ())
4046 end_temporary_allocation ();
4048 /* Look inside a declarator for the name being declared
4049 and get it as a string, for an error message. */
4051 register tree decl
= declarator
;
4055 switch (TREE_CODE (decl
))
4060 innermost_code
= TREE_CODE (decl
);
4061 decl
= TREE_OPERAND (decl
, 0);
4064 case IDENTIFIER_NODE
:
4065 name
= IDENTIFIER_POINTER (decl
);
4076 /* A function definition's declarator must have the form of
4077 a function declarator. */
4079 if (funcdef_flag
&& innermost_code
!= CALL_EXPR
)
4082 /* Anything declared one level down from the top level
4083 must be one of the parameters of a function
4084 (because the body is at least two levels down). */
4086 /* If this looks like a function definition, make it one,
4087 even if it occurs where parms are expected.
4088 Then store_parm_decls will reject it and not use it as a parm. */
4089 if (decl_context
== NORMAL
&& !funcdef_flag
4090 && current_binding_level
->level_chain
== global_binding_level
)
4091 decl_context
= PARM
;
4093 /* Look through the decl specs and record which ones appear.
4094 Some typespecs are defined as built-in typenames.
4095 Others, the ones that are modifiers of other types,
4096 are represented by bits in SPECBITS: set the bits for
4097 the modifiers that appear. Storage class keywords are also in SPECBITS.
4099 If there is a typedef name or a type, store the type in TYPE.
4100 This includes builtin typedefs such as `int'.
4102 Set EXPLICIT_INT or EXPLICIT_CHAR if the type is `int' or `char'
4103 and did not come from a user typedef.
4105 Set LONGLONG if `long' is mentioned twice. */
4107 for (spec
= declspecs
; spec
; spec
= TREE_CHAIN (spec
))
4110 register tree id
= TREE_VALUE (spec
);
4112 if (id
== ridpointers
[(int) RID_INT
])
4114 if (id
== ridpointers
[(int) RID_CHAR
])
4117 if (TREE_CODE (id
) == IDENTIFIER_NODE
)
4118 for (i
= (int) RID_FIRST_MODIFIER
; i
< (int) RID_MAX
; i
++)
4120 if (ridpointers
[i
] == id
)
4122 if (i
== (int) RID_LONG
&& specbits
& (1<<i
))
4125 error ("`long long long' is too long for GCC");
4128 if (pedantic
&& ! in_system_header
)
4129 pedwarn ("ANSI C does not support `long long'");
4133 else if (specbits
& (1 << i
))
4134 pedwarn ("duplicate `%s'", IDENTIFIER_POINTER (id
));
4140 error ("two or more data types in declaration of `%s'", name
);
4141 /* Actual typedefs come to us as TYPE_DECL nodes. */
4142 else if (TREE_CODE (id
) == TYPE_DECL
)
4144 type
= TREE_TYPE (id
);
4145 decl_machine_attr
= DECL_MACHINE_ATTRIBUTES (id
);
4148 /* Built-in types come as identifiers. */
4149 else if (TREE_CODE (id
) == IDENTIFIER_NODE
)
4151 register tree t
= lookup_name (id
);
4152 if (TREE_TYPE (t
) == error_mark_node
)
4154 else if (!t
|| TREE_CODE (t
) != TYPE_DECL
)
4155 error ("`%s' fails to be a typedef or built in type",
4156 IDENTIFIER_POINTER (id
));
4159 type
= TREE_TYPE (t
);
4163 else if (TREE_CODE (id
) != ERROR_MARK
)
4169 typedef_type
= type
;
4171 size_varies
= C_TYPE_VARIABLE_SIZE (type
);
4173 /* No type at all: default to `int', and set DEFAULTED_INT
4174 because it was not a user-defined typedef. */
4178 if (funcdef_flag
&& warn_return_type
4179 && ! (specbits
& ((1 << (int) RID_LONG
) | (1 << (int) RID_SHORT
)
4180 | (1 << (int) RID_SIGNED
) | (1 << (int) RID_UNSIGNED
))))
4181 warn_about_return_type
= 1;
4183 type
= integer_type_node
;
4186 /* Now process the modifiers that were specified
4187 and check for invalid combinations. */
4189 /* Long double is a special combination. */
4191 if ((specbits
& 1 << (int) RID_LONG
)
4192 && TYPE_MAIN_VARIANT (type
) == double_type_node
)
4194 specbits
&= ~ (1 << (int) RID_LONG
);
4195 type
= long_double_type_node
;
4198 /* Check all other uses of type modifiers. */
4200 if (specbits
& ((1 << (int) RID_LONG
) | (1 << (int) RID_SHORT
)
4201 | (1 << (int) RID_UNSIGNED
) | (1 << (int) RID_SIGNED
)))
4205 if (TREE_CODE (type
) != INTEGER_TYPE
)
4206 error ("long, short, signed or unsigned invalid for `%s'", name
);
4207 else if ((specbits
& 1 << (int) RID_LONG
)
4208 && (specbits
& 1 << (int) RID_SHORT
))
4209 error ("long and short specified together for `%s'", name
);
4210 else if (((specbits
& 1 << (int) RID_LONG
)
4211 || (specbits
& 1 << (int) RID_SHORT
))
4213 error ("long or short specified with char for `%s'", name
);
4214 else if (((specbits
& 1 << (int) RID_LONG
)
4215 || (specbits
& 1 << (int) RID_SHORT
))
4216 && TREE_CODE (type
) == REAL_TYPE
)
4217 error ("long or short specified with floating type for `%s'", name
);
4218 else if ((specbits
& 1 << (int) RID_SIGNED
)
4219 && (specbits
& 1 << (int) RID_UNSIGNED
))
4220 error ("signed and unsigned given together for `%s'", name
);
4224 if (!explicit_int
&& !defaulted_int
&& !explicit_char
&& pedantic
)
4226 pedwarn ("long, short, signed or unsigned used invalidly for `%s'",
4228 if (flag_pedantic_errors
)
4233 /* Discard the type modifiers if they are invalid. */
4236 specbits
&= ~((1 << (int) RID_LONG
) | (1 << (int) RID_SHORT
)
4237 | (1 << (int) RID_UNSIGNED
) | (1 << (int) RID_SIGNED
));
4242 if ((specbits
& (1 << (int) RID_COMPLEX
))
4243 && TREE_CODE (type
) != INTEGER_TYPE
&& TREE_CODE (type
) != REAL_TYPE
)
4245 error ("complex invalid for `%s'", name
);
4246 specbits
&= ~ (1 << (int) RID_COMPLEX
);
4249 /* Decide whether an integer type is signed or not.
4250 Optionally treat bitfields as signed by default. */
4251 if (specbits
& 1 << (int) RID_UNSIGNED
4252 /* Traditionally, all bitfields are unsigned. */
4253 || (bitfield
&& flag_traditional
4254 && (! explicit_flag_signed_bitfields
|| !flag_signed_bitfields
))
4255 || (bitfield
&& ! flag_signed_bitfields
4256 && (explicit_int
|| defaulted_int
|| explicit_char
4257 /* A typedef for plain `int' without `signed'
4258 can be controlled just like plain `int'. */
4259 || ! (typedef_decl
!= 0
4260 && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl
)))
4261 && TREE_CODE (type
) != ENUMERAL_TYPE
4262 && !(specbits
& 1 << (int) RID_SIGNED
)))
4265 type
= long_long_unsigned_type_node
;
4266 else if (specbits
& 1 << (int) RID_LONG
)
4267 type
= long_unsigned_type_node
;
4268 else if (specbits
& 1 << (int) RID_SHORT
)
4269 type
= short_unsigned_type_node
;
4270 else if (type
== char_type_node
)
4271 type
= unsigned_char_type_node
;
4272 else if (typedef_decl
)
4273 type
= unsigned_type (type
);
4275 type
= unsigned_type_node
;
4277 else if ((specbits
& 1 << (int) RID_SIGNED
)
4278 && type
== char_type_node
)
4279 type
= signed_char_type_node
;
4281 type
= long_long_integer_type_node
;
4282 else if (specbits
& 1 << (int) RID_LONG
)
4283 type
= long_integer_type_node
;
4284 else if (specbits
& 1 << (int) RID_SHORT
)
4285 type
= short_integer_type_node
;
4287 if (specbits
& 1 << (int) RID_COMPLEX
)
4289 /* If we just have "complex", it is equivalent to
4290 "complex double", but if any modifiers at all are specified it is
4291 the complex form of TYPE. E.g, "complex short" is
4292 "complex short int". */
4294 if (defaulted_int
&& ! longlong
4295 && ! (specbits
& ((1 << (int) RID_LONG
) | (1 << (int) RID_SHORT
)
4296 | (1 << (int) RID_SIGNED
)
4297 | (1 << (int) RID_UNSIGNED
))))
4298 type
= complex_double_type_node
;
4299 else if (type
== integer_type_node
)
4300 type
= complex_integer_type_node
;
4301 else if (type
== float_type_node
)
4302 type
= complex_float_type_node
;
4303 else if (type
== double_type_node
)
4304 type
= complex_double_type_node
;
4305 else if (type
== long_double_type_node
)
4306 type
= complex_long_double_type_node
;
4308 type
= build_complex_type (type
);
4311 /* Set CONSTP if this declaration is `const', whether by
4312 explicit specification or via a typedef.
4313 Likewise for VOLATILEP. */
4315 constp
= !! (specbits
& 1 << (int) RID_CONST
) + TYPE_READONLY (type
);
4316 volatilep
= !! (specbits
& 1 << (int) RID_VOLATILE
) + TYPE_VOLATILE (type
);
4317 inlinep
= !! (specbits
& (1 << (int) RID_INLINE
));
4319 pedwarn ("duplicate `const'");
4321 pedwarn ("duplicate `volatile'");
4322 if (! flag_gen_aux_info
&& (TYPE_READONLY (type
) || TYPE_VOLATILE (type
)))
4323 type
= TYPE_MAIN_VARIANT (type
);
4325 /* Warn if two storage classes are given. Default to `auto'. */
4330 if (specbits
& 1 << (int) RID_AUTO
) nclasses
++;
4331 if (specbits
& 1 << (int) RID_STATIC
) nclasses
++;
4332 if (specbits
& 1 << (int) RID_EXTERN
) nclasses
++;
4333 if (specbits
& 1 << (int) RID_REGISTER
) nclasses
++;
4334 if (specbits
& 1 << (int) RID_TYPEDEF
) nclasses
++;
4335 if (specbits
& 1 << (int) RID_ITERATOR
) nclasses
++;
4337 /* Warn about storage classes that are invalid for certain
4338 kinds of declarations (parameters, typenames, etc.). */
4341 error ("multiple storage classes in declaration of `%s'", name
);
4342 else if (funcdef_flag
4344 & ((1 << (int) RID_REGISTER
)
4345 | (1 << (int) RID_AUTO
)
4346 | (1 << (int) RID_TYPEDEF
))))
4348 if (specbits
& 1 << (int) RID_AUTO
4349 && (pedantic
|| current_binding_level
== global_binding_level
))
4350 pedwarn ("function definition declared `auto'");
4351 if (specbits
& 1 << (int) RID_REGISTER
)
4352 error ("function definition declared `register'");
4353 if (specbits
& 1 << (int) RID_TYPEDEF
)
4354 error ("function definition declared `typedef'");
4355 specbits
&= ~ ((1 << (int) RID_TYPEDEF
) | (1 << (int) RID_REGISTER
)
4356 | (1 << (int) RID_AUTO
));
4358 else if (decl_context
!= NORMAL
&& nclasses
> 0)
4360 if (decl_context
== PARM
&& specbits
& 1 << (int) RID_REGISTER
)
4364 error ((decl_context
== FIELD
4365 ? "storage class specified for structure field `%s'"
4366 : (decl_context
== PARM
4367 ? "storage class specified for parameter `%s'"
4368 : "storage class specified for typename")),
4370 specbits
&= ~ ((1 << (int) RID_TYPEDEF
) | (1 << (int) RID_REGISTER
)
4371 | (1 << (int) RID_AUTO
) | (1 << (int) RID_STATIC
)
4372 | (1 << (int) RID_EXTERN
));
4375 else if (specbits
& 1 << (int) RID_EXTERN
&& initialized
&& ! funcdef_flag
)
4377 /* `extern' with initialization is invalid if not at top level. */
4378 if (current_binding_level
== global_binding_level
)
4379 warning ("`%s' initialized and declared `extern'", name
);
4381 error ("`%s' has both `extern' and initializer", name
);
4383 else if (specbits
& 1 << (int) RID_EXTERN
&& funcdef_flag
4384 && current_binding_level
!= global_binding_level
)
4385 error ("nested function `%s' declared `extern'", name
);
4386 else if (current_binding_level
== global_binding_level
4387 && specbits
& (1 << (int) RID_AUTO
))
4388 error ("top-level declaration of `%s' specifies `auto'", name
);
4389 else if ((specbits
& 1 << (int) RID_ITERATOR
)
4390 && TREE_CODE (declarator
) != IDENTIFIER_NODE
)
4392 error ("iterator `%s' has derived type", name
);
4393 type
= error_mark_node
;
4395 else if ((specbits
& 1 << (int) RID_ITERATOR
)
4396 && TREE_CODE (type
) != INTEGER_TYPE
)
4398 error ("iterator `%s' has noninteger type", name
);
4399 type
= error_mark_node
;
4403 /* Now figure out the structure of the declarator proper.
4404 Descend through it, creating more complex types, until we reach
4405 the declared identifier (or NULL_TREE, in an absolute declarator). */
4407 while (declarator
&& TREE_CODE (declarator
) != IDENTIFIER_NODE
)
4409 if (type
== error_mark_node
)
4411 declarator
= TREE_OPERAND (declarator
, 0);
4415 /* Each level of DECLARATOR is either an ARRAY_REF (for ...[..]),
4416 an INDIRECT_REF (for *...),
4417 a CALL_EXPR (for ...(...)),
4418 an identifier (for the name being declared)
4419 or a null pointer (for the place in an absolute declarator
4420 where the name was omitted).
4421 For the last two cases, we have just exited the loop.
4423 At this point, TYPE is the type of elements of an array,
4424 or for a function to return, or for a pointer to point to.
4425 After this sequence of ifs, TYPE is the type of the
4426 array or function or pointer, and DECLARATOR has had its
4427 outermost layer removed. */
4429 if (TREE_CODE (declarator
) == ARRAY_REF
)
4431 register tree itype
= NULL_TREE
;
4432 register tree size
= TREE_OPERAND (declarator
, 1);
4433 /* An uninitialized decl with `extern' is a reference. */
4434 int extern_ref
= !initialized
&& (specbits
& (1 << (int) RID_EXTERN
));
4435 /* The index is a signed object `sizetype' bits wide. */
4436 tree index_type
= signed_type (sizetype
);
4438 declarator
= TREE_OPERAND (declarator
, 0);
4440 /* Check for some types that there cannot be arrays of. */
4442 if (TYPE_MAIN_VARIANT (type
) == void_type_node
)
4444 error ("declaration of `%s' as array of voids", name
);
4445 type
= error_mark_node
;
4448 if (TREE_CODE (type
) == FUNCTION_TYPE
)
4450 error ("declaration of `%s' as array of functions", name
);
4451 type
= error_mark_node
;
4454 if (size
== error_mark_node
)
4455 type
= error_mark_node
;
4457 if (type
== error_mark_node
)
4460 /* If this is a block level extern, it must live past the end
4461 of the function so that we can check it against other extern
4462 declarations (IDENTIFIER_LIMBO_VALUE). */
4463 if (extern_ref
&& allocation_temporary_p ())
4464 end_temporary_allocation ();
4466 /* If size was specified, set ITYPE to a range-type for that size.
4467 Otherwise, ITYPE remains null. finish_decl may figure it out
4468 from an initial value. */
4472 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue. */
4473 STRIP_TYPE_NOPS (size
);
4475 if (TREE_CODE (TREE_TYPE (size
)) != INTEGER_TYPE
4476 && TREE_CODE (TREE_TYPE (size
)) != ENUMERAL_TYPE
)
4478 error ("size of array `%s' has non-integer type", name
);
4479 size
= integer_one_node
;
4482 if (pedantic
&& integer_zerop (size
))
4483 pedwarn ("ANSI C forbids zero-size array `%s'", name
);
4485 if (TREE_CODE (size
) == INTEGER_CST
)
4487 constant_expression_warning (size
);
4488 if (tree_int_cst_sgn (size
) < 0)
4490 error ("size of array `%s' is negative", name
);
4491 size
= integer_one_node
;
4496 /* Make sure the array size remains visibly nonconstant
4497 even if it is (eg) a const variable with known value. */
4502 if (TREE_CONSTANT (size
))
4503 pedwarn ("ANSI C forbids array `%s' whose size can't be evaluated", name
);
4505 pedwarn ("ANSI C forbids variable-size array `%s'", name
);
4509 /* Convert size to index_type, so that if it is a variable
4510 the computations will be done in the proper mode. */
4511 itype
= fold (build (MINUS_EXPR
, index_type
,
4512 convert (index_type
, size
),
4513 convert (index_type
, size_one_node
)));
4516 itype
= variable_size (itype
);
4517 itype
= build_index_type (itype
);
4520 #if 0 /* This had bad results for pointers to arrays, as in
4521 union incomplete (*foo)[4]; */
4522 /* Complain about arrays of incomplete types, except in typedefs. */
4524 if (TYPE_SIZE (type
) == 0
4525 /* Avoid multiple warnings for nested array types. */
4526 && TREE_CODE (type
) != ARRAY_TYPE
4527 && !(specbits
& (1 << (int) RID_TYPEDEF
))
4528 && !C_TYPE_BEING_DEFINED (type
))
4529 warning ("array type has incomplete element type");
4532 #if 0 /* We shouldn't have a function type here at all!
4533 Functions aren't allowed as array elements. */
4534 if (pedantic
&& TREE_CODE (type
) == FUNCTION_TYPE
4535 && (constp
|| volatilep
))
4536 pedwarn ("ANSI C forbids const or volatile function types");
4539 /* Build the array type itself, then merge any constancy or
4540 volatility into the target type. We must do it in this order
4541 to ensure that the TYPE_MAIN_VARIANT field of the array type
4542 is set correctly. */
4544 type
= build_array_type (type
, itype
);
4545 if (constp
|| volatilep
)
4546 type
= c_build_type_variant (type
, constp
, volatilep
);
4548 #if 0 /* don't clear these; leave them set so that the array type
4549 or the variable is itself const or volatile. */
4555 C_TYPE_VARIABLE_SIZE (type
) = 1;
4557 else if (TREE_CODE (declarator
) == CALL_EXPR
)
4559 int extern_ref
= (!(specbits
& (1 << (int) RID_AUTO
))
4560 || current_binding_level
== global_binding_level
);
4563 /* Declaring a function type.
4564 Make sure we have a valid type for the function to return. */
4565 if (type
== error_mark_node
)
4570 /* Warn about some types functions can't return. */
4572 if (TREE_CODE (type
) == FUNCTION_TYPE
)
4574 error ("`%s' declared as function returning a function", name
);
4575 type
= integer_type_node
;
4577 if (TREE_CODE (type
) == ARRAY_TYPE
)
4579 error ("`%s' declared as function returning an array", name
);
4580 type
= integer_type_node
;
4583 #ifndef TRADITIONAL_RETURN_FLOAT
4584 /* Traditionally, declaring return type float means double. */
4586 if (flag_traditional
&& TYPE_MAIN_VARIANT (type
) == float_type_node
)
4587 type
= double_type_node
;
4588 #endif /* TRADITIONAL_RETURN_FLOAT */
4590 /* If this is a block level extern, it must live past the end
4591 of the function so that we can check it against other extern
4592 declarations (IDENTIFIER_LIMBO_VALUE). */
4593 if (extern_ref
&& allocation_temporary_p ())
4594 end_temporary_allocation ();
4596 /* Construct the function type and go to the next
4597 inner layer of declarator. */
4599 arg_types
= grokparms (TREE_OPERAND (declarator
, 1),
4601 /* Say it's a definition
4602 only for the CALL_EXPR
4603 closest to the identifier. */
4604 && TREE_CODE (TREE_OPERAND (declarator
, 0)) == IDENTIFIER_NODE
);
4605 #if 0 /* This seems to be false. We turn off temporary allocation
4606 above in this function if -traditional.
4607 And this code caused inconsistent results with prototypes:
4608 callers would ignore them, and pass arguments wrong. */
4610 /* Omit the arg types if -traditional, since the arg types
4611 and the list links might not be permanent. */
4612 type
= build_function_type (type
,
4614 ? NULL_TREE
: arg_types
);
4616 /* ANSI seems to say that `const int foo ();'
4617 does not make the function foo const. */
4618 if (constp
|| volatilep
)
4619 type
= c_build_type_variant (type
, constp
, volatilep
);
4623 type
= build_function_type (type
, arg_types
);
4624 declarator
= TREE_OPERAND (declarator
, 0);
4626 /* Set the TYPE_CONTEXTs for each tagged type which is local to
4627 the formal parameter list of this FUNCTION_TYPE to point to
4628 the FUNCTION_TYPE node itself. */
4633 for (link
= current_function_parm_tags
;
4635 link
= TREE_CHAIN (link
))
4636 TYPE_CONTEXT (TREE_VALUE (link
)) = type
;
4639 else if (TREE_CODE (declarator
) == INDIRECT_REF
)
4641 /* Merge any constancy or volatility into the target type
4644 if (pedantic
&& TREE_CODE (type
) == FUNCTION_TYPE
4645 && (constp
|| volatilep
))
4646 pedwarn ("ANSI C forbids const or volatile function types");
4647 if (constp
|| volatilep
)
4648 type
= c_build_type_variant (type
, constp
, volatilep
);
4653 type
= build_pointer_type (type
);
4655 /* Process a list of type modifier keywords
4656 (such as const or volatile) that were given inside the `*'. */
4658 if (TREE_TYPE (declarator
))
4660 register tree typemodlist
;
4662 for (typemodlist
= TREE_TYPE (declarator
); typemodlist
;
4663 typemodlist
= TREE_CHAIN (typemodlist
))
4665 if (TREE_VALUE (typemodlist
) == ridpointers
[(int) RID_CONST
])
4667 else if (TREE_VALUE (typemodlist
) == ridpointers
[(int) RID_VOLATILE
])
4672 error ("invalid type modifier within pointer declarator");
4676 pedwarn ("duplicate `const'");
4678 pedwarn ("duplicate `volatile'");
4681 declarator
= TREE_OPERAND (declarator
, 0);
4688 /* Now TYPE has the actual type. */
4690 /* If this is declaring a typedef name, return a TYPE_DECL. */
4692 if (specbits
& (1 << (int) RID_TYPEDEF
))
4695 /* Note that the grammar rejects storage classes
4696 in typenames, fields or parameters */
4697 if (pedantic
&& TREE_CODE (type
) == FUNCTION_TYPE
4698 && (constp
|| volatilep
))
4699 pedwarn ("ANSI C forbids const or volatile function types");
4700 if (constp
|| volatilep
)
4701 type
= c_build_type_variant (type
, constp
, volatilep
);
4703 decl
= build_decl (TYPE_DECL
, declarator
, type
);
4704 if ((specbits
& (1 << (int) RID_SIGNED
))
4705 || (typedef_decl
&& C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl
)))
4706 C_TYPEDEF_EXPLICITLY_SIGNED (decl
) = 1;
4710 /* Detect the case of an array type of unspecified size
4711 which came, as such, direct from a typedef name.
4712 We must copy the type, so that each identifier gets
4713 a distinct type, so that each identifier's size can be
4714 controlled separately by its own initializer. */
4716 if (type
!= 0 && typedef_type
!= 0
4717 && TYPE_MAIN_VARIANT (type
) == TYPE_MAIN_VARIANT (typedef_type
)
4718 && TREE_CODE (type
) == ARRAY_TYPE
&& TYPE_DOMAIN (type
) == 0)
4720 type
= build_array_type (TREE_TYPE (type
), 0);
4722 C_TYPE_VARIABLE_SIZE (type
) = 1;
4725 /* If this is a type name (such as, in a cast or sizeof),
4726 compute the type and return it now. */
4728 if (decl_context
== TYPENAME
)
4730 /* Note that the grammar rejects storage classes
4731 in typenames, fields or parameters */
4732 if (pedantic
&& TREE_CODE (type
) == FUNCTION_TYPE
4733 && (constp
|| volatilep
))
4734 pedwarn ("ANSI C forbids const or volatile function types");
4735 if (constp
|| volatilep
)
4736 type
= c_build_type_variant (type
, constp
, volatilep
);
4741 /* Aside from typedefs and type names (handle above),
4742 `void' at top level (not within pointer)
4743 is allowed only in public variables.
4744 We don't complain about parms either, but that is because
4745 a better error message can be made later. */
4747 if (TYPE_MAIN_VARIANT (type
) == void_type_node
&& decl_context
!= PARM
4748 && ! ((decl_context
!= FIELD
&& TREE_CODE (type
) != FUNCTION_TYPE
)
4749 && ((specbits
& (1 << (int) RID_EXTERN
))
4750 || (current_binding_level
== global_binding_level
4752 & ((1 << (int) RID_STATIC
) | (1 << (int) RID_REGISTER
)))))))
4754 error ("variable or field `%s' declared void", name
);
4755 type
= integer_type_node
;
4758 /* Now create the decl, which may be a VAR_DECL, a PARM_DECL
4759 or a FUNCTION_DECL, depending on DECL_CONTEXT and TYPE. */
4764 if (decl_context
== PARM
)
4766 tree type_as_written
= type
;
4769 /* A parameter declared as an array of T is really a pointer to T.
4770 One declared as a function is really a pointer to a function. */
4772 if (TREE_CODE (type
) == ARRAY_TYPE
)
4774 /* Transfer const-ness of array into that of type pointed to. */
4775 type
= TREE_TYPE (type
);
4776 if (constp
|| volatilep
)
4777 type
= c_build_type_variant (type
, constp
, volatilep
);
4778 type
= build_pointer_type (type
);
4779 volatilep
= constp
= 0;
4782 else if (TREE_CODE (type
) == FUNCTION_TYPE
)
4784 if (pedantic
&& (constp
|| volatilep
))
4785 pedwarn ("ANSI C forbids const or volatile function types");
4786 if (constp
|| volatilep
)
4787 type
= c_build_type_variant (type
, constp
, volatilep
);
4788 type
= build_pointer_type (type
);
4789 volatilep
= constp
= 0;
4792 decl
= build_decl (PARM_DECL
, declarator
, type
);
4794 C_DECL_VARIABLE_SIZE (decl
) = 1;
4796 /* Compute the type actually passed in the parmlist,
4797 for the case where there is no prototype.
4798 (For example, shorts and chars are passed as ints.)
4799 When there is a prototype, this is overridden later. */
4801 DECL_ARG_TYPE (decl
) = type
;
4802 main_type
= (type
== error_mark_node
4804 : TYPE_MAIN_VARIANT (type
));
4805 if (main_type
== float_type_node
)
4806 DECL_ARG_TYPE (decl
) = double_type_node
;
4807 /* Don't use TYPE_PRECISION to decide whether to promote,
4808 because we should convert short if it's the same size as int,
4809 but we should not convert long if it's the same size as int. */
4810 else if (TREE_CODE (main_type
) != ERROR_MARK
4811 && C_PROMOTING_INTEGER_TYPE_P (main_type
))
4813 if (TYPE_PRECISION (type
) == TYPE_PRECISION (integer_type_node
)
4814 && TREE_UNSIGNED (type
))
4815 DECL_ARG_TYPE (decl
) = unsigned_type_node
;
4817 DECL_ARG_TYPE (decl
) = integer_type_node
;
4820 DECL_ARG_TYPE_AS_WRITTEN (decl
) = type_as_written
;
4822 else if (decl_context
== FIELD
)
4824 /* Structure field. It may not be a function. */
4826 if (TREE_CODE (type
) == FUNCTION_TYPE
)
4828 error ("field `%s' declared as a function", name
);
4829 type
= build_pointer_type (type
);
4831 else if (TREE_CODE (type
) != ERROR_MARK
&& TYPE_SIZE (type
) == 0)
4833 error ("field `%s' has incomplete type", name
);
4834 type
= error_mark_node
;
4836 /* Move type qualifiers down to element of an array. */
4837 if (TREE_CODE (type
) == ARRAY_TYPE
&& (constp
|| volatilep
))
4839 type
= build_array_type (c_build_type_variant (TREE_TYPE (type
),
4841 TYPE_DOMAIN (type
));
4842 #if 0 /* Leave the field const or volatile as well. */
4843 constp
= volatilep
= 0;
4846 decl
= build_decl (FIELD_DECL
, declarator
, type
);
4848 C_DECL_VARIABLE_SIZE (decl
) = 1;
4850 else if (TREE_CODE (type
) == FUNCTION_TYPE
)
4852 /* Every function declaration is "external"
4853 except for those which are inside a function body
4854 in which `auto' is used.
4855 That is a case not specified by ANSI C,
4856 and we use it for forward declarations for nested functions. */
4857 int extern_ref
= (!(specbits
& (1 << (int) RID_AUTO
))
4858 || current_binding_level
== global_binding_level
);
4860 if (specbits
& (1 << (int) RID_AUTO
)
4861 && (pedantic
|| current_binding_level
== global_binding_level
))
4862 pedwarn ("invalid storage class for function `%s'", name
);
4863 if (specbits
& (1 << (int) RID_REGISTER
))
4864 error ("invalid storage class for function `%s'", name
);
4865 /* Function declaration not at top level.
4866 Storage classes other than `extern' are not allowed
4867 and `extern' makes no difference. */
4868 if (current_binding_level
!= global_binding_level
4869 && (specbits
& ((1 << (int) RID_STATIC
) | (1 << (int) RID_INLINE
)))
4871 pedwarn ("invalid storage class for function `%s'", name
);
4873 /* If this is a block level extern, it must live past the end
4874 of the function so that we can check it against other
4875 extern declarations (IDENTIFIER_LIMBO_VALUE). */
4876 if (extern_ref
&& allocation_temporary_p ())
4877 end_temporary_allocation ();
4879 decl
= build_decl (FUNCTION_DECL
, declarator
, type
);
4880 decl
= build_decl_attribute_variant (decl
, decl_machine_attr
);
4882 if (pedantic
&& (constp
|| volatilep
)
4883 && ! DECL_IN_SYSTEM_HEADER (decl
))
4884 pedwarn ("ANSI C forbids const or volatile functions");
4887 && TREE_TYPE (TREE_TYPE (decl
)) != void_type_node
)
4888 warning ("`noreturn' function returns non-void value");
4891 DECL_EXTERNAL (decl
) = 1;
4892 /* Record absence of global scope for `static' or `auto'. */
4894 = !(specbits
& ((1 << (int) RID_STATIC
) | (1 << (int) RID_AUTO
)));
4896 /* Record presence of `inline', if it is reasonable. */
4899 tree last
= tree_last (TYPE_ARG_TYPES (type
));
4901 if (! strcmp (IDENTIFIER_POINTER (declarator
), "main"))
4902 warning ("cannot inline function `main'");
4903 else if (last
&& (TYPE_MAIN_VARIANT (TREE_VALUE (last
))
4905 warning ("inline declaration ignored for function with `...'");
4907 /* Assume that otherwise the function can be inlined. */
4908 DECL_INLINE (decl
) = 1;
4910 if (specbits
& (1 << (int) RID_EXTERN
))
4911 current_extern_inline
= 1;
4916 /* It's a variable. */
4917 /* An uninitialized decl with `extern' is a reference. */
4918 int extern_ref
= !initialized
&& (specbits
& (1 << (int) RID_EXTERN
));
4920 /* Move type qualifiers down to element of an array. */
4921 if (TREE_CODE (type
) == ARRAY_TYPE
&& (constp
|| volatilep
))
4923 type
= build_array_type (c_build_type_variant (TREE_TYPE (type
),
4925 TYPE_DOMAIN (type
));
4926 #if 0 /* Leave the variable const or volatile as well. */
4927 constp
= volatilep
= 0;
4931 /* If this is a block level extern, it must live past the end
4932 of the function so that we can check it against other
4933 extern declarations (IDENTIFIER_LIMBO_VALUE). */
4934 if (extern_ref
&& allocation_temporary_p ())
4935 end_temporary_allocation ();
4937 decl
= build_decl (VAR_DECL
, declarator
, type
);
4939 C_DECL_VARIABLE_SIZE (decl
) = 1;
4942 pedwarn_with_decl (decl
, "variable `%s' declared `inline'");
4944 DECL_EXTERNAL (decl
) = extern_ref
;
4945 /* At top level, the presence of a `static' or `register' storage
4946 class specifier, or the absence of all storage class specifiers
4947 makes this declaration a definition (perhaps tentative). Also,
4948 the absence of both `static' and `register' makes it public. */
4949 if (current_binding_level
== global_binding_level
)
4953 & ((1 << (int) RID_STATIC
) | (1 << (int) RID_REGISTER
)));
4954 TREE_STATIC (decl
) = ! DECL_EXTERNAL (decl
);
4956 /* Not at top level, only `static' makes a static definition. */
4959 TREE_STATIC (decl
) = (specbits
& (1 << (int) RID_STATIC
)) != 0;
4960 TREE_PUBLIC (decl
) = DECL_EXTERNAL (decl
);
4963 if (specbits
& 1 << (int) RID_ITERATOR
)
4964 ITERATOR_P (decl
) = 1;
4967 /* Record `register' declaration for warnings on &
4968 and in case doing stupid register allocation. */
4970 if (specbits
& (1 << (int) RID_REGISTER
))
4971 DECL_REGISTER (decl
) = 1;
4973 /* Record constancy and volatility. */
4976 TREE_READONLY (decl
) = 1;
4979 TREE_SIDE_EFFECTS (decl
) = 1;
4980 TREE_THIS_VOLATILE (decl
) = 1;
4982 /* If a type has volatile components, it should be stored in memory.
4983 Otherwise, the fact that those components are volatile
4984 will be ignored, and would even crash the compiler. */
4985 if (C_TYPE_FIELDS_VOLATILE (TREE_TYPE (decl
)))
4986 mark_addressable (decl
);
4994 /* Decode the parameter-list info for a function type or function definition.
4995 The argument is the value returned by `get_parm_info' (or made in parse.y
4996 if there is an identifier list instead of a parameter decl list).
4997 These two functions are separate because when a function returns
4998 or receives functions then each is called multiple times but the order
4999 of calls is different. The last call to `grokparms' is always the one
5000 that contains the formal parameter names of a function definition.
5002 Store in `last_function_parms' a chain of the decls of parms.
5003 Also store in `last_function_parm_tags' a chain of the struct, union,
5004 and enum tags declared among the parms.
5006 Return a list of arg types to use in the FUNCTION_TYPE for this function.
5008 FUNCDEF_FLAG is nonzero for a function definition, 0 for
5009 a mere declaration. A nonempty identifier-list gets an error message
5010 when FUNCDEF_FLAG is zero. */
5013 grokparms (parms_info
, funcdef_flag
)
5017 tree first_parm
= TREE_CHAIN (parms_info
);
5019 last_function_parms
= TREE_PURPOSE (parms_info
);
5020 last_function_parm_tags
= TREE_VALUE (parms_info
);
5022 if (warn_strict_prototypes
&& first_parm
== 0 && !funcdef_flag
5023 && !in_system_header
)
5024 warning ("function declaration isn't a prototype");
5027 && TREE_CODE (TREE_VALUE (first_parm
)) == IDENTIFIER_NODE
)
5030 pedwarn ("parameter names (without types) in function declaration");
5032 last_function_parms
= first_parm
;
5039 /* We no longer test FUNCDEF_FLAG.
5040 If the arg types are incomplete in a declaration,
5041 they must include undefined tags.
5042 These tags can never be defined in the scope of the declaration,
5043 so the types can never be completed,
5044 and no call can be compiled successfully. */
5046 /* In a fcn definition, arg types must be complete. */
5049 for (parm
= last_function_parms
, typelt
= first_parm
;
5051 parm
= TREE_CHAIN (parm
))
5052 /* Skip over any enumeration constants declared here. */
5053 if (TREE_CODE (parm
) == PARM_DECL
)
5055 /* Barf if the parameter itself has an incomplete type. */
5056 tree type
= TREE_VALUE (typelt
);
5057 if (TYPE_SIZE (type
) == 0)
5059 if (funcdef_flag
&& DECL_NAME (parm
) != 0)
5060 error ("parameter `%s' has incomplete type",
5061 IDENTIFIER_POINTER (DECL_NAME (parm
)));
5063 warning ("parameter has incomplete type");
5066 TREE_VALUE (typelt
) = error_mark_node
;
5067 TREE_TYPE (parm
) = error_mark_node
;
5070 #if 0 /* This has been replaced by parm_tags_warning
5071 which uses a more accurate criterion for what to warn about. */
5074 /* Now warn if is a pointer to an incomplete type. */
5075 while (TREE_CODE (type
) == POINTER_TYPE
5076 || TREE_CODE (type
) == REFERENCE_TYPE
)
5077 type
= TREE_TYPE (type
);
5078 type
= TYPE_MAIN_VARIANT (type
);
5079 if (TYPE_SIZE (type
) == 0)
5081 if (DECL_NAME (parm
) != 0)
5082 warning ("parameter `%s' points to incomplete type",
5083 IDENTIFIER_POINTER (DECL_NAME (parm
)));
5085 warning ("parameter points to incomplete type");
5089 typelt
= TREE_CHAIN (typelt
);
5092 /* Allocate the list of types the way we allocate a type. */
5093 if (first_parm
&& ! TREE_PERMANENT (first_parm
))
5095 /* Construct a copy of the list of types
5096 on the saveable obstack. */
5098 for (typelt
= first_parm
; typelt
; typelt
= TREE_CHAIN (typelt
))
5099 result
= saveable_tree_cons (NULL_TREE
, TREE_VALUE (typelt
),
5101 return nreverse (result
);
5104 /* The list we have is permanent already. */
5110 /* Return a tree_list node with info on a parameter list just parsed.
5111 The TREE_PURPOSE is a chain of decls of those parms.
5112 The TREE_VALUE is a list of structure, union and enum tags defined.
5113 The TREE_CHAIN is a list of argument types to go in the FUNCTION_TYPE.
5114 This tree_list node is later fed to `grokparms'.
5116 VOID_AT_END nonzero means append `void' to the end of the type-list.
5117 Zero means the parmlist ended with an ellipsis so don't append `void'. */
5120 get_parm_info (void_at_end
)
5123 register tree decl
, t
;
5124 register tree types
= 0;
5126 tree tags
= gettags ();
5127 tree parms
= getdecls ();
5129 tree order
= current_binding_level
->parm_order
;
5131 /* Just `void' (and no ellipsis) is special. There are really no parms. */
5132 if (void_at_end
&& parms
!= 0
5133 && TREE_CHAIN (parms
) == 0
5134 && TYPE_MAIN_VARIANT (TREE_TYPE (parms
)) == void_type_node
5135 && DECL_NAME (parms
) == 0)
5138 storedecls (NULL_TREE
);
5139 return saveable_tree_cons (NULL_TREE
, NULL_TREE
,
5140 saveable_tree_cons (NULL_TREE
, void_type_node
, NULL_TREE
));
5143 /* Extract enumerator values and other non-parms declared with the parms.
5144 Likewise any forward parm decls that didn't have real parm decls. */
5145 for (decl
= parms
; decl
; )
5147 tree next
= TREE_CHAIN (decl
);
5149 if (TREE_CODE (decl
) != PARM_DECL
)
5151 TREE_CHAIN (decl
) = new_parms
;
5154 else if (TREE_ASM_WRITTEN (decl
))
5156 error_with_decl (decl
, "parameter `%s' has just a forward declaration");
5157 TREE_CHAIN (decl
) = new_parms
;
5163 /* Put the parm decls back in the order they were in in the parm list. */
5164 for (t
= order
; t
; t
= TREE_CHAIN (t
))
5167 TREE_CHAIN (TREE_VALUE (t
)) = TREE_VALUE (TREE_CHAIN (t
));
5169 TREE_CHAIN (TREE_VALUE (t
)) = 0;
5172 new_parms
= chainon (order
? nreverse (TREE_VALUE (order
)) : 0,
5175 /* Store the parmlist in the binding level since the old one
5176 is no longer a valid list. (We have changed the chain pointers.) */
5177 storedecls (new_parms
);
5179 for (decl
= new_parms
; decl
; decl
= TREE_CHAIN (decl
))
5180 /* There may also be declarations for enumerators if an enumeration
5181 type is declared among the parms. Ignore them here. */
5182 if (TREE_CODE (decl
) == PARM_DECL
)
5184 /* Since there is a prototype,
5185 args are passed in their declared types. */
5186 tree type
= TREE_TYPE (decl
);
5187 DECL_ARG_TYPE (decl
) = type
;
5188 #ifdef PROMOTE_PROTOTYPES
5189 if ((TREE_CODE (type
) == INTEGER_TYPE
5190 || TREE_CODE (type
) == ENUMERAL_TYPE
)
5191 && TYPE_PRECISION (type
) < TYPE_PRECISION (integer_type_node
))
5192 DECL_ARG_TYPE (decl
) = integer_type_node
;
5195 types
= saveable_tree_cons (NULL_TREE
, TREE_TYPE (decl
), types
);
5196 if (TYPE_MAIN_VARIANT (TREE_VALUE (types
)) == void_type_node
&& ! erred
5197 && DECL_NAME (decl
) == 0)
5199 error ("`void' in parameter list must be the entire list");
5205 return saveable_tree_cons (new_parms
, tags
,
5206 nreverse (saveable_tree_cons (NULL_TREE
, void_type_node
, types
)));
5208 return saveable_tree_cons (new_parms
, tags
, nreverse (types
));
5211 /* At end of parameter list, warn about any struct, union or enum tags
5212 defined within. Do so because these types cannot ever become complete. */
5215 parmlist_tags_warning ()
5220 for (elt
= current_binding_level
->tags
; elt
; elt
= TREE_CHAIN (elt
))
5222 enum tree_code code
= TREE_CODE (TREE_VALUE (elt
));
5223 /* An anonymous union parm type is meaningful as a GNU extension.
5224 So don't warn for that. */
5225 if (code
== UNION_TYPE
&& !pedantic
)
5227 if (TREE_PURPOSE (elt
) != 0)
5228 warning ("`%s %s' declared inside parameter list",
5229 (code
== RECORD_TYPE
? "struct"
5230 : code
== UNION_TYPE
? "union"
5232 IDENTIFIER_POINTER (TREE_PURPOSE (elt
)));
5234 warning ("anonymous %s declared inside parameter list",
5235 (code
== RECORD_TYPE
? "struct"
5236 : code
== UNION_TYPE
? "union"
5241 warning ("its scope is only this definition or declaration,");
5242 warning ("which is probably not what you want.");
5248 /* Get the struct, enum or union (CODE says which) with tag NAME.
5249 Define the tag as a forward-reference if it is not defined. */
5252 xref_tag (code
, name
)
5253 enum tree_code code
;
5256 int temporary
= allocation_temporary_p ();
5258 /* If a cross reference is requested, look up the type
5259 already defined for this tag and return it. */
5261 register tree ref
= lookup_tag (code
, name
, current_binding_level
, 0);
5262 /* Even if this is the wrong type of tag, return what we found.
5263 There will be an error message anyway, from pending_xref_error.
5264 If we create an empty xref just for an invalid use of the type,
5265 the main result is to create lots of superfluous error messages. */
5269 push_obstacks_nochange ();
5271 if (current_binding_level
== global_binding_level
&& temporary
)
5272 end_temporary_allocation ();
5274 /* If no such tag is yet defined, create a forward-reference node
5275 and record it as the "definition".
5276 When a real declaration of this type is found,
5277 the forward-reference will be altered into a real type. */
5279 ref
= make_node (code
);
5280 if (code
== ENUMERAL_TYPE
)
5282 /* (In ANSI, Enums can be referred to only if already defined.) */
5284 pedwarn ("ANSI C forbids forward references to `enum' types");
5285 /* Give the type a default layout like unsigned int
5286 to avoid crashing if it does not get defined. */
5287 TYPE_MODE (ref
) = TYPE_MODE (unsigned_type_node
);
5288 TYPE_ALIGN (ref
) = TYPE_ALIGN (unsigned_type_node
);
5289 TREE_UNSIGNED (ref
) = 1;
5290 TYPE_PRECISION (ref
) = TYPE_PRECISION (unsigned_type_node
);
5291 TYPE_MIN_VALUE (ref
) = TYPE_MIN_VALUE (unsigned_type_node
);
5292 TYPE_MAX_VALUE (ref
) = TYPE_MAX_VALUE (unsigned_type_node
);
5295 pushtag (name
, ref
);
5302 /* Make sure that the tag NAME is defined *in the current binding level*
5303 at least as a forward reference.
5304 CODE says which kind of tag NAME ought to be.
5306 We also do a push_obstacks_nochange
5307 whose matching pop is in finish_struct. */
5310 start_struct (code
, name
)
5311 enum tree_code code
;
5314 /* If there is already a tag defined at this binding level
5315 (as a forward reference), just return it. */
5317 register tree ref
= 0;
5319 push_obstacks_nochange ();
5320 if (current_binding_level
== global_binding_level
)
5321 end_temporary_allocation ();
5324 ref
= lookup_tag (code
, name
, current_binding_level
, 1);
5325 if (ref
&& TREE_CODE (ref
) == code
)
5327 C_TYPE_BEING_DEFINED (ref
) = 1;
5328 if (TYPE_FIELDS (ref
))
5329 error ((code
== UNION_TYPE
? "redefinition of `union %s'"
5330 : "redefinition of `struct %s'"),
5331 IDENTIFIER_POINTER (name
));
5336 /* Otherwise create a forward-reference just so the tag is in scope. */
5338 ref
= make_node (code
);
5339 pushtag (name
, ref
);
5340 C_TYPE_BEING_DEFINED (ref
) = 1;
5344 /* Process the specs, declarator (NULL if omitted) and width (NULL if omitted)
5345 of a structure component, returning a FIELD_DECL node.
5346 WIDTH is non-NULL for bit fields only, and is an INTEGER_CST node.
5348 This is done during the parsing of the struct declaration.
5349 The FIELD_DECL nodes are chained together and the lot of them
5350 are ultimately passed to `build_struct' to make the RECORD_TYPE node. */
5353 grokfield (filename
, line
, declarator
, declspecs
, width
)
5356 tree declarator
, declspecs
, width
;
5360 /* The corresponding pop_obstacks is in finish_decl. */
5361 push_obstacks_nochange ();
5363 value
= grokdeclarator (declarator
, declspecs
, width
? BITFIELD
: FIELD
, 0);
5365 finish_decl (value
, NULL_TREE
, NULL_TREE
);
5366 DECL_INITIAL (value
) = width
;
5368 maybe_objc_check_decl (value
);
5372 /* Function to help qsort sort FIELD_DECLs by name order. */
5375 field_decl_cmp (x
, y
)
5378 return (long)DECL_NAME (*x
) - (long)DECL_NAME (*y
);
5381 /* Fill in the fields of a RECORD_TYPE or UNION_TYPE node, T.
5382 FIELDLIST is a chain of FIELD_DECL nodes for the fields.
5384 We also do a pop_obstacks to match the push in start_struct. */
5387 finish_struct (t
, fieldlist
)
5388 register tree t
, fieldlist
;
5392 int toplevel
= global_binding_level
== current_binding_level
;
5394 /* If this type was previously laid out as a forward reference,
5395 make sure we lay it out again. */
5399 /* Nameless union parm types are useful as GCC extension. */
5400 if (! (TREE_CODE (t
) == UNION_TYPE
&& TYPE_NAME (t
) == 0) && !pedantic
)
5401 /* Otherwise, warn about any struct or union def. in parmlist. */
5402 if (in_parm_level_p ())
5405 pedwarn ((TREE_CODE (t
) == UNION_TYPE
? "union defined inside parms"
5406 : "structure defined inside parms"));
5407 else if (! flag_traditional
)
5408 warning ((TREE_CODE (t
) == UNION_TYPE
? "union defined inside parms"
5409 : "structure defined inside parms"));
5412 old_momentary
= suspend_momentary ();
5414 if (fieldlist
== 0 && pedantic
)
5415 pedwarn ((TREE_CODE (t
) == UNION_TYPE
? "union has no members"
5416 : "structure has no members"));
5418 /* Install struct as DECL_CONTEXT of each field decl.
5419 Also process specified field sizes.
5420 Set DECL_FIELD_SIZE to the specified size, or 0 if none specified.
5421 The specified size is found in the DECL_INITIAL.
5422 Store 0 there, except for ": 0" fields (so we can find them
5423 and delete them, below). */
5425 for (x
= fieldlist
; x
; x
= TREE_CHAIN (x
))
5427 DECL_CONTEXT (x
) = t
;
5428 DECL_FIELD_SIZE (x
) = 0;
5430 /* If any field is const, the structure type is pseudo-const. */
5431 if (TREE_READONLY (x
))
5432 C_TYPE_FIELDS_READONLY (t
) = 1;
5435 /* A field that is pseudo-const makes the structure likewise. */
5436 tree t1
= TREE_TYPE (x
);
5437 while (TREE_CODE (t1
) == ARRAY_TYPE
)
5438 t1
= TREE_TYPE (t1
);
5439 if ((TREE_CODE (t1
) == RECORD_TYPE
|| TREE_CODE (t1
) == UNION_TYPE
)
5440 && C_TYPE_FIELDS_READONLY (t1
))
5441 C_TYPE_FIELDS_READONLY (t
) = 1;
5444 /* Any field that is volatile means variables of this type must be
5445 treated in some ways as volatile. */
5446 if (TREE_THIS_VOLATILE (x
))
5447 C_TYPE_FIELDS_VOLATILE (t
) = 1;
5449 /* Any field of nominal variable size implies structure is too. */
5450 if (C_DECL_VARIABLE_SIZE (x
))
5451 C_TYPE_VARIABLE_SIZE (t
) = 1;
5453 /* Detect invalid nested redefinition. */
5454 if (TREE_TYPE (x
) == t
)
5455 error ("nested redefinition of `%s'",
5456 IDENTIFIER_POINTER (TYPE_NAME (t
)));
5458 /* Detect invalid bit-field size. */
5459 if (DECL_INITIAL (x
))
5460 STRIP_NOPS (DECL_INITIAL (x
));
5461 if (DECL_INITIAL (x
))
5463 if (TREE_CODE (DECL_INITIAL (x
)) == INTEGER_CST
)
5464 constant_expression_warning (DECL_INITIAL (x
));
5467 error_with_decl (x
, "bit-field `%s' width not an integer constant");
5468 DECL_INITIAL (x
) = NULL
;
5472 /* Detect invalid bit-field type. */
5473 if (DECL_INITIAL (x
)
5474 && TREE_CODE (TREE_TYPE (x
)) != INTEGER_TYPE
5475 && TREE_CODE (TREE_TYPE (x
)) != ENUMERAL_TYPE
)
5477 error_with_decl (x
, "bit-field `%s' has invalid type");
5478 DECL_INITIAL (x
) = NULL
;
5480 if (DECL_INITIAL (x
) && pedantic
5481 && TYPE_MAIN_VARIANT (TREE_TYPE (x
)) != integer_type_node
5482 && TYPE_MAIN_VARIANT (TREE_TYPE (x
)) != unsigned_type_node
5483 /* Accept an enum that's equivalent to int or unsigned int. */
5484 && !(TREE_CODE (TREE_TYPE (x
)) == ENUMERAL_TYPE
5485 && (TYPE_PRECISION (TREE_TYPE (x
))
5486 == TYPE_PRECISION (integer_type_node
))))
5487 pedwarn_with_decl (x
, "bit-field `%s' type invalid in ANSI C");
5489 /* Detect and ignore out of range field width. */
5490 if (DECL_INITIAL (x
))
5492 unsigned HOST_WIDE_INT width
= TREE_INT_CST_LOW (DECL_INITIAL (x
));
5494 if (tree_int_cst_sgn (DECL_INITIAL (x
)) < 0)
5496 DECL_INITIAL (x
) = NULL
;
5497 error_with_decl (x
, "negative width in bit-field `%s'");
5499 else if (TREE_INT_CST_HIGH (DECL_INITIAL (x
)) != 0
5500 || width
> TYPE_PRECISION (TREE_TYPE (x
)))
5502 DECL_INITIAL (x
) = NULL
;
5503 pedwarn_with_decl (x
, "width of `%s' exceeds its type");
5505 else if (width
== 0 && DECL_NAME (x
) != 0)
5507 error_with_decl (x
, "zero width for bit-field `%s'");
5508 DECL_INITIAL (x
) = NULL
;
5512 /* Process valid field width. */
5513 if (DECL_INITIAL (x
))
5515 register int width
= TREE_INT_CST_LOW (DECL_INITIAL (x
));
5517 DECL_FIELD_SIZE (x
) = width
;
5518 DECL_BIT_FIELD (x
) = 1;
5519 DECL_INITIAL (x
) = NULL
;
5523 /* field size 0 => force desired amount of alignment. */
5524 #ifdef EMPTY_FIELD_BOUNDARY
5525 DECL_ALIGN (x
) = MAX (DECL_ALIGN (x
), EMPTY_FIELD_BOUNDARY
);
5527 #ifdef PCC_BITFIELD_TYPE_MATTERS
5528 DECL_ALIGN (x
) = MAX (DECL_ALIGN (x
),
5529 TYPE_ALIGN (TREE_TYPE (x
)));
5533 else if (TREE_TYPE (x
) != error_mark_node
)
5535 int min_align
= (DECL_PACKED (x
) ? BITS_PER_UNIT
5536 : TYPE_ALIGN (TREE_TYPE (x
)));
5537 /* Non-bit-fields are aligned for their type, except packed
5538 fields which require only BITS_PER_UNIT alignment. */
5539 DECL_ALIGN (x
) = MAX (DECL_ALIGN (x
), min_align
);
5543 /* Now DECL_INITIAL is null on all members. */
5545 /* Delete all duplicate fields from the fieldlist */
5546 for (x
= fieldlist
; x
&& TREE_CHAIN (x
);)
5547 /* Anonymous fields aren't duplicates. */
5548 if (DECL_NAME (TREE_CHAIN (x
)) == 0)
5552 register tree y
= fieldlist
;
5556 if (DECL_NAME (y
) == DECL_NAME (TREE_CHAIN (x
)))
5562 if (DECL_NAME (y
) == DECL_NAME (TREE_CHAIN (x
)))
5564 error_with_decl (TREE_CHAIN (x
), "duplicate member `%s'");
5565 TREE_CHAIN (x
) = TREE_CHAIN (TREE_CHAIN (x
));
5567 else x
= TREE_CHAIN (x
);
5570 /* Now we have the nearly final fieldlist. Record it,
5571 then lay out the structure or union (including the fields). */
5573 TYPE_FIELDS (t
) = fieldlist
;
5577 /* Delete all zero-width bit-fields from the front of the fieldlist */
5579 && DECL_INITIAL (fieldlist
))
5580 fieldlist
= TREE_CHAIN (fieldlist
);
5581 /* Delete all such members from the rest of the fieldlist */
5582 for (x
= fieldlist
; x
;)
5584 if (TREE_CHAIN (x
) && DECL_INITIAL (TREE_CHAIN (x
)))
5585 TREE_CHAIN (x
) = TREE_CHAIN (TREE_CHAIN (x
));
5586 else x
= TREE_CHAIN (x
);
5589 /* Now we have the truly final field list.
5590 Store it in this type and in the variants. */
5592 TYPE_FIELDS (t
) = fieldlist
;
5594 /* If there are lots of fields, sort so we can look through them fast.
5595 We arbitrarily consider 16 or more elts to be "a lot". */
5599 for (x
= fieldlist
; x
; x
= TREE_CHAIN (x
))
5610 len
+= list_length (x
);
5611 /* Use the same allocation policy here that make_node uses, to
5612 ensure that this lives as long as the rest of the struct decl.
5613 All decls in an inline function need to be saved. */
5614 if (allocation_temporary_p ())
5615 space
= savealloc (sizeof (struct lang_type
) + len
* sizeof (tree
));
5617 space
= oballoc (sizeof (struct lang_type
) + len
* sizeof (tree
));
5619 TYPE_LANG_SPECIFIC (t
) = (struct lang_type
*) space
;
5620 TYPE_LANG_SPECIFIC (t
)->len
= len
;
5622 field_array
= &TYPE_LANG_SPECIFIC (t
)->elts
[0];
5624 for (x
= fieldlist
; x
; x
= TREE_CHAIN (x
))
5625 field_array
[len
++] = x
;
5627 qsort (field_array
, len
, sizeof (tree
), field_decl_cmp
);
5631 for (x
= TYPE_MAIN_VARIANT (t
); x
; x
= TYPE_NEXT_VARIANT (x
))
5633 TYPE_FIELDS (x
) = TYPE_FIELDS (t
);
5634 TYPE_LANG_SPECIFIC (x
) = TYPE_LANG_SPECIFIC (t
);
5635 TYPE_ALIGN (x
) = TYPE_ALIGN (t
);
5638 /* Promote each bit-field's type to int if it is narrower than that. */
5639 for (x
= fieldlist
; x
; x
= TREE_CHAIN (x
))
5640 if (DECL_BIT_FIELD (x
)
5641 && (C_PROMOTING_INTEGER_TYPE_P (TREE_TYPE (x
))
5642 || DECL_FIELD_SIZE (x
) < TYPE_PRECISION (integer_type_node
)))
5644 tree type
= TREE_TYPE (x
);
5646 /* Preserve unsignedness if traditional
5647 or if not really getting any wider. */
5648 if (TREE_UNSIGNED (type
)
5649 && (flag_traditional
5651 (TYPE_PRECISION (type
) == TYPE_PRECISION (integer_type_node
)
5653 DECL_FIELD_SIZE (x
) == TYPE_PRECISION (integer_type_node
))))
5654 TREE_TYPE (x
) = unsigned_type_node
;
5656 TREE_TYPE (x
) = integer_type_node
;
5659 /* If this structure or union completes the type of any previous
5660 variable declaration, lay it out and output its rtl. */
5662 if (current_binding_level
->n_incomplete
!= 0)
5665 for (decl
= current_binding_level
->names
; decl
; decl
= TREE_CHAIN (decl
))
5667 if (TREE_TYPE (decl
) == t
5668 && TREE_CODE (decl
) != TYPE_DECL
)
5670 layout_decl (decl
, 0);
5671 /* This is a no-op in c-lang.c or something real in objc-actions.c. */
5672 maybe_objc_check_decl (decl
);
5673 rest_of_decl_compilation (decl
, NULL_PTR
, toplevel
, 0);
5676 --current_binding_level
->n_incomplete
;
5678 else if (TYPE_SIZE (TREE_TYPE (decl
)) == 0
5679 && TREE_CODE (TREE_TYPE (decl
)) == ARRAY_TYPE
)
5681 tree element
= TREE_TYPE (decl
);
5682 while (TREE_CODE (element
) == ARRAY_TYPE
)
5683 element
= TREE_TYPE (element
);
5685 layout_array_type (TREE_TYPE (decl
));
5690 resume_momentary (old_momentary
);
5692 /* Finish debugging output for this type. */
5693 rest_of_type_compilation (t
, toplevel
);
5695 /* The matching push is in start_struct. */
5701 /* Lay out the type T, and its element type, and so on. */
5704 layout_array_type (t
)
5707 if (TREE_CODE (TREE_TYPE (t
)) == ARRAY_TYPE
)
5708 layout_array_type (TREE_TYPE (t
));
5712 /* Begin compiling the definition of an enumeration type.
5713 NAME is its name (or null if anonymous).
5714 Returns the type object, as yet incomplete.
5715 Also records info about it so that build_enumerator
5716 may be used to declare the individual values as they are read. */
5722 register tree enumtype
= 0;
5724 /* If this is the real definition for a previous forward reference,
5725 fill in the contents in the same object that used to be the
5726 forward reference. */
5729 enumtype
= lookup_tag (ENUMERAL_TYPE
, name
, current_binding_level
, 1);
5731 /* The corresponding pop_obstacks is in finish_enum. */
5732 push_obstacks_nochange ();
5733 /* If these symbols and types are global, make them permanent. */
5734 if (current_binding_level
== global_binding_level
)
5735 end_temporary_allocation ();
5737 if (enumtype
== 0 || TREE_CODE (enumtype
) != ENUMERAL_TYPE
)
5739 enumtype
= make_node (ENUMERAL_TYPE
);
5740 pushtag (name
, enumtype
);
5743 C_TYPE_BEING_DEFINED (enumtype
) = 1;
5745 if (TYPE_VALUES (enumtype
) != 0)
5747 /* This enum is a named one that has been declared already. */
5748 error ("redeclaration of `enum %s'", IDENTIFIER_POINTER (name
));
5750 /* Completely replace its old definition.
5751 The old enumerators remain defined, however. */
5752 TYPE_VALUES (enumtype
) = 0;
5755 enum_next_value
= integer_zero_node
;
5761 /* After processing and defining all the values of an enumeration type,
5762 install their decls in the enumeration type and finish it off.
5763 ENUMTYPE is the type object and VALUES a list of decl-value pairs.
5764 Returns ENUMTYPE. */
5767 finish_enum (enumtype
, values
)
5768 register tree enumtype
, values
;
5770 register tree pair
, tem
;
5771 tree minnode
= 0, maxnode
= 0;
5772 int lowprec
, highprec
, precision
;
5773 int toplevel
= global_binding_level
== current_binding_level
;
5775 if (in_parm_level_p ())
5776 warning ("enum defined inside parms");
5778 /* Calculate the maximum value of any enumerator in this type. */
5780 if (values
== error_mark_node
)
5781 minnode
= maxnode
= integer_zero_node
;
5783 for (pair
= values
; pair
; pair
= TREE_CHAIN (pair
))
5785 tree value
= TREE_VALUE (pair
);
5787 minnode
= maxnode
= TREE_VALUE (pair
);
5790 if (tree_int_cst_lt (maxnode
, value
))
5792 if (tree_int_cst_lt (value
, minnode
))
5797 TYPE_MIN_VALUE (enumtype
) = minnode
;
5798 TYPE_MAX_VALUE (enumtype
) = maxnode
;
5800 /* An enum can have some negative values; then it is signed. */
5801 TREE_UNSIGNED (enumtype
) = tree_int_cst_sgn (minnode
) >= 0;
5803 /* Determine the precision this type needs. */
5805 lowprec
= min_precision (minnode
, TREE_UNSIGNED (enumtype
));
5806 highprec
= min_precision (maxnode
, TREE_UNSIGNED (enumtype
));
5807 precision
= MAX (lowprec
, highprec
);
5809 if (flag_short_enums
|| precision
> TYPE_PRECISION (integer_type_node
))
5810 /* Use the width of the narrowest normal C type which is wide enough. */
5811 TYPE_PRECISION (enumtype
) = TYPE_PRECISION (type_for_size (precision
, 1));
5813 TYPE_PRECISION (enumtype
) = TYPE_PRECISION (integer_type_node
);
5815 TYPE_SIZE (enumtype
) = 0;
5816 layout_type (enumtype
);
5818 if (values
!= error_mark_node
)
5820 /* Change the type of the enumerators to be the enum type.
5821 Formerly this was done only for enums that fit in an int,
5822 but the comment said it was done only for enums wider than int.
5823 It seems necessary to do this for wide enums,
5824 and best not to change what's done for ordinary narrower ones. */
5825 for (pair
= values
; pair
; pair
= TREE_CHAIN (pair
))
5827 TREE_TYPE (TREE_PURPOSE (pair
)) = enumtype
;
5828 DECL_SIZE (TREE_PURPOSE (pair
)) = TYPE_SIZE (enumtype
);
5829 if (TREE_CODE (TREE_PURPOSE (pair
)) != FUNCTION_DECL
)
5830 DECL_ALIGN (TREE_PURPOSE (pair
)) = TYPE_ALIGN (enumtype
);
5833 /* Replace the decl nodes in VALUES with their names. */
5834 for (pair
= values
; pair
; pair
= TREE_CHAIN (pair
))
5835 TREE_PURPOSE (pair
) = DECL_NAME (TREE_PURPOSE (pair
));
5837 TYPE_VALUES (enumtype
) = values
;
5840 /* Fix up all variant types of this enum type. */
5841 for (tem
= TYPE_MAIN_VARIANT (enumtype
); tem
; tem
= TYPE_NEXT_VARIANT (tem
))
5843 TYPE_VALUES (tem
) = TYPE_VALUES (enumtype
);
5844 TYPE_MIN_VALUE (tem
) = TYPE_MIN_VALUE (enumtype
);
5845 TYPE_MAX_VALUE (tem
) = TYPE_MAX_VALUE (enumtype
);
5846 TYPE_SIZE (tem
) = TYPE_SIZE (enumtype
);
5847 TYPE_MODE (tem
) = TYPE_MODE (enumtype
);
5848 TYPE_PRECISION (tem
) = TYPE_PRECISION (enumtype
);
5849 TYPE_ALIGN (tem
) = TYPE_ALIGN (enumtype
);
5850 TREE_UNSIGNED (tem
) = TREE_UNSIGNED (enumtype
);
5853 /* Finish debugging output for this type. */
5854 rest_of_type_compilation (enumtype
, toplevel
);
5856 /* This matches a push in start_enum. */
5862 /* Build and install a CONST_DECL for one value of the
5863 current enumeration type (one that was begun with start_enum).
5864 Return a tree-list containing the CONST_DECL and its value.
5865 Assignment of sequential values by default is handled here. */
5868 build_enumerator (name
, value
)
5871 register tree decl
, type
;
5873 /* Validate and default VALUE. */
5875 /* Remove no-op casts from the value. */
5877 STRIP_TYPE_NOPS (value
);
5881 if (TREE_CODE (value
) == INTEGER_CST
)
5883 value
= default_conversion (value
);
5884 constant_expression_warning (value
);
5888 error ("enumerator value for `%s' not integer constant",
5889 IDENTIFIER_POINTER (name
));
5894 /* Default based on previous value. */
5895 /* It should no longer be possible to have NON_LVALUE_EXPR
5899 value
= enum_next_value
;
5901 error ("overflow in enumeration values");
5904 if (pedantic
&& ! int_fits_type_p (value
, integer_type_node
))
5906 pedwarn ("ANSI C restricts enumerator values to range of `int'");
5907 value
= integer_zero_node
;
5910 /* Set basis for default for next value. */
5911 enum_next_value
= build_binary_op (PLUS_EXPR
, value
, integer_one_node
, 0);
5912 enum_overflow
= tree_int_cst_lt (enum_next_value
, value
);
5914 /* Now create a declaration for the enum value name. */
5916 type
= TREE_TYPE (value
);
5917 type
= type_for_size (MAX (TYPE_PRECISION (type
),
5918 TYPE_PRECISION (integer_type_node
)),
5920 || TYPE_PRECISION (type
) >= TYPE_PRECISION (integer_type_node
))
5921 && TREE_UNSIGNED (type
)));
5923 decl
= build_decl (CONST_DECL
, name
, type
);
5924 DECL_INITIAL (decl
) = value
;
5925 TREE_TYPE (value
) = type
;
5928 return saveable_tree_cons (decl
, value
, NULL_TREE
);
5931 /* Create the FUNCTION_DECL for a function definition.
5932 DECLSPECS, DECLARATOR, and ATTRIBUTES are the parts of the declaration;
5933 they describe the function's name and the type it returns,
5934 but twisted together in a fashion that parallels the syntax of C.
5936 This function creates a binding context for the function body
5937 as well as setting up the FUNCTION_DECL in current_function_decl.
5939 Returns 1 on success. If the DECLARATOR is not suitable for a function
5940 (it defines a datum instead), we return 0, which tells
5941 yyparse to report a parse error.
5943 NESTED is nonzero for a function nested within another function. */
5946 start_function (declspecs
, declarator
, attributes
, nested
)
5947 tree declarator
, declspecs
, attributes
;
5950 tree decl1
, old_decl
;
5952 int old_immediate_size_expand
= immediate_size_expand
;
5954 current_function_returns_value
= 0; /* Assume, until we see it does. */
5955 current_function_returns_null
= 0;
5956 warn_about_return_type
= 0;
5957 current_extern_inline
= 0;
5958 c_function_varargs
= 0;
5960 shadowed_labels
= 0;
5962 /* Don't expand any sizes in the return type of the function. */
5963 immediate_size_expand
= 0;
5965 decl1
= grokdeclarator (declarator
, declspecs
, FUNCDEF
, 1);
5967 /* If the declarator is not suitable for a function definition,
5968 cause a syntax error. */
5973 decl_attributes (decl1
, NULL_TREE
, attributes
);
5975 announce_function (decl1
);
5977 if (TYPE_SIZE (TREE_TYPE (TREE_TYPE (decl1
))) == 0)
5979 error ("return-type is an incomplete type");
5980 /* Make it return void instead. */
5982 = build_function_type (void_type_node
,
5983 TYPE_ARG_TYPES (TREE_TYPE (decl1
)));
5986 if (warn_about_return_type
)
5987 warning ("return-type defaults to `int'");
5989 /* Save the parm names or decls from this function's declarator
5990 where store_parm_decls will find them. */
5991 current_function_parms
= last_function_parms
;
5992 current_function_parm_tags
= last_function_parm_tags
;
5994 /* Make the init_value nonzero so pushdecl knows this is not tentative.
5995 error_mark_node is replaced below (in poplevel) with the BLOCK. */
5996 DECL_INITIAL (decl1
) = error_mark_node
;
5998 /* If this definition isn't a prototype and we had a prototype declaration
5999 before, copy the arg type info from that prototype.
6000 But not if what we had before was a builtin function. */
6001 old_decl
= lookup_name_current_level (DECL_NAME (decl1
));
6002 if (old_decl
!= 0 && TREE_CODE (TREE_TYPE (old_decl
)) == FUNCTION_TYPE
6003 && !DECL_BUILT_IN (old_decl
)
6004 && (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (decl1
)))
6005 == TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (old_decl
))))
6006 && TYPE_ARG_TYPES (TREE_TYPE (decl1
)) == 0)
6008 TREE_TYPE (decl1
) = TREE_TYPE (old_decl
);
6009 current_function_prototype_file
= DECL_SOURCE_FILE (old_decl
);
6010 current_function_prototype_line
= DECL_SOURCE_LINE (old_decl
);
6013 /* If there is no explicit declaration, look for any out-of-scope implicit
6016 old_decl
= IDENTIFIER_IMPLICIT_DECL (DECL_NAME (decl1
));
6018 /* Optionally warn of old-fashioned def with no previous prototype. */
6019 if (warn_strict_prototypes
6020 && TYPE_ARG_TYPES (TREE_TYPE (decl1
)) == 0
6021 && !(old_decl
!= 0 && TYPE_ARG_TYPES (TREE_TYPE (old_decl
)) != 0))
6022 warning ("function declaration isn't a prototype");
6023 /* Optionally warn of any global def with no previous prototype. */
6024 else if (warn_missing_prototypes
6025 && TREE_PUBLIC (decl1
)
6026 && !(old_decl
!= 0 && TYPE_ARG_TYPES (TREE_TYPE (old_decl
)) != 0)
6027 && strcmp ("main", IDENTIFIER_POINTER (DECL_NAME (decl1
))))
6028 warning_with_decl (decl1
, "no previous prototype for `%s'");
6029 /* Optionally warn of any def with no previous prototype
6030 if the function has already been used. */
6031 else if (warn_missing_prototypes
6032 && old_decl
!= 0 && TREE_USED (old_decl
)
6033 && TYPE_ARG_TYPES (TREE_TYPE (old_decl
)) == 0)
6034 warning_with_decl (decl1
,
6035 "`%s' was used with no prototype before its definition");
6036 /* Optionally warn of any global def with no previous declaration. */
6037 else if (warn_missing_declarations
6038 && TREE_PUBLIC (decl1
)
6040 && strcmp ("main", IDENTIFIER_POINTER (DECL_NAME (decl1
))))
6041 warning_with_decl (decl1
, "no previous declaration for `%s'");
6042 /* Optionally warn of any def with no previous declaration
6043 if the function has already been used. */
6044 else if (warn_missing_declarations
6045 && old_decl
!= 0 && TREE_USED (old_decl
)
6046 && old_decl
== IDENTIFIER_IMPLICIT_DECL (DECL_NAME (decl1
)))
6047 warning_with_decl (decl1
,
6048 "`%s' was used with no declaration before its definition");
6050 /* This is a definition, not a reference.
6051 So normally clear DECL_EXTERNAL.
6052 However, `extern inline' acts like a declaration
6053 except for defining how to inline. So set DECL_EXTERNAL in that case. */
6054 DECL_EXTERNAL (decl1
) = current_extern_inline
;
6056 /* This function exists in static storage.
6057 (This does not mean `static' in the C sense!) */
6058 TREE_STATIC (decl1
) = 1;
6060 /* A nested function is not global. */
6061 if (current_function_decl
!= 0)
6062 TREE_PUBLIC (decl1
) = 0;
6064 /* Record the decl so that the function name is defined.
6065 If we already have a decl for this name, and it is a FUNCTION_DECL,
6066 use the old decl. */
6068 current_function_decl
= pushdecl (decl1
);
6071 declare_parm_level (1);
6072 current_binding_level
->subblocks_tag_transparent
= 1;
6074 make_function_rtl (current_function_decl
);
6076 restype
= TREE_TYPE (TREE_TYPE (current_function_decl
));
6077 /* Promote the value to int before returning it. */
6078 if (C_PROMOTING_INTEGER_TYPE_P (restype
))
6080 /* It retains unsignedness if traditional
6081 or if not really getting wider. */
6082 if (TREE_UNSIGNED (restype
)
6083 && (flag_traditional
6084 || (TYPE_PRECISION (restype
)
6085 == TYPE_PRECISION (integer_type_node
))))
6086 restype
= unsigned_type_node
;
6088 restype
= integer_type_node
;
6090 DECL_RESULT (current_function_decl
)
6091 = build_decl (RESULT_DECL
, NULL_TREE
, restype
);
6094 /* Allocate further tree nodes temporarily during compilation
6095 of this function only. */
6096 temporary_allocation ();
6098 /* If this fcn was already referenced via a block-scope `extern' decl
6099 (or an implicit decl), propagate certain information about the usage. */
6100 if (TREE_ADDRESSABLE (DECL_ASSEMBLER_NAME (current_function_decl
)))
6101 TREE_ADDRESSABLE (current_function_decl
) = 1;
6103 immediate_size_expand
= old_immediate_size_expand
;
6108 /* Record that this function is going to be a varargs function.
6109 This is called before store_parm_decls, which is too early
6110 to call mark_varargs directly. */
6115 c_function_varargs
= 1;
6118 /* Store the parameter declarations into the current function declaration.
6119 This is called after parsing the parameter declarations, before
6120 digesting the body of the function.
6122 For an old-style definition, modify the function's type
6123 to specify at least the number of arguments. */
6128 register tree fndecl
= current_function_decl
;
6131 /* This is either a chain of PARM_DECLs (if a prototype was used)
6132 or a list of IDENTIFIER_NODEs (for an old-fashioned C definition). */
6133 tree specparms
= current_function_parms
;
6135 /* This is a list of types declared among parms in a prototype. */
6136 tree parmtags
= current_function_parm_tags
;
6138 /* This is a chain of PARM_DECLs from old-style parm declarations. */
6139 register tree parmdecls
= getdecls ();
6141 /* This is a chain of any other decls that came in among the parm
6142 declarations. If a parm is declared with enum {foo, bar} x;
6143 then CONST_DECLs for foo and bar are put here. */
6146 /* Nonzero if this definition is written with a prototype. */
6149 if (specparms
!= 0 && TREE_CODE (specparms
) != TREE_LIST
)
6151 /* This case is when the function was defined with an ANSI prototype.
6152 The parms already have decls, so we need not do anything here
6153 except record them as in effect
6154 and complain if any redundant old-style parm decls were written. */
6165 error_with_decl (fndecl
,
6166 "parm types given both in parmlist and separately");
6167 /* Get rid of the erroneous decls; don't keep them on
6168 the list of parms, since they might not be PARM_DECLs. */
6169 for (decl
= current_binding_level
->names
;
6170 decl
; decl
= TREE_CHAIN (decl
))
6171 if (DECL_NAME (decl
))
6172 IDENTIFIER_LOCAL_VALUE (DECL_NAME (decl
)) = 0;
6173 for (link
= current_binding_level
->shadowed
;
6174 link
; link
= TREE_CHAIN (link
))
6175 IDENTIFIER_LOCAL_VALUE (TREE_PURPOSE (link
)) = TREE_VALUE (link
);
6176 current_binding_level
->names
= 0;
6177 current_binding_level
->shadowed
= 0;
6180 specparms
= nreverse (specparms
);
6181 for (parm
= specparms
; parm
; parm
= next
)
6183 next
= TREE_CHAIN (parm
);
6184 if (TREE_CODE (parm
) == PARM_DECL
)
6186 if (DECL_NAME (parm
) == 0)
6187 error_with_decl (parm
, "parameter name omitted");
6188 else if (TYPE_MAIN_VARIANT (TREE_TYPE (parm
)) == void_type_node
)
6190 error_with_decl (parm
, "parameter `%s' declared void");
6191 /* Change the type to error_mark_node so this parameter
6192 will be ignored by assign_parms. */
6193 TREE_TYPE (parm
) = error_mark_node
;
6199 /* If we find an enum constant or a type tag,
6200 put it aside for the moment. */
6201 TREE_CHAIN (parm
) = 0;
6202 others
= chainon (others
, parm
);
6206 /* Get the decls in their original chain order
6207 and record in the function. */
6208 DECL_ARGUMENTS (fndecl
) = getdecls ();
6211 /* If this function takes a variable number of arguments,
6212 add a phony parameter to the end of the parm list,
6213 to represent the position of the first unnamed argument. */
6214 if (TREE_VALUE (tree_last (TYPE_ARG_TYPES (TREE_TYPE (fndecl
))))
6217 tree dummy
= build_decl (PARM_DECL
, NULL_TREE
, void_type_node
);
6218 /* Let's hope the address of the unnamed parm
6219 won't depend on its type. */
6220 TREE_TYPE (dummy
) = integer_type_node
;
6221 DECL_ARG_TYPE (dummy
) = integer_type_node
;
6222 DECL_ARGUMENTS (fndecl
)
6223 = chainon (DECL_ARGUMENTS (fndecl
), dummy
);
6227 /* Now pushdecl the enum constants. */
6228 for (parm
= others
; parm
; parm
= next
)
6230 next
= TREE_CHAIN (parm
);
6231 if (DECL_NAME (parm
) == 0)
6233 else if (TYPE_MAIN_VARIANT (TREE_TYPE (parm
)) == void_type_node
)
6235 else if (TREE_CODE (parm
) != PARM_DECL
)
6239 storetags (chainon (parmtags
, gettags ()));
6243 /* SPECPARMS is an identifier list--a chain of TREE_LIST nodes
6244 each with a parm name as the TREE_VALUE.
6246 PARMDECLS is a chain of declarations for parameters.
6247 Warning! It can also contain CONST_DECLs which are not parameters
6248 but are names of enumerators of any enum types
6249 declared among the parameters.
6251 First match each formal parameter name with its declaration.
6252 Associate decls with the names and store the decls
6253 into the TREE_PURPOSE slots. */
6255 for (parm
= parmdecls
; parm
; parm
= TREE_CHAIN (parm
))
6256 DECL_RESULT (parm
) = 0;
6258 for (parm
= specparms
; parm
; parm
= TREE_CHAIN (parm
))
6260 register tree tail
, found
= NULL
;
6262 if (TREE_VALUE (parm
) == 0)
6264 error_with_decl (fndecl
, "parameter name missing from parameter list");
6265 TREE_PURPOSE (parm
) = 0;
6269 /* See if any of the parmdecls specifies this parm by name.
6270 Ignore any enumerator decls. */
6271 for (tail
= parmdecls
; tail
; tail
= TREE_CHAIN (tail
))
6272 if (DECL_NAME (tail
) == TREE_VALUE (parm
)
6273 && TREE_CODE (tail
) == PARM_DECL
)
6279 /* If declaration already marked, we have a duplicate name.
6280 Complain, and don't use this decl twice. */
6281 if (found
&& DECL_RESULT (found
) != 0)
6283 error_with_decl (found
, "multiple parameters named `%s'");
6287 /* If the declaration says "void", complain and ignore it. */
6288 if (found
&& TYPE_MAIN_VARIANT (TREE_TYPE (found
)) == void_type_node
)
6290 error_with_decl (found
, "parameter `%s' declared void");
6291 TREE_TYPE (found
) = integer_type_node
;
6292 DECL_ARG_TYPE (found
) = integer_type_node
;
6293 layout_decl (found
, 0);
6296 /* Traditionally, a parm declared float is actually a double. */
6297 if (found
&& flag_traditional
6298 && TYPE_MAIN_VARIANT (TREE_TYPE (found
)) == float_type_node
)
6300 TREE_TYPE (found
) = double_type_node
;
6301 DECL_ARG_TYPE (found
) = double_type_node
;
6302 layout_decl (found
, 0);
6305 /* If no declaration found, default to int. */
6308 found
= build_decl (PARM_DECL
, TREE_VALUE (parm
),
6310 DECL_ARG_TYPE (found
) = TREE_TYPE (found
);
6311 DECL_SOURCE_LINE (found
) = DECL_SOURCE_LINE (fndecl
);
6312 DECL_SOURCE_FILE (found
) = DECL_SOURCE_FILE (fndecl
);
6314 warning_with_decl (found
, "type of `%s' defaults to `int'");
6318 TREE_PURPOSE (parm
) = found
;
6320 /* Mark this decl as "already found" -- see test, above.
6321 It is safe to use DECL_RESULT for this
6322 since it is not used in PARM_DECLs or CONST_DECLs. */
6323 DECL_RESULT (found
) = error_mark_node
;
6326 /* Put anything which is on the parmdecls chain and which is
6327 not a PARM_DECL onto the list NONPARMS. (The types of
6328 non-parm things which might appear on the list include
6329 enumerators and NULL-named TYPE_DECL nodes.) Complain about
6330 any actual PARM_DECLs not matched with any names. */
6333 for (parm
= parmdecls
; parm
; )
6335 tree next
= TREE_CHAIN (parm
);
6336 TREE_CHAIN (parm
) = 0;
6338 if (TREE_CODE (parm
) != PARM_DECL
)
6339 nonparms
= chainon (nonparms
, parm
);
6342 /* Complain about args with incomplete types. */
6343 if (TYPE_SIZE (TREE_TYPE (parm
)) == 0)
6345 error_with_decl (parm
, "parameter `%s' has incomplete type");
6346 TREE_TYPE (parm
) = error_mark_node
;
6349 if (DECL_RESULT (parm
) == 0)
6351 error_with_decl (parm
,
6352 "declaration for parameter `%s' but no such parameter");
6353 /* Pretend the parameter was not missing.
6354 This gets us to a standard state and minimizes
6355 further error messages. */
6357 = chainon (specparms
,
6358 tree_cons (parm
, NULL_TREE
, NULL_TREE
));
6365 /* Chain the declarations together in the order of the list of names. */
6366 /* Store that chain in the function decl, replacing the list of names. */
6368 DECL_ARGUMENTS (fndecl
) = 0;
6371 for (last
= 0; parm
; parm
= TREE_CHAIN (parm
))
6372 if (TREE_PURPOSE (parm
))
6375 DECL_ARGUMENTS (fndecl
) = TREE_PURPOSE (parm
);
6377 TREE_CHAIN (last
) = TREE_PURPOSE (parm
);
6378 last
= TREE_PURPOSE (parm
);
6379 TREE_CHAIN (last
) = 0;
6383 /* If there was a previous prototype,
6384 set the DECL_ARG_TYPE of each argument according to
6385 the type previously specified, and report any mismatches. */
6387 if (TYPE_ARG_TYPES (TREE_TYPE (fndecl
)))
6390 for (parm
= DECL_ARGUMENTS (fndecl
),
6391 type
= TYPE_ARG_TYPES (TREE_TYPE (fndecl
));
6392 parm
|| (type
&& (TYPE_MAIN_VARIANT (TREE_VALUE (type
))
6393 != void_type_node
));
6394 parm
= TREE_CHAIN (parm
), type
= TREE_CHAIN (type
))
6396 if (parm
== 0 || type
== 0
6397 || TYPE_MAIN_VARIANT (TREE_VALUE (type
)) == void_type_node
)
6399 error ("number of arguments doesn't match prototype");
6400 error_with_file_and_line (current_function_prototype_file
,
6401 current_function_prototype_line
,
6402 "prototype declaration");
6405 /* Type for passing arg must be consistent
6406 with that declared for the arg. */
6407 if (! comptypes (DECL_ARG_TYPE (parm
), TREE_VALUE (type
)))
6409 if (TYPE_MAIN_VARIANT (TREE_TYPE (parm
))
6410 == TYPE_MAIN_VARIANT (TREE_VALUE (type
)))
6412 /* Adjust argument to match prototype. E.g. a previous
6413 `int foo(float);' prototype causes
6414 `int foo(x) float x; {...}' to be treated like
6415 `int foo(float x) {...}'. This is particularly
6416 useful for argument types like uid_t. */
6417 DECL_ARG_TYPE (parm
) = TREE_TYPE (parm
);
6418 #ifdef PROMOTE_PROTOTYPES
6419 if ((TREE_CODE (TREE_TYPE (parm
)) == INTEGER_TYPE
6420 || TREE_CODE (TREE_TYPE (parm
)) == ENUMERAL_TYPE
)
6421 && TYPE_PRECISION (TREE_TYPE (parm
))
6422 < TYPE_PRECISION (integer_type_node
))
6423 DECL_ARG_TYPE (parm
) = integer_type_node
;
6427 pedwarn ("promoted argument `%s' doesn't match prototype",
6428 IDENTIFIER_POINTER (DECL_NAME (parm
)));
6429 warning_with_file_and_line
6430 (current_function_prototype_file
,
6431 current_function_prototype_line
,
6432 "prototype declaration");
6435 /* If -traditional, allow `int' argument to match
6436 `unsigned' prototype. */
6437 else if (! (flag_traditional
6438 && TYPE_MAIN_VARIANT (TREE_TYPE (parm
)) == integer_type_node
6439 && TYPE_MAIN_VARIANT (TREE_VALUE (type
)) == unsigned_type_node
))
6441 error ("argument `%s' doesn't match prototype",
6442 IDENTIFIER_POINTER (DECL_NAME (parm
)));
6443 error_with_file_and_line (current_function_prototype_file
,
6444 current_function_prototype_line
,
6445 "prototype declaration");
6449 TYPE_ACTUAL_ARG_TYPES (TREE_TYPE (fndecl
)) = 0;
6452 /* Otherwise, create a prototype that would match. */
6456 tree actual
= 0, last
= 0, type
;
6458 for (parm
= DECL_ARGUMENTS (fndecl
); parm
; parm
= TREE_CHAIN (parm
))
6460 type
= perm_tree_cons (NULL_TREE
, DECL_ARG_TYPE (parm
),
6463 TREE_CHAIN (last
) = type
;
6468 type
= perm_tree_cons (NULL_TREE
, void_type_node
, NULL_TREE
);
6470 TREE_CHAIN (last
) = type
;
6474 /* We are going to assign a new value for the TYPE_ACTUAL_ARG_TYPES
6475 of the type of this function, but we need to avoid having this
6476 affect the types of other similarly-typed functions, so we must
6477 first force the generation of an identical (but separate) type
6478 node for the relevant function type. The new node we create
6479 will be a variant of the main variant of the original function
6482 TREE_TYPE (fndecl
) = build_type_copy (TREE_TYPE (fndecl
));
6484 TYPE_ACTUAL_ARG_TYPES (TREE_TYPE (fndecl
)) = actual
;
6487 /* Now store the final chain of decls for the arguments
6488 as the decl-chain of the current lexical scope.
6489 Put the enumerators in as well, at the front so that
6490 DECL_ARGUMENTS is not modified. */
6492 storedecls (chainon (nonparms
, DECL_ARGUMENTS (fndecl
)));
6495 /* Make sure the binding level for the top of the function body
6496 gets a BLOCK if there are any in the function.
6497 Otherwise, the dbx output is wrong. */
6499 keep_next_if_subblocks
= 1;
6501 /* ??? This might be an improvement,
6502 but needs to be thought about some more. */
6504 keep_next_level_flag
= 1;
6507 /* Write a record describing this function definition to the prototypes
6508 file (if requested). */
6510 gen_aux_info_record (fndecl
, 1, 0, prototype
);
6512 /* Initialize the RTL code for the function. */
6514 init_function_start (fndecl
, input_filename
, lineno
);
6516 /* If this is a varargs function, inform function.c. */
6518 if (c_function_varargs
)
6521 /* Declare __FUNCTION__ and __PRETTY_FUNCTION__ for this function. */
6523 declare_function_name ();
6525 /* Set up parameters and prepare for return, for the function. */
6527 expand_function_start (fndecl
, 0);
6529 /* If this function is `main', emit a call to `__main'
6530 to run global initializers, etc. */
6531 if (DECL_NAME (fndecl
)
6532 && strcmp (IDENTIFIER_POINTER (DECL_NAME (fndecl
)), "main") == 0
6533 && DECL_CONTEXT (fndecl
) == NULL_TREE
)
6534 expand_main_function ();
6537 /* SPECPARMS is an identifier list--a chain of TREE_LIST nodes
6538 each with a parm name as the TREE_VALUE. A null pointer as TREE_VALUE
6539 stands for an ellipsis in the identifier list.
6541 PARMLIST is the data returned by get_parm_info for the
6542 parmlist that follows the semicolon.
6544 We return a value of the same sort that get_parm_info returns,
6545 except that it describes the combination of identifiers and parmlist. */
6548 combine_parm_decls (specparms
, parmlist
, void_at_end
)
6549 tree specparms
, parmlist
;
6552 register tree fndecl
= current_function_decl
;
6555 tree parmdecls
= TREE_PURPOSE (parmlist
);
6557 /* This is a chain of any other decls that came in among the parm
6558 declarations. They were separated already by get_parm_info,
6559 so we just need to keep them separate. */
6560 tree nonparms
= TREE_VALUE (parmlist
);
6564 for (parm
= parmdecls
; parm
; parm
= TREE_CHAIN (parm
))
6565 DECL_RESULT (parm
) = 0;
6567 for (parm
= specparms
; parm
; parm
= TREE_CHAIN (parm
))
6569 register tree tail
, found
= NULL
;
6571 /* See if any of the parmdecls specifies this parm by name. */
6572 for (tail
= parmdecls
; tail
; tail
= TREE_CHAIN (tail
))
6573 if (DECL_NAME (tail
) == TREE_VALUE (parm
))
6579 /* If declaration already marked, we have a duplicate name.
6580 Complain, and don't use this decl twice. */
6581 if (found
&& DECL_RESULT (found
) != 0)
6583 error_with_decl (found
, "multiple parameters named `%s'");
6587 /* If the declaration says "void", complain and ignore it. */
6588 if (found
&& TYPE_MAIN_VARIANT (TREE_TYPE (found
)) == void_type_node
)
6590 error_with_decl (found
, "parameter `%s' declared void");
6591 TREE_TYPE (found
) = integer_type_node
;
6592 DECL_ARG_TYPE (found
) = integer_type_node
;
6593 layout_decl (found
, 0);
6596 /* Traditionally, a parm declared float is actually a double. */
6597 if (found
&& flag_traditional
6598 && TYPE_MAIN_VARIANT (TREE_TYPE (found
)) == float_type_node
)
6600 TREE_TYPE (found
) = double_type_node
;
6601 DECL_ARG_TYPE (found
) = double_type_node
;
6602 layout_decl (found
, 0);
6605 /* If no declaration found, default to int. */
6608 found
= build_decl (PARM_DECL
, TREE_VALUE (parm
),
6610 DECL_ARG_TYPE (found
) = TREE_TYPE (found
);
6611 DECL_SOURCE_LINE (found
) = DECL_SOURCE_LINE (fndecl
);
6612 DECL_SOURCE_FILE (found
) = DECL_SOURCE_FILE (fndecl
);
6613 error_with_decl (found
, "type of parameter `%s' is not declared");
6617 TREE_PURPOSE (parm
) = found
;
6619 /* Mark this decl as "already found" -- see test, above.
6620 It is safe to use DECL_RESULT for this
6621 since it is not used in PARM_DECLs or CONST_DECLs. */
6622 DECL_RESULT (found
) = error_mark_node
;
6625 /* Complain about any actual PARM_DECLs not matched with any names. */
6627 for (parm
= parmdecls
; parm
; )
6629 tree next
= TREE_CHAIN (parm
);
6630 TREE_CHAIN (parm
) = 0;
6632 /* Complain about args with incomplete types. */
6633 if (TYPE_SIZE (TREE_TYPE (parm
)) == 0)
6635 error_with_decl (parm
, "parameter `%s' has incomplete type");
6636 TREE_TYPE (parm
) = error_mark_node
;
6639 if (DECL_RESULT (parm
) == 0)
6641 error_with_decl (parm
,
6642 "declaration for parameter `%s' but no such parameter");
6643 /* Pretend the parameter was not missing.
6644 This gets us to a standard state and minimizes
6645 further error messages. */
6647 = chainon (specparms
,
6648 tree_cons (parm
, NULL_TREE
, NULL_TREE
));
6654 /* Chain the declarations together in the order of the list of names.
6655 At the same time, build up a list of their types, in reverse order. */
6661 for (last
= 0; parm
; parm
= TREE_CHAIN (parm
))
6662 if (TREE_PURPOSE (parm
))
6665 parmdecls
= TREE_PURPOSE (parm
);
6667 TREE_CHAIN (last
) = TREE_PURPOSE (parm
);
6668 last
= TREE_PURPOSE (parm
);
6669 TREE_CHAIN (last
) = 0;
6671 types
= saveable_tree_cons (NULL_TREE
, TREE_TYPE (parm
), types
);
6676 return saveable_tree_cons (parmdecls
, nonparms
,
6677 nreverse (saveable_tree_cons (NULL_TREE
, void_type_node
, types
)));
6679 return saveable_tree_cons (parmdecls
, nonparms
, nreverse (types
));
6682 /* Finish up a function declaration and compile that function
6683 all the way to assembler language output. The free the storage
6684 for the function definition.
6686 This is called after parsing the body of the function definition.
6688 NESTED is nonzero if the function being finished is nested in another. */
6691 finish_function (nested
)
6694 register tree fndecl
= current_function_decl
;
6696 /* TREE_READONLY (fndecl) = 1;
6697 This caused &foo to be of type ptr-to-const-function
6698 which then got a warning when stored in a ptr-to-function variable. */
6701 BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl
)) = fndecl
;
6703 /* Must mark the RESULT_DECL as being in this function. */
6705 DECL_CONTEXT (DECL_RESULT (fndecl
)) = fndecl
;
6707 /* Obey `register' declarations if `setjmp' is called in this fn. */
6708 if (flag_traditional
&& current_function_calls_setjmp
)
6710 setjmp_protect (DECL_INITIAL (fndecl
));
6711 setjmp_protect_args ();
6714 #ifdef DEFAULT_MAIN_RETURN
6715 if (! strcmp (IDENTIFIER_POINTER (DECL_NAME (fndecl
)), "main"))
6717 if (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (fndecl
)))
6718 != integer_type_node
)
6719 warning_with_decl (fndecl
, "return type of `%s' is not `int'");
6722 /* Make it so that `main' always returns success by default. */
6723 DEFAULT_MAIN_RETURN
;
6728 /* Generate rtl for function exit. */
6729 expand_function_end (input_filename
, lineno
, 0);
6731 /* So we can tell if jump_optimize sets it to 1. */
6734 /* Run the optimizers and output the assembler code for this function. */
6735 rest_of_compilation (fndecl
);
6737 current_function_returns_null
|= can_reach_end
;
6739 if (TREE_THIS_VOLATILE (fndecl
) && current_function_returns_null
)
6740 warning ("`noreturn' function does return");
6741 else if (warn_return_type
&& can_reach_end
6742 && TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (fndecl
))) != void_type_node
)
6743 /* If this function returns non-void and control can drop through,
6745 warning ("control reaches end of non-void function");
6746 /* With just -W, complain only if function returns both with
6747 and without a value. */
6748 else if (extra_warnings
6749 && current_function_returns_value
&& current_function_returns_null
)
6750 warning ("this function may return with or without a value");
6752 /* If requested, warn about function definitions where the function will
6753 return a value (usually of some struct or union type) which itself will
6754 take up a lot of stack space. */
6756 if (warn_larger_than
&& !DECL_EXTERNAL (fndecl
) && TREE_TYPE (fndecl
))
6758 register tree ret_type
= TREE_TYPE (TREE_TYPE (fndecl
));
6762 register tree ret_type_size
= TYPE_SIZE (ret_type
);
6764 if (TREE_CODE (ret_type_size
) == INTEGER_CST
)
6767 = TREE_INT_CST_LOW (ret_type_size
) / BITS_PER_UNIT
;
6769 if (units
> larger_than_size
)
6770 warning_with_decl (fndecl
,
6771 "size of return value of `%s' is %u bytes",
6777 /* Free all the tree nodes making up this function. */
6778 /* Switch back to allocating nodes permanently
6779 until we start another function. */
6781 permanent_allocation (1);
6783 if (DECL_SAVED_INSNS (fndecl
) == 0 && ! nested
)
6785 /* Stop pointing to the local nodes about to be freed. */
6786 /* But DECL_INITIAL must remain nonzero so we know this
6787 was an actual function definition. */
6788 /* For a nested function, this is done in pop_c_function_context. */
6789 /* If rest_of_compilation set this to 0, leave it 0. */
6790 if (DECL_INITIAL (fndecl
) != 0)
6791 DECL_INITIAL (fndecl
) = error_mark_node
;
6792 DECL_ARGUMENTS (fndecl
) = 0;
6795 if (DECL_STATIC_CONSTRUCTOR (fndecl
))
6797 #ifndef ASM_OUTPUT_CONSTRUCTOR
6798 if (! flag_gnu_linker
)
6799 static_ctors
= perm_tree_cons (NULL_TREE
, fndecl
, static_ctors
);
6802 assemble_constructor (IDENTIFIER_POINTER (DECL_NAME (fndecl
)));
6804 if (DECL_STATIC_DESTRUCTOR (fndecl
))
6806 #ifndef ASM_OUTPUT_DESTRUCTOR
6807 if (! flag_gnu_linker
)
6808 static_dtors
= perm_tree_cons (NULL_TREE
, fndecl
, static_dtors
);
6811 assemble_destructor (IDENTIFIER_POINTER (DECL_NAME (fndecl
)));
6816 /* Let the error reporting routines know that we're outside a
6817 function. For a nested function, this value is used in
6818 pop_c_function_context and then reset via pop_function_context. */
6819 current_function_decl
= NULL
;
6823 /* Save and restore the variables in this file and elsewhere
6824 that keep track of the progress of compilation of the current function.
6825 Used for nested functions. */
6829 struct c_function
*next
;
6831 tree shadowed_labels
;
6834 int warn_about_return_type
;
6836 struct binding_level
*binding_level
;
6839 struct c_function
*c_function_chain
;
6841 /* Save and reinitialize the variables
6842 used during compilation of a C function. */
6845 push_c_function_context ()
6847 struct c_function
*p
6848 = (struct c_function
*) xmalloc (sizeof (struct c_function
));
6851 pedwarn ("ANSI C forbids nested functions");
6853 push_function_context ();
6855 p
->next
= c_function_chain
;
6856 c_function_chain
= p
;
6858 p
->named_labels
= named_labels
;
6859 p
->shadowed_labels
= shadowed_labels
;
6860 p
->returns_value
= current_function_returns_value
;
6861 p
->returns_null
= current_function_returns_null
;
6862 p
->warn_about_return_type
= warn_about_return_type
;
6863 p
->extern_inline
= current_extern_inline
;
6864 p
->binding_level
= current_binding_level
;
6867 /* Restore the variables used during compilation of a C function. */
6870 pop_c_function_context ()
6872 struct c_function
*p
= c_function_chain
;
6875 /* Bring back all the labels that were shadowed. */
6876 for (link
= shadowed_labels
; link
; link
= TREE_CHAIN (link
))
6877 if (DECL_NAME (TREE_VALUE (link
)) != 0)
6878 IDENTIFIER_LABEL_VALUE (DECL_NAME (TREE_VALUE (link
)))
6879 = TREE_VALUE (link
);
6881 if (DECL_SAVED_INSNS (current_function_decl
) == 0)
6883 /* Stop pointing to the local nodes about to be freed. */
6884 /* But DECL_INITIAL must remain nonzero so we know this
6885 was an actual function definition. */
6886 DECL_INITIAL (current_function_decl
) = error_mark_node
;
6887 DECL_ARGUMENTS (current_function_decl
) = 0;
6890 pop_function_context ();
6892 c_function_chain
= p
->next
;
6894 named_labels
= p
->named_labels
;
6895 shadowed_labels
= p
->shadowed_labels
;
6896 current_function_returns_value
= p
->returns_value
;
6897 current_function_returns_null
= p
->returns_null
;
6898 warn_about_return_type
= p
->warn_about_return_type
;
6899 current_extern_inline
= p
->extern_inline
;
6900 current_binding_level
= p
->binding_level
;
6905 /* integrate_decl_tree calls this function, but since we don't use the
6906 DECL_LANG_SPECIFIC field, this is a no-op. */
6909 copy_lang_decl (node
)