1 /* Process declarations and variables for C compiler.
2 Copyright (C) 1988, 1992 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. */
35 /* In grokdeclarator, distinguish syntactic contexts of declarators. */
37 { NORMAL
, /* Ordinary declaration */
38 FUNCDEF
, /* Function definition */
39 PARM
, /* Declaration of parm before function body */
40 FIELD
, /* Declaration inside struct or union */
41 BITFIELD
, /* Likewise but with specified width */
42 TYPENAME
}; /* Typename (inside cast or sizeof) */
44 #ifndef CHAR_TYPE_SIZE
45 #define CHAR_TYPE_SIZE BITS_PER_UNIT
48 #ifndef SHORT_TYPE_SIZE
49 #define SHORT_TYPE_SIZE (BITS_PER_UNIT * MIN ((UNITS_PER_WORD + 1) / 2, 2))
53 #define INT_TYPE_SIZE BITS_PER_WORD
56 #ifndef LONG_TYPE_SIZE
57 #define LONG_TYPE_SIZE BITS_PER_WORD
60 #ifndef LONG_LONG_TYPE_SIZE
61 #define LONG_LONG_TYPE_SIZE (BITS_PER_WORD * 2)
64 #ifndef WCHAR_UNSIGNED
65 #define WCHAR_UNSIGNED 0
68 #ifndef FLOAT_TYPE_SIZE
69 #define FLOAT_TYPE_SIZE BITS_PER_WORD
72 #ifndef DOUBLE_TYPE_SIZE
73 #define DOUBLE_TYPE_SIZE (BITS_PER_WORD * 2)
76 #ifndef LONG_DOUBLE_TYPE_SIZE
77 #define LONG_DOUBLE_TYPE_SIZE (BITS_PER_WORD * 2)
80 /* We let tm.h override the types used here, to handle trivial differences
81 such as the choice of unsigned int or long unsigned int for size_t.
82 When machines start needing nontrivial differences in the size type,
83 it would be best to do something here to figure out automatically
84 from other information what type to use. */
87 #define SIZE_TYPE "long unsigned int"
91 #define PTRDIFF_TYPE "long int"
95 #define WCHAR_TYPE "int"
98 /* a node which has tree code ERROR_MARK, and whose type is itself.
99 All erroneous expressions are replaced with this node. All functions
100 that accept nodes as arguments should avoid generating error messages
101 if this node is one of the arguments, since it is undesirable to get
102 multiple error messages from one error in the input. */
104 tree error_mark_node
;
106 /* INTEGER_TYPE and REAL_TYPE nodes for the standard data types */
108 tree short_integer_type_node
;
109 tree integer_type_node
;
110 tree long_integer_type_node
;
111 tree long_long_integer_type_node
;
113 tree short_unsigned_type_node
;
114 tree unsigned_type_node
;
115 tree long_unsigned_type_node
;
116 tree long_long_unsigned_type_node
;
118 tree ptrdiff_type_node
;
120 tree unsigned_char_type_node
;
121 tree signed_char_type_node
;
123 tree wchar_type_node
;
124 tree signed_wchar_type_node
;
125 tree unsigned_wchar_type_node
;
127 tree float_type_node
;
128 tree double_type_node
;
129 tree long_double_type_node
;
131 tree intQI_type_node
;
132 tree intHI_type_node
;
133 tree intSI_type_node
;
134 tree intDI_type_node
;
136 tree unsigned_intQI_type_node
;
137 tree unsigned_intHI_type_node
;
138 tree unsigned_intSI_type_node
;
139 tree unsigned_intDI_type_node
;
141 /* a VOID_TYPE node. */
145 /* Nodes for types `void *' and `const void *'. */
147 tree ptr_type_node
, const_ptr_type_node
;
149 /* Nodes for types `char *' and `const char *'. */
151 tree string_type_node
, const_string_type_node
;
153 /* Type `char[256]' or something like it.
154 Used when an array of char is needed and the size is irrelevant. */
156 tree char_array_type_node
;
158 /* Type `int[256]' or something like it.
159 Used when an array of int needed and the size is irrelevant. */
161 tree int_array_type_node
;
163 /* Type `wchar_t[256]' or something like it.
164 Used when a wide string literal is created. */
166 tree wchar_array_type_node
;
168 /* type `int ()' -- used for implicit declaration of functions. */
170 tree default_function_type
;
172 /* function types `double (double)' and `double (double, double)', etc. */
174 tree double_ftype_double
, double_ftype_double_double
;
175 tree int_ftype_int
, long_ftype_long
;
177 /* Function type `void (void *, void *, int)' and similar ones */
179 tree void_ftype_ptr_ptr_int
, int_ftype_ptr_ptr_int
, void_ftype_ptr_int_int
;
181 /* Function type `char *(char *, char *)' and similar ones */
182 tree string_ftype_ptr_ptr
, int_ftype_string_string
;
184 /* Function type `int (const void *, const void *, size_t)' */
185 tree int_ftype_cptr_cptr_sizet
;
187 /* Two expressions that are constants with value zero.
188 The first is of type `int', the second of type `void *'. */
190 tree integer_zero_node
;
191 tree null_pointer_node
;
193 /* A node for the integer constant 1. */
195 tree integer_one_node
;
197 /* Nonzero if we have seen an invalid cross reference
198 to a struct, union, or enum, but not yet printed the message. */
200 tree pending_invalid_xref
;
201 /* File and line to appear in the eventual error message. */
202 char *pending_invalid_xref_file
;
203 int pending_invalid_xref_line
;
205 /* While defining an enum type, this is 1 plus the last enumerator
208 static tree enum_next_value
;
210 /* Nonzero means that there was overflow computing enum_next_value. */
212 static int enum_overflow
;
214 /* Parsing a function declarator leaves a list of parameter names
215 or a chain or parameter decls here. */
217 static tree last_function_parms
;
219 /* Parsing a function declarator leaves here a chain of structure
220 and enum types declared in the parmlist. */
222 static tree last_function_parm_tags
;
224 /* After parsing the declarator that starts a function definition,
225 `start_function' puts here the list of parameter names or chain of decls.
226 `store_parm_decls' finds it here. */
228 static tree current_function_parms
;
230 /* Similar, for last_function_parm_tags. */
231 static tree current_function_parm_tags
;
233 /* A list (chain of TREE_LIST nodes) of all LABEL_DECLs in the function
234 that have names. Here so we can clear out their names' definitions
235 at the end of the function. */
237 static tree named_labels
;
239 /* A list of LABEL_DECLs from outer contexts that are currently shadowed. */
241 static tree shadowed_labels
;
243 /* Nonzero when store_parm_decls is called indicates a varargs function.
244 Value not meaningful after store_parm_decls. */
246 static int c_function_varargs
;
248 /* The FUNCTION_DECL for the function currently being compiled,
249 or 0 if between functions. */
250 tree current_function_decl
;
252 /* Set to 0 at beginning of a function definition, set to 1 if
253 a return statement that specifies a return value is seen. */
255 int current_function_returns_value
;
257 /* Set to 0 at beginning of a function definition, set to 1 if
258 a return statement with no argument is seen. */
260 int current_function_returns_null
;
262 /* Set to nonzero by `grokdeclarator' for a function
263 whose return type is defaulted, if warnings for this are desired. */
265 static int warn_about_return_type
;
267 /* Nonzero when starting a function declared `extern inline'. */
269 static int current_extern_inline
;
271 /* For each binding contour we allocate a binding_level structure
272 * which records the names defined in that contour.
275 * 1) one for each function definition,
276 * where internal declarations of the parameters appear.
277 * 2) one for each compound statement,
278 * to record its declarations.
280 * The current meaning of a name can be found by searching the levels from
281 * the current one out to the global one.
284 /* Note that the information in the `names' component of the global contour
285 is duplicated in the IDENTIFIER_GLOBAL_VALUEs of all identifiers. */
289 /* A chain of _DECL nodes for all variables, constants, functions,
290 and typedef types. These are in the reverse of the order supplied.
294 /* A list of structure, union and enum definitions,
295 * for looking up tag names.
296 * It is a chain of TREE_LIST nodes, each of whose TREE_PURPOSE is a name,
297 * or NULL_TREE; and whose TREE_VALUE is a RECORD_TYPE, UNION_TYPE,
298 * or ENUMERAL_TYPE node.
302 /* For each level, a list of shadowed outer-level local definitions
303 to be restored when this level is popped.
304 Each link is a TREE_LIST whose TREE_PURPOSE is an identifier and
305 whose TREE_VALUE is its old definition (a kind of ..._DECL node). */
308 /* For each level (except not the global one),
309 a chain of BLOCK nodes for all the levels
310 that were entered and exited one level down. */
313 /* The binding level which this one is contained in (inherits from). */
314 struct binding_level
*level_chain
;
316 /* Nonzero for the level that holds the parameters of a function. */
317 /* 2 for a definition, 1 for a declaration. */
320 /* Nonzero if this level "doesn't exist" for tags. */
321 char tag_transparent
;
323 /* Nonzero if sublevels of this level "don't exist" for tags.
324 This is set in the parm level of a function definition
325 while reading the function body, so that the outermost block
326 of the function body will be tag-transparent. */
327 char subblocks_tag_transparent
;
329 /* Nonzero means make a BLOCK for this level regardless of all else. */
332 /* Nonzero means make a BLOCK if this level has any subblocks. */
333 char keep_if_subblocks
;
335 /* Number of decls in `names' that have incomplete
336 structure or union types. */
339 /* A list of decls giving the (reversed) specified order of parms,
340 not including any forward-decls in the parmlist.
341 This is so we can put the parms in proper order for assign_parms. */
345 #define NULL_BINDING_LEVEL (struct binding_level *) NULL
347 /* The binding level currently in effect. */
349 static struct binding_level
*current_binding_level
;
351 /* A chain of binding_level structures awaiting reuse. */
353 static struct binding_level
*free_binding_level
;
355 /* The outermost binding level, for names of file scope.
356 This is created when the compiler is started and exists
357 through the entire run. */
359 static struct binding_level
*global_binding_level
;
361 /* Binding level structures are initialized by copying this one. */
363 static struct binding_level clear_binding_level
364 = {NULL
, NULL
, NULL
, NULL
, NULL
, 0, 0, 0};
366 /* Nonzero means unconditionally make a BLOCK for the next level pushed. */
368 static int keep_next_level_flag
;
370 /* Nonzero means make a BLOCK for the next level pushed
371 if it has subblocks. */
373 static int keep_next_if_subblocks
;
375 /* The chain of outer levels of label scopes.
376 This uses the same data structure used for binding levels,
377 but it works differently: each link in the chain records
378 saved values of named_labels and shadowed_labels for
379 a label binding level outside the current one. */
381 static struct binding_level
*label_level_chain
;
383 /* Forward declarations. */
385 static tree
grokparms (), grokdeclarator ();
387 tree
builtin_function ();
389 static tree
lookup_tag ();
390 static tree
lookup_tag_reverse ();
391 static tree
lookup_name_current_level ();
392 static char *redeclaration_error_message ();
393 static void layout_array_type ();
395 /* C-specific option variables. */
397 /* Nonzero means allow type mismatches in conditional expressions;
398 just make their values `void'. */
400 int flag_cond_mismatch
;
402 /* Nonzero means give `double' the same size as `float'. */
404 int flag_short_double
;
406 /* Nonzero means don't recognize the keyword `asm'. */
410 /* Nonzero means don't recognize any builtin functions. */
414 /* Nonzero means don't recognize the non-ANSI builtin functions.
417 int flag_no_nonansi_builtin
;
419 /* Nonzero means do some things the same way PCC does. */
421 int flag_traditional
;
423 /* Nonzero means to treat bitfields as signed unless they say `unsigned'. */
425 int flag_signed_bitfields
= 1;
427 /* Nonzero means handle `#ident' directives. 0 means ignore them. */
429 int flag_no_ident
= 0;
431 /* Nonzero means warn about implicit declarations. */
435 /* Nonzero means give string constants the type `const char *'
436 to get extra warnings from them. These warnings will be too numerous
437 to be useful, except in thoroughly ANSIfied programs. */
439 int warn_write_strings
;
441 /* Nonzero means warn about pointer casts that can drop a type qualifier
442 from the pointer target type. */
446 /* Warn about traditional constructs whose meanings changed in ANSI C. */
448 int warn_traditional
;
450 /* Nonzero means warn about sizeof(function) or addition/subtraction
451 of function pointers. */
453 int warn_pointer_arith
;
455 /* Nonzero means warn for non-prototype function decls
456 or non-prototyped defs without previous prototype. */
458 int warn_strict_prototypes
;
460 /* Nonzero means warn for any global function def
461 without separate previous prototype decl. */
463 int warn_missing_prototypes
;
465 /* Nonzero means warn about multiple (redundant) decls for the same single
466 variable or function. */
468 int warn_redundant_decls
= 0;
470 /* Nonzero means warn about extern declarations of objects not at
471 file-scope level and about *all* declarations of functions (whether
472 extern or static) not at file-scope level. Note that we exclude
473 implicit function declarations. To get warnings about those, use
476 int warn_nested_externs
= 0;
478 /* Warn about *printf or *scanf format/argument anomalies. */
482 /* Warn about a subscript that has type char. */
484 int warn_char_subscripts
= 0;
486 /* Warn if a type conversion is done that might have confusing results. */
490 /* Warn if adding () is suggested. */
492 int warn_parentheses
;
494 /* Nonzero means `$' can be in an identifier.
495 See cccp.c for reasons why this breaks some obscure ANSI C programs. */
497 #ifndef DOLLARS_IN_IDENTIFIERS
498 #define DOLLARS_IN_IDENTIFIERS 1
500 int dollars_in_ident
= DOLLARS_IN_IDENTIFIERS
> 1;
502 char *language_string
= "GNU C";
504 /* Decode the string P as a language-specific option for C.
505 Return 1 if it is recognized (and handle it);
506 return 0 if not recognized. */
512 if (!strcmp (p
, "-ftraditional") || !strcmp (p
, "-traditional"))
514 flag_traditional
= 1;
515 flag_writable_strings
= 1;
516 #if DOLLARS_IN_IDENTIFIERS > 0
517 dollars_in_ident
= 1;
520 else if (!strcmp (p
, "-fnotraditional"))
522 else if (!strcmp (p
, "-fsigned-char"))
523 flag_signed_char
= 1;
524 else if (!strcmp (p
, "-funsigned-char"))
525 flag_signed_char
= 0;
526 else if (!strcmp (p
, "-fno-signed-char"))
527 flag_signed_char
= 0;
528 else if (!strcmp (p
, "-fno-unsigned-char"))
529 flag_signed_char
= 1;
530 else if (!strcmp (p
, "-fsigned-bitfields"))
531 flag_signed_bitfields
= 1;
532 else if (!strcmp (p
, "-funsigned-bitfields"))
533 flag_signed_bitfields
= 0;
534 else if (!strcmp (p
, "-fno-signed-bitfields"))
535 flag_signed_bitfields
= 0;
536 else if (!strcmp (p
, "-fno-unsigned-bitfields"))
537 flag_signed_bitfields
= 1;
538 else if (!strcmp (p
, "-fshort-enums"))
539 flag_short_enums
= 1;
540 else if (!strcmp (p
, "-fno-short-enums"))
541 flag_short_enums
= 0;
542 else if (!strcmp (p
, "-fcond-mismatch"))
543 flag_cond_mismatch
= 1;
544 else if (!strcmp (p
, "-fno-cond-mismatch"))
545 flag_cond_mismatch
= 0;
546 else if (!strcmp (p
, "-fshort-double"))
547 flag_short_double
= 1;
548 else if (!strcmp (p
, "-fno-short-double"))
549 flag_short_double
= 0;
550 else if (!strcmp (p
, "-fasm"))
552 else if (!strcmp (p
, "-fno-asm"))
554 else if (!strcmp (p
, "-fbuiltin"))
556 else if (!strcmp (p
, "-fno-builtin"))
558 else if (!strcmp (p
, "-fno-ident"))
560 else if (!strcmp (p
, "-fident"))
562 else if (!strcmp (p
, "-ansi"))
563 flag_no_asm
= 1, flag_no_nonansi_builtin
= 1, dollars_in_ident
= 0;
564 else if (!strcmp (p
, "-Wimplicit"))
566 else if (!strcmp (p
, "-Wno-implicit"))
568 else if (!strcmp (p
, "-Wwrite-strings"))
569 warn_write_strings
= 1;
570 else if (!strcmp (p
, "-Wno-write-strings"))
571 warn_write_strings
= 0;
572 else if (!strcmp (p
, "-Wcast-qual"))
574 else if (!strcmp (p
, "-Wno-cast-qual"))
576 else if (!strcmp (p
, "-Wpointer-arith"))
577 warn_pointer_arith
= 1;
578 else if (!strcmp (p
, "-Wno-pointer-arith"))
579 warn_pointer_arith
= 0;
580 else if (!strcmp (p
, "-Wstrict-prototypes"))
581 warn_strict_prototypes
= 1;
582 else if (!strcmp (p
, "-Wno-strict-prototypes"))
583 warn_strict_prototypes
= 0;
584 else if (!strcmp (p
, "-Wmissing-prototypes"))
585 warn_missing_prototypes
= 1;
586 else if (!strcmp (p
, "-Wno-missing-prototypes"))
587 warn_missing_prototypes
= 0;
588 else if (!strcmp (p
, "-Wredundant-decls"))
589 warn_redundant_decls
= 1;
590 else if (!strcmp (p
, "-Wno-redundant-decls"))
591 warn_redundant_decls
= 0;
592 else if (!strcmp (p
, "-Wnested-externs"))
593 warn_nested_externs
= 1;
594 else if (!strcmp (p
, "-Wno-nested-externs"))
595 warn_nested_externs
= 0;
596 else if (!strcmp (p
, "-Wtraditional"))
597 warn_traditional
= 1;
598 else if (!strcmp (p
, "-Wno-traditional"))
599 warn_traditional
= 0;
600 else if (!strcmp (p
, "-Wformat"))
602 else if (!strcmp (p
, "-Wno-format"))
604 else if (!strcmp (p
, "-Wchar-subscripts"))
605 warn_char_subscripts
= 1;
606 else if (!strcmp (p
, "-Wno-char-subscripts"))
607 warn_char_subscripts
= 0;
608 else if (!strcmp (p
, "-Wconversion"))
610 else if (!strcmp (p
, "-Wno-conversion"))
612 else if (!strcmp (p
, "-Wparentheses"))
613 warn_parentheses
= 1;
614 else if (!strcmp (p
, "-Wno-parentheses"))
615 warn_parentheses
= 0;
616 else if (!strcmp (p
, "-Wcomment"))
617 ; /* cpp handles this one. */
618 else if (!strcmp (p
, "-Wno-comment"))
619 ; /* cpp handles this one. */
620 else if (!strcmp (p
, "-Wcomments"))
621 ; /* cpp handles this one. */
622 else if (!strcmp (p
, "-Wno-comments"))
623 ; /* cpp handles this one. */
624 else if (!strcmp (p
, "-Wtrigraphs"))
625 ; /* cpp handles this one. */
626 else if (!strcmp (p
, "-Wno-trigraphs"))
627 ; /* cpp handles this one. */
628 else if (!strcmp (p
, "-Wimport"))
629 ; /* cpp handles this one. */
630 else if (!strcmp (p
, "-Wno-import"))
631 ; /* cpp handles this one. */
632 else if (!strcmp (p
, "-Wall"))
635 warn_uninitialized
= 1;
637 warn_return_type
= 1;
641 warn_char_subscripts
= 1;
642 warn_parentheses
= 1;
650 /* Hooks for print_node. */
663 print_lang_identifier (file
, node
, indent
)
668 print_node (file
, "global", IDENTIFIER_GLOBAL_VALUE (node
), indent
+ 4);
669 print_node (file
, "local", IDENTIFIER_LOCAL_VALUE (node
), indent
+ 4);
670 print_node (file
, "label", IDENTIFIER_LABEL_VALUE (node
), indent
+ 4);
671 print_node (file
, "implicit", IDENTIFIER_IMPLICIT_DECL (node
), indent
+ 4);
672 print_node (file
, "error locus", IDENTIFIER_ERROR_LOCUS (node
), indent
+ 4);
675 /* Create a new `struct binding_level'. */
678 struct binding_level
*
679 make_binding_level ()
682 return (struct binding_level
*) xmalloc (sizeof (struct binding_level
));
685 /* Nonzero if we are currently in the global binding level. */
690 return current_binding_level
== global_binding_level
;
696 keep_next_level_flag
= 1;
699 /* Nonzero if the current level needs to have a BLOCK made. */
704 return ((current_binding_level
->keep_if_subblocks
705 && current_binding_level
->blocks
!= 0)
706 || current_binding_level
->keep
707 || current_binding_level
->names
!= 0
708 || (current_binding_level
->tags
!= 0
709 && !current_binding_level
->tag_transparent
));
712 /* Identify this binding level as a level of parameters.
713 DEFINITION_FLAG is 1 for a definition, 0 for a declaration. */
716 declare_parm_level (definition_flag
)
719 current_binding_level
->parm_flag
= 1 + definition_flag
;
722 /* Nonzero if currently making parm declarations. */
727 return current_binding_level
->parm_flag
;
730 /* Enter a new binding level.
731 If TAG_TRANSPARENT is nonzero, do so only for the name space of variables,
732 not for that of tags. */
735 pushlevel (tag_transparent
)
738 register struct binding_level
*newlevel
= NULL_BINDING_LEVEL
;
740 /* If this is the top level of a function,
741 just make sure that NAMED_LABELS is 0. */
743 if (current_binding_level
== global_binding_level
)
748 /* Reuse or create a struct for this binding level. */
750 if (free_binding_level
)
752 newlevel
= free_binding_level
;
753 free_binding_level
= free_binding_level
->level_chain
;
757 newlevel
= make_binding_level ();
760 /* Add this level to the front of the chain (stack) of levels that
763 *newlevel
= clear_binding_level
;
764 newlevel
->tag_transparent
766 || (current_binding_level
767 ? current_binding_level
->subblocks_tag_transparent
769 newlevel
->level_chain
= current_binding_level
;
770 current_binding_level
= newlevel
;
771 newlevel
->keep
= keep_next_level_flag
;
772 keep_next_level_flag
= 0;
773 newlevel
->keep_if_subblocks
= keep_next_if_subblocks
;
774 keep_next_if_subblocks
= 0;
777 /* Exit a binding level.
778 Pop the level off, and restore the state of the identifier-decl mappings
779 that were in effect when this level was entered.
781 If KEEP is nonzero, this level had explicit declarations, so
782 and create a "block" (a BLOCK node) for the level
783 to record its declarations and subblocks for symbol table output.
785 If FUNCTIONBODY is nonzero, this level is the body of a function,
786 so create a block as if KEEP were set and also clear out all
789 If REVERSE is nonzero, reverse the order of decls before putting
790 them into the BLOCK. */
793 poplevel (keep
, reverse
, functionbody
)
799 /* The chain of decls was accumulated in reverse order.
800 Put it into forward order, just for cleanliness. */
802 tree tags
= current_binding_level
->tags
;
803 tree subblocks
= current_binding_level
->blocks
;
807 keep
|= current_binding_level
->keep
;
809 /* This warning is turned off because it causes warnings for
810 declarations like `extern struct foo *x'. */
812 /* Warn about incomplete structure types in this level. */
813 for (link
= tags
; link
; link
= TREE_CHAIN (link
))
814 if (TYPE_SIZE (TREE_VALUE (link
)) == 0)
816 tree type
= TREE_VALUE (link
);
818 switch (TREE_CODE (type
))
821 errmsg
= "`struct %s' incomplete in scope ending here";
824 errmsg
= "`union %s' incomplete in scope ending here";
827 errmsg
= "`enum %s' incomplete in scope ending here";
830 if (TREE_CODE (TYPE_NAME (type
)) == IDENTIFIER_NODE
)
831 error (errmsg
, IDENTIFIER_POINTER (TYPE_NAME (type
)));
833 /* If this type has a typedef-name, the TYPE_NAME is a TYPE_DECL. */
834 error (errmsg
, IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type
))));
838 /* Get the decls in the order they were written.
839 Usually current_binding_level->names is in reverse order.
840 But parameter decls were previously put in forward order. */
843 current_binding_level
->names
844 = decls
= nreverse (current_binding_level
->names
);
846 decls
= current_binding_level
->names
;
848 /* Output any nested inline functions within this block
849 if they weren't already output. */
851 for (decl
= decls
; decl
; decl
= TREE_CHAIN (decl
))
852 if (TREE_CODE (decl
) == FUNCTION_DECL
853 && ! TREE_ASM_WRITTEN (decl
)
854 && DECL_INITIAL (decl
) != 0
855 && TREE_ADDRESSABLE (decl
))
856 output_inline_function (decl
);
858 /* If there were any declarations or structure tags in that level,
859 or if this level is a function body,
860 create a BLOCK to record them for the life of this function. */
862 if (keep
|| functionbody
863 || (current_binding_level
->keep_if_subblocks
&& subblocks
!= 0))
864 block
= build_block (keep
? decls
: NULL_TREE
, keep
? tags
: NULL_TREE
,
865 subblocks
, NULL_TREE
, NULL_TREE
);
867 /* In each subblock, record that this is its superior. */
869 for (link
= subblocks
; link
; link
= TREE_CHAIN (link
))
870 BLOCK_SUPERCONTEXT (link
) = block
;
872 /* Clear out the meanings of the local variables of this level. */
874 for (link
= decls
; link
; link
= TREE_CHAIN (link
))
876 if (DECL_NAME (link
) != 0)
878 /* If the ident. was used or addressed via a local extern decl,
879 don't forget that fact. */
880 if (TREE_EXTERNAL (link
))
882 if (TREE_USED (link
))
883 TREE_USED (DECL_NAME (link
)) = 1;
884 if (TREE_ADDRESSABLE (link
))
885 TREE_ADDRESSABLE (DECL_ASSEMBLER_NAME (link
)) = 1;
887 IDENTIFIER_LOCAL_VALUE (DECL_NAME (link
)) = 0;
891 /* Restore all name-meanings of the outer levels
892 that were shadowed by this level. */
894 for (link
= current_binding_level
->shadowed
; link
; link
= TREE_CHAIN (link
))
895 IDENTIFIER_LOCAL_VALUE (TREE_PURPOSE (link
)) = TREE_VALUE (link
);
897 /* If the level being exited is the top level of a function,
898 check over all the labels, and clear out the current
899 (function local) meanings of their names. */
903 /* If this is the top level block of a function,
904 the vars are the function's parameters.
905 Don't leave them in the BLOCK because they are
906 found in the FUNCTION_DECL instead. */
908 BLOCK_VARS (block
) = 0;
910 /* Clear out the definitions of all label names,
911 since their scopes end here,
912 and add them to BLOCK_VARS. */
914 for (link
= named_labels
; link
; link
= TREE_CHAIN (link
))
916 register tree label
= TREE_VALUE (link
);
918 if (DECL_INITIAL (label
) == 0)
920 error_with_decl (label
, "label `%s' used but not defined");
921 /* Avoid crashing later. */
922 define_label (input_filename
, lineno
,
925 else if (warn_unused
&& !TREE_USED (label
))
926 warning_with_decl (label
, "label `%s' defined but not used");
927 IDENTIFIER_LABEL_VALUE (DECL_NAME (label
)) = 0;
929 /* Put the labels into the "variables" of the
930 top-level block, so debugger can see them. */
931 TREE_CHAIN (label
) = BLOCK_VARS (block
);
932 BLOCK_VARS (block
) = label
;
936 /* Pop the current level, and free the structure for reuse. */
939 register struct binding_level
*level
= current_binding_level
;
940 current_binding_level
= current_binding_level
->level_chain
;
942 level
->level_chain
= free_binding_level
;
943 free_binding_level
= level
;
946 /* Dispose of the block that we just made inside some higher level. */
948 DECL_INITIAL (current_function_decl
) = block
;
950 current_binding_level
->blocks
951 = chainon (current_binding_level
->blocks
, block
);
952 /* If we did not make a block for the level just exited,
953 any blocks made for inner levels
954 (since they cannot be recorded as subblocks in that level)
955 must be carried forward so they will later become subblocks
956 of something else. */
958 current_binding_level
->blocks
959 = chainon (current_binding_level
->blocks
, subblocks
);
961 /* Set the TYPE_CONTEXTs for all of the tagged types belonging to this
962 binding contour so that they point to the appropriate construct, i.e.
963 either to the current FUNCTION_DECL node, or else to the BLOCK node
966 Note that for tagged types whose scope is just the formal parameter
967 list for some function type specification, we can't properly set
968 their TYPE_CONTEXTs here, because we don't have a pointer to the
969 appropriate FUNCTION_TYPE node readily available to us. For those
970 cases, the TYPE_CONTEXTs of the relevant tagged type nodes get set
971 in `grokdeclarator' as soon as we have created the FUNCTION_TYPE
972 node which will represent the "scope" for these "parameter list local"
977 for (link
= tags
; link
; link
= TREE_CHAIN (link
))
978 TYPE_CONTEXT (TREE_VALUE (link
)) = current_function_decl
;
980 for (link
= tags
; link
; link
= TREE_CHAIN (link
))
981 TYPE_CONTEXT (TREE_VALUE (link
)) = block
;
984 TREE_USED (block
) = 1;
991 register struct binding_level
*newlevel
;
993 /* Reuse or create a struct for this binding level. */
995 if (free_binding_level
)
997 newlevel
= free_binding_level
;
998 free_binding_level
= free_binding_level
->level_chain
;
1002 newlevel
= make_binding_level ();
1005 /* Add this level to the front of the chain (stack) of label levels. */
1007 newlevel
->level_chain
= label_level_chain
;
1008 label_level_chain
= newlevel
;
1010 newlevel
->names
= named_labels
;
1011 newlevel
->shadowed
= shadowed_labels
;
1013 shadowed_labels
= 0;
1019 register struct binding_level
*level
= label_level_chain
;
1022 /* Clear out the definitions of the declared labels in this level.
1023 Leave in the list any ordinary, non-declared labels. */
1024 for (link
= named_labels
, prev
= 0; link
;)
1026 if (C_DECLARED_LABEL_FLAG (TREE_VALUE (link
)))
1028 if (DECL_SOURCE_LINE (TREE_VALUE (link
)) == 0)
1030 error_with_decl ("label `%s' used but not defined",
1032 /* Avoid crashing later. */
1033 define_label (input_filename
, lineno
,
1034 DECL_NAME (TREE_VALUE (link
)));
1036 else if (warn_unused
&& !TREE_USED (TREE_VALUE (link
)))
1037 warning_with_decl (TREE_VALUE (link
),
1038 "label `%s' defined but not used");
1039 IDENTIFIER_LABEL_VALUE (DECL_NAME (TREE_VALUE (link
))) = 0;
1041 /* Delete this element from the list. */
1042 link
= TREE_CHAIN (link
);
1044 TREE_CHAIN (prev
) = link
;
1046 named_labels
= link
;
1051 link
= TREE_CHAIN (link
);
1055 /* Bring back all the labels that were shadowed. */
1056 for (link
= shadowed_labels
; link
; link
= TREE_CHAIN (link
))
1057 if (DECL_NAME (TREE_VALUE (link
)) != 0)
1058 IDENTIFIER_LABEL_VALUE (DECL_NAME (TREE_VALUE (link
)))
1059 = TREE_VALUE (link
);
1061 named_labels
= chainon (named_labels
, level
->names
);
1062 shadowed_labels
= level
->shadowed
;
1064 /* Pop the current level, and free the structure for reuse. */
1065 label_level_chain
= label_level_chain
->level_chain
;
1066 level
->level_chain
= free_binding_level
;
1067 free_binding_level
= level
;
1070 /* Push a definition or a declaration of struct, union or enum tag "name".
1071 "type" should be the type node.
1072 We assume that the tag "name" is not already defined.
1074 Note that the definition may really be just a forward reference.
1075 In that case, the TYPE_SIZE will be zero. */
1078 pushtag (name
, type
)
1081 register struct binding_level
*b
;
1083 /* Find the proper binding level for this type tag. */
1085 for (b
= current_binding_level
; b
->tag_transparent
; b
= b
->level_chain
)
1090 /* Record the identifier as the type's name if it has none. */
1092 if (TYPE_NAME (type
) == 0)
1093 TYPE_NAME (type
) = name
;
1096 if (b
== global_binding_level
)
1097 b
->tags
= perm_tree_cons (name
, type
, b
->tags
);
1099 b
->tags
= saveable_tree_cons (name
, type
, b
->tags
);
1101 /* Create a fake NULL-named TYPE_DECL node whose TREE_TYPE will be the
1102 tagged type we just added to the current binding level. This fake
1103 NULL-named TYPE_DECL node helps dwarfout.c to know when it needs
1104 to output a a representation of a tagged type, and it also gives
1105 us a convenient place to record the "scope start" address for the
1108 TYPE_STUB_DECL (type
) = pushdecl (build_decl (TYPE_DECL
, NULL_TREE
, type
));
1111 /* Handle when a new declaration NEWDECL
1112 has the same name as an old one OLDDECL
1113 in the same binding contour.
1114 Prints an error message if appropriate.
1116 If safely possible, alter OLDDECL to look like NEWDECL, and return 1.
1117 Otherwise, return 0. */
1120 duplicate_decls (newdecl
, olddecl
)
1121 register tree newdecl
, olddecl
;
1123 int types_match
= comptypes (TREE_TYPE (newdecl
), TREE_TYPE (olddecl
));
1124 int new_is_definition
= (TREE_CODE (newdecl
) == FUNCTION_DECL
1125 && DECL_INITIAL (newdecl
) != 0);
1126 tree oldtype
= TREE_TYPE (olddecl
);
1127 tree newtype
= TREE_TYPE (newdecl
);
1129 if (TREE_CODE (newtype
) == ERROR_MARK
1130 || TREE_CODE (oldtype
) == ERROR_MARK
)
1133 /* New decl is completely inconsistent with the old one =>
1134 tell caller to replace the old one.
1135 This is always an error except in the case of shadowing a builtin. */
1136 if (TREE_CODE (olddecl
) != TREE_CODE (newdecl
))
1138 if (TREE_CODE (olddecl
) == FUNCTION_DECL
1139 && DECL_BUILT_IN (olddecl
))
1141 /* If you declare a built-in function name as static, the
1142 built-in definition is overridden,
1143 but optionally warn this was a bad choice of name. */
1144 if (!TREE_PUBLIC (newdecl
))
1147 warning_with_decl (newdecl
, "shadowing built-in function `%s'");
1149 /* Likewise, if the built-in is not ansi, then programs can
1150 override it even globally without an error. */
1151 else if (DECL_BUILT_IN_NONANSI (olddecl
))
1152 warning_with_decl (newdecl
,
1153 "built-in function `%s' declared as non-function");
1155 error_with_decl (newdecl
,
1156 "built-in function `%s' declared as non-function");
1158 else if (TREE_CODE (olddecl
) == FUNCTION_DECL
1159 && DECL_BUILT_IN_NONANSI (olddecl
))
1161 /* If overriding decl is static,
1162 optionally warn this was a bad choice of name. */
1163 if (!TREE_PUBLIC (newdecl
))
1166 warning_with_decl (newdecl
, "shadowing library function `%s'");
1168 /* Otherwise, always warn. */
1170 warning_with_decl (newdecl
,
1171 "library function `%s' declared as non-function");
1175 error_with_decl (newdecl
, "`%s' redeclared as different kind of symbol");
1176 error_with_decl (olddecl
, "previous declaration of `%s'");
1182 /* For real parm decl following a forward decl,
1183 return 1 so old decl will be reused. */
1184 if (types_match
&& TREE_CODE (newdecl
) == PARM_DECL
1185 && TREE_ASM_WRITTEN (olddecl
) && ! TREE_ASM_WRITTEN (newdecl
))
1188 /* The new declaration is the same kind of object as the old one.
1189 The declarations may partially match. Print warnings if they don't
1190 match enough. Ultimately, copy most of the information from the new
1191 decl to the old one, and keep using the old one. */
1193 if (flag_traditional
&& TREE_CODE (newdecl
) == FUNCTION_DECL
1194 && IDENTIFIER_IMPLICIT_DECL (DECL_NAME (newdecl
)) == olddecl
1195 && DECL_INITIAL (olddecl
) == 0)
1196 /* If -traditional, avoid error for redeclaring fcn
1197 after implicit decl. */
1199 else if (TREE_CODE (olddecl
) == FUNCTION_DECL
1200 && DECL_BUILT_IN (olddecl
))
1202 /* A function declaration for a built-in function. */
1203 if (!TREE_PUBLIC (newdecl
))
1205 /* If you declare a built-in function name as static, the
1206 built-in definition is overridden,
1207 but optionally warn this was a bad choice of name. */
1209 warning_with_decl (newdecl
, "shadowing built-in function `%s'");
1210 /* Discard the old built-in function. */
1213 else if (!types_match
)
1215 /* Accept the return type of the new declaration if same modes. */
1216 tree oldreturntype
= TREE_TYPE (TREE_TYPE (olddecl
));
1217 tree newreturntype
= TREE_TYPE (TREE_TYPE (newdecl
));
1218 if (TYPE_MODE (oldreturntype
) == TYPE_MODE (newreturntype
))
1220 TREE_TYPE (TREE_TYPE (olddecl
)) = newreturntype
;
1221 types_match
= comptypes (TREE_TYPE (newdecl
), TREE_TYPE (olddecl
));
1223 TREE_TYPE (TREE_TYPE (olddecl
)) = oldreturntype
;
1228 /* If types don't match for a built-in, throw away the built-in. */
1229 warning_with_decl (newdecl
, "conflicting types for built-in function `%s'");
1233 else if (TREE_CODE (olddecl
) == FUNCTION_DECL
1234 && DECL_SOURCE_LINE (olddecl
) == 0)
1236 /* A function declaration for a predeclared function
1237 that isn't actually built in. */
1238 if (!TREE_PUBLIC (newdecl
))
1240 /* If you declare a it as static, the
1241 default definition is overridden. */
1244 else if (!types_match
)
1246 /* If the types don't match, preserve volatility indication.
1247 Later on, we will discard everything else about the
1248 default declaration. */
1249 TREE_THIS_VOLATILE (newdecl
) |= TREE_THIS_VOLATILE (olddecl
);
1252 /* Permit char *foo () to match void *foo (...) if not pedantic,
1253 if one of them came from a system header file. */
1254 else if (!types_match
1255 && TREE_CODE (olddecl
) == FUNCTION_DECL
1256 && TREE_CODE (newdecl
) == FUNCTION_DECL
1257 && TREE_CODE (TREE_TYPE (oldtype
)) == POINTER_TYPE
1258 && TREE_CODE (TREE_TYPE (newtype
)) == POINTER_TYPE
1259 && (DECL_IN_SYSTEM_HEADER (olddecl
)
1260 || DECL_IN_SYSTEM_HEADER (newdecl
))
1261 && ((TREE_TYPE (TREE_TYPE (newtype
)) == void_type_node
1262 && TYPE_ARG_TYPES (oldtype
) == 0
1263 && self_promoting_args_p (TYPE_ARG_TYPES (newtype
))
1264 && TREE_TYPE (TREE_TYPE (oldtype
)) == char_type_node
)
1266 (TREE_TYPE (TREE_TYPE (newtype
)) == char_type_node
1267 && TYPE_ARG_TYPES (newtype
) == 0
1268 && self_promoting_args_p (TYPE_ARG_TYPES (oldtype
))
1269 && TREE_TYPE (TREE_TYPE (oldtype
)) == void_type_node
)))
1272 pedwarn_with_decl (newdecl
, "conflicting types for `%s'");
1273 /* Make sure we keep void * as ret type, not char *. */
1274 if (TREE_TYPE (TREE_TYPE (oldtype
)) == void_type_node
)
1275 TREE_TYPE (newdecl
) = newtype
= oldtype
;
1277 else if (!types_match
1278 /* Permit char *foo (int, ...); followed by char *foo ();
1280 && ! (TREE_CODE (olddecl
) == FUNCTION_DECL
1282 /* Return types must still match. */
1283 && comptypes (TREE_TYPE (oldtype
),
1284 TREE_TYPE (newtype
))
1285 && TYPE_ARG_TYPES (newtype
) == 0))
1287 error_with_decl (newdecl
, "conflicting types for `%s'");
1288 /* Check for function type mismatch
1289 involving an empty arglist vs a nonempty one. */
1290 if (TREE_CODE (olddecl
) == FUNCTION_DECL
1291 && comptypes (TREE_TYPE (oldtype
),
1292 TREE_TYPE (newtype
))
1293 && ((TYPE_ARG_TYPES (oldtype
) == 0
1294 && DECL_INITIAL (olddecl
) == 0)
1296 (TYPE_ARG_TYPES (newtype
) == 0
1297 && DECL_INITIAL (newdecl
) == 0)))
1299 /* Classify the problem further. */
1300 register tree t
= TYPE_ARG_TYPES (oldtype
);
1302 t
= TYPE_ARG_TYPES (newtype
);
1303 for (; t
; t
= TREE_CHAIN (t
))
1305 register tree type
= TREE_VALUE (t
);
1307 if (TREE_CHAIN (t
) == 0 && type
!= void_type_node
)
1309 error ("A parameter list with an ellipsis can't match");
1310 error ("an empty parameter name list declaration.");
1314 if (type
== float_type_node
1315 || (TREE_CODE (type
) == INTEGER_TYPE
1316 && (TYPE_PRECISION (type
)
1317 < TYPE_PRECISION (integer_type_node
))))
1319 error ("An argument type that has a default promotion");
1320 error ("can't match an empty parameter name list declaration.");
1325 error_with_decl (olddecl
, "previous declaration of `%s'");
1329 char *errmsg
= redeclaration_error_message (newdecl
, olddecl
);
1332 error_with_decl (newdecl
, errmsg
);
1333 error_with_decl (olddecl
,
1334 "`%s' previously declared here");
1336 else if (TREE_CODE (olddecl
) == FUNCTION_DECL
1337 && DECL_INITIAL (olddecl
) != 0
1338 && TYPE_ARG_TYPES (oldtype
) == 0
1339 && TYPE_ARG_TYPES (newtype
) != 0)
1341 register tree type
, parm
;
1343 /* Prototype decl follows defn w/o prototype. */
1345 for (parm
= TYPE_ACTUAL_ARG_TYPES (oldtype
),
1346 type
= TYPE_ARG_TYPES (newtype
),
1348 (TREE_VALUE (parm
) != void_type_node
1349 || TREE_VALUE (type
) != void_type_node
);
1350 parm
= TREE_CHAIN (parm
), type
= TREE_CHAIN (type
), nargs
++)
1352 if (TREE_VALUE (parm
) == void_type_node
1353 || TREE_VALUE (type
) == void_type_node
)
1355 errmsg
= "prototype for `%s' follows and number of arguments";
1358 /* Type for passing arg must be consistent
1359 with that declared for the arg. */
1360 if (! comptypes (TREE_VALUE (parm
), TREE_VALUE (type
))
1361 /* If -traditional, allow `unsigned int' instead of `int'
1362 in the prototype. */
1363 && (! (flag_traditional
1364 && TREE_VALUE (parm
) == integer_type_node
1365 && TREE_VALUE (type
) == unsigned_type_node
)))
1367 errmsg
= "prototype for `%s' follows and argument %d";
1373 error_with_decl (newdecl
, errmsg
, nargs
);
1374 error_with_decl (olddecl
,
1375 "doesn't match non-prototype definition here");
1379 warning_with_decl (newdecl
, "prototype for `%s' follows");
1380 warning_with_decl (olddecl
, "non-prototype definition here");
1383 /* Warn about mismatches in various flags. */
1386 /* Warn if function is now inline
1387 but was previously declared not inline and has been called. */
1388 if (TREE_CODE (olddecl
) == FUNCTION_DECL
1389 && ! TREE_INLINE (olddecl
) && TREE_INLINE (newdecl
)
1390 && TREE_USED (olddecl
))
1391 warning_with_decl (newdecl
,
1392 "`%s' declared inline after being called");
1393 if (TREE_CODE (olddecl
) == FUNCTION_DECL
1394 && ! TREE_INLINE (olddecl
) && TREE_INLINE (newdecl
)
1395 && DECL_INITIAL (olddecl
) != 0)
1396 warning_with_decl (newdecl
,
1397 "`%s' declared inline after its definition");
1398 /* It is nice to warn when a function is declared
1399 global first and then static. */
1400 if (TREE_CODE (olddecl
) == FUNCTION_DECL
1401 && TREE_PUBLIC (olddecl
)
1402 && !TREE_PUBLIC (newdecl
))
1403 warning_with_decl (newdecl
, "static declaration for `%s' follows non-static");
1405 /* These bits are logically part of the type, for variables.
1406 But not for functions
1407 (where qualifiers are not valid ANSI anyway). */
1408 if (pedantic
&& TREE_CODE (olddecl
) != FUNCTION_DECL
1409 && (TREE_READONLY (newdecl
) != TREE_READONLY (olddecl
)
1410 || TREE_THIS_VOLATILE (newdecl
) != TREE_THIS_VOLATILE (olddecl
)))
1411 pedwarn_with_decl (newdecl
, "type qualifiers for `%s' conflict with previous decl");
1415 /* Copy all the DECL_... slots specified in the new decl
1416 except for any that we copy here from the old type.
1418 Past this point, we don't change OLDTYPE and NEWTYPE
1419 even if we change the types of NEWDECL and OLDDECL. */
1423 /* Merge the data types specified in the two decls. */
1424 if (TREE_CODE (newdecl
) != FUNCTION_DECL
|| !DECL_BUILT_IN (olddecl
))
1426 = TREE_TYPE (olddecl
)
1427 = common_type (newtype
, oldtype
);
1429 /* Lay the type out, unless already done. */
1430 if (oldtype
!= TREE_TYPE (newdecl
))
1432 if (TREE_TYPE (newdecl
) != error_mark_node
)
1433 layout_type (TREE_TYPE (newdecl
));
1434 if (TREE_CODE (newdecl
) != FUNCTION_DECL
1435 && TREE_CODE (newdecl
) != TYPE_DECL
1436 && TREE_CODE (newdecl
) != CONST_DECL
)
1437 layout_decl (newdecl
, 0);
1441 /* Since the type is OLDDECL's, make OLDDECL's size go with. */
1442 DECL_SIZE (newdecl
) = DECL_SIZE (olddecl
);
1443 if (TREE_CODE (olddecl
) != FUNCTION_DECL
)
1444 if (DECL_ALIGN (olddecl
) > DECL_ALIGN (newdecl
))
1445 DECL_ALIGN (newdecl
) = DECL_ALIGN (olddecl
);
1448 /* Merge the type qualifiers. */
1449 if (DECL_BUILT_IN_NONANSI (olddecl
) && TREE_THIS_VOLATILE (olddecl
)
1450 && !TREE_THIS_VOLATILE (newdecl
))
1451 TREE_THIS_VOLATILE (olddecl
) = 0;
1452 if (TREE_READONLY (newdecl
))
1453 TREE_READONLY (olddecl
) = 1;
1454 if (TREE_THIS_VOLATILE (newdecl
))
1456 TREE_THIS_VOLATILE (olddecl
) = 1;
1457 if (TREE_CODE (newdecl
) == VAR_DECL
)
1458 make_var_volatile (newdecl
);
1461 /* Keep source location of definition rather than declaration. */
1462 if (DECL_INITIAL (newdecl
) == 0 && DECL_INITIAL (olddecl
) != 0)
1464 DECL_SOURCE_LINE (newdecl
) = DECL_SOURCE_LINE (olddecl
);
1465 DECL_SOURCE_FILE (newdecl
) = DECL_SOURCE_FILE (olddecl
);
1468 /* Merge the unused-warning information. */
1469 if (DECL_IN_SYSTEM_HEADER (olddecl
))
1470 DECL_IN_SYSTEM_HEADER (newdecl
) = 1;
1471 else if (DECL_IN_SYSTEM_HEADER (newdecl
))
1472 DECL_IN_SYSTEM_HEADER (olddecl
) = 1;
1474 /* Merge the initialization information. */
1475 if (DECL_INITIAL (newdecl
) == 0)
1476 DECL_INITIAL (newdecl
) = DECL_INITIAL (olddecl
);
1478 /* Keep the old rtl since we can safely use it. */
1479 DECL_RTL (newdecl
) = DECL_RTL (olddecl
);
1481 /* If cannot merge, then use the new type and qualifiers,
1482 and don't preserve the old rtl. */
1485 TREE_TYPE (olddecl
) = TREE_TYPE (newdecl
);
1486 TREE_READONLY (olddecl
) = TREE_READONLY (newdecl
);
1487 TREE_THIS_VOLATILE (olddecl
) = TREE_THIS_VOLATILE (newdecl
);
1488 TREE_SIDE_EFFECTS (olddecl
) = TREE_SIDE_EFFECTS (newdecl
);
1491 /* Merge the storage class information. */
1492 /* For functions, static overrides non-static. */
1493 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
1495 TREE_PUBLIC (newdecl
) &= TREE_PUBLIC (olddecl
);
1496 /* This is since we don't automatically
1497 copy the attributes of NEWDECL into OLDDECL. */
1498 TREE_PUBLIC (olddecl
) = TREE_PUBLIC (newdecl
);
1499 /* If this clears `static', clear it in the identifier too. */
1500 if (! TREE_PUBLIC (olddecl
))
1501 TREE_PUBLIC (DECL_NAME (olddecl
)) = 0;
1503 if (TREE_EXTERNAL (newdecl
))
1505 TREE_STATIC (newdecl
) = TREE_STATIC (olddecl
);
1506 TREE_EXTERNAL (newdecl
) = TREE_EXTERNAL (olddecl
);
1507 /* An extern decl does not override previous storage class. */
1508 TREE_PUBLIC (newdecl
) = TREE_PUBLIC (olddecl
);
1512 TREE_STATIC (olddecl
) = TREE_STATIC (newdecl
);
1513 TREE_EXTERNAL (olddecl
) = 0;
1514 TREE_PUBLIC (olddecl
) = TREE_PUBLIC (newdecl
);
1516 /* If either decl says `inline', this fn is inline,
1517 unless its definition was passed already. */
1518 if (TREE_INLINE (newdecl
) && DECL_INITIAL (olddecl
) == 0)
1519 TREE_INLINE (olddecl
) = 1;
1521 /* Get rid of any built-in function if new arg types don't match it
1522 or if we have a function definition. */
1523 if (TREE_CODE (newdecl
) == FUNCTION_DECL
1524 && DECL_BUILT_IN (olddecl
)
1525 && (!types_match
|| new_is_definition
))
1527 TREE_TYPE (olddecl
) = TREE_TYPE (newdecl
);
1528 DECL_BUILT_IN (olddecl
) = 0;
1531 /* If redeclaring a builtin function, and not a definition,
1533 Also preserve various other info from the definition. */
1534 if (TREE_CODE (newdecl
) == FUNCTION_DECL
&& !new_is_definition
)
1536 if (DECL_BUILT_IN (olddecl
))
1538 DECL_BUILT_IN (newdecl
) = 1;
1539 DECL_SET_FUNCTION_CODE (newdecl
, DECL_FUNCTION_CODE (olddecl
));
1542 DECL_FRAME_SIZE (newdecl
) = DECL_FRAME_SIZE (olddecl
);
1544 DECL_RESULT (newdecl
) = DECL_RESULT (olddecl
);
1545 DECL_INITIAL (newdecl
) = DECL_INITIAL (olddecl
);
1546 DECL_SAVED_INSNS (newdecl
) = DECL_SAVED_INSNS (olddecl
);
1547 DECL_ARGUMENTS (newdecl
) = DECL_ARGUMENTS (olddecl
);
1550 bcopy ((char *) newdecl
+ sizeof (struct tree_common
),
1551 (char *) olddecl
+ sizeof (struct tree_common
),
1552 sizeof (struct tree_decl
) - sizeof (struct tree_common
));
1557 /* Record a decl-node X as belonging to the current lexical scope.
1558 Check for errors (such as an incompatible declaration for the same
1559 name already seen in the same scope).
1561 Returns either X or an old decl for the same name.
1562 If an old decl is returned, it may have been smashed
1563 to agree with what X says. */
1570 register tree name
= DECL_NAME (x
);
1571 register struct binding_level
*b
= current_binding_level
;
1573 DECL_CONTEXT (x
) = current_function_decl
;
1574 /* A local declaration for a function doesn't constitute nesting. */
1575 if (TREE_CODE (x
) == FUNCTION_DECL
&& DECL_INITIAL (x
) == 0)
1576 DECL_CONTEXT (x
) = 0;
1578 if (warn_nested_externs
&& TREE_EXTERNAL (x
) && b
!= global_binding_level
1579 && x
!= IDENTIFIER_IMPLICIT_DECL (name
))
1580 warning ("nested extern declaration of `%s'", IDENTIFIER_POINTER (name
));
1587 t
= lookup_name_current_level (name
);
1588 if (t
!= 0 && t
== error_mark_node
)
1589 /* error_mark_node is 0 for a while during initialization! */
1592 error_with_decl (x
, "`%s' used prior to declaration");
1597 file
= DECL_SOURCE_FILE (t
);
1598 line
= DECL_SOURCE_LINE (t
);
1601 if (t
!= 0 && duplicate_decls (x
, t
))
1603 if (TREE_CODE (t
) == PARM_DECL
)
1605 /* Don't allow more than one "real" duplicate
1606 of a forward parm decl. */
1607 TREE_ASM_WRITTEN (t
) = TREE_ASM_WRITTEN (x
);
1610 /* If this decl is `static' and an implicit decl was seen previously,
1611 warn. But don't complain if -traditional,
1612 since traditional compilers don't complain. */
1613 if (!flag_traditional
&& TREE_PUBLIC (name
)
1614 && ! TREE_PUBLIC (x
) && ! TREE_EXTERNAL (x
)
1615 /* We used to warn also for explicit extern followed by static,
1616 but sometimes you need to do it that way. */
1617 && IDENTIFIER_IMPLICIT_DECL (name
) != 0)
1619 pedwarn ("`%s' was declared implicitly `extern' and later `static'",
1620 IDENTIFIER_POINTER (name
));
1621 pedwarn_with_file_and_line (file
, line
,
1622 "previous declaration of `%s'",
1623 IDENTIFIER_POINTER (name
));
1625 if (warn_redundant_decls
&& line
!= 0)
1627 warning ("redundant redeclaration of `%s' in same scope",
1628 IDENTIFIER_POINTER (name
));
1629 warning_with_file_and_line (file
, line
,
1630 "previous declaration of `%s'",
1631 IDENTIFIER_POINTER (name
));
1636 /* If we are processing a typedef statement, generate a whole new
1637 ..._TYPE node (which will be just an variant of the existing
1638 ..._TYPE node with identical properties) and then install the
1639 TYPE_DECL node generated to represent the typedef name as the
1640 TYPE_NAME of this brand new (duplicate) ..._TYPE node.
1642 The whole point here is to end up with a situation where each
1643 and every ..._TYPE node the compiler creates will be uniquely
1644 associated with AT MOST one node representing a typedef name.
1645 This way, even though the compiler substitutes corresponding
1646 ..._TYPE nodes for TYPE_DECL (i.e. "typedef name") nodes very
1647 early on, later parts of the compiler can always do the reverse
1648 translation and get back the corresponding typedef name. For
1651 typedef struct S MY_TYPE;
1654 Later parts of the compiler might only know that `object' was of
1655 type `struct S' if if were not for code just below. With this
1656 code however, later parts of the compiler see something like:
1658 struct S' == struct S
1659 typedef struct S' MY_TYPE;
1662 And they can then deduce (from the node for type struct S') that
1663 the original object declaration was:
1667 Being able to do this is important for proper support of protoize,
1668 and also for generating precise symbolic debugging information
1669 which takes full account of the programmer's (typedef) vocabulary.
1671 Obviously, we don't want to generate a duplicate ..._TYPE node if
1672 the TYPE_DECL node that we are now processing really represents a
1673 standard built-in type.
1675 Since all standard types are effectively declared at line zero
1676 in the source file, we can easily check to see if we are working
1677 on a standard type by checking the current value of lineno. */
1679 if (TREE_CODE (x
) == TYPE_DECL
)
1681 if (DECL_SOURCE_LINE (x
) == 0)
1683 if (TYPE_NAME (TREE_TYPE (x
)) == 0)
1684 TYPE_NAME (TREE_TYPE (x
)) = x
;
1688 tree tt
= TREE_TYPE (x
);
1690 tt
= build_type_copy (tt
);
1696 /* Multiple external decls of the same identifier ought to match. */
1698 if (TREE_EXTERNAL (x
) && IDENTIFIER_GLOBAL_VALUE (name
) != 0
1699 && (TREE_EXTERNAL (IDENTIFIER_GLOBAL_VALUE (name
))
1700 || TREE_PUBLIC (IDENTIFIER_GLOBAL_VALUE (name
)))
1701 /* We get warnings about inline functions where they are defined.
1702 Avoid duplicate warnings where they are used. */
1703 && !TREE_INLINE (x
))
1705 if (! comptypes (TREE_TYPE (x
),
1706 TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (name
))))
1708 pedwarn_with_decl (x
,
1709 "type mismatch with previous external decl");
1710 pedwarn_with_decl (IDENTIFIER_GLOBAL_VALUE (name
),
1711 "previous external decl of `%s'");
1715 /* If a function has had an implicit declaration, and then is defined,
1716 make sure they are compatible. */
1718 if (IDENTIFIER_IMPLICIT_DECL (name
) != 0
1719 && IDENTIFIER_GLOBAL_VALUE (name
) == 0
1720 && TREE_CODE (x
) == FUNCTION_DECL
1721 && ! comptypes (TREE_TYPE (x
),
1722 TREE_TYPE (IDENTIFIER_IMPLICIT_DECL (name
))))
1724 warning_with_decl (x
, "type mismatch with previous implicit declaration");
1725 warning_with_decl (IDENTIFIER_IMPLICIT_DECL (name
),
1726 "previous implicit declaration of `%s'");
1729 /* In PCC-compatibility mode, extern decls of vars with no current decl
1730 take effect at top level no matter where they are. */
1731 if (flag_traditional
&& TREE_EXTERNAL (x
)
1732 && lookup_name (name
) == 0)
1734 tree type
= TREE_TYPE (x
);
1736 /* But don't do this if the type contains temporary nodes. */
1739 if (type
== error_mark_node
)
1741 if (! TREE_PERMANENT (type
))
1743 warning_with_decl (x
, "type of external `%s' is not global");
1744 /* By exiting the loop early, we leave TYPE nonzero,
1745 and thus prevent globalization of the decl. */
1748 else if (TREE_CODE (type
) == FUNCTION_TYPE
1749 && TYPE_ARG_TYPES (type
) != 0)
1750 /* The types might not be truly local,
1751 but the list of arg types certainly is temporary.
1752 Since prototypes are nontraditional,
1753 ok not to do the traditional thing. */
1755 type
= TREE_TYPE (type
);
1759 b
= global_binding_level
;
1762 /* This name is new in its binding level.
1763 Install the new declaration and return it. */
1764 if (b
== global_binding_level
)
1766 /* Install a global value. */
1768 /* If the first global decl has external linkage,
1769 warn if we later see static one. */
1770 if (IDENTIFIER_GLOBAL_VALUE (name
) == 0 && TREE_PUBLIC (x
))
1771 TREE_PUBLIC (name
) = 1;
1773 IDENTIFIER_GLOBAL_VALUE (name
) = x
;
1775 /* Don't forget if the function was used via an implicit decl. */
1776 if (IDENTIFIER_IMPLICIT_DECL (name
)
1777 && TREE_USED (IDENTIFIER_IMPLICIT_DECL (name
)))
1778 TREE_USED (x
) = 1, TREE_USED (name
) = 1;
1780 /* Don't forget if its address was taken in that way. */
1781 if (IDENTIFIER_IMPLICIT_DECL (name
)
1782 && TREE_ADDRESSABLE (IDENTIFIER_IMPLICIT_DECL (name
)))
1783 TREE_ADDRESSABLE (x
) = 1;
1785 /* Warn about mismatches against previous implicit decl. */
1786 if (IDENTIFIER_IMPLICIT_DECL (name
) != 0
1787 /* If this real decl matches the implicit, don't complain. */
1788 && ! (TREE_CODE (x
) == FUNCTION_DECL
1789 && TREE_TYPE (TREE_TYPE (x
)) == integer_type_node
))
1790 pedwarn ("`%s' was previously implicitly declared to return `int'",
1791 IDENTIFIER_POINTER (name
));
1793 /* If this decl is `static' and an `extern' was seen previously,
1794 that is erroneous. */
1795 if (TREE_PUBLIC (name
)
1796 && ! TREE_PUBLIC (x
) && ! TREE_EXTERNAL (x
))
1798 /* Okay to declare an ANSI built-in as inline static. */
1799 if (t
!= 0 && DECL_BUILT_IN (t
)
1802 /* Okay to declare a non-ANSI built-in as anything. */
1803 else if (t
!= 0 && DECL_BUILT_IN_NONANSI (t
))
1805 else if (IDENTIFIER_IMPLICIT_DECL (name
))
1806 pedwarn ("`%s' was declared implicitly `extern' and later `static'",
1807 IDENTIFIER_POINTER (name
));
1809 pedwarn ("`%s' was declared `extern' and later `static'",
1810 IDENTIFIER_POINTER (name
));
1815 /* Here to install a non-global value. */
1816 tree oldlocal
= IDENTIFIER_LOCAL_VALUE (name
);
1817 tree oldglobal
= IDENTIFIER_GLOBAL_VALUE (name
);
1818 IDENTIFIER_LOCAL_VALUE (name
) = x
;
1820 /* If this is an extern function declaration, see if we
1821 have a global definition for the function. */
1823 && TREE_EXTERNAL (x
) && !TREE_INLINE (x
)
1825 && TREE_CODE (x
) == FUNCTION_DECL
1826 && TREE_CODE (oldglobal
) == FUNCTION_DECL
)
1828 /* We have one. Their types must agree. */
1829 if (! comptypes (TREE_TYPE (x
),
1830 TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (name
))))
1831 pedwarn_with_decl (x
, "local declaration of `%s' doesn't match global one");
1832 /* If the global one is inline, make the local one inline. */
1833 else if (TREE_INLINE (oldglobal
)
1834 || DECL_BUILT_IN (oldglobal
)
1835 || (TYPE_ARG_TYPES (TREE_TYPE (oldglobal
)) != 0
1836 && TYPE_ARG_TYPES (TREE_TYPE (x
)) == 0))
1837 IDENTIFIER_LOCAL_VALUE (name
) = oldglobal
;
1840 #if 0 /* This case is probably sometimes the right thing to do. */
1841 /* If we have a local external declaration,
1842 then any file-scope declaration should not
1843 have been static. */
1844 if (oldlocal
== 0 && oldglobal
!= 0
1845 && !TREE_PUBLIC (oldglobal
)
1846 && TREE_EXTERNAL (x
) && TREE_PUBLIC (x
))
1847 warning ("`%s' locally external but globally static",
1848 IDENTIFIER_POINTER (name
));
1851 /* If we have a local external declaration,
1852 and no file-scope declaration has yet been seen,
1853 then if we later have a file-scope decl it must not be static. */
1856 && TREE_EXTERNAL (x
)
1859 TREE_PUBLIC (name
) = 1;
1862 /* Warn if shadowing an argument at the top level of the body. */
1863 if (oldlocal
!= 0 && !TREE_EXTERNAL (x
)
1864 /* This warning doesn't apply to the parms of a nested fcn. */
1865 && ! current_binding_level
->parm_flag
1866 /* Check that this is one level down from the parms. */
1867 && current_binding_level
->level_chain
->parm_flag
1868 /* Check that the decl being shadowed
1869 comes from the parm level, one level up. */
1870 && chain_member (oldlocal
, current_binding_level
->level_chain
->names
))
1872 if (TREE_CODE (oldlocal
) == PARM_DECL
)
1873 pedwarn ("declaration of `%s' shadows a parameter",
1874 IDENTIFIER_POINTER (name
));
1876 pedwarn ("declaration of `%s' shadows a symbol from the parameter list",
1877 IDENTIFIER_POINTER (name
));
1880 /* Maybe warn if shadowing something else. */
1881 else if (warn_shadow
&& !TREE_EXTERNAL (x
)
1882 /* No shadow warnings for internally generated vars. */
1883 && !DECL_IGNORED_P (x
)
1884 /* No shadow warnings for vars made for inlining. */
1885 && ! DECL_FROM_INLINE (x
))
1887 char *warnstring
= 0;
1889 if (TREE_CODE (x
) == PARM_DECL
1890 && current_binding_level
->parm_flag
== 1)
1891 /* Don't warn about the parm names in a declaration. */
1893 else if (oldlocal
!= 0 && TREE_CODE (oldlocal
) == PARM_DECL
)
1894 warnstring
= "declaration of `%s' shadows a parameter";
1895 else if (oldlocal
!= 0)
1896 warnstring
= "declaration of `%s' shadows previous local";
1897 else if (IDENTIFIER_GLOBAL_VALUE (name
) != 0
1898 && IDENTIFIER_GLOBAL_VALUE (name
) != error_mark_node
)
1899 warnstring
= "declaration of `%s' shadows global declaration";
1902 warning (warnstring
, IDENTIFIER_POINTER (name
));
1905 /* If storing a local value, there may already be one (inherited).
1906 If so, record it for restoration when this binding level ends. */
1908 b
->shadowed
= tree_cons (name
, oldlocal
, b
->shadowed
);
1911 /* Keep count of variables in this level with incomplete type. */
1912 if (TYPE_SIZE (TREE_TYPE (x
)) == 0)
1916 /* Put decls on list in reverse order.
1917 We will reverse them later if necessary. */
1918 TREE_CHAIN (x
) = b
->names
;
1924 /* Like pushdecl, only it places X in GLOBAL_BINDING_LEVEL, if appropriate. */
1927 pushdecl_top_level (x
)
1931 register struct binding_level
*b
= current_binding_level
;
1933 current_binding_level
= global_binding_level
;
1935 current_binding_level
= b
;
1939 /* Generate an implicit declaration for identifier FUNCTIONID
1940 as a function of type int (). Print a warning if appropriate. */
1943 implicitly_declare (functionid
)
1947 int traditional_warning
= 0;
1948 /* Only one "implicit declaration" warning per identifier. */
1949 int implicit_warning
;
1951 /* Save the decl permanently so we can warn if definition follows. */
1952 push_obstacks_nochange ();
1953 end_temporary_allocation ();
1955 /* We used to reuse an old implicit decl here,
1956 but this loses with inline functions because it can clobber
1957 the saved decl chains. */
1958 /* if (IDENTIFIER_IMPLICIT_DECL (functionid) != 0)
1959 decl = IDENTIFIER_IMPLICIT_DECL (functionid);
1961 decl
= build_decl (FUNCTION_DECL
, functionid
, default_function_type
);
1963 /* Warn of implicit decl following explicit local extern decl.
1964 This is probably a program designed for traditional C. */
1965 if (TREE_PUBLIC (functionid
) && IDENTIFIER_GLOBAL_VALUE (functionid
) == 0)
1966 traditional_warning
= 1;
1968 /* Warn once of an implicit declaration. */
1969 implicit_warning
= (IDENTIFIER_IMPLICIT_DECL (functionid
) == 0);
1971 TREE_EXTERNAL (decl
) = 1;
1972 TREE_PUBLIC (decl
) = 1;
1974 /* Record that we have an implicit decl and this is it. */
1975 IDENTIFIER_IMPLICIT_DECL (functionid
) = decl
;
1977 /* ANSI standard says implicit declarations are in the innermost block.
1978 So we record the decl in the standard fashion.
1979 If flag_traditional is set, pushdecl does it top-level. */
1982 /* This is a no-op in c-lang.c or something real in objc-actions.c. */
1983 maybe_objc_check_decl (decl
);
1985 rest_of_decl_compilation (decl
, NULL_PTR
, 0, 0);
1987 if (warn_implicit
&& implicit_warning
)
1988 warning ("implicit declaration of function `%s'",
1989 IDENTIFIER_POINTER (functionid
));
1990 else if (warn_traditional
&& traditional_warning
)
1991 warning ("function `%s' was previously declared within a block",
1992 IDENTIFIER_POINTER (functionid
));
1994 /* Write a record describing this implicit function declaration to the
1995 prototypes file (if requested). */
1997 gen_aux_info_record (decl
, 0, 1, 0);
2004 /* Return zero if the declaration NEWDECL is valid
2005 when the declaration OLDDECL (assumed to be for the same name)
2006 has already been seen.
2007 Otherwise return an error message format string with a %s
2008 where the identifier should go. */
2011 redeclaration_error_message (newdecl
, olddecl
)
2012 tree newdecl
, olddecl
;
2014 if (TREE_CODE (newdecl
) == TYPE_DECL
)
2016 if (flag_traditional
&& TREE_TYPE (newdecl
) == TREE_TYPE (olddecl
))
2018 return "redefinition of `%s'";
2020 else if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
2022 /* Declarations of functions can insist on internal linkage
2023 but they can't be inconsistent with internal linkage,
2024 so there can be no error on that account.
2025 However defining the same name twice is no good. */
2026 if (DECL_INITIAL (olddecl
) != 0 && DECL_INITIAL (newdecl
) != 0
2027 /* However, defining once as extern inline and a second
2028 time in another way is ok. */
2029 && !(TREE_INLINE (olddecl
) && TREE_EXTERNAL (olddecl
)
2030 && !(TREE_INLINE (newdecl
) && TREE_EXTERNAL (newdecl
))))
2031 return "redefinition of `%s'";
2034 else if (current_binding_level
== global_binding_level
)
2036 /* Objects declared at top level: */
2037 /* If at least one is a reference, it's ok. */
2038 if (TREE_EXTERNAL (newdecl
) || TREE_EXTERNAL (olddecl
))
2040 /* Reject two definitions. */
2041 if (DECL_INITIAL (olddecl
) != 0 && DECL_INITIAL (newdecl
) != 0)
2042 return "redefinition of `%s'";
2043 /* Now we have two tentative defs, or one tentative and one real def. */
2044 /* Insist that the linkage match. */
2045 if (TREE_PUBLIC (olddecl
) != TREE_PUBLIC (newdecl
))
2046 return "conflicting declarations of `%s'";
2049 else if (current_binding_level
->parm_flag
2050 && TREE_ASM_WRITTEN (olddecl
) && !TREE_ASM_WRITTEN (newdecl
))
2054 /* Objects declared with block scope: */
2055 /* Reject two definitions, and reject a definition
2056 together with an external reference. */
2057 if (!(TREE_EXTERNAL (newdecl
) && TREE_EXTERNAL (olddecl
)))
2058 return "redeclaration of `%s'";
2063 /* Get the LABEL_DECL corresponding to identifier ID as a label.
2064 Create one if none exists so far for the current function.
2065 This function is called for both label definitions and label references. */
2071 register tree decl
= IDENTIFIER_LABEL_VALUE (id
);
2073 /* Use a label already defined or ref'd with this name. */
2076 /* But not if it is inherited and wasn't declared to be inheritable. */
2077 if (DECL_CONTEXT (decl
) != current_function_decl
2078 && ! C_DECLARED_LABEL_FLAG (decl
))
2079 return shadow_label (id
);
2083 decl
= build_decl (LABEL_DECL
, id
, void_type_node
);
2085 /* Make sure every label has an rtx. */
2088 /* A label not explicitly declared must be local to where it's ref'd. */
2089 DECL_CONTEXT (decl
) = current_function_decl
;
2091 DECL_MODE (decl
) = VOIDmode
;
2093 /* Say where one reference is to the label,
2094 for the sake of the error if it is not defined. */
2095 DECL_SOURCE_LINE (decl
) = lineno
;
2096 DECL_SOURCE_FILE (decl
) = input_filename
;
2098 IDENTIFIER_LABEL_VALUE (id
) = decl
;
2100 named_labels
= tree_cons (NULL_TREE
, decl
, named_labels
);
2105 /* Make a label named NAME in the current function,
2106 shadowing silently any that may be inherited from containing functions
2107 or containing scopes.
2109 Note that valid use, if the label being shadowed
2110 comes from another scope in the same function,
2111 requires calling declare_nonlocal_label right away. */
2117 register tree decl
= IDENTIFIER_LABEL_VALUE (name
);
2121 shadowed_labels
= tree_cons (NULL_TREE
, decl
, shadowed_labels
);
2122 IDENTIFIER_LABEL_VALUE (name
) = decl
= 0;
2125 return lookup_label (name
);
2128 /* Define a label, specifying the location in the source file.
2129 Return the LABEL_DECL node for the label, if the definition is valid.
2130 Otherwise return 0. */
2133 define_label (filename
, line
, name
)
2138 tree decl
= lookup_label (name
);
2140 /* If label with this name is known from an outer context, shadow it. */
2141 if (decl
!= 0 && DECL_CONTEXT (decl
) != current_function_decl
)
2143 shadowed_labels
= tree_cons (NULL_TREE
, decl
, shadowed_labels
);
2144 IDENTIFIER_LABEL_VALUE (name
) = 0;
2145 decl
= lookup_label (name
);
2148 if (DECL_INITIAL (decl
) != 0)
2150 error_with_decl (decl
, "duplicate label `%s'");
2155 /* Mark label as having been defined. */
2156 DECL_INITIAL (decl
) = error_mark_node
;
2157 /* Say where in the source. */
2158 DECL_SOURCE_FILE (decl
) = filename
;
2159 DECL_SOURCE_LINE (decl
) = line
;
2164 /* Return the list of declarations of the current level.
2165 Note that this list is in reverse order unless/until
2166 you nreverse it; and when you do nreverse it, you must
2167 store the result back using `storedecls' or you will lose. */
2172 return current_binding_level
->names
;
2175 /* Return the list of type-tags (for structs, etc) of the current level. */
2180 return current_binding_level
->tags
;
2183 /* Store the list of declarations of the current level.
2184 This is done for the parameter declarations of a function being defined,
2185 after they are modified in the light of any missing parameters. */
2191 current_binding_level
->names
= decls
;
2194 /* Similarly, store the list of tags of the current level. */
2200 current_binding_level
->tags
= tags
;
2203 /* Given NAME, an IDENTIFIER_NODE,
2204 return the structure (or union or enum) definition for that name.
2205 Searches binding levels from BINDING_LEVEL up to the global level.
2206 If THISLEVEL_ONLY is nonzero, searches only the specified context
2207 (but skips any tag-transparent contexts to find one that is
2208 meaningful for tags).
2209 CODE says which kind of type the caller wants;
2210 it is RECORD_TYPE or UNION_TYPE or ENUMERAL_TYPE.
2211 If the wrong kind of type is found, an error is reported. */
2214 lookup_tag (code
, name
, binding_level
, thislevel_only
)
2215 enum tree_code code
;
2216 struct binding_level
*binding_level
;
2220 register struct binding_level
*level
;
2222 for (level
= binding_level
; level
; level
= level
->level_chain
)
2225 for (tail
= level
->tags
; tail
; tail
= TREE_CHAIN (tail
))
2227 if (TREE_PURPOSE (tail
) == name
)
2229 if (TREE_CODE (TREE_VALUE (tail
)) != code
)
2231 /* Definition isn't the kind we were looking for. */
2232 pending_invalid_xref
= name
;
2233 pending_invalid_xref_file
= input_filename
;
2234 pending_invalid_xref_line
= lineno
;
2236 return TREE_VALUE (tail
);
2239 if (thislevel_only
&& ! level
->tag_transparent
)
2245 /* Print an error message now
2246 for a recent invalid struct, union or enum cross reference.
2247 We don't print them immediately because they are not invalid
2248 when used in the `struct foo;' construct for shadowing. */
2251 pending_xref_error ()
2253 if (pending_invalid_xref
!= 0)
2254 error_with_file_and_line (pending_invalid_xref_file
,
2255 pending_invalid_xref_line
,
2256 "`%s' defined as wrong kind of tag",
2257 IDENTIFIER_POINTER (pending_invalid_xref
));
2258 pending_invalid_xref
= 0;
2261 /* Given a type, find the tag that was defined for it and return the tag name.
2262 Otherwise return 0. */
2265 lookup_tag_reverse (type
)
2268 register struct binding_level
*level
;
2270 for (level
= current_binding_level
; level
; level
= level
->level_chain
)
2273 for (tail
= level
->tags
; tail
; tail
= TREE_CHAIN (tail
))
2275 if (TREE_VALUE (tail
) == type
)
2276 return TREE_PURPOSE (tail
);
2282 /* Look up NAME in the current binding level and its superiors
2283 in the namespace of variables, functions and typedefs.
2284 Return a ..._DECL node of some kind representing its definition,
2285 or return 0 if it is undefined. */
2292 if (current_binding_level
!= global_binding_level
2293 && IDENTIFIER_LOCAL_VALUE (name
))
2294 val
= IDENTIFIER_LOCAL_VALUE (name
);
2296 val
= IDENTIFIER_GLOBAL_VALUE (name
);
2300 /* Similar to `lookup_name' but look only at current binding level. */
2303 lookup_name_current_level (name
)
2308 if (current_binding_level
== global_binding_level
)
2309 return IDENTIFIER_GLOBAL_VALUE (name
);
2311 if (IDENTIFIER_LOCAL_VALUE (name
) == 0)
2314 for (t
= current_binding_level
->names
; t
; t
= TREE_CHAIN (t
))
2315 if (DECL_NAME (t
) == name
)
2321 /* Create the predefined scalar types of C,
2322 and some nodes representing standard constants (0, 1, (void *)0).
2323 Initialize the global binding level.
2324 Make definitions for built-in primitive functions. */
2327 init_decl_processing ()
2329 register tree endlink
;
2330 /* Either char* or void*. */
2331 tree traditional_ptr_type_node
;
2332 /* Data types of memcpy and strlen. */
2333 tree memcpy_ftype
, strlen_ftype
;
2334 tree void_ftype_any
;
2335 int wchar_type_size
;
2338 current_function_decl
= NULL
;
2339 named_labels
= NULL
;
2340 current_binding_level
= NULL_BINDING_LEVEL
;
2341 free_binding_level
= NULL_BINDING_LEVEL
;
2342 pushlevel (0); /* make the binding_level structure for global names */
2343 global_binding_level
= current_binding_level
;
2345 /* Define `int' and `char' first so that dbx will output them first. */
2347 integer_type_node
= make_signed_type (INT_TYPE_SIZE
);
2348 pushdecl (build_decl (TYPE_DECL
, ridpointers
[(int) RID_INT
],
2349 integer_type_node
));
2351 /* Define `char', which is like either `signed char' or `unsigned char'
2352 but not the same as either. */
2356 ? make_signed_type (CHAR_TYPE_SIZE
)
2357 : make_unsigned_type (CHAR_TYPE_SIZE
));
2358 pushdecl (build_decl (TYPE_DECL
, get_identifier ("char"),
2361 long_integer_type_node
= make_signed_type (LONG_TYPE_SIZE
);
2362 pushdecl (build_decl (TYPE_DECL
, get_identifier ("long int"),
2363 long_integer_type_node
));
2365 unsigned_type_node
= make_unsigned_type (INT_TYPE_SIZE
);
2366 pushdecl (build_decl (TYPE_DECL
, get_identifier ("unsigned int"),
2367 unsigned_type_node
));
2369 long_unsigned_type_node
= make_unsigned_type (LONG_TYPE_SIZE
);
2370 pushdecl (build_decl (TYPE_DECL
, get_identifier ("long unsigned int"),
2371 long_unsigned_type_node
));
2373 /* `unsigned long' is the standard type for sizeof.
2374 Traditionally, use a signed type.
2375 Note that stddef.h uses `unsigned long',
2376 and this must agree, even of long and int are the same size. */
2377 if (flag_traditional
)
2378 sizetype
= long_integer_type_node
;
2381 = TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (get_identifier (SIZE_TYPE
)));
2384 = TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (get_identifier (PTRDIFF_TYPE
)));
2386 TREE_TYPE (TYPE_SIZE (integer_type_node
)) = sizetype
;
2387 TREE_TYPE (TYPE_SIZE (char_type_node
)) = sizetype
;
2388 TREE_TYPE (TYPE_SIZE (unsigned_type_node
)) = sizetype
;
2389 TREE_TYPE (TYPE_SIZE (long_unsigned_type_node
)) = sizetype
;
2390 TREE_TYPE (TYPE_SIZE (long_integer_type_node
)) = sizetype
;
2392 error_mark_node
= make_node (ERROR_MARK
);
2393 TREE_TYPE (error_mark_node
) = error_mark_node
;
2395 short_integer_type_node
= make_signed_type (SHORT_TYPE_SIZE
);
2396 pushdecl (build_decl (TYPE_DECL
, get_identifier ("short int"),
2397 short_integer_type_node
));
2399 long_long_integer_type_node
= make_signed_type (LONG_LONG_TYPE_SIZE
);
2400 pushdecl (build_decl (TYPE_DECL
, get_identifier ("long long int"),
2401 long_long_integer_type_node
));
2403 short_unsigned_type_node
= make_unsigned_type (SHORT_TYPE_SIZE
);
2404 pushdecl (build_decl (TYPE_DECL
, get_identifier ("short unsigned int"),
2405 short_unsigned_type_node
));
2407 long_long_unsigned_type_node
= make_unsigned_type (LONG_LONG_TYPE_SIZE
);
2408 pushdecl (build_decl (TYPE_DECL
, get_identifier ("long long unsigned int"),
2409 long_long_unsigned_type_node
));
2411 /* Define both `signed char' and `unsigned char'. */
2412 signed_char_type_node
= make_signed_type (CHAR_TYPE_SIZE
);
2413 pushdecl (build_decl (TYPE_DECL
, get_identifier ("signed char"),
2414 signed_char_type_node
));
2416 unsigned_char_type_node
= make_unsigned_type (CHAR_TYPE_SIZE
);
2417 pushdecl (build_decl (TYPE_DECL
, get_identifier ("unsigned char"),
2418 unsigned_char_type_node
));
2420 intQI_type_node
= make_signed_type (8);
2421 pushdecl (build_decl (TYPE_DECL
, NULL_TREE
, intQI_type_node
));
2423 intHI_type_node
= make_signed_type (16);
2424 pushdecl (build_decl (TYPE_DECL
, NULL_TREE
, intHI_type_node
));
2426 intSI_type_node
= make_signed_type (32);
2427 pushdecl (build_decl (TYPE_DECL
, NULL_TREE
, intSI_type_node
));
2429 intDI_type_node
= make_signed_type (64);
2430 pushdecl (build_decl (TYPE_DECL
, NULL_TREE
, intDI_type_node
));
2432 unsigned_intQI_type_node
= make_unsigned_type (8);
2433 pushdecl (build_decl (TYPE_DECL
, NULL_TREE
, unsigned_intQI_type_node
));
2435 unsigned_intHI_type_node
= make_unsigned_type (16);
2436 pushdecl (build_decl (TYPE_DECL
, NULL_TREE
, unsigned_intHI_type_node
));
2438 unsigned_intSI_type_node
= make_unsigned_type (32);
2439 pushdecl (build_decl (TYPE_DECL
, NULL_TREE
, unsigned_intSI_type_node
));
2441 unsigned_intDI_type_node
= make_unsigned_type (64);
2442 pushdecl (build_decl (TYPE_DECL
, NULL_TREE
, unsigned_intDI_type_node
));
2444 float_type_node
= make_node (REAL_TYPE
);
2445 TYPE_PRECISION (float_type_node
) = FLOAT_TYPE_SIZE
;
2446 pushdecl (build_decl (TYPE_DECL
, ridpointers
[(int) RID_FLOAT
],
2448 layout_type (float_type_node
);
2450 double_type_node
= make_node (REAL_TYPE
);
2451 if (flag_short_double
)
2452 TYPE_PRECISION (double_type_node
) = FLOAT_TYPE_SIZE
;
2454 TYPE_PRECISION (double_type_node
) = DOUBLE_TYPE_SIZE
;
2455 pushdecl (build_decl (TYPE_DECL
, ridpointers
[(int) RID_DOUBLE
],
2457 layout_type (double_type_node
);
2459 long_double_type_node
= make_node (REAL_TYPE
);
2460 TYPE_PRECISION (long_double_type_node
) = LONG_DOUBLE_TYPE_SIZE
;
2461 pushdecl (build_decl (TYPE_DECL
, get_identifier ("long double"),
2462 long_double_type_node
));
2463 layout_type (long_double_type_node
);
2466 = TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (get_identifier (WCHAR_TYPE
)));
2467 wchar_type_size
= TYPE_PRECISION (wchar_type_node
);
2468 signed_wchar_type_node
= type_for_size (wchar_type_size
, 0);
2469 unsigned_wchar_type_node
= type_for_size (wchar_type_size
, 1);
2471 integer_zero_node
= build_int_2 (0, 0);
2472 TREE_TYPE (integer_zero_node
) = integer_type_node
;
2473 integer_one_node
= build_int_2 (1, 0);
2474 TREE_TYPE (integer_one_node
) = integer_type_node
;
2476 size_zero_node
= build_int_2 (0, 0);
2477 TREE_TYPE (size_zero_node
) = sizetype
;
2478 size_one_node
= build_int_2 (1, 0);
2479 TREE_TYPE (size_one_node
) = sizetype
;
2481 void_type_node
= make_node (VOID_TYPE
);
2482 pushdecl (build_decl (TYPE_DECL
,
2483 ridpointers
[(int) RID_VOID
], void_type_node
));
2484 layout_type (void_type_node
); /* Uses integer_zero_node */
2485 /* We are not going to have real types in C with less than byte alignment,
2486 so we might as well not have any types that claim to have it. */
2487 TYPE_ALIGN (void_type_node
) = BITS_PER_UNIT
;
2489 null_pointer_node
= build_int_2 (0, 0);
2490 TREE_TYPE (null_pointer_node
) = build_pointer_type (void_type_node
);
2491 layout_type (TREE_TYPE (null_pointer_node
));
2493 string_type_node
= build_pointer_type (char_type_node
);
2494 const_string_type_node
2495 = build_pointer_type (build_type_variant (char_type_node
, 1, 0));
2497 /* make a type for arrays of 256 characters.
2498 256 is picked randomly because we have a type for integers from 0 to 255.
2499 With luck nothing will ever really depend on the length of this
2501 char_array_type_node
2502 = build_array_type (char_type_node
, unsigned_char_type_node
);
2503 /* Likewise for arrays of ints. */
2505 = build_array_type (integer_type_node
, unsigned_char_type_node
);
2506 /* This is for wide string constants. */
2507 wchar_array_type_node
2508 = build_array_type (wchar_type_node
, unsigned_char_type_node
);
2510 default_function_type
2511 = build_function_type (integer_type_node
, NULL_TREE
);
2513 ptr_type_node
= build_pointer_type (void_type_node
);
2515 = build_pointer_type (build_type_variant (void_type_node
, 1, 0));
2517 endlink
= tree_cons (NULL_TREE
, void_type_node
, NULL_TREE
);
2520 = build_function_type (void_type_node
, NULL_TREE
);
2523 = build_function_type (double_type_node
,
2524 tree_cons (NULL_TREE
, double_type_node
, endlink
));
2526 double_ftype_double_double
2527 = build_function_type (double_type_node
,
2528 tree_cons (NULL_TREE
, double_type_node
,
2529 tree_cons (NULL_TREE
,
2530 double_type_node
, endlink
)));
2533 = build_function_type (integer_type_node
,
2534 tree_cons (NULL_TREE
, integer_type_node
, endlink
));
2537 = build_function_type (long_integer_type_node
,
2538 tree_cons (NULL_TREE
,
2539 long_integer_type_node
, endlink
));
2541 void_ftype_ptr_ptr_int
2542 = build_function_type (void_type_node
,
2543 tree_cons (NULL_TREE
, ptr_type_node
,
2544 tree_cons (NULL_TREE
, ptr_type_node
,
2545 tree_cons (NULL_TREE
,
2549 int_ftype_cptr_cptr_sizet
2550 = build_function_type (integer_type_node
,
2551 tree_cons (NULL_TREE
, const_ptr_type_node
,
2552 tree_cons (NULL_TREE
, const_ptr_type_node
,
2553 tree_cons (NULL_TREE
,
2557 void_ftype_ptr_int_int
2558 = build_function_type (void_type_node
,
2559 tree_cons (NULL_TREE
, ptr_type_node
,
2560 tree_cons (NULL_TREE
, integer_type_node
,
2561 tree_cons (NULL_TREE
,
2565 string_ftype_ptr_ptr
/* strcpy prototype */
2566 = build_function_type (string_type_node
,
2567 tree_cons (NULL_TREE
, string_type_node
,
2568 tree_cons (NULL_TREE
,
2569 const_string_type_node
,
2572 int_ftype_string_string
/* strcmp prototype */
2573 = build_function_type (integer_type_node
,
2574 tree_cons (NULL_TREE
, const_string_type_node
,
2575 tree_cons (NULL_TREE
,
2576 const_string_type_node
,
2579 strlen_ftype
/* strlen prototype */
2580 = build_function_type (flag_traditional
? integer_type_node
: sizetype
,
2581 tree_cons (NULL_TREE
, const_string_type_node
,
2584 traditional_ptr_type_node
2585 = (flag_traditional
? string_type_node
: ptr_type_node
);
2587 memcpy_ftype
/* memcpy prototype */
2588 = build_function_type (traditional_ptr_type_node
,
2589 tree_cons (NULL_TREE
, ptr_type_node
,
2590 tree_cons (NULL_TREE
, const_ptr_type_node
,
2591 tree_cons (NULL_TREE
,
2595 /* ``integer_tpe_node'' misspelling corrected: North-Keys 30 Mar 91 */
2596 builtin_function ("__builtin_constant_p",
2597 build_function_type (integer_type_node
, endlink
),
2598 BUILT_IN_CONSTANT_P
, NULL_PTR
);
2600 builtin_function ("__builtin_return_address",
2601 build_function_type (integer_type_node
,
2602 tree_cons (NULL_TREE
,
2605 BUILT_IN_RETURN_ADDRESS
, NULL_PTR
);
2607 builtin_function ("__builtin_frame_address",
2608 build_function_type (integer_type_node
,
2609 tree_cons (NULL_TREE
,
2612 BUILT_IN_FRAME_ADDRESS
, NULL_PTR
);
2614 builtin_function ("__builtin_alloca",
2615 build_function_type (ptr_type_node
,
2616 tree_cons (NULL_TREE
,
2619 BUILT_IN_ALLOCA
, "alloca");
2620 if (! flag_no_builtin
&& !flag_no_nonansi_builtin
)
2622 temp
= builtin_function ("alloca",
2623 build_function_type (ptr_type_node
,
2624 tree_cons (NULL_TREE
,
2627 BUILT_IN_ALLOCA
, NULL_PTR
);
2628 /* Suppress error if redefined as a non-function. */
2629 DECL_BUILT_IN_NONANSI (temp
) = 1;
2630 temp
= builtin_function ("_exit", void_ftype_any
, NOT_BUILT_IN
,
2632 TREE_THIS_VOLATILE (temp
) = 1;
2633 TREE_SIDE_EFFECTS (temp
) = 1;
2634 /* Suppress error if redefined as a non-function. */
2635 DECL_BUILT_IN_NONANSI (temp
) = 1;
2638 builtin_function ("__builtin_abs", int_ftype_int
, BUILT_IN_ABS
, NULL_PTR
);
2639 builtin_function ("__builtin_fabs", double_ftype_double
, BUILT_IN_FABS
,
2641 builtin_function ("__builtin_labs", long_ftype_long
, BUILT_IN_LABS
,
2643 builtin_function ("__builtin_ffs", int_ftype_int
, BUILT_IN_FFS
, NULL_PTR
);
2644 builtin_function ("__builtin_saveregs", default_function_type
,
2645 BUILT_IN_SAVEREGS
, NULL_PTR
);
2646 /* EXPAND_BUILTIN_VARARGS is obsolete. */
2648 builtin_function ("__builtin_varargs",
2649 build_function_type (ptr_type_node
,
2650 tree_cons (NULL_TREE
,
2653 BUILT_IN_VARARGS
, NULL_PTR
);
2655 builtin_function ("__builtin_classify_type", default_function_type
,
2656 BUILT_IN_CLASSIFY_TYPE
, NULL_PTR
);
2657 builtin_function ("__builtin_next_arg",
2658 build_function_type (ptr_type_node
, endlink
),
2659 BUILT_IN_NEXT_ARG
, NULL_PTR
);
2660 builtin_function ("__builtin_args_info",
2661 build_function_type (integer_type_node
,
2662 tree_cons (NULL_TREE
,
2665 BUILT_IN_ARGS_INFO
, NULL_PTR
);
2667 /* Currently under experimentation. */
2668 builtin_function ("__builtin_memcpy", memcpy_ftype
,
2669 BUILT_IN_MEMCPY
, "memcpy");
2670 builtin_function ("__builtin_memcmp", int_ftype_cptr_cptr_sizet
,
2671 BUILT_IN_MEMCMP
, "memcmp");
2672 builtin_function ("__builtin_strcmp", int_ftype_string_string
,
2673 BUILT_IN_STRCMP
, "strcmp");
2674 builtin_function ("__builtin_strcpy", string_ftype_ptr_ptr
,
2675 BUILT_IN_STRCPY
, "strcpy");
2676 builtin_function ("__builtin_strlen", strlen_ftype
,
2677 BUILT_IN_STRLEN
, "strlen");
2678 builtin_function ("__builtin_fsqrt", double_ftype_double
,
2679 BUILT_IN_FSQRT
, "sqrt");
2680 /* In an ANSI C program, it is okay to supply built-in meanings
2681 for these functions, since applications cannot validly use them
2682 with any other meaning.
2683 However, honor the -fno-builtin option. */
2684 if (!flag_no_builtin
)
2686 builtin_function ("abs", int_ftype_int
, BUILT_IN_ABS
, NULL_PTR
);
2687 builtin_function ("fabs", double_ftype_double
, BUILT_IN_FABS
, NULL_PTR
);
2688 builtin_function ("labs", long_ftype_long
, BUILT_IN_LABS
, NULL_PTR
);
2689 builtin_function ("memcpy", memcpy_ftype
, BUILT_IN_MEMCPY
, NULL_PTR
);
2690 builtin_function ("memcmp", int_ftype_cptr_cptr_sizet
, BUILT_IN_MEMCMP
,
2692 builtin_function ("strcmp", int_ftype_string_string
, BUILT_IN_STRCMP
,
2694 builtin_function ("strcpy", string_ftype_ptr_ptr
, BUILT_IN_STRCPY
,
2696 builtin_function ("strlen", strlen_ftype
, BUILT_IN_STRLEN
, NULL_PTR
);
2697 builtin_function ("sqrt", double_ftype_double
, BUILT_IN_FSQRT
, NULL_PTR
);
2699 /* Declare these functions volatile
2700 to avoid spurious "control drops through" warnings. */
2701 /* Don't specify the argument types, to avoid errors
2702 from certain code which isn't valid in ANSI but which exists. */
2703 temp
= builtin_function ("abort", void_ftype_any
, NOT_BUILT_IN
,
2705 TREE_THIS_VOLATILE (temp
) = 1;
2706 TREE_SIDE_EFFECTS (temp
) = 1;
2707 temp
= builtin_function ("exit", void_ftype_any
, NOT_BUILT_IN
, NULL_PTR
);
2708 TREE_THIS_VOLATILE (temp
) = 1;
2709 TREE_SIDE_EFFECTS (temp
) = 1;
2713 /* Support for these has not been written in either expand_builtin
2714 or build_function_call. */
2715 builtin_function ("__builtin_div", default_ftype
, BUILT_IN_DIV
, NULL_PTR
);
2716 builtin_function ("__builtin_ldiv", default_ftype
, BUILT_IN_LDIV
, NULL_PTR
);
2717 builtin_function ("__builtin_ffloor", double_ftype_double
, BUILT_IN_FFLOOR
,
2719 builtin_function ("__builtin_fceil", double_ftype_double
, BUILT_IN_FCEIL
,
2721 builtin_function ("__builtin_fmod", double_ftype_double_double
,
2722 BUILT_IN_FMOD
, NULL_PTR
);
2723 builtin_function ("__builtin_frem", double_ftype_double_double
,
2724 BUILT_IN_FREM
, NULL_PTR
);
2725 builtin_function ("__builtin_memset", ptr_ftype_ptr_int_int
,
2726 BUILT_IN_MEMSET
, NULL_PTR
);
2727 builtin_function ("__builtin_getexp", double_ftype_double
, BUILT_IN_GETEXP
,
2729 builtin_function ("__builtin_getman", double_ftype_double
, BUILT_IN_GETMAN
,
2733 /* Create the global bindings for __FUNCTION__ and __PRETTY_FUNCTION__. */
2734 declare_function_name ();
2736 start_identifier_warnings ();
2738 init_format_info_table ();
2741 /* Return a definition for a builtin function named NAME and whose data type
2742 is TYPE. TYPE should be a function type with argument types.
2743 FUNCTION_CODE tells later passes how to compile calls to this function.
2744 See tree.h for its possible values.
2746 If LIBRARY_NAME is nonzero, use that for DECL_ASSEMBLER_NAME,
2747 the name to be called if we can't opencode the function. */
2750 builtin_function (name
, type
, function_code
, library_name
)
2753 enum built_in_function function_code
;
2756 tree decl
= build_decl (FUNCTION_DECL
, get_identifier (name
), type
);
2757 TREE_EXTERNAL (decl
) = 1;
2758 TREE_PUBLIC (decl
) = 1;
2759 /* If -traditional, permit redefining a builtin function any way you like.
2760 (Though really, if the program redefines these functions,
2761 it probably won't work right unless compiled with -fno-builtin.) */
2762 if (flag_traditional
&& name
[0] != '_')
2763 DECL_BUILT_IN_NONANSI (decl
) = 1;
2765 DECL_ASSEMBLER_NAME (decl
) = get_identifier (library_name
);
2766 make_decl_rtl (decl
, NULL_PTR
, 1);
2768 if (function_code
!= NOT_BUILT_IN
)
2770 DECL_BUILT_IN (decl
) = 1;
2771 DECL_SET_FUNCTION_CODE (decl
, function_code
);
2773 /* Warn if a function in the namespace for users
2774 is used without an occasion to consider it declared. */
2775 if (name
[0] != '_' || name
[1] != '_')
2776 C_DECL_ANTICIPATED (decl
) = 1;
2781 /* Called when a declaration is seen that contains no names to declare.
2782 If its type is a reference to a structure, union or enum inherited
2783 from a containing scope, shadow that tag name for the current scope
2784 with a forward reference.
2785 If its type defines a new named structure or union
2786 or defines an enum, it is valid but we need not do anything here.
2787 Otherwise, it is an error. */
2790 shadow_tag (declspecs
)
2797 pending_invalid_xref
= 0;
2799 for (link
= declspecs
; link
; link
= TREE_CHAIN (link
))
2801 register tree value
= TREE_VALUE (link
);
2802 register enum tree_code code
= TREE_CODE (value
);
2804 if (code
== RECORD_TYPE
|| code
== UNION_TYPE
|| code
== ENUMERAL_TYPE
)
2805 /* Used to test also that TYPE_SIZE (value) != 0.
2806 That caused warning for `struct foo;' at top level in the file. */
2808 register tree name
= lookup_tag_reverse (value
);
2815 if (code
!= ENUMERAL_TYPE
) /* Empty unnamed enum OK */
2817 pedwarn ("unnamed struct/union that defines no instances");
2823 t
= lookup_tag (code
, name
, current_binding_level
, 1);
2827 t
= make_node (code
);
2835 warning ("useless keyword or type name in empty declaration");
2843 error ("two types specified in one empty declaration");
2845 pedwarn ("empty declaration");
2849 /* Decode a "typename", such as "int **", returning a ..._TYPE node. */
2852 groktypename (typename
)
2855 if (TREE_CODE (typename
) != TREE_LIST
)
2857 return grokdeclarator (TREE_VALUE (typename
),
2858 TREE_PURPOSE (typename
),
2862 /* Return a PARM_DECL node for a given pair of specs and declarator. */
2865 groktypename_in_parm_context (typename
)
2868 if (TREE_CODE (typename
) != TREE_LIST
)
2870 return grokdeclarator (TREE_VALUE (typename
),
2871 TREE_PURPOSE (typename
),
2875 /* Decode a declarator in an ordinary declaration or data definition.
2876 This is called as soon as the type information and variable name
2877 have been parsed, before parsing the initializer if any.
2878 Here we create the ..._DECL node, fill in its type,
2879 and put it on the list of decls for the current context.
2880 The ..._DECL node is returned as the value.
2882 Exception: for arrays where the length is not specified,
2883 the type is left null, to be filled in by `finish_decl'.
2885 Function definitions do not come here; they go to start_function
2886 instead. However, external and forward declarations of functions
2887 do go through here. Structure field declarations are done by
2888 grokfield and not through here. */
2890 /* Set this to zero to debug not using the temporary obstack
2891 to parse initializers. */
2892 int debug_temp_inits
= 1;
2895 start_decl (declarator
, declspecs
, initialized
)
2896 tree declspecs
, declarator
;
2899 register tree decl
= grokdeclarator (declarator
, declspecs
,
2900 NORMAL
, initialized
);
2902 int init_written
= initialized
;
2904 /* The corresponding pop_obstacks is in finish_decl. */
2905 push_obstacks_nochange ();
2908 /* Is it valid for this decl to have an initializer at all?
2909 If not, set INITIALIZED to zero, which will indirectly
2910 tell `finish_decl' to ignore the initializer once it is parsed. */
2911 switch (TREE_CODE (decl
))
2914 /* typedef foo = bar means give foo the same type as bar.
2915 We haven't parsed bar yet, so `finish_decl' will fix that up.
2916 Any other case of an initialization in a TYPE_DECL is an error. */
2917 if (pedantic
|| list_length (declspecs
) > 1)
2919 error ("typedef `%s' is initialized",
2920 IDENTIFIER_POINTER (DECL_NAME (decl
)));
2926 error ("function `%s' is initialized like a variable",
2927 IDENTIFIER_POINTER (DECL_NAME (decl
)));
2932 /* DECL_INITIAL in a PARM_DECL is really DECL_ARG_TYPE. */
2933 error ("parameter `%s' is initialized",
2934 IDENTIFIER_POINTER (DECL_NAME (decl
)));
2939 /* Don't allow initializations for incomplete types
2940 except for arrays which might be completed by the initialization. */
2941 if (TYPE_SIZE (TREE_TYPE (decl
)) != 0)
2943 /* A complete type is ok if size is fixed. */
2945 if (TREE_CODE (TYPE_SIZE (TREE_TYPE (decl
))) != INTEGER_CST
2946 || C_DECL_VARIABLE_SIZE (decl
))
2948 error ("variable-sized object may not be initialized");
2952 else if (TREE_CODE (TREE_TYPE (decl
)) != ARRAY_TYPE
)
2954 error ("variable `%s' has initializer but incomplete type",
2955 IDENTIFIER_POINTER (DECL_NAME (decl
)));
2958 else if (TYPE_SIZE (TREE_TYPE (TREE_TYPE (decl
))) == 0)
2960 error ("elements of array `%s' have incomplete type",
2961 IDENTIFIER_POINTER (DECL_NAME (decl
)));
2968 #if 0 /* Seems redundant with grokdeclarator. */
2969 if (current_binding_level
!= global_binding_level
2970 && TREE_EXTERNAL (decl
)
2971 && TREE_CODE (decl
) != FUNCTION_DECL
)
2972 warning ("declaration of `%s' has `extern' and is initialized",
2973 IDENTIFIER_POINTER (DECL_NAME (decl
)));
2975 TREE_EXTERNAL (decl
) = 0;
2976 if (current_binding_level
== global_binding_level
)
2977 TREE_STATIC (decl
) = 1;
2979 /* Tell `pushdecl' this is an initialized decl
2980 even though we don't yet have the initializer expression.
2981 Also tell `finish_decl' it may store the real initializer. */
2982 DECL_INITIAL (decl
) = error_mark_node
;
2985 /* If this is a function declaration, write a record describing it to the
2986 prototypes file (if requested). */
2988 if (TREE_CODE (decl
) == FUNCTION_DECL
)
2989 gen_aux_info_record (decl
, 0, 0, TYPE_ARG_TYPES (TREE_TYPE (decl
)) != 0);
2991 /* Add this decl to the current binding level.
2992 TEM may equal DECL or it may be a previous decl of the same name. */
2993 tem
= pushdecl (decl
);
2995 /* For a local variable, define the RTL now. */
2996 if (current_binding_level
!= global_binding_level
2997 /* But not if this is a duplicate decl
2998 and we preserved the rtl from the previous one
2999 (which may or may not happen). */
3000 && DECL_RTL (tem
) == 0)
3002 if (TYPE_SIZE (TREE_TYPE (tem
)) != 0)
3004 else if (TREE_CODE (TREE_TYPE (tem
)) == ARRAY_TYPE
3005 && DECL_INITIAL (tem
) != 0)
3011 /* When parsing and digesting the initializer,
3012 use temporary storage. Do this even if we will ignore the value. */
3013 if (current_binding_level
== global_binding_level
&& debug_temp_inits
)
3014 temporary_allocation ();
3020 /* Finish processing of a declaration;
3021 install its initial value.
3022 If the length of an array type is not known before,
3023 it must be determined now, from the initial value, or it is an error. */
3026 finish_decl (decl
, init
, asmspec_tree
)
3030 register tree type
= TREE_TYPE (decl
);
3031 int was_incomplete
= (DECL_SIZE (decl
) == 0);
3032 int temporary
= allocation_temporary_p ();
3036 asmspec
= TREE_STRING_POINTER (asmspec_tree
);
3038 /* If `start_decl' didn't like having an initialization, ignore it now. */
3040 if (init
!= 0 && DECL_INITIAL (decl
) == 0)
3042 /* Don't crash if parm is initialized. */
3043 if (TREE_CODE (decl
) == PARM_DECL
)
3048 if (TREE_CODE (decl
) != TYPE_DECL
)
3049 store_init_value (decl
, init
);
3052 /* typedef foo = bar; store the type of bar as the type of foo. */
3053 TREE_TYPE (decl
) = TREE_TYPE (init
);
3054 DECL_INITIAL (decl
) = init
= 0;
3058 /* For top-level declaration, the initial value was read in
3059 the temporary obstack. MAXINDEX, rtl, etc. to be made below
3060 must go in the permanent obstack; but don't discard the
3061 temporary data yet. */
3063 if (current_binding_level
== global_binding_level
&& temporary
)
3064 end_temporary_allocation ();
3066 /* Deduce size of array from initialization, if not already known */
3068 if (TREE_CODE (type
) == ARRAY_TYPE
3069 && TYPE_DOMAIN (type
) == 0
3070 && TREE_CODE (decl
) != TYPE_DECL
)
3073 = (TREE_STATIC (decl
)
3074 /* Even if pedantic, an external linkage array
3075 may have incomplete type at first. */
3076 ? pedantic
&& !TREE_PUBLIC (decl
)
3077 : !TREE_EXTERNAL (decl
));
3079 = complete_array_type (type
, DECL_INITIAL (decl
), do_default
);
3081 /* Get the completed type made by complete_array_type. */
3082 type
= TREE_TYPE (decl
);
3085 error_with_decl (decl
, "initializer fails to determine size of `%s'");
3090 error_with_decl (decl
, "array size missing in `%s'");
3091 else if (!pedantic
&& TREE_STATIC (decl
))
3092 TREE_EXTERNAL (decl
) = 1;
3095 if (pedantic
&& TYPE_DOMAIN (type
) != 0
3096 && tree_int_cst_lt (TYPE_MAX_VALUE (TYPE_DOMAIN (type
)),
3098 error_with_decl (decl
, "zero-size array `%s'");
3100 layout_decl (decl
, 0);
3103 if (TREE_CODE (decl
) == VAR_DECL
)
3105 if (TREE_STATIC (decl
) && DECL_SIZE (decl
) == 0)
3107 /* A static variable with an incomplete type:
3108 that is an error if it is initialized or `static'.
3109 Otherwise, let it through, but if it is not `extern'
3110 then it may cause an error message later. */
3111 if (! (TREE_PUBLIC (decl
) && DECL_INITIAL (decl
) == 0))
3112 error_with_decl (decl
, "storage size of `%s' isn't known");
3114 else if (!TREE_EXTERNAL (decl
) && DECL_SIZE (decl
) == 0)
3116 /* An automatic variable with an incomplete type:
3117 that is an error. */
3118 error_with_decl (decl
, "storage size of `%s' isn't known");
3119 TREE_TYPE (decl
) = error_mark_node
;
3122 if ((TREE_EXTERNAL (decl
) || TREE_STATIC (decl
))
3123 && DECL_SIZE (decl
) != 0
3124 && TREE_CODE (DECL_SIZE (decl
)) != INTEGER_CST
)
3125 error_with_decl (decl
, "storage size of `%s' isn't constant");
3128 /* Output the assembler code and/or RTL code for variables and functions,
3129 unless the type is an undefined structure or union.
3130 If not, it will get done when the type is completed. */
3132 if (TREE_CODE (decl
) == VAR_DECL
|| TREE_CODE (decl
) == FUNCTION_DECL
)
3134 if (flag_traditional
&& allocation_temporary_p ())
3136 push_obstacks_nochange ();
3137 end_temporary_allocation ();
3138 /* This is a no-op in c-lang.c or something real in objc-actions.c. */
3139 maybe_objc_check_decl (decl
);
3140 rest_of_decl_compilation (decl
, asmspec
,
3141 current_binding_level
== global_binding_level
,
3147 /* This is a no-op in c-lang.c or something real in objc-actions.c. */
3148 maybe_objc_check_decl (decl
);
3149 rest_of_decl_compilation (decl
, asmspec
,
3150 current_binding_level
== global_binding_level
,
3153 if (current_binding_level
!= global_binding_level
)
3155 /* Recompute the RTL of a local array now
3156 if it used to be an incomplete type. */
3158 && ! TREE_STATIC (decl
) && ! TREE_EXTERNAL (decl
))
3160 /* If we used it already as memory, it must stay in memory. */
3161 TREE_ADDRESSABLE (decl
) = TREE_USED (decl
);
3162 /* If it's still incomplete now, no init will save it. */
3163 if (DECL_SIZE (decl
) == 0)
3164 DECL_INITIAL (decl
) = 0;
3167 /* Compute and store the initial value. */
3168 expand_decl_init (decl
);
3172 if (TREE_CODE (decl
) == TYPE_DECL
)
3174 /* This is a no-op in c-lang.c or something real in objc-actions.c. */
3175 maybe_objc_check_decl (decl
);
3176 rest_of_decl_compilation (decl
, NULL_PTR
,
3177 current_binding_level
== global_binding_level
,
3181 if (temporary
&& TREE_PERMANENT (decl
))
3183 /* We need to remember that this array HAD an initialization,
3184 but discard the actual temporary nodes,
3185 since we can't have a permanent node keep pointing to them. */
3186 if (DECL_INITIAL (decl
) != 0)
3187 DECL_INITIAL (decl
) = error_mark_node
;
3190 /* Resume permanent allocation, if not within a function. */
3191 /* The corresponding push_obstacks_nochange is in start_decl,
3192 and in push_parm_decl and in grokfield. */
3194 if (current_binding_level
== global_binding_level
&& temporary
)
3195 /* Actually free the temporary space that we no longer need. */
3196 permanent_allocation ();
3198 /* At the end of a declaration, throw away any variable type sizes
3199 of types defined inside that declaration. There is no use
3200 computing them in the following function definition. */
3201 if (current_binding_level
== global_binding_level
)
3202 get_pending_sizes ();
3205 /* If DECL has a cleanup, build and return that cleanup here.
3206 This is a callback called by expand_expr. */
3209 maybe_build_cleanup (decl
)
3212 /* There are no cleanups in C. */
3216 /* Given a parsed parameter declaration,
3217 decode it into a PARM_DECL and push that on the current binding level.
3218 Also, for the sake of forward parm decls,
3219 record the given order of parms in `parm_order'. */
3222 push_parm_decl (parm
)
3226 int old_immediate_size_expand
= immediate_size_expand
;
3227 /* Don't try computing parm sizes now -- wait till fn is called. */
3228 immediate_size_expand
= 0;
3230 /* The corresponding pop_obstacks is in finish_decl. */
3231 push_obstacks_nochange ();
3233 decl
= grokdeclarator (TREE_VALUE (parm
), TREE_PURPOSE (parm
), PARM
, 0);
3234 if (DECL_NAME (decl
))
3236 olddecl
= lookup_name (DECL_NAME (decl
));
3237 if (pedantic
&& olddecl
!= 0 && TREE_CODE (olddecl
) == TYPE_DECL
)
3238 pedwarn_with_decl (decl
, "ANSI C forbids parameter `%s' shadowing typedef");
3240 decl
= pushdecl (decl
);
3242 immediate_size_expand
= old_immediate_size_expand
;
3244 current_binding_level
->parm_order
3245 = tree_cons (NULL_TREE
, decl
, current_binding_level
->parm_order
);
3247 /* Add this decl to the current binding level. */
3248 finish_decl (decl
, NULL_TREE
, NULL_TREE
);
3251 /* Clear the given order of parms in `parm_order'.
3252 Used at start of parm list,
3253 and also at semicolon terminating forward decls. */
3258 current_binding_level
->parm_order
= NULL_TREE
;
3261 /* Make TYPE a complete type based on INITIAL_VALUE.
3262 Return 0 if successful, 1 if INITIAL_VALUE can't be deciphered,
3263 2 if there was no information (in which case assume 1 if DO_DEFAULT). */
3266 complete_array_type (type
, initial_value
, do_default
)
3271 register tree maxindex
= NULL_TREE
;
3276 /* Note MAXINDEX is really the maximum index,
3277 one less than the size. */
3278 if (TREE_CODE (initial_value
) == STRING_CST
)
3281 = int_size_in_bytes (TREE_TYPE (TREE_TYPE (initial_value
)));
3282 maxindex
= build_int_2 (TREE_STRING_LENGTH (initial_value
) / eltsize
- 1, 0);
3284 else if (TREE_CODE (initial_value
) == CONSTRUCTOR
)
3287 = list_length (CONSTRUCTOR_ELTS (initial_value
));
3288 maxindex
= build_int_2 (nelts
- 1, 0);
3292 /* Make an error message unless that happened already. */
3293 if (initial_value
!= error_mark_node
)
3296 /* Prevent further error messages. */
3297 maxindex
= build_int_2 (1, 0);
3304 maxindex
= build_int_2 (1, 0);
3310 TYPE_DOMAIN (type
) = build_index_type (maxindex
);
3311 if (!TREE_TYPE (maxindex
))
3312 TREE_TYPE (maxindex
) = TYPE_DOMAIN (type
);
3315 /* Lay out the type now that we can get the real answer. */
3322 /* Given declspecs and a declarator,
3323 determine the name and type of the object declared
3324 and construct a ..._DECL node for it.
3325 (In one case we can return a ..._TYPE node instead.
3326 For invalid input we sometimes return 0.)
3328 DECLSPECS is a chain of tree_list nodes whose value fields
3329 are the storage classes and type specifiers.
3331 DECL_CONTEXT says which syntactic context this declaration is in:
3332 NORMAL for most contexts. Make a VAR_DECL or FUNCTION_DECL or TYPE_DECL.
3333 FUNCDEF for a function definition. Like NORMAL but a few different
3334 error messages in each case. Return value may be zero meaning
3335 this definition is too screwy to try to parse.
3336 PARM for a parameter declaration (either within a function prototype
3337 or before a function body). Make a PARM_DECL, or return void_type_node.
3338 TYPENAME if for a typename (in a cast or sizeof).
3339 Don't make a DECL node; just return the ..._TYPE node.
3340 FIELD for a struct or union field; make a FIELD_DECL.
3341 BITFIELD for a field with specified width.
3342 INITIALIZED is 1 if the decl has an initializer.
3344 In the TYPENAME case, DECLARATOR is really an absolute declarator.
3345 It may also be so in the PARM case, for a prototype where the
3346 argument type is specified but not the name.
3348 This function is where the complicated C meanings of `static'
3349 and `extern' are interpreted. */
3352 grokdeclarator (declarator
, declspecs
, decl_context
, initialized
)
3355 enum decl_context decl_context
;
3360 tree type
= NULL_TREE
;
3365 int explicit_int
= 0;
3366 int explicit_char
= 0;
3367 tree typedef_decl
= 0;
3369 tree typedef_type
= 0;
3370 int funcdef_flag
= 0;
3371 enum tree_code innermost_code
= ERROR_MARK
;
3373 int size_varies
= 0;
3375 if (decl_context
== BITFIELD
)
3376 bitfield
= 1, decl_context
= FIELD
;
3378 if (decl_context
== FUNCDEF
)
3379 funcdef_flag
= 1, decl_context
= NORMAL
;
3381 push_obstacks_nochange ();
3383 if (flag_traditional
&& allocation_temporary_p ())
3384 end_temporary_allocation ();
3386 /* Look inside a declarator for the name being declared
3387 and get it as a string, for an error message. */
3389 register tree decl
= declarator
;
3393 switch (TREE_CODE (decl
))
3398 innermost_code
= TREE_CODE (decl
);
3399 decl
= TREE_OPERAND (decl
, 0);
3402 case IDENTIFIER_NODE
:
3403 name
= IDENTIFIER_POINTER (decl
);
3414 /* A function definition's declarator must have the form of
3415 a function declarator. */
3417 if (funcdef_flag
&& innermost_code
!= CALL_EXPR
)
3420 /* Anything declared one level down from the top level
3421 must be one of the parameters of a function
3422 (because the body is at least two levels down). */
3424 /* If this looks like a function definition, make it one,
3425 even if it occurs where parms are expected.
3426 Then store_parm_decls will reject it and not use it as a parm. */
3427 if (decl_context
== NORMAL
&& !funcdef_flag
3428 && current_binding_level
->level_chain
== global_binding_level
)
3429 decl_context
= PARM
;
3431 /* Look through the decl specs and record which ones appear.
3432 Some typespecs are defined as built-in typenames.
3433 Others, the ones that are modifiers of other types,
3434 are represented by bits in SPECBITS: set the bits for
3435 the modifiers that appear. Storage class keywords are also in SPECBITS.
3437 If there is a typedef name or a type, store the type in TYPE.
3438 This includes builtin typedefs such as `int'.
3440 Set EXPLICIT_INT or EXPLICIT_CHAR if the type is `int' or `char'
3441 and did not come from a user typedef.
3443 Set LONGLONG if `long' is mentioned twice. */
3445 for (spec
= declspecs
; spec
; spec
= TREE_CHAIN (spec
))
3448 register tree id
= TREE_VALUE (spec
);
3450 if (id
== ridpointers
[(int) RID_INT
])
3452 if (id
== ridpointers
[(int) RID_CHAR
])
3455 if (TREE_CODE (id
) == IDENTIFIER_NODE
)
3456 for (i
= (int) RID_FIRST_MODIFIER
; i
< (int) RID_MAX
; i
++)
3458 if (ridpointers
[i
] == id
)
3460 if (i
== (int) RID_LONG
&& specbits
& (1<<i
))
3463 pedwarn ("duplicate `%s'", IDENTIFIER_POINTER (id
));
3465 error ("`long long long' is too long for GCC");
3469 else if (specbits
& (1 << i
))
3470 pedwarn ("duplicate `%s'", IDENTIFIER_POINTER (id
));
3476 error ("two or more data types in declaration of `%s'", name
);
3477 /* Actual typedefs come to us as TYPE_DECL nodes. */
3478 else if (TREE_CODE (id
) == TYPE_DECL
)
3480 type
= TREE_TYPE (id
);
3483 /* Built-in types come as identifiers. */
3484 else if (TREE_CODE (id
) == IDENTIFIER_NODE
)
3486 register tree t
= lookup_name (id
);
3487 if (TREE_TYPE (t
) == error_mark_node
)
3489 else if (!t
|| TREE_CODE (t
) != TYPE_DECL
)
3490 error ("`%s' fails to be a typedef or built in type",
3491 IDENTIFIER_POINTER (id
));
3494 type
= TREE_TYPE (t
);
3498 else if (TREE_CODE (id
) != ERROR_MARK
)
3504 typedef_type
= type
;
3506 size_varies
= C_TYPE_VARIABLE_SIZE (type
);
3508 /* No type at all: default to `int', and set EXPLICIT_INT
3509 because it was not a user-defined typedef. */
3513 if (funcdef_flag
&& warn_return_type
3514 && ! (specbits
& ((1 << (int) RID_LONG
) | (1 << (int) RID_SHORT
)
3515 | (1 << (int) RID_SIGNED
) | (1 << (int) RID_UNSIGNED
))))
3516 warn_about_return_type
= 1;
3518 type
= integer_type_node
;
3521 /* Now process the modifiers that were specified
3522 and check for invalid combinations. */
3524 /* Long double is a special combination. */
3526 if ((specbits
& 1 << (int) RID_LONG
) && type
== double_type_node
)
3528 specbits
&= ~ (1 << (int) RID_LONG
);
3529 type
= long_double_type_node
;
3532 /* Check all other uses of type modifiers. */
3534 if (specbits
& ((1 << (int) RID_LONG
) | (1 << (int) RID_SHORT
)
3535 | (1 << (int) RID_UNSIGNED
) | (1 << (int) RID_SIGNED
)))
3539 if (TREE_CODE (type
) != INTEGER_TYPE
)
3540 error ("long, short, signed or unsigned invalid for `%s'", name
);
3541 else if ((specbits
& 1 << (int) RID_LONG
)
3542 && (specbits
& 1 << (int) RID_SHORT
))
3543 error ("long and short specified together for `%s'", name
);
3544 else if (((specbits
& 1 << (int) RID_LONG
)
3545 || (specbits
& 1 << (int) RID_SHORT
))
3547 error ("long or short specified with char for `%s'", name
);
3548 else if (((specbits
& 1 << (int) RID_LONG
)
3549 || (specbits
& 1 << (int) RID_SHORT
))
3550 && TREE_CODE (type
) == REAL_TYPE
)
3551 error ("long or short specified with floating type for `%s'", name
);
3552 else if ((specbits
& 1 << (int) RID_SIGNED
)
3553 && (specbits
& 1 << (int) RID_UNSIGNED
))
3554 error ("signed and unsigned given together for `%s'", name
);
3558 if (!explicit_int
&& !explicit_char
&& pedantic
)
3560 pedwarn ("long, short, signed or unsigned used invalidly for `%s'",
3562 if (flag_pedantic_errors
)
3567 /* Discard the type modifiers if they are invalid. */
3570 specbits
&= ~((1 << (int) RID_LONG
) | (1 << (int) RID_SHORT
)
3571 | (1 << (int) RID_UNSIGNED
) | (1 << (int) RID_SIGNED
));
3576 /* Decide whether an integer type is signed or not.
3577 Optionally treat bitfields as signed by default. */
3578 if (specbits
& 1 << (int) RID_UNSIGNED
3579 /* Traditionally, all bitfields are unsigned. */
3580 || (bitfield
&& flag_traditional
)
3581 || (bitfield
&& ! flag_signed_bitfields
3582 && (explicit_int
|| explicit_char
3583 /* A typedef for plain `int' without `signed'
3584 can be controlled just like plain `int'. */
3585 || ! (typedef_decl
!= 0
3586 && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl
)))
3587 && TREE_CODE (type
) != ENUMERAL_TYPE
3588 && !(specbits
& 1 << (int) RID_SIGNED
)))
3591 type
= long_long_unsigned_type_node
;
3592 else if (specbits
& 1 << (int) RID_LONG
)
3593 type
= long_unsigned_type_node
;
3594 else if (specbits
& 1 << (int) RID_SHORT
)
3595 type
= short_unsigned_type_node
;
3596 else if (type
== char_type_node
)
3597 type
= unsigned_char_type_node
;
3598 else if (typedef_decl
)
3599 type
= unsigned_type (type
);
3601 type
= unsigned_type_node
;
3603 else if ((specbits
& 1 << (int) RID_SIGNED
)
3604 && type
== char_type_node
)
3605 type
= signed_char_type_node
;
3607 type
= long_long_integer_type_node
;
3608 else if (specbits
& 1 << (int) RID_LONG
)
3609 type
= long_integer_type_node
;
3610 else if (specbits
& 1 << (int) RID_SHORT
)
3611 type
= short_integer_type_node
;
3613 /* Set CONSTP if this declaration is `const', whether by
3614 explicit specification or via a typedef.
3615 Likewise for VOLATILEP. */
3617 constp
= !! (specbits
& 1 << (int) RID_CONST
) + TYPE_READONLY (type
);
3618 volatilep
= !! (specbits
& 1 << (int) RID_VOLATILE
) + TYPE_VOLATILE (type
);
3619 inlinep
= !! (specbits
& (1 << (int) RID_INLINE
));
3621 pedwarn ("duplicate `const'");
3623 pedwarn ("duplicate `volatile'");
3624 if (! flag_gen_aux_info
&& (TYPE_READONLY (type
) || TYPE_VOLATILE (type
)))
3625 type
= TYPE_MAIN_VARIANT (type
);
3627 /* Warn if two storage classes are given. Default to `auto'. */
3632 if (specbits
& 1 << (int) RID_AUTO
) nclasses
++;
3633 if (specbits
& 1 << (int) RID_STATIC
) nclasses
++;
3634 if (specbits
& 1 << (int) RID_EXTERN
) nclasses
++;
3635 if (specbits
& 1 << (int) RID_REGISTER
) nclasses
++;
3636 if (specbits
& 1 << (int) RID_TYPEDEF
) nclasses
++;
3638 /* Warn about storage classes that are invalid for certain
3639 kinds of declarations (parameters, typenames, etc.). */
3642 error ("multiple storage classes in declaration of `%s'", name
);
3643 else if (funcdef_flag
3645 & ((1 << (int) RID_REGISTER
)
3646 | (1 << (int) RID_AUTO
)
3647 | (1 << (int) RID_TYPEDEF
))))
3649 if (specbits
& 1 << (int) RID_AUTO
3650 && (pedantic
|| current_binding_level
== global_binding_level
))
3651 pedwarn ("function definition declared `auto'");
3652 if (specbits
& 1 << (int) RID_REGISTER
)
3653 error ("function definition declared `register'");
3654 if (specbits
& 1 << (int) RID_TYPEDEF
)
3655 error ("function definition declared `typedef'");
3656 specbits
&= ~ ((1 << (int) RID_TYPEDEF
) | (1 << (int) RID_REGISTER
)
3657 | (1 << (int) RID_AUTO
));
3659 else if (decl_context
!= NORMAL
&& nclasses
> 0)
3661 if (decl_context
== PARM
&& specbits
& 1 << (int) RID_REGISTER
)
3665 error ((decl_context
== FIELD
3666 ? "storage class specified for structure field `%s'"
3667 : (decl_context
== PARM
3668 ? "storage class specified for parameter `%s'"
3669 : "storage class specified for typename")),
3671 specbits
&= ~ ((1 << (int) RID_TYPEDEF
) | (1 << (int) RID_REGISTER
)
3672 | (1 << (int) RID_AUTO
) | (1 << (int) RID_STATIC
)
3673 | (1 << (int) RID_EXTERN
));
3676 else if (specbits
& 1 << (int) RID_EXTERN
&& initialized
&& ! funcdef_flag
)
3678 /* `extern' with initialization is invalid if not at top level. */
3679 if (current_binding_level
== global_binding_level
)
3680 warning ("`%s' initialized and declared `extern'", name
);
3682 error ("`%s' has both `extern' and initializer", name
);
3684 else if (specbits
& 1 << (int) RID_EXTERN
&& funcdef_flag
3685 && current_binding_level
!= global_binding_level
)
3686 error ("nested function `%s' declared `extern'", name
);
3687 else if (current_binding_level
== global_binding_level
3688 && specbits
& (1 << (int) RID_AUTO
))
3689 error ("top-level declaration of `%s' specifies `auto'", name
);
3692 /* Now figure out the structure of the declarator proper.
3693 Descend through it, creating more complex types, until we reach
3694 the declared identifier (or NULL_TREE, in an absolute declarator). */
3696 while (declarator
&& TREE_CODE (declarator
) != IDENTIFIER_NODE
)
3698 if (type
== error_mark_node
)
3700 declarator
= TREE_OPERAND (declarator
, 0);
3704 /* Each level of DECLARATOR is either an ARRAY_REF (for ...[..]),
3705 an INDIRECT_REF (for *...),
3706 a CALL_EXPR (for ...(...)),
3707 an identifier (for the name being declared)
3708 or a null pointer (for the place in an absolute declarator
3709 where the name was omitted).
3710 For the last two cases, we have just exited the loop.
3712 At this point, TYPE is the type of elements of an array,
3713 or for a function to return, or for a pointer to point to.
3714 After this sequence of ifs, TYPE is the type of the
3715 array or function or pointer, and DECLARATOR has had its
3716 outermost layer removed. */
3718 if (TREE_CODE (declarator
) == ARRAY_REF
)
3720 register tree itype
= NULL_TREE
;
3721 register tree size
= TREE_OPERAND (declarator
, 1);
3723 declarator
= TREE_OPERAND (declarator
, 0);
3725 /* Check for some types that there cannot be arrays of. */
3727 if (type
== void_type_node
)
3729 error ("declaration of `%s' as array of voids", name
);
3730 type
= error_mark_node
;
3733 if (TREE_CODE (type
) == FUNCTION_TYPE
)
3735 error ("declaration of `%s' as array of functions", name
);
3736 type
= error_mark_node
;
3739 if (size
== error_mark_node
)
3740 type
= error_mark_node
;
3742 if (type
== error_mark_node
)
3745 /* If size was specified, set ITYPE to a range-type for that size.
3746 Otherwise, ITYPE remains null. finish_decl may figure it out
3747 from an initial value. */
3751 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue. */
3754 if (TREE_CODE (TREE_TYPE (size
)) != INTEGER_TYPE
3755 && TREE_CODE (TREE_TYPE (size
)) != ENUMERAL_TYPE
)
3757 error ("size of array `%s' has non-integer type", name
);
3758 size
= integer_one_node
;
3760 if (pedantic
&& integer_zerop (size
))
3761 pedwarn ("ANSI C forbids zero-size array `%s'", name
);
3762 if (TREE_CODE (size
) == INTEGER_CST
)
3764 if (INT_CST_LT (size
, integer_zero_node
))
3766 error ("size of array `%s' is negative", name
);
3767 size
= integer_one_node
;
3769 itype
= build_index_type (size_binop (MINUS_EXPR
, size
,
3775 pedwarn ("ANSI C forbids variable-size array `%s'", name
);
3776 itype
= build_binary_op (MINUS_EXPR
, size
, integer_one_node
,
3778 /* Make sure the array size remains visibly nonconstant
3779 even if it is (eg) a const variable with known value. */
3781 itype
= variable_size (itype
);
3782 itype
= build_index_type (itype
);
3786 #if 0 /* This had bad results for pointers to arrays, as in
3787 union incomplete (*foo)[4]; */
3788 /* Complain about arrays of incomplete types, except in typedefs. */
3790 if (TYPE_SIZE (type
) == 0
3791 /* Avoid multiple warnings for nested array types. */
3792 && TREE_CODE (type
) != ARRAY_TYPE
3793 && !(specbits
& (1 << (int) RID_TYPEDEF
))
3794 && !C_TYPE_BEING_DEFINED (type
))
3795 warning ("array type has incomplete element type");
3798 /* Build the array type itself.
3799 Merge any constancy or volatility into the target type. */
3801 #if 0 /* We shouldn't have a function type here at all!
3802 Functions aren't allowed as array elements. */
3803 if (pedantic
&& TREE_CODE (type
) == FUNCTION_TYPE
3804 && (constp
|| volatilep
))
3805 pedwarn ("ANSI C forbids const or volatile function types");
3807 if (constp
|| volatilep
)
3808 type
= c_build_type_variant (type
, constp
, volatilep
);
3810 #if 0 /* don't clear these; leave them set so that the array type
3811 or the variable is itself const or volatile. */
3816 type
= build_array_type (type
, itype
);
3818 C_TYPE_VARIABLE_SIZE (type
) = 1;
3820 else if (TREE_CODE (declarator
) == CALL_EXPR
)
3824 /* Declaring a function type.
3825 Make sure we have a valid type for the function to return. */
3826 if (type
== error_mark_node
)
3831 /* Warn about some types functions can't return. */
3833 if (TREE_CODE (type
) == FUNCTION_TYPE
)
3835 error ("`%s' declared as function returning a function", name
);
3836 type
= integer_type_node
;
3838 if (TREE_CODE (type
) == ARRAY_TYPE
)
3840 error ("`%s' declared as function returning an array", name
);
3841 type
= integer_type_node
;
3844 #ifndef TRADITIONAL_RETURN_FLOAT
3845 /* Traditionally, declaring return type float means double. */
3847 if (flag_traditional
&& type
== float_type_node
)
3848 type
= double_type_node
;
3849 #endif /* TRADITIONAL_RETURN_FLOAT */
3851 /* Construct the function type and go to the next
3852 inner layer of declarator. */
3854 arg_types
= grokparms (TREE_OPERAND (declarator
, 1),
3856 /* Say it's a definition
3857 only for the CALL_EXPR
3858 closest to the identifier. */
3859 && TREE_CODE (TREE_OPERAND (declarator
, 0)) == IDENTIFIER_NODE
);
3860 #if 0 /* This seems to be false. We turn off temporary allocation
3861 above in this function if -traditional.
3862 And this code caused inconsistent results with prototypes:
3863 callers would ignore them, and pass arguments wrong. */
3865 /* Omit the arg types if -traditional, since the arg types
3866 and the list links might not be permanent. */
3867 type
= build_function_type (type
,
3869 ? NULL_TREE
: arg_types
);
3871 type
= build_function_type (type
, arg_types
);
3872 declarator
= TREE_OPERAND (declarator
, 0);
3874 /* Set the TYPE_CONTEXTs for each tagged type which is local to
3875 the formal parameter list of this FUNCTION_TYPE to point to
3876 the FUNCTION_TYPE node itself. */
3881 for (link
= current_function_parm_tags
;
3883 link
= TREE_CHAIN (link
))
3884 TYPE_CONTEXT (TREE_VALUE (link
)) = type
;
3887 else if (TREE_CODE (declarator
) == INDIRECT_REF
)
3889 /* Merge any constancy or volatility into the target type
3892 if (pedantic
&& TREE_CODE (type
) == FUNCTION_TYPE
3893 && (constp
|| volatilep
))
3894 pedwarn ("ANSI C forbids const or volatile function types");
3895 if (constp
|| volatilep
)
3896 type
= c_build_type_variant (type
, constp
, volatilep
);
3901 type
= build_pointer_type (type
);
3903 /* Process a list of type modifier keywords
3904 (such as const or volatile) that were given inside the `*'. */
3906 if (TREE_TYPE (declarator
))
3908 register tree typemodlist
;
3910 for (typemodlist
= TREE_TYPE (declarator
); typemodlist
;
3911 typemodlist
= TREE_CHAIN (typemodlist
))
3913 if (TREE_VALUE (typemodlist
) == ridpointers
[(int) RID_CONST
])
3915 else if (TREE_VALUE (typemodlist
) == ridpointers
[(int) RID_VOLATILE
])
3920 error ("invalid type modifier within pointer declarator");
3924 pedwarn ("duplicate `const'");
3926 pedwarn ("duplicate `volatile'");
3929 declarator
= TREE_OPERAND (declarator
, 0);
3936 /* Now TYPE has the actual type. */
3938 /* If this is declaring a typedef name, return a TYPE_DECL. */
3940 if (specbits
& (1 << (int) RID_TYPEDEF
))
3943 /* Note that the grammar rejects storage classes
3944 in typenames, fields or parameters */
3945 if (pedantic
&& TREE_CODE (type
) == FUNCTION_TYPE
3946 && (constp
|| volatilep
))
3947 pedwarn ("ANSI C forbids const or volatile function types");
3948 if (constp
|| volatilep
)
3949 type
= c_build_type_variant (type
, constp
, volatilep
);
3951 decl
= build_decl (TYPE_DECL
, declarator
, type
);
3952 if ((specbits
& (1 << (int) RID_SIGNED
))
3953 || (typedef_decl
&& C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl
)))
3954 C_TYPEDEF_EXPLICITLY_SIGNED (decl
) = 1;
3958 /* Detect the case of an array type of unspecified size
3959 which came, as such, direct from a typedef name.
3960 We must copy the type, so that each identifier gets
3961 a distinct type, so that each identifier's size can be
3962 controlled separately by its own initializer. */
3964 if (type
!= 0 && typedef_type
!= 0
3965 && TYPE_MAIN_VARIANT (type
) == TYPE_MAIN_VARIANT (typedef_type
)
3966 && TREE_CODE (type
) == ARRAY_TYPE
&& TYPE_DOMAIN (type
) == 0)
3968 type
= build_array_type (TREE_TYPE (type
), 0);
3970 C_TYPE_VARIABLE_SIZE (type
) = 1;
3973 /* If this is a type name (such as, in a cast or sizeof),
3974 compute the type and return it now. */
3976 if (decl_context
== TYPENAME
)
3978 /* Note that the grammar rejects storage classes
3979 in typenames, fields or parameters */
3980 if (pedantic
&& TREE_CODE (type
) == FUNCTION_TYPE
3981 && (constp
|| volatilep
))
3982 pedwarn ("ANSI C forbids const or volatile function types");
3983 if (constp
|| volatilep
)
3984 type
= c_build_type_variant (type
, constp
, volatilep
);
3989 /* `void' at top level (not within pointer)
3990 is allowed only in typedefs or type names.
3991 We don't complain about parms either, but that is because
3992 a better error message can be made later. */
3994 if (type
== void_type_node
&& decl_context
!= PARM
)
3996 error ("variable or field `%s' declared void",
3997 IDENTIFIER_POINTER (declarator
));
3998 type
= integer_type_node
;
4001 /* Now create the decl, which may be a VAR_DECL, a PARM_DECL
4002 or a FUNCTION_DECL, depending on DECL_CONTEXT and TYPE. */
4007 if (decl_context
== PARM
)
4009 tree type_as_written
= type
;
4011 /* A parameter declared as an array of T is really a pointer to T.
4012 One declared as a function is really a pointer to a function. */
4014 if (TREE_CODE (type
) == ARRAY_TYPE
)
4016 /* Transfer const-ness of array into that of type pointed to. */
4017 type
= build_pointer_type
4018 (c_build_type_variant (TREE_TYPE (type
), constp
, volatilep
));
4019 volatilep
= constp
= 0;
4022 else if (TREE_CODE (type
) == FUNCTION_TYPE
)
4024 if (pedantic
&& (constp
|| volatilep
))
4025 pedwarn ("ANSI C forbids const or volatile function types");
4026 type
= build_pointer_type (c_build_type_variant (type
, constp
, volatilep
));
4027 volatilep
= constp
= 0;
4031 error ("parameter `%s' is initialized", name
);
4033 decl
= build_decl (PARM_DECL
, declarator
, type
);
4035 C_DECL_VARIABLE_SIZE (decl
) = 1;
4037 /* Compute the type actually passed in the parmlist,
4038 for the case where there is no prototype.
4039 (For example, shorts and chars are passed as ints.)
4040 When there is a prototype, this is overridden later. */
4042 DECL_ARG_TYPE (decl
) = type
;
4043 if (type
== float_type_node
)
4044 DECL_ARG_TYPE (decl
) = double_type_node
;
4045 /* Don't use TYPE_PREISION to decide whether to promote,
4046 because we should convert short if it's the same size as int,
4047 but we should not convert long if it's the same size as int. */
4048 else if (type
== char_type_node
|| type
== signed_char_type_node
4049 || type
== unsigned_char_type_node
4050 || type
== short_integer_type_node
4051 || type
== short_unsigned_type_node
)
4053 if (TYPE_PRECISION (type
) == TYPE_PRECISION (integer_type_node
)
4054 && TREE_UNSIGNED (type
))
4055 DECL_ARG_TYPE (decl
) = unsigned_type_node
;
4057 DECL_ARG_TYPE (decl
) = integer_type_node
;
4060 DECL_ARG_TYPE_AS_WRITTEN (decl
) = type_as_written
;
4062 else if (decl_context
== FIELD
)
4064 /* Structure field. It may not be a function. */
4066 if (TREE_CODE (type
) == FUNCTION_TYPE
)
4068 error ("field `%s' declared as a function",
4069 IDENTIFIER_POINTER (declarator
));
4070 type
= build_pointer_type (type
);
4072 else if (TREE_CODE (type
) != ERROR_MARK
&& TYPE_SIZE (type
) == 0)
4074 error ("field `%s' has incomplete type",
4075 IDENTIFIER_POINTER (declarator
));
4076 type
= error_mark_node
;
4078 /* Move type qualifiers down to element of an array. */
4079 if (TREE_CODE (type
) == ARRAY_TYPE
&& (constp
|| volatilep
))
4081 type
= build_array_type (c_build_type_variant (TREE_TYPE (type
),
4083 TYPE_DOMAIN (type
));
4084 #if 0 /* Leave the field const or volatile as well. */
4085 constp
= volatilep
= 0;
4088 decl
= build_decl (FIELD_DECL
, declarator
, type
);
4090 C_DECL_VARIABLE_SIZE (decl
) = 1;
4092 else if (TREE_CODE (type
) == FUNCTION_TYPE
)
4094 if (specbits
& (1 << (int) RID_AUTO
)
4095 && (pedantic
|| current_binding_level
== global_binding_level
))
4096 pedwarn ("invalid storage class for function `%s'",
4097 IDENTIFIER_POINTER (declarator
));
4098 if (specbits
& (1 << (int) RID_REGISTER
))
4099 error ("invalid storage class for function `%s'",
4100 IDENTIFIER_POINTER (declarator
));
4101 /* Function declaration not at top level.
4102 Storage classes other than `extern' are not allowed
4103 and `extern' makes no difference. */
4104 if (current_binding_level
!= global_binding_level
4105 && (specbits
& ((1 << (int) RID_STATIC
) | (1 << (int) RID_INLINE
)))
4107 pedwarn ("invalid storage class for function `%s'",
4108 IDENTIFIER_POINTER (declarator
));
4109 decl
= build_decl (FUNCTION_DECL
, declarator
, type
);
4111 if (pedantic
&& (constp
|| volatilep
))
4112 pedwarn ("ANSI C forbids const or volatile functions");
4114 /* Every function declaration is "external"
4115 except for those which are inside a function body
4116 in which `auto' is used.
4117 That is a case not specified by ANSI C,
4118 and we use it for forward declarations for nested functions. */
4119 if (!(specbits
& (1 << (int) RID_AUTO
))
4120 || current_binding_level
== global_binding_level
)
4121 TREE_EXTERNAL (decl
) = 1;
4122 /* Record absence of global scope for `static' or `auto'. */
4124 = !(specbits
& ((1 << (int) RID_STATIC
) | (1 << (int) RID_AUTO
)));
4125 /* Record presence of `inline', if it is reasonable. */
4128 tree last
= tree_last (TYPE_ARG_TYPES (type
));
4130 if (! strcmp (IDENTIFIER_POINTER (declarator
), "main"))
4131 warning ("cannot inline function `main'");
4132 else if (last
&& TREE_VALUE (last
) != void_type_node
)
4133 warning ("inline declaration ignored for function with `...'");
4135 /* Assume that otherwise the function can be inlined. */
4136 TREE_INLINE (decl
) = 1;
4138 if (specbits
& (1 << (int) RID_EXTERN
))
4139 current_extern_inline
= 1;
4144 /* It's a variable. */
4146 /* Move type qualifiers down to element of an array. */
4147 if (TREE_CODE (type
) == ARRAY_TYPE
&& (constp
|| volatilep
))
4149 type
= build_array_type (c_build_type_variant (TREE_TYPE (type
),
4151 TYPE_DOMAIN (type
));
4152 #if 0 /* Leave the variable const or volatile as well. */
4153 constp
= volatilep
= 0;
4157 decl
= build_decl (VAR_DECL
, declarator
, type
);
4159 C_DECL_VARIABLE_SIZE (decl
) = 1;
4162 pedwarn_with_decl (decl
, "variable `%s' declared `inline'");
4164 /* An uninitialized decl with `extern' is a reference. */
4165 TREE_EXTERNAL (decl
)
4166 = !initialized
&& (specbits
& (1 << (int) RID_EXTERN
));
4167 /* At top level, the presence of a `static' or `register' storage
4168 class specifier, or the absence of all storage class specifiers
4169 makes this declaration a definition (perhaps tentative). Also,
4170 the absence of both `static' and `register' makes it public. */
4171 if (current_binding_level
== global_binding_level
)
4175 & ((1 << (int) RID_STATIC
) | (1 << (int) RID_REGISTER
)));
4176 TREE_STATIC (decl
) = ! TREE_EXTERNAL (decl
);
4178 /* Not at top level, only `static' makes a static definition. */
4181 TREE_STATIC (decl
) = (specbits
& (1 << (int) RID_STATIC
)) != 0;
4182 TREE_PUBLIC (decl
) = TREE_EXTERNAL (decl
);
4186 /* Record `register' declaration for warnings on &
4187 and in case doing stupid register allocation. */
4189 if (specbits
& (1 << (int) RID_REGISTER
))
4190 TREE_REGDECL (decl
) = 1;
4192 /* Record constancy and volatility. */
4195 TREE_READONLY (decl
) = 1;
4198 TREE_SIDE_EFFECTS (decl
) = 1;
4199 TREE_THIS_VOLATILE (decl
) = 1;
4201 /* If a type has volatile components, it should be stored in memory.
4202 Otherwise, the fact that those components are volatile
4203 will be ignored, and would even crash the compiler. */
4204 if (C_TYPE_FIELDS_VOLATILE (TREE_TYPE (decl
)))
4205 mark_addressable (decl
);
4213 /* Make a variant type in the proper way for C, propagating qualifiers
4214 down to the element type of an array. */
4217 c_build_type_variant (type
, constp
, volatilep
)
4219 int constp
, volatilep
;
4221 if (TREE_CODE (type
) == ARRAY_TYPE
)
4222 type
= build_array_type (c_build_type_variant (TREE_TYPE (type
),
4224 TYPE_DOMAIN (type
));
4225 return build_type_variant (type
, constp
, volatilep
);
4228 /* Decode the parameter-list info for a function type or function definition.
4229 The argument is the value returned by `get_parm_info' (or made in parse.y
4230 if there is an identifier list instead of a parameter decl list).
4231 These two functions are separate because when a function returns
4232 or receives functions then each is called multiple times but the order
4233 of calls is different. The last call to `grokparms' is always the one
4234 that contains the formal parameter names of a function definition.
4236 Store in `last_function_parms' a chain of the decls of parms.
4237 Also store in `last_function_parm_tags' a chain of the struct, union,
4238 and enum tags declared among the parms.
4240 Return a list of arg types to use in the FUNCTION_TYPE for this function.
4242 FUNCDEF_FLAG is nonzero for a function definition, 0 for
4243 a mere declaration. A nonempty identifier-list gets an error message
4244 when FUNCDEF_FLAG is zero. */
4247 grokparms (parms_info
, funcdef_flag
)
4251 tree first_parm
= TREE_CHAIN (parms_info
);
4253 last_function_parms
= TREE_PURPOSE (parms_info
);
4254 last_function_parm_tags
= TREE_VALUE (parms_info
);
4256 if (warn_strict_prototypes
&& first_parm
== 0 && !funcdef_flag
)
4257 warning ("function declaration isn't a prototype");
4260 && TREE_CODE (TREE_VALUE (first_parm
)) == IDENTIFIER_NODE
)
4263 pedwarn ("parameter names (without types) in function declaration");
4265 last_function_parms
= first_parm
;
4272 /* We no longer test FUNCDEF_FLAG.
4273 If the arg types are incomplete in a declaration,
4274 they must include undefined tags.
4275 These tags can never be defined in the scope of the declaration,
4276 so the types can never be completed,
4277 and no call can be compiled successfully. */
4279 /* In a fcn definition, arg types must be complete. */
4282 for (parm
= last_function_parms
, typelt
= first_parm
;
4284 parm
= TREE_CHAIN (parm
))
4285 /* Skip over any enumeration constants declared here. */
4286 if (TREE_CODE (parm
) == PARM_DECL
)
4288 /* Barf if the parameter itself has an incomplete type. */
4289 tree type
= TREE_VALUE (typelt
);
4290 if (TYPE_SIZE (type
) == 0)
4292 if (funcdef_flag
&& DECL_NAME (parm
) != 0)
4293 error ("parameter `%s' has incomplete type",
4294 IDENTIFIER_POINTER (DECL_NAME (parm
)));
4296 warning ("parameter has incomplete type");
4299 TREE_VALUE (typelt
) = error_mark_node
;
4300 TREE_TYPE (parm
) = error_mark_node
;
4303 #if 0 /* This has been replaced by parm_tags_warning
4304 which uses a more accurate criterion for what to warn about. */
4307 /* Now warn if is a pointer to an incomplete type. */
4308 while (TREE_CODE (type
) == POINTER_TYPE
4309 || TREE_CODE (type
) == REFERENCE_TYPE
)
4310 type
= TREE_TYPE (type
);
4311 type
= TYPE_MAIN_VARIANT (type
);
4312 if (TYPE_SIZE (type
) == 0)
4314 if (DECL_NAME (parm
) != 0)
4315 warning ("parameter `%s' points to incomplete type",
4316 IDENTIFIER_POINTER (DECL_NAME (parm
)));
4318 warning ("parameter points to incomplete type");
4322 typelt
= TREE_CHAIN (typelt
);
4330 /* Return a tree_list node with info on a parameter list just parsed.
4331 The TREE_PURPOSE is a chain of decls of those parms.
4332 The TREE_VALUE is a list of structure, union and enum tags defined.
4333 The TREE_CHAIN is a list of argument types to go in the FUNCTION_TYPE.
4334 This tree_list node is later fed to `grokparms'.
4336 VOID_AT_END nonzero means append `void' to the end of the type-list.
4337 Zero means the parmlist ended with an ellipsis so don't append `void'. */
4340 get_parm_info (void_at_end
)
4343 register tree decl
, t
;
4344 register tree types
= 0;
4346 tree tags
= gettags ();
4347 tree parms
= getdecls ();
4349 tree order
= current_binding_level
->parm_order
;
4351 /* Just `void' (and no ellipsis) is special. There are really no parms. */
4352 if (void_at_end
&& parms
!= 0
4353 && TREE_CHAIN (parms
) == 0
4354 && TREE_TYPE (parms
) == void_type_node
4355 && DECL_NAME (parms
) == 0)
4358 storedecls (NULL_TREE
);
4359 return saveable_tree_cons (NULL_TREE
, NULL_TREE
,
4360 saveable_tree_cons (NULL_TREE
, void_type_node
, NULL_TREE
));
4363 /* Extract enumerator values and other non-parms declared with the parms.
4364 Likewise any forward parm decls that didn't have real parm decls. */
4365 for (decl
= parms
; decl
; )
4367 tree next
= TREE_CHAIN (decl
);
4369 if (TREE_CODE (decl
) != PARM_DECL
)
4371 TREE_CHAIN (decl
) = new_parms
;
4374 else if (TREE_ASM_WRITTEN (decl
))
4376 error_with_decl (decl
, "parameter `%s' has just a forward declaration");
4377 TREE_CHAIN (decl
) = new_parms
;
4383 /* Put the parm decls back in the order they were in in the parm list. */
4384 for (t
= order
; t
; t
= TREE_CHAIN (t
))
4387 TREE_CHAIN (TREE_VALUE (t
)) = TREE_VALUE (TREE_CHAIN (t
));
4389 TREE_CHAIN (TREE_VALUE (t
)) = 0;
4392 new_parms
= chainon (order
? nreverse (TREE_VALUE (order
)) : 0,
4395 /* Store the parmlist in the binding level since the old one
4396 is no longer a valid list. (We have changed the chain pointers.) */
4397 storedecls (new_parms
);
4399 for (decl
= new_parms
; decl
; decl
= TREE_CHAIN (decl
))
4400 /* There may also be declarations for enumerators if an enumeration
4401 type is declared among the parms. Ignore them here. */
4402 if (TREE_CODE (decl
) == PARM_DECL
)
4404 /* Since there is a prototype,
4405 args are passed in their declared types. */
4406 tree type
= TREE_TYPE (decl
);
4407 DECL_ARG_TYPE (decl
) = type
;
4408 #ifdef PROMOTE_PROTOTYPES
4409 if (TREE_CODE (type
) == INTEGER_TYPE
4410 && TYPE_PRECISION (type
) < TYPE_PRECISION (integer_type_node
))
4411 DECL_ARG_TYPE (decl
) = integer_type_node
;
4414 types
= saveable_tree_cons (NULL_TREE
, TREE_TYPE (decl
), types
);
4415 if (TREE_VALUE (types
) == void_type_node
&& ! erred
4416 && DECL_NAME (decl
) == 0)
4418 error ("`void' in parameter list must be the entire list");
4424 return saveable_tree_cons (new_parms
, tags
,
4425 nreverse (saveable_tree_cons (NULL_TREE
, void_type_node
, types
)));
4427 return saveable_tree_cons (new_parms
, tags
, nreverse (types
));
4430 /* At end of parameter list, warn about any struct, union or enum tags
4431 defined within. Do so because these types cannot ever become complete. */
4434 parmlist_tags_warning ()
4439 for (elt
= current_binding_level
->tags
; elt
; elt
= TREE_CHAIN (elt
))
4441 enum tree_code code
= TREE_CODE (TREE_VALUE (elt
));
4442 /* An anonymous union parm type is meaningful as a GNU extension.
4443 So don't warn for that. */
4444 if (code
== UNION_TYPE
&& !pedantic
)
4446 if (TREE_PURPOSE (elt
) != 0)
4447 warning ("`%s %s' declared inside parameter list",
4448 (code
== RECORD_TYPE
? "struct"
4449 : code
== UNION_TYPE
? "union"
4451 IDENTIFIER_POINTER (TREE_PURPOSE (elt
)));
4453 warning ("anonymous %s declared inside parameter list",
4454 (code
== RECORD_TYPE
? "struct"
4455 : code
== UNION_TYPE
? "union"
4460 warning ("its scope is only this definition or declaration,");
4461 warning ("which is probably not what you want.");
4467 /* Get the struct, enum or union (CODE says which) with tag NAME.
4468 Define the tag as a forward-reference if it is not defined. */
4471 xref_tag (code
, name
)
4472 enum tree_code code
;
4475 int temporary
= allocation_temporary_p ();
4477 /* If a cross reference is requested, look up the type
4478 already defined for this tag and return it. */
4480 register tree ref
= lookup_tag (code
, name
, current_binding_level
, 0);
4481 /* Even if this is the wrong type of tag, return what we found.
4482 There will be an error message anyway, from pending_xref_error.
4483 If we create an empty xref just for an invalid use of the type,
4484 the main result is to create lots of superfluous error messages. */
4488 push_obstacks_nochange ();
4490 if (current_binding_level
== global_binding_level
&& temporary
)
4491 end_temporary_allocation ();
4493 /* If no such tag is yet defined, create a forward-reference node
4494 and record it as the "definition".
4495 When a real declaration of this type is found,
4496 the forward-reference will be altered into a real type. */
4498 ref
= make_node (code
);
4499 if (code
== ENUMERAL_TYPE
)
4501 /* (In ANSI, Enums can be referred to only if already defined.) */
4503 pedwarn ("ANSI C forbids forward references to `enum' types");
4504 /* Give the type a default layout like unsigned int
4505 to avoid crashing if it does not get defined. */
4506 TYPE_MODE (ref
) = TYPE_MODE (unsigned_type_node
);
4507 TYPE_ALIGN (ref
) = TYPE_ALIGN (unsigned_type_node
);
4508 TREE_UNSIGNED (ref
) = 1;
4509 TYPE_PRECISION (ref
) = TYPE_PRECISION (unsigned_type_node
);
4510 TYPE_MIN_VALUE (ref
) = TYPE_MIN_VALUE (unsigned_type_node
);
4511 TYPE_MAX_VALUE (ref
) = TYPE_MAX_VALUE (unsigned_type_node
);
4514 pushtag (name
, ref
);
4521 /* Make sure that the tag NAME is defined *in the current binding level*
4522 at least as a forward reference.
4523 CODE says which kind of tag NAME ought to be. */
4526 start_struct (code
, name
)
4527 enum tree_code code
;
4530 /* If there is already a tag defined at this binding level
4531 (as a forward reference), just return it. */
4533 register tree ref
= 0;
4536 ref
= lookup_tag (code
, name
, current_binding_level
, 1);
4537 if (ref
&& TREE_CODE (ref
) == code
)
4539 C_TYPE_BEING_DEFINED (ref
) = 1;
4540 if (TYPE_FIELDS (ref
))
4541 error ((code
== UNION_TYPE
? "redefinition of `union %s'"
4542 : "redefinition of `struct %s'"),
4543 IDENTIFIER_POINTER (name
));
4548 /* Otherwise create a forward-reference just so the tag is in scope. */
4550 ref
= make_node (code
);
4551 pushtag (name
, ref
);
4552 C_TYPE_BEING_DEFINED (ref
) = 1;
4556 /* Process the specs, declarator (NULL if omitted) and width (NULL if omitted)
4557 of a structure component, returning a FIELD_DECL node.
4558 WIDTH is non-NULL for bit fields only, and is an INTEGER_CST node.
4560 This is done during the parsing of the struct declaration.
4561 The FIELD_DECL nodes are chained together and the lot of them
4562 are ultimately passed to `build_struct' to make the RECORD_TYPE node. */
4565 grokfield (filename
, line
, declarator
, declspecs
, width
)
4568 tree declarator
, declspecs
, width
;
4572 /* The corresponding pop_obstacks is in finish_decl. */
4573 push_obstacks_nochange ();
4575 value
= grokdeclarator (declarator
, declspecs
, width
? BITFIELD
: FIELD
, 0);
4577 finish_decl (value
, NULL_TREE
, NULL_TREE
);
4578 DECL_INITIAL (value
) = width
;
4583 /* Function to help qsort sort FIELD_DECLs by name order. */
4586 field_decl_cmp (x
, y
)
4589 return (long)DECL_NAME (*x
) - (long)DECL_NAME (*y
);
4592 /* Fill in the fields of a RECORD_TYPE or UNION_TYPE node, T.
4593 FIELDLIST is a chain of FIELD_DECL nodes for the fields. */
4596 finish_struct (t
, fieldlist
)
4597 register tree t
, fieldlist
;
4601 int toplevel
= global_binding_level
== current_binding_level
;
4603 /* If this type was previously laid out as a forward reference,
4604 make sure we lay it out again. */
4608 /* Nameless union parm types are useful as GCC extension. */
4609 if (! (TREE_CODE (t
) == UNION_TYPE
&& TYPE_NAME (t
) == 0) && !pedantic
)
4610 /* Otherwise, warn about any struct or union def. in parmlist. */
4611 if (in_parm_level_p ())
4614 pedwarn ((TREE_CODE (t
) == UNION_TYPE
? "union defined inside parms"
4615 : "structure defined inside parms"));
4617 warning ((TREE_CODE (t
) == UNION_TYPE
? "union defined inside parms"
4618 : "structure defined inside parms"));
4621 old_momentary
= suspend_momentary ();
4623 if (fieldlist
== 0 && pedantic
)
4624 pedwarn ((TREE_CODE (t
) == UNION_TYPE
? "union has no members"
4625 : "structure has no members"));
4627 /* Install struct as DECL_CONTEXT of each field decl.
4628 Also process specified field sizes.
4629 Set DECL_FIELD_SIZE to the specified size, or 0 if none specified.
4630 The specified size is found in the DECL_INITIAL.
4631 Store 0 there, except for ": 0" fields (so we can find them
4632 and delete them, below). */
4634 for (x
= fieldlist
; x
; x
= TREE_CHAIN (x
))
4636 DECL_CONTEXT (x
) = t
;
4637 DECL_FIELD_SIZE (x
) = 0;
4639 /* If any field is const, the structure type is pseudo-const. */
4640 if (TREE_READONLY (x
))
4641 C_TYPE_FIELDS_READONLY (t
) = 1;
4644 /* A field that is pseudo-const makes the structure likewise. */
4645 tree t1
= TREE_TYPE (x
);
4646 while (TREE_CODE (t1
) == ARRAY_TYPE
)
4647 t1
= TREE_TYPE (t1
);
4648 if ((TREE_CODE (t1
) == RECORD_TYPE
|| TREE_CODE (t1
) == UNION_TYPE
)
4649 && C_TYPE_FIELDS_READONLY (t1
))
4650 C_TYPE_FIELDS_READONLY (t
) = 1;
4653 /* Any field that is volatile means variables of this type must be
4654 treated in some ways as volatile. */
4655 if (TREE_THIS_VOLATILE (x
))
4656 C_TYPE_FIELDS_VOLATILE (t
) = 1;
4658 /* Any field of nominal variable size implies structure is too. */
4659 if (C_DECL_VARIABLE_SIZE (x
))
4660 C_TYPE_VARIABLE_SIZE (t
) = 1;
4662 /* Detect invalid bit-field size. */
4663 if (DECL_INITIAL (x
))
4664 STRIP_NOPS (DECL_INITIAL (x
));
4665 if (DECL_INITIAL (x
) && TREE_CODE (DECL_INITIAL (x
)) != INTEGER_CST
)
4667 error_with_decl (x
, "bit-field `%s' width not an integer constant");
4668 DECL_INITIAL (x
) = NULL
;
4671 /* Detect invalid bit-field type. */
4672 if (DECL_INITIAL (x
)
4673 && TREE_CODE (TREE_TYPE (x
)) != INTEGER_TYPE
4674 && TREE_CODE (TREE_TYPE (x
)) != ENUMERAL_TYPE
)
4676 error_with_decl (x
, "bit-field `%s' has invalid type");
4677 DECL_INITIAL (x
) = NULL
;
4679 if (DECL_INITIAL (x
) && pedantic
4680 && TYPE_MAIN_VARIANT (TREE_TYPE (x
)) != integer_type_node
4681 && TYPE_MAIN_VARIANT (TREE_TYPE (x
)) != unsigned_type_node
)
4682 pedwarn_with_decl (x
, "bit-field `%s' type invalid in ANSI C");
4684 /* Detect and ignore out of range field width. */
4685 if (DECL_INITIAL (x
))
4687 register int width
= TREE_INT_CST_LOW (DECL_INITIAL (x
));
4691 DECL_INITIAL (x
) = NULL
;
4692 error_with_decl (x
, "negative width in bit-field `%s'");
4694 else if (width
== 0 && DECL_NAME (x
) != 0)
4696 error_with_decl (x
, "zero width for bit-field `%s'");
4697 DECL_INITIAL (x
) = NULL
;
4699 else if (width
> TYPE_PRECISION (TREE_TYPE (x
))
4700 || TREE_INT_CST_HIGH (DECL_INITIAL (x
)) != 0)
4702 DECL_INITIAL (x
) = NULL
;
4703 pedwarn_with_decl (x
, "width of `%s' exceeds its type");
4707 /* Process valid field width. */
4708 if (DECL_INITIAL (x
))
4710 register int width
= TREE_INT_CST_LOW (DECL_INITIAL (x
));
4712 DECL_FIELD_SIZE (x
) = width
;
4713 DECL_BIT_FIELD (x
) = 1;
4714 DECL_INITIAL (x
) = NULL
;
4718 /* field size 0 => force desired amount of alignment. */
4719 #ifdef EMPTY_FIELD_BOUNDARY
4720 DECL_ALIGN (x
) = MAX (DECL_ALIGN (x
), EMPTY_FIELD_BOUNDARY
);
4722 #ifdef PCC_BITFIELD_TYPE_MATTERS
4723 DECL_ALIGN (x
) = MAX (DECL_ALIGN (x
),
4724 TYPE_ALIGN (TREE_TYPE (x
)));
4730 int min_align
= (DECL_PACKED (x
) ? BITS_PER_UNIT
4731 : TYPE_ALIGN (TREE_TYPE (x
)));
4732 /* Non-bit-fields are aligned for their type, except packed
4733 fields which require only BITS_PER_UNIT alignment. */
4734 DECL_ALIGN (x
) = MAX (DECL_ALIGN (x
), min_align
);
4738 /* Now DECL_INITIAL is null on all members. */
4740 /* Delete all duplicate fields from the fieldlist */
4741 for (x
= fieldlist
; x
&& TREE_CHAIN (x
);)
4742 /* Anonymous fields aren't duplicates. */
4743 if (DECL_NAME (TREE_CHAIN (x
)) == 0)
4747 register tree y
= fieldlist
;
4751 if (DECL_NAME (y
) == DECL_NAME (TREE_CHAIN (x
)))
4757 if (DECL_NAME (y
) == DECL_NAME (TREE_CHAIN (x
)))
4759 error_with_decl (TREE_CHAIN (x
), "duplicate member `%s'");
4760 TREE_CHAIN (x
) = TREE_CHAIN (TREE_CHAIN (x
));
4762 else x
= TREE_CHAIN (x
);
4765 /* Now we have the nearly final fieldlist. Record it,
4766 then lay out the structure or union (including the fields). */
4768 TYPE_FIELDS (t
) = fieldlist
;
4772 /* Delete all zero-width bit-fields from the front of the fieldlist */
4774 && DECL_INITIAL (fieldlist
))
4775 fieldlist
= TREE_CHAIN (fieldlist
);
4776 /* Delete all such members from the rest of the fieldlist */
4777 for (x
= fieldlist
; x
;)
4779 if (TREE_CHAIN (x
) && DECL_INITIAL (TREE_CHAIN (x
)))
4780 TREE_CHAIN (x
) = TREE_CHAIN (TREE_CHAIN (x
));
4781 else x
= TREE_CHAIN (x
);
4784 /* Now we have the truly final field list.
4785 Store it in this type and in the variants. */
4787 TYPE_FIELDS (t
) = fieldlist
;
4789 /* If there are lots of fields, sort so we can look through them fast.
4790 We arbitrarily consider 16 or more elts to be "a lot". */
4794 for (x
= fieldlist
; x
; x
= TREE_CHAIN (x
))
4805 len
+= list_length (x
);
4806 /* Use the same allocation policy here that make_node uses, to
4807 ensure that this lives as long as the rest of the struct decl.
4808 All decls in an inline function need to be saved. */
4809 if (allocation_temporary_p ())
4810 space
= savealloc (sizeof (struct lang_type
) + len
* sizeof (tree
));
4812 space
= oballoc (sizeof (struct lang_type
) + len
* sizeof (tree
));
4814 TYPE_LANG_SPECIFIC (t
) = (struct lang_type
*) space
;
4815 TYPE_LANG_SPECIFIC (t
)->len
= len
;
4817 field_array
= &TYPE_LANG_SPECIFIC (t
)->elts
[0];
4819 for (x
= fieldlist
; x
; x
= TREE_CHAIN (x
))
4820 field_array
[len
++] = x
;
4822 qsort (field_array
, len
, sizeof (tree
), field_decl_cmp
);
4826 for (x
= TYPE_MAIN_VARIANT (t
); x
; x
= TYPE_NEXT_VARIANT (x
))
4828 TYPE_FIELDS (x
) = TYPE_FIELDS (t
);
4829 TYPE_LANG_SPECIFIC (x
) = TYPE_LANG_SPECIFIC (t
);
4830 TYPE_ALIGN (x
) = TYPE_ALIGN (t
);
4833 /* Promote each bit-field's type to int if it is narrower than that. */
4834 for (x
= fieldlist
; x
; x
= TREE_CHAIN (x
))
4835 if (DECL_BIT_FIELD (x
)
4836 && TREE_CODE (TREE_TYPE (x
)) == INTEGER_TYPE
4837 && (TYPE_PRECISION (TREE_TYPE (x
))
4838 < TYPE_PRECISION (integer_type_node
)))
4839 TREE_TYPE (x
) = integer_type_node
;
4841 /* If this structure or union completes the type of any previous
4842 variable declaration, lay it out and output its rtl. */
4844 if (current_binding_level
->n_incomplete
!= 0)
4847 for (decl
= current_binding_level
->names
; decl
; decl
= TREE_CHAIN (decl
))
4849 if (TREE_TYPE (decl
) == t
4850 && TREE_CODE (decl
) != TYPE_DECL
)
4852 layout_decl (decl
, 0);
4853 /* This is a no-op in c-lang.c or something real in objc-actions.c. */
4854 maybe_objc_check_decl (decl
);
4855 rest_of_decl_compilation (decl
, NULL_PTR
, toplevel
, 0);
4858 --current_binding_level
->n_incomplete
;
4860 else if (TYPE_SIZE (TREE_TYPE (decl
)) == 0
4861 && TREE_CODE (TREE_TYPE (decl
)) == ARRAY_TYPE
)
4863 tree element
= TREE_TYPE (decl
);
4864 while (TREE_CODE (element
) == ARRAY_TYPE
)
4865 element
= TREE_TYPE (element
);
4867 layout_array_type (TREE_TYPE (decl
));
4872 resume_momentary (old_momentary
);
4874 /* Finish debugging output for this type. */
4875 rest_of_type_compilation (t
, toplevel
);
4880 /* Lay out the type T, and its element type, and so on. */
4883 layout_array_type (t
)
4886 if (TREE_CODE (TREE_TYPE (t
)) == ARRAY_TYPE
)
4887 layout_array_type (TREE_TYPE (t
));
4891 /* Begin compiling the definition of an enumeration type.
4892 NAME is its name (or null if anonymous).
4893 Returns the type object, as yet incomplete.
4894 Also records info about it so that build_enumerator
4895 may be used to declare the individual values as they are read. */
4901 register tree enumtype
= 0;
4903 /* If this is the real definition for a previous forward reference,
4904 fill in the contents in the same object that used to be the
4905 forward reference. */
4908 enumtype
= lookup_tag (ENUMERAL_TYPE
, name
, current_binding_level
, 1);
4910 if (enumtype
== 0 || TREE_CODE (enumtype
) != ENUMERAL_TYPE
)
4912 enumtype
= make_node (ENUMERAL_TYPE
);
4913 pushtag (name
, enumtype
);
4916 C_TYPE_BEING_DEFINED (enumtype
) = 1;
4918 if (TYPE_VALUES (enumtype
) != 0)
4920 /* This enum is a named one that has been declared already. */
4921 error ("redeclaration of `enum %s'", IDENTIFIER_POINTER (name
));
4923 /* Completely replace its old definition.
4924 The old enumerators remain defined, however. */
4925 TYPE_VALUES (enumtype
) = 0;
4928 enum_next_value
= integer_zero_node
;
4934 /* After processing and defining all the values of an enumeration type,
4935 install their decls in the enumeration type and finish it off.
4936 ENUMTYPE is the type object and VALUES a list of decl-value pairs.
4937 Returns ENUMTYPE. */
4940 finish_enum (enumtype
, values
)
4941 register tree enumtype
, values
;
4944 tree minnode
= 0, maxnode
= 0;
4945 register HOST_WIDE_INT maxvalue
= 0;
4946 register HOST_WIDE_INT minvalue
= 0;
4948 unsigned precision
= 0;
4949 int toplevel
= global_binding_level
== current_binding_level
;
4951 if (in_parm_level_p ())
4952 warning ("enum defined inside parms");
4954 /* Calculate the maximum value of any enumerator in this type. */
4956 for (pair
= values
; pair
; pair
= TREE_CHAIN (pair
))
4958 tree value
= TREE_VALUE (pair
);
4960 minnode
= maxnode
= TREE_VALUE (pair
);
4963 if (tree_int_cst_lt (maxnode
, value
))
4965 if (tree_int_cst_lt (value
, minnode
))
4970 TYPE_MIN_VALUE (enumtype
) = minnode
;
4971 TYPE_MAX_VALUE (enumtype
) = maxnode
;
4973 /* Determine the precision this type needs. */
4975 if (TREE_INT_CST_HIGH (minnode
) >= 0
4976 ? tree_int_cst_lt (TYPE_MAX_VALUE (unsigned_type_node
), maxnode
)
4977 : (tree_int_cst_lt (minnode
, TYPE_MIN_VALUE (integer_type_node
))
4978 || tree_int_cst_lt (TYPE_MAX_VALUE (integer_type_node
), maxnode
)))
4979 precision
= TYPE_PRECISION (long_long_integer_type_node
);
4982 maxvalue
= TREE_INT_CST_LOW (maxnode
);
4983 minvalue
= TREE_INT_CST_LOW (minnode
);
4986 precision
= floor_log2 (maxvalue
) + 1;
4989 /* Compute number of bits to represent magnitude of a negative value.
4990 Add one to MINVALUE since range of negative numbers
4991 includes the power of two. */
4992 unsigned negprecision
= floor_log2 (-minvalue
- 1) + 1;
4993 if (negprecision
> precision
)
4994 precision
= negprecision
;
4995 precision
+= 1; /* room for sign bit */
5002 if (flag_short_enums
|| precision
> TYPE_PRECISION (integer_type_node
))
5003 /* Use the width of the narrowest normal C type which is wide enough. */
5004 TYPE_PRECISION (enumtype
) = TYPE_PRECISION (type_for_size (precision
, 1));
5006 TYPE_PRECISION (enumtype
) = TYPE_PRECISION (integer_type_node
);
5008 TYPE_SIZE (enumtype
) = 0;
5009 layout_type (enumtype
);
5011 /* An enum can have some negative values; then it is signed. */
5012 TREE_UNSIGNED (enumtype
) = ! tree_int_cst_lt (minnode
, integer_zero_node
);
5014 /* If the enumerators might not fit in an int, change their type now. */
5015 /* It seems more useful in the debugger to leave these as int
5016 unless the enumerator is wider than int. */
5017 if (TYPE_PRECISION (enumtype
) <= TYPE_PRECISION (integer_type_node
))
5018 for (pair
= values
; pair
; pair
= TREE_CHAIN (pair
))
5020 TREE_TYPE (TREE_PURPOSE (pair
)) = enumtype
;
5021 DECL_SIZE (TREE_PURPOSE (pair
)) = TYPE_SIZE (enumtype
);
5022 if (TREE_CODE (TREE_PURPOSE (pair
)) != FUNCTION_DECL
)
5023 DECL_ALIGN (TREE_PURPOSE (pair
)) = TYPE_ALIGN (enumtype
);
5026 /* Replace the decl nodes in VALUES with their names. */
5027 for (pair
= values
; pair
; pair
= TREE_CHAIN (pair
))
5028 TREE_PURPOSE (pair
) = DECL_NAME (TREE_PURPOSE (pair
));
5030 TYPE_VALUES (enumtype
) = values
;
5032 /* Finish debugging output for this type. */
5033 rest_of_type_compilation (enumtype
, toplevel
);
5038 /* Build and install a CONST_DECL for one value of the
5039 current enumeration type (one that was begun with start_enum).
5040 Return a tree-list containing the CONST_DECL and its value.
5041 Assignment of sequential values by default is handled here. */
5044 build_enumerator (name
, value
)
5049 /* Validate and default VALUE. */
5051 /* Remove no-op casts from the value. */
5054 if (value
!= 0 && TREE_CODE (value
) != INTEGER_CST
)
5056 error ("enumerator value for `%s' not integer constant",
5057 IDENTIFIER_POINTER (name
));
5061 /* Default based on previous value. */
5062 /* It should no longer be possible to have NON_LVALUE_EXPR
5066 value
= enum_next_value
;
5068 error ("overflow in enumeration values");
5071 if (pedantic
&& ! int_fits_type_p (value
, integer_type_node
))
5073 pedwarn ("ANSI C restricts enumerator values to range of `int'");
5074 value
= integer_zero_node
;
5077 /* Set basis for default for next value. */
5078 enum_next_value
= build_binary_op (PLUS_EXPR
, value
, integer_one_node
, 0);
5079 enum_overflow
= tree_int_cst_lt (enum_next_value
, value
);
5081 /* Now create a declaration for the enum value name. */
5083 decl
= build_decl (CONST_DECL
, name
, integer_type_node
);
5084 DECL_INITIAL (decl
) = value
;
5085 TREE_TYPE (value
) = integer_type_node
;
5088 return saveable_tree_cons (decl
, value
, NULL_TREE
);
5091 /* Create the FUNCTION_DECL for a function definition.
5092 DECLSPECS and DECLARATOR are the parts of the declaration;
5093 they describe the function's name and the type it returns,
5094 but twisted together in a fashion that parallels the syntax of C.
5096 This function creates a binding context for the function body
5097 as well as setting up the FUNCTION_DECL in current_function_decl.
5099 Returns 1 on success. If the DECLARATOR is not suitable for a function
5100 (it defines a datum instead), we return 0, which tells
5101 yyparse to report a parse error.
5103 NESTED is nonzero for a function nested within another function. */
5106 start_function (declspecs
, declarator
, nested
)
5107 tree declarator
, declspecs
;
5110 tree decl1
, old_decl
;
5113 current_function_returns_value
= 0; /* Assume, until we see it does. */
5114 current_function_returns_null
= 0;
5115 warn_about_return_type
= 0;
5116 current_extern_inline
= 0;
5117 c_function_varargs
= 0;
5119 shadowed_labels
= 0;
5121 decl1
= grokdeclarator (declarator
, declspecs
, FUNCDEF
, 1);
5123 /* If the declarator is not suitable for a function definition,
5124 cause a syntax error. */
5128 announce_function (decl1
);
5130 if (TYPE_SIZE (TREE_TYPE (TREE_TYPE (decl1
))) == 0)
5132 error ("return-type is an incomplete type");
5133 /* Make it return void instead. */
5135 = build_function_type (void_type_node
,
5136 TYPE_ARG_TYPES (TREE_TYPE (decl1
)));
5139 if (warn_about_return_type
)
5140 warning ("return-type defaults to `int'");
5142 /* Save the parm names or decls from this function's declarator
5143 where store_parm_decls will find them. */
5144 current_function_parms
= last_function_parms
;
5145 current_function_parm_tags
= last_function_parm_tags
;
5147 /* Make the init_value nonzero so pushdecl knows this is not tentative.
5148 error_mark_node is replaced below (in poplevel) with the BLOCK. */
5149 DECL_INITIAL (decl1
) = error_mark_node
;
5151 /* If this definition isn't a prototype and we had a prototype declaration
5152 before, copy the arg type info from that prototype.
5153 But not if what we had before was a builtin function. */
5154 old_decl
= lookup_name_current_level (DECL_NAME (decl1
));
5155 if (old_decl
!= 0 && TREE_CODE (TREE_TYPE (old_decl
)) == FUNCTION_TYPE
5156 && !DECL_BUILT_IN (old_decl
)
5157 && TREE_TYPE (TREE_TYPE (decl1
)) == TREE_TYPE (TREE_TYPE (old_decl
))
5158 && TYPE_ARG_TYPES (TREE_TYPE (decl1
)) == 0)
5159 TREE_TYPE (decl1
) = TREE_TYPE (old_decl
);
5161 /* Optionally warn of old-fashioned def with no previous prototype. */
5162 if (warn_strict_prototypes
5163 && TYPE_ARG_TYPES (TREE_TYPE (decl1
)) == 0
5164 && !(old_decl
!= 0 && TYPE_ARG_TYPES (TREE_TYPE (old_decl
)) != 0))
5165 warning ("function declaration isn't a prototype");
5166 /* Optionally warn of any global def with no previous prototype. */
5167 else if (warn_missing_prototypes
5168 && TREE_PUBLIC (decl1
)
5169 && !(old_decl
!= 0 && TYPE_ARG_TYPES (TREE_TYPE (old_decl
)) != 0))
5170 warning_with_decl (decl1
, "no previous prototype for `%s'");
5171 /* Optionally warn of any def with no previous prototype
5172 if the function has already been used. */
5173 else if (warn_missing_prototypes
5174 && old_decl
!= 0 && TREE_USED (old_decl
)
5175 && !(old_decl
!= 0 && TYPE_ARG_TYPES (TREE_TYPE (old_decl
)) != 0))
5176 warning_with_decl (decl1
, "`%s' was used with no prototype before its definition");
5178 /* This is a definition, not a reference.
5179 So normally clear TREE_EXTERNAL.
5180 However, `extern inline' acts like a declaration
5181 except for defining how to inline. So set TREE_EXTERNAL in that case. */
5182 TREE_EXTERNAL (decl1
) = current_extern_inline
;
5184 /* This function exists in static storage.
5185 (This does not mean `static' in the C sense!) */
5186 TREE_STATIC (decl1
) = 1;
5188 /* A nested function is not global. */
5189 if (current_function_decl
!= 0)
5190 TREE_PUBLIC (decl1
) = 0;
5192 /* Record the decl so that the function name is defined.
5193 If we already have a decl for this name, and it is a FUNCTION_DECL,
5194 use the old decl. */
5196 current_function_decl
= pushdecl (decl1
);
5199 declare_parm_level (1);
5200 current_binding_level
->subblocks_tag_transparent
= 1;
5202 make_function_rtl (current_function_decl
);
5204 restype
= TREE_TYPE (TREE_TYPE (current_function_decl
));
5205 /* Promote the value to int before returning it. */
5206 if (TREE_CODE (restype
) == INTEGER_TYPE
5207 && TYPE_PRECISION (restype
) < TYPE_PRECISION (integer_type_node
))
5208 restype
= integer_type_node
;
5209 DECL_RESULT (current_function_decl
)
5210 = build_decl (RESULT_DECL
, NULL_TREE
, restype
);
5213 /* Allocate further tree nodes temporarily during compilation
5214 of this function only. */
5215 temporary_allocation ();
5217 /* If this fcn was already referenced via a block-scope `extern' decl
5218 (or an implicit decl), propagate certain information about the usage. */
5219 if (TREE_ADDRESSABLE (DECL_ASSEMBLER_NAME (current_function_decl
)))
5220 TREE_ADDRESSABLE (current_function_decl
) = 1;
5225 /* Record that this function is going to be a varargs function.
5226 This is called before store_parm_decls, which is too early
5227 to call mark_varargs directly. */
5232 c_function_varargs
= 1;
5235 /* Store the parameter declarations into the current function declaration.
5236 This is called after parsing the parameter declarations, before
5237 digesting the body of the function.
5239 For an old-style definition, modify the function's type
5240 to specify at least the number of arguments. */
5245 register tree fndecl
= current_function_decl
;
5248 /* This is either a chain of PARM_DECLs (if a prototype was used)
5249 or a list of IDENTIFIER_NODEs (for an old-fashioned C definition). */
5250 tree specparms
= current_function_parms
;
5252 /* This is a list of types declared among parms in a prototype. */
5253 tree parmtags
= current_function_parm_tags
;
5255 /* This is a chain of PARM_DECLs from old-style parm declarations. */
5256 register tree parmdecls
= getdecls ();
5258 /* This is a chain of any other decls that came in among the parm
5259 declarations. If a parm is declared with enum {foo, bar} x;
5260 then CONST_DECLs for foo and bar are put here. */
5263 /* Nonzero if this definition is written with a prototype. */
5266 if (specparms
!= 0 && TREE_CODE (specparms
) != TREE_LIST
)
5268 /* This case is when the function was defined with an ANSI prototype.
5269 The parms already have decls, so we need not do anything here
5270 except record them as in effect
5271 and complain if any redundant old-style parm decls were written. */
5279 error_with_decl (fndecl
,
5280 "parm types given both in parmlist and separately");
5282 specparms
= nreverse (specparms
);
5283 for (parm
= specparms
; parm
; parm
= next
)
5285 next
= TREE_CHAIN (parm
);
5286 if (TREE_CODE (parm
) == PARM_DECL
)
5288 if (DECL_NAME (parm
) == 0)
5289 error_with_decl (parm
, "parameter name omitted");
5290 else if (TREE_TYPE (parm
) == void_type_node
)
5292 error_with_decl (parm
, "parameter `%s' declared void");
5293 /* Change the type to error_mark_node so this parameter
5294 will be ignored by assign_parms. */
5295 TREE_TYPE (parm
) = error_mark_node
;
5301 /* If we find an enum constant or a type tag,
5302 put it aside for the moment. */
5303 TREE_CHAIN (parm
) = 0;
5304 others
= chainon (others
, parm
);
5308 /* Get the decls in their original chain order
5309 and record in the function. */
5310 DECL_ARGUMENTS (fndecl
) = getdecls ();
5313 /* If this function takes a variable number of arguments,
5314 add a phony parameter to the end of the parm list,
5315 to represent the position of the first unnamed argument. */
5316 if (TREE_VALUE (tree_last (TYPE_ARG_TYPES (TREE_TYPE (fndecl
))))
5319 tree dummy
= build_decl (PARM_DECL
, NULL_TREE
, void_type_node
);
5320 /* Let's hope the address of the unnamed parm
5321 won't depend on its type. */
5322 TREE_TYPE (dummy
) = integer_type_node
;
5323 DECL_ARG_TYPE (dummy
) = integer_type_node
;
5324 DECL_ARGUMENTS (fndecl
)
5325 = chainon (DECL_ARGUMENTS (fndecl
), dummy
);
5329 /* Now pushdecl the enum constants. */
5330 for (parm
= others
; parm
; parm
= next
)
5332 next
= TREE_CHAIN (parm
);
5333 if (DECL_NAME (parm
) == 0)
5335 else if (TREE_TYPE (parm
) == void_type_node
)
5337 else if (TREE_CODE (parm
) != PARM_DECL
)
5341 storetags (chainon (parmtags
, gettags ()));
5345 /* SPECPARMS is an identifier list--a chain of TREE_LIST nodes
5346 each with a parm name as the TREE_VALUE.
5348 PARMDECLS is a chain of declarations for parameters.
5349 Warning! It can also contain CONST_DECLs which are not parameters
5350 but are names of enumerators of any enum types
5351 declared among the parameters.
5353 First match each formal parameter name with its declaration.
5354 Associate decls with the names and store the decls
5355 into the TREE_PURPOSE slots. */
5357 for (parm
= parmdecls
; parm
; parm
= TREE_CHAIN (parm
))
5358 DECL_RESULT (parm
) = 0;
5360 for (parm
= specparms
; parm
; parm
= TREE_CHAIN (parm
))
5362 register tree tail
, found
= NULL
;
5364 if (TREE_VALUE (parm
) == 0)
5366 error_with_decl (fndecl
, "parameter name missing from parameter list");
5367 TREE_PURPOSE (parm
) = 0;
5371 /* See if any of the parmdecls specifies this parm by name.
5372 Ignore any enumerator decls. */
5373 for (tail
= parmdecls
; tail
; tail
= TREE_CHAIN (tail
))
5374 if (DECL_NAME (tail
) == TREE_VALUE (parm
)
5375 && TREE_CODE (tail
) == PARM_DECL
)
5381 /* If declaration already marked, we have a duplicate name.
5382 Complain, and don't use this decl twice. */
5383 if (found
&& DECL_RESULT (found
) != 0)
5385 error_with_decl (found
, "multiple parameters named `%s'");
5389 /* If the declaration says "void", complain and ignore it. */
5390 if (found
&& TREE_TYPE (found
) == void_type_node
)
5392 error_with_decl (found
, "parameter `%s' declared void");
5393 TREE_TYPE (found
) = integer_type_node
;
5394 DECL_ARG_TYPE (found
) = integer_type_node
;
5395 layout_decl (found
, 0);
5398 /* Traditionally, a parm declared float is actually a double. */
5399 if (found
&& flag_traditional
5400 && TREE_TYPE (found
) == float_type_node
)
5401 TREE_TYPE (found
) = double_type_node
;
5403 /* If no declaration found, default to int. */
5406 found
= build_decl (PARM_DECL
, TREE_VALUE (parm
),
5408 DECL_ARG_TYPE (found
) = TREE_TYPE (found
);
5409 DECL_SOURCE_LINE (found
) = DECL_SOURCE_LINE (fndecl
);
5410 DECL_SOURCE_FILE (found
) = DECL_SOURCE_FILE (fndecl
);
5412 warning_with_decl (found
, "type of `%s' defaults to `int'");
5416 TREE_PURPOSE (parm
) = found
;
5418 /* Mark this decl as "already found" -- see test, above.
5419 It is safe to use DECL_RESULT for this
5420 since it is not used in PARM_DECLs or CONST_DECLs. */
5421 DECL_RESULT (found
) = error_mark_node
;
5424 /* Put anything which is on the parmdecls chain and which is
5425 not a PARM_DECL onto the list NONPARMS. (The types of
5426 non-parm things which might appear on the list include
5427 enumerators and NULL-named TYPE_DECL nodes.) Complain about
5428 any actual PARM_DECLs not matched with any names. */
5431 for (parm
= parmdecls
; parm
; )
5433 tree next
= TREE_CHAIN (parm
);
5434 TREE_CHAIN (parm
) = 0;
5436 if (TREE_CODE (parm
) != PARM_DECL
)
5437 nonparms
= chainon (nonparms
, parm
);
5440 /* Complain about args with incomplete types. */
5441 if (TYPE_SIZE (TREE_TYPE (parm
)) == 0)
5443 error_with_decl (parm
, "parameter `%s' has incomplete type");
5444 TREE_TYPE (parm
) = error_mark_node
;
5447 if (DECL_RESULT (parm
) == 0)
5449 error_with_decl (parm
,
5450 "declaration for parameter `%s' but no such parameter");
5451 /* Pretend the parameter was not missing.
5452 This gets us to a standard state and minimizes
5453 further error messages. */
5455 = chainon (specparms
,
5456 tree_cons (parm
, NULL_TREE
, NULL_TREE
));
5463 /* Chain the declarations together in the order of the list of names. */
5464 /* Store that chain in the function decl, replacing the list of names. */
5466 DECL_ARGUMENTS (fndecl
) = 0;
5469 for (last
= 0; parm
; parm
= TREE_CHAIN (parm
))
5470 if (TREE_PURPOSE (parm
))
5473 DECL_ARGUMENTS (fndecl
) = TREE_PURPOSE (parm
);
5475 TREE_CHAIN (last
) = TREE_PURPOSE (parm
);
5476 last
= TREE_PURPOSE (parm
);
5477 TREE_CHAIN (last
) = 0;
5481 /* If there was a previous prototype,
5482 set the DECL_ARG_TYPE of each argument according to
5483 the type previously specified, and report any mismatches. */
5485 if (TYPE_ARG_TYPES (TREE_TYPE (fndecl
)))
5488 for (parm
= DECL_ARGUMENTS (fndecl
),
5489 type
= TYPE_ARG_TYPES (TREE_TYPE (fndecl
));
5490 parm
|| (type
&& TREE_VALUE (type
) != void_type_node
);
5491 parm
= TREE_CHAIN (parm
), type
= TREE_CHAIN (type
))
5493 if (parm
== 0 || type
== 0
5494 || TREE_VALUE (type
) == void_type_node
)
5496 error ("number of arguments doesn't match prototype");
5499 /* Type for passing arg must be consistent
5500 with that declared for the arg. */
5501 if (! comptypes (DECL_ARG_TYPE (parm
), TREE_VALUE (type
)))
5503 if (TREE_TYPE (parm
) == TREE_VALUE (type
))
5505 /* Adjust argument to match prototype. E.g. a previous
5506 `int foo(float);' prototype causes
5507 `int foo(x) float x; {...}' to be treated like
5508 `int foo(float x) {...}'. This is particularly
5509 useful for argument types like uid_t. */
5510 DECL_ARG_TYPE (parm
) = TREE_TYPE (parm
);
5511 #ifdef PROMOTE_PROTOTYPES
5512 if (TREE_CODE (TREE_TYPE (parm
)) == INTEGER_TYPE
5513 && TYPE_PRECISION (TREE_TYPE (parm
))
5514 < TYPE_PRECISION (integer_type_node
))
5515 DECL_ARG_TYPE (parm
) = integer_type_node
;
5518 warning ("promoted argument `%s' doesn't match prototype",
5519 IDENTIFIER_POINTER (DECL_NAME (parm
)));
5521 /* If -traditional, allow `int' argument to match
5522 `unsigned' prototype. */
5523 else if (! (flag_traditional
5524 && TREE_TYPE (parm
) == integer_type_node
5525 && TREE_VALUE (type
) == unsigned_type_node
))
5526 error ("argument `%s' doesn't match prototype",
5527 IDENTIFIER_POINTER (DECL_NAME (parm
)));
5530 TYPE_ACTUAL_ARG_TYPES (TREE_TYPE (fndecl
)) = 0;
5533 /* Otherwise, create a prototype that would match. */
5537 register tree actual
, type
;
5538 register tree last
= 0;
5540 for (parm
= DECL_ARGUMENTS (fndecl
); parm
; parm
= TREE_CHAIN (parm
))
5542 type
= perm_tree_cons (NULL_TREE
, DECL_ARG_TYPE (parm
),
5545 TREE_CHAIN (last
) = type
;
5550 type
= perm_tree_cons (NULL_TREE
, void_type_node
, NULL_TREE
);
5552 TREE_CHAIN (last
) = type
;
5556 /* We are going to assign a new value for the TYPE_ACTUAL_ARG_TYPES
5557 of the type of this function, but we need to avoid having this
5558 affect the types of other similarly-typed functions, so we must
5559 first force the generation of an identical (but separate) type
5560 node for the relevant function type. The new node we create
5561 will be a variant of the main variant of the original function
5564 TREE_TYPE (fndecl
) = build_type_copy (TREE_TYPE (fndecl
));
5566 TYPE_ACTUAL_ARG_TYPES (TREE_TYPE (fndecl
)) = actual
;
5569 /* Now store the final chain of decls for the arguments
5570 as the decl-chain of the current lexical scope.
5571 Put the enumerators in as well, at the front so that
5572 DECL_ARGUMENTS is not modified. */
5574 storedecls (chainon (nonparms
, DECL_ARGUMENTS (fndecl
)));
5577 /* Make sure the binding level for the top of the function body
5578 gets a BLOCK if there are any in the function.
5579 Otherwise, the dbx output is wrong. */
5581 keep_next_if_subblocks
= 1;
5583 /* ??? This might be an improvement,
5584 but needs to be thought about some more. */
5586 keep_next_level_flag
= 1;
5589 /* Write a record describing this function definition to the prototypes
5590 file (if requested). */
5592 gen_aux_info_record (fndecl
, 1, 0, prototype
);
5594 /* Initialize the RTL code for the function. */
5596 init_function_start (fndecl
, input_filename
, lineno
);
5598 /* If this is a varargs function, inform function.c. */
5600 if (c_function_varargs
)
5603 /* Declare __FUNCTION__ and __PRETTY_FUNCTION__ for this function. */
5605 declare_function_name ();
5607 /* Set up parameters and prepare for return, for the function. */
5609 expand_function_start (fndecl
, 0);
5611 /* If this function is `main', emit a call to `__main'
5612 to run global initializers, etc. */
5613 if (DECL_NAME (fndecl
)
5614 && strcmp (IDENTIFIER_POINTER (DECL_NAME (fndecl
)), "main") == 0
5615 && DECL_CONTEXT (fndecl
) == NULL_TREE
)
5616 expand_main_function ();
5619 /* SPECPARMS is an identifier list--a chain of TREE_LIST nodes
5620 each with a parm name as the TREE_VALUE. A null pointer as TREE_VALUE
5621 stands for an ellipsis in the identifier list.
5623 PARMLIST is the data returned by get_parm_info for the
5624 parmlist that follows the semicolon.
5626 We return a value of the same sort that get_parm_info returns,
5627 except that it describes the combination of identifiers and parmlist. */
5630 combine_parm_decls (specparms
, parmlist
, void_at_end
)
5631 tree specparms
, parmlist
;
5634 register tree fndecl
= current_function_decl
;
5637 tree parmdecls
= TREE_PURPOSE (parmlist
);
5639 /* This is a chain of any other decls that came in among the parm
5640 declarations. They were separated already by get_parm_info,
5641 so we just need to keep them separate. */
5642 tree nonparms
= TREE_VALUE (parmlist
);
5646 for (parm
= parmdecls
; parm
; parm
= TREE_CHAIN (parm
))
5647 DECL_RESULT (parm
) = 0;
5649 for (parm
= specparms
; parm
; parm
= TREE_CHAIN (parm
))
5651 register tree tail
, found
= NULL
;
5653 /* See if any of the parmdecls specifies this parm by name. */
5654 for (tail
= parmdecls
; tail
; tail
= TREE_CHAIN (tail
))
5655 if (DECL_NAME (tail
) == TREE_VALUE (parm
))
5661 /* If declaration already marked, we have a duplicate name.
5662 Complain, and don't use this decl twice. */
5663 if (found
&& DECL_RESULT (found
) != 0)
5665 error_with_decl (found
, "multiple parameters named `%s'");
5669 /* If the declaration says "void", complain and ignore it. */
5670 if (found
&& TREE_TYPE (found
) == void_type_node
)
5672 error_with_decl (found
, "parameter `%s' declared void");
5673 TREE_TYPE (found
) = integer_type_node
;
5674 DECL_ARG_TYPE (found
) = integer_type_node
;
5675 layout_decl (found
, 0);
5678 /* Traditionally, a parm declared float is actually a double. */
5679 if (found
&& flag_traditional
5680 && TREE_TYPE (found
) == float_type_node
)
5681 TREE_TYPE (found
) = double_type_node
;
5683 /* If no declaration found, default to int. */
5686 found
= build_decl (PARM_DECL
, TREE_VALUE (parm
),
5688 DECL_ARG_TYPE (found
) = TREE_TYPE (found
);
5689 DECL_SOURCE_LINE (found
) = DECL_SOURCE_LINE (fndecl
);
5690 DECL_SOURCE_FILE (found
) = DECL_SOURCE_FILE (fndecl
);
5691 error (found
, "type of parameter `%s' is not declared");
5695 TREE_PURPOSE (parm
) = found
;
5697 /* Mark this decl as "already found" -- see test, above.
5698 It is safe to use DECL_RESULT for this
5699 since it is not used in PARM_DECLs or CONST_DECLs. */
5700 DECL_RESULT (found
) = error_mark_node
;
5703 /* Complain about any actual PARM_DECLs not matched with any names. */
5705 for (parm
= parmdecls
; parm
; )
5707 tree next
= TREE_CHAIN (parm
);
5708 TREE_CHAIN (parm
) = 0;
5710 /* Complain about args with incomplete types. */
5711 if (TYPE_SIZE (TREE_TYPE (parm
)) == 0)
5713 error_with_decl (parm
, "parameter `%s' has incomplete type");
5714 TREE_TYPE (parm
) = error_mark_node
;
5717 if (DECL_RESULT (parm
) == 0)
5719 error_with_decl (parm
,
5720 "declaration for parameter `%s' but no such parameter");
5721 /* Pretend the parameter was not missing.
5722 This gets us to a standard state and minimizes
5723 further error messages. */
5725 = chainon (specparms
,
5726 tree_cons (parm
, NULL_TREE
, NULL_TREE
));
5732 /* Chain the declarations together in the order of the list of names.
5733 At the same time, build up a list of their types, in reverse order. */
5739 for (last
= 0; parm
; parm
= TREE_CHAIN (parm
))
5740 if (TREE_PURPOSE (parm
))
5743 parmdecls
= TREE_PURPOSE (parm
);
5745 TREE_CHAIN (last
) = TREE_PURPOSE (parm
);
5746 last
= TREE_PURPOSE (parm
);
5747 TREE_CHAIN (last
) = 0;
5749 types
= saveable_tree_cons (NULL_TREE
, TREE_TYPE (parm
), types
);
5754 return saveable_tree_cons (parmdecls
, nonparms
,
5755 nreverse (saveable_tree_cons (NULL_TREE
, void_type_node
, types
)));
5757 return saveable_tree_cons (parmdecls
, nonparms
, nreverse (types
));
5760 /* Finish up a function declaration and compile that function
5761 all the way to assembler language output. The free the storage
5762 for the function definition.
5764 This is called after parsing the body of the function definition.
5766 NESTED is nonzero if the function being finished is nested in another. */
5769 finish_function (nested
)
5772 register tree fndecl
= current_function_decl
;
5774 /* TREE_READONLY (fndecl) = 1;
5775 This caused &foo to be of type ptr-to-const-function
5776 which then got a warning when stored in a ptr-to-function variable. */
5779 BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl
)) = fndecl
;
5781 /* Must mark the RESULT_DECL as being in this function. */
5783 DECL_CONTEXT (DECL_RESULT (fndecl
)) = fndecl
;
5785 /* Obey `register' declarations if `setjmp' is called in this fn. */
5786 if (flag_traditional
&& current_function_calls_setjmp
)
5788 setjmp_protect (DECL_INITIAL (fndecl
));
5789 setjmp_protect_args ();
5792 #ifdef DEFAULT_MAIN_RETURN
5793 if (! strcmp (IDENTIFIER_POINTER (DECL_NAME (fndecl
)), "main"))
5795 if (TREE_TYPE (fndecl
) != integer_type_node
)
5796 warning_with_decl (fndecl
, "return type of `%s' is not `int'");
5799 /* Make it so that `main' always returns success by default. */
5800 DEFAULT_MAIN_RETURN
;
5805 /* Generate rtl for function exit. */
5806 expand_function_end (input_filename
, lineno
);
5808 /* So we can tell if jump_optimize sets it to 1. */
5811 /* Run the optimizers and output the assembler code for this function. */
5812 rest_of_compilation (fndecl
);
5814 current_function_returns_null
|= can_reach_end
;
5816 if (TREE_THIS_VOLATILE (fndecl
) && current_function_returns_null
)
5817 warning ("`volatile' function does return");
5818 else if (warn_return_type
&& current_function_returns_null
5819 && TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (fndecl
))) != void_type_node
)
5820 /* If this function returns non-void and control can drop through,
5822 warning ("control reaches end of non-void function");
5823 /* With just -W, complain only if function returns both with
5824 and without a value. */
5825 else if (extra_warnings
5826 && current_function_returns_value
&& current_function_returns_null
)
5827 warning ("this function may return with or without a value");
5829 /* Free all the tree nodes making up this function. */
5830 /* Switch back to allocating nodes permanently
5831 until we start another function. */
5833 permanent_allocation ();
5835 if (DECL_SAVED_INSNS (fndecl
) == 0 && ! nested
)
5837 /* Stop pointing to the local nodes about to be freed. */
5838 /* But DECL_INITIAL must remain nonzero so we know this
5839 was an actual function definition. */
5840 /* For a nested function, this is done in pop_c_function_context. */
5841 DECL_INITIAL (fndecl
) = error_mark_node
;
5842 DECL_ARGUMENTS (fndecl
) = 0;
5847 /* Let the error reporting routines know that we're outside a
5848 function. For a nested function, this value is used in
5849 pop_c_function_context and then reset via pop_function_context. */
5850 current_function_decl
= NULL
;
5854 /* Save and restore the variables in this file and elsewhere
5855 that keep track of the progress of compilation of the current function.
5856 Used for nested functions. */
5860 struct c_function
*next
;
5861 tree enum_next_value
;
5863 tree shadowed_labels
;
5866 int warn_about_return_type
;
5868 struct binding_level
*binding_level
;
5871 struct c_function
*c_function_chain
;
5873 /* Save and reinitialize the variables
5874 used during compilation of a C function. */
5877 push_c_function_context ()
5879 struct c_function
*p
5880 = (struct c_function
*) xmalloc (sizeof (struct c_function
));
5883 pedwarn ("ANSI C forbids nested functions");
5885 push_function_context ();
5887 p
->next
= c_function_chain
;
5888 c_function_chain
= p
;
5890 p
->enum_next_value
= enum_next_value
;
5891 p
->named_labels
= named_labels
;
5892 p
->shadowed_labels
= shadowed_labels
;
5893 p
->returns_value
= current_function_returns_value
;
5894 p
->returns_null
= current_function_returns_null
;
5895 p
->warn_about_return_type
= warn_about_return_type
;
5896 p
->extern_inline
= current_extern_inline
;
5897 p
->binding_level
= current_binding_level
;
5900 /* Restore the variables used during compilation of a C function. */
5903 pop_c_function_context ()
5905 struct c_function
*p
= c_function_chain
;
5908 /* Bring back all the labels that were shadowed. */
5909 for (link
= shadowed_labels
; link
; link
= TREE_CHAIN (link
))
5910 if (DECL_NAME (TREE_VALUE (link
)) != 0)
5911 IDENTIFIER_LABEL_VALUE (DECL_NAME (TREE_VALUE (link
)))
5912 = TREE_VALUE (link
);
5914 if (DECL_SAVED_INSNS (current_function_decl
) == 0)
5916 /* Stop pointing to the local nodes about to be freed. */
5917 /* But DECL_INITIAL must remain nonzero so we know this
5918 was an actual function definition. */
5919 DECL_INITIAL (current_function_decl
) = error_mark_node
;
5920 DECL_ARGUMENTS (current_function_decl
) = 0;
5923 pop_function_context ();
5925 c_function_chain
= p
->next
;
5927 enum_next_value
= p
->enum_next_value
;
5928 named_labels
= p
->named_labels
;
5929 shadowed_labels
= p
->shadowed_labels
;
5930 current_function_returns_value
= p
->returns_value
;
5931 current_function_returns_null
= p
->returns_null
;
5932 warn_about_return_type
= p
->warn_about_return_type
;
5933 current_extern_inline
= p
->extern_inline
;
5934 current_binding_level
= p
->binding_level
;