configure.in (GLIBCPP_ENABLE_CXX_FLAGS): Do not pass arguments, let the defaults...
[official-gcc.git] / gcc / c-decl.c
blob8c86bc0d87a5a39c6e688356c517711350652d9b
1 /* Process declarations and variables for C compiler.
2 Copyright (C) 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
3 2001, 2002 Free Software Foundation, Inc.
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify it under
8 the terms of the GNU General Public License as published by the Free
9 Software Foundation; either version 2, or (at your option) any later
10 version.
12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
15 for more details.
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING. If not, write to the Free
19 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
20 02111-1307, USA. */
22 /* Process declarations and symbol lookup for C front end.
23 Also constructs types; the standard scalar types at initialization,
24 and structure, union, array and enum types when they are declared. */
26 /* ??? not all decl nodes are given the most useful possible
27 line numbers. For example, the CONST_DECLs for enum values. */
29 #include "config.h"
30 #include "system.h"
31 #include "coretypes.h"
32 #include "tm.h"
33 #include "intl.h"
34 #include "tree.h"
35 #include "tree-inline.h"
36 #include "rtl.h"
37 #include "flags.h"
38 #include "function.h"
39 #include "output.h"
40 #include "expr.h"
41 #include "c-tree.h"
42 #include "toplev.h"
43 #include "ggc.h"
44 #include "tm_p.h"
45 #include "cpplib.h"
46 #include "target.h"
47 #include "debug.h"
48 #include "timevar.h"
49 #include "c-common.h"
50 #include "c-pragma.h"
52 /* In grokdeclarator, distinguish syntactic contexts of declarators. */
53 enum decl_context
54 { NORMAL, /* Ordinary declaration */
55 FUNCDEF, /* Function definition */
56 PARM, /* Declaration of parm before function body */
57 FIELD, /* Declaration inside struct or union */
58 BITFIELD, /* Likewise but with specified width */
59 TYPENAME}; /* Typename (inside cast or sizeof) */
62 /* Nonzero if we have seen an invalid cross reference
63 to a struct, union, or enum, but not yet printed the message. */
65 tree pending_invalid_xref;
66 /* File and line to appear in the eventual error message. */
67 const char *pending_invalid_xref_file;
68 int pending_invalid_xref_line;
70 /* While defining an enum type, this is 1 plus the last enumerator
71 constant value. Note that will do not have to save this or `enum_overflow'
72 around nested function definition since such a definition could only
73 occur in an enum value expression and we don't use these variables in
74 that case. */
76 static tree enum_next_value;
78 /* Nonzero means that there was overflow computing enum_next_value. */
80 static int enum_overflow;
82 /* Parsing a function declarator leaves a list of parameter names
83 or a chain or parameter decls here. */
85 static tree last_function_parms;
87 /* Parsing a function declarator leaves here a chain of structure
88 and enum types declared in the parmlist. */
90 static tree last_function_parm_tags;
92 /* After parsing the declarator that starts a function definition,
93 `start_function' puts here the list of parameter names or chain of decls.
94 `store_parm_decls' finds it here. */
96 static tree current_function_parms;
98 /* Similar, for last_function_parm_tags. */
99 static tree current_function_parm_tags;
101 /* Similar, for the file and line that the prototype came from if this is
102 an old-style definition. */
103 static const char *current_function_prototype_file;
104 static int current_function_prototype_line;
106 /* The current statement tree. */
108 static GTY(()) struct stmt_tree_s c_stmt_tree;
110 /* The current scope statement stack. */
112 static GTY(()) tree c_scope_stmt_stack;
114 /* A list (chain of TREE_LIST nodes) of all LABEL_DECLs in the function
115 that have names. Here so we can clear out their names' definitions
116 at the end of the function. */
118 static GTY(()) tree named_labels;
120 /* A list of LABEL_DECLs from outer contexts that are currently shadowed. */
122 static GTY(()) tree shadowed_labels;
124 /* Set to 0 at beginning of a function definition, set to 1 if
125 a return statement that specifies a return value is seen. */
127 int current_function_returns_value;
129 /* Set to 0 at beginning of a function definition, set to 1 if
130 a return statement with no argument is seen. */
132 int current_function_returns_null;
134 /* Set to 0 at beginning of a function definition, set to 1 if
135 a call to a noreturn function is seen. */
137 int current_function_returns_abnormally;
139 /* Set to nonzero by `grokdeclarator' for a function
140 whose return type is defaulted, if warnings for this are desired. */
142 static int warn_about_return_type;
144 /* Nonzero when starting a function declared `extern inline'. */
146 static int current_extern_inline;
148 /* For each binding contour we allocate a binding_level structure
149 * which records the names defined in that contour.
150 * Contours include:
151 * 0) the global one
152 * 1) one for each function definition,
153 * where internal declarations of the parameters appear.
154 * 2) one for each compound statement,
155 * to record its declarations.
157 * The current meaning of a name can be found by searching the levels from
158 * the current one out to the global one.
161 /* Note that the information in the `names' component of the global contour
162 is duplicated in the IDENTIFIER_GLOBAL_VALUEs of all identifiers. */
164 struct binding_level GTY(())
166 /* A chain of _DECL nodes for all variables, constants, functions,
167 and typedef types. These are in the reverse of the order supplied.
169 tree names;
171 /* A list of structure, union and enum definitions,
172 * for looking up tag names.
173 * It is a chain of TREE_LIST nodes, each of whose TREE_PURPOSE is a name,
174 * or NULL_TREE; and whose TREE_VALUE is a RECORD_TYPE, UNION_TYPE,
175 * or ENUMERAL_TYPE node.
177 tree tags;
179 /* For each level, a list of shadowed outer-level local definitions
180 to be restored when this level is popped.
181 Each link is a TREE_LIST whose TREE_PURPOSE is an identifier and
182 whose TREE_VALUE is its old definition (a kind of ..._DECL node). */
183 tree shadowed;
185 /* For each level (except not the global one),
186 a chain of BLOCK nodes for all the levels
187 that were entered and exited one level down. */
188 tree blocks;
190 /* The BLOCK node for this level, if one has been preallocated.
191 If 0, the BLOCK is allocated (if needed) when the level is popped. */
192 tree this_block;
194 /* The binding level which this one is contained in (inherits from). */
195 struct binding_level *level_chain;
197 /* Nonzero for the level that holds the parameters of a function. */
198 char parm_flag;
200 /* Nonzero if this level "doesn't exist" for tags. */
201 char tag_transparent;
203 /* Nonzero if sublevels of this level "don't exist" for tags.
204 This is set in the parm level of a function definition
205 while reading the function body, so that the outermost block
206 of the function body will be tag-transparent. */
207 char subblocks_tag_transparent;
209 /* Nonzero means make a BLOCK for this level regardless of all else. */
210 char keep;
212 /* Nonzero means make a BLOCK if this level has any subblocks. */
213 char keep_if_subblocks;
215 /* List of decls in `names' that have incomplete structure or
216 union types. */
217 tree incomplete_list;
219 /* A list of decls giving the (reversed) specified order of parms,
220 not including any forward-decls in the parmlist.
221 This is so we can put the parms in proper order for assign_parms. */
222 tree parm_order;
225 #define NULL_BINDING_LEVEL (struct binding_level *) NULL
227 /* The binding level currently in effect. */
229 static GTY(()) struct binding_level *current_binding_level;
231 /* A chain of binding_level structures awaiting reuse. */
233 static GTY((deletable (""))) struct binding_level *free_binding_level;
235 /* The outermost binding level, for names of file scope.
236 This is created when the compiler is started and exists
237 through the entire run. */
239 static GTY(()) struct binding_level *global_binding_level;
241 /* Binding level structures are initialized by copying this one. */
243 static struct binding_level clear_binding_level
244 = {NULL, NULL, NULL, NULL, NULL, NULL_BINDING_LEVEL, 0, 0, 0, 0, 0, NULL,
245 NULL};
247 /* Nonzero means unconditionally make a BLOCK for the next level pushed. */
249 static int keep_next_level_flag;
251 /* Nonzero means make a BLOCK for the next level pushed
252 if it has subblocks. */
254 static int keep_next_if_subblocks;
256 /* The chain of outer levels of label scopes.
257 This uses the same data structure used for binding levels,
258 but it works differently: each link in the chain records
259 saved values of named_labels and shadowed_labels for
260 a label binding level outside the current one. */
262 static GTY(()) struct binding_level *label_level_chain;
264 /* Functions called automatically at the beginning and end of execution. */
266 tree static_ctors, static_dtors;
268 /* Forward declarations. */
270 static struct binding_level * make_binding_level PARAMS ((void));
271 static void pop_binding_level PARAMS ((struct binding_level **));
272 static void clear_limbo_values PARAMS ((tree));
273 static int duplicate_decls PARAMS ((tree, tree, int));
274 static int redeclaration_error_message PARAMS ((tree, tree));
275 static void storedecls PARAMS ((tree));
276 static void storetags PARAMS ((tree));
277 static tree lookup_tag PARAMS ((enum tree_code, tree,
278 struct binding_level *, int));
279 static tree lookup_tag_reverse PARAMS ((tree));
280 static tree grokdeclarator PARAMS ((tree, tree, enum decl_context,
281 int));
282 static tree grokparms PARAMS ((tree, int));
283 static void layout_array_type PARAMS ((tree));
284 static tree c_make_fname_decl PARAMS ((tree, int));
285 static void c_expand_body PARAMS ((tree, int, int));
286 static void warn_if_shadowing PARAMS ((tree, tree));
287 static bool flexible_array_type_p PARAMS ((tree));
289 /* States indicating how grokdeclarator() should handle declspecs marked
290 with __attribute__((deprecated)). An object declared as
291 __attribute__((deprecated)) suppresses warnings of uses of other
292 deprecated items. */
294 enum deprecated_states {
295 DEPRECATED_NORMAL,
296 DEPRECATED_SUPPRESS
299 static enum deprecated_states deprecated_state = DEPRECATED_NORMAL;
301 void
302 c_print_identifier (file, node, indent)
303 FILE *file;
304 tree node;
305 int indent;
307 print_node (file, "global", IDENTIFIER_GLOBAL_VALUE (node), indent + 4);
308 print_node (file, "local", IDENTIFIER_LOCAL_VALUE (node), indent + 4);
309 print_node (file, "label", IDENTIFIER_LABEL_VALUE (node), indent + 4);
310 print_node (file, "implicit", IDENTIFIER_IMPLICIT_DECL (node), indent + 4);
311 print_node (file, "error locus", IDENTIFIER_ERROR_LOCUS (node), indent + 4);
312 print_node (file, "limbo value", IDENTIFIER_LIMBO_VALUE (node), indent + 4);
313 if (C_IS_RESERVED_WORD (node))
315 tree rid = ridpointers[C_RID_CODE (node)];
316 indent_to (file, indent + 4);
317 fprintf (file, "rid ");
318 fprintf (file, HOST_PTR_PRINTF, (void *)rid);
319 fprintf (file, " \"%s\"", IDENTIFIER_POINTER (rid));
323 /* Hook called at end of compilation to assume 1 elt
324 for a top-level tentative array defn that wasn't complete before. */
326 void
327 c_finish_incomplete_decl (decl)
328 tree decl;
330 if (TREE_CODE (decl) == VAR_DECL)
332 tree type = TREE_TYPE (decl);
333 if (type != error_mark_node
334 && TREE_CODE (type) == ARRAY_TYPE
335 && ! DECL_EXTERNAL (decl)
336 && TYPE_DOMAIN (type) == 0)
338 warning_with_decl (decl, "array `%s' assumed to have one element");
340 complete_array_type (type, NULL_TREE, 1);
342 layout_decl (decl, 0);
347 /* Reuse or create a struct for this binding level. */
349 static struct binding_level *
350 make_binding_level ()
352 if (free_binding_level)
354 struct binding_level *result = free_binding_level;
355 free_binding_level = result->level_chain;
356 return result;
358 else
359 return (struct binding_level *) ggc_alloc (sizeof (struct binding_level));
362 /* Remove a binding level from a list and add it to the level chain. */
364 static void
365 pop_binding_level (lp)
366 struct binding_level **lp;
368 struct binding_level *l = *lp;
369 *lp = l->level_chain;
371 memset (l, 0, sizeof (struct binding_level));
372 l->level_chain = free_binding_level;
373 free_binding_level = l;
376 /* Nonzero if we are currently in the global binding level. */
379 global_bindings_p ()
381 return current_binding_level == global_binding_level;
384 void
385 keep_next_level ()
387 keep_next_level_flag = 1;
390 /* Nonzero if the current level needs to have a BLOCK made. */
393 kept_level_p ()
395 return ((current_binding_level->keep_if_subblocks
396 && current_binding_level->blocks != 0)
397 || current_binding_level->keep
398 || current_binding_level->names != 0
399 || (current_binding_level->tags != 0
400 && !current_binding_level->tag_transparent));
403 /* Identify this binding level as a level of parameters.
404 DEFINITION_FLAG is 1 for a definition, 0 for a declaration.
405 But it turns out there is no way to pass the right value for
406 DEFINITION_FLAG, so we ignore it. */
408 void
409 declare_parm_level (definition_flag)
410 int definition_flag ATTRIBUTE_UNUSED;
412 current_binding_level->parm_flag = 1;
415 /* Nonzero if currently making parm declarations. */
418 in_parm_level_p ()
420 return current_binding_level->parm_flag;
423 /* Enter a new binding level.
424 If TAG_TRANSPARENT is nonzero, do so only for the name space of variables,
425 not for that of tags. */
427 void
428 pushlevel (tag_transparent)
429 int tag_transparent;
431 struct binding_level *newlevel = NULL_BINDING_LEVEL;
433 /* If this is the top level of a function,
434 just make sure that NAMED_LABELS is 0. */
436 if (current_binding_level == global_binding_level)
438 named_labels = 0;
441 newlevel = make_binding_level ();
443 /* Add this level to the front of the chain (stack) of levels that
444 are active. */
446 *newlevel = clear_binding_level;
447 newlevel->tag_transparent
448 = (tag_transparent
449 || (current_binding_level
450 ? current_binding_level->subblocks_tag_transparent
451 : 0));
452 newlevel->level_chain = current_binding_level;
453 current_binding_level = newlevel;
454 newlevel->keep = keep_next_level_flag;
455 keep_next_level_flag = 0;
456 newlevel->keep_if_subblocks = keep_next_if_subblocks;
457 keep_next_if_subblocks = 0;
460 /* Clear the limbo values of all identifiers defined in BLOCK or a subblock. */
462 static void
463 clear_limbo_values (block)
464 tree block;
466 tree tem;
468 for (tem = BLOCK_VARS (block); tem; tem = TREE_CHAIN (tem))
469 if (DECL_NAME (tem) != 0)
470 IDENTIFIER_LIMBO_VALUE (DECL_NAME (tem)) = 0;
472 for (tem = BLOCK_SUBBLOCKS (block); tem; tem = TREE_CHAIN (tem))
473 clear_limbo_values (tem);
476 /* Exit a binding level.
477 Pop the level off, and restore the state of the identifier-decl mappings
478 that were in effect when this level was entered.
480 If KEEP is nonzero, this level had explicit declarations, so
481 and create a "block" (a BLOCK node) for the level
482 to record its declarations and subblocks for symbol table output.
484 If FUNCTIONBODY is nonzero, this level is the body of a function,
485 so create a block as if KEEP were set and also clear out all
486 label names.
488 If REVERSE is nonzero, reverse the order of decls before putting
489 them into the BLOCK. */
491 tree
492 poplevel (keep, reverse, functionbody)
493 int keep;
494 int reverse;
495 int functionbody;
497 tree link;
498 /* The chain of decls was accumulated in reverse order.
499 Put it into forward order, just for cleanliness. */
500 tree decls;
501 tree tags = current_binding_level->tags;
502 tree subblocks = current_binding_level->blocks;
503 tree block = 0;
504 tree decl;
505 int block_previously_created;
507 keep |= current_binding_level->keep;
509 /* This warning is turned off because it causes warnings for
510 declarations like `extern struct foo *x'. */
511 #if 0
512 /* Warn about incomplete structure types in this level. */
513 for (link = tags; link; link = TREE_CHAIN (link))
514 if (!COMPLETE_TYPE_P (TREE_VALUE (link)))
516 tree type = TREE_VALUE (link);
517 tree type_name = TYPE_NAME (type);
518 char *id = IDENTIFIER_POINTER (TREE_CODE (type_name) == IDENTIFIER_NODE
519 ? type_name
520 : DECL_NAME (type_name));
521 switch (TREE_CODE (type))
523 case RECORD_TYPE:
524 error ("`struct %s' incomplete in scope ending here", id);
525 break;
526 case UNION_TYPE:
527 error ("`union %s' incomplete in scope ending here", id);
528 break;
529 case ENUMERAL_TYPE:
530 error ("`enum %s' incomplete in scope ending here", id);
531 break;
534 #endif /* 0 */
536 /* Get the decls in the order they were written.
537 Usually current_binding_level->names is in reverse order.
538 But parameter decls were previously put in forward order. */
540 if (reverse)
541 current_binding_level->names
542 = decls = nreverse (current_binding_level->names);
543 else
544 decls = current_binding_level->names;
546 /* Output any nested inline functions within this block
547 if they weren't already output. */
549 for (decl = decls; decl; decl = TREE_CHAIN (decl))
550 if (TREE_CODE (decl) == FUNCTION_DECL
551 && ! TREE_ASM_WRITTEN (decl)
552 && DECL_INITIAL (decl) != 0
553 && TREE_ADDRESSABLE (decl))
555 /* If this decl was copied from a file-scope decl
556 on account of a block-scope extern decl,
557 propagate TREE_ADDRESSABLE to the file-scope decl.
559 DECL_ABSTRACT_ORIGIN can be set to itself if warn_return_type is
560 true, since then the decl goes through save_for_inline_copying. */
561 if (DECL_ABSTRACT_ORIGIN (decl) != 0
562 && DECL_ABSTRACT_ORIGIN (decl) != decl)
563 TREE_ADDRESSABLE (DECL_ABSTRACT_ORIGIN (decl)) = 1;
566 /* We used to warn about unused variables in expand_end_bindings,
567 i.e. while generating RTL. But in function-at-a-time mode we may
568 choose to never expand a function at all (e.g. auto inlining), so
569 we do this explicitly now. */
570 warn_about_unused_variables (getdecls ());
572 /* If there were any declarations or structure tags in that level,
573 or if this level is a function body,
574 create a BLOCK to record them for the life of this function. */
576 block = 0;
577 block_previously_created = (current_binding_level->this_block != 0);
578 if (block_previously_created)
579 block = current_binding_level->this_block;
580 else if (keep || functionbody
581 || (current_binding_level->keep_if_subblocks && subblocks != 0))
582 block = make_node (BLOCK);
583 if (block != 0)
585 BLOCK_VARS (block) = decls;
586 BLOCK_SUBBLOCKS (block) = subblocks;
589 /* In each subblock, record that this is its superior. */
591 for (link = subblocks; link; link = TREE_CHAIN (link))
592 BLOCK_SUPERCONTEXT (link) = block;
594 /* Clear out the meanings of the local variables of this level. */
596 for (link = decls; link; link = TREE_CHAIN (link))
598 if (DECL_NAME (link) != 0)
600 /* If the ident. was used or addressed via a local extern decl,
601 don't forget that fact. */
602 if (DECL_EXTERNAL (link))
604 if (TREE_USED (link))
605 TREE_USED (DECL_NAME (link)) = 1;
606 if (TREE_ADDRESSABLE (link))
607 TREE_ADDRESSABLE (DECL_ASSEMBLER_NAME (link)) = 1;
609 IDENTIFIER_LOCAL_VALUE (DECL_NAME (link)) = 0;
613 /* Restore all name-meanings of the outer levels
614 that were shadowed by this level. */
616 for (link = current_binding_level->shadowed; link; link = TREE_CHAIN (link))
617 IDENTIFIER_LOCAL_VALUE (TREE_PURPOSE (link)) = TREE_VALUE (link);
619 /* If the level being exited is the top level of a function,
620 check over all the labels, and clear out the current
621 (function local) meanings of their names. */
623 if (functionbody)
625 clear_limbo_values (block);
627 /* If this is the top level block of a function,
628 the vars are the function's parameters.
629 Don't leave them in the BLOCK because they are
630 found in the FUNCTION_DECL instead. */
632 BLOCK_VARS (block) = 0;
634 /* Clear out the definitions of all label names,
635 since their scopes end here,
636 and add them to BLOCK_VARS. */
638 for (link = named_labels; link; link = TREE_CHAIN (link))
640 tree label = TREE_VALUE (link);
642 if (DECL_INITIAL (label) == 0)
644 error_with_decl (label, "label `%s' used but not defined");
645 /* Avoid crashing later. */
646 define_label (input_filename, lineno,
647 DECL_NAME (label));
649 else if (warn_unused_label && !TREE_USED (label))
650 warning_with_decl (label, "label `%s' defined but not used");
651 IDENTIFIER_LABEL_VALUE (DECL_NAME (label)) = 0;
653 /* Put the labels into the "variables" of the
654 top-level block, so debugger can see them. */
655 TREE_CHAIN (label) = BLOCK_VARS (block);
656 BLOCK_VARS (block) = label;
660 /* Pop the current level, and free the structure for reuse. */
662 pop_binding_level (&current_binding_level);
664 /* Dispose of the block that we just made inside some higher level. */
665 if (functionbody)
666 DECL_INITIAL (current_function_decl) = block;
667 else if (block)
669 if (!block_previously_created)
670 current_binding_level->blocks
671 = chainon (current_binding_level->blocks, block);
673 /* If we did not make a block for the level just exited,
674 any blocks made for inner levels
675 (since they cannot be recorded as subblocks in that level)
676 must be carried forward so they will later become subblocks
677 of something else. */
678 else if (subblocks)
679 current_binding_level->blocks
680 = chainon (current_binding_level->blocks, subblocks);
682 /* Set the TYPE_CONTEXTs for all of the tagged types belonging to this
683 binding contour so that they point to the appropriate construct, i.e.
684 either to the current FUNCTION_DECL node, or else to the BLOCK node
685 we just constructed.
687 Note that for tagged types whose scope is just the formal parameter
688 list for some function type specification, we can't properly set
689 their TYPE_CONTEXTs here, because we don't have a pointer to the
690 appropriate FUNCTION_TYPE node readily available to us. For those
691 cases, the TYPE_CONTEXTs of the relevant tagged type nodes get set
692 in `grokdeclarator' as soon as we have created the FUNCTION_TYPE
693 node which will represent the "scope" for these "parameter list local"
694 tagged types. */
696 if (functionbody)
697 for (link = tags; link; link = TREE_CHAIN (link))
698 TYPE_CONTEXT (TREE_VALUE (link)) = current_function_decl;
699 else if (block)
700 for (link = tags; link; link = TREE_CHAIN (link))
701 TYPE_CONTEXT (TREE_VALUE (link)) = block;
703 if (block)
704 TREE_USED (block) = 1;
706 return block;
709 /* Insert BLOCK at the end of the list of subblocks of the
710 current binding level. This is used when a BIND_EXPR is expanded,
711 to handle the BLOCK node inside the BIND_EXPR. */
713 void
714 insert_block (block)
715 tree block;
717 TREE_USED (block) = 1;
718 current_binding_level->blocks
719 = chainon (current_binding_level->blocks, block);
722 /* Set the BLOCK node for the innermost scope
723 (the one we are currently in). */
725 void
726 set_block (block)
727 tree block;
729 current_binding_level->this_block = block;
730 current_binding_level->names = chainon (current_binding_level->names,
731 BLOCK_VARS (block));
732 current_binding_level->blocks = chainon (current_binding_level->blocks,
733 BLOCK_SUBBLOCKS (block));
736 void
737 push_label_level ()
739 struct binding_level *newlevel;
741 newlevel = make_binding_level ();
743 /* Add this level to the front of the chain (stack) of label levels. */
745 newlevel->level_chain = label_level_chain;
746 label_level_chain = newlevel;
748 newlevel->names = named_labels;
749 newlevel->shadowed = shadowed_labels;
750 named_labels = 0;
751 shadowed_labels = 0;
754 void
755 pop_label_level ()
757 struct binding_level *level = label_level_chain;
758 tree link, prev;
760 /* Clear out the definitions of the declared labels in this level.
761 Leave in the list any ordinary, non-declared labels. */
762 for (link = named_labels, prev = 0; link;)
764 if (C_DECLARED_LABEL_FLAG (TREE_VALUE (link)))
766 if (DECL_SOURCE_LINE (TREE_VALUE (link)) == 0)
768 error_with_decl (TREE_VALUE (link),
769 "label `%s' used but not defined");
770 /* Avoid crashing later. */
771 define_label (input_filename, lineno,
772 DECL_NAME (TREE_VALUE (link)));
774 else if (warn_unused_label && !TREE_USED (TREE_VALUE (link)))
775 warning_with_decl (TREE_VALUE (link),
776 "label `%s' defined but not used");
777 IDENTIFIER_LABEL_VALUE (DECL_NAME (TREE_VALUE (link))) = 0;
779 /* Delete this element from the list. */
780 link = TREE_CHAIN (link);
781 if (prev)
782 TREE_CHAIN (prev) = link;
783 else
784 named_labels = link;
786 else
788 prev = link;
789 link = TREE_CHAIN (link);
793 /* Bring back all the labels that were shadowed. */
794 for (link = shadowed_labels; link; link = TREE_CHAIN (link))
795 if (DECL_NAME (TREE_VALUE (link)) != 0)
796 IDENTIFIER_LABEL_VALUE (DECL_NAME (TREE_VALUE (link)))
797 = TREE_VALUE (link);
799 named_labels = chainon (named_labels, level->names);
800 shadowed_labels = level->shadowed;
802 /* Pop the current level, and free the structure for reuse. */
803 pop_binding_level (&label_level_chain);
806 /* Push a definition or a declaration of struct, union or enum tag "name".
807 "type" should be the type node.
808 We assume that the tag "name" is not already defined.
810 Note that the definition may really be just a forward reference.
811 In that case, the TYPE_SIZE will be zero. */
813 void
814 pushtag (name, type)
815 tree name, type;
817 struct binding_level *b;
819 /* Find the proper binding level for this type tag. */
821 for (b = current_binding_level; b->tag_transparent; b = b->level_chain)
822 continue;
824 if (name)
826 /* Record the identifier as the type's name if it has none. */
828 if (TYPE_NAME (type) == 0)
829 TYPE_NAME (type) = name;
832 b->tags = tree_cons (name, type, b->tags);
834 /* Create a fake NULL-named TYPE_DECL node whose TREE_TYPE will be the
835 tagged type we just added to the current binding level. This fake
836 NULL-named TYPE_DECL node helps dwarfout.c to know when it needs
837 to output a representation of a tagged type, and it also gives
838 us a convenient place to record the "scope start" address for the
839 tagged type. */
841 TYPE_STUB_DECL (type) = pushdecl (build_decl (TYPE_DECL, NULL_TREE, type));
843 /* An approximation for now, so we can tell this is a function-scope tag.
844 This will be updated in poplevel. */
845 TYPE_CONTEXT (type) = DECL_CONTEXT (TYPE_STUB_DECL (type));
848 /* Handle when a new declaration NEWDECL
849 has the same name as an old one OLDDECL
850 in the same binding contour.
851 Prints an error message if appropriate.
853 If safely possible, alter OLDDECL to look like NEWDECL, and return 1.
854 Otherwise, return 0.
856 When DIFFERENT_BINDING_LEVEL is true, NEWDECL is an external declaration,
857 and OLDDECL is in an outer binding level and should thus not be changed. */
859 static int
860 duplicate_decls (newdecl, olddecl, different_binding_level)
861 tree newdecl, olddecl;
862 int different_binding_level;
864 int types_match = comptypes (TREE_TYPE (newdecl), TREE_TYPE (olddecl));
865 int new_is_definition = (TREE_CODE (newdecl) == FUNCTION_DECL
866 && DECL_INITIAL (newdecl) != 0);
867 tree oldtype = TREE_TYPE (olddecl);
868 tree newtype = TREE_TYPE (newdecl);
869 int errmsg = 0;
871 if (DECL_P (olddecl))
873 if (TREE_CODE (newdecl) == FUNCTION_DECL
874 && TREE_CODE (olddecl) == FUNCTION_DECL
875 && (DECL_UNINLINABLE (newdecl) || DECL_UNINLINABLE (olddecl)))
877 if (DECL_DECLARED_INLINE_P (newdecl)
878 && DECL_UNINLINABLE (newdecl)
879 && lookup_attribute ("noinline", DECL_ATTRIBUTES (newdecl)))
880 /* Already warned elsewhere. */;
881 else if (DECL_DECLARED_INLINE_P (olddecl)
882 && DECL_UNINLINABLE (olddecl)
883 && lookup_attribute ("noinline", DECL_ATTRIBUTES (olddecl)))
884 /* Already warned. */;
885 else if (DECL_DECLARED_INLINE_P (newdecl)
886 && ! DECL_DECLARED_INLINE_P (olddecl)
887 && DECL_UNINLINABLE (olddecl)
888 && lookup_attribute ("noinline", DECL_ATTRIBUTES (olddecl)))
890 warning_with_decl (newdecl,
891 "function `%s' redeclared as inline");
892 warning_with_decl (olddecl,
893 "previous declaration of function `%s' with attribute noinline");
895 else if (DECL_DECLARED_INLINE_P (olddecl)
896 && DECL_UNINLINABLE (newdecl)
897 && lookup_attribute ("noinline", DECL_ATTRIBUTES (newdecl)))
899 warning_with_decl (newdecl,
900 "function `%s' redeclared with attribute noinline");
901 warning_with_decl (olddecl,
902 "previous declaration of function `%s' was inline");
906 DECL_ATTRIBUTES (newdecl)
907 = (*targetm.merge_decl_attributes) (olddecl, newdecl);
910 if (TREE_CODE (newtype) == ERROR_MARK
911 || TREE_CODE (oldtype) == ERROR_MARK)
912 types_match = 0;
914 /* New decl is completely inconsistent with the old one =>
915 tell caller to replace the old one.
916 This is always an error except in the case of shadowing a builtin. */
917 if (TREE_CODE (olddecl) != TREE_CODE (newdecl))
919 if (TREE_CODE (olddecl) == FUNCTION_DECL
920 && (DECL_BUILT_IN (olddecl)
921 || DECL_BUILT_IN_NONANSI (olddecl)))
923 /* If you declare a built-in or predefined function name as static,
924 the old definition is overridden,
925 but optionally warn this was a bad choice of name. */
926 if (!TREE_PUBLIC (newdecl))
928 if (!warn_shadow)
930 else if (DECL_BUILT_IN (olddecl))
931 warning_with_decl (newdecl, "shadowing built-in function `%s'");
932 else
933 warning_with_decl (newdecl, "shadowing library function `%s'");
935 /* Likewise, if the built-in is not ansi, then programs can
936 override it even globally without an error. */
937 else if (! DECL_BUILT_IN (olddecl))
938 warning_with_decl (newdecl,
939 "library function `%s' declared as non-function");
941 else if (DECL_BUILT_IN_NONANSI (olddecl))
942 warning_with_decl (newdecl,
943 "built-in function `%s' declared as non-function");
944 else
945 warning_with_decl (newdecl,
946 "built-in function `%s' declared as non-function");
948 else
950 error_with_decl (newdecl, "`%s' redeclared as different kind of symbol");
951 error_with_decl (olddecl, "previous declaration of `%s'");
954 return 0;
957 /* For real parm decl following a forward decl,
958 return 1 so old decl will be reused. */
959 if (types_match && TREE_CODE (newdecl) == PARM_DECL
960 && TREE_ASM_WRITTEN (olddecl) && ! TREE_ASM_WRITTEN (newdecl))
961 return 1;
963 /* The new declaration is the same kind of object as the old one.
964 The declarations may partially match. Print warnings if they don't
965 match enough. Ultimately, copy most of the information from the new
966 decl to the old one, and keep using the old one. */
968 if (TREE_CODE (olddecl) == FUNCTION_DECL && DECL_BUILT_IN (olddecl))
970 /* A function declaration for a built-in function. */
971 if (!TREE_PUBLIC (newdecl))
973 /* If you declare a built-in function name as static, the
974 built-in definition is overridden,
975 but optionally warn this was a bad choice of name. */
976 if (warn_shadow)
977 warning_with_decl (newdecl, "shadowing built-in function `%s'");
978 /* Discard the old built-in function. */
979 return 0;
981 else if (!types_match)
983 /* Accept the return type of the new declaration if same modes. */
984 tree oldreturntype = TREE_TYPE (oldtype);
985 tree newreturntype = TREE_TYPE (newtype);
987 if (TYPE_MODE (oldreturntype) == TYPE_MODE (newreturntype))
989 /* Function types may be shared, so we can't just modify
990 the return type of olddecl's function type. */
991 tree trytype
992 = build_function_type (newreturntype,
993 TYPE_ARG_TYPES (oldtype));
994 trytype = build_type_attribute_variant (trytype,
995 TYPE_ATTRIBUTES (oldtype));
997 types_match = comptypes (newtype, trytype);
998 if (types_match)
999 oldtype = trytype;
1001 /* Accept harmless mismatch in first argument type also.
1002 This is for the ffs and fprintf builtins. */
1003 if (TYPE_ARG_TYPES (TREE_TYPE (newdecl)) != 0
1004 && TYPE_ARG_TYPES (oldtype) != 0
1005 && TREE_VALUE (TYPE_ARG_TYPES (newtype)) != 0
1006 && TREE_VALUE (TYPE_ARG_TYPES (oldtype)) != 0
1007 && (TYPE_MODE (TREE_VALUE (TYPE_ARG_TYPES (newtype)))
1008 == TYPE_MODE (TREE_VALUE (TYPE_ARG_TYPES (oldtype)))))
1010 /* Function types may be shared, so we can't just modify
1011 the return type of olddecl's function type. */
1012 tree trytype
1013 = build_function_type (TREE_TYPE (oldtype),
1014 tree_cons (NULL_TREE,
1015 TREE_VALUE (TYPE_ARG_TYPES (newtype)),
1016 TREE_CHAIN (TYPE_ARG_TYPES (oldtype))));
1017 trytype = build_type_attribute_variant (trytype,
1018 TYPE_ATTRIBUTES (oldtype));
1020 types_match = comptypes (newtype, trytype);
1021 if (types_match)
1022 oldtype = trytype;
1024 if (! different_binding_level)
1025 TREE_TYPE (olddecl) = oldtype;
1027 else if (TYPE_ARG_TYPES (oldtype) == NULL
1028 && TYPE_ARG_TYPES (newtype) != NULL)
1030 /* For bcmp, bzero, fputs the builtin type has arguments not
1031 specified. Use the ones from the prototype so that type checking
1032 is done for them. */
1033 tree trytype
1034 = build_function_type (TREE_TYPE (oldtype),
1035 TYPE_ARG_TYPES (newtype));
1036 trytype = build_type_attribute_variant (trytype,
1037 TYPE_ATTRIBUTES (oldtype));
1039 oldtype = trytype;
1040 if (! different_binding_level)
1041 TREE_TYPE (olddecl) = oldtype;
1043 if (!types_match)
1045 /* If types don't match for a built-in, throw away the built-in. */
1046 warning_with_decl (newdecl, "conflicting types for built-in function `%s'");
1047 return 0;
1050 else if (TREE_CODE (olddecl) == FUNCTION_DECL
1051 && DECL_SOURCE_LINE (olddecl) == 0)
1053 /* A function declaration for a predeclared function
1054 that isn't actually built in. */
1055 if (!TREE_PUBLIC (newdecl))
1057 /* If you declare it as static, the
1058 default definition is overridden. */
1059 return 0;
1061 else if (!types_match)
1063 /* If the types don't match, preserve volatility indication.
1064 Later on, we will discard everything else about the
1065 default declaration. */
1066 TREE_THIS_VOLATILE (newdecl) |= TREE_THIS_VOLATILE (olddecl);
1069 /* Permit char *foo () to match void *foo (...) if not pedantic,
1070 if one of them came from a system header file. */
1071 else if (!types_match
1072 && TREE_CODE (olddecl) == FUNCTION_DECL
1073 && TREE_CODE (newdecl) == FUNCTION_DECL
1074 && TREE_CODE (TREE_TYPE (oldtype)) == POINTER_TYPE
1075 && TREE_CODE (TREE_TYPE (newtype)) == POINTER_TYPE
1076 && (DECL_IN_SYSTEM_HEADER (olddecl)
1077 || DECL_IN_SYSTEM_HEADER (newdecl))
1078 && ((TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (newtype))) == void_type_node
1079 && TYPE_ARG_TYPES (oldtype) == 0
1080 && self_promoting_args_p (TYPE_ARG_TYPES (newtype))
1081 && TREE_TYPE (TREE_TYPE (oldtype)) == char_type_node)
1083 (TREE_TYPE (TREE_TYPE (newtype)) == char_type_node
1084 && TYPE_ARG_TYPES (newtype) == 0
1085 && self_promoting_args_p (TYPE_ARG_TYPES (oldtype))
1086 && TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (oldtype))) == void_type_node)))
1088 if (pedantic)
1089 pedwarn_with_decl (newdecl, "conflicting types for `%s'");
1090 /* Make sure we keep void * as ret type, not char *. */
1091 if (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (oldtype))) == void_type_node)
1092 TREE_TYPE (newdecl) = newtype = oldtype;
1094 /* Set DECL_IN_SYSTEM_HEADER, so that if we see another declaration
1095 we will come back here again. */
1096 DECL_IN_SYSTEM_HEADER (newdecl) = 1;
1098 else if (!types_match
1099 /* Permit char *foo (int, ...); followed by char *foo ();
1100 if not pedantic. */
1101 && ! (TREE_CODE (olddecl) == FUNCTION_DECL
1102 && ! pedantic
1103 /* Return types must still match. */
1104 && comptypes (TREE_TYPE (oldtype),
1105 TREE_TYPE (newtype))
1106 && TYPE_ARG_TYPES (newtype) == 0))
1108 error_with_decl (newdecl, "conflicting types for `%s'");
1109 /* Check for function type mismatch
1110 involving an empty arglist vs a nonempty one. */
1111 if (TREE_CODE (olddecl) == FUNCTION_DECL
1112 && comptypes (TREE_TYPE (oldtype),
1113 TREE_TYPE (newtype))
1114 && ((TYPE_ARG_TYPES (oldtype) == 0
1115 && DECL_INITIAL (olddecl) == 0)
1117 (TYPE_ARG_TYPES (newtype) == 0
1118 && DECL_INITIAL (newdecl) == 0)))
1120 /* Classify the problem further. */
1121 tree t = TYPE_ARG_TYPES (oldtype);
1122 if (t == 0)
1123 t = TYPE_ARG_TYPES (newtype);
1124 for (; t; t = TREE_CHAIN (t))
1126 tree type = TREE_VALUE (t);
1128 if (TREE_CHAIN (t) == 0
1129 && TYPE_MAIN_VARIANT (type) != void_type_node)
1131 error ("a parameter list with an ellipsis can't match an empty parameter name list declaration");
1132 break;
1135 if (c_type_promotes_to (type) != type)
1137 error ("an argument type that has a default promotion can't match an empty parameter name list declaration");
1138 break;
1142 error_with_decl (olddecl, "previous declaration of `%s'");
1144 /* TLS cannot follow non-TLS declaration. */
1145 else if (TREE_CODE (olddecl) == VAR_DECL && TREE_CODE (newdecl) == VAR_DECL
1146 && !DECL_THREAD_LOCAL (olddecl) && DECL_THREAD_LOCAL (newdecl))
1148 error_with_decl (newdecl, "thread-local declaration of `%s' follows non thread-local declaration");
1149 error_with_decl (olddecl, "previous declaration of `%s'");
1151 /* non-TLS declaration cannot follow TLS declaration. */
1152 else if (TREE_CODE (olddecl) == VAR_DECL && TREE_CODE (newdecl) == VAR_DECL
1153 && DECL_THREAD_LOCAL (olddecl) && !DECL_THREAD_LOCAL (newdecl))
1155 error_with_decl (newdecl, "non thread-local declaration of `%s' follows thread-local declaration");
1156 error_with_decl (olddecl, "previous declaration of `%s'");
1158 else
1160 errmsg = redeclaration_error_message (newdecl, olddecl);
1161 if (errmsg)
1163 switch (errmsg)
1165 case 1:
1166 error_with_decl (newdecl, "redefinition of `%s'");
1167 break;
1168 case 2:
1169 error_with_decl (newdecl, "redeclaration of `%s'");
1170 break;
1171 case 3:
1172 error_with_decl (newdecl, "conflicting declarations of `%s'");
1173 break;
1174 default:
1175 abort ();
1178 error_with_decl (olddecl,
1179 ((DECL_INITIAL (olddecl)
1180 && current_binding_level == global_binding_level)
1181 ? "`%s' previously defined here"
1182 : "`%s' previously declared here"));
1183 return 0;
1185 else if (TREE_CODE (newdecl) == TYPE_DECL
1186 && (DECL_IN_SYSTEM_HEADER (olddecl)
1187 || DECL_IN_SYSTEM_HEADER (newdecl)))
1189 warning_with_decl (newdecl, "redefinition of `%s'");
1190 warning_with_decl
1191 (olddecl,
1192 ((DECL_INITIAL (olddecl)
1193 && current_binding_level == global_binding_level)
1194 ? "`%s' previously defined here"
1195 : "`%s' previously declared here"));
1197 else if (TREE_CODE (olddecl) == FUNCTION_DECL
1198 && DECL_INITIAL (olddecl) != 0
1199 && TYPE_ARG_TYPES (oldtype) == 0
1200 && TYPE_ARG_TYPES (newtype) != 0
1201 && TYPE_ACTUAL_ARG_TYPES (oldtype) != 0)
1203 tree type, parm;
1204 int nargs;
1205 /* Prototype decl follows defn w/o prototype. */
1207 for (parm = TYPE_ACTUAL_ARG_TYPES (oldtype),
1208 type = TYPE_ARG_TYPES (newtype),
1209 nargs = 1;
1211 parm = TREE_CHAIN (parm), type = TREE_CHAIN (type), nargs++)
1213 if (TYPE_MAIN_VARIANT (TREE_VALUE (parm)) == void_type_node
1214 && TYPE_MAIN_VARIANT (TREE_VALUE (type)) == void_type_node)
1216 warning_with_decl (newdecl, "prototype for `%s' follows");
1217 warning_with_decl (olddecl, "non-prototype definition here");
1218 break;
1220 if (TYPE_MAIN_VARIANT (TREE_VALUE (parm)) == void_type_node
1221 || TYPE_MAIN_VARIANT (TREE_VALUE (type)) == void_type_node)
1223 error_with_decl (newdecl,
1224 "prototype for `%s' follows and number of arguments doesn't match");
1225 error_with_decl (olddecl, "non-prototype definition here");
1226 errmsg = 1;
1227 break;
1229 /* Type for passing arg must be consistent
1230 with that declared for the arg. */
1231 if (! comptypes (TREE_VALUE (parm), TREE_VALUE (type)))
1233 error_with_decl (newdecl,
1234 "prototype for `%s' follows and argument %d doesn't match",
1235 nargs);
1236 error_with_decl (olddecl, "non-prototype definition here");
1237 errmsg = 1;
1238 break;
1242 /* Warn about mismatches in various flags. */
1243 else
1245 /* Warn if function is now inline
1246 but was previously declared not inline and has been called. */
1247 if (TREE_CODE (olddecl) == FUNCTION_DECL
1248 && ! DECL_DECLARED_INLINE_P (olddecl)
1249 && DECL_DECLARED_INLINE_P (newdecl)
1250 && TREE_USED (olddecl))
1251 warning_with_decl (newdecl,
1252 "`%s' declared inline after being called");
1253 if (TREE_CODE (olddecl) == FUNCTION_DECL
1254 && ! DECL_DECLARED_INLINE_P (olddecl)
1255 && DECL_DECLARED_INLINE_P (newdecl)
1256 && DECL_INITIAL (olddecl) != 0)
1257 warning_with_decl (newdecl,
1258 "`%s' declared inline after its definition");
1260 /* If pedantic, warn when static declaration follows a non-static
1261 declaration. Otherwise, do so only for functions. */
1262 if ((pedantic || TREE_CODE (olddecl) == FUNCTION_DECL)
1263 && TREE_PUBLIC (olddecl)
1264 && !TREE_PUBLIC (newdecl))
1265 warning_with_decl (newdecl, "static declaration for `%s' follows non-static");
1267 /* If warn_traditional, warn when a non-static function
1268 declaration follows a static one. */
1269 if (warn_traditional && !in_system_header
1270 && TREE_CODE (olddecl) == FUNCTION_DECL
1271 && !TREE_PUBLIC (olddecl)
1272 && TREE_PUBLIC (newdecl))
1273 warning_with_decl (newdecl, "non-static declaration for `%s' follows static");
1275 /* Warn when const declaration follows a non-const
1276 declaration, but not for functions. */
1277 if (TREE_CODE (olddecl) != FUNCTION_DECL
1278 && !TREE_READONLY (olddecl)
1279 && TREE_READONLY (newdecl))
1280 warning_with_decl (newdecl, "const declaration for `%s' follows non-const");
1281 /* These bits are logically part of the type, for variables.
1282 But not for functions
1283 (where qualifiers are not valid ANSI anyway). */
1284 else if (pedantic && TREE_CODE (olddecl) != FUNCTION_DECL
1285 && (TREE_READONLY (newdecl) != TREE_READONLY (olddecl)
1286 || TREE_THIS_VOLATILE (newdecl) != TREE_THIS_VOLATILE (olddecl)))
1287 pedwarn_with_decl (newdecl, "type qualifiers for `%s' conflict with previous decl");
1291 /* Optionally warn about more than one declaration for the same name. */
1292 if (errmsg == 0 && warn_redundant_decls && DECL_SOURCE_LINE (olddecl) != 0
1293 /* Don't warn about a function declaration
1294 followed by a definition. */
1295 && !(TREE_CODE (newdecl) == FUNCTION_DECL && DECL_INITIAL (newdecl) != 0
1296 && DECL_INITIAL (olddecl) == 0)
1297 /* Don't warn about extern decl followed by (tentative) definition. */
1298 && !(DECL_EXTERNAL (olddecl) && ! DECL_EXTERNAL (newdecl)))
1300 warning_with_decl (newdecl, "redundant redeclaration of `%s' in same scope");
1301 warning_with_decl (olddecl, "previous declaration of `%s'");
1304 /* Copy all the DECL_... slots specified in the new decl
1305 except for any that we copy here from the old type.
1307 Past this point, we don't change OLDTYPE and NEWTYPE
1308 even if we change the types of NEWDECL and OLDDECL. */
1310 if (types_match)
1312 /* When copying info to olddecl, we store into write_olddecl
1313 instead. This allows us to avoid modifying olddecl when
1314 different_binding_level is true. */
1315 tree write_olddecl = different_binding_level ? newdecl : olddecl;
1317 /* Merge the data types specified in the two decls. */
1318 if (TREE_CODE (newdecl) != FUNCTION_DECL || !DECL_BUILT_IN (olddecl))
1320 if (different_binding_level)
1322 if (TYPE_ARG_TYPES (oldtype) != 0
1323 && TYPE_ARG_TYPES (newtype) == 0)
1324 TREE_TYPE (newdecl) = common_type (newtype, oldtype);
1325 else
1326 TREE_TYPE (newdecl)
1327 = build_type_attribute_variant
1328 (newtype,
1329 merge_attributes (TYPE_ATTRIBUTES (newtype),
1330 TYPE_ATTRIBUTES (oldtype)));
1332 else
1333 TREE_TYPE (newdecl)
1334 = TREE_TYPE (olddecl)
1335 = common_type (newtype, oldtype);
1338 /* Lay the type out, unless already done. */
1339 if (oldtype != TREE_TYPE (newdecl))
1341 if (TREE_TYPE (newdecl) != error_mark_node)
1342 layout_type (TREE_TYPE (newdecl));
1343 if (TREE_CODE (newdecl) != FUNCTION_DECL
1344 && TREE_CODE (newdecl) != TYPE_DECL
1345 && TREE_CODE (newdecl) != CONST_DECL)
1346 layout_decl (newdecl, 0);
1348 else
1350 /* Since the type is OLDDECL's, make OLDDECL's size go with. */
1351 DECL_SIZE (newdecl) = DECL_SIZE (olddecl);
1352 DECL_SIZE_UNIT (newdecl) = DECL_SIZE_UNIT (olddecl);
1353 DECL_MODE (newdecl) = DECL_MODE (olddecl);
1354 if (TREE_CODE (olddecl) != FUNCTION_DECL)
1355 if (DECL_ALIGN (olddecl) > DECL_ALIGN (newdecl))
1357 DECL_ALIGN (newdecl) = DECL_ALIGN (olddecl);
1358 DECL_USER_ALIGN (newdecl) |= DECL_ALIGN (olddecl);
1362 /* Keep the old rtl since we can safely use it. */
1363 COPY_DECL_RTL (olddecl, newdecl);
1365 /* Merge the type qualifiers. */
1366 if (TREE_READONLY (newdecl))
1367 TREE_READONLY (write_olddecl) = 1;
1369 if (TREE_THIS_VOLATILE (newdecl))
1371 TREE_THIS_VOLATILE (write_olddecl) = 1;
1372 if (TREE_CODE (newdecl) == VAR_DECL
1373 /* If an automatic variable is re-declared in the same
1374 function scope, but the old declaration was not
1375 volatile, make_var_volatile() would crash because the
1376 variable would have been assigned to a pseudo, not a
1377 MEM. Since this duplicate declaration is invalid
1378 anyway, we just skip the call. */
1379 && errmsg == 0)
1380 make_var_volatile (newdecl);
1383 /* Keep source location of definition rather than declaration. */
1384 /* When called with different_binding_level set, keep the old
1385 information so that meaningful diagnostics can be given. */
1386 if (DECL_INITIAL (newdecl) == 0 && DECL_INITIAL (olddecl) != 0
1387 && ! different_binding_level)
1389 DECL_SOURCE_LINE (newdecl) = DECL_SOURCE_LINE (olddecl);
1390 DECL_SOURCE_FILE (newdecl) = DECL_SOURCE_FILE (olddecl);
1393 /* Merge the unused-warning information. */
1394 if (DECL_IN_SYSTEM_HEADER (olddecl))
1395 DECL_IN_SYSTEM_HEADER (newdecl) = 1;
1396 else if (DECL_IN_SYSTEM_HEADER (newdecl))
1397 DECL_IN_SYSTEM_HEADER (write_olddecl) = 1;
1399 /* Merge the initialization information. */
1400 /* When called with different_binding_level set, don't copy over
1401 DECL_INITIAL, so that we don't accidentally change function
1402 declarations into function definitions. */
1403 if (DECL_INITIAL (newdecl) == 0 && ! different_binding_level)
1404 DECL_INITIAL (newdecl) = DECL_INITIAL (olddecl);
1406 /* Merge the section attribute.
1407 We want to issue an error if the sections conflict but that must be
1408 done later in decl_attributes since we are called before attributes
1409 are assigned. */
1410 if (DECL_SECTION_NAME (newdecl) == NULL_TREE)
1411 DECL_SECTION_NAME (newdecl) = DECL_SECTION_NAME (olddecl);
1413 /* Copy the assembler name.
1414 Currently, it can only be defined in the prototype. */
1415 COPY_DECL_ASSEMBLER_NAME (olddecl, newdecl);
1417 if (TREE_CODE (newdecl) == FUNCTION_DECL)
1419 DECL_STATIC_CONSTRUCTOR(newdecl) |= DECL_STATIC_CONSTRUCTOR(olddecl);
1420 DECL_STATIC_DESTRUCTOR (newdecl) |= DECL_STATIC_DESTRUCTOR (olddecl);
1421 DECL_NO_LIMIT_STACK (newdecl) |= DECL_NO_LIMIT_STACK (olddecl);
1422 DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (newdecl)
1423 |= DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (olddecl);
1426 /* If cannot merge, then use the new type and qualifiers,
1427 and don't preserve the old rtl. */
1428 else if (! different_binding_level)
1430 TREE_TYPE (olddecl) = TREE_TYPE (newdecl);
1431 TREE_READONLY (olddecl) = TREE_READONLY (newdecl);
1432 TREE_THIS_VOLATILE (olddecl) = TREE_THIS_VOLATILE (newdecl);
1433 TREE_SIDE_EFFECTS (olddecl) = TREE_SIDE_EFFECTS (newdecl);
1436 /* Merge the storage class information. */
1437 merge_weak (newdecl, olddecl);
1439 /* For functions, static overrides non-static. */
1440 if (TREE_CODE (newdecl) == FUNCTION_DECL)
1442 TREE_PUBLIC (newdecl) &= TREE_PUBLIC (olddecl);
1443 /* This is since we don't automatically
1444 copy the attributes of NEWDECL into OLDDECL. */
1445 /* No need to worry about different_binding_level here because
1446 then TREE_PUBLIC (newdecl) was true. */
1447 TREE_PUBLIC (olddecl) = TREE_PUBLIC (newdecl);
1448 /* If this clears `static', clear it in the identifier too. */
1449 if (! TREE_PUBLIC (olddecl))
1450 TREE_PUBLIC (DECL_NAME (olddecl)) = 0;
1452 if (DECL_EXTERNAL (newdecl))
1454 if (! different_binding_level)
1456 /* Don't mess with these flags on local externs; they remain
1457 external even if there's a declaration at file scope which
1458 isn't. */
1459 TREE_STATIC (newdecl) = TREE_STATIC (olddecl);
1460 DECL_EXTERNAL (newdecl) = DECL_EXTERNAL (olddecl);
1462 /* An extern decl does not override previous storage class. */
1463 TREE_PUBLIC (newdecl) = TREE_PUBLIC (olddecl);
1464 if (! DECL_EXTERNAL (newdecl))
1465 DECL_CONTEXT (newdecl) = DECL_CONTEXT (olddecl);
1467 else
1469 TREE_STATIC (olddecl) = TREE_STATIC (newdecl);
1470 TREE_PUBLIC (olddecl) = TREE_PUBLIC (newdecl);
1473 if (TREE_CODE (newdecl) == FUNCTION_DECL)
1475 /* If we're redefining a function previously defined as extern
1476 inline, make sure we emit debug info for the inline before we
1477 throw it away, in case it was inlined into a function that hasn't
1478 been written out yet. */
1479 if (new_is_definition && DECL_INITIAL (olddecl))
1481 if (TREE_USED (olddecl))
1482 (*debug_hooks->outlining_inline_function) (olddecl);
1484 /* The new defn must not be inline. */
1485 DECL_INLINE (newdecl) = 0;
1486 DECL_UNINLINABLE (newdecl) = 1;
1488 else
1490 /* If either decl says `inline', this fn is inline,
1491 unless its definition was passed already. */
1492 if (DECL_DECLARED_INLINE_P (newdecl)
1493 || DECL_DECLARED_INLINE_P (olddecl))
1494 DECL_DECLARED_INLINE_P (newdecl) = 1;
1496 DECL_UNINLINABLE (newdecl) = DECL_UNINLINABLE (olddecl)
1497 = (DECL_UNINLINABLE (newdecl) || DECL_UNINLINABLE (olddecl));
1500 if (DECL_BUILT_IN (olddecl))
1502 /* Get rid of any built-in function if new arg types don't match it
1503 or if we have a function definition. */
1504 if (! types_match || new_is_definition)
1506 if (! different_binding_level)
1508 TREE_TYPE (olddecl) = TREE_TYPE (newdecl);
1509 DECL_BUILT_IN_CLASS (olddecl) = NOT_BUILT_IN;
1512 else
1514 /* If redeclaring a builtin function, and not a definition,
1515 it stays built in. */
1516 DECL_BUILT_IN_CLASS (newdecl) = DECL_BUILT_IN_CLASS (olddecl);
1517 DECL_FUNCTION_CODE (newdecl) = DECL_FUNCTION_CODE (olddecl);
1521 /* Also preserve various other info from the definition. */
1522 if (! new_is_definition)
1524 DECL_RESULT (newdecl) = DECL_RESULT (olddecl);
1525 /* When called with different_binding_level set, don't copy over
1526 DECL_INITIAL, so that we don't accidentally change function
1527 declarations into function definitions. */
1528 if (! different_binding_level)
1529 DECL_INITIAL (newdecl) = DECL_INITIAL (olddecl);
1530 DECL_SAVED_INSNS (newdecl) = DECL_SAVED_INSNS (olddecl);
1531 DECL_SAVED_TREE (newdecl) = DECL_SAVED_TREE (olddecl);
1532 DECL_NUM_STMTS (newdecl) = DECL_NUM_STMTS (olddecl);
1533 DECL_ARGUMENTS (newdecl) = DECL_ARGUMENTS (olddecl);
1535 /* Set DECL_INLINE on the declaration if we've got a body
1536 from which to instantiate. */
1537 if (DECL_INLINE (olddecl) && ! DECL_UNINLINABLE (newdecl))
1539 DECL_INLINE (newdecl) = 1;
1540 DECL_ABSTRACT_ORIGIN (newdecl)
1541 = (different_binding_level
1542 ? DECL_ORIGIN (olddecl)
1543 : DECL_ABSTRACT_ORIGIN (olddecl));
1546 else
1548 /* If a previous declaration said inline, mark the
1549 definition as inlinable. */
1550 if (DECL_DECLARED_INLINE_P (newdecl)
1551 && ! DECL_UNINLINABLE (newdecl))
1552 DECL_INLINE (newdecl) = 1;
1555 if (different_binding_level)
1556 return 0;
1558 /* Copy most of the decl-specific fields of NEWDECL into OLDDECL.
1559 But preserve OLDDECL's DECL_UID. */
1561 unsigned olddecl_uid = DECL_UID (olddecl);
1563 memcpy ((char *) olddecl + sizeof (struct tree_common),
1564 (char *) newdecl + sizeof (struct tree_common),
1565 sizeof (struct tree_decl) - sizeof (struct tree_common));
1566 DECL_UID (olddecl) = olddecl_uid;
1569 /* NEWDECL contains the merged attribute lists.
1570 Update OLDDECL to be the same. */
1571 DECL_ATTRIBUTES (olddecl) = DECL_ATTRIBUTES (newdecl);
1573 return 1;
1576 /* Check whether decl-node X shadows an existing declaration.
1577 OLDLOCAL is the old IDENTIFIER_LOCAL_VALUE of the DECL_NAME of X,
1578 which might be a NULL_TREE. */
1579 static void
1580 warn_if_shadowing (x, oldlocal)
1581 tree x, oldlocal;
1583 tree name;
1585 if (DECL_EXTERNAL (x))
1586 return;
1588 name = DECL_NAME (x);
1590 /* Warn if shadowing an argument at the top level of the body. */
1591 if (oldlocal != 0
1592 /* This warning doesn't apply to the parms of a nested fcn. */
1593 && ! current_binding_level->parm_flag
1594 /* Check that this is one level down from the parms. */
1595 && current_binding_level->level_chain->parm_flag
1596 /* Check that the decl being shadowed
1597 comes from the parm level, one level up. */
1598 && chain_member (oldlocal, current_binding_level->level_chain->names))
1600 if (TREE_CODE (oldlocal) == PARM_DECL)
1601 pedwarn ("declaration of `%s' shadows a parameter",
1602 IDENTIFIER_POINTER (name));
1603 else
1604 pedwarn ("declaration of `%s' shadows a symbol from the parameter list",
1605 IDENTIFIER_POINTER (name));
1607 /* Maybe warn if shadowing something else. */
1608 else if (warn_shadow
1609 /* No shadow warnings for internally generated vars. */
1610 && DECL_SOURCE_LINE (x) != 0
1611 /* No shadow warnings for vars made for inlining. */
1612 && ! DECL_FROM_INLINE (x))
1614 if (TREE_CODE (x) == PARM_DECL
1615 && current_binding_level->level_chain->parm_flag)
1616 /* Don't warn about the parm names in function declarator
1617 within a function declarator.
1618 It would be nice to avoid warning in any function
1619 declarator in a declaration, as opposed to a definition,
1620 but there is no way to tell it's not a definition. */
1622 else if (oldlocal)
1624 if (TREE_CODE (oldlocal) == PARM_DECL)
1625 shadow_warning ("a parameter", name, oldlocal);
1626 else
1627 shadow_warning ("a previous local", name, oldlocal);
1629 else if (IDENTIFIER_GLOBAL_VALUE (name) != 0
1630 && IDENTIFIER_GLOBAL_VALUE (name) != error_mark_node)
1631 shadow_warning ("a global declaration", name,
1632 IDENTIFIER_GLOBAL_VALUE (name));
1636 /* Record a decl-node X as belonging to the current lexical scope.
1637 Check for errors (such as an incompatible declaration for the same
1638 name already seen in the same scope).
1640 Returns either X or an old decl for the same name.
1641 If an old decl is returned, it may have been smashed
1642 to agree with what X says. */
1644 tree
1645 pushdecl (x)
1646 tree x;
1648 tree t;
1649 tree name = DECL_NAME (x);
1650 struct binding_level *b = current_binding_level;
1652 /* Functions need the lang_decl data. */
1653 if (TREE_CODE (x) == FUNCTION_DECL && ! DECL_LANG_SPECIFIC (x))
1654 DECL_LANG_SPECIFIC (x) = (struct lang_decl *)
1655 ggc_alloc_cleared (sizeof (struct lang_decl));
1657 DECL_CONTEXT (x) = current_function_decl;
1658 /* A local extern declaration for a function doesn't constitute nesting.
1659 A local auto declaration does, since it's a forward decl
1660 for a nested function coming later. */
1661 if ((TREE_CODE (x) == FUNCTION_DECL || TREE_CODE (x) == VAR_DECL)
1662 && DECL_INITIAL (x) == 0 && DECL_EXTERNAL (x))
1663 DECL_CONTEXT (x) = 0;
1665 if (name)
1667 int different_binding_level = 0;
1669 if (warn_nested_externs
1670 && DECL_EXTERNAL (x)
1671 && b != global_binding_level
1672 && x != IDENTIFIER_IMPLICIT_DECL (name)
1673 /* No error messages for __FUNCTION__ and __PRETTY_FUNCTION__. */
1674 && !DECL_IN_SYSTEM_HEADER (x))
1675 warning ("nested extern declaration of `%s'",
1676 IDENTIFIER_POINTER (name));
1678 t = lookup_name_current_level (name);
1679 if (! t && DECL_EXTERNAL (x) && TREE_PUBLIC (x))
1681 t = IDENTIFIER_GLOBAL_VALUE (name);
1682 /* Type decls at global scope don't conflict with externs declared
1683 inside lexical blocks. */
1684 if (! t || TREE_CODE (t) == TYPE_DECL)
1685 /* If there's no visible global declaration, try for an
1686 invisible one. */
1687 t = IDENTIFIER_LIMBO_VALUE (name);
1688 different_binding_level = 1;
1690 if (t != 0 && t == error_mark_node)
1691 /* error_mark_node is 0 for a while during initialization! */
1693 t = 0;
1694 error_with_decl (x, "`%s' used prior to declaration");
1697 /* If this decl is `static' and an implicit decl was seen previously,
1698 warn. */
1699 if (TREE_PUBLIC (name)
1700 /* Don't test for DECL_EXTERNAL, because grokdeclarator
1701 sets this for all functions. */
1702 && ! TREE_PUBLIC (x)
1703 && (TREE_CODE (x) == FUNCTION_DECL || b == global_binding_level)
1704 /* We used to warn also for explicit extern followed by static,
1705 but sometimes you need to do it that way. */
1706 && IDENTIFIER_IMPLICIT_DECL (name) != 0)
1708 pedwarn ("`%s' was declared implicitly `extern' and later `static'",
1709 IDENTIFIER_POINTER (name));
1710 pedwarn_with_file_and_line
1711 (DECL_SOURCE_FILE (IDENTIFIER_IMPLICIT_DECL (name)),
1712 DECL_SOURCE_LINE (IDENTIFIER_IMPLICIT_DECL (name)),
1713 "previous declaration of `%s'",
1714 IDENTIFIER_POINTER (name));
1715 TREE_THIS_VOLATILE (name) = 1;
1718 if (t != 0 && duplicate_decls (x, t, different_binding_level))
1720 if (TREE_CODE (t) == PARM_DECL)
1722 /* Don't allow more than one "real" duplicate
1723 of a forward parm decl. */
1724 TREE_ASM_WRITTEN (t) = TREE_ASM_WRITTEN (x);
1725 return t;
1727 return t;
1730 /* If we are processing a typedef statement, generate a whole new
1731 ..._TYPE node (which will be just a variant of the existing
1732 ..._TYPE node with identical properties) and then install the
1733 TYPE_DECL node generated to represent the typedef name as the
1734 TYPE_NAME of this brand new (duplicate) ..._TYPE node.
1736 The whole point here is to end up with a situation where each
1737 and every ..._TYPE node the compiler creates will be uniquely
1738 associated with AT MOST one node representing a typedef name.
1739 This way, even though the compiler substitutes corresponding
1740 ..._TYPE nodes for TYPE_DECL (i.e. "typedef name") nodes very
1741 early on, later parts of the compiler can always do the reverse
1742 translation and get back the corresponding typedef name. For
1743 example, given:
1745 typedef struct S MY_TYPE;
1746 MY_TYPE object;
1748 Later parts of the compiler might only know that `object' was of
1749 type `struct S' if it were not for code just below. With this
1750 code however, later parts of the compiler see something like:
1752 struct S' == struct S
1753 typedef struct S' MY_TYPE;
1754 struct S' object;
1756 And they can then deduce (from the node for type struct S') that
1757 the original object declaration was:
1759 MY_TYPE object;
1761 Being able to do this is important for proper support of protoize,
1762 and also for generating precise symbolic debugging information
1763 which takes full account of the programmer's (typedef) vocabulary.
1765 Obviously, we don't want to generate a duplicate ..._TYPE node if
1766 the TYPE_DECL node that we are now processing really represents a
1767 standard built-in type.
1769 Since all standard types are effectively declared at line zero
1770 in the source file, we can easily check to see if we are working
1771 on a standard type by checking the current value of lineno. */
1773 if (TREE_CODE (x) == TYPE_DECL)
1775 if (DECL_SOURCE_LINE (x) == 0)
1777 if (TYPE_NAME (TREE_TYPE (x)) == 0)
1778 TYPE_NAME (TREE_TYPE (x)) = x;
1780 else if (TREE_TYPE (x) != error_mark_node
1781 && DECL_ORIGINAL_TYPE (x) == NULL_TREE)
1783 tree tt = TREE_TYPE (x);
1784 DECL_ORIGINAL_TYPE (x) = tt;
1785 tt = build_type_copy (tt);
1786 TYPE_NAME (tt) = x;
1787 TREE_USED (tt) = TREE_USED (x);
1788 TREE_TYPE (x) = tt;
1792 /* Multiple external decls of the same identifier ought to match.
1793 We get warnings about inline functions where they are defined.
1794 Avoid duplicate warnings where they are used. */
1795 if (TREE_PUBLIC (x)
1796 && ! (TREE_CODE (x) == FUNCTION_DECL && DECL_INLINE (x)))
1798 tree decl;
1800 if (IDENTIFIER_LIMBO_VALUE (name) != 0)
1801 /* Decls in limbo are always extern, so no need to check that. */
1802 decl = IDENTIFIER_LIMBO_VALUE (name);
1803 else
1804 decl = 0;
1806 if (decl && ! comptypes (TREE_TYPE (x), TREE_TYPE (decl))
1807 /* If old decl is built-in, we already warned if we should. */
1808 && !DECL_BUILT_IN (decl))
1810 pedwarn_with_decl (x,
1811 "type mismatch with previous external decl");
1812 pedwarn_with_decl (decl, "previous external decl of `%s'");
1816 /* If a function has had an implicit declaration, and then is defined,
1817 make sure they are compatible. */
1819 if (IDENTIFIER_IMPLICIT_DECL (name) != 0
1820 && IDENTIFIER_GLOBAL_VALUE (name) == 0
1821 && TREE_CODE (x) == FUNCTION_DECL
1822 && ! comptypes (TREE_TYPE (x),
1823 TREE_TYPE (IDENTIFIER_IMPLICIT_DECL (name))))
1825 warning_with_decl (x, "type mismatch with previous implicit declaration");
1826 warning_with_decl (IDENTIFIER_IMPLICIT_DECL (name),
1827 "previous implicit declaration of `%s'");
1830 /* This name is new in its binding level.
1831 Install the new declaration and return it. */
1832 if (b == global_binding_level)
1834 /* Install a global value. */
1836 /* If the first global decl has external linkage,
1837 warn if we later see static one. */
1838 if (IDENTIFIER_GLOBAL_VALUE (name) == 0 && TREE_PUBLIC (x))
1839 TREE_PUBLIC (name) = 1;
1841 IDENTIFIER_GLOBAL_VALUE (name) = x;
1843 /* We no longer care about any previous block level declarations. */
1844 IDENTIFIER_LIMBO_VALUE (name) = 0;
1846 /* Don't forget if the function was used via an implicit decl. */
1847 if (IDENTIFIER_IMPLICIT_DECL (name)
1848 && TREE_USED (IDENTIFIER_IMPLICIT_DECL (name)))
1849 TREE_USED (x) = 1, TREE_USED (name) = 1;
1851 /* Don't forget if its address was taken in that way. */
1852 if (IDENTIFIER_IMPLICIT_DECL (name)
1853 && TREE_ADDRESSABLE (IDENTIFIER_IMPLICIT_DECL (name)))
1854 TREE_ADDRESSABLE (x) = 1;
1856 /* Warn about mismatches against previous implicit decl. */
1857 if (IDENTIFIER_IMPLICIT_DECL (name) != 0
1858 /* If this real decl matches the implicit, don't complain. */
1859 && ! (TREE_CODE (x) == FUNCTION_DECL
1860 && (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (x)))
1861 == integer_type_node)))
1862 pedwarn ("`%s' was previously implicitly declared to return `int'",
1863 IDENTIFIER_POINTER (name));
1865 /* If this decl is `static' and an `extern' was seen previously,
1866 that is erroneous. */
1867 if (TREE_PUBLIC (name)
1868 && ! TREE_PUBLIC (x) && ! DECL_EXTERNAL (x))
1870 /* Okay to redeclare an ANSI built-in as static. */
1871 if (t != 0 && DECL_BUILT_IN (t))
1873 /* Okay to declare a non-ANSI built-in as anything. */
1874 else if (t != 0 && DECL_BUILT_IN_NONANSI (t))
1876 /* Okay to have global type decl after an earlier extern
1877 declaration inside a lexical block. */
1878 else if (TREE_CODE (x) == TYPE_DECL)
1880 else if (IDENTIFIER_IMPLICIT_DECL (name))
1882 if (! TREE_THIS_VOLATILE (name))
1883 pedwarn ("`%s' was declared implicitly `extern' and later `static'",
1884 IDENTIFIER_POINTER (name));
1886 else
1887 pedwarn ("`%s' was declared `extern' and later `static'",
1888 IDENTIFIER_POINTER (name));
1891 else
1893 /* Here to install a non-global value. */
1894 tree oldlocal = IDENTIFIER_LOCAL_VALUE (name);
1895 tree oldglobal = IDENTIFIER_GLOBAL_VALUE (name);
1897 IDENTIFIER_LOCAL_VALUE (name) = x;
1899 /* If this is an extern function declaration, see if we
1900 have a global definition or declaration for the function. */
1901 if (oldlocal == 0
1902 && oldglobal != 0
1903 && TREE_CODE (x) == FUNCTION_DECL
1904 && TREE_CODE (oldglobal) == FUNCTION_DECL
1905 && DECL_EXTERNAL (x)
1906 && ! DECL_DECLARED_INLINE_P (x))
1908 /* We have one. Their types must agree. */
1909 if (! comptypes (TREE_TYPE (x),
1910 TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (name))))
1911 pedwarn_with_decl (x, "extern declaration of `%s' doesn't match global one");
1912 else
1914 /* Inner extern decl is inline if global one is.
1915 Copy enough to really inline it. */
1916 if (DECL_DECLARED_INLINE_P (oldglobal))
1918 DECL_DECLARED_INLINE_P (x)
1919 = DECL_DECLARED_INLINE_P (oldglobal);
1920 DECL_INLINE (x) = DECL_INLINE (oldglobal);
1921 DECL_INITIAL (x) = (current_function_decl == oldglobal
1922 ? 0 : DECL_INITIAL (oldglobal));
1923 DECL_SAVED_INSNS (x) = DECL_SAVED_INSNS (oldglobal);
1924 DECL_NUM_STMTS (x) = DECL_NUM_STMTS (oldglobal);
1925 DECL_ARGUMENTS (x) = DECL_ARGUMENTS (oldglobal);
1926 DECL_RESULT (x) = DECL_RESULT (oldglobal);
1927 TREE_ASM_WRITTEN (x) = TREE_ASM_WRITTEN (oldglobal);
1928 DECL_ABSTRACT_ORIGIN (x)
1929 = DECL_ABSTRACT_ORIGIN (oldglobal);
1931 /* Inner extern decl is built-in if global one is. */
1932 if (DECL_BUILT_IN (oldglobal))
1934 DECL_BUILT_IN_CLASS (x) = DECL_BUILT_IN_CLASS (oldglobal);
1935 DECL_FUNCTION_CODE (x) = DECL_FUNCTION_CODE (oldglobal);
1937 /* Keep the arg types from a file-scope fcn defn. */
1938 if (TYPE_ARG_TYPES (TREE_TYPE (oldglobal)) != 0
1939 && DECL_INITIAL (oldglobal)
1940 && TYPE_ARG_TYPES (TREE_TYPE (x)) == 0)
1941 TREE_TYPE (x) = TREE_TYPE (oldglobal);
1945 #if 0
1946 /* This case is probably sometimes the right thing to do. */
1947 /* If we have a local external declaration,
1948 then any file-scope declaration should not
1949 have been static. */
1950 if (oldlocal == 0 && oldglobal != 0
1951 && !TREE_PUBLIC (oldglobal)
1952 && DECL_EXTERNAL (x) && TREE_PUBLIC (x))
1953 warning ("`%s' locally external but globally static",
1954 IDENTIFIER_POINTER (name));
1955 #endif
1957 /* If we have a local external declaration,
1958 and no file-scope declaration has yet been seen,
1959 then if we later have a file-scope decl it must not be static. */
1960 if (oldlocal == 0
1961 && DECL_EXTERNAL (x)
1962 && TREE_PUBLIC (x))
1964 if (oldglobal == 0)
1965 TREE_PUBLIC (name) = 1;
1967 /* Save this decl, so that we can do type checking against
1968 other decls after it falls out of scope.
1970 Only save it once. This prevents temporary decls created in
1971 expand_inline_function from being used here, since this
1972 will have been set when the inline function was parsed.
1973 It also helps give slightly better warnings. */
1974 if (IDENTIFIER_LIMBO_VALUE (name) == 0)
1975 IDENTIFIER_LIMBO_VALUE (name) = x;
1978 warn_if_shadowing (x, oldlocal);
1980 /* If storing a local value, there may already be one (inherited).
1981 If so, record it for restoration when this binding level ends. */
1982 if (oldlocal != 0)
1983 b->shadowed = tree_cons (name, oldlocal, b->shadowed);
1986 /* Keep list of variables in this level with incomplete type.
1987 If the input is erroneous, we can have error_mark in the type
1988 slot (e.g. "f(void a, ...)") - that doesn't count as an
1989 incomplete type. */
1990 if (TREE_TYPE (x) != error_mark_node
1991 && !COMPLETE_TYPE_P (TREE_TYPE (x)))
1993 tree element = TREE_TYPE (x);
1995 while (TREE_CODE (element) == ARRAY_TYPE)
1996 element = TREE_TYPE (element);
1997 if (TREE_CODE (element) == RECORD_TYPE
1998 || TREE_CODE (element) == UNION_TYPE)
1999 b->incomplete_list = tree_cons (NULL_TREE, x, b->incomplete_list);
2003 /* Put decls on list in reverse order.
2004 We will reverse them later if necessary. */
2005 TREE_CHAIN (x) = b->names;
2006 b->names = x;
2008 return x;
2011 /* Like pushdecl, only it places X in GLOBAL_BINDING_LEVEL, if appropriate. */
2013 tree
2014 pushdecl_top_level (x)
2015 tree x;
2017 tree t;
2018 struct binding_level *b = current_binding_level;
2020 current_binding_level = global_binding_level;
2021 t = pushdecl (x);
2022 current_binding_level = b;
2023 return t;
2026 /* Generate an implicit declaration for identifier FUNCTIONID
2027 as a function of type int (). Print a warning if appropriate. */
2029 tree
2030 implicitly_declare (functionid)
2031 tree functionid;
2033 tree decl;
2034 int traditional_warning = 0;
2035 /* Only one "implicit declaration" warning per identifier. */
2036 int implicit_warning;
2038 /* We used to reuse an old implicit decl here,
2039 but this loses with inline functions because it can clobber
2040 the saved decl chains. */
2041 #if 0
2042 if (IDENTIFIER_IMPLICIT_DECL (functionid) != 0)
2043 decl = IDENTIFIER_IMPLICIT_DECL (functionid);
2044 else
2045 #endif
2046 decl = build_decl (FUNCTION_DECL, functionid, default_function_type);
2048 /* Warn of implicit decl following explicit local extern decl.
2049 This is probably a program designed for traditional C. */
2050 if (TREE_PUBLIC (functionid) && IDENTIFIER_GLOBAL_VALUE (functionid) == 0)
2051 traditional_warning = 1;
2053 /* Warn once of an implicit declaration. */
2054 implicit_warning = (IDENTIFIER_IMPLICIT_DECL (functionid) == 0);
2056 DECL_EXTERNAL (decl) = 1;
2057 TREE_PUBLIC (decl) = 1;
2059 /* Record that we have an implicit decl and this is it. */
2060 IDENTIFIER_IMPLICIT_DECL (functionid) = decl;
2062 /* ANSI standard says implicit declarations are in the innermost block.
2063 So we record the decl in the standard fashion. */
2064 pushdecl (decl);
2066 /* This is a no-op in c-lang.c or something real in objc-act.c. */
2067 if (flag_objc)
2068 objc_check_decl (decl);
2070 rest_of_decl_compilation (decl, NULL, 0, 0);
2072 if (implicit_warning)
2073 implicit_decl_warning (functionid);
2074 else if (warn_traditional && traditional_warning)
2075 warning ("function `%s' was previously declared within a block",
2076 IDENTIFIER_POINTER (functionid));
2078 /* Write a record describing this implicit function declaration to the
2079 prototypes file (if requested). */
2081 gen_aux_info_record (decl, 0, 1, 0);
2083 /* Possibly apply some default attributes to this implicit declaration. */
2084 decl_attributes (&decl, NULL_TREE, 0);
2086 return decl;
2089 void
2090 implicit_decl_warning (id)
2091 tree id;
2093 const char *name = IDENTIFIER_POINTER (id);
2094 if (mesg_implicit_function_declaration == 2)
2095 error ("implicit declaration of function `%s'", name);
2096 else if (mesg_implicit_function_declaration == 1)
2097 warning ("implicit declaration of function `%s'", name);
2100 /* Return zero if the declaration NEWDECL is valid
2101 when the declaration OLDDECL (assumed to be for the same name)
2102 has already been seen.
2103 Otherwise return 1 if NEWDECL is a redefinition, 2 if it is a redeclaration,
2104 and 3 if it is a conflicting declaration. */
2106 static int
2107 redeclaration_error_message (newdecl, olddecl)
2108 tree newdecl, olddecl;
2110 if (TREE_CODE (newdecl) == TYPE_DECL)
2112 /* Do not complain about type redeclarations where at least one
2113 declaration was in a system header. */
2114 if (DECL_IN_SYSTEM_HEADER (olddecl) || DECL_IN_SYSTEM_HEADER (newdecl))
2115 return 0;
2116 return 1;
2118 else if (TREE_CODE (newdecl) == FUNCTION_DECL)
2120 /* Declarations of functions can insist on internal linkage
2121 but they can't be inconsistent with internal linkage,
2122 so there can be no error on that account.
2123 However defining the same name twice is no good. */
2124 if (DECL_INITIAL (olddecl) != 0 && DECL_INITIAL (newdecl) != 0
2125 /* However, defining once as extern inline and a second
2126 time in another way is ok. */
2127 && ! (DECL_DECLARED_INLINE_P (olddecl) && DECL_EXTERNAL (olddecl)
2128 && ! (DECL_DECLARED_INLINE_P (newdecl)
2129 && DECL_EXTERNAL (newdecl))))
2130 return 1;
2131 return 0;
2133 else if (DECL_CONTEXT (newdecl) == NULL_TREE)
2135 /* Objects declared at top level: */
2136 /* If at least one is a reference, it's ok. */
2137 if (DECL_EXTERNAL (newdecl) || DECL_EXTERNAL (olddecl))
2138 return 0;
2139 /* Reject two definitions. */
2140 if (DECL_INITIAL (olddecl) != 0 && DECL_INITIAL (newdecl) != 0)
2141 return 1;
2142 /* Now we have two tentative defs, or one tentative and one real def. */
2143 /* Insist that the linkage match. */
2144 if (TREE_PUBLIC (olddecl) != TREE_PUBLIC (newdecl))
2145 return 3;
2146 return 0;
2148 else if (current_binding_level->parm_flag
2149 && TREE_ASM_WRITTEN (olddecl) && !TREE_ASM_WRITTEN (newdecl))
2150 return 0;
2151 else
2153 /* Newdecl has block scope. If olddecl has block scope also, then
2154 reject two definitions, and reject a definition together with an
2155 external reference. Otherwise, it is OK, because newdecl must
2156 be an extern reference to olddecl. */
2157 if (!(DECL_EXTERNAL (newdecl) && DECL_EXTERNAL (olddecl))
2158 && DECL_CONTEXT (newdecl) == DECL_CONTEXT (olddecl))
2159 return 2;
2160 return 0;
2164 /* Get the LABEL_DECL corresponding to identifier ID as a label.
2165 Create one if none exists so far for the current function.
2166 This function is called for both label definitions and label references. */
2168 tree
2169 lookup_label (id)
2170 tree id;
2172 tree decl = IDENTIFIER_LABEL_VALUE (id);
2174 if (current_function_decl == 0)
2176 error ("label %s referenced outside of any function",
2177 IDENTIFIER_POINTER (id));
2178 return 0;
2181 /* Use a label already defined or ref'd with this name. */
2182 if (decl != 0)
2184 /* But not if it is inherited and wasn't declared to be inheritable. */
2185 if (DECL_CONTEXT (decl) != current_function_decl
2186 && ! C_DECLARED_LABEL_FLAG (decl))
2187 return shadow_label (id);
2188 return decl;
2191 decl = build_decl (LABEL_DECL, id, void_type_node);
2193 /* A label not explicitly declared must be local to where it's ref'd. */
2194 DECL_CONTEXT (decl) = current_function_decl;
2196 DECL_MODE (decl) = VOIDmode;
2198 /* Say where one reference is to the label,
2199 for the sake of the error if it is not defined. */
2200 DECL_SOURCE_LINE (decl) = lineno;
2201 DECL_SOURCE_FILE (decl) = input_filename;
2203 IDENTIFIER_LABEL_VALUE (id) = decl;
2205 named_labels = tree_cons (NULL_TREE, decl, named_labels);
2207 return decl;
2210 /* Make a label named NAME in the current function,
2211 shadowing silently any that may be inherited from containing functions
2212 or containing scopes.
2214 Note that valid use, if the label being shadowed
2215 comes from another scope in the same function,
2216 requires calling declare_nonlocal_label right away. */
2218 tree
2219 shadow_label (name)
2220 tree name;
2222 tree decl = IDENTIFIER_LABEL_VALUE (name);
2224 if (decl != 0)
2226 tree dup;
2228 /* Check to make sure that the label hasn't already been declared
2229 at this label scope */
2230 for (dup = named_labels; dup; dup = TREE_CHAIN (dup))
2231 if (TREE_VALUE (dup) == decl)
2233 error ("duplicate label declaration `%s'",
2234 IDENTIFIER_POINTER (name));
2235 error_with_decl (TREE_VALUE (dup),
2236 "this is a previous declaration");
2237 /* Just use the previous declaration. */
2238 return lookup_label (name);
2241 shadowed_labels = tree_cons (NULL_TREE, decl, shadowed_labels);
2242 IDENTIFIER_LABEL_VALUE (name) = decl = 0;
2245 return lookup_label (name);
2248 /* Define a label, specifying the location in the source file.
2249 Return the LABEL_DECL node for the label, if the definition is valid.
2250 Otherwise return 0. */
2252 tree
2253 define_label (filename, line, name)
2254 const char *filename;
2255 int line;
2256 tree name;
2258 tree decl = lookup_label (name);
2260 /* If label with this name is known from an outer context, shadow it. */
2261 if (decl != 0 && DECL_CONTEXT (decl) != current_function_decl)
2263 shadowed_labels = tree_cons (NULL_TREE, decl, shadowed_labels);
2264 IDENTIFIER_LABEL_VALUE (name) = 0;
2265 decl = lookup_label (name);
2268 if (warn_traditional && !in_system_header && lookup_name (name))
2269 warning_with_file_and_line (filename, line,
2270 "traditional C lacks a separate namespace for labels, identifier `%s' conflicts",
2271 IDENTIFIER_POINTER (name));
2273 if (DECL_INITIAL (decl) != 0)
2275 error_with_file_and_line (filename, line, "duplicate label `%s'",
2276 IDENTIFIER_POINTER (name));
2277 return 0;
2279 else
2281 /* Mark label as having been defined. */
2282 DECL_INITIAL (decl) = error_mark_node;
2283 /* Say where in the source. */
2284 DECL_SOURCE_FILE (decl) = filename;
2285 DECL_SOURCE_LINE (decl) = line;
2286 return decl;
2290 /* Return the list of declarations of the current level.
2291 Note that this list is in reverse order unless/until
2292 you nreverse it; and when you do nreverse it, you must
2293 store the result back using `storedecls' or you will lose. */
2295 tree
2296 getdecls ()
2298 return current_binding_level->names;
2301 /* Return the list of type-tags (for structs, etc) of the current level. */
2303 tree
2304 gettags ()
2306 return current_binding_level->tags;
2309 /* Store the list of declarations of the current level.
2310 This is done for the parameter declarations of a function being defined,
2311 after they are modified in the light of any missing parameters. */
2313 static void
2314 storedecls (decls)
2315 tree decls;
2317 current_binding_level->names = decls;
2320 /* Similarly, store the list of tags of the current level. */
2322 static void
2323 storetags (tags)
2324 tree tags;
2326 current_binding_level->tags = tags;
2329 /* Given NAME, an IDENTIFIER_NODE,
2330 return the structure (or union or enum) definition for that name.
2331 Searches binding levels from BINDING_LEVEL up to the global level.
2332 If THISLEVEL_ONLY is nonzero, searches only the specified context
2333 (but skips any tag-transparent contexts to find one that is
2334 meaningful for tags).
2335 CODE says which kind of type the caller wants;
2336 it is RECORD_TYPE or UNION_TYPE or ENUMERAL_TYPE.
2337 If the wrong kind of type is found, an error is reported. */
2339 static tree
2340 lookup_tag (code, name, binding_level, thislevel_only)
2341 enum tree_code code;
2342 struct binding_level *binding_level;
2343 tree name;
2344 int thislevel_only;
2346 struct binding_level *level;
2347 int thislevel = 1;
2349 for (level = binding_level; level; level = level->level_chain)
2351 tree tail;
2352 for (tail = level->tags; tail; tail = TREE_CHAIN (tail))
2354 if (TREE_PURPOSE (tail) == name)
2356 if (TREE_CODE (TREE_VALUE (tail)) != code)
2358 /* Definition isn't the kind we were looking for. */
2359 pending_invalid_xref = name;
2360 pending_invalid_xref_file = input_filename;
2361 pending_invalid_xref_line = lineno;
2362 /* If in the same binding level as a declaration as a tag
2363 of a different type, this must not be allowed to
2364 shadow that tag, so give the error immediately.
2365 (For example, "struct foo; union foo;" is invalid.) */
2366 if (thislevel)
2367 pending_xref_error ();
2369 return TREE_VALUE (tail);
2372 if (! level->tag_transparent)
2374 if (thislevel_only)
2375 return NULL_TREE;
2376 thislevel = 0;
2379 return NULL_TREE;
2382 /* Print an error message now
2383 for a recent invalid struct, union or enum cross reference.
2384 We don't print them immediately because they are not invalid
2385 when used in the `struct foo;' construct for shadowing. */
2387 void
2388 pending_xref_error ()
2390 if (pending_invalid_xref != 0)
2391 error_with_file_and_line (pending_invalid_xref_file,
2392 pending_invalid_xref_line,
2393 "`%s' defined as wrong kind of tag",
2394 IDENTIFIER_POINTER (pending_invalid_xref));
2395 pending_invalid_xref = 0;
2398 /* Given a type, find the tag that was defined for it and return the tag name.
2399 Otherwise return 0. */
2401 static tree
2402 lookup_tag_reverse (type)
2403 tree type;
2405 struct binding_level *level;
2407 for (level = current_binding_level; level; level = level->level_chain)
2409 tree tail;
2410 for (tail = level->tags; tail; tail = TREE_CHAIN (tail))
2412 if (TREE_VALUE (tail) == type)
2413 return TREE_PURPOSE (tail);
2416 return NULL_TREE;
2419 /* Look up NAME in the current binding level and its superiors
2420 in the namespace of variables, functions and typedefs.
2421 Return a ..._DECL node of some kind representing its definition,
2422 or return 0 if it is undefined. */
2424 tree
2425 lookup_name (name)
2426 tree name;
2428 tree val;
2430 if (current_binding_level != global_binding_level
2431 && IDENTIFIER_LOCAL_VALUE (name))
2432 val = IDENTIFIER_LOCAL_VALUE (name);
2433 else
2434 val = IDENTIFIER_GLOBAL_VALUE (name);
2435 return val;
2438 /* Similar to `lookup_name' but look only at current binding level. */
2440 tree
2441 lookup_name_current_level (name)
2442 tree name;
2444 tree t;
2446 if (current_binding_level == global_binding_level)
2447 return IDENTIFIER_GLOBAL_VALUE (name);
2449 if (IDENTIFIER_LOCAL_VALUE (name) == 0)
2450 return 0;
2452 for (t = current_binding_level->names; t; t = TREE_CHAIN (t))
2453 if (DECL_NAME (t) == name)
2454 break;
2456 return t;
2459 /* Create the predefined scalar types of C,
2460 and some nodes representing standard constants (0, 1, (void *) 0).
2461 Initialize the global binding level.
2462 Make definitions for built-in primitive functions. */
2464 void
2465 c_init_decl_processing ()
2467 tree endlink;
2468 tree ptr_ftype_void, ptr_ftype_ptr;
2470 /* Adds some ggc roots, and reserved words for c-parse.in. */
2471 c_parse_init ();
2473 current_function_decl = NULL;
2474 named_labels = NULL;
2475 current_binding_level = NULL_BINDING_LEVEL;
2476 free_binding_level = NULL_BINDING_LEVEL;
2478 /* Make the binding_level structure for global names. */
2479 pushlevel (0);
2480 global_binding_level = current_binding_level;
2482 build_common_tree_nodes (flag_signed_char);
2484 c_common_nodes_and_builtins ();
2486 boolean_type_node = integer_type_node;
2487 boolean_true_node = integer_one_node;
2488 boolean_false_node = integer_zero_node;
2490 c_bool_type_node = make_unsigned_type (BOOL_TYPE_SIZE);
2491 TREE_SET_CODE (c_bool_type_node, BOOLEAN_TYPE);
2492 TYPE_MAX_VALUE (c_bool_type_node) = build_int_2 (1, 0);
2493 TREE_TYPE (TYPE_MAX_VALUE (c_bool_type_node)) = c_bool_type_node;
2494 TYPE_PRECISION (c_bool_type_node) = 1;
2495 pushdecl (build_decl (TYPE_DECL, get_identifier ("_Bool"),
2496 c_bool_type_node));
2497 c_bool_false_node = build_int_2 (0, 0);
2498 TREE_TYPE (c_bool_false_node) = c_bool_type_node;
2499 c_bool_true_node = build_int_2 (1, 0);
2500 TREE_TYPE (c_bool_true_node) = c_bool_type_node;
2502 endlink = void_list_node;
2503 ptr_ftype_void = build_function_type (ptr_type_node, endlink);
2504 ptr_ftype_ptr
2505 = build_function_type (ptr_type_node,
2506 tree_cons (NULL_TREE, ptr_type_node, endlink));
2508 pedantic_lvalues = pedantic;
2510 make_fname_decl = c_make_fname_decl;
2511 start_fname_decls ();
2514 /* Create the VAR_DECL for __FUNCTION__ etc. ID is the name to give the
2515 decl, NAME is the initialization string and TYPE_DEP indicates whether
2516 NAME depended on the type of the function. As we don't yet implement
2517 delayed emission of static data, we mark the decl as emitted
2518 so it is not placed in the output. Anything using it must therefore pull
2519 out the STRING_CST initializer directly. This does mean that these names
2520 are string merging candidates, which is wrong for C99's __func__. FIXME. */
2522 static tree
2523 c_make_fname_decl (id, type_dep)
2524 tree id;
2525 int type_dep;
2527 const char *name = fname_as_string (type_dep);
2528 tree decl, type, init;
2529 size_t length = strlen (name);
2531 type = build_array_type
2532 (build_qualified_type (char_type_node, TYPE_QUAL_CONST),
2533 build_index_type (size_int (length)));
2535 decl = build_decl (VAR_DECL, id, type);
2536 /* We don't push the decl, so have to set its context here. */
2537 DECL_CONTEXT (decl) = current_function_decl;
2539 TREE_STATIC (decl) = 1;
2540 TREE_READONLY (decl) = 1;
2541 DECL_ARTIFICIAL (decl) = 1;
2543 init = build_string (length + 1, name);
2544 TREE_TYPE (init) = type;
2545 DECL_INITIAL (decl) = init;
2547 TREE_USED (decl) = 1;
2549 finish_decl (decl, init, NULL_TREE);
2551 return decl;
2554 /* Return a definition for a builtin function named NAME and whose data type
2555 is TYPE. TYPE should be a function type with argument types.
2556 FUNCTION_CODE tells later passes how to compile calls to this function.
2557 See tree.h for its possible values.
2559 If LIBRARY_NAME is nonzero, use that for DECL_ASSEMBLER_NAME,
2560 the name to be called if we can't opencode the function. If
2561 ATTRS is nonzero, use that for the function's attribute list. */
2563 tree
2564 builtin_function (name, type, function_code, class, library_name, attrs)
2565 const char *name;
2566 tree type;
2567 int function_code;
2568 enum built_in_class class;
2569 const char *library_name;
2570 tree attrs;
2572 tree decl = build_decl (FUNCTION_DECL, get_identifier (name), type);
2573 DECL_EXTERNAL (decl) = 1;
2574 TREE_PUBLIC (decl) = 1;
2575 if (library_name)
2576 SET_DECL_ASSEMBLER_NAME (decl, get_identifier (library_name));
2577 make_decl_rtl (decl, NULL);
2578 pushdecl (decl);
2579 DECL_BUILT_IN_CLASS (decl) = class;
2580 DECL_FUNCTION_CODE (decl) = function_code;
2582 /* Warn if a function in the namespace for users
2583 is used without an occasion to consider it declared. */
2584 if (name[0] != '_' || name[1] != '_')
2585 C_DECL_ANTICIPATED (decl) = 1;
2587 /* Possibly apply some default attributes to this built-in function. */
2588 if (attrs)
2589 decl_attributes (&decl, attrs, ATTR_FLAG_BUILT_IN);
2590 else
2591 decl_attributes (&decl, NULL_TREE, 0);
2593 return decl;
2596 /* Apply default attributes to a function, if a system function with default
2597 attributes. */
2599 void
2600 c_insert_default_attributes (decl)
2601 tree decl;
2603 if (!TREE_PUBLIC (decl))
2604 return;
2605 c_common_insert_default_attributes (decl);
2608 /* Called when a declaration is seen that contains no names to declare.
2609 If its type is a reference to a structure, union or enum inherited
2610 from a containing scope, shadow that tag name for the current scope
2611 with a forward reference.
2612 If its type defines a new named structure or union
2613 or defines an enum, it is valid but we need not do anything here.
2614 Otherwise, it is an error. */
2616 void
2617 shadow_tag (declspecs)
2618 tree declspecs;
2620 shadow_tag_warned (declspecs, 0);
2623 void
2624 shadow_tag_warned (declspecs, warned)
2625 tree declspecs;
2626 int warned;
2627 /* 1 => we have done a pedwarn. 2 => we have done a warning, but
2628 no pedwarn. */
2630 int found_tag = 0;
2631 tree link;
2632 tree specs, attrs;
2634 pending_invalid_xref = 0;
2636 /* Remove the attributes from declspecs, since they will confuse the
2637 following code. */
2638 split_specs_attrs (declspecs, &specs, &attrs);
2640 for (link = specs; link; link = TREE_CHAIN (link))
2642 tree value = TREE_VALUE (link);
2643 enum tree_code code = TREE_CODE (value);
2645 if (code == RECORD_TYPE || code == UNION_TYPE || code == ENUMERAL_TYPE)
2646 /* Used to test also that TYPE_SIZE (value) != 0.
2647 That caused warning for `struct foo;' at top level in the file. */
2649 tree name = lookup_tag_reverse (value);
2650 tree t;
2652 found_tag++;
2654 if (name == 0)
2656 if (warned != 1 && code != ENUMERAL_TYPE)
2657 /* Empty unnamed enum OK */
2659 pedwarn ("unnamed struct/union that defines no instances");
2660 warned = 1;
2663 else
2665 t = lookup_tag (code, name, current_binding_level, 1);
2667 if (t == 0)
2669 t = make_node (code);
2670 pushtag (name, t);
2674 else
2676 if (!warned && ! in_system_header)
2678 warning ("useless keyword or type name in empty declaration");
2679 warned = 2;
2684 if (found_tag > 1)
2685 error ("two types specified in one empty declaration");
2687 if (warned != 1)
2689 if (found_tag == 0)
2690 pedwarn ("empty declaration");
2694 /* Construct an array declarator. EXPR is the expression inside [], or
2695 NULL_TREE. QUALS are the type qualifiers inside the [] (to be applied
2696 to the pointer to which a parameter array is converted). STATIC_P is
2697 nonzero if "static" is inside the [], zero otherwise. VLA_UNSPEC_P
2698 is nonzero is the array is [*], a VLA of unspecified length which is
2699 nevertheless a complete type (not currently implemented by GCC),
2700 zero otherwise. The declarator is constructed as an ARRAY_REF
2701 (to be decoded by grokdeclarator), whose operand 0 is what's on the
2702 left of the [] (filled by in set_array_declarator_type) and operand 1
2703 is the expression inside; whose TREE_TYPE is the type qualifiers and
2704 which has TREE_STATIC set if "static" is used. */
2706 tree
2707 build_array_declarator (expr, quals, static_p, vla_unspec_p)
2708 tree expr;
2709 tree quals;
2710 int static_p;
2711 int vla_unspec_p;
2713 tree decl;
2714 decl = build_nt (ARRAY_REF, NULL_TREE, expr);
2715 TREE_TYPE (decl) = quals;
2716 TREE_STATIC (decl) = (static_p ? 1 : 0);
2717 if (pedantic && !flag_isoc99)
2719 if (static_p || quals != NULL_TREE)
2720 pedwarn ("ISO C90 does not support `static' or type qualifiers in parameter array declarators");
2721 if (vla_unspec_p)
2722 pedwarn ("ISO C90 does not support `[*]' array declarators");
2724 if (vla_unspec_p)
2725 warning ("GCC does not yet properly implement `[*]' array declarators");
2726 return decl;
2729 /* Set the type of an array declarator. DECL is the declarator, as
2730 constructed by build_array_declarator; TYPE is what appears on the left
2731 of the [] and goes in operand 0. ABSTRACT_P is nonzero if it is an
2732 abstract declarator, zero otherwise; this is used to reject static and
2733 type qualifiers in abstract declarators, where they are not in the
2734 C99 grammar. */
2736 tree
2737 set_array_declarator_type (decl, type, abstract_p)
2738 tree decl;
2739 tree type;
2740 int abstract_p;
2742 TREE_OPERAND (decl, 0) = type;
2743 if (abstract_p && (TREE_TYPE (decl) != NULL_TREE || TREE_STATIC (decl)))
2744 error ("static or type qualifiers in abstract declarator");
2745 return decl;
2748 /* Decode a "typename", such as "int **", returning a ..._TYPE node. */
2750 tree
2751 groktypename (typename)
2752 tree typename;
2754 tree specs, attrs;
2756 if (TREE_CODE (typename) != TREE_LIST)
2757 return typename;
2759 split_specs_attrs (TREE_PURPOSE (typename), &specs, &attrs);
2761 typename = grokdeclarator (TREE_VALUE (typename), specs, TYPENAME, 0);
2763 /* Apply attributes. */
2764 decl_attributes (&typename, attrs, 0);
2766 return typename;
2769 /* Return a PARM_DECL node for a given pair of specs and declarator. */
2771 tree
2772 groktypename_in_parm_context (typename)
2773 tree typename;
2775 if (TREE_CODE (typename) != TREE_LIST)
2776 return typename;
2777 return grokdeclarator (TREE_VALUE (typename),
2778 TREE_PURPOSE (typename),
2779 PARM, 0);
2782 /* Decode a declarator in an ordinary declaration or data definition.
2783 This is called as soon as the type information and variable name
2784 have been parsed, before parsing the initializer if any.
2785 Here we create the ..._DECL node, fill in its type,
2786 and put it on the list of decls for the current context.
2787 The ..._DECL node is returned as the value.
2789 Exception: for arrays where the length is not specified,
2790 the type is left null, to be filled in by `finish_decl'.
2792 Function definitions do not come here; they go to start_function
2793 instead. However, external and forward declarations of functions
2794 do go through here. Structure field declarations are done by
2795 grokfield and not through here. */
2797 tree
2798 start_decl (declarator, declspecs, initialized, attributes)
2799 tree declarator, declspecs;
2800 int initialized;
2801 tree attributes;
2803 tree decl;
2804 tree tem;
2806 /* An object declared as __attribute__((deprecated)) suppresses
2807 warnings of uses of other deprecated items. */
2808 if (lookup_attribute ("deprecated", attributes))
2809 deprecated_state = DEPRECATED_SUPPRESS;
2811 decl = grokdeclarator (declarator, declspecs,
2812 NORMAL, initialized);
2814 deprecated_state = DEPRECATED_NORMAL;
2816 if (warn_main > 0 && TREE_CODE (decl) != FUNCTION_DECL
2817 && MAIN_NAME_P (DECL_NAME (decl)))
2818 warning_with_decl (decl, "`%s' is usually a function");
2820 if (initialized)
2821 /* Is it valid for this decl to have an initializer at all?
2822 If not, set INITIALIZED to zero, which will indirectly
2823 tell `finish_decl' to ignore the initializer once it is parsed. */
2824 switch (TREE_CODE (decl))
2826 case TYPE_DECL:
2827 error ("typedef `%s' is initialized (use __typeof__ instead)",
2828 IDENTIFIER_POINTER (DECL_NAME (decl)));
2829 initialized = 0;
2830 break;
2832 case FUNCTION_DECL:
2833 error ("function `%s' is initialized like a variable",
2834 IDENTIFIER_POINTER (DECL_NAME (decl)));
2835 initialized = 0;
2836 break;
2838 case PARM_DECL:
2839 /* DECL_INITIAL in a PARM_DECL is really DECL_ARG_TYPE. */
2840 error ("parameter `%s' is initialized",
2841 IDENTIFIER_POINTER (DECL_NAME (decl)));
2842 initialized = 0;
2843 break;
2845 default:
2846 /* Don't allow initializations for incomplete types
2847 except for arrays which might be completed by the initialization. */
2849 /* This can happen if the array size is an undefined macro. We already
2850 gave a warning, so we don't need another one. */
2851 if (TREE_TYPE (decl) == error_mark_node)
2852 initialized = 0;
2853 else if (COMPLETE_TYPE_P (TREE_TYPE (decl)))
2855 /* A complete type is ok if size is fixed. */
2857 if (TREE_CODE (TYPE_SIZE (TREE_TYPE (decl))) != INTEGER_CST
2858 || C_DECL_VARIABLE_SIZE (decl))
2860 error ("variable-sized object may not be initialized");
2861 initialized = 0;
2864 else if (TREE_CODE (TREE_TYPE (decl)) != ARRAY_TYPE)
2866 error ("variable `%s' has initializer but incomplete type",
2867 IDENTIFIER_POINTER (DECL_NAME (decl)));
2868 initialized = 0;
2870 else if (!COMPLETE_TYPE_P (TREE_TYPE (TREE_TYPE (decl))))
2872 error ("elements of array `%s' have incomplete type",
2873 IDENTIFIER_POINTER (DECL_NAME (decl)));
2874 initialized = 0;
2878 if (initialized)
2880 #if 0
2881 /* Seems redundant with grokdeclarator. */
2882 if (current_binding_level != global_binding_level
2883 && DECL_EXTERNAL (decl)
2884 && TREE_CODE (decl) != FUNCTION_DECL)
2885 warning ("declaration of `%s' has `extern' and is initialized",
2886 IDENTIFIER_POINTER (DECL_NAME (decl)));
2887 #endif
2888 DECL_EXTERNAL (decl) = 0;
2889 if (current_binding_level == global_binding_level)
2890 TREE_STATIC (decl) = 1;
2892 /* Tell `pushdecl' this is an initialized decl
2893 even though we don't yet have the initializer expression.
2894 Also tell `finish_decl' it may store the real initializer. */
2895 DECL_INITIAL (decl) = error_mark_node;
2898 /* If this is a function declaration, write a record describing it to the
2899 prototypes file (if requested). */
2901 if (TREE_CODE (decl) == FUNCTION_DECL)
2902 gen_aux_info_record (decl, 0, 0, TYPE_ARG_TYPES (TREE_TYPE (decl)) != 0);
2904 /* ANSI specifies that a tentative definition which is not merged with
2905 a non-tentative definition behaves exactly like a definition with an
2906 initializer equal to zero. (Section 3.7.2)
2908 -fno-common gives strict ANSI behavior, though this tends to break
2909 a large body of code that grew up without this rule.
2911 Thread-local variables are never common, since there's no entrenched
2912 body of code to break, and it allows more efficient variable references
2913 in the presense of dynamic linking. */
2915 if (TREE_CODE (decl) == VAR_DECL
2916 && !initialized
2917 && TREE_PUBLIC (decl)
2918 && !DECL_THREAD_LOCAL (decl)
2919 && !flag_no_common)
2920 DECL_COMMON (decl) = 1;
2922 /* Set attributes here so if duplicate decl, will have proper attributes. */
2923 decl_attributes (&decl, attributes, 0);
2925 /* If #pragma weak was used, mark the decl weak now. */
2926 if (current_binding_level == global_binding_level)
2927 maybe_apply_pragma_weak (decl);
2929 if (TREE_CODE (decl) == FUNCTION_DECL
2930 && DECL_DECLARED_INLINE_P (decl)
2931 && DECL_UNINLINABLE (decl)
2932 && lookup_attribute ("noinline", DECL_ATTRIBUTES (decl)))
2933 warning_with_decl (decl,
2934 "inline function `%s' given attribute noinline");
2936 /* Add this decl to the current binding level.
2937 TEM may equal DECL or it may be a previous decl of the same name. */
2938 tem = pushdecl (decl);
2940 /* For a local variable, define the RTL now. */
2941 if (current_binding_level != global_binding_level
2942 /* But not if this is a duplicate decl
2943 and we preserved the rtl from the previous one
2944 (which may or may not happen). */
2945 && !DECL_RTL_SET_P (tem)
2946 && !DECL_CONTEXT (tem))
2948 if (TREE_TYPE (tem) != error_mark_node
2949 && COMPLETE_TYPE_P (TREE_TYPE (tem)))
2950 expand_decl (tem);
2951 else if (TREE_CODE (TREE_TYPE (tem)) == ARRAY_TYPE
2952 && DECL_INITIAL (tem) != 0)
2953 expand_decl (tem);
2956 return tem;
2959 /* Finish processing of a declaration;
2960 install its initial value.
2961 If the length of an array type is not known before,
2962 it must be determined now, from the initial value, or it is an error. */
2964 void
2965 finish_decl (decl, init, asmspec_tree)
2966 tree decl, init;
2967 tree asmspec_tree;
2969 tree type = TREE_TYPE (decl);
2970 int was_incomplete = (DECL_SIZE (decl) == 0);
2971 const char *asmspec = 0;
2973 /* If a name was specified, get the string. */
2974 if (current_binding_level == global_binding_level)
2975 asmspec_tree = maybe_apply_renaming_pragma (decl, asmspec_tree);
2976 if (asmspec_tree)
2977 asmspec = TREE_STRING_POINTER (asmspec_tree);
2979 /* If `start_decl' didn't like having an initialization, ignore it now. */
2980 if (init != 0 && DECL_INITIAL (decl) == 0)
2981 init = 0;
2983 /* Don't crash if parm is initialized. */
2984 if (TREE_CODE (decl) == PARM_DECL)
2985 init = 0;
2987 if (init)
2988 store_init_value (decl, init);
2990 /* Deduce size of array from initialization, if not already known */
2991 if (TREE_CODE (type) == ARRAY_TYPE
2992 && TYPE_DOMAIN (type) == 0
2993 && TREE_CODE (decl) != TYPE_DECL)
2995 int do_default
2996 = (TREE_STATIC (decl)
2997 /* Even if pedantic, an external linkage array
2998 may have incomplete type at first. */
2999 ? pedantic && !TREE_PUBLIC (decl)
3000 : !DECL_EXTERNAL (decl));
3001 int failure
3002 = complete_array_type (type, DECL_INITIAL (decl), do_default);
3004 /* Get the completed type made by complete_array_type. */
3005 type = TREE_TYPE (decl);
3007 if (failure == 1)
3008 error_with_decl (decl, "initializer fails to determine size of `%s'");
3010 else if (failure == 2)
3012 if (do_default)
3013 error_with_decl (decl, "array size missing in `%s'");
3014 /* If a `static' var's size isn't known,
3015 make it extern as well as static, so it does not get
3016 allocated.
3017 If it is not `static', then do not mark extern;
3018 finish_incomplete_decl will give it a default size
3019 and it will get allocated. */
3020 else if (!pedantic && TREE_STATIC (decl) && ! TREE_PUBLIC (decl))
3021 DECL_EXTERNAL (decl) = 1;
3024 /* TYPE_MAX_VALUE is always one less than the number of elements
3025 in the array, because we start counting at zero. Therefore,
3026 warn only if the value is less than zero. */
3027 else if (pedantic && TYPE_DOMAIN (type) != 0
3028 && tree_int_cst_sgn (TYPE_MAX_VALUE (TYPE_DOMAIN (type))) < 0)
3029 error_with_decl (decl, "zero or negative size array `%s'");
3031 layout_decl (decl, 0);
3034 if (TREE_CODE (decl) == VAR_DECL)
3036 if (DECL_SIZE (decl) == 0 && TREE_TYPE (decl) != error_mark_node
3037 && COMPLETE_TYPE_P (TREE_TYPE (decl)))
3038 layout_decl (decl, 0);
3040 if (DECL_SIZE (decl) == 0
3041 /* Don't give an error if we already gave one earlier. */
3042 && TREE_TYPE (decl) != error_mark_node
3043 && (TREE_STATIC (decl)
3045 /* A static variable with an incomplete type
3046 is an error if it is initialized.
3047 Also if it is not file scope.
3048 Otherwise, let it through, but if it is not `extern'
3049 then it may cause an error message later. */
3050 (DECL_INITIAL (decl) != 0
3051 || DECL_CONTEXT (decl) != 0)
3053 /* An automatic variable with an incomplete type
3054 is an error. */
3055 !DECL_EXTERNAL (decl)))
3057 error_with_decl (decl, "storage size of `%s' isn't known");
3058 TREE_TYPE (decl) = error_mark_node;
3061 if ((DECL_EXTERNAL (decl) || TREE_STATIC (decl))
3062 && DECL_SIZE (decl) != 0)
3064 if (TREE_CODE (DECL_SIZE (decl)) == INTEGER_CST)
3065 constant_expression_warning (DECL_SIZE (decl));
3066 else
3067 error_with_decl (decl, "storage size of `%s' isn't constant");
3070 if (TREE_USED (type))
3071 TREE_USED (decl) = 1;
3074 /* If this is a function and an assembler name is specified, it isn't
3075 builtin any more. Also reset DECL_RTL so we can give it its new
3076 name. */
3077 if (TREE_CODE (decl) == FUNCTION_DECL && asmspec)
3079 DECL_BUILT_IN_CLASS (decl) = NOT_BUILT_IN;
3080 SET_DECL_RTL (decl, NULL_RTX);
3081 SET_DECL_ASSEMBLER_NAME (decl, get_identifier (asmspec));
3084 /* Output the assembler code and/or RTL code for variables and functions,
3085 unless the type is an undefined structure or union.
3086 If not, it will get done when the type is completed. */
3088 if (TREE_CODE (decl) == VAR_DECL || TREE_CODE (decl) == FUNCTION_DECL)
3090 /* This is a no-op in c-lang.c or something real in objc-act.c. */
3091 if (flag_objc)
3092 objc_check_decl (decl);
3094 if (!DECL_CONTEXT (decl))
3096 if (DECL_INITIAL (decl) == NULL_TREE
3097 || DECL_INITIAL (decl) == error_mark_node)
3098 /* Don't output anything
3099 when a tentative file-scope definition is seen.
3100 But at end of compilation, do output code for them. */
3101 DECL_DEFER_OUTPUT (decl) = 1;
3102 rest_of_decl_compilation (decl, asmspec,
3103 (DECL_CONTEXT (decl) == 0
3104 || TREE_ASM_WRITTEN (decl)), 0);
3106 else
3108 /* This is a local variable. If there is an ASMSPEC, the
3109 user has requested that we handle it specially. */
3110 if (asmspec)
3112 /* In conjunction with an ASMSPEC, the `register'
3113 keyword indicates that we should place the variable
3114 in a particular register. */
3115 if (DECL_REGISTER (decl))
3116 DECL_C_HARD_REGISTER (decl) = 1;
3118 /* If this is not a static variable, issue a warning.
3119 It doesn't make any sense to give an ASMSPEC for an
3120 ordinary, non-register local variable. Historically,
3121 GCC has accepted -- but ignored -- the ASMSPEC in
3122 this case. */
3123 if (TREE_CODE (decl) == VAR_DECL
3124 && !DECL_REGISTER (decl)
3125 && !TREE_STATIC (decl))
3126 warning_with_decl (decl,
3127 "ignoring asm-specifier for non-static local variable `%s'");
3128 else
3129 SET_DECL_ASSEMBLER_NAME (decl, get_identifier (asmspec));
3132 if (TREE_CODE (decl) != FUNCTION_DECL)
3133 add_decl_stmt (decl);
3136 if (DECL_CONTEXT (decl) != 0)
3138 /* Recompute the RTL of a local array now
3139 if it used to be an incomplete type. */
3140 if (was_incomplete
3141 && ! TREE_STATIC (decl) && ! DECL_EXTERNAL (decl))
3143 /* If we used it already as memory, it must stay in memory. */
3144 TREE_ADDRESSABLE (decl) = TREE_USED (decl);
3145 /* If it's still incomplete now, no init will save it. */
3146 if (DECL_SIZE (decl) == 0)
3147 DECL_INITIAL (decl) = 0;
3152 if (TREE_CODE (decl) == TYPE_DECL)
3154 /* This is a no-op in c-lang.c or something real in objc-act.c. */
3155 if (flag_objc)
3156 objc_check_decl (decl);
3157 rest_of_decl_compilation (decl, NULL, DECL_CONTEXT (decl) == 0, 0);
3160 /* At the end of a declaration, throw away any variable type sizes
3161 of types defined inside that declaration. There is no use
3162 computing them in the following function definition. */
3163 if (current_binding_level == global_binding_level)
3164 get_pending_sizes ();
3167 /* Given a parsed parameter declaration,
3168 decode it into a PARM_DECL and push that on the current binding level.
3169 Also, for the sake of forward parm decls,
3170 record the given order of parms in `parm_order'. */
3172 void
3173 push_parm_decl (parm)
3174 tree parm;
3176 tree decl;
3177 int old_immediate_size_expand = immediate_size_expand;
3178 /* Don't try computing parm sizes now -- wait till fn is called. */
3179 immediate_size_expand = 0;
3181 decl = grokdeclarator (TREE_VALUE (TREE_PURPOSE (parm)),
3182 TREE_PURPOSE (TREE_PURPOSE (parm)), PARM, 0);
3183 decl_attributes (&decl, TREE_VALUE (parm), 0);
3185 #if 0
3186 if (DECL_NAME (decl))
3188 tree olddecl;
3189 olddecl = lookup_name (DECL_NAME (decl));
3190 if (pedantic && olddecl != 0 && TREE_CODE (olddecl) == TYPE_DECL)
3191 pedwarn_with_decl (decl,
3192 "ISO C forbids parameter `%s' shadowing typedef");
3194 #endif
3196 decl = pushdecl (decl);
3198 immediate_size_expand = old_immediate_size_expand;
3200 current_binding_level->parm_order
3201 = tree_cons (NULL_TREE, decl, current_binding_level->parm_order);
3203 /* Add this decl to the current binding level. */
3204 finish_decl (decl, NULL_TREE, NULL_TREE);
3207 /* Clear the given order of parms in `parm_order'.
3208 Used at start of parm list,
3209 and also at semicolon terminating forward decls. */
3211 void
3212 clear_parm_order ()
3214 current_binding_level->parm_order = NULL_TREE;
3217 /* Build a COMPOUND_LITERAL_EXPR. TYPE is the type given in the compound
3218 literal, which may be an incomplete array type completed by the
3219 initializer; INIT is a CONSTRUCTOR that initializes the compound
3220 literal. */
3222 tree
3223 build_compound_literal (type, init)
3224 tree type;
3225 tree init;
3227 /* We do not use start_decl here because we have a type, not a declarator;
3228 and do not use finish_decl because the decl should be stored inside
3229 the COMPOUND_LITERAL_EXPR rather than added elsewhere as a DECL_STMT. */
3230 tree decl = build_decl (VAR_DECL, NULL_TREE, type);
3231 tree complit;
3232 tree stmt;
3233 DECL_EXTERNAL (decl) = 0;
3234 TREE_PUBLIC (decl) = 0;
3235 TREE_STATIC (decl) = (current_binding_level == global_binding_level);
3236 DECL_CONTEXT (decl) = current_function_decl;
3237 TREE_USED (decl) = 1;
3238 TREE_TYPE (decl) = type;
3239 TREE_READONLY (decl) = TREE_READONLY (type);
3240 store_init_value (decl, init);
3242 if (TREE_CODE (type) == ARRAY_TYPE && !COMPLETE_TYPE_P (type))
3244 int failure = complete_array_type (type, DECL_INITIAL (decl), 1);
3245 if (failure)
3246 abort ();
3249 type = TREE_TYPE (decl);
3250 if (type == error_mark_node || !COMPLETE_TYPE_P (type))
3251 return error_mark_node;
3253 stmt = build_stmt (DECL_STMT, decl);
3254 complit = build1 (COMPOUND_LITERAL_EXPR, TREE_TYPE (decl), stmt);
3255 TREE_SIDE_EFFECTS (complit) = 1;
3257 layout_decl (decl, 0);
3259 if (TREE_STATIC (decl))
3261 /* This decl needs a name for the assembler output. We also need
3262 a unique suffix to be added to the name. */
3263 char *name;
3264 extern int var_labelno;
3266 ASM_FORMAT_PRIVATE_NAME (name, "__compound_literal", var_labelno);
3267 var_labelno++;
3268 DECL_NAME (decl) = get_identifier (name);
3269 DECL_DEFER_OUTPUT (decl) = 1;
3270 DECL_COMDAT (decl) = 1;
3271 DECL_ARTIFICIAL (decl) = 1;
3272 pushdecl (decl);
3273 rest_of_decl_compilation (decl, NULL, 1, 0);
3276 return complit;
3279 /* Make TYPE a complete type based on INITIAL_VALUE.
3280 Return 0 if successful, 1 if INITIAL_VALUE can't be deciphered,
3281 2 if there was no information (in which case assume 1 if DO_DEFAULT). */
3284 complete_array_type (type, initial_value, do_default)
3285 tree type;
3286 tree initial_value;
3287 int do_default;
3289 tree maxindex = NULL_TREE;
3290 int value = 0;
3292 if (initial_value)
3294 /* Note MAXINDEX is really the maximum index,
3295 one less than the size. */
3296 if (TREE_CODE (initial_value) == STRING_CST)
3298 int eltsize
3299 = int_size_in_bytes (TREE_TYPE (TREE_TYPE (initial_value)));
3300 maxindex = build_int_2 ((TREE_STRING_LENGTH (initial_value)
3301 / eltsize) - 1, 0);
3303 else if (TREE_CODE (initial_value) == CONSTRUCTOR)
3305 tree elts = CONSTRUCTOR_ELTS (initial_value);
3306 maxindex = build_int_2 (-1, -1);
3307 for (; elts; elts = TREE_CHAIN (elts))
3309 if (TREE_PURPOSE (elts))
3310 maxindex = TREE_PURPOSE (elts);
3311 else
3312 maxindex = fold (build (PLUS_EXPR, integer_type_node,
3313 maxindex, integer_one_node));
3315 maxindex = copy_node (maxindex);
3317 else
3319 /* Make an error message unless that happened already. */
3320 if (initial_value != error_mark_node)
3321 value = 1;
3323 /* Prevent further error messages. */
3324 maxindex = build_int_2 (0, 0);
3328 if (!maxindex)
3330 if (do_default)
3331 maxindex = build_int_2 (0, 0);
3332 value = 2;
3335 if (maxindex)
3337 TYPE_DOMAIN (type) = build_index_type (maxindex);
3338 if (!TREE_TYPE (maxindex))
3339 TREE_TYPE (maxindex) = TYPE_DOMAIN (type);
3342 /* Lay out the type now that we can get the real answer. */
3344 layout_type (type);
3346 return value;
3349 /* Determine whether TYPE is a structure with a flexible array member,
3350 or a union containing such a structure (possibly recursively). */
3352 static bool
3353 flexible_array_type_p (type)
3354 tree type;
3356 tree x;
3357 switch (TREE_CODE (type))
3359 case RECORD_TYPE:
3360 x = TYPE_FIELDS (type);
3361 if (x == NULL_TREE)
3362 return false;
3363 while (TREE_CHAIN (x) != NULL_TREE)
3364 x = TREE_CHAIN (x);
3365 if (TREE_CODE (TREE_TYPE (x)) == ARRAY_TYPE
3366 && TYPE_SIZE (TREE_TYPE (x)) == NULL_TREE
3367 && TYPE_DOMAIN (TREE_TYPE (x)) != NULL_TREE
3368 && TYPE_MAX_VALUE (TYPE_DOMAIN (TREE_TYPE (x))) == NULL_TREE)
3369 return true;
3370 return false;
3371 case UNION_TYPE:
3372 for (x = TYPE_FIELDS (type); x != NULL_TREE; x = TREE_CHAIN (x))
3374 if (flexible_array_type_p (TREE_TYPE (x)))
3375 return true;
3377 return false;
3378 default:
3379 return false;
3383 /* Given declspecs and a declarator,
3384 determine the name and type of the object declared
3385 and construct a ..._DECL node for it.
3386 (In one case we can return a ..._TYPE node instead.
3387 For invalid input we sometimes return 0.)
3389 DECLSPECS is a chain of tree_list nodes whose value fields
3390 are the storage classes and type specifiers.
3392 DECL_CONTEXT says which syntactic context this declaration is in:
3393 NORMAL for most contexts. Make a VAR_DECL or FUNCTION_DECL or TYPE_DECL.
3394 FUNCDEF for a function definition. Like NORMAL but a few different
3395 error messages in each case. Return value may be zero meaning
3396 this definition is too screwy to try to parse.
3397 PARM for a parameter declaration (either within a function prototype
3398 or before a function body). Make a PARM_DECL, or return void_type_node.
3399 TYPENAME if for a typename (in a cast or sizeof).
3400 Don't make a DECL node; just return the ..._TYPE node.
3401 FIELD for a struct or union field; make a FIELD_DECL.
3402 BITFIELD for a field with specified width.
3403 INITIALIZED is 1 if the decl has an initializer.
3405 In the TYPENAME case, DECLARATOR is really an absolute declarator.
3406 It may also be so in the PARM case, for a prototype where the
3407 argument type is specified but not the name.
3409 This function is where the complicated C meanings of `static'
3410 and `extern' are interpreted. */
3412 static tree
3413 grokdeclarator (declarator, declspecs, decl_context, initialized)
3414 tree declspecs;
3415 tree declarator;
3416 enum decl_context decl_context;
3417 int initialized;
3419 int specbits = 0;
3420 tree spec;
3421 tree type = NULL_TREE;
3422 int longlong = 0;
3423 int constp;
3424 int restrictp;
3425 int volatilep;
3426 int type_quals = TYPE_UNQUALIFIED;
3427 int inlinep;
3428 int explicit_int = 0;
3429 int explicit_char = 0;
3430 int defaulted_int = 0;
3431 tree typedef_decl = 0;
3432 const char *name;
3433 tree typedef_type = 0;
3434 int funcdef_flag = 0;
3435 enum tree_code innermost_code = ERROR_MARK;
3436 int bitfield = 0;
3437 int size_varies = 0;
3438 tree decl_attr = NULL_TREE;
3439 tree array_ptr_quals = NULL_TREE;
3440 int array_parm_static = 0;
3441 tree returned_attrs = NULL_TREE;
3443 if (decl_context == BITFIELD)
3444 bitfield = 1, decl_context = FIELD;
3446 if (decl_context == FUNCDEF)
3447 funcdef_flag = 1, decl_context = NORMAL;
3449 /* Look inside a declarator for the name being declared
3450 and get it as a string, for an error message. */
3452 tree decl = declarator;
3453 name = 0;
3455 while (decl)
3456 switch (TREE_CODE (decl))
3458 case ARRAY_REF:
3459 case INDIRECT_REF:
3460 case CALL_EXPR:
3461 innermost_code = TREE_CODE (decl);
3462 decl = TREE_OPERAND (decl, 0);
3463 break;
3465 case TREE_LIST:
3466 decl = TREE_VALUE (decl);
3467 break;
3469 case IDENTIFIER_NODE:
3470 name = IDENTIFIER_POINTER (decl);
3471 decl = 0;
3472 break;
3474 default:
3475 abort ();
3477 if (name == 0)
3478 name = "type name";
3481 /* A function definition's declarator must have the form of
3482 a function declarator. */
3484 if (funcdef_flag && innermost_code != CALL_EXPR)
3485 return 0;
3487 /* Anything declared one level down from the top level
3488 must be one of the parameters of a function
3489 (because the body is at least two levels down). */
3491 /* If this looks like a function definition, make it one,
3492 even if it occurs where parms are expected.
3493 Then store_parm_decls will reject it and not use it as a parm. */
3494 if (decl_context == NORMAL && !funcdef_flag
3495 && current_binding_level->parm_flag)
3496 decl_context = PARM;
3498 /* Look through the decl specs and record which ones appear.
3499 Some typespecs are defined as built-in typenames.
3500 Others, the ones that are modifiers of other types,
3501 are represented by bits in SPECBITS: set the bits for
3502 the modifiers that appear. Storage class keywords are also in SPECBITS.
3504 If there is a typedef name or a type, store the type in TYPE.
3505 This includes builtin typedefs such as `int'.
3507 Set EXPLICIT_INT or EXPLICIT_CHAR if the type is `int' or `char'
3508 and did not come from a user typedef.
3510 Set LONGLONG if `long' is mentioned twice. */
3512 for (spec = declspecs; spec; spec = TREE_CHAIN (spec))
3514 tree id = TREE_VALUE (spec);
3516 /* If the entire declaration is itself tagged as deprecated then
3517 suppress reports of deprecated items. */
3518 if (id && TREE_DEPRECATED (id))
3520 if (deprecated_state != DEPRECATED_SUPPRESS)
3521 warn_deprecated_use (id);
3524 if (id == ridpointers[(int) RID_INT])
3525 explicit_int = 1;
3526 if (id == ridpointers[(int) RID_CHAR])
3527 explicit_char = 1;
3529 if (TREE_CODE (id) == IDENTIFIER_NODE && C_IS_RESERVED_WORD (id))
3531 enum rid i = C_RID_CODE (id);
3532 if ((int) i <= (int) RID_LAST_MODIFIER)
3534 if (i == RID_LONG && (specbits & (1 << (int) RID_LONG)))
3536 if (longlong)
3537 error ("`long long long' is too long for GCC");
3538 else
3540 if (pedantic && !flag_isoc99 && ! in_system_header
3541 && warn_long_long)
3542 pedwarn ("ISO C90 does not support `long long'");
3543 longlong = 1;
3546 else if (specbits & (1 << (int) i))
3548 if (i == RID_CONST || i == RID_VOLATILE || i == RID_RESTRICT)
3550 if (!flag_isoc99)
3551 pedwarn ("duplicate `%s'", IDENTIFIER_POINTER (id));
3553 else
3554 error ("duplicate `%s'", IDENTIFIER_POINTER (id));
3557 /* Diagnose "__thread extern". Recall that this list
3558 is in the reverse order seen in the text. */
3559 if (i == RID_THREAD
3560 && (specbits & (1 << (int) RID_EXTERN
3561 | 1 << (int) RID_STATIC)))
3563 if (specbits & 1 << (int) RID_EXTERN)
3564 error ("`__thread' before `extern'");
3565 else
3566 error ("`__thread' before `static'");
3569 specbits |= 1 << (int) i;
3570 goto found;
3573 if (type)
3574 error ("two or more data types in declaration of `%s'", name);
3575 /* Actual typedefs come to us as TYPE_DECL nodes. */
3576 else if (TREE_CODE (id) == TYPE_DECL)
3578 if (TREE_TYPE (id) == error_mark_node)
3579 ; /* Allow the type to default to int to avoid cascading errors. */
3580 else
3582 type = TREE_TYPE (id);
3583 decl_attr = DECL_ATTRIBUTES (id);
3584 typedef_decl = id;
3587 /* Built-in types come as identifiers. */
3588 else if (TREE_CODE (id) == IDENTIFIER_NODE)
3590 tree t = lookup_name (id);
3591 if (TREE_TYPE (t) == error_mark_node)
3593 else if (!t || TREE_CODE (t) != TYPE_DECL)
3594 error ("`%s' fails to be a typedef or built in type",
3595 IDENTIFIER_POINTER (id));
3596 else
3598 type = TREE_TYPE (t);
3599 typedef_decl = t;
3602 else if (TREE_CODE (id) != ERROR_MARK)
3603 type = id;
3605 found:
3609 typedef_type = type;
3610 if (type)
3611 size_varies = C_TYPE_VARIABLE_SIZE (type);
3613 /* No type at all: default to `int', and set DEFAULTED_INT
3614 because it was not a user-defined typedef. */
3616 if (type == 0)
3618 if ((! (specbits & ((1 << (int) RID_LONG) | (1 << (int) RID_SHORT)
3619 | (1 << (int) RID_SIGNED)
3620 | (1 << (int) RID_UNSIGNED)
3621 | (1 << (int) RID_COMPLEX))))
3622 /* Don't warn about typedef foo = bar. */
3623 && ! (specbits & (1 << (int) RID_TYPEDEF) && initialized)
3624 && ! in_system_header)
3626 /* Issue a warning if this is an ISO C 99 program or if -Wreturn-type
3627 and this is a function, or if -Wimplicit; prefer the former
3628 warning since it is more explicit. */
3629 if ((warn_implicit_int || warn_return_type || flag_isoc99)
3630 && funcdef_flag)
3631 warn_about_return_type = 1;
3632 else if (warn_implicit_int || flag_isoc99)
3633 pedwarn_c99 ("type defaults to `int' in declaration of `%s'",
3634 name);
3637 defaulted_int = 1;
3638 type = integer_type_node;
3641 /* Now process the modifiers that were specified
3642 and check for invalid combinations. */
3644 /* Long double is a special combination. */
3646 if ((specbits & 1 << (int) RID_LONG) && ! longlong
3647 && TYPE_MAIN_VARIANT (type) == double_type_node)
3649 specbits &= ~(1 << (int) RID_LONG);
3650 type = long_double_type_node;
3653 /* Check all other uses of type modifiers. */
3655 if (specbits & ((1 << (int) RID_LONG) | (1 << (int) RID_SHORT)
3656 | (1 << (int) RID_UNSIGNED) | (1 << (int) RID_SIGNED)))
3658 int ok = 0;
3660 if ((specbits & 1 << (int) RID_LONG)
3661 && (specbits & 1 << (int) RID_SHORT))
3662 error ("both long and short specified for `%s'", name);
3663 else if (((specbits & 1 << (int) RID_LONG)
3664 || (specbits & 1 << (int) RID_SHORT))
3665 && explicit_char)
3666 error ("long or short specified with char for `%s'", name);
3667 else if (((specbits & 1 << (int) RID_LONG)
3668 || (specbits & 1 << (int) RID_SHORT))
3669 && TREE_CODE (type) == REAL_TYPE)
3671 static int already = 0;
3673 error ("long or short specified with floating type for `%s'", name);
3674 if (! already && ! pedantic)
3676 error ("the only valid combination is `long double'");
3677 already = 1;
3680 else if ((specbits & 1 << (int) RID_SIGNED)
3681 && (specbits & 1 << (int) RID_UNSIGNED))
3682 error ("both signed and unsigned specified for `%s'", name);
3683 else if (TREE_CODE (type) != INTEGER_TYPE)
3684 error ("long, short, signed or unsigned invalid for `%s'", name);
3685 else
3687 ok = 1;
3688 if (!explicit_int && !defaulted_int && !explicit_char)
3690 error ("long, short, signed or unsigned used invalidly for `%s'",
3691 name);
3692 ok = 0;
3696 /* Discard the type modifiers if they are invalid. */
3697 if (! ok)
3699 specbits &= ~((1 << (int) RID_LONG) | (1 << (int) RID_SHORT)
3700 | (1 << (int) RID_UNSIGNED) | (1 << (int) RID_SIGNED));
3701 longlong = 0;
3705 if ((specbits & (1 << (int) RID_COMPLEX))
3706 && TREE_CODE (type) != INTEGER_TYPE && TREE_CODE (type) != REAL_TYPE)
3708 error ("complex invalid for `%s'", name);
3709 specbits &= ~(1 << (int) RID_COMPLEX);
3712 /* Decide whether an integer type is signed or not.
3713 Optionally treat bitfields as signed by default. */
3714 if (specbits & 1 << (int) RID_UNSIGNED
3715 || (bitfield && ! flag_signed_bitfields
3716 && (explicit_int || defaulted_int || explicit_char
3717 /* A typedef for plain `int' without `signed'
3718 can be controlled just like plain `int'. */
3719 || ! (typedef_decl != 0
3720 && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl)))
3721 && TREE_CODE (type) != ENUMERAL_TYPE
3722 && !(specbits & 1 << (int) RID_SIGNED)))
3724 if (longlong)
3725 type = long_long_unsigned_type_node;
3726 else if (specbits & 1 << (int) RID_LONG)
3727 type = long_unsigned_type_node;
3728 else if (specbits & 1 << (int) RID_SHORT)
3729 type = short_unsigned_type_node;
3730 else if (type == char_type_node)
3731 type = unsigned_char_type_node;
3732 else if (typedef_decl)
3733 type = c_common_unsigned_type (type);
3734 else
3735 type = unsigned_type_node;
3737 else if ((specbits & 1 << (int) RID_SIGNED)
3738 && type == char_type_node)
3739 type = signed_char_type_node;
3740 else if (longlong)
3741 type = long_long_integer_type_node;
3742 else if (specbits & 1 << (int) RID_LONG)
3743 type = long_integer_type_node;
3744 else if (specbits & 1 << (int) RID_SHORT)
3745 type = short_integer_type_node;
3747 if (specbits & 1 << (int) RID_COMPLEX)
3749 if (pedantic && !flag_isoc99)
3750 pedwarn ("ISO C90 does not support complex types");
3751 /* If we just have "complex", it is equivalent to
3752 "complex double", but if any modifiers at all are specified it is
3753 the complex form of TYPE. E.g, "complex short" is
3754 "complex short int". */
3756 if (defaulted_int && ! longlong
3757 && ! (specbits & ((1 << (int) RID_LONG) | (1 << (int) RID_SHORT)
3758 | (1 << (int) RID_SIGNED)
3759 | (1 << (int) RID_UNSIGNED))))
3761 if (pedantic)
3762 pedwarn ("ISO C does not support plain `complex' meaning `double complex'");
3763 type = complex_double_type_node;
3765 else if (type == integer_type_node)
3767 if (pedantic)
3768 pedwarn ("ISO C does not support complex integer types");
3769 type = complex_integer_type_node;
3771 else if (type == float_type_node)
3772 type = complex_float_type_node;
3773 else if (type == double_type_node)
3774 type = complex_double_type_node;
3775 else if (type == long_double_type_node)
3776 type = complex_long_double_type_node;
3777 else
3779 if (pedantic)
3780 pedwarn ("ISO C does not support complex integer types");
3781 type = build_complex_type (type);
3785 /* Figure out the type qualifiers for the declaration. There are
3786 two ways a declaration can become qualified. One is something
3787 like `const int i' where the `const' is explicit. Another is
3788 something like `typedef const int CI; CI i' where the type of the
3789 declaration contains the `const'. */
3790 constp = !! (specbits & 1 << (int) RID_CONST) + TYPE_READONLY (type);
3791 restrictp = !! (specbits & 1 << (int) RID_RESTRICT) + TYPE_RESTRICT (type);
3792 volatilep = !! (specbits & 1 << (int) RID_VOLATILE) + TYPE_VOLATILE (type);
3793 inlinep = !! (specbits & (1 << (int) RID_INLINE));
3794 if (constp > 1 && ! flag_isoc99)
3795 pedwarn ("duplicate `const'");
3796 if (restrictp > 1 && ! flag_isoc99)
3797 pedwarn ("duplicate `restrict'");
3798 if (volatilep > 1 && ! flag_isoc99)
3799 pedwarn ("duplicate `volatile'");
3800 if (! flag_gen_aux_info && (TYPE_QUALS (type)))
3801 type = TYPE_MAIN_VARIANT (type);
3802 type_quals = ((constp ? TYPE_QUAL_CONST : 0)
3803 | (restrictp ? TYPE_QUAL_RESTRICT : 0)
3804 | (volatilep ? TYPE_QUAL_VOLATILE : 0));
3806 /* Warn if two storage classes are given. Default to `auto'. */
3809 int nclasses = 0;
3811 if (specbits & 1 << (int) RID_AUTO) nclasses++;
3812 if (specbits & 1 << (int) RID_STATIC) nclasses++;
3813 if (specbits & 1 << (int) RID_EXTERN) nclasses++;
3814 if (specbits & 1 << (int) RID_REGISTER) nclasses++;
3815 if (specbits & 1 << (int) RID_TYPEDEF) nclasses++;
3817 /* "static __thread" and "extern __thread" are allowed. */
3818 if ((specbits & (1 << (int) RID_THREAD
3819 | 1 << (int) RID_STATIC
3820 | 1 << (int) RID_EXTERN)) == (1 << (int) RID_THREAD))
3821 nclasses++;
3823 /* Warn about storage classes that are invalid for certain
3824 kinds of declarations (parameters, typenames, etc.). */
3826 if (nclasses > 1)
3827 error ("multiple storage classes in declaration of `%s'", name);
3828 else if (funcdef_flag
3829 && (specbits
3830 & ((1 << (int) RID_REGISTER)
3831 | (1 << (int) RID_AUTO)
3832 | (1 << (int) RID_TYPEDEF)
3833 | (1 << (int) RID_THREAD))))
3835 if (specbits & 1 << (int) RID_AUTO
3836 && (pedantic || current_binding_level == global_binding_level))
3837 pedwarn ("function definition declared `auto'");
3838 if (specbits & 1 << (int) RID_REGISTER)
3839 error ("function definition declared `register'");
3840 if (specbits & 1 << (int) RID_TYPEDEF)
3841 error ("function definition declared `typedef'");
3842 if (specbits & 1 << (int) RID_THREAD)
3843 error ("function definition declared `__thread'");
3844 specbits &= ~((1 << (int) RID_TYPEDEF) | (1 << (int) RID_REGISTER)
3845 | (1 << (int) RID_AUTO) | (1 << (int) RID_THREAD));
3847 else if (decl_context != NORMAL && nclasses > 0)
3849 if (decl_context == PARM && specbits & 1 << (int) RID_REGISTER)
3851 else
3853 switch (decl_context)
3855 case FIELD:
3856 error ("storage class specified for structure field `%s'",
3857 name);
3858 break;
3859 case PARM:
3860 error ("storage class specified for parameter `%s'", name);
3861 break;
3862 default:
3863 error ("storage class specified for typename");
3864 break;
3866 specbits &= ~((1 << (int) RID_TYPEDEF) | (1 << (int) RID_REGISTER)
3867 | (1 << (int) RID_AUTO) | (1 << (int) RID_STATIC)
3868 | (1 << (int) RID_EXTERN) | (1 << (int) RID_THREAD));
3871 else if (specbits & 1 << (int) RID_EXTERN && initialized && ! funcdef_flag)
3873 /* `extern' with initialization is invalid if not at top level. */
3874 if (current_binding_level == global_binding_level)
3875 warning ("`%s' initialized and declared `extern'", name);
3876 else
3877 error ("`%s' has both `extern' and initializer", name);
3879 else if (current_binding_level == global_binding_level)
3881 if (specbits & 1 << (int) RID_AUTO)
3882 error ("top-level declaration of `%s' specifies `auto'", name);
3884 else
3886 if (specbits & 1 << (int) RID_EXTERN && funcdef_flag)
3887 error ("nested function `%s' declared `extern'", name);
3888 else if ((specbits & (1 << (int) RID_THREAD
3889 | 1 << (int) RID_EXTERN
3890 | 1 << (int) RID_STATIC))
3891 == (1 << (int) RID_THREAD))
3893 error ("function-scope `%s' implicitly auto and declared `__thread'",
3894 name);
3895 specbits &= ~(1 << (int) RID_THREAD);
3900 /* Now figure out the structure of the declarator proper.
3901 Descend through it, creating more complex types, until we reach
3902 the declared identifier (or NULL_TREE, in an absolute declarator). */
3904 while (declarator && TREE_CODE (declarator) != IDENTIFIER_NODE)
3906 if (type == error_mark_node)
3908 declarator = TREE_OPERAND (declarator, 0);
3909 continue;
3912 /* Each level of DECLARATOR is either an ARRAY_REF (for ...[..]),
3913 an INDIRECT_REF (for *...),
3914 a CALL_EXPR (for ...(...)),
3915 a TREE_LIST (for nested attributes),
3916 an identifier (for the name being declared)
3917 or a null pointer (for the place in an absolute declarator
3918 where the name was omitted).
3919 For the last two cases, we have just exited the loop.
3921 At this point, TYPE is the type of elements of an array,
3922 or for a function to return, or for a pointer to point to.
3923 After this sequence of ifs, TYPE is the type of the
3924 array or function or pointer, and DECLARATOR has had its
3925 outermost layer removed. */
3927 if (array_ptr_quals != NULL_TREE || array_parm_static)
3929 /* Only the innermost declarator (making a parameter be of
3930 array type which is converted to pointer type)
3931 may have static or type qualifiers. */
3932 error ("static or type qualifiers in non-parameter array declarator");
3933 array_ptr_quals = NULL_TREE;
3934 array_parm_static = 0;
3937 if (TREE_CODE (declarator) == TREE_LIST)
3939 /* We encode a declarator with embedded attributes using
3940 a TREE_LIST. */
3941 tree attrs = TREE_PURPOSE (declarator);
3942 tree inner_decl;
3943 int attr_flags = 0;
3944 declarator = TREE_VALUE (declarator);
3945 inner_decl = declarator;
3946 while (inner_decl != NULL_TREE
3947 && TREE_CODE (inner_decl) == TREE_LIST)
3948 inner_decl = TREE_VALUE (inner_decl);
3949 if (inner_decl == NULL_TREE
3950 || TREE_CODE (inner_decl) == IDENTIFIER_NODE)
3951 attr_flags |= (int) ATTR_FLAG_DECL_NEXT;
3952 else if (TREE_CODE (inner_decl) == CALL_EXPR)
3953 attr_flags |= (int) ATTR_FLAG_FUNCTION_NEXT;
3954 else if (TREE_CODE (inner_decl) == ARRAY_REF)
3955 attr_flags |= (int) ATTR_FLAG_ARRAY_NEXT;
3956 returned_attrs = decl_attributes (&type,
3957 chainon (returned_attrs, attrs),
3958 attr_flags);
3960 else if (TREE_CODE (declarator) == ARRAY_REF)
3962 tree itype = NULL_TREE;
3963 tree size = TREE_OPERAND (declarator, 1);
3964 /* The index is a signed object `sizetype' bits wide. */
3965 tree index_type = c_common_signed_type (sizetype);
3967 array_ptr_quals = TREE_TYPE (declarator);
3968 array_parm_static = TREE_STATIC (declarator);
3970 declarator = TREE_OPERAND (declarator, 0);
3972 /* Check for some types that there cannot be arrays of. */
3974 if (VOID_TYPE_P (type))
3976 error ("declaration of `%s' as array of voids", name);
3977 type = error_mark_node;
3980 if (TREE_CODE (type) == FUNCTION_TYPE)
3982 error ("declaration of `%s' as array of functions", name);
3983 type = error_mark_node;
3986 if (pedantic && flexible_array_type_p (type))
3987 pedwarn ("invalid use of structure with flexible array member");
3989 if (size == error_mark_node)
3990 type = error_mark_node;
3992 if (type == error_mark_node)
3993 continue;
3995 /* If size was specified, set ITYPE to a range-type for that size.
3996 Otherwise, ITYPE remains null. finish_decl may figure it out
3997 from an initial value. */
3999 if (size)
4001 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue. */
4002 STRIP_TYPE_NOPS (size);
4004 if (! INTEGRAL_TYPE_P (TREE_TYPE (size)))
4006 error ("size of array `%s' has non-integer type", name);
4007 size = integer_one_node;
4010 if (pedantic && integer_zerop (size))
4011 pedwarn ("ISO C forbids zero-size array `%s'", name);
4013 if (TREE_CODE (size) == INTEGER_CST)
4015 constant_expression_warning (size);
4016 if (tree_int_cst_sgn (size) < 0)
4018 error ("size of array `%s' is negative", name);
4019 size = integer_one_node;
4022 else
4024 /* Make sure the array size remains visibly nonconstant
4025 even if it is (eg) a const variable with known value. */
4026 size_varies = 1;
4028 if (!flag_isoc99 && pedantic)
4030 if (TREE_CONSTANT (size))
4031 pedwarn ("ISO C90 forbids array `%s' whose size can't be evaluated",
4032 name);
4033 else
4034 pedwarn ("ISO C90 forbids variable-size array `%s'",
4035 name);
4039 if (integer_zerop (size))
4041 /* A zero-length array cannot be represented with an
4042 unsigned index type, which is what we'll get with
4043 build_index_type. Create an open-ended range instead. */
4044 itype = build_range_type (sizetype, size, NULL_TREE);
4046 else
4048 /* Compute the maximum valid index, that is, size - 1.
4049 Do the calculation in index_type, so that if it is
4050 a variable the computations will be done in the
4051 proper mode. */
4052 itype = fold (build (MINUS_EXPR, index_type,
4053 convert (index_type, size),
4054 convert (index_type, size_one_node)));
4056 /* If that overflowed, the array is too big.
4057 ??? While a size of INT_MAX+1 technically shouldn't
4058 cause an overflow (because we subtract 1), the overflow
4059 is recorded during the conversion to index_type, before
4060 the subtraction. Handling this case seems like an
4061 unnecessary complication. */
4062 if (TREE_OVERFLOW (itype))
4064 error ("size of array `%s' is too large", name);
4065 type = error_mark_node;
4066 continue;
4069 if (size_varies)
4070 itype = variable_size (itype);
4071 itype = build_index_type (itype);
4074 else if (decl_context == FIELD)
4076 if (pedantic && !flag_isoc99 && !in_system_header)
4077 pedwarn ("ISO C90 does not support flexible array members");
4079 /* ISO C99 Flexible array members are effectively identical
4080 to GCC's zero-length array extension. */
4081 itype = build_range_type (sizetype, size_zero_node, NULL_TREE);
4084 /* If pedantic, complain about arrays of incomplete types. */
4086 if (pedantic && !COMPLETE_TYPE_P (type))
4087 pedwarn ("array type has incomplete element type");
4089 #if 0
4090 /* We shouldn't have a function type here at all!
4091 Functions aren't allowed as array elements. */
4092 if (pedantic && TREE_CODE (type) == FUNCTION_TYPE
4093 && (constp || volatilep))
4094 pedwarn ("ISO C forbids const or volatile function types");
4095 #endif
4097 /* Build the array type itself, then merge any constancy or
4098 volatility into the target type. We must do it in this order
4099 to ensure that the TYPE_MAIN_VARIANT field of the array type
4100 is set correctly. */
4102 type = build_array_type (type, itype);
4103 if (type_quals)
4104 type = c_build_qualified_type (type, type_quals);
4106 if (size_varies)
4107 C_TYPE_VARIABLE_SIZE (type) = 1;
4109 /* The GCC extension for zero-length arrays differs from
4110 ISO flexible array members in that sizeof yields zero. */
4111 if (size && integer_zerop (size))
4113 layout_type (type);
4114 TYPE_SIZE (type) = bitsize_zero_node;
4115 TYPE_SIZE_UNIT (type) = size_zero_node;
4117 if (decl_context != PARM
4118 && (array_ptr_quals != NULL_TREE || array_parm_static))
4120 error ("static or type qualifiers in non-parameter array declarator");
4121 array_ptr_quals = NULL_TREE;
4122 array_parm_static = 0;
4125 else if (TREE_CODE (declarator) == CALL_EXPR)
4127 tree arg_types;
4129 /* Declaring a function type.
4130 Make sure we have a valid type for the function to return. */
4131 if (type == error_mark_node)
4132 continue;
4134 size_varies = 0;
4136 /* Warn about some types functions can't return. */
4138 if (TREE_CODE (type) == FUNCTION_TYPE)
4140 error ("`%s' declared as function returning a function", name);
4141 type = integer_type_node;
4143 if (TREE_CODE (type) == ARRAY_TYPE)
4145 error ("`%s' declared as function returning an array", name);
4146 type = integer_type_node;
4149 /* Construct the function type and go to the next
4150 inner layer of declarator. */
4152 arg_types = grokparms (TREE_OPERAND (declarator, 1),
4153 funcdef_flag
4154 /* Say it's a definition
4155 only for the CALL_EXPR
4156 closest to the identifier. */
4157 && TREE_CODE (TREE_OPERAND (declarator, 0)) == IDENTIFIER_NODE);
4158 /* Type qualifiers before the return type of the function
4159 qualify the return type, not the function type. */
4160 if (type_quals)
4162 /* Type qualifiers on a function return type are normally
4163 permitted by the standard but have no effect, so give a
4164 warning at -W. Qualifiers on a void return type have
4165 meaning as a GNU extension, and are banned on function
4166 definitions in ISO C. FIXME: strictly we shouldn't
4167 pedwarn for qualified void return types except on function
4168 definitions, but not doing so could lead to the undesirable
4169 state of a "volatile void" function return type not being
4170 warned about, and a use of the function being compiled
4171 with GNU semantics, with no diagnostics under -pedantic. */
4172 if (VOID_TYPE_P (type) && pedantic && !in_system_header)
4173 pedwarn ("ISO C forbids qualified void function return type");
4174 else if (extra_warnings
4175 && !(VOID_TYPE_P (type)
4176 && type_quals == TYPE_QUAL_VOLATILE))
4177 warning ("type qualifiers ignored on function return type");
4179 type = c_build_qualified_type (type, type_quals);
4181 type_quals = TYPE_UNQUALIFIED;
4183 type = build_function_type (type, arg_types);
4184 declarator = TREE_OPERAND (declarator, 0);
4186 /* Set the TYPE_CONTEXTs for each tagged type which is local to
4187 the formal parameter list of this FUNCTION_TYPE to point to
4188 the FUNCTION_TYPE node itself. */
4191 tree link;
4193 for (link = last_function_parm_tags;
4194 link;
4195 link = TREE_CHAIN (link))
4196 TYPE_CONTEXT (TREE_VALUE (link)) = type;
4199 else if (TREE_CODE (declarator) == INDIRECT_REF)
4201 /* Merge any constancy or volatility into the target type
4202 for the pointer. */
4204 if (pedantic && TREE_CODE (type) == FUNCTION_TYPE
4205 && type_quals)
4206 pedwarn ("ISO C forbids qualified function types");
4207 if (type_quals)
4208 type = c_build_qualified_type (type, type_quals);
4209 type_quals = TYPE_UNQUALIFIED;
4210 size_varies = 0;
4212 type = build_pointer_type (type);
4214 /* Process a list of type modifier keywords
4215 (such as const or volatile) that were given inside the `*'. */
4217 if (TREE_TYPE (declarator))
4219 tree typemodlist;
4220 int erred = 0;
4222 constp = 0;
4223 volatilep = 0;
4224 restrictp = 0;
4225 for (typemodlist = TREE_TYPE (declarator); typemodlist;
4226 typemodlist = TREE_CHAIN (typemodlist))
4228 tree qualifier = TREE_VALUE (typemodlist);
4230 if (C_IS_RESERVED_WORD (qualifier))
4232 if (C_RID_CODE (qualifier) == RID_CONST)
4233 constp++;
4234 else if (C_RID_CODE (qualifier) == RID_VOLATILE)
4235 volatilep++;
4236 else if (C_RID_CODE (qualifier) == RID_RESTRICT)
4237 restrictp++;
4238 else
4239 erred++;
4241 else
4242 erred++;
4245 if (erred)
4246 error ("invalid type modifier within pointer declarator");
4247 if (constp > 1 && ! flag_isoc99)
4248 pedwarn ("duplicate `const'");
4249 if (volatilep > 1 && ! flag_isoc99)
4250 pedwarn ("duplicate `volatile'");
4251 if (restrictp > 1 && ! flag_isoc99)
4252 pedwarn ("duplicate `restrict'");
4254 type_quals = ((constp ? TYPE_QUAL_CONST : 0)
4255 | (restrictp ? TYPE_QUAL_RESTRICT : 0)
4256 | (volatilep ? TYPE_QUAL_VOLATILE : 0));
4259 declarator = TREE_OPERAND (declarator, 0);
4261 else
4262 abort ();
4266 /* Now TYPE has the actual type. */
4268 /* Did array size calculations overflow? */
4270 if (TREE_CODE (type) == ARRAY_TYPE
4271 && COMPLETE_TYPE_P (type)
4272 && TREE_OVERFLOW (TYPE_SIZE (type)))
4274 error ("size of array `%s' is too large", name);
4275 /* If we proceed with the array type as it is, we'll eventually
4276 crash in tree_low_cst(). */
4277 type = error_mark_node;
4280 /* If this is declaring a typedef name, return a TYPE_DECL. */
4282 if (specbits & (1 << (int) RID_TYPEDEF))
4284 tree decl;
4285 /* Note that the grammar rejects storage classes
4286 in typenames, fields or parameters */
4287 if (pedantic && TREE_CODE (type) == FUNCTION_TYPE
4288 && type_quals)
4289 pedwarn ("ISO C forbids qualified function types");
4290 if (type_quals)
4291 type = c_build_qualified_type (type, type_quals);
4292 decl = build_decl (TYPE_DECL, declarator, type);
4293 if ((specbits & (1 << (int) RID_SIGNED))
4294 || (typedef_decl && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl)))
4295 C_TYPEDEF_EXPLICITLY_SIGNED (decl) = 1;
4296 decl_attributes (&decl, returned_attrs, 0);
4297 return decl;
4300 /* Detect the case of an array type of unspecified size
4301 which came, as such, direct from a typedef name.
4302 We must copy the type, so that each identifier gets
4303 a distinct type, so that each identifier's size can be
4304 controlled separately by its own initializer. */
4306 if (type != 0 && typedef_type != 0
4307 && TREE_CODE (type) == ARRAY_TYPE && TYPE_DOMAIN (type) == 0
4308 && TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (typedef_type))
4310 type = build_array_type (TREE_TYPE (type), 0);
4311 if (size_varies)
4312 C_TYPE_VARIABLE_SIZE (type) = 1;
4315 /* If this is a type name (such as, in a cast or sizeof),
4316 compute the type and return it now. */
4318 if (decl_context == TYPENAME)
4320 /* Note that the grammar rejects storage classes
4321 in typenames, fields or parameters */
4322 if (pedantic && TREE_CODE (type) == FUNCTION_TYPE
4323 && type_quals)
4324 pedwarn ("ISO C forbids const or volatile function types");
4325 if (type_quals)
4326 type = c_build_qualified_type (type, type_quals);
4327 decl_attributes (&type, returned_attrs, 0);
4328 return type;
4331 /* Aside from typedefs and type names (handle above),
4332 `void' at top level (not within pointer)
4333 is allowed only in public variables.
4334 We don't complain about parms either, but that is because
4335 a better error message can be made later. */
4337 if (VOID_TYPE_P (type) && decl_context != PARM
4338 && ! ((decl_context != FIELD && TREE_CODE (type) != FUNCTION_TYPE)
4339 && ((specbits & (1 << (int) RID_EXTERN))
4340 || (current_binding_level == global_binding_level
4341 && !(specbits
4342 & ((1 << (int) RID_STATIC) | (1 << (int) RID_REGISTER)))))))
4344 error ("variable or field `%s' declared void", name);
4345 type = integer_type_node;
4348 /* Now create the decl, which may be a VAR_DECL, a PARM_DECL
4349 or a FUNCTION_DECL, depending on DECL_CONTEXT and TYPE. */
4352 tree decl;
4354 if (decl_context == PARM)
4356 tree type_as_written;
4357 tree promoted_type;
4359 /* A parameter declared as an array of T is really a pointer to T.
4360 One declared as a function is really a pointer to a function. */
4362 if (TREE_CODE (type) == ARRAY_TYPE)
4364 /* Transfer const-ness of array into that of type pointed to. */
4365 type = TREE_TYPE (type);
4366 if (type_quals)
4367 type = c_build_qualified_type (type, type_quals);
4368 type = build_pointer_type (type);
4369 type_quals = TYPE_UNQUALIFIED;
4370 if (array_ptr_quals)
4372 tree new_ptr_quals, new_ptr_attrs;
4373 int erred = 0;
4374 split_specs_attrs (array_ptr_quals, &new_ptr_quals, &new_ptr_attrs);
4375 /* We don't yet implement attributes in this context. */
4376 if (new_ptr_attrs != NULL_TREE)
4377 warning ("attributes in parameter array declarator ignored");
4379 constp = 0;
4380 volatilep = 0;
4381 restrictp = 0;
4382 for (; new_ptr_quals; new_ptr_quals = TREE_CHAIN (new_ptr_quals))
4384 tree qualifier = TREE_VALUE (new_ptr_quals);
4386 if (C_IS_RESERVED_WORD (qualifier))
4388 if (C_RID_CODE (qualifier) == RID_CONST)
4389 constp++;
4390 else if (C_RID_CODE (qualifier) == RID_VOLATILE)
4391 volatilep++;
4392 else if (C_RID_CODE (qualifier) == RID_RESTRICT)
4393 restrictp++;
4394 else
4395 erred++;
4397 else
4398 erred++;
4401 if (erred)
4402 error ("invalid type modifier within array declarator");
4404 type_quals = ((constp ? TYPE_QUAL_CONST : 0)
4405 | (restrictp ? TYPE_QUAL_RESTRICT : 0)
4406 | (volatilep ? TYPE_QUAL_VOLATILE : 0));
4408 size_varies = 0;
4410 else if (TREE_CODE (type) == FUNCTION_TYPE)
4412 if (pedantic && type_quals)
4413 pedwarn ("ISO C forbids qualified function types");
4414 if (type_quals)
4415 type = c_build_qualified_type (type, type_quals);
4416 type = build_pointer_type (type);
4417 type_quals = TYPE_UNQUALIFIED;
4419 else if (type_quals)
4420 type = c_build_qualified_type (type, type_quals);
4422 type_as_written = type;
4424 decl = build_decl (PARM_DECL, declarator, type);
4425 if (size_varies)
4426 C_DECL_VARIABLE_SIZE (decl) = 1;
4428 /* Compute the type actually passed in the parmlist,
4429 for the case where there is no prototype.
4430 (For example, shorts and chars are passed as ints.)
4431 When there is a prototype, this is overridden later. */
4433 if (type == error_mark_node)
4434 promoted_type = type;
4435 else
4436 promoted_type = c_type_promotes_to (type);
4438 DECL_ARG_TYPE (decl) = promoted_type;
4439 DECL_ARG_TYPE_AS_WRITTEN (decl) = type_as_written;
4441 else if (decl_context == FIELD)
4443 /* Structure field. It may not be a function. */
4445 if (TREE_CODE (type) == FUNCTION_TYPE)
4447 error ("field `%s' declared as a function", name);
4448 type = build_pointer_type (type);
4450 else if (TREE_CODE (type) != ERROR_MARK
4451 && !COMPLETE_OR_UNBOUND_ARRAY_TYPE_P (type))
4453 error ("field `%s' has incomplete type", name);
4454 type = error_mark_node;
4456 /* Move type qualifiers down to element of an array. */
4457 if (TREE_CODE (type) == ARRAY_TYPE && type_quals)
4459 type = build_array_type (c_build_qualified_type (TREE_TYPE (type),
4460 type_quals),
4461 TYPE_DOMAIN (type));
4462 #if 0
4463 /* Leave the field const or volatile as well. */
4464 type_quals = TYPE_UNQUALIFIED;
4465 #endif
4467 decl = build_decl (FIELD_DECL, declarator, type);
4468 DECL_NONADDRESSABLE_P (decl) = bitfield;
4470 if (size_varies)
4471 C_DECL_VARIABLE_SIZE (decl) = 1;
4473 else if (TREE_CODE (type) == FUNCTION_TYPE)
4475 /* Every function declaration is "external"
4476 except for those which are inside a function body
4477 in which `auto' is used.
4478 That is a case not specified by ANSI C,
4479 and we use it for forward declarations for nested functions. */
4480 int extern_ref = (!(specbits & (1 << (int) RID_AUTO))
4481 || current_binding_level == global_binding_level);
4483 if (specbits & (1 << (int) RID_AUTO)
4484 && (pedantic || current_binding_level == global_binding_level))
4485 pedwarn ("invalid storage class for function `%s'", name);
4486 if (specbits & (1 << (int) RID_REGISTER))
4487 error ("invalid storage class for function `%s'", name);
4488 if (specbits & (1 << (int) RID_THREAD))
4489 error ("invalid storage class for function `%s'", name);
4490 /* Function declaration not at top level.
4491 Storage classes other than `extern' are not allowed
4492 and `extern' makes no difference. */
4493 if (current_binding_level != global_binding_level
4494 && (specbits & ((1 << (int) RID_STATIC) | (1 << (int) RID_INLINE)))
4495 && pedantic)
4496 pedwarn ("invalid storage class for function `%s'", name);
4498 decl = build_decl (FUNCTION_DECL, declarator, type);
4499 decl = build_decl_attribute_variant (decl, decl_attr);
4501 DECL_LANG_SPECIFIC (decl) = (struct lang_decl *)
4502 ggc_alloc_cleared (sizeof (struct lang_decl));
4504 if (pedantic && type_quals && ! DECL_IN_SYSTEM_HEADER (decl))
4505 pedwarn ("ISO C forbids qualified function types");
4507 /* GNU C interprets a `volatile void' return type to indicate
4508 that the function does not return. */
4509 if ((type_quals & TYPE_QUAL_VOLATILE)
4510 && !VOID_TYPE_P (TREE_TYPE (TREE_TYPE (decl))))
4511 warning ("`noreturn' function returns non-void value");
4513 if (extern_ref)
4514 DECL_EXTERNAL (decl) = 1;
4515 /* Record absence of global scope for `static' or `auto'. */
4516 TREE_PUBLIC (decl)
4517 = !(specbits & ((1 << (int) RID_STATIC) | (1 << (int) RID_AUTO)));
4519 if (defaulted_int)
4520 C_FUNCTION_IMPLICIT_INT (decl) = 1;
4522 /* Record presence of `inline', if it is reasonable. */
4523 if (MAIN_NAME_P (declarator))
4525 if (inlinep)
4526 warning ("cannot inline function `main'");
4528 else if (inlinep)
4530 /* Assume that otherwise the function can be inlined. */
4531 DECL_DECLARED_INLINE_P (decl) = 1;
4533 /* Do not mark bare declarations as DECL_INLINE. Doing so
4534 in the presence of multiple declarations can result in
4535 the abstract origin pointing between the declarations,
4536 which will confuse dwarf2out. */
4537 if (initialized)
4539 DECL_INLINE (decl) = 1;
4540 if (specbits & (1 << (int) RID_EXTERN))
4541 current_extern_inline = 1;
4544 /* If -finline-functions, assume it can be inlined. This does
4545 two things: let the function be deferred until it is actually
4546 needed, and let dwarf2 know that the function is inlinable. */
4547 else if (flag_inline_trees == 2 && initialized)
4549 DECL_INLINE (decl) = 1;
4550 DECL_DECLARED_INLINE_P (decl) = 0;
4553 else
4555 /* It's a variable. */
4556 /* An uninitialized decl with `extern' is a reference. */
4557 int extern_ref = !initialized && (specbits & (1 << (int) RID_EXTERN));
4559 /* Move type qualifiers down to element of an array. */
4560 if (TREE_CODE (type) == ARRAY_TYPE && type_quals)
4562 int saved_align = TYPE_ALIGN(type);
4563 type = build_array_type (c_build_qualified_type (TREE_TYPE (type),
4564 type_quals),
4565 TYPE_DOMAIN (type));
4566 TYPE_ALIGN (type) = saved_align;
4567 #if 0 /* Leave the variable const or volatile as well. */
4568 type_quals = TYPE_UNQUALIFIED;
4569 #endif
4571 else if (type_quals)
4572 type = c_build_qualified_type (type, type_quals);
4574 decl = build_decl (VAR_DECL, declarator, type);
4575 if (size_varies)
4576 C_DECL_VARIABLE_SIZE (decl) = 1;
4578 if (inlinep)
4579 pedwarn_with_decl (decl, "variable `%s' declared `inline'");
4581 DECL_EXTERNAL (decl) = extern_ref;
4583 /* At top level, the presence of a `static' or `register' storage
4584 class specifier, or the absence of all storage class specifiers
4585 makes this declaration a definition (perhaps tentative). Also,
4586 the absence of both `static' and `register' makes it public. */
4587 if (current_binding_level == global_binding_level)
4589 TREE_PUBLIC (decl) = !(specbits & ((1 << (int) RID_STATIC)
4590 | (1 << (int) RID_REGISTER)));
4591 TREE_STATIC (decl) = !extern_ref;
4593 /* Not at top level, only `static' makes a static definition. */
4594 else
4596 TREE_STATIC (decl) = (specbits & (1 << (int) RID_STATIC)) != 0;
4597 TREE_PUBLIC (decl) = extern_ref;
4600 if (specbits & 1 << (int) RID_THREAD)
4602 if (targetm.have_tls)
4603 DECL_THREAD_LOCAL (decl) = 1;
4604 else
4605 /* A mere warning is sure to result in improper semantics
4606 at runtime. Don't bother to allow this to compile. */
4607 error ("thread-local storage not supported for this target");
4611 /* Record `register' declaration for warnings on &
4612 and in case doing stupid register allocation. */
4614 if (specbits & (1 << (int) RID_REGISTER))
4615 DECL_REGISTER (decl) = 1;
4617 /* Record constancy and volatility. */
4618 c_apply_type_quals_to_decl (type_quals, decl);
4620 /* If a type has volatile components, it should be stored in memory.
4621 Otherwise, the fact that those components are volatile
4622 will be ignored, and would even crash the compiler. */
4623 if (C_TYPE_FIELDS_VOLATILE (TREE_TYPE (decl)))
4624 c_mark_addressable (decl);
4626 decl_attributes (&decl, returned_attrs, 0);
4628 return decl;
4632 /* Decode the parameter-list info for a function type or function definition.
4633 The argument is the value returned by `get_parm_info' (or made in parse.y
4634 if there is an identifier list instead of a parameter decl list).
4635 These two functions are separate because when a function returns
4636 or receives functions then each is called multiple times but the order
4637 of calls is different. The last call to `grokparms' is always the one
4638 that contains the formal parameter names of a function definition.
4640 Store in `last_function_parms' a chain of the decls of parms.
4641 Also store in `last_function_parm_tags' a chain of the struct, union,
4642 and enum tags declared among the parms.
4644 Return a list of arg types to use in the FUNCTION_TYPE for this function.
4646 FUNCDEF_FLAG is nonzero for a function definition, 0 for
4647 a mere declaration. A nonempty identifier-list gets an error message
4648 when FUNCDEF_FLAG is zero. */
4650 static tree
4651 grokparms (parms_info, funcdef_flag)
4652 tree parms_info;
4653 int funcdef_flag;
4655 tree first_parm = TREE_CHAIN (parms_info);
4657 last_function_parms = TREE_PURPOSE (parms_info);
4658 last_function_parm_tags = TREE_VALUE (parms_info);
4660 if (warn_strict_prototypes && first_parm == 0 && !funcdef_flag
4661 && !in_system_header)
4662 warning ("function declaration isn't a prototype");
4664 if (first_parm != 0
4665 && TREE_CODE (TREE_VALUE (first_parm)) == IDENTIFIER_NODE)
4667 if (! funcdef_flag)
4668 pedwarn ("parameter names (without types) in function declaration");
4670 last_function_parms = first_parm;
4671 return 0;
4673 else
4675 tree parm;
4676 tree typelt;
4677 /* We no longer test FUNCDEF_FLAG.
4678 If the arg types are incomplete in a declaration,
4679 they must include undefined tags.
4680 These tags can never be defined in the scope of the declaration,
4681 so the types can never be completed,
4682 and no call can be compiled successfully. */
4683 #if 0
4684 /* In a fcn definition, arg types must be complete. */
4685 if (funcdef_flag)
4686 #endif
4687 for (parm = last_function_parms, typelt = first_parm;
4688 parm;
4689 parm = TREE_CHAIN (parm))
4690 /* Skip over any enumeration constants declared here. */
4691 if (TREE_CODE (parm) == PARM_DECL)
4693 /* Barf if the parameter itself has an incomplete type. */
4694 tree type = TREE_VALUE (typelt);
4695 if (type == error_mark_node)
4696 continue;
4697 if (!COMPLETE_TYPE_P (type))
4699 if (funcdef_flag && DECL_NAME (parm) != 0)
4700 error ("parameter `%s' has incomplete type",
4701 IDENTIFIER_POINTER (DECL_NAME (parm)));
4702 else
4703 warning ("parameter has incomplete type");
4704 if (funcdef_flag)
4706 TREE_VALUE (typelt) = error_mark_node;
4707 TREE_TYPE (parm) = error_mark_node;
4710 #if 0
4711 /* This has been replaced by parm_tags_warning, which
4712 uses a more accurate criterion for what to warn
4713 about. */
4714 else
4716 /* Now warn if is a pointer to an incomplete type. */
4717 while (TREE_CODE (type) == POINTER_TYPE
4718 || TREE_CODE (type) == REFERENCE_TYPE)
4719 type = TREE_TYPE (type);
4720 type = TYPE_MAIN_VARIANT (type);
4721 if (!COMPLETE_TYPE_P (type))
4723 if (DECL_NAME (parm) != 0)
4724 warning ("parameter `%s' points to incomplete type",
4725 IDENTIFIER_POINTER (DECL_NAME (parm)));
4726 else
4727 warning ("parameter points to incomplete type");
4730 #endif
4731 typelt = TREE_CHAIN (typelt);
4734 return first_parm;
4738 /* Return a tree_list node with info on a parameter list just parsed.
4739 The TREE_PURPOSE is a chain of decls of those parms.
4740 The TREE_VALUE is a list of structure, union and enum tags defined.
4741 The TREE_CHAIN is a list of argument types to go in the FUNCTION_TYPE.
4742 This tree_list node is later fed to `grokparms'.
4744 VOID_AT_END nonzero means append `void' to the end of the type-list.
4745 Zero means the parmlist ended with an ellipsis so don't append `void'. */
4747 tree
4748 get_parm_info (void_at_end)
4749 int void_at_end;
4751 tree decl, t;
4752 tree types = 0;
4753 int erred = 0;
4754 tree tags = gettags ();
4755 tree parms = getdecls ();
4756 tree new_parms = 0;
4757 tree order = current_binding_level->parm_order;
4759 /* Just `void' (and no ellipsis) is special. There are really no parms.
4760 But if the `void' is qualified (by `const' or `volatile') or has a
4761 storage class specifier (`register'), then the behavior is undefined;
4762 by not counting it as the special case of `void' we will cause an
4763 error later. Typedefs for `void' are OK (see DR#157). */
4764 if (void_at_end && parms != 0
4765 && TREE_CHAIN (parms) == 0
4766 && VOID_TYPE_P (TREE_TYPE (parms))
4767 && ! TREE_THIS_VOLATILE (parms)
4768 && ! TREE_READONLY (parms)
4769 && ! DECL_REGISTER (parms)
4770 && DECL_NAME (parms) == 0)
4772 parms = NULL_TREE;
4773 storedecls (NULL_TREE);
4774 return tree_cons (NULL_TREE, NULL_TREE,
4775 tree_cons (NULL_TREE, void_type_node, NULL_TREE));
4778 /* Extract enumerator values and other non-parms declared with the parms.
4779 Likewise any forward parm decls that didn't have real parm decls. */
4780 for (decl = parms; decl;)
4782 tree next = TREE_CHAIN (decl);
4784 if (TREE_CODE (decl) != PARM_DECL)
4786 TREE_CHAIN (decl) = new_parms;
4787 new_parms = decl;
4789 else if (TREE_ASM_WRITTEN (decl))
4791 error_with_decl (decl,
4792 "parameter `%s' has just a forward declaration");
4793 TREE_CHAIN (decl) = new_parms;
4794 new_parms = decl;
4796 decl = next;
4799 /* Put the parm decls back in the order they were in in the parm list. */
4800 for (t = order; t; t = TREE_CHAIN (t))
4802 if (TREE_CHAIN (t))
4803 TREE_CHAIN (TREE_VALUE (t)) = TREE_VALUE (TREE_CHAIN (t));
4804 else
4805 TREE_CHAIN (TREE_VALUE (t)) = 0;
4808 new_parms = chainon (order ? nreverse (TREE_VALUE (order)) : 0,
4809 new_parms);
4811 /* Store the parmlist in the binding level since the old one
4812 is no longer a valid list. (We have changed the chain pointers.) */
4813 storedecls (new_parms);
4815 for (decl = new_parms; decl; decl = TREE_CHAIN (decl))
4816 /* There may also be declarations for enumerators if an enumeration
4817 type is declared among the parms. Ignore them here. */
4818 if (TREE_CODE (decl) == PARM_DECL)
4820 /* Since there is a prototype,
4821 args are passed in their declared types. */
4822 tree type = TREE_TYPE (decl);
4823 DECL_ARG_TYPE (decl) = type;
4824 if (PROMOTE_PROTOTYPES
4825 && INTEGRAL_TYPE_P (type)
4826 && TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node))
4827 DECL_ARG_TYPE (decl) = integer_type_node;
4829 types = tree_cons (NULL_TREE, TREE_TYPE (decl), types);
4830 if (VOID_TYPE_P (TREE_VALUE (types)) && ! erred
4831 && DECL_NAME (decl) == 0)
4833 error ("`void' in parameter list must be the entire list");
4834 erred = 1;
4838 if (void_at_end)
4839 return tree_cons (new_parms, tags,
4840 nreverse (tree_cons (NULL_TREE, void_type_node, types)));
4842 return tree_cons (new_parms, tags, nreverse (types));
4845 /* At end of parameter list, warn about any struct, union or enum tags
4846 defined within. Do so because these types cannot ever become complete. */
4848 void
4849 parmlist_tags_warning ()
4851 tree elt;
4852 static int already;
4854 for (elt = current_binding_level->tags; elt; elt = TREE_CHAIN (elt))
4856 enum tree_code code = TREE_CODE (TREE_VALUE (elt));
4857 /* An anonymous union parm type is meaningful as a GNU extension.
4858 So don't warn for that. */
4859 if (code == UNION_TYPE && TREE_PURPOSE (elt) == 0 && !pedantic)
4860 continue;
4861 if (TREE_PURPOSE (elt) != 0)
4863 if (code == RECORD_TYPE)
4864 warning ("`struct %s' declared inside parameter list",
4865 IDENTIFIER_POINTER (TREE_PURPOSE (elt)));
4866 else if (code == UNION_TYPE)
4867 warning ("`union %s' declared inside parameter list",
4868 IDENTIFIER_POINTER (TREE_PURPOSE (elt)));
4869 else
4870 warning ("`enum %s' declared inside parameter list",
4871 IDENTIFIER_POINTER (TREE_PURPOSE (elt)));
4873 else
4875 /* For translation these need to be separate warnings */
4876 if (code == RECORD_TYPE)
4877 warning ("anonymous struct declared inside parameter list");
4878 else if (code == UNION_TYPE)
4879 warning ("anonymous union declared inside parameter list");
4880 else
4881 warning ("anonymous enum declared inside parameter list");
4883 if (! already)
4885 warning ("its scope is only this definition or declaration, which is probably not what you want");
4886 already = 1;
4891 /* Get the struct, enum or union (CODE says which) with tag NAME.
4892 Define the tag as a forward-reference if it is not defined. */
4894 tree
4895 xref_tag (code, name)
4896 enum tree_code code;
4897 tree name;
4899 /* If a cross reference is requested, look up the type
4900 already defined for this tag and return it. */
4902 tree ref = lookup_tag (code, name, current_binding_level, 0);
4903 /* If this is the right type of tag, return what we found.
4904 (This reference will be shadowed by shadow_tag later if appropriate.)
4905 If this is the wrong type of tag, do not return it. If it was the
4906 wrong type in the same binding level, we will have had an error
4907 message already; if in a different binding level and declaring
4908 a name, pending_xref_error will give an error message; but if in a
4909 different binding level and not declaring a name, this tag should
4910 shadow the previous declaration of a different type of tag, and
4911 this would not work properly if we return the reference found.
4912 (For example, with "struct foo" in an outer scope, "union foo;"
4913 must shadow that tag with a new one of union type.) */
4914 if (ref && TREE_CODE (ref) == code)
4915 return ref;
4917 /* If no such tag is yet defined, create a forward-reference node
4918 and record it as the "definition".
4919 When a real declaration of this type is found,
4920 the forward-reference will be altered into a real type. */
4922 ref = make_node (code);
4923 if (code == ENUMERAL_TYPE)
4925 /* Give the type a default layout like unsigned int
4926 to avoid crashing if it does not get defined. */
4927 TYPE_MODE (ref) = TYPE_MODE (unsigned_type_node);
4928 TYPE_ALIGN (ref) = TYPE_ALIGN (unsigned_type_node);
4929 TYPE_USER_ALIGN (ref) = 0;
4930 TREE_UNSIGNED (ref) = 1;
4931 TYPE_PRECISION (ref) = TYPE_PRECISION (unsigned_type_node);
4932 TYPE_MIN_VALUE (ref) = TYPE_MIN_VALUE (unsigned_type_node);
4933 TYPE_MAX_VALUE (ref) = TYPE_MAX_VALUE (unsigned_type_node);
4936 pushtag (name, ref);
4938 return ref;
4941 /* Make sure that the tag NAME is defined *in the current binding level*
4942 at least as a forward reference.
4943 CODE says which kind of tag NAME ought to be. */
4945 tree
4946 start_struct (code, name)
4947 enum tree_code code;
4948 tree name;
4950 /* If there is already a tag defined at this binding level
4951 (as a forward reference), just return it. */
4953 tree ref = 0;
4955 if (name != 0)
4956 ref = lookup_tag (code, name, current_binding_level, 1);
4957 if (ref && TREE_CODE (ref) == code)
4959 if (TYPE_FIELDS (ref))
4961 if (code == UNION_TYPE)
4962 error ("redefinition of `union %s'", IDENTIFIER_POINTER (name));
4963 else
4964 error ("redefinition of `struct %s'", IDENTIFIER_POINTER (name));
4967 else
4969 /* Otherwise create a forward-reference just so the tag is in scope. */
4971 ref = make_node (code);
4972 pushtag (name, ref);
4975 C_TYPE_BEING_DEFINED (ref) = 1;
4976 TYPE_PACKED (ref) = flag_pack_struct;
4977 return ref;
4980 /* Process the specs, declarator (NULL if omitted) and width (NULL if omitted)
4981 of a structure component, returning a FIELD_DECL node.
4982 WIDTH is non-NULL for bit fields only, and is an INTEGER_CST node.
4984 This is done during the parsing of the struct declaration.
4985 The FIELD_DECL nodes are chained together and the lot of them
4986 are ultimately passed to `build_struct' to make the RECORD_TYPE node. */
4988 tree
4989 grokfield (filename, line, declarator, declspecs, width)
4990 const char *filename ATTRIBUTE_UNUSED;
4991 int line ATTRIBUTE_UNUSED;
4992 tree declarator, declspecs, width;
4994 tree value;
4996 if (declarator == NULL_TREE && width == NULL_TREE)
4998 /* This is an unnamed decl.
5000 If we have something of the form "union { list } ;" then this
5001 is the anonymous union extension. Similarly for struct.
5003 If this is something of the form "struct foo;", then
5004 If MS extensions are enabled, this is handled as an
5005 anonymous struct.
5006 Otherwise this is a forward declaration of a structure tag.
5008 If this is something of the form "foo;" and foo is a TYPE_DECL, then
5009 If MS extensions are enabled and foo names a structure, then
5010 again this is an anonymous struct.
5011 Otherwise this is an error.
5013 Oh what a horrid tangled web we weave. I wonder if MS consiously
5014 took this from Plan 9 or if it was an accident of implementation
5015 that took root before someone noticed the bug... */
5017 tree type = TREE_VALUE (declspecs);
5019 if (flag_ms_extensions && TREE_CODE (type) == TYPE_DECL)
5020 type = TREE_TYPE (type);
5021 if (TREE_CODE (type) == RECORD_TYPE || TREE_CODE (type) == UNION_TYPE)
5023 if (flag_ms_extensions)
5024 ; /* ok */
5025 else if (flag_iso)
5026 goto warn_unnamed_field;
5027 else if (TYPE_NAME (type) == NULL)
5028 ; /* ok */
5029 else
5030 goto warn_unnamed_field;
5032 else
5034 warn_unnamed_field:
5035 warning ("declaration does not declare anything");
5036 return NULL_TREE;
5040 value = grokdeclarator (declarator, declspecs, width ? BITFIELD : FIELD, 0);
5042 finish_decl (value, NULL_TREE, NULL_TREE);
5043 DECL_INITIAL (value) = width;
5045 if (flag_objc)
5046 objc_check_decl (value);
5047 return value;
5050 /* Fill in the fields of a RECORD_TYPE or UNION_TYPE node, T.
5051 FIELDLIST is a chain of FIELD_DECL nodes for the fields.
5052 ATTRIBUTES are attributes to be applied to the structure. */
5054 tree
5055 finish_struct (t, fieldlist, attributes)
5056 tree t;
5057 tree fieldlist;
5058 tree attributes;
5060 tree x;
5061 int toplevel = global_binding_level == current_binding_level;
5062 int saw_named_field;
5064 /* If this type was previously laid out as a forward reference,
5065 make sure we lay it out again. */
5067 TYPE_SIZE (t) = 0;
5069 decl_attributes (&t, attributes, (int) ATTR_FLAG_TYPE_IN_PLACE);
5071 /* Nameless union parm types are useful as GCC extension. */
5072 if (! (TREE_CODE (t) == UNION_TYPE && TYPE_NAME (t) == 0) && !pedantic)
5073 /* Otherwise, warn about any struct or union def. in parmlist. */
5074 if (in_parm_level_p ())
5076 if (pedantic)
5077 pedwarn ("%s defined inside parms",
5078 TREE_CODE (t) == UNION_TYPE ? _("union") : _("structure"));
5079 else
5080 warning ("%s defined inside parms",
5081 TREE_CODE (t) == UNION_TYPE ? _("union") : _("structure"));
5084 if (pedantic)
5086 for (x = fieldlist; x; x = TREE_CHAIN (x))
5087 if (DECL_NAME (x) != 0)
5088 break;
5090 if (x == 0)
5091 pedwarn ("%s has no %s",
5092 TREE_CODE (t) == UNION_TYPE ? _("union") : _("struct"),
5093 fieldlist ? _("named members") : _("members"));
5096 /* Install struct as DECL_CONTEXT of each field decl.
5097 Also process specified field sizes,m which is found in the DECL_INITIAL.
5098 Store 0 there, except for ": 0" fields (so we can find them
5099 and delete them, below). */
5101 saw_named_field = 0;
5102 for (x = fieldlist; x; x = TREE_CHAIN (x))
5104 DECL_CONTEXT (x) = t;
5105 DECL_PACKED (x) |= TYPE_PACKED (t);
5107 /* If any field is const, the structure type is pseudo-const. */
5108 if (TREE_READONLY (x))
5109 C_TYPE_FIELDS_READONLY (t) = 1;
5110 else
5112 /* A field that is pseudo-const makes the structure likewise. */
5113 tree t1 = TREE_TYPE (x);
5114 while (TREE_CODE (t1) == ARRAY_TYPE)
5115 t1 = TREE_TYPE (t1);
5116 if ((TREE_CODE (t1) == RECORD_TYPE || TREE_CODE (t1) == UNION_TYPE)
5117 && C_TYPE_FIELDS_READONLY (t1))
5118 C_TYPE_FIELDS_READONLY (t) = 1;
5121 /* Any field that is volatile means variables of this type must be
5122 treated in some ways as volatile. */
5123 if (TREE_THIS_VOLATILE (x))
5124 C_TYPE_FIELDS_VOLATILE (t) = 1;
5126 /* Any field of nominal variable size implies structure is too. */
5127 if (C_DECL_VARIABLE_SIZE (x))
5128 C_TYPE_VARIABLE_SIZE (t) = 1;
5130 /* Detect invalid nested redefinition. */
5131 if (TREE_TYPE (x) == t)
5132 error ("nested redefinition of `%s'",
5133 IDENTIFIER_POINTER (TYPE_NAME (t)));
5135 /* Detect invalid bit-field size. */
5136 if (DECL_INITIAL (x))
5137 STRIP_NOPS (DECL_INITIAL (x));
5138 if (DECL_INITIAL (x))
5140 if (TREE_CODE (DECL_INITIAL (x)) == INTEGER_CST)
5141 constant_expression_warning (DECL_INITIAL (x));
5142 else
5144 error_with_decl (x,
5145 "bit-field `%s' width not an integer constant");
5146 DECL_INITIAL (x) = NULL;
5150 /* Detect invalid bit-field type. */
5151 if (DECL_INITIAL (x)
5152 && TREE_CODE (TREE_TYPE (x)) != INTEGER_TYPE
5153 && TREE_CODE (TREE_TYPE (x)) != BOOLEAN_TYPE
5154 && TREE_CODE (TREE_TYPE (x)) != ENUMERAL_TYPE)
5156 error_with_decl (x, "bit-field `%s' has invalid type");
5157 DECL_INITIAL (x) = NULL;
5160 if (DECL_INITIAL (x) && pedantic
5161 && TYPE_MAIN_VARIANT (TREE_TYPE (x)) != integer_type_node
5162 && TYPE_MAIN_VARIANT (TREE_TYPE (x)) != unsigned_type_node
5163 && TYPE_MAIN_VARIANT (TREE_TYPE (x)) != c_bool_type_node
5164 /* Accept an enum that's equivalent to int or unsigned int. */
5165 && !(TREE_CODE (TREE_TYPE (x)) == ENUMERAL_TYPE
5166 && (TYPE_PRECISION (TREE_TYPE (x))
5167 == TYPE_PRECISION (integer_type_node))))
5168 pedwarn_with_decl (x, "bit-field `%s' type invalid in ISO C");
5170 /* Detect and ignore out of range field width and process valid
5171 field widths. */
5172 if (DECL_INITIAL (x))
5174 int max_width
5175 = (TYPE_MAIN_VARIANT (TREE_TYPE (x)) == c_bool_type_node
5176 ? CHAR_TYPE_SIZE : TYPE_PRECISION (TREE_TYPE (x)));
5178 if (tree_int_cst_sgn (DECL_INITIAL (x)) < 0)
5179 error_with_decl (x, "negative width in bit-field `%s'");
5180 else if (0 < compare_tree_int (DECL_INITIAL (x), max_width))
5181 pedwarn_with_decl (x, "width of `%s' exceeds its type");
5182 else if (integer_zerop (DECL_INITIAL (x)) && DECL_NAME (x) != 0)
5183 error_with_decl (x, "zero width for bit-field `%s'");
5184 else
5186 /* The test above has assured us that TREE_INT_CST_HIGH is 0. */
5187 unsigned HOST_WIDE_INT width
5188 = tree_low_cst (DECL_INITIAL (x), 1);
5190 if (TREE_CODE (TREE_TYPE (x)) == ENUMERAL_TYPE
5191 && (width < min_precision (TYPE_MIN_VALUE (TREE_TYPE (x)),
5192 TREE_UNSIGNED (TREE_TYPE (x)))
5193 || (width
5194 < min_precision (TYPE_MAX_VALUE (TREE_TYPE (x)),
5195 TREE_UNSIGNED (TREE_TYPE (x))))))
5196 warning_with_decl (x,
5197 "`%s' is narrower than values of its type");
5199 DECL_SIZE (x) = bitsize_int (width);
5200 DECL_BIT_FIELD (x) = 1;
5201 SET_DECL_C_BIT_FIELD (x);
5203 if (width == 0
5204 && ! (* targetm.ms_bitfield_layout_p) (t))
5206 /* field size 0 => force desired amount of alignment. */
5207 #ifdef EMPTY_FIELD_BOUNDARY
5208 DECL_ALIGN (x) = MAX (DECL_ALIGN (x), EMPTY_FIELD_BOUNDARY);
5209 #endif
5210 #ifdef PCC_BITFIELD_TYPE_MATTERS
5211 if (PCC_BITFIELD_TYPE_MATTERS)
5213 DECL_ALIGN (x) = MAX (DECL_ALIGN (x),
5214 TYPE_ALIGN (TREE_TYPE (x)));
5215 DECL_USER_ALIGN (x) |= TYPE_USER_ALIGN (TREE_TYPE (x));
5217 #endif
5222 else if (TREE_TYPE (x) != error_mark_node)
5224 unsigned int min_align = (DECL_PACKED (x) ? BITS_PER_UNIT
5225 : TYPE_ALIGN (TREE_TYPE (x)));
5227 /* Non-bit-fields are aligned for their type, except packed
5228 fields which require only BITS_PER_UNIT alignment. */
5229 DECL_ALIGN (x) = MAX (DECL_ALIGN (x), min_align);
5230 if (! DECL_PACKED (x))
5231 DECL_USER_ALIGN (x) |= TYPE_USER_ALIGN (TREE_TYPE (x));
5234 DECL_INITIAL (x) = 0;
5236 /* Detect flexible array member in an invalid context. */
5237 if (TREE_CODE (TREE_TYPE (x)) == ARRAY_TYPE
5238 && TYPE_SIZE (TREE_TYPE (x)) == NULL_TREE
5239 && TYPE_DOMAIN (TREE_TYPE (x)) != NULL_TREE
5240 && TYPE_MAX_VALUE (TYPE_DOMAIN (TREE_TYPE (x))) == NULL_TREE)
5242 if (TREE_CODE (t) == UNION_TYPE)
5243 error_with_decl (x, "flexible array member in union");
5244 else if (TREE_CHAIN (x) != NULL_TREE)
5245 error_with_decl (x, "flexible array member not at end of struct");
5246 else if (! saw_named_field)
5247 error_with_decl (x, "flexible array member in otherwise empty struct");
5250 if (pedantic && TREE_CODE (t) == RECORD_TYPE
5251 && flexible_array_type_p (TREE_TYPE (x)))
5252 pedwarn_with_decl (x, "invalid use of structure with flexible array member");
5254 if (DECL_NAME (x))
5255 saw_named_field = 1;
5258 /* Delete all duplicate fields from the fieldlist */
5259 for (x = fieldlist; x && TREE_CHAIN (x);)
5260 /* Anonymous fields aren't duplicates. */
5261 if (DECL_NAME (TREE_CHAIN (x)) == 0)
5262 x = TREE_CHAIN (x);
5263 else
5265 tree y = fieldlist;
5267 while (1)
5269 if (DECL_NAME (y) == DECL_NAME (TREE_CHAIN (x)))
5270 break;
5271 if (y == x)
5272 break;
5273 y = TREE_CHAIN (y);
5275 if (DECL_NAME (y) == DECL_NAME (TREE_CHAIN (x)))
5277 error_with_decl (TREE_CHAIN (x), "duplicate member `%s'");
5278 TREE_CHAIN (x) = TREE_CHAIN (TREE_CHAIN (x));
5280 else
5281 x = TREE_CHAIN (x);
5284 /* Now we have the nearly final fieldlist. Record it,
5285 then lay out the structure or union (including the fields). */
5287 TYPE_FIELDS (t) = fieldlist;
5289 layout_type (t);
5291 /* Delete all zero-width bit-fields from the fieldlist */
5293 tree *fieldlistp = &fieldlist;
5294 while (*fieldlistp)
5295 if (TREE_CODE (*fieldlistp) == FIELD_DECL && DECL_INITIAL (*fieldlistp))
5296 *fieldlistp = TREE_CHAIN (*fieldlistp);
5297 else
5298 fieldlistp = &TREE_CHAIN (*fieldlistp);
5301 /* Now we have the truly final field list.
5302 Store it in this type and in the variants. */
5304 TYPE_FIELDS (t) = fieldlist;
5306 for (x = TYPE_MAIN_VARIANT (t); x; x = TYPE_NEXT_VARIANT (x))
5308 TYPE_FIELDS (x) = TYPE_FIELDS (t);
5309 TYPE_LANG_SPECIFIC (x) = TYPE_LANG_SPECIFIC (t);
5310 TYPE_ALIGN (x) = TYPE_ALIGN (t);
5311 TYPE_USER_ALIGN (x) = TYPE_USER_ALIGN (t);
5314 /* If this was supposed to be a transparent union, but we can't
5315 make it one, warn and turn off the flag. */
5316 if (TREE_CODE (t) == UNION_TYPE
5317 && TYPE_TRANSPARENT_UNION (t)
5318 && TYPE_MODE (t) != DECL_MODE (TYPE_FIELDS (t)))
5320 TYPE_TRANSPARENT_UNION (t) = 0;
5321 warning ("union cannot be made transparent");
5324 /* If this structure or union completes the type of any previous
5325 variable declaration, lay it out and output its rtl. */
5327 if (current_binding_level->incomplete_list != NULL_TREE)
5329 tree prev = NULL_TREE;
5331 for (x = current_binding_level->incomplete_list; x; x = TREE_CHAIN (x))
5333 tree decl = TREE_VALUE (x);
5335 if (TYPE_MAIN_VARIANT (TREE_TYPE (decl)) == TYPE_MAIN_VARIANT (t)
5336 && TREE_CODE (decl) != TYPE_DECL)
5338 layout_decl (decl, 0);
5339 /* This is a no-op in c-lang.c or something real in objc-act.c. */
5340 if (flag_objc)
5341 objc_check_decl (decl);
5342 rest_of_decl_compilation (decl, NULL, toplevel, 0);
5343 if (! toplevel)
5344 expand_decl (decl);
5345 /* Unlink X from the incomplete list. */
5346 if (prev)
5347 TREE_CHAIN (prev) = TREE_CHAIN (x);
5348 else
5349 current_binding_level->incomplete_list = TREE_CHAIN (x);
5351 else if (!COMPLETE_TYPE_P (TREE_TYPE (decl))
5352 && TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE)
5354 tree element = TREE_TYPE (decl);
5355 while (TREE_CODE (element) == ARRAY_TYPE)
5356 element = TREE_TYPE (element);
5357 if (element == t)
5359 layout_array_type (TREE_TYPE (decl));
5360 if (TREE_CODE (decl) != TYPE_DECL)
5362 layout_decl (decl, 0);
5363 if (flag_objc)
5364 objc_check_decl (decl);
5365 rest_of_decl_compilation (decl, NULL, toplevel, 0);
5366 if (! toplevel)
5367 expand_decl (decl);
5369 /* Unlink X from the incomplete list. */
5370 if (prev)
5371 TREE_CHAIN (prev) = TREE_CHAIN (x);
5372 else
5373 current_binding_level->incomplete_list = TREE_CHAIN (x);
5379 /* Finish debugging output for this type. */
5380 rest_of_type_compilation (t, toplevel);
5382 return t;
5385 /* Lay out the type T, and its element type, and so on. */
5387 static void
5388 layout_array_type (t)
5389 tree t;
5391 if (TREE_CODE (TREE_TYPE (t)) == ARRAY_TYPE)
5392 layout_array_type (TREE_TYPE (t));
5393 layout_type (t);
5396 /* Begin compiling the definition of an enumeration type.
5397 NAME is its name (or null if anonymous).
5398 Returns the type object, as yet incomplete.
5399 Also records info about it so that build_enumerator
5400 may be used to declare the individual values as they are read. */
5402 tree
5403 start_enum (name)
5404 tree name;
5406 tree enumtype = 0;
5408 /* If this is the real definition for a previous forward reference,
5409 fill in the contents in the same object that used to be the
5410 forward reference. */
5412 if (name != 0)
5413 enumtype = lookup_tag (ENUMERAL_TYPE, name, current_binding_level, 1);
5415 if (enumtype == 0 || TREE_CODE (enumtype) != ENUMERAL_TYPE)
5417 enumtype = make_node (ENUMERAL_TYPE);
5418 pushtag (name, enumtype);
5421 C_TYPE_BEING_DEFINED (enumtype) = 1;
5423 if (TYPE_VALUES (enumtype) != 0)
5425 /* This enum is a named one that has been declared already. */
5426 error ("redeclaration of `enum %s'", IDENTIFIER_POINTER (name));
5428 /* Completely replace its old definition.
5429 The old enumerators remain defined, however. */
5430 TYPE_VALUES (enumtype) = 0;
5433 enum_next_value = integer_zero_node;
5434 enum_overflow = 0;
5436 if (flag_short_enums)
5437 TYPE_PACKED (enumtype) = 1;
5439 return enumtype;
5442 /* After processing and defining all the values of an enumeration type,
5443 install their decls in the enumeration type and finish it off.
5444 ENUMTYPE is the type object, VALUES a list of decl-value pairs,
5445 and ATTRIBUTES are the specified attributes.
5446 Returns ENUMTYPE. */
5448 tree
5449 finish_enum (enumtype, values, attributes)
5450 tree enumtype;
5451 tree values;
5452 tree attributes;
5454 tree pair, tem;
5455 tree minnode = 0, maxnode = 0, enum_value_type;
5456 int precision, unsign;
5457 int toplevel = (global_binding_level == current_binding_level);
5459 if (in_parm_level_p ())
5460 warning ("enum defined inside parms");
5462 decl_attributes (&enumtype, attributes, (int) ATTR_FLAG_TYPE_IN_PLACE);
5464 /* Calculate the maximum value of any enumerator in this type. */
5466 if (values == error_mark_node)
5467 minnode = maxnode = integer_zero_node;
5468 else
5470 minnode = maxnode = TREE_VALUE (values);
5471 for (pair = TREE_CHAIN (values); pair; pair = TREE_CHAIN (pair))
5473 tree value = TREE_VALUE (pair);
5474 if (tree_int_cst_lt (maxnode, value))
5475 maxnode = value;
5476 if (tree_int_cst_lt (value, minnode))
5477 minnode = value;
5481 /* Construct the final type of this enumeration. It is the same
5482 as one of the integral types - the narrowest one that fits, except
5483 that normally we only go as narrow as int - and signed iff any of
5484 the values are negative. */
5485 unsign = (tree_int_cst_sgn (minnode) >= 0);
5486 precision = MAX (min_precision (minnode, unsign),
5487 min_precision (maxnode, unsign));
5488 if (TYPE_PACKED (enumtype) || precision > TYPE_PRECISION (integer_type_node))
5490 tree narrowest = c_common_type_for_size (precision, unsign);
5491 if (narrowest == 0)
5493 warning ("enumeration values exceed range of largest integer");
5494 narrowest = long_long_integer_type_node;
5497 precision = TYPE_PRECISION (narrowest);
5499 else
5500 precision = TYPE_PRECISION (integer_type_node);
5502 if (precision == TYPE_PRECISION (integer_type_node))
5503 enum_value_type = c_common_type_for_size (precision, 0);
5504 else
5505 enum_value_type = enumtype;
5507 TYPE_MIN_VALUE (enumtype) = minnode;
5508 TYPE_MAX_VALUE (enumtype) = maxnode;
5509 TYPE_PRECISION (enumtype) = precision;
5510 TREE_UNSIGNED (enumtype) = unsign;
5511 TYPE_SIZE (enumtype) = 0;
5512 layout_type (enumtype);
5514 if (values != error_mark_node)
5516 /* Change the type of the enumerators to be the enum type. We
5517 need to do this irrespective of the size of the enum, for
5518 proper type checking. Replace the DECL_INITIALs of the
5519 enumerators, and the value slots of the list, with copies
5520 that have the enum type; they cannot be modified in place
5521 because they may be shared (e.g. integer_zero_node) Finally,
5522 change the purpose slots to point to the names of the decls. */
5523 for (pair = values; pair; pair = TREE_CHAIN (pair))
5525 tree enu = TREE_PURPOSE (pair);
5527 TREE_TYPE (enu) = enumtype;
5528 DECL_SIZE (enu) = TYPE_SIZE (enumtype);
5529 DECL_SIZE_UNIT (enu) = TYPE_SIZE_UNIT (enumtype);
5530 DECL_ALIGN (enu) = TYPE_ALIGN (enumtype);
5531 DECL_USER_ALIGN (enu) = TYPE_USER_ALIGN (enumtype);
5532 DECL_MODE (enu) = TYPE_MODE (enumtype);
5534 /* The ISO C Standard mandates enumerators to have type int,
5535 even though the underlying type of an enum type is
5536 unspecified. Here we convert any enumerators that fit in
5537 an int to type int, to avoid promotions to unsigned types
5538 when comparing integers with enumerators that fit in the
5539 int range. When -pedantic is given, build_enumerator()
5540 would have already taken care of those that don't fit. */
5541 if (int_fits_type_p (DECL_INITIAL (enu), enum_value_type))
5542 DECL_INITIAL (enu) = convert (enum_value_type, DECL_INITIAL (enu));
5543 else
5544 DECL_INITIAL (enu) = convert (enumtype, DECL_INITIAL (enu));
5546 TREE_PURPOSE (pair) = DECL_NAME (enu);
5547 TREE_VALUE (pair) = DECL_INITIAL (enu);
5550 TYPE_VALUES (enumtype) = values;
5553 /* Fix up all variant types of this enum type. */
5554 for (tem = TYPE_MAIN_VARIANT (enumtype); tem; tem = TYPE_NEXT_VARIANT (tem))
5556 if (tem == enumtype)
5557 continue;
5558 TYPE_VALUES (tem) = TYPE_VALUES (enumtype);
5559 TYPE_MIN_VALUE (tem) = TYPE_MIN_VALUE (enumtype);
5560 TYPE_MAX_VALUE (tem) = TYPE_MAX_VALUE (enumtype);
5561 TYPE_SIZE (tem) = TYPE_SIZE (enumtype);
5562 TYPE_SIZE_UNIT (tem) = TYPE_SIZE_UNIT (enumtype);
5563 TYPE_MODE (tem) = TYPE_MODE (enumtype);
5564 TYPE_PRECISION (tem) = TYPE_PRECISION (enumtype);
5565 TYPE_ALIGN (tem) = TYPE_ALIGN (enumtype);
5566 TYPE_USER_ALIGN (tem) = TYPE_USER_ALIGN (enumtype);
5567 TREE_UNSIGNED (tem) = TREE_UNSIGNED (enumtype);
5570 /* Finish debugging output for this type. */
5571 rest_of_type_compilation (enumtype, toplevel);
5573 return enumtype;
5576 /* Build and install a CONST_DECL for one value of the
5577 current enumeration type (one that was begun with start_enum).
5578 Return a tree-list containing the CONST_DECL and its value.
5579 Assignment of sequential values by default is handled here. */
5581 tree
5582 build_enumerator (name, value)
5583 tree name, value;
5585 tree decl, type;
5587 /* Validate and default VALUE. */
5589 /* Remove no-op casts from the value. */
5590 if (value)
5591 STRIP_TYPE_NOPS (value);
5593 if (value != 0)
5595 if (TREE_CODE (value) == INTEGER_CST)
5597 value = default_conversion (value);
5598 constant_expression_warning (value);
5600 else
5602 error ("enumerator value for `%s' not integer constant",
5603 IDENTIFIER_POINTER (name));
5604 value = 0;
5608 /* Default based on previous value. */
5609 /* It should no longer be possible to have NON_LVALUE_EXPR
5610 in the default. */
5611 if (value == 0)
5613 value = enum_next_value;
5614 if (enum_overflow)
5615 error ("overflow in enumeration values");
5618 if (pedantic && ! int_fits_type_p (value, integer_type_node))
5620 pedwarn ("ISO C restricts enumerator values to range of `int'");
5621 value = convert (integer_type_node, value);
5624 /* Set basis for default for next value. */
5625 enum_next_value = build_binary_op (PLUS_EXPR, value, integer_one_node, 0);
5626 enum_overflow = tree_int_cst_lt (enum_next_value, value);
5628 /* Now create a declaration for the enum value name. */
5630 type = TREE_TYPE (value);
5631 type = c_common_type_for_size (MAX (TYPE_PRECISION (type),
5632 TYPE_PRECISION (integer_type_node)),
5633 (TYPE_PRECISION (type)
5634 >= TYPE_PRECISION (integer_type_node)
5635 && TREE_UNSIGNED (type)));
5637 decl = build_decl (CONST_DECL, name, type);
5638 DECL_INITIAL (decl) = convert (type, value);
5639 pushdecl (decl);
5641 return tree_cons (decl, value, NULL_TREE);
5645 /* Create the FUNCTION_DECL for a function definition.
5646 DECLSPECS, DECLARATOR and ATTRIBUTES are the parts of
5647 the declaration; they describe the function's name and the type it returns,
5648 but twisted together in a fashion that parallels the syntax of C.
5650 This function creates a binding context for the function body
5651 as well as setting up the FUNCTION_DECL in current_function_decl.
5653 Returns 1 on success. If the DECLARATOR is not suitable for a function
5654 (it defines a datum instead), we return 0, which tells
5655 yyparse to report a parse error. */
5658 start_function (declspecs, declarator, attributes)
5659 tree declarator, declspecs, attributes;
5661 tree decl1, old_decl;
5662 tree restype;
5663 int old_immediate_size_expand = immediate_size_expand;
5665 current_function_returns_value = 0; /* Assume, until we see it does. */
5666 current_function_returns_null = 0;
5667 current_function_returns_abnormally = 0;
5668 warn_about_return_type = 0;
5669 current_extern_inline = 0;
5670 named_labels = 0;
5671 shadowed_labels = 0;
5673 /* Don't expand any sizes in the return type of the function. */
5674 immediate_size_expand = 0;
5676 decl1 = grokdeclarator (declarator, declspecs, FUNCDEF, 1);
5678 /* If the declarator is not suitable for a function definition,
5679 cause a syntax error. */
5680 if (decl1 == 0)
5682 immediate_size_expand = old_immediate_size_expand;
5683 return 0;
5686 decl_attributes (&decl1, attributes, 0);
5688 /* If #pragma weak was used, mark the decl weak now. */
5689 if (current_binding_level == global_binding_level)
5690 maybe_apply_pragma_weak (decl1);
5692 if (DECL_DECLARED_INLINE_P (decl1)
5693 && DECL_UNINLINABLE (decl1)
5694 && lookup_attribute ("noinline", DECL_ATTRIBUTES (decl1)))
5695 warning_with_decl (decl1,
5696 "inline function `%s' given attribute noinline");
5698 announce_function (decl1);
5700 if (!COMPLETE_OR_VOID_TYPE_P (TREE_TYPE (TREE_TYPE (decl1))))
5702 error ("return type is an incomplete type");
5703 /* Make it return void instead. */
5704 TREE_TYPE (decl1)
5705 = build_function_type (void_type_node,
5706 TYPE_ARG_TYPES (TREE_TYPE (decl1)));
5709 if (warn_about_return_type)
5710 pedwarn_c99 ("return type defaults to `int'");
5712 /* Save the parm names or decls from this function's declarator
5713 where store_parm_decls will find them. */
5714 current_function_parms = last_function_parms;
5715 current_function_parm_tags = last_function_parm_tags;
5717 /* Make the init_value nonzero so pushdecl knows this is not tentative.
5718 error_mark_node is replaced below (in poplevel) with the BLOCK. */
5719 DECL_INITIAL (decl1) = error_mark_node;
5721 /* If this definition isn't a prototype and we had a prototype declaration
5722 before, copy the arg type info from that prototype.
5723 But not if what we had before was a builtin function. */
5724 old_decl = lookup_name_current_level (DECL_NAME (decl1));
5725 if (old_decl != 0 && TREE_CODE (TREE_TYPE (old_decl)) == FUNCTION_TYPE
5726 && !DECL_BUILT_IN (old_decl)
5727 && (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (decl1)))
5728 == TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (old_decl))))
5729 && TYPE_ARG_TYPES (TREE_TYPE (decl1)) == 0)
5731 TREE_TYPE (decl1) = TREE_TYPE (old_decl);
5732 current_function_prototype_file = DECL_SOURCE_FILE (old_decl);
5733 current_function_prototype_line = DECL_SOURCE_LINE (old_decl);
5736 /* If there is no explicit declaration, look for any out-of-scope implicit
5737 declarations. */
5738 if (old_decl == 0)
5739 old_decl = IDENTIFIER_IMPLICIT_DECL (DECL_NAME (decl1));
5741 /* Optionally warn of old-fashioned def with no previous prototype. */
5742 if (warn_strict_prototypes
5743 && TYPE_ARG_TYPES (TREE_TYPE (decl1)) == 0
5744 && !(old_decl != 0
5745 && (TYPE_ARG_TYPES (TREE_TYPE (old_decl)) != 0
5746 || (DECL_BUILT_IN (old_decl)
5747 && ! C_DECL_ANTICIPATED (old_decl)))))
5748 warning ("function declaration isn't a prototype");
5749 /* Optionally warn of any global def with no previous prototype. */
5750 else if (warn_missing_prototypes
5751 && TREE_PUBLIC (decl1)
5752 && !(old_decl != 0
5753 && (TYPE_ARG_TYPES (TREE_TYPE (old_decl)) != 0
5754 || (DECL_BUILT_IN (old_decl)
5755 && ! C_DECL_ANTICIPATED (old_decl))))
5756 && ! MAIN_NAME_P (DECL_NAME (decl1)))
5757 warning_with_decl (decl1, "no previous prototype for `%s'");
5758 /* Optionally warn of any def with no previous prototype
5759 if the function has already been used. */
5760 else if (warn_missing_prototypes
5761 && old_decl != 0 && TREE_USED (old_decl)
5762 && TYPE_ARG_TYPES (TREE_TYPE (old_decl)) == 0)
5763 warning_with_decl (decl1,
5764 "`%s' was used with no prototype before its definition");
5765 /* Optionally warn of any global def with no previous declaration. */
5766 else if (warn_missing_declarations
5767 && TREE_PUBLIC (decl1)
5768 && old_decl == 0
5769 && ! MAIN_NAME_P (DECL_NAME (decl1)))
5770 warning_with_decl (decl1, "no previous declaration for `%s'");
5771 /* Optionally warn of any def with no previous declaration
5772 if the function has already been used. */
5773 else if (warn_missing_declarations
5774 && old_decl != 0 && TREE_USED (old_decl)
5775 && old_decl == IDENTIFIER_IMPLICIT_DECL (DECL_NAME (decl1)))
5776 warning_with_decl (decl1,
5777 "`%s' was used with no declaration before its definition");
5779 /* This is a definition, not a reference.
5780 So normally clear DECL_EXTERNAL.
5781 However, `extern inline' acts like a declaration
5782 except for defining how to inline. So set DECL_EXTERNAL in that case. */
5783 DECL_EXTERNAL (decl1) = current_extern_inline;
5785 /* This function exists in static storage.
5786 (This does not mean `static' in the C sense!) */
5787 TREE_STATIC (decl1) = 1;
5789 /* A nested function is not global. */
5790 if (current_function_decl != 0)
5791 TREE_PUBLIC (decl1) = 0;
5793 /* Warn for unlikely, improbable, or stupid declarations of `main'. */
5794 if (warn_main > 0 && MAIN_NAME_P (DECL_NAME (decl1)))
5796 tree args;
5797 int argct = 0;
5799 if (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (decl1)))
5800 != integer_type_node)
5801 pedwarn_with_decl (decl1, "return type of `%s' is not `int'");
5803 for (args = TYPE_ARG_TYPES (TREE_TYPE (decl1)); args;
5804 args = TREE_CHAIN (args))
5806 tree type = args ? TREE_VALUE (args) : 0;
5808 if (type == void_type_node)
5809 break;
5811 ++argct;
5812 switch (argct)
5814 case 1:
5815 if (TYPE_MAIN_VARIANT (type) != integer_type_node)
5816 pedwarn_with_decl (decl1,
5817 "first argument of `%s' should be `int'");
5818 break;
5820 case 2:
5821 if (TREE_CODE (type) != POINTER_TYPE
5822 || TREE_CODE (TREE_TYPE (type)) != POINTER_TYPE
5823 || (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (type)))
5824 != char_type_node))
5825 pedwarn_with_decl (decl1,
5826 "second argument of `%s' should be `char **'");
5827 break;
5829 case 3:
5830 if (TREE_CODE (type) != POINTER_TYPE
5831 || TREE_CODE (TREE_TYPE (type)) != POINTER_TYPE
5832 || (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (type)))
5833 != char_type_node))
5834 pedwarn_with_decl (decl1,
5835 "third argument of `%s' should probably be `char **'");
5836 break;
5840 /* It is intentional that this message does not mention the third
5841 argument because it's only mentioned in an appendix of the
5842 standard. */
5843 if (argct > 0 && (argct < 2 || argct > 3))
5844 pedwarn_with_decl (decl1, "`%s' takes only zero or two arguments");
5846 if (! TREE_PUBLIC (decl1))
5847 pedwarn_with_decl (decl1, "`%s' is normally a non-static function");
5850 /* Record the decl so that the function name is defined.
5851 If we already have a decl for this name, and it is a FUNCTION_DECL,
5852 use the old decl. */
5854 current_function_decl = pushdecl (decl1);
5856 pushlevel (0);
5857 declare_parm_level (1);
5858 current_binding_level->subblocks_tag_transparent = 1;
5860 make_decl_rtl (current_function_decl, NULL);
5862 restype = TREE_TYPE (TREE_TYPE (current_function_decl));
5863 /* Promote the value to int before returning it. */
5864 if (c_promoting_integer_type_p (restype))
5866 /* It retains unsignedness if not really getting wider. */
5867 if (TREE_UNSIGNED (restype)
5868 && (TYPE_PRECISION (restype)
5869 == TYPE_PRECISION (integer_type_node)))
5870 restype = unsigned_type_node;
5871 else
5872 restype = integer_type_node;
5874 DECL_RESULT (current_function_decl)
5875 = build_decl (RESULT_DECL, NULL_TREE, restype);
5877 /* If this fcn was already referenced via a block-scope `extern' decl
5878 (or an implicit decl), propagate certain information about the usage. */
5879 if (TREE_ADDRESSABLE (DECL_ASSEMBLER_NAME (current_function_decl)))
5880 TREE_ADDRESSABLE (current_function_decl) = 1;
5882 immediate_size_expand = old_immediate_size_expand;
5884 start_fname_decls ();
5886 return 1;
5889 /* Store the parameter declarations into the current function declaration.
5890 This is called after parsing the parameter declarations, before
5891 digesting the body of the function.
5893 For an old-style definition, modify the function's type
5894 to specify at least the number of arguments. */
5896 void
5897 store_parm_decls ()
5899 tree fndecl = current_function_decl;
5900 tree parm;
5902 /* This is either a chain of PARM_DECLs (if a prototype was used)
5903 or a list of IDENTIFIER_NODEs (for an old-fashioned C definition). */
5904 tree specparms = current_function_parms;
5906 /* This is a list of types declared among parms in a prototype. */
5907 tree parmtags = current_function_parm_tags;
5909 /* This is a chain of PARM_DECLs from old-style parm declarations. */
5910 tree parmdecls = getdecls ();
5912 /* This is a chain of any other decls that came in among the parm
5913 declarations. If a parm is declared with enum {foo, bar} x;
5914 then CONST_DECLs for foo and bar are put here. */
5915 tree nonparms = 0;
5917 /* The function containing FNDECL, if any. */
5918 tree context = decl_function_context (fndecl);
5920 /* Nonzero if this definition is written with a prototype. */
5921 int prototype = 0;
5923 int saved_warn_shadow = warn_shadow;
5925 /* Don't re-emit shadow warnings. */
5926 warn_shadow = 0;
5928 if (specparms != 0 && TREE_CODE (specparms) != TREE_LIST)
5930 /* This case is when the function was defined with an ANSI prototype.
5931 The parms already have decls, so we need not do anything here
5932 except record them as in effect
5933 and complain if any redundant old-style parm decls were written. */
5935 tree next;
5936 tree others = 0;
5938 prototype = 1;
5940 if (parmdecls != 0)
5942 tree decl, link;
5944 error_with_decl (fndecl,
5945 "parm types given both in parmlist and separately");
5946 /* Get rid of the erroneous decls; don't keep them on
5947 the list of parms, since they might not be PARM_DECLs. */
5948 for (decl = current_binding_level->names;
5949 decl; decl = TREE_CHAIN (decl))
5950 if (DECL_NAME (decl))
5951 IDENTIFIER_LOCAL_VALUE (DECL_NAME (decl)) = 0;
5952 for (link = current_binding_level->shadowed;
5953 link; link = TREE_CHAIN (link))
5954 IDENTIFIER_LOCAL_VALUE (TREE_PURPOSE (link)) = TREE_VALUE (link);
5955 current_binding_level->names = 0;
5956 current_binding_level->shadowed = 0;
5959 specparms = nreverse (specparms);
5960 for (parm = specparms; parm; parm = next)
5962 next = TREE_CHAIN (parm);
5963 if (TREE_CODE (parm) == PARM_DECL)
5965 if (DECL_NAME (parm) == 0)
5966 error_with_decl (parm, "parameter name omitted");
5967 else if (TREE_CODE (TREE_TYPE (parm)) != ERROR_MARK
5968 && VOID_TYPE_P (TREE_TYPE (parm)))
5970 error_with_decl (parm, "parameter `%s' declared void");
5971 /* Change the type to error_mark_node so this parameter
5972 will be ignored by assign_parms. */
5973 TREE_TYPE (parm) = error_mark_node;
5975 pushdecl (parm);
5977 else
5979 /* If we find an enum constant or a type tag,
5980 put it aside for the moment. */
5981 TREE_CHAIN (parm) = 0;
5982 others = chainon (others, parm);
5986 /* Get the decls in their original chain order
5987 and record in the function. */
5988 DECL_ARGUMENTS (fndecl) = getdecls ();
5990 #if 0
5991 /* If this function takes a variable number of arguments,
5992 add a phony parameter to the end of the parm list,
5993 to represent the position of the first unnamed argument. */
5994 if (TREE_VALUE (tree_last (TYPE_ARG_TYPES (TREE_TYPE (fndecl))))
5995 != void_type_node)
5997 tree dummy = build_decl (PARM_DECL, NULL_TREE, void_type_node);
5998 /* Let's hope the address of the unnamed parm
5999 won't depend on its type. */
6000 TREE_TYPE (dummy) = integer_type_node;
6001 DECL_ARG_TYPE (dummy) = integer_type_node;
6002 DECL_ARGUMENTS (fndecl) = chainon (DECL_ARGUMENTS (fndecl), dummy);
6004 #endif
6006 /* Now pushdecl the enum constants. */
6007 for (parm = others; parm; parm = next)
6009 next = TREE_CHAIN (parm);
6010 if (DECL_NAME (parm) == 0)
6012 else if (TYPE_MAIN_VARIANT (TREE_TYPE (parm)) == void_type_node)
6014 else if (TREE_CODE (parm) != PARM_DECL)
6015 pushdecl (parm);
6018 storetags (chainon (parmtags, gettags ()));
6020 else
6022 /* SPECPARMS is an identifier list--a chain of TREE_LIST nodes
6023 each with a parm name as the TREE_VALUE.
6025 PARMDECLS is a chain of declarations for parameters.
6026 Warning! It can also contain CONST_DECLs which are not parameters
6027 but are names of enumerators of any enum types
6028 declared among the parameters.
6030 First match each formal parameter name with its declaration.
6031 Associate decls with the names and store the decls
6032 into the TREE_PURPOSE slots. */
6034 /* We use DECL_WEAK as a flag to show which parameters have been
6035 seen already since it is not used on PARM_DECL or CONST_DECL. */
6036 for (parm = parmdecls; parm; parm = TREE_CHAIN (parm))
6037 DECL_WEAK (parm) = 0;
6039 for (parm = specparms; parm; parm = TREE_CHAIN (parm))
6041 tree tail, found = NULL;
6043 if (TREE_VALUE (parm) == 0)
6045 error_with_decl (fndecl,
6046 "parameter name missing from parameter list");
6047 TREE_PURPOSE (parm) = 0;
6048 continue;
6051 /* See if any of the parmdecls specifies this parm by name.
6052 Ignore any enumerator decls. */
6053 for (tail = parmdecls; tail; tail = TREE_CHAIN (tail))
6054 if (DECL_NAME (tail) == TREE_VALUE (parm)
6055 && TREE_CODE (tail) == PARM_DECL)
6057 found = tail;
6058 break;
6061 /* If declaration already marked, we have a duplicate name.
6062 Complain, and don't use this decl twice. */
6063 if (found && DECL_WEAK (found))
6065 error_with_decl (found, "multiple parameters named `%s'");
6066 found = 0;
6069 /* If the declaration says "void", complain and ignore it. */
6070 if (found && VOID_TYPE_P (TREE_TYPE (found)))
6072 error_with_decl (found, "parameter `%s' declared void");
6073 TREE_TYPE (found) = integer_type_node;
6074 DECL_ARG_TYPE (found) = integer_type_node;
6075 layout_decl (found, 0);
6078 /* If no declaration found, default to int. */
6079 if (!found)
6081 found = build_decl (PARM_DECL, TREE_VALUE (parm),
6082 integer_type_node);
6083 DECL_ARG_TYPE (found) = TREE_TYPE (found);
6084 DECL_SOURCE_LINE (found) = DECL_SOURCE_LINE (fndecl);
6085 DECL_SOURCE_FILE (found) = DECL_SOURCE_FILE (fndecl);
6086 if (flag_isoc99)
6087 pedwarn_with_decl (found, "type of `%s' defaults to `int'");
6088 else if (extra_warnings)
6089 warning_with_decl (found, "type of `%s' defaults to `int'");
6090 pushdecl (found);
6093 TREE_PURPOSE (parm) = found;
6095 /* Mark this decl as "already found". */
6096 DECL_WEAK (found) = 1;
6099 /* Put anything which is on the parmdecls chain and which is
6100 not a PARM_DECL onto the list NONPARMS. (The types of
6101 non-parm things which might appear on the list include
6102 enumerators and NULL-named TYPE_DECL nodes.) Complain about
6103 any actual PARM_DECLs not matched with any names. */
6105 nonparms = 0;
6106 for (parm = parmdecls; parm;)
6108 tree next = TREE_CHAIN (parm);
6109 TREE_CHAIN (parm) = 0;
6111 if (TREE_CODE (parm) != PARM_DECL)
6112 nonparms = chainon (nonparms, parm);
6113 else
6115 /* Complain about args with incomplete types. */
6116 if (!COMPLETE_TYPE_P (TREE_TYPE (parm)))
6118 error_with_decl (parm, "parameter `%s' has incomplete type");
6119 TREE_TYPE (parm) = error_mark_node;
6122 if (! DECL_WEAK (parm))
6124 error_with_decl (parm,
6125 "declaration for parameter `%s' but no such parameter");
6126 /* Pretend the parameter was not missing.
6127 This gets us to a standard state and minimizes
6128 further error messages. */
6129 specparms
6130 = chainon (specparms,
6131 tree_cons (parm, NULL_TREE, NULL_TREE));
6135 parm = next;
6138 /* Chain the declarations together in the order of the list of
6139 names. Store that chain in the function decl, replacing the
6140 list of names. */
6141 parm = specparms;
6142 DECL_ARGUMENTS (fndecl) = 0;
6144 tree last;
6145 for (last = 0; parm; parm = TREE_CHAIN (parm))
6146 if (TREE_PURPOSE (parm))
6148 if (last == 0)
6149 DECL_ARGUMENTS (fndecl) = TREE_PURPOSE (parm);
6150 else
6151 TREE_CHAIN (last) = TREE_PURPOSE (parm);
6152 last = TREE_PURPOSE (parm);
6153 TREE_CHAIN (last) = 0;
6157 /* If there was a previous prototype,
6158 set the DECL_ARG_TYPE of each argument according to
6159 the type previously specified, and report any mismatches. */
6161 if (TYPE_ARG_TYPES (TREE_TYPE (fndecl)))
6163 tree type;
6164 for (parm = DECL_ARGUMENTS (fndecl),
6165 type = TYPE_ARG_TYPES (TREE_TYPE (fndecl));
6166 parm || (type && (TYPE_MAIN_VARIANT (TREE_VALUE (type))
6167 != void_type_node));
6168 parm = TREE_CHAIN (parm), type = TREE_CHAIN (type))
6170 if (parm == 0 || type == 0
6171 || TYPE_MAIN_VARIANT (TREE_VALUE (type)) == void_type_node)
6173 error ("number of arguments doesn't match prototype");
6174 error_with_file_and_line (current_function_prototype_file,
6175 current_function_prototype_line,
6176 "prototype declaration");
6177 break;
6179 /* Type for passing arg must be consistent with that
6180 declared for the arg. ISO C says we take the unqualified
6181 type for parameters declared with qualified type. */
6182 if (! comptypes (TYPE_MAIN_VARIANT (DECL_ARG_TYPE (parm)),
6183 TYPE_MAIN_VARIANT (TREE_VALUE (type))))
6185 if (TYPE_MAIN_VARIANT (TREE_TYPE (parm))
6186 == TYPE_MAIN_VARIANT (TREE_VALUE (type)))
6188 /* Adjust argument to match prototype. E.g. a previous
6189 `int foo(float);' prototype causes
6190 `int foo(x) float x; {...}' to be treated like
6191 `int foo(float x) {...}'. This is particularly
6192 useful for argument types like uid_t. */
6193 DECL_ARG_TYPE (parm) = TREE_TYPE (parm);
6195 if (PROMOTE_PROTOTYPES
6196 && INTEGRAL_TYPE_P (TREE_TYPE (parm))
6197 && TYPE_PRECISION (TREE_TYPE (parm))
6198 < TYPE_PRECISION (integer_type_node))
6199 DECL_ARG_TYPE (parm) = integer_type_node;
6201 if (pedantic)
6203 pedwarn ("promoted argument `%s' doesn't match prototype",
6204 IDENTIFIER_POINTER (DECL_NAME (parm)));
6205 warning_with_file_and_line
6206 (current_function_prototype_file,
6207 current_function_prototype_line,
6208 "prototype declaration");
6211 else
6213 error ("argument `%s' doesn't match prototype",
6214 IDENTIFIER_POINTER (DECL_NAME (parm)));
6215 error_with_file_and_line (current_function_prototype_file,
6216 current_function_prototype_line,
6217 "prototype declaration");
6221 TYPE_ACTUAL_ARG_TYPES (TREE_TYPE (fndecl)) = 0;
6224 /* Otherwise, create a prototype that would match. */
6226 else
6228 tree actual = 0, last = 0, type;
6230 for (parm = DECL_ARGUMENTS (fndecl); parm; parm = TREE_CHAIN (parm))
6232 type = tree_cons (NULL_TREE, DECL_ARG_TYPE (parm), NULL_TREE);
6233 if (last)
6234 TREE_CHAIN (last) = type;
6235 else
6236 actual = type;
6237 last = type;
6239 type = tree_cons (NULL_TREE, void_type_node, NULL_TREE);
6240 if (last)
6241 TREE_CHAIN (last) = type;
6242 else
6243 actual = type;
6245 /* We are going to assign a new value for the TYPE_ACTUAL_ARG_TYPES
6246 of the type of this function, but we need to avoid having this
6247 affect the types of other similarly-typed functions, so we must
6248 first force the generation of an identical (but separate) type
6249 node for the relevant function type. The new node we create
6250 will be a variant of the main variant of the original function
6251 type. */
6253 TREE_TYPE (fndecl) = build_type_copy (TREE_TYPE (fndecl));
6255 TYPE_ACTUAL_ARG_TYPES (TREE_TYPE (fndecl)) = actual;
6258 /* Now store the final chain of decls for the arguments
6259 as the decl-chain of the current lexical scope.
6260 Put the enumerators in as well, at the front so that
6261 DECL_ARGUMENTS is not modified. */
6263 storedecls (chainon (nonparms, DECL_ARGUMENTS (fndecl)));
6266 /* Make sure the binding level for the top of the function body
6267 gets a BLOCK if there are any in the function.
6268 Otherwise, the dbx output is wrong. */
6270 keep_next_if_subblocks = 1;
6272 /* ??? This might be an improvement,
6273 but needs to be thought about some more. */
6274 #if 0
6275 keep_next_level_flag = 1;
6276 #endif
6278 /* Write a record describing this function definition to the prototypes
6279 file (if requested). */
6281 gen_aux_info_record (fndecl, 1, 0, prototype);
6283 /* Initialize the RTL code for the function. */
6284 init_function_start (fndecl, input_filename, lineno);
6286 /* Begin the statement tree for this function. */
6287 begin_stmt_tree (&DECL_SAVED_TREE (current_function_decl));
6289 /* If this is a nested function, save away the sizes of any
6290 variable-size types so that we can expand them when generating
6291 RTL. */
6292 if (context)
6294 tree t;
6296 DECL_LANG_SPECIFIC (fndecl)->pending_sizes
6297 = nreverse (get_pending_sizes ());
6298 for (t = DECL_LANG_SPECIFIC (fndecl)->pending_sizes;
6300 t = TREE_CHAIN (t))
6301 SAVE_EXPR_CONTEXT (TREE_VALUE (t)) = context;
6304 /* This function is being processed in whole-function mode. */
6305 cfun->x_whole_function_mode_p = 1;
6307 /* Even though we're inside a function body, we still don't want to
6308 call expand_expr to calculate the size of a variable-sized array.
6309 We haven't necessarily assigned RTL to all variables yet, so it's
6310 not safe to try to expand expressions involving them. */
6311 immediate_size_expand = 0;
6312 cfun->x_dont_save_pending_sizes_p = 1;
6314 warn_shadow = saved_warn_shadow;
6317 /* Finish up a function declaration and compile that function
6318 all the way to assembler language output. The free the storage
6319 for the function definition.
6321 This is called after parsing the body of the function definition.
6323 NESTED is nonzero if the function being finished is nested in another.
6324 CAN_DEFER_P is nonzero if the function may be deferred. */
6326 void
6327 finish_function (nested, can_defer_p)
6328 int nested;
6329 int can_defer_p;
6331 tree fndecl = current_function_decl;
6333 #if 0
6334 /* This caused &foo to be of type ptr-to-const-function which then
6335 got a warning when stored in a ptr-to-function variable. */
6336 TREE_READONLY (fndecl) = 1;
6337 #endif
6339 poplevel (1, 0, 1);
6340 BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl)) = fndecl;
6342 /* Must mark the RESULT_DECL as being in this function. */
6344 DECL_CONTEXT (DECL_RESULT (fndecl)) = fndecl;
6346 if (MAIN_NAME_P (DECL_NAME (fndecl)) && flag_hosted)
6348 if (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (fndecl)))
6349 != integer_type_node)
6351 /* If warn_main is 1 (-Wmain) or 2 (-Wall), we have already warned.
6352 If warn_main is -1 (-Wno-main) we don't want to be warned. */
6353 if (! warn_main)
6354 pedwarn_with_decl (fndecl, "return type of `%s' is not `int'");
6356 else
6358 #ifdef DEFAULT_MAIN_RETURN
6359 /* Make it so that `main' always returns success by default. */
6360 DEFAULT_MAIN_RETURN;
6361 #else
6362 if (flag_isoc99)
6363 c_expand_return (integer_zero_node);
6364 #endif
6368 finish_fname_decls ();
6370 /* Tie off the statement tree for this function. */
6371 finish_stmt_tree (&DECL_SAVED_TREE (fndecl));
6373 /* Complain if there's just no return statement. */
6374 if (warn_return_type
6375 && TREE_CODE (TREE_TYPE (TREE_TYPE (fndecl))) != VOID_TYPE
6376 && !current_function_returns_value && !current_function_returns_null
6377 /* Don't complain if we abort. */
6378 && !current_function_returns_abnormally
6379 /* Don't warn for main(). */
6380 && !MAIN_NAME_P (DECL_NAME (fndecl))
6381 /* Or if they didn't actually specify a return type. */
6382 && !C_FUNCTION_IMPLICIT_INT (fndecl)
6383 /* Normally, with -Wreturn-type, flow will complain. Unless we're an
6384 inline function, as we might never be compiled separately. */
6385 && DECL_INLINE (fndecl))
6386 warning ("no return statement in function returning non-void");
6388 /* Clear out memory we no longer need. */
6389 free_after_parsing (cfun);
6390 /* Since we never call rest_of_compilation, we never clear
6391 CFUN. Do so explicitly. */
6392 free_after_compilation (cfun);
6393 cfun = NULL;
6395 if (! nested)
6397 /* Generate RTL for the body of this function. */
6398 c_expand_body (fndecl, nested, can_defer_p);
6400 /* Let the error reporting routines know that we're outside a
6401 function. For a nested function, this value is used in
6402 c_pop_function_context and then reset via pop_function_context. */
6403 current_function_decl = NULL;
6407 /* Generate the RTL for a deferred function FNDECL. */
6409 void
6410 c_expand_deferred_function (fndecl)
6411 tree fndecl;
6413 /* DECL_INLINE or DECL_RESULT might got cleared after the inline
6414 function was deferred, e.g. in duplicate_decls. */
6415 if (DECL_INLINE (fndecl) && DECL_RESULT (fndecl))
6417 c_expand_body (fndecl, 0, 0);
6418 current_function_decl = NULL;
6422 /* Generate the RTL for the body of FNDECL. If NESTED_P is nonzero,
6423 then we are already in the process of generating RTL for another
6424 function. If can_defer_p is zero, we won't attempt to defer the
6425 generation of RTL. */
6427 static void
6428 c_expand_body (fndecl, nested_p, can_defer_p)
6429 tree fndecl;
6430 int nested_p, can_defer_p;
6432 int uninlinable = 1;
6434 /* There's no reason to do any of the work here if we're only doing
6435 semantic analysis; this code just generates RTL. */
6436 if (flag_syntax_only)
6437 return;
6439 if (flag_inline_trees)
6441 /* First, cache whether the current function is inlinable. Some
6442 predicates depend on cfun and current_function_decl to
6443 function completely. */
6444 timevar_push (TV_INTEGRATION);
6445 uninlinable = ! tree_inlinable_function_p (fndecl);
6447 if (! uninlinable && can_defer_p
6448 /* Save function tree for inlining. Should return 0 if the
6449 language does not support function deferring or the
6450 function could not be deferred. */
6451 && defer_fn (fndecl))
6453 /* Let the back-end know that this function exists. */
6454 (*debug_hooks->deferred_inline_function) (fndecl);
6455 timevar_pop (TV_INTEGRATION);
6456 return;
6459 /* Then, inline any functions called in it. */
6460 optimize_inline_calls (fndecl);
6461 timevar_pop (TV_INTEGRATION);
6464 timevar_push (TV_EXPAND);
6466 if (nested_p)
6468 /* Make sure that we will evaluate variable-sized types involved
6469 in our function's type. */
6470 expand_pending_sizes (DECL_LANG_SPECIFIC (fndecl)->pending_sizes);
6471 /* Squirrel away our current state. */
6472 push_function_context ();
6475 /* Initialize the RTL code for the function. */
6476 current_function_decl = fndecl;
6477 input_filename = DECL_SOURCE_FILE (fndecl);
6478 init_function_start (fndecl, input_filename, DECL_SOURCE_LINE (fndecl));
6480 /* This function is being processed in whole-function mode. */
6481 cfun->x_whole_function_mode_p = 1;
6483 /* Even though we're inside a function body, we still don't want to
6484 call expand_expr to calculate the size of a variable-sized array.
6485 We haven't necessarily assigned RTL to all variables yet, so it's
6486 not safe to try to expand expressions involving them. */
6487 immediate_size_expand = 0;
6488 cfun->x_dont_save_pending_sizes_p = 1;
6490 /* Set up parameters and prepare for return, for the function. */
6491 expand_function_start (fndecl, 0);
6493 /* If this function is `main', emit a call to `__main'
6494 to run global initializers, etc. */
6495 if (DECL_NAME (fndecl)
6496 && MAIN_NAME_P (DECL_NAME (fndecl))
6497 && DECL_CONTEXT (fndecl) == NULL_TREE)
6498 expand_main_function ();
6500 /* Generate the RTL for this function. */
6501 expand_stmt (DECL_SAVED_TREE (fndecl));
6502 if (uninlinable)
6504 /* Allow the body of the function to be garbage collected. */
6505 DECL_SAVED_TREE (fndecl) = NULL_TREE;
6508 /* We hard-wired immediate_size_expand to zero above.
6509 expand_function_end will decrement this variable. So, we set the
6510 variable to one here, so that after the decrement it will remain
6511 zero. */
6512 immediate_size_expand = 1;
6514 /* Allow language dialects to perform special processing. */
6515 if (lang_expand_function_end)
6516 (*lang_expand_function_end) ();
6518 /* Generate rtl for function exit. */
6519 expand_function_end (input_filename, lineno, 0);
6521 /* If this is a nested function, protect the local variables in the stack
6522 above us from being collected while we're compiling this function. */
6523 if (nested_p)
6524 ggc_push_context ();
6526 /* Run the optimizers and output the assembler code for this function. */
6527 rest_of_compilation (fndecl);
6529 /* Undo the GC context switch. */
6530 if (nested_p)
6531 ggc_pop_context ();
6533 /* With just -W, complain only if function returns both with
6534 and without a value. */
6535 if (extra_warnings
6536 && current_function_returns_value
6537 && current_function_returns_null)
6538 warning ("this function may return with or without a value");
6540 /* If requested, warn about function definitions where the function will
6541 return a value (usually of some struct or union type) which itself will
6542 take up a lot of stack space. */
6544 if (warn_larger_than && !DECL_EXTERNAL (fndecl) && TREE_TYPE (fndecl))
6546 tree ret_type = TREE_TYPE (TREE_TYPE (fndecl));
6548 if (ret_type && TYPE_SIZE_UNIT (ret_type)
6549 && TREE_CODE (TYPE_SIZE_UNIT (ret_type)) == INTEGER_CST
6550 && 0 < compare_tree_int (TYPE_SIZE_UNIT (ret_type),
6551 larger_than_size))
6553 unsigned int size_as_int
6554 = TREE_INT_CST_LOW (TYPE_SIZE_UNIT (ret_type));
6556 if (compare_tree_int (TYPE_SIZE_UNIT (ret_type), size_as_int) == 0)
6557 warning_with_decl (fndecl,
6558 "size of return value of `%s' is %u bytes",
6559 size_as_int);
6560 else
6561 warning_with_decl (fndecl,
6562 "size of return value of `%s' is larger than %d bytes",
6563 larger_than_size);
6567 if (DECL_SAVED_INSNS (fndecl) == 0 && ! nested_p
6568 && ! flag_inline_trees)
6570 /* Stop pointing to the local nodes about to be freed.
6571 But DECL_INITIAL must remain nonzero so we know this
6572 was an actual function definition.
6573 For a nested function, this is done in c_pop_function_context.
6574 If rest_of_compilation set this to 0, leave it 0. */
6575 if (DECL_INITIAL (fndecl) != 0)
6576 DECL_INITIAL (fndecl) = error_mark_node;
6578 DECL_ARGUMENTS (fndecl) = 0;
6581 if (DECL_STATIC_CONSTRUCTOR (fndecl))
6583 if (targetm.have_ctors_dtors)
6584 (* targetm.asm_out.constructor) (XEXP (DECL_RTL (fndecl), 0),
6585 DEFAULT_INIT_PRIORITY);
6586 else
6587 static_ctors = tree_cons (NULL_TREE, fndecl, static_ctors);
6590 if (DECL_STATIC_DESTRUCTOR (fndecl))
6592 if (targetm.have_ctors_dtors)
6593 (* targetm.asm_out.destructor) (XEXP (DECL_RTL (fndecl), 0),
6594 DEFAULT_INIT_PRIORITY);
6595 else
6596 static_dtors = tree_cons (NULL_TREE, fndecl, static_dtors);
6599 if (nested_p)
6600 /* Return to the enclosing function. */
6601 pop_function_context ();
6602 timevar_pop (TV_EXPAND);
6605 /* Check the declarations given in a for-loop for satisfying the C99
6606 constraints. */
6607 void
6608 check_for_loop_decls ()
6610 tree t;
6612 if (!flag_isoc99)
6614 /* If we get here, declarations have been used in a for loop without
6615 the C99 for loop scope. This doesn't make much sense, so don't
6616 allow it. */
6617 error ("`for' loop initial declaration used outside C99 mode");
6618 return;
6620 /* C99 subclause 6.8.5 paragraph 3:
6622 [#3] The declaration part of a for statement shall only
6623 declare identifiers for objects having storage class auto or
6624 register.
6626 It isn't clear whether, in this sentence, "identifiers" binds to
6627 "shall only declare" or to "objects" - that is, whether all identifiers
6628 declared must be identifiers for objects, or whether the restriction
6629 only applies to those that are. (A question on this in comp.std.c
6630 in November 2000 received no answer.) We implement the strictest
6631 interpretation, to avoid creating an extension which later causes
6632 problems. */
6634 for (t = gettags (); t; t = TREE_CHAIN (t))
6636 if (TREE_PURPOSE (t) != 0)
6638 enum tree_code code = TREE_CODE (TREE_VALUE (t));
6640 if (code == RECORD_TYPE)
6641 error ("`struct %s' declared in `for' loop initial declaration",
6642 IDENTIFIER_POINTER (TREE_PURPOSE (t)));
6643 else if (code == UNION_TYPE)
6644 error ("`union %s' declared in `for' loop initial declaration",
6645 IDENTIFIER_POINTER (TREE_PURPOSE (t)));
6646 else
6647 error ("`enum %s' declared in `for' loop initial declaration",
6648 IDENTIFIER_POINTER (TREE_PURPOSE (t)));
6652 for (t = getdecls (); t; t = TREE_CHAIN (t))
6654 if (TREE_CODE (t) != VAR_DECL && DECL_NAME (t))
6655 error_with_decl (t, "declaration of non-variable `%s' in `for' loop initial declaration");
6656 else if (TREE_STATIC (t))
6657 error_with_decl (t, "declaration of static variable `%s' in `for' loop initial declaration");
6658 else if (DECL_EXTERNAL (t))
6659 error_with_decl (t, "declaration of `extern' variable `%s' in `for' loop initial declaration");
6663 /* Save and restore the variables in this file and elsewhere
6664 that keep track of the progress of compilation of the current function.
6665 Used for nested functions. */
6667 struct language_function GTY(())
6669 struct c_language_function base;
6670 tree named_labels;
6671 tree shadowed_labels;
6672 int returns_value;
6673 int returns_null;
6674 int returns_abnormally;
6675 int warn_about_return_type;
6676 int extern_inline;
6677 struct binding_level *binding_level;
6680 /* Save and reinitialize the variables
6681 used during compilation of a C function. */
6683 void
6684 c_push_function_context (f)
6685 struct function *f;
6687 struct language_function *p;
6688 p = ((struct language_function *)
6689 ggc_alloc (sizeof (struct language_function)));
6690 f->language = p;
6692 p->base.x_stmt_tree = c_stmt_tree;
6693 p->base.x_scope_stmt_stack = c_scope_stmt_stack;
6694 p->named_labels = named_labels;
6695 p->shadowed_labels = shadowed_labels;
6696 p->returns_value = current_function_returns_value;
6697 p->returns_null = current_function_returns_null;
6698 p->returns_abnormally = current_function_returns_abnormally;
6699 p->warn_about_return_type = warn_about_return_type;
6700 p->extern_inline = current_extern_inline;
6701 p->binding_level = current_binding_level;
6704 /* Restore the variables used during compilation of a C function. */
6706 void
6707 c_pop_function_context (f)
6708 struct function *f;
6710 struct language_function *p = f->language;
6711 tree link;
6713 /* Bring back all the labels that were shadowed. */
6714 for (link = shadowed_labels; link; link = TREE_CHAIN (link))
6715 if (DECL_NAME (TREE_VALUE (link)) != 0)
6716 IDENTIFIER_LABEL_VALUE (DECL_NAME (TREE_VALUE (link)))
6717 = TREE_VALUE (link);
6719 if (DECL_SAVED_INSNS (current_function_decl) == 0
6720 && DECL_SAVED_TREE (current_function_decl) == NULL_TREE)
6722 /* Stop pointing to the local nodes about to be freed. */
6723 /* But DECL_INITIAL must remain nonzero so we know this
6724 was an actual function definition. */
6725 DECL_INITIAL (current_function_decl) = error_mark_node;
6726 DECL_ARGUMENTS (current_function_decl) = 0;
6729 c_stmt_tree = p->base.x_stmt_tree;
6730 c_scope_stmt_stack = p->base.x_scope_stmt_stack;
6731 named_labels = p->named_labels;
6732 shadowed_labels = p->shadowed_labels;
6733 current_function_returns_value = p->returns_value;
6734 current_function_returns_null = p->returns_null;
6735 current_function_returns_abnormally = p->returns_abnormally;
6736 warn_about_return_type = p->warn_about_return_type;
6737 current_extern_inline = p->extern_inline;
6738 current_binding_level = p->binding_level;
6740 f->language = NULL;
6743 /* Copy the DECL_LANG_SPECIFIC data associated with DECL. */
6745 void
6746 c_dup_lang_specific_decl (decl)
6747 tree decl;
6749 struct lang_decl *ld;
6751 if (!DECL_LANG_SPECIFIC (decl))
6752 return;
6754 ld = (struct lang_decl *) ggc_alloc (sizeof (struct lang_decl));
6755 memcpy ((char *) ld, (char *) DECL_LANG_SPECIFIC (decl),
6756 sizeof (struct lang_decl));
6757 DECL_LANG_SPECIFIC (decl) = ld;
6760 /* The functions below are required for functionality of doing
6761 function at once processing in the C front end. Currently these
6762 functions are not called from anywhere in the C front end, but as
6763 these changes continue, that will change. */
6765 /* Returns nonzero if the current statement is a full expression,
6766 i.e. temporaries created during that statement should be destroyed
6767 at the end of the statement. */
6770 stmts_are_full_exprs_p ()
6772 return 0;
6775 /* Returns the stmt_tree (if any) to which statements are currently
6776 being added. If there is no active statement-tree, NULL is
6777 returned. */
6779 stmt_tree
6780 current_stmt_tree ()
6782 return &c_stmt_tree;
6785 /* Returns the stack of SCOPE_STMTs for the current function. */
6787 tree *
6788 current_scope_stmt_stack ()
6790 return &c_scope_stmt_stack;
6793 /* Nonzero if TYPE is an anonymous union or struct type. Always 0 in
6794 C. */
6797 anon_aggr_type_p (node)
6798 tree node ATTRIBUTE_UNUSED;
6800 return 0;
6803 /* Dummy function in place of callback used by C++. */
6805 void
6806 extract_interface_info ()
6810 /* Return a new COMPOUND_STMT, after adding it to the current
6811 statement tree. */
6813 tree
6814 c_begin_compound_stmt ()
6816 tree stmt;
6818 /* Create the COMPOUND_STMT. */
6819 stmt = add_stmt (build_stmt (COMPOUND_STMT, NULL_TREE));
6821 return stmt;
6824 /* Expand T (a DECL_STMT) if it declares an entity not handled by the
6825 common code. */
6827 void
6828 c_expand_decl_stmt (t)
6829 tree t;
6831 tree decl = DECL_STMT_DECL (t);
6833 /* Expand nested functions. */
6834 if (TREE_CODE (decl) == FUNCTION_DECL
6835 && DECL_CONTEXT (decl) == current_function_decl
6836 && DECL_SAVED_TREE (decl))
6837 c_expand_body (decl, /*nested_p=*/1, /*can_defer_p=*/0);
6840 /* Return the IDENTIFIER_GLOBAL_VALUE of T, for use in common code, since
6841 the definition of IDENTIFIER_GLOBAL_VALUE is different for C and C++. */
6843 tree
6844 identifier_global_value (t)
6845 tree t;
6847 return IDENTIFIER_GLOBAL_VALUE (t);
6850 /* Record a builtin type for C. If NAME is non-NULL, it is the name used;
6851 otherwise the name is found in ridpointers from RID_INDEX. */
6853 void
6854 record_builtin_type (rid_index, name, type)
6855 enum rid rid_index;
6856 const char *name;
6857 tree type;
6859 tree id;
6860 if (name == 0)
6861 id = ridpointers[(int) rid_index];
6862 else
6863 id = get_identifier (name);
6864 pushdecl (build_decl (TYPE_DECL, id, type));
6867 /* Build the void_list_node (void_type_node having been created). */
6868 tree
6869 build_void_list_node ()
6871 tree t = build_tree_list (NULL_TREE, void_type_node);
6872 return t;
6875 /* Return something to represent absolute declarators containing a *.
6876 TARGET is the absolute declarator that the * contains.
6877 TYPE_QUALS_ATTRS is a list of modifiers such as const or volatile
6878 to apply to the pointer type, represented as identifiers, possible mixed
6879 with attributes.
6881 We return an INDIRECT_REF whose "contents" are TARGET (inside a TREE_LIST,
6882 if attributes are present) and whose type is the modifier list. */
6884 tree
6885 make_pointer_declarator (type_quals_attrs, target)
6886 tree type_quals_attrs, target;
6888 tree quals, attrs;
6889 tree itarget = target;
6890 split_specs_attrs (type_quals_attrs, &quals, &attrs);
6891 if (attrs != NULL_TREE)
6892 itarget = tree_cons (attrs, target, NULL_TREE);
6893 return build1 (INDIRECT_REF, quals, itarget);
6896 #include "gt-c-decl.h"