1 /* Process declarations and variables for C compiler.
2 Copyright (C) 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
3 2001, 2002, 2003, 2004 Free Software Foundation, Inc.
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify it under
8 the terms of the GNU General Public License as published by the Free
9 Software Foundation; either version 2, or (at your option) any later
12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING. If not, write to the Free
19 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
22 /* Process declarations and symbol lookup for C front end.
23 Also constructs types; the standard scalar types at initialization,
24 and structure, union, array and enum types when they are declared. */
26 /* ??? not all decl nodes are given the most useful possible
27 line numbers. For example, the CONST_DECLs for enum values. */
31 #include "coretypes.h"
35 #include "tree-inline.h"
56 #include "langhooks-def.h"
58 /* In grokdeclarator, distinguish syntactic contexts of declarators. */
60 { NORMAL
, /* Ordinary declaration */
61 FUNCDEF
, /* Function definition */
62 PARM
, /* Declaration of parm before function body */
63 FIELD
, /* Declaration inside struct or union */
64 TYPENAME
}; /* Typename (inside cast or sizeof) */
67 /* Nonzero if we have seen an invalid cross reference
68 to a struct, union, or enum, but not yet printed the message. */
70 tree pending_invalid_xref
;
71 /* File and line to appear in the eventual error message. */
72 location_t pending_invalid_xref_location
;
74 /* While defining an enum type, this is 1 plus the last enumerator
75 constant value. Note that will do not have to save this or `enum_overflow'
76 around nested function definition since such a definition could only
77 occur in an enum value expression and we don't use these variables in
80 static tree enum_next_value
;
82 /* Nonzero means that there was overflow computing enum_next_value. */
84 static int enum_overflow
;
86 /* Parsing a function declarator leaves a list of parameter names
87 or a chain of parameter decls here. */
89 static tree last_function_parms
;
91 /* ... and a chain of structure and enum types declared in the
94 static tree last_function_parm_tags
;
96 /* ... and a chain of all non-parameter declarations (such as
97 CONST_DECLs from enumerations) here. */
99 static tree last_function_parm_others
;
101 /* After parsing the declarator that starts a function definition,
102 `start_function' puts the list of parameter names or chain of decls here
103 for `store_parm_decls' to find. */
105 static tree current_function_parms
;
107 /* Similar, for last_function_parm_tags. */
109 static tree current_function_parm_tags
;
111 /* And for last_function_parm_others. */
113 static tree current_function_parm_others
;
115 /* Similar, for the file and line that the prototype came from if this is
116 an old-style definition. */
118 static location_t current_function_prototype_locus
;
120 /* The current statement tree. */
122 static GTY(()) struct stmt_tree_s c_stmt_tree
;
124 /* The current scope statement stack. */
126 static GTY(()) tree c_scope_stmt_stack
;
128 /* State saving variables. */
129 int c_in_iteration_stmt
;
132 /* A list of external DECLs that appeared at block scope when there was
133 some other global meaning for that identifier. */
134 static GTY(()) tree truly_local_externals
;
136 /* All the builtins; this is a subset of the entries of global_scope. */
138 static GTY(()) tree first_builtin_decl
;
139 static GTY(()) tree last_builtin_decl
;
141 /* A DECL for the current file-scope context. */
143 static GTY(()) tree current_file_decl
;
145 /* Set to 0 at beginning of a function definition, set to 1 if
146 a return statement that specifies a return value is seen. */
148 int current_function_returns_value
;
150 /* Set to 0 at beginning of a function definition, set to 1 if
151 a return statement with no argument is seen. */
153 int current_function_returns_null
;
155 /* Set to 0 at beginning of a function definition, set to 1 if
156 a call to a noreturn function is seen. */
158 int current_function_returns_abnormally
;
160 /* Set to nonzero by `grokdeclarator' for a function
161 whose return type is defaulted, if warnings for this are desired. */
163 static int warn_about_return_type
;
165 /* Nonzero when starting a function declared `extern inline'. */
167 static int current_extern_inline
;
169 /* Each c_scope structure describes the complete contents of one scope.
170 Three scopes are distinguished specially: the innermost or current
171 scope, the innermost function scope, and the outermost or file scope.
173 Most declarations are recorded in the current scope.
175 All normal label declarations are recorded in the innermost
176 function scope, as are bindings of undeclared identifiers to
177 error_mark_node. (GCC permits nested functions as an extension,
178 hence the 'innermost' qualifier.) Explicitly declared labels
179 (using the __label__ extension) appear in the current scope.
181 Being in the global scope (current_scope == global_scope) causes
182 special behavior in several places below. Also, under some
183 conditions the Objective-C front end records declarations in the
184 global scope even though that isn't the current scope.
186 The order of the names, parms, and blocks lists matters, and they
187 are frequently appended to. To avoid having to walk all the way to
188 the end of the list on each insertion, or reverse the lists later,
189 we maintain a pointer to the last list entry for each of the lists.
191 The order of the tags, shadowed, and shadowed_tags
192 lists does not matter, so we just prepend to these lists. */
194 struct c_scope
GTY(())
196 /* The scope containing this one. */
197 struct c_scope
*outer
;
199 /* The next outermost function scope. */
200 struct c_scope
*outer_function
;
202 /* All variables, constants, functions, labels, and typedef names. */
206 /* All parameter declarations. Used only in the outermost scope of
211 /* All structure, union, and enum type tags. */
214 /* For each scope, a list of shadowed outer-scope definitions
215 to be restored when this scope is popped.
216 Each link is a TREE_LIST whose TREE_PURPOSE is an identifier and
217 whose TREE_VALUE is its old definition (a kind of ..._DECL node). */
220 /* For each scope, a list of shadowed outer-scope tag definitions
221 to be restored when this scope is popped.
222 Each link is a TREE_LIST whose TREE_PURPOSE is an identifier and
223 whose TREE_VALUE is its old definition (a kind of ..._TYPE node). */
226 /* For each scope (except the global one), a chain of BLOCK nodes
227 for all the scopes that were entered and exited one level down. */
231 /* True if we are currently filling this scope with parameter
233 BOOL_BITFIELD parm_flag
: 1;
235 /* True if we already complained about forward parameter decls
236 in this scope. This prevents double warnings on
237 foo (int a; int b; ...) */
238 BOOL_BITFIELD warned_forward_parm_decls
: 1;
240 /* True if this is the outermost block scope of a function body.
241 This scope contains the parameters, the local variables declared
242 in the outermost block, and all the labels (except those in
243 nested functions, or declared at block scope with __label__). */
244 BOOL_BITFIELD function_body
: 1;
246 /* True means make a BLOCK for this scope no matter what. */
247 BOOL_BITFIELD keep
: 1;
250 /* The scope currently in effect. */
252 static GTY(()) struct c_scope
*current_scope
;
254 /* A chain of c_scope structures awaiting reuse. */
256 static GTY((deletable (""))) struct c_scope
*scope_freelist
;
258 /* The innermost function scope. Ordinary (not explicitly declared)
259 labels, bindings to error_mark_node, and the lazily-created
260 bindings of __func__ and its friends get this scope. */
262 static GTY(()) struct c_scope
*current_function_scope
;
264 /* The outermost scope, corresponding to the C "file scope". This is
265 created when the compiler is started and exists through the entire run. */
267 static GTY(()) struct c_scope
*global_scope
;
269 /* Append VAR to LIST in scope SCOPE. */
270 #define SCOPE_LIST_APPEND(scope, list, decl) do { \
271 struct c_scope *s_ = (scope); \
273 if (s_->list##_last) \
274 TREE_CHAIN (s_->list##_last) = d_; \
277 s_->list##_last = d_; \
280 /* Concatenate FROM in scope FSCOPE onto TO in scope TSCOPE. */
281 #define SCOPE_LIST_CONCAT(tscope, to, fscope, from) do { \
282 struct c_scope *t_ = (tscope); \
283 struct c_scope *f_ = (fscope); \
285 TREE_CHAIN (t_->to##_last) = f_->from; \
288 t_->to##_last = f_->from##_last; \
291 /* True means unconditionally make a BLOCK for the next scope pushed. */
293 static bool keep_next_level_flag
;
295 /* True means the next call to pushlevel will be the outermost scope
296 of a function body, so do not push a new scope, merely cease
297 expecting parameter decls. */
299 static bool next_is_function_body
;
301 /* Functions called automatically at the beginning and end of execution. */
303 tree static_ctors
, static_dtors
;
305 /* Forward declarations. */
307 static struct c_scope
*make_scope (void);
308 static void pop_scope (void);
309 static tree
make_label (tree
, location_t
);
310 static void bind_label (tree
, tree
, struct c_scope
*);
311 static void implicit_decl_warning (tree
);
312 static tree
lookup_tag (enum tree_code
, tree
, int);
313 static tree
lookup_name_current_level (tree
);
314 static tree
grokdeclarator (tree
, tree
, enum decl_context
, int, tree
*);
315 static tree
grokparms (tree
, int);
316 static void layout_array_type (tree
);
317 static void store_parm_decls_newstyle (void);
318 static void store_parm_decls_oldstyle (void);
319 static tree
c_make_fname_decl (tree
, int);
320 static void c_expand_body_1 (tree
, int);
321 static tree
any_external_decl (tree
);
322 static void record_external_decl (tree
);
323 static void warn_if_shadowing (tree
, tree
);
324 static void check_bitfield_type_and_width (tree
*, tree
*, const char *);
325 static void clone_underlying_type (tree
);
326 static bool flexible_array_type_p (tree
);
327 static hashval_t
link_hash_hash (const void *);
328 static int link_hash_eq (const void *, const void *);
330 /* States indicating how grokdeclarator() should handle declspecs marked
331 with __attribute__((deprecated)). An object declared as
332 __attribute__((deprecated)) suppresses warnings of uses of other
335 enum deprecated_states
{
340 static enum deprecated_states deprecated_state
= DEPRECATED_NORMAL
;
343 c_print_identifier (FILE *file
, tree node
, int indent
)
345 print_node (file
, "symbol", IDENTIFIER_SYMBOL_VALUE (node
), indent
+ 4);
346 print_node (file
, "tag", IDENTIFIER_TAG_VALUE (node
), indent
+ 4);
347 print_node (file
, "label", IDENTIFIER_LABEL_VALUE (node
), indent
+ 4);
348 if (C_IS_RESERVED_WORD (node
))
350 tree rid
= ridpointers
[C_RID_CODE (node
)];
351 indent_to (file
, indent
+ 4);
352 fprintf (file
, "rid " HOST_PTR_PRINTF
" \"%s\"",
353 (void *) rid
, IDENTIFIER_POINTER (rid
));
357 /* Hook called at end of compilation to assume 1 elt
358 for a file-scope tentative array defn that wasn't complete before. */
361 c_finish_incomplete_decl (tree decl
)
363 if (TREE_CODE (decl
) == VAR_DECL
)
365 tree type
= TREE_TYPE (decl
);
366 if (type
!= error_mark_node
367 && TREE_CODE (type
) == ARRAY_TYPE
368 && ! DECL_EXTERNAL (decl
)
369 && TYPE_DOMAIN (type
) == 0)
371 warning ("%Jarray '%D' assumed to have one element", decl
, decl
);
373 complete_array_type (type
, NULL_TREE
, 1);
375 layout_decl (decl
, 0);
380 /* Reuse or create a struct for this scope. */
382 static struct c_scope
*
385 struct c_scope
*result
;
388 result
= scope_freelist
;
389 scope_freelist
= result
->outer
;
392 result
= ggc_alloc_cleared (sizeof (struct c_scope
));
397 /* Remove the topmost scope from the stack and add it to the
398 free list, updating current_function_scope if necessary. */
403 struct c_scope
*scope
= current_scope
;
405 current_scope
= scope
->outer
;
406 if (scope
->function_body
)
407 current_function_scope
= scope
->outer_function
;
409 memset (scope
, 0, sizeof (struct c_scope
));
410 scope
->outer
= scope_freelist
;
411 scope_freelist
= scope
;
414 /* The Objective-C front-end often needs to determine the current scope. */
417 get_current_scope (void)
419 return current_scope
;
422 /* The following function is used only by Objective-C. It needs to live here
423 because it accesses the innards of c_scope. */
426 objc_mark_locals_volatile (void *enclosing_blk
)
428 struct c_scope
*scope
;
430 for (scope
= current_scope
;
431 scope
&& scope
!= enclosing_blk
;
432 scope
= scope
->outer
)
436 for (decl
= scope
->names
; decl
; decl
= TREE_CHAIN (decl
))
438 DECL_REGISTER (decl
) = 0;
439 TREE_THIS_VOLATILE (decl
) = 1;
441 /* Do not climb up past the current function. */
442 if (scope
->function_body
)
447 /* Nonzero if we are currently in the global scope. */
450 global_bindings_p (void)
452 return current_scope
== global_scope
;
456 keep_next_level (void)
458 keep_next_level_flag
= true;
461 /* Identify this scope as currently being filled with parameters. */
464 declare_parm_level (void)
466 current_scope
->parm_flag
= true;
469 /* Nonzero if currently making parm declarations. */
472 in_parm_level_p (void)
474 return current_scope
->parm_flag
;
477 /* Enter a new scope. The dummy parameter is for signature
478 compatibility with lang_hooks.decls.pushlevel. */
481 pushlevel (int dummy ATTRIBUTE_UNUSED
)
483 if (next_is_function_body
)
485 /* This is the transition from the parameters to the top level
486 of the function body. These are the same scope
487 (C99 6.2.1p4,6) so we do not push another scope structure.
488 next_is_function_body is set only by store_parm_decls, which
489 in turn is called when and only when we are about to
490 encounter the opening curly brace for the function body.
492 The outermost block of a function always gets a BLOCK node,
493 because the debugging output routines expect that each
494 function has at least one BLOCK. */
495 current_scope
->parm_flag
= false;
496 current_scope
->function_body
= true;
497 current_scope
->keep
= true;
498 current_scope
->outer_function
= current_function_scope
;
499 current_function_scope
= current_scope
;
501 keep_next_level_flag
= false;
502 next_is_function_body
= false;
506 struct c_scope
*scope
= make_scope ();
508 scope
->keep
= keep_next_level_flag
;
509 scope
->outer
= current_scope
;
510 current_scope
= scope
;
511 keep_next_level_flag
= false;
515 /* Exit a scope. Restore the state of the identifier-decl mappings
516 that were in effect when this scope was entered.
518 If KEEP is KEEP_YES (1), this scope had explicit declarations, so
519 create a BLOCK node to record its declarations and subblocks for
520 debugging output. If KEEP is KEEP_MAYBE, do so only if the names
521 or tags lists are nonempty.
523 The second parameter is ignored; it is present only for
524 signature compatibility with lang_hooks.decls.poplevel.
526 If FUNCTIONBODY is nonzero, this level is the body of a function,
527 even if current_scope->function_body is not set. This is used
528 by language-independent code that generates synthetic functions,
529 and cannot set current_scope->function_body.
531 FIXME: Eliminate the need for all arguments. */
534 poplevel (int keep
, int dummy ATTRIBUTE_UNUSED
, int functionbody
)
536 struct c_scope
*scope
= current_scope
;
541 /* The following line does not use |= due to a bug in HP's C compiler. */
542 scope
->function_body
= scope
->function_body
| functionbody
;
544 if (keep
== KEEP_MAYBE
)
545 keep
= (scope
->names
|| scope
->tags
);
548 keep
|= scope
->function_body
;
550 /* If appropriate, create a BLOCK to record the decls for the life
555 block
= make_node (BLOCK
);
556 BLOCK_VARS (block
) = scope
->names
;
557 BLOCK_SUBBLOCKS (block
) = scope
->blocks
;
558 TREE_USED (block
) = 1;
561 /* In each subblock, record that this is its superior. */
562 for (p
= scope
->blocks
; p
; p
= TREE_CHAIN (p
))
563 BLOCK_SUPERCONTEXT (p
) = block
;
565 /* Clear out the variable bindings in this scope.
567 Propagate TREE_ADDRESSABLE from nested functions to their
568 containing functions.
570 Issue warnings for unused variables and labels, and errors for
571 undefined labels, if there are any. */
573 for (p
= scope
->names
; p
; p
= TREE_CHAIN (p
))
575 switch (TREE_CODE (p
))
578 if (TREE_USED (p
) && !DECL_INITIAL (p
))
580 error ("%Jlabel `%D' used but not defined", p
, p
);
581 DECL_INITIAL (p
) = error_mark_node
;
583 else if (!TREE_USED (p
) && warn_unused_label
)
585 if (DECL_INITIAL (p
))
586 warning ("%Jlabel `%D' defined but not used", p
, p
);
588 warning ("%Jlabel `%D' declared but not defined", p
, p
);
591 IDENTIFIER_LABEL_VALUE (DECL_NAME (p
)) = 0;
595 if (! TREE_ASM_WRITTEN (p
)
596 && DECL_INITIAL (p
) != 0
597 && TREE_ADDRESSABLE (p
)
598 && DECL_ABSTRACT_ORIGIN (p
) != 0
599 && DECL_ABSTRACT_ORIGIN (p
) != p
)
600 TREE_ADDRESSABLE (DECL_ABSTRACT_ORIGIN (p
)) = 1;
604 /* Keep this in sync with stmt.c:warn_about_unused_variables.
605 No warnings when the global scope is popped because the
606 global scope isn't popped for the last translation unit,
607 so the warnings are done in c_write_global_declaration. */
608 if (warn_unused_variable
&& scope
!= global_scope
610 && !DECL_IN_SYSTEM_HEADER (p
)
612 && !DECL_ARTIFICIAL (p
))
613 warning ("%Junused variable `%D'", p
, p
);
620 if (DECL_EXTERNAL (p
) && scope
!= global_scope
)
621 /* External decls stay in the symbol-value slot but are
623 C_DECL_INVISIBLE (p
) = 1;
625 IDENTIFIER_SYMBOL_VALUE (DECL_NAME (p
)) = 0;
631 /* Clear out the parameter bindings in this scope, if any.
632 Unused-parameter warnings are handled by function.c. */
633 for (p
= scope
->parms
; p
; p
= TREE_CHAIN (p
))
635 IDENTIFIER_SYMBOL_VALUE (DECL_NAME (p
)) = 0;
637 /* Clear out the tag-meanings declared in this scope.
639 Set the TYPE_CONTEXTs for all of the tagged types belonging to
640 this scope so that they point to the appropriate construct, i.e.
641 either to the current FUNCTION_DECL node, or else to the BLOCK
642 node we just constructed.
644 Note that for tagged types whose scope is just the formal
645 parameter list for some function type specification, we can't
646 properly set their TYPE_CONTEXTs here, because we don't have a
647 pointer to the appropriate FUNCTION_TYPE node readily available
648 to us. For those cases, the TYPE_CONTEXTs of the relevant tagged
649 type nodes get set in `grokdeclarator' as soon as we have created
650 the FUNCTION_TYPE node which will represent the "scope" for these
651 "parameter list local" tagged types. */
653 decl
= scope
->function_body
? current_function_decl
: block
;
654 for (p
= scope
->tags
; p
; p
= TREE_CHAIN (p
))
656 if (TREE_PURPOSE (p
))
657 IDENTIFIER_TAG_VALUE (TREE_PURPOSE (p
)) = 0;
659 TYPE_CONTEXT (TREE_VALUE (p
)) = decl
;
662 /* Restore all name- and label-meanings from outer scopes that were
663 shadowed by this scope. */
664 for (p
= scope
->shadowed
; p
; p
= TREE_CHAIN (p
))
665 if (TREE_VALUE (p
) && TREE_CODE (TREE_VALUE (p
)) == LABEL_DECL
)
666 IDENTIFIER_LABEL_VALUE (TREE_PURPOSE (p
)) = TREE_VALUE (p
);
668 IDENTIFIER_SYMBOL_VALUE (TREE_PURPOSE (p
)) = TREE_VALUE (p
);
670 /* Restore all tag-meanings from outer scopes that were shadowed by
672 for (p
= scope
->shadowed_tags
; p
; p
= TREE_CHAIN (p
))
673 IDENTIFIER_TAG_VALUE (TREE_PURPOSE (p
)) = TREE_VALUE (p
);
675 /* Dispose of the block that we just made inside some higher level. */
676 if (scope
->function_body
&& current_function_decl
)
677 DECL_INITIAL (current_function_decl
) = block
;
678 else if (scope
->outer
)
681 SCOPE_LIST_APPEND (scope
->outer
, blocks
, block
);
682 /* If we did not make a block for the scope just exited, any
683 blocks made for inner scopes must be carried forward so they
684 will later become subblocks of something else. */
685 else if (scope
->blocks
)
686 SCOPE_LIST_CONCAT (scope
->outer
, blocks
, scope
, blocks
);
689 /* Pop the current scope, and free the structure for reuse. */
695 /* Insert BLOCK at the end of the list of subblocks of the current
696 scope. This is used when a BIND_EXPR is expanded, to handle the
697 BLOCK node inside the BIND_EXPR. */
700 insert_block (tree block
)
702 TREE_USED (block
) = 1;
703 SCOPE_LIST_APPEND (current_scope
, blocks
, block
);
706 /* Set the BLOCK node for the innermost scope (the one we are
707 currently in). The RTL expansion machinery requires us to provide
708 this hook, but it is not useful in function-at-a-time mode. */
711 set_block (tree block ATTRIBUTE_UNUSED
)
715 /* Push a definition or a declaration of struct, union or enum tag "name".
716 "type" should be the type node.
717 We assume that the tag "name" is not already defined.
719 Note that the definition may really be just a forward reference.
720 In that case, the TYPE_SIZE will be zero. */
723 pushtag (tree name
, tree type
)
725 struct c_scope
*b
= current_scope
;
727 /* Record the identifier as the type's name if it has none. */
730 if (TYPE_NAME (type
) == 0)
731 TYPE_NAME (type
) = name
;
733 if (IDENTIFIER_TAG_VALUE (name
))
734 b
->shadowed_tags
= tree_cons (name
, IDENTIFIER_TAG_VALUE (name
),
736 IDENTIFIER_TAG_VALUE (name
) = type
;
739 b
->tags
= tree_cons (name
, type
, b
->tags
);
741 /* Create a fake NULL-named TYPE_DECL node whose TREE_TYPE will be the
742 tagged type we just added to the current scope. This fake
743 NULL-named TYPE_DECL node helps dwarfout.c to know when it needs
744 to output a representation of a tagged type, and it also gives
745 us a convenient place to record the "scope start" address for the
748 TYPE_STUB_DECL (type
) = pushdecl (build_decl (TYPE_DECL
, NULL_TREE
, type
));
750 /* An approximation for now, so we can tell this is a function-scope tag.
751 This will be updated in poplevel. */
752 TYPE_CONTEXT (type
) = DECL_CONTEXT (TYPE_STUB_DECL (type
));
755 /* Subroutine of compare_decls. Allow harmless mismatches in return
756 and argument types provided that the type modes match. This function
757 return a unified type given a suitable match, and 0 otherwise. */
760 match_builtin_function_types (tree newtype
, tree oldtype
)
762 tree newrettype
, oldrettype
;
763 tree newargs
, oldargs
;
764 tree trytype
, tryargs
;
766 /* Accept the return type of the new declaration if same modes. */
767 oldrettype
= TREE_TYPE (oldtype
);
768 newrettype
= TREE_TYPE (newtype
);
770 if (TYPE_MODE (oldrettype
) != TYPE_MODE (newrettype
))
773 oldargs
= TYPE_ARG_TYPES (oldtype
);
774 newargs
= TYPE_ARG_TYPES (newtype
);
777 while (oldargs
|| newargs
)
781 || ! TREE_VALUE (oldargs
)
782 || ! TREE_VALUE (newargs
)
783 || TYPE_MODE (TREE_VALUE (oldargs
))
784 != TYPE_MODE (TREE_VALUE (newargs
)))
787 oldargs
= TREE_CHAIN (oldargs
);
788 newargs
= TREE_CHAIN (newargs
);
791 trytype
= build_function_type (newrettype
, tryargs
);
792 return build_type_attribute_variant (trytype
, TYPE_ATTRIBUTES (oldtype
));
795 /* Subroutine of diagnose_mismatched_decls. Check for function type
796 mismatch involving an empty arglist vs a nonempty one and give clearer
799 diagnose_arglist_conflict (tree newdecl
, tree olddecl
,
800 tree newtype
, tree oldtype
)
804 if (TREE_CODE (olddecl
) != FUNCTION_DECL
805 || !comptypes (TREE_TYPE (oldtype
), TREE_TYPE (newtype
), COMPARE_STRICT
)
806 || !((TYPE_ARG_TYPES (oldtype
) == 0 && DECL_INITIAL (olddecl
) == 0)
808 (TYPE_ARG_TYPES (newtype
) == 0 && DECL_INITIAL (newdecl
) == 0)))
811 t
= TYPE_ARG_TYPES (oldtype
);
813 t
= TYPE_ARG_TYPES (newtype
);
814 for (; t
; t
= TREE_CHAIN (t
))
816 tree type
= TREE_VALUE (t
);
818 if (TREE_CHAIN (t
) == 0
819 && TYPE_MAIN_VARIANT (type
) != void_type_node
)
821 inform ("a parameter list with an ellipsis can't match "
822 "an empty parameter name list declaration");
826 if (c_type_promotes_to (type
) != type
)
828 inform ("an argument type that has a default promotion can't match "
829 "an empty parameter name list declaration");
835 /* Another subroutine of diagnose_mismatched_decls. OLDDECL is an
836 old-style function definition, NEWDECL is a prototype declaration.
837 Diagnose inconsistencies in the argument list. Returns TRUE if
838 the prototype is compatible, FALSE if not. */
840 validate_proto_after_old_defn (tree newdecl
, tree newtype
, tree oldtype
)
842 tree newargs
, oldargs
;
845 /* ??? Elsewhere TYPE_MAIN_VARIANT is not used in this context. */
846 #define END_OF_ARGLIST(t) (TYPE_MAIN_VARIANT (t) == void_type_node)
848 oldargs
= TYPE_ACTUAL_ARG_TYPES (oldtype
);
849 newargs
= TYPE_ARG_TYPES (newtype
);
854 tree oldargtype
= TREE_VALUE (oldargs
);
855 tree newargtype
= TREE_VALUE (newargs
);
857 if (END_OF_ARGLIST (oldargtype
) && END_OF_ARGLIST (newargtype
))
860 /* Reaching the end of just one list means the two decls don't
861 agree on the number of arguments. */
862 if (END_OF_ARGLIST (oldargtype
))
864 error ("%Jprototype for '%D' declares more arguments "
865 "than previous old-style definition", newdecl
, newdecl
);
868 else if (END_OF_ARGLIST (newargtype
))
870 error ("%Jprototype for '%D' declares fewer arguments "
871 "than previous old-style definition", newdecl
, newdecl
);
875 /* Type for passing arg must be consistent with that declared
877 else if (! comptypes (oldargtype
, newargtype
, COMPARE_STRICT
))
879 error ("%Jprototype for '%D' declares arg %d with incompatible type",
880 newdecl
, newdecl
, i
);
884 oldargs
= TREE_CHAIN (oldargs
);
885 newargs
= TREE_CHAIN (newargs
);
889 /* If we get here, no errors were found, but do issue a warning
890 for this poor-style construct. */
891 warning ("%Jprototype for '%D' follows non-prototype definition",
894 #undef END_OF_ARGLIST
897 /* Subroutine of diagnose_mismatched_decls. Report the location of DECL,
898 first in a pair of mismatched declarations, using the diagnostic
901 locate_old_decl (tree decl
, void (*diag
)(const char *, ...))
903 if (TREE_CODE (decl
) == FUNCTION_DECL
&& DECL_BUILT_IN (decl
))
905 else if (DECL_INITIAL (decl
))
906 diag (N_("%Jprevious definition of '%D' was here"), decl
, decl
);
907 else if (C_DECL_IMPLICIT (decl
))
908 diag (N_("%Jprevious implicit declaration of '%D' was here"), decl
, decl
);
910 diag (N_("%Jprevious declaration of '%D' was here"), decl
, decl
);
913 /* Subroutine of duplicate_decls. Compare NEWDECL to OLDDECL.
914 Returns true if the caller should proceed to merge the two, false
915 if OLDDECL should simply be discarded. As a side effect, issues
916 all necessary diagnostics for invalid or poor-style combinations.
917 If it returns true, writes the types of NEWDECL and OLDDECL to
918 *NEWTYPEP and *OLDTYPEP - these may have been adjusted from
919 TREE_TYPE (NEWDECL, OLDDECL) respectively. */
922 diagnose_mismatched_decls (tree newdecl
, tree olddecl
,
923 tree
*newtypep
, tree
*oldtypep
)
925 tree newtype
, oldtype
;
926 bool pedwarned
= false;
929 /* If we have error_mark_node for either decl or type, just discard
930 the previous decl - we're in an error cascade already. */
931 if (olddecl
== error_mark_node
|| newdecl
== error_mark_node
)
933 *oldtypep
= oldtype
= TREE_TYPE (olddecl
);
934 *newtypep
= newtype
= TREE_TYPE (newdecl
);
935 if (oldtype
== error_mark_node
|| newtype
== error_mark_node
)
938 /* Two different categories of symbol altogether. This is an error
939 unless OLDDECL is a builtin. OLDDECL will be discarded in any case. */
940 if (TREE_CODE (olddecl
) != TREE_CODE (newdecl
))
942 if (TREE_CODE (olddecl
) != FUNCTION_DECL
943 || !DECL_BUILT_IN (olddecl
) || !C_DECL_INVISIBLE (olddecl
))
945 error ("%J'%D' redeclared as different kind of symbol",
947 locate_old_decl (olddecl
, error
);
949 else if (TREE_PUBLIC (newdecl
))
950 warning ("%Jbuilt-in function '%D' declared as non-function",
952 else if (warn_shadow
)
953 warning ("%Jshadowing built-in function '%D'",
958 if (!comptypes (oldtype
, newtype
, COMPARE_STRICT
))
960 if (TREE_CODE (olddecl
) == FUNCTION_DECL
961 && DECL_BUILT_IN (olddecl
) && C_DECL_INVISIBLE (olddecl
))
963 /* Accept harmless mismatch in function types.
964 This is for the ffs and fprintf builtins. */
965 tree trytype
= match_builtin_function_types (newtype
, oldtype
);
967 if (trytype
&& comptypes (newtype
, trytype
, COMPARE_STRICT
))
968 *oldtypep
= oldtype
= trytype
;
971 /* If types don't match for a built-in, throw away the
972 built-in. No point in calling locate_old_decl here, it
973 won't print anything. */
974 warning ("%Jconflicting types for built-in function '%D'",
979 else if (TREE_CODE (olddecl
) == FUNCTION_DECL
980 && DECL_SOURCE_LINE (olddecl
) == 0)
982 /* A conflicting function declaration for a predeclared
983 function that isn't actually built in. Objective C uses
984 these. The new declaration silently overrides everything
985 but the volatility (i.e. noreturn) indication. See also
986 below. FIXME: Make Objective C use normal builtins. */
987 TREE_THIS_VOLATILE (newdecl
) |= TREE_THIS_VOLATILE (olddecl
);
990 /* Permit void foo (...) to match int foo (...) if the latter is
991 the definition and implicit int was used. See
992 c-torture/compile/920625-2.c. */
993 else if (TREE_CODE (newdecl
) == FUNCTION_DECL
&& DECL_INITIAL (newdecl
)
994 && TYPE_MAIN_VARIANT (TREE_TYPE (oldtype
)) == void_type_node
995 && TYPE_MAIN_VARIANT (TREE_TYPE (newtype
)) == integer_type_node
996 && C_FUNCTION_IMPLICIT_INT (newdecl
))
998 pedwarn ("%Jconflicting types for '%D'", newdecl
, newdecl
);
999 /* Make sure we keep void as the return type. */
1000 TREE_TYPE (newdecl
) = *newtypep
= newtype
= oldtype
;
1001 C_FUNCTION_IMPLICIT_INT (newdecl
) = 0;
1006 error ("%Jconflicting types for '%D'", newdecl
, newdecl
);
1007 diagnose_arglist_conflict (newdecl
, olddecl
, newtype
, oldtype
);
1008 locate_old_decl (olddecl
, error
);
1013 /* Redeclaration of a type is a constraint violation (6.7.2.3p1),
1014 but silently ignore the redeclaration if either is in a system
1015 header. (Conflicting redeclarations were handled above.) */
1016 if (TREE_CODE (newdecl
) == TYPE_DECL
)
1018 if (DECL_IN_SYSTEM_HEADER (newdecl
) || DECL_IN_SYSTEM_HEADER (olddecl
))
1019 return true; /* Allow OLDDECL to continue in use. */
1021 error ("%Jredefinition of typedef '%D'", newdecl
, newdecl
);
1022 locate_old_decl (olddecl
, error
);
1026 /* Function declarations can either be 'static' or 'extern' (no
1027 qualifier is equivalent to 'extern' - C99 6.2.2p5) and therefore
1028 can never conflict with each other on account of linkage (6.2.2p4).
1029 Multiple definitions are not allowed (6.9p3,5) but GCC permits
1030 two definitions if one is 'extern inline' and one is not. The non-
1031 extern-inline definition supersedes the extern-inline definition. */
1032 else if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
1034 /* If you declare a built-in function name as static, or
1035 define the built-in with an old-style definition (so we
1036 can't validate the argument list) the built-in definition is
1037 overridden, but optionally warn this was a bad choice of name. */
1038 if (DECL_BUILT_IN (olddecl
)
1039 && C_DECL_INVISIBLE (olddecl
)
1040 && (!TREE_PUBLIC (newdecl
)
1041 || (DECL_INITIAL (newdecl
)
1042 && !TYPE_ARG_TYPES (TREE_TYPE (newdecl
)))))
1045 warning ("%Jshadowing built-in function '%D'", newdecl
, newdecl
);
1046 /* Discard the old built-in function. */
1050 if (DECL_INITIAL (newdecl
))
1052 if (DECL_INITIAL (olddecl
)
1053 && !(DECL_DECLARED_INLINE_P (olddecl
)
1054 && DECL_EXTERNAL (olddecl
)
1055 && !(DECL_DECLARED_INLINE_P (newdecl
)
1056 && DECL_EXTERNAL (newdecl
))))
1058 error ("%Jredefinition of '%D'", newdecl
, newdecl
);
1059 locate_old_decl (olddecl
, error
);
1063 /* If we have a prototype after an old-style function definition,
1064 the argument types must be checked specially. */
1065 else if (DECL_INITIAL (olddecl
)
1066 && !TYPE_ARG_TYPES (oldtype
) && TYPE_ARG_TYPES (newtype
)
1067 && TYPE_ACTUAL_ARG_TYPES (oldtype
)
1068 && !validate_proto_after_old_defn (newdecl
, newtype
, oldtype
))
1070 locate_old_decl (olddecl
, error
);
1073 /* Mismatched non-static and static is considered poor style.
1074 We only diagnose static then non-static if -Wtraditional,
1075 because it is the most convenient way to get some effects
1076 (see e.g. what unwind-dw2-fde-glibc.c does to the definition
1077 of _Unwind_Find_FDE in unwind-dw2-fde.c). Revisit? */
1078 if (TREE_PUBLIC (olddecl
) && !TREE_PUBLIC (newdecl
))
1080 /* A static function declaration for a predeclared function
1081 that isn't actually built in, silently overrides the
1082 default. Objective C uses these. See also above.
1083 FIXME: Make Objective C use normal builtins. */
1084 if (TREE_CODE (olddecl
) == FUNCTION_DECL
1085 && DECL_SOURCE_LINE (olddecl
) == 0)
1089 warning ("%Jstatic declaration of '%D' follows "
1090 "non-static declaration", newdecl
, newdecl
);
1094 else if (TREE_PUBLIC (newdecl
) && !TREE_PUBLIC (olddecl
)
1095 && warn_traditional
)
1097 warning ("%Jnon-static declaration of '%D' follows "
1098 "static declaration", newdecl
, newdecl
);
1102 else if (TREE_CODE (newdecl
) == VAR_DECL
)
1104 /* Only variables can be thread-local, and all declarations must
1105 agree on this property. */
1106 if (DECL_THREAD_LOCAL (newdecl
) != DECL_THREAD_LOCAL (olddecl
))
1108 if (DECL_THREAD_LOCAL (newdecl
))
1109 error ("%Jthread-local declaration of '%D' follows "
1110 "non-thread-local declaration", newdecl
, newdecl
);
1112 error ("%Jnon-thread-local declaration of '%D' follows "
1113 "thread-local declaration", newdecl
, newdecl
);
1115 locate_old_decl (olddecl
, error
);
1119 /* Multiple initialized definitions are not allowed (6.9p3,5). */
1120 if (DECL_INITIAL (newdecl
) && DECL_INITIAL (olddecl
))
1122 error ("%Jredefinition of '%D'", newdecl
, newdecl
);
1123 locate_old_decl (olddecl
, error
);
1127 /* Objects declared at file scope: if at least one is 'extern',
1128 it's fine (6.2.2p4); otherwise the linkage must agree (6.2.2p7). */
1129 if (DECL_FILE_SCOPE_P (newdecl
))
1131 if (!DECL_EXTERNAL (newdecl
)
1132 && !DECL_EXTERNAL (olddecl
)
1133 && TREE_PUBLIC (newdecl
) != TREE_PUBLIC (olddecl
))
1135 if (TREE_PUBLIC (newdecl
))
1136 error ("%Jnon-static declaration of '%D' follows "
1137 "static declaration", newdecl
, newdecl
);
1139 error ("%Jstatic declaration of '%D' follows "
1140 "non-static declaration", newdecl
, newdecl
);
1142 locate_old_decl (olddecl
, error
);
1146 /* Two objects with the same name declared at the same block
1147 scope must both be external references (6.7p3). */
1148 else if (DECL_CONTEXT (newdecl
) == DECL_CONTEXT (olddecl
)
1149 && (!DECL_EXTERNAL (newdecl
) || !DECL_EXTERNAL (olddecl
)))
1151 if (DECL_EXTERNAL (newdecl
))
1152 error ("%Jextern declaration of '%D' follows "
1153 "declaration with no linkage", newdecl
, newdecl
);
1154 else if (DECL_EXTERNAL (olddecl
))
1155 error ("%Jdeclaration of '%D' with no linkage follows "
1156 "extern declaration", newdecl
, newdecl
);
1158 error ("%Jredeclaration of '%D' with no linkage",
1161 locate_old_decl (olddecl
, error
);
1167 /* All decls must agree on a non-default visibility. */
1168 if (DECL_VISIBILITY (newdecl
) != VISIBILITY_DEFAULT
1169 && DECL_VISIBILITY (olddecl
) != VISIBILITY_DEFAULT
1170 && DECL_VISIBILITY (newdecl
) != DECL_VISIBILITY (olddecl
))
1172 warning ("%Jredeclaration of '%D' with different visibility "
1173 "(old visibility preserved)", newdecl
, newdecl
);
1177 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
1179 /* Diagnose inline __attribute__ ((noinline)) which is silly. */
1180 if (DECL_DECLARED_INLINE_P (newdecl
)
1181 && lookup_attribute ("noinline", DECL_ATTRIBUTES (olddecl
)))
1183 warning ("%Jinline declaration of '%D' follows "
1184 "declaration with attribute noinline", newdecl
, newdecl
);
1187 else if (DECL_DECLARED_INLINE_P (olddecl
)
1188 && lookup_attribute ("noinline", DECL_ATTRIBUTES (newdecl
)))
1190 warning ("%Jdeclaration of '%D' with attribute noinline follows "
1191 "inline declaration ", newdecl
, newdecl
);
1195 /* Inline declaration after use or definition.
1196 ??? Should we still warn about this now we have unit-at-a-time
1197 mode and can get it right? */
1198 if (DECL_DECLARED_INLINE_P (newdecl
) && !DECL_DECLARED_INLINE_P (olddecl
))
1200 if (TREE_USED (olddecl
))
1202 warning ("%J'%D' declared inline after being called",
1206 else if (DECL_INITIAL (olddecl
))
1208 warning ("%J'%D' declared inline after its definition",
1214 else /* PARM_DECL, VAR_DECL */
1216 /* Redeclaration of a PARM_DECL is invalid unless this is the
1217 real position of a forward-declared parameter (GCC extension). */
1218 if (TREE_CODE (newdecl
) == PARM_DECL
1219 && (!TREE_ASM_WRITTEN (olddecl
) || TREE_ASM_WRITTEN (newdecl
)))
1221 error ("%Jredefinition of parameter '%D'", newdecl
, newdecl
);
1222 locate_old_decl (olddecl
, error
);
1226 /* These bits are only type qualifiers when applied to objects. */
1227 if (TREE_THIS_VOLATILE (newdecl
) != TREE_THIS_VOLATILE (olddecl
))
1229 if (TREE_THIS_VOLATILE (newdecl
))
1230 pedwarn ("%Jvolatile declaration of '%D' follows "
1231 "non-volatile declaration", newdecl
, newdecl
);
1233 pedwarn ("%Jnon-volatile declaration of '%D' follows "
1234 "volatile declaration", newdecl
, newdecl
);
1237 if (TREE_READONLY (newdecl
) != TREE_READONLY (olddecl
))
1239 if (TREE_READONLY (newdecl
))
1240 pedwarn ("%Jconst declaration of '%D' follows "
1241 "non-const declaration", newdecl
, newdecl
);
1243 pedwarn ("%Jnon-const declaration of '%D' follows "
1244 "const declaration", newdecl
, newdecl
);
1249 /* Optional warning for completely redundant decls. */
1250 if (!warned
&& !pedwarned
1251 && warn_redundant_decls
1252 /* Don't warn about a function declaration followed by a
1254 && !(TREE_CODE (newdecl
) == FUNCTION_DECL
1255 && DECL_INITIAL (newdecl
) && !DECL_INITIAL (olddecl
))
1256 /* Don't warn about an extern followed by a definition. */
1257 && !(DECL_EXTERNAL (olddecl
) && !DECL_EXTERNAL (newdecl
))
1258 /* Don't warn about forward parameter decls. */
1259 && !(TREE_CODE (newdecl
) == PARM_DECL
1260 && TREE_ASM_WRITTEN (olddecl
) && !TREE_ASM_WRITTEN (newdecl
)))
1262 warning ("%Jredundant redeclaration of '%D'", newdecl
, newdecl
);
1266 /* Report location of previous decl/defn in a consistent manner. */
1267 if (warned
|| pedwarned
)
1268 locate_old_decl (olddecl
, pedwarned
? pedwarn
: warning
);
1273 /* Subroutine of duplicate_decls. NEWDECL has been found to be
1274 consistent with OLDDECL, but carries new information. Merge the
1275 new information into OLDDECL. This function issues no
1279 merge_decls (tree newdecl
, tree olddecl
, tree newtype
, tree oldtype
)
1281 int new_is_definition
= (TREE_CODE (newdecl
) == FUNCTION_DECL
1282 && DECL_INITIAL (newdecl
) != 0);
1284 /* For real parm decl following a forward decl, return 1 so old decl
1285 will be reused. Only allow this to happen once. */
1286 if (TREE_CODE (newdecl
) == PARM_DECL
1287 && TREE_ASM_WRITTEN (olddecl
) && ! TREE_ASM_WRITTEN (newdecl
))
1289 TREE_ASM_WRITTEN (olddecl
) = 0;
1293 DECL_ATTRIBUTES (newdecl
)
1294 = (*targetm
.merge_decl_attributes
) (olddecl
, newdecl
);
1296 /* Merge the data types specified in the two decls. */
1298 = TREE_TYPE (olddecl
)
1299 = common_type (newtype
, oldtype
);
1301 /* Lay the type out, unless already done. */
1302 if (oldtype
!= TREE_TYPE (newdecl
))
1304 if (TREE_TYPE (newdecl
) != error_mark_node
)
1305 layout_type (TREE_TYPE (newdecl
));
1306 if (TREE_CODE (newdecl
) != FUNCTION_DECL
1307 && TREE_CODE (newdecl
) != TYPE_DECL
1308 && TREE_CODE (newdecl
) != CONST_DECL
)
1309 layout_decl (newdecl
, 0);
1313 /* Since the type is OLDDECL's, make OLDDECL's size go with. */
1314 DECL_SIZE (newdecl
) = DECL_SIZE (olddecl
);
1315 DECL_SIZE_UNIT (newdecl
) = DECL_SIZE_UNIT (olddecl
);
1316 DECL_MODE (newdecl
) = DECL_MODE (olddecl
);
1317 if (TREE_CODE (olddecl
) != FUNCTION_DECL
)
1318 if (DECL_ALIGN (olddecl
) > DECL_ALIGN (newdecl
))
1320 DECL_ALIGN (newdecl
) = DECL_ALIGN (olddecl
);
1321 DECL_USER_ALIGN (newdecl
) |= DECL_ALIGN (olddecl
);
1325 /* Keep the old rtl since we can safely use it. */
1326 COPY_DECL_RTL (olddecl
, newdecl
);
1328 /* Merge the type qualifiers. */
1329 if (TREE_READONLY (newdecl
))
1330 TREE_READONLY (olddecl
) = 1;
1332 if (TREE_THIS_VOLATILE (newdecl
))
1334 TREE_THIS_VOLATILE (olddecl
) = 1;
1335 if (TREE_CODE (newdecl
) == VAR_DECL
)
1336 make_var_volatile (newdecl
);
1339 /* Keep source location of definition rather than declaration. */
1340 if (DECL_INITIAL (newdecl
) == 0 && DECL_INITIAL (olddecl
) != 0)
1341 DECL_SOURCE_LOCATION (newdecl
) = DECL_SOURCE_LOCATION (olddecl
);
1343 /* Merge the unused-warning information. */
1344 if (DECL_IN_SYSTEM_HEADER (olddecl
))
1345 DECL_IN_SYSTEM_HEADER (newdecl
) = 1;
1346 else if (DECL_IN_SYSTEM_HEADER (newdecl
))
1347 DECL_IN_SYSTEM_HEADER (olddecl
) = 1;
1349 /* Merge the initialization information. */
1350 if (DECL_INITIAL (newdecl
) == 0)
1351 DECL_INITIAL (newdecl
) = DECL_INITIAL (olddecl
);
1353 /* Merge the section attribute.
1354 We want to issue an error if the sections conflict but that must be
1355 done later in decl_attributes since we are called before attributes
1357 if (DECL_SECTION_NAME (newdecl
) == NULL_TREE
)
1358 DECL_SECTION_NAME (newdecl
) = DECL_SECTION_NAME (olddecl
);
1360 /* Copy the assembler name.
1361 Currently, it can only be defined in the prototype. */
1362 COPY_DECL_ASSEMBLER_NAME (olddecl
, newdecl
);
1364 /* If either declaration has a nondefault visibility, use it. */
1365 if (DECL_VISIBILITY (olddecl
) != VISIBILITY_DEFAULT
)
1366 DECL_VISIBILITY (newdecl
) = DECL_VISIBILITY (olddecl
);
1368 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
1370 DECL_STATIC_CONSTRUCTOR(newdecl
) |= DECL_STATIC_CONSTRUCTOR(olddecl
);
1371 DECL_STATIC_DESTRUCTOR (newdecl
) |= DECL_STATIC_DESTRUCTOR (olddecl
);
1372 DECL_NO_LIMIT_STACK (newdecl
) |= DECL_NO_LIMIT_STACK (olddecl
);
1373 DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (newdecl
)
1374 |= DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (olddecl
);
1375 TREE_THIS_VOLATILE (newdecl
) |= TREE_THIS_VOLATILE (olddecl
);
1376 TREE_READONLY (newdecl
) |= TREE_READONLY (olddecl
);
1377 DECL_IS_MALLOC (newdecl
) |= DECL_IS_MALLOC (olddecl
);
1378 DECL_IS_PURE (newdecl
) |= DECL_IS_PURE (olddecl
);
1381 /* Merge the storage class information. */
1382 merge_weak (newdecl
, olddecl
);
1384 /* For functions, static overrides non-static. */
1385 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
1387 TREE_PUBLIC (newdecl
) &= TREE_PUBLIC (olddecl
);
1388 /* This is since we don't automatically
1389 copy the attributes of NEWDECL into OLDDECL. */
1390 TREE_PUBLIC (olddecl
) = TREE_PUBLIC (newdecl
);
1391 /* If this clears `static', clear it in the identifier too. */
1392 if (! TREE_PUBLIC (olddecl
))
1393 TREE_PUBLIC (DECL_NAME (olddecl
)) = 0;
1395 if (DECL_EXTERNAL (newdecl
))
1397 TREE_STATIC (newdecl
) = TREE_STATIC (olddecl
);
1398 DECL_EXTERNAL (newdecl
) = DECL_EXTERNAL (olddecl
);
1400 /* An extern decl does not override previous storage class. */
1401 TREE_PUBLIC (newdecl
) = TREE_PUBLIC (olddecl
);
1402 if (! DECL_EXTERNAL (newdecl
))
1404 DECL_CONTEXT (newdecl
) = DECL_CONTEXT (olddecl
);
1405 DECL_COMMON (newdecl
) = DECL_COMMON (olddecl
);
1410 TREE_STATIC (olddecl
) = TREE_STATIC (newdecl
);
1411 TREE_PUBLIC (olddecl
) = TREE_PUBLIC (newdecl
);
1414 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
1416 /* If we're redefining a function previously defined as extern
1417 inline, make sure we emit debug info for the inline before we
1418 throw it away, in case it was inlined into a function that hasn't
1419 been written out yet. */
1420 if (new_is_definition
&& DECL_INITIAL (olddecl
))
1422 if (TREE_USED (olddecl
)
1423 /* In unit-at-a-time mode we never inline re-defined extern
1424 inline functions. */
1425 && !flag_unit_at_a_time
1426 && cgraph_function_possibly_inlined_p (olddecl
))
1427 (*debug_hooks
->outlining_inline_function
) (olddecl
);
1429 /* The new defn must not be inline. */
1430 DECL_INLINE (newdecl
) = 0;
1431 DECL_UNINLINABLE (newdecl
) = 1;
1435 /* If either decl says `inline', this fn is inline,
1436 unless its definition was passed already. */
1437 if (DECL_DECLARED_INLINE_P (newdecl
)
1438 || DECL_DECLARED_INLINE_P (olddecl
))
1439 DECL_DECLARED_INLINE_P (newdecl
) = 1;
1441 DECL_UNINLINABLE (newdecl
) = DECL_UNINLINABLE (olddecl
)
1442 = (DECL_UNINLINABLE (newdecl
) || DECL_UNINLINABLE (olddecl
));
1445 if (DECL_BUILT_IN (olddecl
))
1447 /* If redeclaring a builtin function, it stays built in. */
1448 DECL_BUILT_IN_CLASS (newdecl
) = DECL_BUILT_IN_CLASS (olddecl
);
1449 DECL_FUNCTION_CODE (newdecl
) = DECL_FUNCTION_CODE (olddecl
);
1452 /* Also preserve various other info from the definition. */
1453 if (! new_is_definition
)
1455 DECL_RESULT (newdecl
) = DECL_RESULT (olddecl
);
1456 DECL_INITIAL (newdecl
) = DECL_INITIAL (olddecl
);
1457 DECL_STRUCT_FUNCTION (newdecl
) = DECL_STRUCT_FUNCTION (olddecl
);
1458 DECL_SAVED_TREE (newdecl
) = DECL_SAVED_TREE (olddecl
);
1459 DECL_ARGUMENTS (newdecl
) = DECL_ARGUMENTS (olddecl
);
1461 /* Set DECL_INLINE on the declaration if we've got a body
1462 from which to instantiate. */
1463 if (DECL_INLINE (olddecl
) && ! DECL_UNINLINABLE (newdecl
))
1465 DECL_INLINE (newdecl
) = 1;
1466 DECL_ABSTRACT_ORIGIN (newdecl
)
1467 = DECL_ABSTRACT_ORIGIN (olddecl
);
1472 /* If a previous declaration said inline, mark the
1473 definition as inlinable. */
1474 if (DECL_DECLARED_INLINE_P (newdecl
)
1475 && ! DECL_UNINLINABLE (newdecl
))
1476 DECL_INLINE (newdecl
) = 1;
1480 /* Copy most of the decl-specific fields of NEWDECL into OLDDECL.
1481 But preserve OLDDECL's DECL_UID. */
1483 unsigned olddecl_uid
= DECL_UID (olddecl
);
1485 memcpy ((char *) olddecl
+ sizeof (struct tree_common
),
1486 (char *) newdecl
+ sizeof (struct tree_common
),
1487 sizeof (struct tree_decl
) - sizeof (struct tree_common
));
1488 DECL_UID (olddecl
) = olddecl_uid
;
1491 /* If OLDDECL had its DECL_RTL instantiated, re-invoke make_decl_rtl
1492 so that encode_section_info has a chance to look at the new decl
1493 flags and attributes. */
1494 if (DECL_RTL_SET_P (olddecl
)
1495 && (TREE_CODE (olddecl
) == FUNCTION_DECL
1496 || (TREE_CODE (olddecl
) == VAR_DECL
1497 && TREE_STATIC (olddecl
))))
1498 make_decl_rtl (olddecl
, NULL
);
1501 /* Handle when a new declaration NEWDECL has the same name as an old
1502 one OLDDECL in the same binding contour. Prints an error message
1505 If safely possible, alter OLDDECL to look like NEWDECL, and return
1506 true. Otherwise, return false. */
1509 duplicate_decls (tree newdecl
, tree olddecl
)
1511 tree newtype
, oldtype
;
1513 if (!diagnose_mismatched_decls (newdecl
, olddecl
, &newtype
, &oldtype
))
1516 merge_decls (newdecl
, olddecl
, newtype
, oldtype
);
1521 /* Return any external DECL associated with ID, whether or not it is
1522 currently in scope. */
1525 any_external_decl (tree id
)
1527 tree decl
= IDENTIFIER_SYMBOL_VALUE (id
);
1530 if (decl
== 0 || TREE_CODE (decl
) == ERROR_MARK
)
1532 else if (TREE_CODE (decl
) != TYPE_DECL
&& DECL_EXTERNAL (decl
))
1535 t
= purpose_member (id
, truly_local_externals
);
1537 return TREE_VALUE (t
);
1542 /* Record an external decl DECL. This only does something if a
1543 shadowing decl already exists. */
1545 record_external_decl (tree decl
)
1547 tree name
= DECL_NAME (decl
);
1548 if (!IDENTIFIER_SYMBOL_VALUE (name
))
1551 truly_local_externals
= tree_cons (name
, decl
, truly_local_externals
);
1554 /* Check whether decl-node X shadows an existing declaration.
1555 OLD is the old IDENTIFIER_SYMBOL_VALUE of the DECL_NAME of X,
1556 which might be a NULL_TREE. */
1558 warn_if_shadowing (tree x
, tree old
)
1560 /* Nothing to shadow? */
1562 /* Shadow warnings not wanted? */
1564 /* No shadow warnings for internally generated vars. */
1565 || DECL_SOURCE_LINE (x
) == 0
1566 /* No shadow warnings for vars made for inlining. */
1567 || DECL_FROM_INLINE (x
)
1568 /* Don't warn about the parm names in function declarator
1569 within a function declarator.
1570 It would be nice to avoid warning in any function
1571 declarator in a declaration, as opposed to a definition,
1572 but there is no way to tell it's not a definition. */
1573 || (TREE_CODE (x
) == PARM_DECL
&& current_scope
->outer
->parm_flag
))
1576 if (TREE_CODE (old
) == PARM_DECL
)
1577 warning ("%Jdeclaration of '%D' shadows a parameter", x
, x
);
1578 else if (DECL_FILE_SCOPE_P (old
))
1579 warning ("%Jdeclaration of '%D' shadows a global declaration", x
, x
);
1581 warning ("%Jdeclaration of '%D' shadows a previous local", x
, x
);
1583 warning ("%Jshadowed declaration is here", old
);
1587 /* Subroutine of pushdecl.
1589 X is a TYPE_DECL for a typedef statement. Create a brand new
1590 ..._TYPE node (which will be just a variant of the existing
1591 ..._TYPE node with identical properties) and then install X
1592 as the TYPE_NAME of this brand new (duplicate) ..._TYPE node.
1594 The whole point here is to end up with a situation where each
1595 and every ..._TYPE node the compiler creates will be uniquely
1596 associated with AT MOST one node representing a typedef name.
1597 This way, even though the compiler substitutes corresponding
1598 ..._TYPE nodes for TYPE_DECL (i.e. "typedef name") nodes very
1599 early on, later parts of the compiler can always do the reverse
1600 translation and get back the corresponding typedef name. For
1603 typedef struct S MY_TYPE;
1606 Later parts of the compiler might only know that `object' was of
1607 type `struct S' if it were not for code just below. With this
1608 code however, later parts of the compiler see something like:
1610 struct S' == struct S
1611 typedef struct S' MY_TYPE;
1614 And they can then deduce (from the node for type struct S') that
1615 the original object declaration was:
1619 Being able to do this is important for proper support of protoize,
1620 and also for generating precise symbolic debugging information
1621 which takes full account of the programmer's (typedef) vocabulary.
1623 Obviously, we don't want to generate a duplicate ..._TYPE node if
1624 the TYPE_DECL node that we are now processing really represents a
1625 standard built-in type.
1627 Since all standard types are effectively declared at line zero
1628 in the source file, we can easily check to see if we are working
1629 on a standard type by checking the current value of lineno. */
1632 clone_underlying_type (tree x
)
1634 if (DECL_SOURCE_LINE (x
) == 0)
1636 if (TYPE_NAME (TREE_TYPE (x
)) == 0)
1637 TYPE_NAME (TREE_TYPE (x
)) = x
;
1639 else if (TREE_TYPE (x
) != error_mark_node
1640 && DECL_ORIGINAL_TYPE (x
) == NULL_TREE
)
1642 tree tt
= TREE_TYPE (x
);
1643 DECL_ORIGINAL_TYPE (x
) = tt
;
1644 tt
= build_type_copy (tt
);
1646 TREE_USED (tt
) = TREE_USED (x
);
1651 /* Record a decl-node X as belonging to the current lexical scope.
1652 Check for errors (such as an incompatible declaration for the same
1653 name already seen in the same scope).
1655 Returns either X or an old decl for the same name.
1656 If an old decl is returned, it may have been smashed
1657 to agree with what X says. */
1662 tree name
= DECL_NAME (x
);
1663 struct c_scope
*scope
= current_scope
;
1665 #ifdef ENABLE_CHECKING
1666 if (error_mark_node
== 0)
1667 /* Called too early. */
1671 /* Functions need the lang_decl data. */
1672 if (TREE_CODE (x
) == FUNCTION_DECL
&& ! DECL_LANG_SPECIFIC (x
))
1673 DECL_LANG_SPECIFIC (x
) = ggc_alloc_cleared (sizeof (struct lang_decl
));
1675 /* A local extern declaration for a function doesn't constitute nesting.
1676 A local auto declaration does, since it's a forward decl
1677 for a nested function coming later. */
1678 if (current_function_decl
== NULL
1679 || ((TREE_CODE (x
) == FUNCTION_DECL
|| TREE_CODE (x
) == VAR_DECL
)
1680 && DECL_INITIAL (x
) == 0 && DECL_EXTERNAL (x
)))
1681 DECL_CONTEXT (x
) = current_file_decl
;
1683 DECL_CONTEXT (x
) = current_function_decl
;
1689 if (warn_nested_externs
1690 && scope
!= global_scope
1691 && DECL_EXTERNAL (x
)
1692 && !DECL_IN_SYSTEM_HEADER (x
))
1693 warning ("nested extern declaration of `%s'",
1694 IDENTIFIER_POINTER (name
));
1696 old
= lookup_name_current_level (name
);
1697 if (old
&& duplicate_decls (x
, old
))
1699 /* For PARM_DECLs, old may be a forward declaration.
1700 If so, we want to remove it from its old location
1701 (in the variables chain) and rechain it in the
1702 location given by the new declaration. */
1703 if (TREE_CODE (x
) == PARM_DECL
)
1706 for (p
= &scope
->names
; *p
; p
= &TREE_CHAIN (*p
))
1709 *p
= TREE_CHAIN (old
);
1710 SCOPE_LIST_APPEND (scope
, parms
, old
);
1716 if (DECL_EXTERNAL (x
) || scope
== global_scope
)
1718 /* Find and check against a previous, not-in-scope, external
1719 decl for this identifier. (C99 6.2.7p2: All declarations
1720 that refer to the same object or function shall have
1721 compatible type; otherwise, the behavior is undefined.) */
1722 tree ext
= any_external_decl (name
);
1725 if (duplicate_decls (x
, ext
))
1726 x
= copy_node (ext
);
1729 record_external_decl (x
);
1732 if (TREE_CODE (x
) == TYPE_DECL
)
1733 clone_underlying_type (x
);
1735 /* If storing a local value, there may already be one
1736 (inherited). If so, record it for restoration when this
1737 scope ends. Take care not to do this if we are replacing an
1738 older decl in the same scope (i.e. duplicate_decls returned
1740 if (scope
!= global_scope
1741 && IDENTIFIER_SYMBOL_VALUE (name
)
1742 && IDENTIFIER_SYMBOL_VALUE (name
) != old
)
1744 warn_if_shadowing (x
, IDENTIFIER_SYMBOL_VALUE (name
));
1745 scope
->shadowed
= tree_cons (name
, IDENTIFIER_SYMBOL_VALUE (name
),
1749 /* Install the new declaration in the requested scope. */
1750 IDENTIFIER_SYMBOL_VALUE (name
) = x
;
1751 C_DECL_INVISIBLE (x
) = 0;
1753 /* If x's type is incomplete because it's based on a
1754 structure or union which has not yet been fully declared,
1755 attach it to that structure or union type, so we can go
1756 back and complete the variable declaration later, if the
1757 structure or union gets fully declared.
1759 If the input is erroneous, we can have error_mark in the type
1760 slot (e.g. "f(void a, ...)") - that doesn't count as an
1762 if (TREE_TYPE (x
) != error_mark_node
1763 && !COMPLETE_TYPE_P (TREE_TYPE (x
)))
1765 tree element
= TREE_TYPE (x
);
1767 while (TREE_CODE (element
) == ARRAY_TYPE
)
1768 element
= TREE_TYPE (element
);
1769 element
= TYPE_MAIN_VARIANT (element
);
1771 if ((TREE_CODE (element
) == RECORD_TYPE
1772 || TREE_CODE (element
) == UNION_TYPE
)
1773 && (TREE_CODE (x
) != TYPE_DECL
1774 || TREE_CODE (TREE_TYPE (x
)) == ARRAY_TYPE
)
1775 && !COMPLETE_TYPE_P (element
))
1776 C_TYPE_INCOMPLETE_VARS (element
)
1777 = tree_cons (NULL_TREE
, x
, C_TYPE_INCOMPLETE_VARS (element
));
1781 if (TREE_CODE (x
) == PARM_DECL
)
1782 SCOPE_LIST_APPEND (scope
, parms
, x
);
1784 SCOPE_LIST_APPEND (scope
, names
, x
);
1789 /* Record X as belonging to the global scope (C99 "file scope").
1790 This is used only internally by the Objective-C front end,
1791 and is limited to its needs. duplicate_decls is not called;
1792 if there is any preexisting decl for this identifier, it is an ICE. */
1795 pushdecl_top_level (tree x
)
1799 if (TREE_CODE (x
) != VAR_DECL
)
1802 name
= DECL_NAME (x
);
1804 if (IDENTIFIER_SYMBOL_VALUE (name
))
1807 DECL_CONTEXT (x
) = current_file_decl
;
1808 IDENTIFIER_SYMBOL_VALUE (name
) = x
;
1810 SCOPE_LIST_APPEND (global_scope
, names
, x
);
1814 /* Generate an implicit declaration for identifier FUNCTIONID as a
1815 function of type int (). */
1818 implicitly_declare (tree functionid
)
1820 tree decl
= any_external_decl (functionid
);
1824 /* Implicit declaration of a function already declared
1825 (somehow) in a different scope, or as a built-in.
1826 If this is the first time this has happened, warn;
1827 then recycle the old declaration. */
1828 if (!C_DECL_IMPLICIT (decl
))
1830 implicit_decl_warning (DECL_NAME (decl
));
1831 if (! DECL_FILE_SCOPE_P (decl
))
1832 warning ("%Jprevious declaration of '%D'", decl
, decl
);
1833 C_DECL_IMPLICIT (decl
) = 1;
1835 /* If this function is global, then it must already be in the
1836 global scope, so there's no need to push it again. */
1837 if (current_scope
== global_scope
)
1839 /* If this is a local declaration, make a copy; we can't have
1840 the same DECL listed in two different scopes. */
1841 return pushdecl (copy_node (decl
));
1844 /* Not seen before. */
1845 decl
= build_decl (FUNCTION_DECL
, functionid
, default_function_type
);
1846 DECL_EXTERNAL (decl
) = 1;
1847 TREE_PUBLIC (decl
) = 1;
1848 C_DECL_IMPLICIT (decl
) = 1;
1849 implicit_decl_warning (functionid
);
1851 /* C89 says implicit declarations are in the innermost block.
1852 So we record the decl in the standard fashion. */
1853 decl
= pushdecl (decl
);
1855 /* No need to call objc_check_decl here - it's a function type. */
1856 rest_of_decl_compilation (decl
, NULL
, 0, 0);
1858 /* Write a record describing this implicit function declaration
1859 to the prototypes file (if requested). */
1860 gen_aux_info_record (decl
, 0, 1, 0);
1862 /* Possibly apply some default attributes to this implicit declaration. */
1863 decl_attributes (&decl
, NULL_TREE
, 0);
1869 implicit_decl_warning (tree id
)
1871 const char *name
= IDENTIFIER_POINTER (id
);
1872 if (mesg_implicit_function_declaration
== 2)
1873 error ("implicit declaration of function `%s'", name
);
1874 else if (mesg_implicit_function_declaration
== 1)
1875 warning ("implicit declaration of function `%s'", name
);
1878 /* Issue an error message for a reference to an undeclared variable
1879 ID, including a reference to a builtin outside of function-call
1880 context. Establish a binding of the identifier to error_mark_node
1881 in an appropriate scope, which will suppress further errors for the
1884 undeclared_variable (tree id
)
1886 static bool already
= false;
1887 struct c_scope
*scope
;
1889 if (current_function_decl
== 0)
1891 error ("`%s' undeclared here (not in a function)",
1892 IDENTIFIER_POINTER (id
));
1893 scope
= current_scope
;
1897 error ("`%s' undeclared (first use in this function)",
1898 IDENTIFIER_POINTER (id
));
1902 error ("(Each undeclared identifier is reported only once");
1903 error ("for each function it appears in.)");
1907 scope
= current_function_scope
;
1910 scope
->shadowed
= tree_cons (id
, IDENTIFIER_SYMBOL_VALUE (id
),
1912 IDENTIFIER_SYMBOL_VALUE (id
) = error_mark_node
;
1915 /* Subroutine of lookup_label, declare_label, define_label: construct a
1916 LABEL_DECL with all the proper frills. */
1919 make_label (tree name
, location_t location
)
1921 tree label
= build_decl (LABEL_DECL
, name
, void_type_node
);
1923 DECL_CONTEXT (label
) = current_function_decl
;
1924 DECL_MODE (label
) = VOIDmode
;
1925 DECL_SOURCE_LOCATION (label
) = location
;
1930 /* Another subroutine of lookup_label, declare_label, define_label:
1931 set up the binding of name to LABEL_DECL in the given SCOPE. */
1934 bind_label (tree name
, tree label
, struct c_scope
*scope
)
1936 if (IDENTIFIER_LABEL_VALUE (name
))
1937 scope
->shadowed
= tree_cons (name
, IDENTIFIER_LABEL_VALUE (name
),
1939 IDENTIFIER_LABEL_VALUE (name
) = label
;
1941 SCOPE_LIST_APPEND (scope
, names
, label
);
1944 /* Get the LABEL_DECL corresponding to identifier NAME as a label.
1945 Create one if none exists so far for the current function.
1946 This is called when a label is used in a goto expression or
1947 has its address taken. */
1950 lookup_label (tree name
)
1954 if (current_function_decl
== 0)
1956 error ("label %s referenced outside of any function",
1957 IDENTIFIER_POINTER (name
));
1961 /* Use a label already defined or ref'd with this name, but not if
1962 it is inherited from a containing function and wasn't declared
1964 label
= IDENTIFIER_LABEL_VALUE (name
);
1965 if (label
&& (DECL_CONTEXT (label
) == current_function_decl
1966 || C_DECLARED_LABEL_FLAG (label
)))
1968 /* If the label has only been declared, update its apparent
1969 location to point here, for better diagnostics if it
1970 turns out not to have been defined. */
1971 if (!TREE_USED (label
))
1972 DECL_SOURCE_LOCATION (label
) = input_location
;
1976 /* No label binding for that identifier; make one. */
1977 label
= make_label (name
, input_location
);
1979 /* Ordinary labels go in the current function scope. */
1980 bind_label (name
, label
, current_function_scope
);
1984 /* Make a label named NAME in the current function, shadowing silently
1985 any that may be inherited from containing functions or containing
1986 scopes. This is called for __label__ declarations. */
1988 /* Note that valid use, if the label being shadowed comes from another
1989 scope in the same function, requires calling declare_nonlocal_label
1990 right away. (Is this still true? -zw 2003-07-17) */
1993 declare_label (tree name
)
1995 tree label
= IDENTIFIER_LABEL_VALUE (name
);
1998 /* Check to make sure that the label hasn't already been declared
2000 for (dup
= current_scope
->names
; dup
; dup
= TREE_CHAIN (dup
))
2003 error ("duplicate label declaration `%s'", IDENTIFIER_POINTER (name
));
2004 error ("%Jthis is a previous declaration", dup
);
2006 /* Just use the previous declaration. */
2010 label
= make_label (name
, input_location
);
2011 C_DECLARED_LABEL_FLAG (label
) = 1;
2013 /* Declared labels go in the current scope. */
2014 bind_label (name
, label
, current_scope
);
2018 /* Define a label, specifying the location in the source file.
2019 Return the LABEL_DECL node for the label, if the definition is valid.
2020 Otherwise return 0. */
2023 define_label (location_t location
, tree name
)
2027 /* Find any preexisting label with this name. It is an error
2028 if that label has already been defined in this function, or
2029 if there is a containing function with a declared label with
2031 label
= IDENTIFIER_LABEL_VALUE (name
);
2034 && ((DECL_CONTEXT (label
) == current_function_decl
2035 && DECL_INITIAL (label
) != 0)
2036 || (DECL_CONTEXT (label
) != current_function_decl
2037 && C_DECLARED_LABEL_FLAG (label
))))
2039 error ("%Hduplicate label `%D'", &location
, label
);
2040 if (DECL_INITIAL (label
))
2041 error ("%J`%D' previously defined here", label
, label
);
2043 error ("%J`%D' previously declared here", label
, label
);
2046 else if (label
&& DECL_CONTEXT (label
) == current_function_decl
)
2048 /* The label has been used or declared already in this function,
2049 but not defined. Update its location to point to this
2051 DECL_SOURCE_LOCATION (label
) = location
;
2055 /* No label binding for that identifier; make one. */
2056 label
= make_label (name
, location
);
2058 /* Ordinary labels go in the current function scope. */
2059 bind_label (name
, label
, current_function_scope
);
2062 if (warn_traditional
&& !in_system_header
&& lookup_name (name
))
2063 warning ("%Htraditional C lacks a separate namespace for labels, "
2064 "identifier `%s' conflicts", &location
,
2065 IDENTIFIER_POINTER (name
));
2067 /* Mark label as having been defined. */
2068 DECL_INITIAL (label
) = error_mark_node
;
2072 /* Return the list of declarations of the current scope.
2073 This hook is optional and not implemented for C. */
2082 /* Given NAME, an IDENTIFIER_NODE,
2083 return the structure (or union or enum) definition for that name.
2084 If THISLEVEL_ONLY is nonzero, searches only the current_scope.
2085 CODE says which kind of type the caller wants;
2086 it is RECORD_TYPE or UNION_TYPE or ENUMERAL_TYPE.
2087 If the wrong kind of type is found, an error is reported. */
2090 lookup_tag (enum tree_code code
, tree name
, int thislevel_only
)
2092 tree tag
= IDENTIFIER_TAG_VALUE (name
);
2098 /* We only care about whether it's in this level if
2099 thislevel_only was set or it might be a type clash. */
2100 if (thislevel_only
|| TREE_CODE (tag
) != code
)
2102 if (current_scope
== global_scope
2103 || purpose_member (name
, current_scope
->tags
))
2107 if (thislevel_only
&& !thislevel
)
2110 if (TREE_CODE (tag
) != code
)
2112 /* Definition isn't the kind we were looking for. */
2113 pending_invalid_xref
= name
;
2114 pending_invalid_xref_location
= input_location
;
2116 /* If in the same binding level as a declaration as a tag
2117 of a different type, this must not be allowed to
2118 shadow that tag, so give the error immediately.
2119 (For example, "struct foo; union foo;" is invalid.) */
2121 pending_xref_error ();
2126 /* Print an error message now
2127 for a recent invalid struct, union or enum cross reference.
2128 We don't print them immediately because they are not invalid
2129 when used in the `struct foo;' construct for shadowing. */
2132 pending_xref_error (void)
2134 if (pending_invalid_xref
!= 0)
2135 error ("%H`%s' defined as wrong kind of tag",
2136 &pending_invalid_xref_location
,
2137 IDENTIFIER_POINTER (pending_invalid_xref
));
2138 pending_invalid_xref
= 0;
2142 /* Look up NAME in the current scope and its superiors
2143 in the namespace of variables, functions and typedefs.
2144 Return a ..._DECL node of some kind representing its definition,
2145 or return 0 if it is undefined. */
2148 lookup_name (tree name
)
2150 tree decl
= IDENTIFIER_SYMBOL_VALUE (name
);
2151 if (decl
== 0 || decl
== error_mark_node
)
2153 if (C_DECL_INVISIBLE (decl
))
2158 /* Similar to `lookup_name' but look only at the current scope. */
2161 lookup_name_current_level (tree name
)
2163 tree decl
= IDENTIFIER_SYMBOL_VALUE (name
);
2165 if (decl
== 0 || decl
== error_mark_node
|| C_DECL_INVISIBLE (decl
))
2168 if (current_scope
== global_scope
)
2171 /* Scan the current scope for a decl with name NAME.
2172 For PARM_DECLs, we have to look at both ->parms and ->names, since
2173 forward parameter declarations wind up on the ->names list. */
2174 if (TREE_CODE (decl
) == PARM_DECL
2175 && chain_member (decl
, current_scope
->parms
))
2177 if (chain_member (decl
, current_scope
->names
))
2183 /* Create the predefined scalar types of C,
2184 and some nodes representing standard constants (0, 1, (void *) 0).
2185 Initialize the global scope.
2186 Make definitions for built-in primitive functions. */
2189 c_init_decl_processing (void)
2192 tree ptr_ftype_void
, ptr_ftype_ptr
;
2193 location_t save_loc
= input_location
;
2195 /* Adds some ggc roots, and reserved words for c-parse.in. */
2198 current_function_decl
= 0;
2200 /* Make the c_scope structure for global names. */
2202 global_scope
= current_scope
;
2204 /* Declarations from c_common_nodes_and_builtins must not be associated
2205 with this input file, lest we get differences between using and not
2206 using preprocessed headers. */
2207 input_location
.file
= "<internal>";
2208 input_location
.line
= 0;
2210 /* Make the DECL for the toplevel file scope. */
2211 current_file_decl
= build_decl (TRANSLATION_UNIT_DECL
, NULL
, NULL
);
2213 build_common_tree_nodes (flag_signed_char
);
2215 c_common_nodes_and_builtins ();
2217 /* In C, comparisons and TRUTH_* expressions have type int. */
2218 truthvalue_type_node
= integer_type_node
;
2219 truthvalue_true_node
= integer_one_node
;
2220 truthvalue_false_node
= integer_zero_node
;
2222 /* Even in C99, which has a real boolean type. */
2223 pushdecl (build_decl (TYPE_DECL
, get_identifier ("_Bool"),
2224 boolean_type_node
));
2226 endlink
= void_list_node
;
2227 ptr_ftype_void
= build_function_type (ptr_type_node
, endlink
);
2229 = build_function_type (ptr_type_node
,
2230 tree_cons (NULL_TREE
, ptr_type_node
, endlink
));
2232 input_location
= save_loc
;
2234 pedantic_lvalues
= true;
2236 make_fname_decl
= c_make_fname_decl
;
2237 start_fname_decls ();
2239 first_builtin_decl
= global_scope
->names
;
2240 last_builtin_decl
= global_scope
->names_last
;
2243 /* Create the VAR_DECL for __FUNCTION__ etc. ID is the name to give the
2244 decl, NAME is the initialization string and TYPE_DEP indicates whether
2245 NAME depended on the type of the function. As we don't yet implement
2246 delayed emission of static data, we mark the decl as emitted
2247 so it is not placed in the output. Anything using it must therefore pull
2248 out the STRING_CST initializer directly. FIXME. */
2251 c_make_fname_decl (tree id
, int type_dep
)
2253 const char *name
= fname_as_string (type_dep
);
2254 tree decl
, type
, init
;
2255 size_t length
= strlen (name
);
2257 type
= build_array_type
2258 (build_qualified_type (char_type_node
, TYPE_QUAL_CONST
),
2259 build_index_type (size_int (length
)));
2261 decl
= build_decl (VAR_DECL
, id
, type
);
2263 TREE_STATIC (decl
) = 1;
2264 TREE_READONLY (decl
) = 1;
2265 DECL_ARTIFICIAL (decl
) = 1;
2267 init
= build_string (length
+ 1, name
);
2268 TREE_TYPE (init
) = type
;
2269 DECL_INITIAL (decl
) = init
;
2271 TREE_USED (decl
) = 1;
2273 if (current_function_decl
)
2275 DECL_CONTEXT (decl
) = current_function_decl
;
2276 IDENTIFIER_SYMBOL_VALUE (id
) = decl
;
2277 SCOPE_LIST_APPEND (current_function_scope
, names
, decl
);
2280 finish_decl (decl
, init
, NULL_TREE
);
2285 /* Return a definition for a builtin function named NAME and whose data type
2286 is TYPE. TYPE should be a function type with argument types.
2287 FUNCTION_CODE tells later passes how to compile calls to this function.
2288 See tree.h for its possible values.
2290 If LIBRARY_NAME is nonzero, use that for DECL_ASSEMBLER_NAME,
2291 the name to be called if we can't opencode the function. If
2292 ATTRS is nonzero, use that for the function's attribute list. */
2295 builtin_function (const char *name
, tree type
, int function_code
,
2296 enum built_in_class
class, const char *library_name
,
2299 tree decl
= build_decl (FUNCTION_DECL
, get_identifier (name
), type
);
2300 DECL_EXTERNAL (decl
) = 1;
2301 TREE_PUBLIC (decl
) = 1;
2303 SET_DECL_ASSEMBLER_NAME (decl
, get_identifier (library_name
));
2304 make_decl_rtl (decl
, NULL
);
2306 DECL_BUILT_IN_CLASS (decl
) = class;
2307 DECL_FUNCTION_CODE (decl
) = function_code
;
2309 /* Warn if a function in the namespace for users
2310 is used without an occasion to consider it declared. */
2311 if (name
[0] != '_' || name
[1] != '_')
2312 C_DECL_INVISIBLE (decl
) = 1;
2314 /* Possibly apply some default attributes to this built-in function. */
2316 decl_attributes (&decl
, attrs
, ATTR_FLAG_BUILT_IN
);
2318 decl_attributes (&decl
, NULL_TREE
, 0);
2323 /* Called when a declaration is seen that contains no names to declare.
2324 If its type is a reference to a structure, union or enum inherited
2325 from a containing scope, shadow that tag name for the current scope
2326 with a forward reference.
2327 If its type defines a new named structure or union
2328 or defines an enum, it is valid but we need not do anything here.
2329 Otherwise, it is an error. */
2332 shadow_tag (tree declspecs
)
2334 shadow_tag_warned (declspecs
, 0);
2338 shadow_tag_warned (tree declspecs
, int warned
)
2341 /* 1 => we have done a pedwarn. 2 => we have done a warning, but
2348 pending_invalid_xref
= 0;
2350 /* Remove the attributes from declspecs, since they will confuse the
2352 split_specs_attrs (declspecs
, &specs
, &attrs
);
2354 for (link
= specs
; link
; link
= TREE_CHAIN (link
))
2356 tree value
= TREE_VALUE (link
);
2357 enum tree_code code
= TREE_CODE (value
);
2359 if (code
== RECORD_TYPE
|| code
== UNION_TYPE
|| code
== ENUMERAL_TYPE
)
2360 /* Used to test also that TYPE_SIZE (value) != 0.
2361 That caused warning for `struct foo;' at top level in the file. */
2363 tree name
= TYPE_NAME (value
);
2370 if (warned
!= 1 && code
!= ENUMERAL_TYPE
)
2371 /* Empty unnamed enum OK */
2373 pedwarn ("unnamed struct/union that defines no instances");
2379 t
= lookup_tag (code
, name
, 1);
2383 t
= make_node (code
);
2390 if (!warned
&& ! in_system_header
)
2392 warning ("useless keyword or type name in empty declaration");
2399 error ("two types specified in one empty declaration");
2404 pedwarn ("empty declaration");
2408 /* Construct an array declarator. EXPR is the expression inside [], or
2409 NULL_TREE. QUALS are the type qualifiers inside the [] (to be applied
2410 to the pointer to which a parameter array is converted). STATIC_P is
2411 nonzero if "static" is inside the [], zero otherwise. VLA_UNSPEC_P
2412 is nonzero is the array is [*], a VLA of unspecified length which is
2413 nevertheless a complete type (not currently implemented by GCC),
2414 zero otherwise. The declarator is constructed as an ARRAY_REF
2415 (to be decoded by grokdeclarator), whose operand 0 is what's on the
2416 left of the [] (filled by in set_array_declarator_type) and operand 1
2417 is the expression inside; whose TREE_TYPE is the type qualifiers and
2418 which has TREE_STATIC set if "static" is used. */
2421 build_array_declarator (tree expr
, tree quals
, int static_p
, int vla_unspec_p
)
2424 decl
= build_nt (ARRAY_REF
, NULL_TREE
, expr
);
2425 TREE_TYPE (decl
) = quals
;
2426 TREE_STATIC (decl
) = (static_p
? 1 : 0);
2427 if (pedantic
&& !flag_isoc99
)
2429 if (static_p
|| quals
!= NULL_TREE
)
2430 pedwarn ("ISO C90 does not support `static' or type qualifiers in parameter array declarators");
2432 pedwarn ("ISO C90 does not support `[*]' array declarators");
2435 warning ("GCC does not yet properly implement `[*]' array declarators");
2439 /* Set the type of an array declarator. DECL is the declarator, as
2440 constructed by build_array_declarator; TYPE is what appears on the left
2441 of the [] and goes in operand 0. ABSTRACT_P is nonzero if it is an
2442 abstract declarator, zero otherwise; this is used to reject static and
2443 type qualifiers in abstract declarators, where they are not in the
2447 set_array_declarator_type (tree decl
, tree type
, int abstract_p
)
2449 TREE_OPERAND (decl
, 0) = type
;
2450 if (abstract_p
&& (TREE_TYPE (decl
) != NULL_TREE
|| TREE_STATIC (decl
)))
2451 error ("static or type qualifiers in abstract declarator");
2455 /* Decode a "typename", such as "int **", returning a ..._TYPE node. */
2458 groktypename (tree typename
)
2462 if (TREE_CODE (typename
) != TREE_LIST
)
2465 split_specs_attrs (TREE_PURPOSE (typename
), &specs
, &attrs
);
2467 typename
= grokdeclarator (TREE_VALUE (typename
), specs
, TYPENAME
, 0,
2470 /* Apply attributes. */
2471 decl_attributes (&typename
, attrs
, 0);
2476 /* Return a PARM_DECL node for a given pair of specs and declarator. */
2479 groktypename_in_parm_context (tree typename
)
2481 if (TREE_CODE (typename
) != TREE_LIST
)
2483 return grokdeclarator (TREE_VALUE (typename
),
2484 TREE_PURPOSE (typename
),
2488 /* Decode a declarator in an ordinary declaration or data definition.
2489 This is called as soon as the type information and variable name
2490 have been parsed, before parsing the initializer if any.
2491 Here we create the ..._DECL node, fill in its type,
2492 and put it on the list of decls for the current context.
2493 The ..._DECL node is returned as the value.
2495 Exception: for arrays where the length is not specified,
2496 the type is left null, to be filled in by `finish_decl'.
2498 Function definitions do not come here; they go to start_function
2499 instead. However, external and forward declarations of functions
2500 do go through here. Structure field declarations are done by
2501 grokfield and not through here. */
2504 start_decl (tree declarator
, tree declspecs
, int initialized
, tree attributes
)
2509 /* An object declared as __attribute__((deprecated)) suppresses
2510 warnings of uses of other deprecated items. */
2511 if (lookup_attribute ("deprecated", attributes
))
2512 deprecated_state
= DEPRECATED_SUPPRESS
;
2514 decl
= grokdeclarator (declarator
, declspecs
,
2515 NORMAL
, initialized
, NULL
);
2517 deprecated_state
= DEPRECATED_NORMAL
;
2519 if (warn_main
> 0 && TREE_CODE (decl
) != FUNCTION_DECL
2520 && MAIN_NAME_P (DECL_NAME (decl
)))
2521 warning ("%J'%D' is usually a function", decl
, decl
);
2524 /* Is it valid for this decl to have an initializer at all?
2525 If not, set INITIALIZED to zero, which will indirectly
2526 tell `finish_decl' to ignore the initializer once it is parsed. */
2527 switch (TREE_CODE (decl
))
2530 error ("typedef `%s' is initialized (use __typeof__ instead)",
2531 IDENTIFIER_POINTER (DECL_NAME (decl
)));
2536 error ("function `%s' is initialized like a variable",
2537 IDENTIFIER_POINTER (DECL_NAME (decl
)));
2542 /* DECL_INITIAL in a PARM_DECL is really DECL_ARG_TYPE. */
2543 error ("parameter `%s' is initialized",
2544 IDENTIFIER_POINTER (DECL_NAME (decl
)));
2549 /* Don't allow initializations for incomplete types
2550 except for arrays which might be completed by the initialization. */
2552 /* This can happen if the array size is an undefined macro. We already
2553 gave a warning, so we don't need another one. */
2554 if (TREE_TYPE (decl
) == error_mark_node
)
2556 else if (COMPLETE_TYPE_P (TREE_TYPE (decl
)))
2558 /* A complete type is ok if size is fixed. */
2560 if (TREE_CODE (TYPE_SIZE (TREE_TYPE (decl
))) != INTEGER_CST
2561 || C_DECL_VARIABLE_SIZE (decl
))
2563 error ("variable-sized object may not be initialized");
2567 else if (TREE_CODE (TREE_TYPE (decl
)) != ARRAY_TYPE
)
2569 error ("variable `%s' has initializer but incomplete type",
2570 IDENTIFIER_POINTER (DECL_NAME (decl
)));
2573 else if (!COMPLETE_TYPE_P (TREE_TYPE (TREE_TYPE (decl
))))
2575 error ("elements of array `%s' have incomplete type",
2576 IDENTIFIER_POINTER (DECL_NAME (decl
)));
2583 DECL_EXTERNAL (decl
) = 0;
2584 if (current_scope
== global_scope
)
2585 TREE_STATIC (decl
) = 1;
2587 /* Tell `pushdecl' this is an initialized decl
2588 even though we don't yet have the initializer expression.
2589 Also tell `finish_decl' it may store the real initializer. */
2590 DECL_INITIAL (decl
) = error_mark_node
;
2593 /* If this is a function declaration, write a record describing it to the
2594 prototypes file (if requested). */
2596 if (TREE_CODE (decl
) == FUNCTION_DECL
)
2597 gen_aux_info_record (decl
, 0, 0, TYPE_ARG_TYPES (TREE_TYPE (decl
)) != 0);
2599 /* ANSI specifies that a tentative definition which is not merged with
2600 a non-tentative definition behaves exactly like a definition with an
2601 initializer equal to zero. (Section 3.7.2)
2603 -fno-common gives strict ANSI behavior, though this tends to break
2604 a large body of code that grew up without this rule.
2606 Thread-local variables are never common, since there's no entrenched
2607 body of code to break, and it allows more efficient variable references
2608 in the presence of dynamic linking. */
2610 if (TREE_CODE (decl
) == VAR_DECL
2612 && TREE_PUBLIC (decl
)
2613 && !DECL_THREAD_LOCAL (decl
)
2615 DECL_COMMON (decl
) = 1;
2617 /* Set attributes here so if duplicate decl, will have proper attributes. */
2618 decl_attributes (&decl
, attributes
, 0);
2620 if (TREE_CODE (decl
) == FUNCTION_DECL
2621 && targetm
.calls
.promote_prototypes (TREE_TYPE (decl
)))
2623 tree ce
= declarator
;
2625 if (TREE_CODE (ce
) == INDIRECT_REF
)
2626 ce
= TREE_OPERAND (declarator
, 0);
2627 if (TREE_CODE (ce
) == CALL_EXPR
)
2629 tree args
= TREE_PURPOSE (TREE_OPERAND (ce
, 1));
2630 for (; args
; args
= TREE_CHAIN (args
))
2632 tree type
= TREE_TYPE (args
);
2633 if (INTEGRAL_TYPE_P (type
)
2634 && TYPE_PRECISION (type
) < TYPE_PRECISION (integer_type_node
))
2635 DECL_ARG_TYPE (args
) = integer_type_node
;
2640 if (TREE_CODE (decl
) == FUNCTION_DECL
2641 && DECL_DECLARED_INLINE_P (decl
)
2642 && DECL_UNINLINABLE (decl
)
2643 && lookup_attribute ("noinline", DECL_ATTRIBUTES (decl
)))
2644 warning ("%Jinline function '%D' given attribute noinline", decl
, decl
);
2646 /* Add this decl to the current scope.
2647 TEM may equal DECL or it may be a previous decl of the same name. */
2648 tem
= pushdecl (decl
);
2650 /* For a local variable, define the RTL now. */
2651 if (current_scope
!= global_scope
2652 /* But not if this is a duplicate decl
2653 and we preserved the rtl from the previous one
2654 (which may or may not happen). */
2655 && !DECL_RTL_SET_P (tem
)
2656 && DECL_FILE_SCOPE_P (tem
))
2658 if (TREE_TYPE (tem
) != error_mark_node
2659 && (COMPLETE_TYPE_P (TREE_TYPE (tem
))
2660 || (TREE_CODE (TREE_TYPE (tem
)) == ARRAY_TYPE
2661 && DECL_INITIAL (tem
) != 0)))
2668 /* Finish processing of a declaration;
2669 install its initial value.
2670 If the length of an array type is not known before,
2671 it must be determined now, from the initial value, or it is an error. */
2674 finish_decl (tree decl
, tree init
, tree asmspec_tree
)
2676 tree type
= TREE_TYPE (decl
);
2677 int was_incomplete
= (DECL_SIZE (decl
) == 0);
2678 const char *asmspec
= 0;
2680 /* If a name was specified, get the string. */
2681 if (current_scope
== global_scope
)
2682 asmspec_tree
= maybe_apply_renaming_pragma (decl
, asmspec_tree
);
2684 asmspec
= TREE_STRING_POINTER (asmspec_tree
);
2686 /* If `start_decl' didn't like having an initialization, ignore it now. */
2687 if (init
!= 0 && DECL_INITIAL (decl
) == 0)
2690 /* Don't crash if parm is initialized. */
2691 if (TREE_CODE (decl
) == PARM_DECL
)
2695 store_init_value (decl
, init
);
2697 if (c_dialect_objc () && (TREE_CODE (decl
) == VAR_DECL
2698 || TREE_CODE (decl
) == FUNCTION_DECL
2699 || TREE_CODE (decl
) == FIELD_DECL
))
2700 objc_check_decl (decl
);
2702 /* Deduce size of array from initialization, if not already known. */
2703 if (TREE_CODE (type
) == ARRAY_TYPE
2704 && TYPE_DOMAIN (type
) == 0
2705 && TREE_CODE (decl
) != TYPE_DECL
)
2708 = (TREE_STATIC (decl
)
2709 /* Even if pedantic, an external linkage array
2710 may have incomplete type at first. */
2711 ? pedantic
&& !TREE_PUBLIC (decl
)
2712 : !DECL_EXTERNAL (decl
));
2714 = complete_array_type (type
, DECL_INITIAL (decl
), do_default
);
2716 /* Get the completed type made by complete_array_type. */
2717 type
= TREE_TYPE (decl
);
2720 error ("%Jinitializer fails to determine size of '%D'", decl
, decl
);
2722 else if (failure
== 2)
2725 error ("%Jarray size missing in '%D'", decl
, decl
);
2726 /* If a `static' var's size isn't known,
2727 make it extern as well as static, so it does not get
2729 If it is not `static', then do not mark extern;
2730 finish_incomplete_decl will give it a default size
2731 and it will get allocated. */
2732 else if (!pedantic
&& TREE_STATIC (decl
) && ! TREE_PUBLIC (decl
))
2733 DECL_EXTERNAL (decl
) = 1;
2736 /* TYPE_MAX_VALUE is always one less than the number of elements
2737 in the array, because we start counting at zero. Therefore,
2738 warn only if the value is less than zero. */
2739 else if (pedantic
&& TYPE_DOMAIN (type
) != 0
2740 && tree_int_cst_sgn (TYPE_MAX_VALUE (TYPE_DOMAIN (type
))) < 0)
2741 error ("%Jzero or negative size array '%D'", decl
, decl
);
2743 layout_decl (decl
, 0);
2746 if (TREE_CODE (decl
) == VAR_DECL
)
2748 if (DECL_SIZE (decl
) == 0 && TREE_TYPE (decl
) != error_mark_node
2749 && COMPLETE_TYPE_P (TREE_TYPE (decl
)))
2750 layout_decl (decl
, 0);
2752 if (DECL_SIZE (decl
) == 0
2753 /* Don't give an error if we already gave one earlier. */
2754 && TREE_TYPE (decl
) != error_mark_node
2755 && (TREE_STATIC (decl
)
2757 /* A static variable with an incomplete type
2758 is an error if it is initialized.
2759 Also if it is not file scope.
2760 Otherwise, let it through, but if it is not `extern'
2761 then it may cause an error message later. */
2762 (DECL_INITIAL (decl
) != 0
2763 || !DECL_FILE_SCOPE_P (decl
))
2765 /* An automatic variable with an incomplete type
2767 !DECL_EXTERNAL (decl
)))
2769 error ("%Jstorage size of '%D' isn't known", decl
, decl
);
2770 TREE_TYPE (decl
) = error_mark_node
;
2773 if ((DECL_EXTERNAL (decl
) || TREE_STATIC (decl
))
2774 && DECL_SIZE (decl
) != 0)
2776 if (TREE_CODE (DECL_SIZE (decl
)) == INTEGER_CST
)
2777 constant_expression_warning (DECL_SIZE (decl
));
2779 error ("%Jstorage size of '%D' isn't constant", decl
, decl
);
2782 if (TREE_USED (type
))
2783 TREE_USED (decl
) = 1;
2786 /* If this is a function and an assembler name is specified, reset DECL_RTL
2787 so we can give it its new name. Also, update built_in_decls if it
2788 was a normal built-in. */
2789 if (TREE_CODE (decl
) == FUNCTION_DECL
&& asmspec
)
2791 /* ASMSPEC is given, and not the name of a register. Mark the
2792 name with a star so assemble_name won't munge it. */
2793 char *starred
= alloca (strlen (asmspec
) + 2);
2795 strcpy (starred
+ 1, asmspec
);
2797 if (DECL_BUILT_IN_CLASS (decl
) == BUILT_IN_NORMAL
)
2799 tree builtin
= built_in_decls
[DECL_FUNCTION_CODE (decl
)];
2800 SET_DECL_RTL (builtin
, NULL_RTX
);
2801 SET_DECL_ASSEMBLER_NAME (builtin
, get_identifier (starred
));
2802 #ifdef TARGET_MEM_FUNCTIONS
2803 if (DECL_FUNCTION_CODE (decl
) == BUILT_IN_MEMCPY
)
2804 init_block_move_fn (starred
);
2805 else if (DECL_FUNCTION_CODE (decl
) == BUILT_IN_MEMSET
)
2806 init_block_clear_fn (starred
);
2808 if (DECL_FUNCTION_CODE (decl
) == BUILT_IN_BCOPY
)
2809 init_block_move_fn (starred
);
2810 else if (DECL_FUNCTION_CODE (decl
) == BUILT_IN_BZERO
)
2811 init_block_clear_fn (starred
);
2814 SET_DECL_RTL (decl
, NULL_RTX
);
2815 change_decl_assembler_name (decl
, get_identifier (starred
));
2818 /* If #pragma weak was used, mark the decl weak now. */
2819 if (current_scope
== global_scope
)
2820 maybe_apply_pragma_weak (decl
);
2822 /* Output the assembler code and/or RTL code for variables and functions,
2823 unless the type is an undefined structure or union.
2824 If not, it will get done when the type is completed. */
2826 if (TREE_CODE (decl
) == VAR_DECL
|| TREE_CODE (decl
) == FUNCTION_DECL
)
2828 /* This is a no-op in c-lang.c or something real in objc-act.c. */
2829 if (c_dialect_objc ())
2830 objc_check_decl (decl
);
2832 if (DECL_FILE_SCOPE_P (decl
))
2834 if (DECL_INITIAL (decl
) == NULL_TREE
2835 || DECL_INITIAL (decl
) == error_mark_node
)
2836 /* Don't output anything
2837 when a tentative file-scope definition is seen.
2838 But at end of compilation, do output code for them. */
2839 DECL_DEFER_OUTPUT (decl
) = 1;
2840 rest_of_decl_compilation (decl
, asmspec
, true, 0);
2844 /* This is a local variable. If there is an ASMSPEC, the
2845 user has requested that we handle it specially. */
2848 /* In conjunction with an ASMSPEC, the `register'
2849 keyword indicates that we should place the variable
2850 in a particular register. */
2851 if (DECL_REGISTER (decl
))
2852 DECL_C_HARD_REGISTER (decl
) = 1;
2854 /* If this is not a static variable, issue a warning.
2855 It doesn't make any sense to give an ASMSPEC for an
2856 ordinary, non-register local variable. Historically,
2857 GCC has accepted -- but ignored -- the ASMSPEC in
2859 if (TREE_CODE (decl
) == VAR_DECL
2860 && !DECL_REGISTER (decl
)
2861 && !TREE_STATIC (decl
))
2862 warning ("%Jignoring asm-specifier for non-static local "
2863 "variable '%D'", decl
, decl
);
2865 change_decl_assembler_name (decl
, get_identifier (asmspec
));
2868 if (TREE_CODE (decl
) != FUNCTION_DECL
)
2869 add_decl_stmt (decl
);
2872 if (!DECL_FILE_SCOPE_P (decl
))
2874 /* Recompute the RTL of a local array now
2875 if it used to be an incomplete type. */
2877 && ! TREE_STATIC (decl
) && ! DECL_EXTERNAL (decl
))
2879 /* If we used it already as memory, it must stay in memory. */
2880 TREE_ADDRESSABLE (decl
) = TREE_USED (decl
);
2881 /* If it's still incomplete now, no init will save it. */
2882 if (DECL_SIZE (decl
) == 0)
2883 DECL_INITIAL (decl
) = 0;
2888 /* If this was marked 'used', be sure it will be output. */
2889 if (lookup_attribute ("used", DECL_ATTRIBUTES (decl
)))
2890 mark_referenced (DECL_ASSEMBLER_NAME (decl
));
2892 if (TREE_CODE (decl
) == TYPE_DECL
)
2893 rest_of_decl_compilation (decl
, NULL
, DECL_FILE_SCOPE_P (decl
), 0);
2895 /* At the end of a declaration, throw away any variable type sizes
2896 of types defined inside that declaration. There is no use
2897 computing them in the following function definition. */
2898 if (current_scope
== global_scope
)
2899 get_pending_sizes ();
2901 /* Install a cleanup (aka destructor) if one was given. */
2902 if (TREE_CODE (decl
) == VAR_DECL
&& !TREE_STATIC (decl
))
2904 tree attr
= lookup_attribute ("cleanup", DECL_ATTRIBUTES (decl
));
2907 static bool eh_initialized_p
;
2909 tree cleanup_id
= TREE_VALUE (TREE_VALUE (attr
));
2910 tree cleanup_decl
= lookup_name (cleanup_id
);
2913 /* Build "cleanup(&decl)" for the destructor. */
2914 cleanup
= build_unary_op (ADDR_EXPR
, decl
, 0);
2915 cleanup
= build_tree_list (NULL_TREE
, cleanup
);
2916 cleanup
= build_function_call (cleanup_decl
, cleanup
);
2918 /* Don't warn about decl unused; the cleanup uses it. */
2919 TREE_USED (decl
) = 1;
2921 /* Initialize EH, if we've been told to do so. */
2922 if (flag_exceptions
&& !eh_initialized_p
)
2924 eh_initialized_p
= true;
2925 eh_personality_libfunc
2926 = init_one_libfunc (USING_SJLJ_EXCEPTIONS
2927 ? "__gcc_personality_sj0"
2928 : "__gcc_personality_v0");
2929 using_eh_for_cleanups ();
2932 add_stmt (build_stmt (CLEANUP_STMT
, decl
, cleanup
));
2937 /* Given a parsed parameter declaration, decode it into a PARM_DECL
2938 and push that on the current scope. */
2941 push_parm_decl (tree parm
)
2945 /* Don't attempt to expand sizes while parsing this decl.
2946 (We can get here with i_s_e 1 somehow from Objective-C.) */
2947 int save_immediate_size_expand
= immediate_size_expand
;
2948 immediate_size_expand
= 0;
2950 decl
= grokdeclarator (TREE_VALUE (TREE_PURPOSE (parm
)),
2951 TREE_PURPOSE (TREE_PURPOSE (parm
)),
2953 decl_attributes (&decl
, TREE_VALUE (parm
), 0);
2955 decl
= pushdecl (decl
);
2957 finish_decl (decl
, NULL_TREE
, NULL_TREE
);
2959 immediate_size_expand
= save_immediate_size_expand
;
2962 /* Mark all the parameter declarations to date as forward decls,
2963 shift them to the variables list, and reset the parameters list.
2964 Also diagnose use of this extension. */
2967 mark_forward_parm_decls (void)
2971 if (pedantic
&& !current_scope
->warned_forward_parm_decls
)
2973 pedwarn ("ISO C forbids forward parameter declarations");
2974 current_scope
->warned_forward_parm_decls
= true;
2977 for (parm
= current_scope
->parms
; parm
; parm
= TREE_CHAIN (parm
))
2978 TREE_ASM_WRITTEN (parm
) = 1;
2980 SCOPE_LIST_CONCAT (current_scope
, names
, current_scope
, parms
);
2981 current_scope
->parms
= 0;
2982 current_scope
->parms_last
= 0;
2985 static GTY(()) int compound_literal_number
;
2987 /* Build a COMPOUND_LITERAL_EXPR. TYPE is the type given in the compound
2988 literal, which may be an incomplete array type completed by the
2989 initializer; INIT is a CONSTRUCTOR that initializes the compound
2993 build_compound_literal (tree type
, tree init
)
2995 /* We do not use start_decl here because we have a type, not a declarator;
2996 and do not use finish_decl because the decl should be stored inside
2997 the COMPOUND_LITERAL_EXPR rather than added elsewhere as a DECL_STMT. */
2998 tree decl
= build_decl (VAR_DECL
, NULL_TREE
, type
);
3001 DECL_EXTERNAL (decl
) = 0;
3002 TREE_PUBLIC (decl
) = 0;
3003 TREE_STATIC (decl
) = (current_scope
== global_scope
);
3004 DECL_CONTEXT (decl
) = current_function_decl
;
3005 TREE_USED (decl
) = 1;
3006 TREE_TYPE (decl
) = type
;
3007 TREE_READONLY (decl
) = TREE_READONLY (type
);
3008 store_init_value (decl
, init
);
3010 if (TREE_CODE (type
) == ARRAY_TYPE
&& !COMPLETE_TYPE_P (type
))
3012 int failure
= complete_array_type (type
, DECL_INITIAL (decl
), 1);
3017 type
= TREE_TYPE (decl
);
3018 if (type
== error_mark_node
|| !COMPLETE_TYPE_P (type
))
3019 return error_mark_node
;
3021 stmt
= build_stmt (DECL_STMT
, decl
);
3022 complit
= build1 (COMPOUND_LITERAL_EXPR
, TREE_TYPE (decl
), stmt
);
3023 TREE_SIDE_EFFECTS (complit
) = 1;
3025 layout_decl (decl
, 0);
3027 if (TREE_STATIC (decl
))
3029 /* This decl needs a name for the assembler output. We also need
3030 a unique suffix to be added to the name. */
3033 ASM_FORMAT_PRIVATE_NAME (name
, "__compound_literal",
3034 compound_literal_number
);
3035 compound_literal_number
++;
3036 DECL_NAME (decl
) = get_identifier (name
);
3037 DECL_DEFER_OUTPUT (decl
) = 1;
3038 DECL_COMDAT (decl
) = 1;
3039 DECL_ARTIFICIAL (decl
) = 1;
3041 rest_of_decl_compilation (decl
, NULL
, 1, 0);
3047 /* Make TYPE a complete type based on INITIAL_VALUE.
3048 Return 0 if successful, 1 if INITIAL_VALUE can't be deciphered,
3049 2 if there was no information (in which case assume 1 if DO_DEFAULT). */
3052 complete_array_type (tree type
, tree initial_value
, int do_default
)
3054 tree maxindex
= NULL_TREE
;
3059 /* Note MAXINDEX is really the maximum index,
3060 one less than the size. */
3061 if (TREE_CODE (initial_value
) == STRING_CST
)
3064 = int_size_in_bytes (TREE_TYPE (TREE_TYPE (initial_value
)));
3065 maxindex
= build_int_2 ((TREE_STRING_LENGTH (initial_value
)
3068 else if (TREE_CODE (initial_value
) == CONSTRUCTOR
)
3070 tree elts
= CONSTRUCTOR_ELTS (initial_value
);
3071 maxindex
= build_int_2 (-1, -1);
3072 for (; elts
; elts
= TREE_CHAIN (elts
))
3074 if (TREE_PURPOSE (elts
))
3075 maxindex
= TREE_PURPOSE (elts
);
3077 maxindex
= fold (build (PLUS_EXPR
, integer_type_node
,
3078 maxindex
, integer_one_node
));
3080 maxindex
= copy_node (maxindex
);
3084 /* Make an error message unless that happened already. */
3085 if (initial_value
!= error_mark_node
)
3088 /* Prevent further error messages. */
3089 maxindex
= build_int_2 (0, 0);
3096 maxindex
= build_int_2 (0, 0);
3102 TYPE_DOMAIN (type
) = build_index_type (maxindex
);
3103 if (!TREE_TYPE (maxindex
))
3104 TREE_TYPE (maxindex
) = TYPE_DOMAIN (type
);
3107 /* Lay out the type now that we can get the real answer. */
3114 /* Determine whether TYPE is a structure with a flexible array member,
3115 or a union containing such a structure (possibly recursively). */
3118 flexible_array_type_p (tree type
)
3121 switch (TREE_CODE (type
))
3124 x
= TYPE_FIELDS (type
);
3127 while (TREE_CHAIN (x
) != NULL_TREE
)
3129 if (TREE_CODE (TREE_TYPE (x
)) == ARRAY_TYPE
3130 && TYPE_SIZE (TREE_TYPE (x
)) == NULL_TREE
3131 && TYPE_DOMAIN (TREE_TYPE (x
)) != NULL_TREE
3132 && TYPE_MAX_VALUE (TYPE_DOMAIN (TREE_TYPE (x
))) == NULL_TREE
)
3136 for (x
= TYPE_FIELDS (type
); x
!= NULL_TREE
; x
= TREE_CHAIN (x
))
3138 if (flexible_array_type_p (TREE_TYPE (x
)))
3147 /* Performs sanity checks on the TYPE and WIDTH of the bit-field NAME,
3148 replacing with appropriate values if they are invalid. */
3150 check_bitfield_type_and_width (tree
*type
, tree
*width
, const char *orig_name
)
3153 unsigned int max_width
;
3154 unsigned HOST_WIDE_INT w
;
3155 const char *name
= orig_name
? orig_name
: _("<anonymous>");
3158 STRIP_NOPS (*width
);
3160 /* Detect and ignore out of range field width and process valid
3162 if (TREE_CODE (*width
) != INTEGER_CST
)
3164 error ("bit-field `%s' width not an integer constant", name
);
3165 *width
= integer_one_node
;
3169 constant_expression_warning (*width
);
3170 if (tree_int_cst_sgn (*width
) < 0)
3172 error ("negative width in bit-field `%s'", name
);
3173 *width
= integer_one_node
;
3175 else if (integer_zerop (*width
) && orig_name
)
3177 error ("zero width for bit-field `%s'", name
);
3178 *width
= integer_one_node
;
3182 /* Detect invalid bit-field type. */
3183 if (TREE_CODE (*type
) != INTEGER_TYPE
3184 && TREE_CODE (*type
) != BOOLEAN_TYPE
3185 && TREE_CODE (*type
) != ENUMERAL_TYPE
)
3187 error ("bit-field `%s' has invalid type", name
);
3188 *type
= unsigned_type_node
;
3191 type_mv
= TYPE_MAIN_VARIANT (*type
);
3193 && type_mv
!= integer_type_node
3194 && type_mv
!= unsigned_type_node
3195 && type_mv
!= boolean_type_node
)
3196 pedwarn ("type of bit-field `%s' is a GCC extension", name
);
3198 if (type_mv
== boolean_type_node
)
3199 max_width
= CHAR_TYPE_SIZE
;
3201 max_width
= TYPE_PRECISION (*type
);
3203 if (0 < compare_tree_int (*width
, max_width
))
3205 error ("width of `%s' exceeds its type", name
);
3207 *width
= build_int_2 (w
, 0);
3210 w
= tree_low_cst (*width
, 1);
3212 if (TREE_CODE (*type
) == ENUMERAL_TYPE
3213 && (w
< min_precision (TYPE_MIN_VALUE (*type
), TREE_UNSIGNED (*type
))
3214 || w
< min_precision (TYPE_MAX_VALUE (*type
), TREE_UNSIGNED (*type
))))
3215 warning ("`%s' is narrower than values of its type", name
);
3218 /* Given declspecs and a declarator,
3219 determine the name and type of the object declared
3220 and construct a ..._DECL node for it.
3221 (In one case we can return a ..._TYPE node instead.
3222 For invalid input we sometimes return 0.)
3224 DECLSPECS is a chain of tree_list nodes whose value fields
3225 are the storage classes and type specifiers.
3227 DECL_CONTEXT says which syntactic context this declaration is in:
3228 NORMAL for most contexts. Make a VAR_DECL or FUNCTION_DECL or TYPE_DECL.
3229 FUNCDEF for a function definition. Like NORMAL but a few different
3230 error messages in each case. Return value may be zero meaning
3231 this definition is too screwy to try to parse.
3232 PARM for a parameter declaration (either within a function prototype
3233 or before a function body). Make a PARM_DECL, or return void_type_node.
3234 TYPENAME if for a typename (in a cast or sizeof).
3235 Don't make a DECL node; just return the ..._TYPE node.
3236 FIELD for a struct or union field; make a FIELD_DECL.
3237 INITIALIZED is 1 if the decl has an initializer.
3238 WIDTH is non-NULL for bit-fields, and is a pointer to an INTEGER_CST node
3239 representing the width of the bit-field.
3241 In the TYPENAME case, DECLARATOR is really an absolute declarator.
3242 It may also be so in the PARM case, for a prototype where the
3243 argument type is specified but not the name.
3245 This function is where the complicated C meanings of `static'
3246 and `extern' are interpreted. */
3249 grokdeclarator (tree declarator
, tree declspecs
,
3250 enum decl_context decl_context
, int initialized
, tree
*width
)
3254 tree type
= NULL_TREE
;
3259 int type_quals
= TYPE_UNQUALIFIED
;
3261 int explicit_int
= 0;
3262 int explicit_char
= 0;
3263 int defaulted_int
= 0;
3264 tree typedef_decl
= 0;
3265 const char *name
, *orig_name
;
3266 tree typedef_type
= 0;
3267 int funcdef_flag
= 0;
3268 enum tree_code innermost_code
= ERROR_MARK
;
3269 int size_varies
= 0;
3270 tree decl_attr
= NULL_TREE
;
3271 tree array_ptr_quals
= NULL_TREE
;
3272 int array_parm_static
= 0;
3273 tree returned_attrs
= NULL_TREE
;
3274 bool bitfield
= width
!= NULL
;
3277 if (decl_context
== FUNCDEF
)
3278 funcdef_flag
= 1, decl_context
= NORMAL
;
3280 /* Look inside a declarator for the name being declared
3281 and get it as a string, for an error message. */
3283 tree decl
= declarator
;
3287 switch (TREE_CODE (decl
))
3292 innermost_code
= TREE_CODE (decl
);
3293 decl
= TREE_OPERAND (decl
, 0);
3297 decl
= TREE_VALUE (decl
);
3300 case IDENTIFIER_NODE
:
3301 name
= IDENTIFIER_POINTER (decl
);
3313 /* A function definition's declarator must have the form of
3314 a function declarator. */
3316 if (funcdef_flag
&& innermost_code
!= CALL_EXPR
)
3319 /* If this looks like a function definition, make it one,
3320 even if it occurs where parms are expected.
3321 Then store_parm_decls will reject it and not use it as a parm. */
3322 if (decl_context
== NORMAL
&& !funcdef_flag
3323 && current_scope
->parm_flag
)
3324 decl_context
= PARM
;
3326 /* Look through the decl specs and record which ones appear.
3327 Some typespecs are defined as built-in typenames.
3328 Others, the ones that are modifiers of other types,
3329 are represented by bits in SPECBITS: set the bits for
3330 the modifiers that appear. Storage class keywords are also in SPECBITS.
3332 If there is a typedef name or a type, store the type in TYPE.
3333 This includes builtin typedefs such as `int'.
3335 Set EXPLICIT_INT or EXPLICIT_CHAR if the type is `int' or `char'
3336 and did not come from a user typedef.
3338 Set LONGLONG if `long' is mentioned twice. */
3340 for (spec
= declspecs
; spec
; spec
= TREE_CHAIN (spec
))
3342 tree id
= TREE_VALUE (spec
);
3344 /* If the entire declaration is itself tagged as deprecated then
3345 suppress reports of deprecated items. */
3346 if (id
&& TREE_DEPRECATED (id
))
3348 if (deprecated_state
!= DEPRECATED_SUPPRESS
)
3349 warn_deprecated_use (id
);
3352 if (id
== ridpointers
[(int) RID_INT
])
3354 if (id
== ridpointers
[(int) RID_CHAR
])
3357 if (TREE_CODE (id
) == IDENTIFIER_NODE
&& C_IS_RESERVED_WORD (id
))
3359 enum rid i
= C_RID_CODE (id
);
3360 if ((int) i
<= (int) RID_LAST_MODIFIER
)
3362 if (i
== RID_LONG
&& (specbits
& (1 << (int) RID_LONG
)))
3365 error ("`long long long' is too long for GCC");
3368 if (pedantic
&& !flag_isoc99
&& ! in_system_header
3370 pedwarn ("ISO C90 does not support `long long'");
3374 else if (specbits
& (1 << (int) i
))
3376 if (i
== RID_CONST
|| i
== RID_VOLATILE
|| i
== RID_RESTRICT
)
3379 pedwarn ("duplicate `%s'", IDENTIFIER_POINTER (id
));
3382 error ("duplicate `%s'", IDENTIFIER_POINTER (id
));
3385 /* Diagnose "__thread extern". Recall that this list
3386 is in the reverse order seen in the text. */
3388 && (specbits
& (1 << (int) RID_EXTERN
3389 | 1 << (int) RID_STATIC
)))
3391 if (specbits
& 1 << (int) RID_EXTERN
)
3392 error ("`__thread' before `extern'");
3394 error ("`__thread' before `static'");
3397 specbits
|= 1 << (int) i
;
3402 error ("two or more data types in declaration of `%s'", name
);
3403 /* Actual typedefs come to us as TYPE_DECL nodes. */
3404 else if (TREE_CODE (id
) == TYPE_DECL
)
3406 if (TREE_TYPE (id
) == error_mark_node
)
3407 ; /* Allow the type to default to int to avoid cascading errors. */
3410 type
= TREE_TYPE (id
);
3411 decl_attr
= DECL_ATTRIBUTES (id
);
3415 /* Built-in types come as identifiers. */
3416 else if (TREE_CODE (id
) == IDENTIFIER_NODE
)
3418 tree t
= lookup_name (id
);
3419 if (TREE_TYPE (t
) == error_mark_node
)
3421 else if (!t
|| TREE_CODE (t
) != TYPE_DECL
)
3422 error ("`%s' fails to be a typedef or built in type",
3423 IDENTIFIER_POINTER (id
));
3426 type
= TREE_TYPE (t
);
3430 else if (TREE_CODE (id
) != ERROR_MARK
)
3437 typedef_type
= type
;
3439 size_varies
= C_TYPE_VARIABLE_SIZE (type
);
3441 /* No type at all: default to `int', and set DEFAULTED_INT
3442 because it was not a user-defined typedef. */
3446 if ((! (specbits
& ((1 << (int) RID_LONG
) | (1 << (int) RID_SHORT
)
3447 | (1 << (int) RID_SIGNED
)
3448 | (1 << (int) RID_UNSIGNED
)
3449 | (1 << (int) RID_COMPLEX
))))
3450 /* Don't warn about typedef foo = bar. */
3451 && ! (specbits
& (1 << (int) RID_TYPEDEF
) && initialized
)
3452 && ! in_system_header
)
3454 /* Issue a warning if this is an ISO C 99 program or if -Wreturn-type
3455 and this is a function, or if -Wimplicit; prefer the former
3456 warning since it is more explicit. */
3457 if ((warn_implicit_int
|| warn_return_type
|| flag_isoc99
)
3459 warn_about_return_type
= 1;
3460 else if (warn_implicit_int
|| flag_isoc99
)
3461 pedwarn_c99 ("type defaults to `int' in declaration of `%s'",
3466 type
= integer_type_node
;
3469 /* Now process the modifiers that were specified
3470 and check for invalid combinations. */
3472 /* Long double is a special combination. */
3474 if ((specbits
& 1 << (int) RID_LONG
) && ! longlong
3475 && TYPE_MAIN_VARIANT (type
) == double_type_node
)
3477 specbits
&= ~(1 << (int) RID_LONG
);
3478 type
= long_double_type_node
;
3481 /* Check all other uses of type modifiers. */
3483 if (specbits
& ((1 << (int) RID_LONG
) | (1 << (int) RID_SHORT
)
3484 | (1 << (int) RID_UNSIGNED
) | (1 << (int) RID_SIGNED
)))
3488 if ((specbits
& 1 << (int) RID_LONG
)
3489 && (specbits
& 1 << (int) RID_SHORT
))
3490 error ("both long and short specified for `%s'", name
);
3491 else if (((specbits
& 1 << (int) RID_LONG
)
3492 || (specbits
& 1 << (int) RID_SHORT
))
3494 error ("long or short specified with char for `%s'", name
);
3495 else if (((specbits
& 1 << (int) RID_LONG
)
3496 || (specbits
& 1 << (int) RID_SHORT
))
3497 && TREE_CODE (type
) == REAL_TYPE
)
3499 static int already
= 0;
3501 error ("long or short specified with floating type for `%s'", name
);
3502 if (! already
&& ! pedantic
)
3504 error ("the only valid combination is `long double'");
3508 else if ((specbits
& 1 << (int) RID_SIGNED
)
3509 && (specbits
& 1 << (int) RID_UNSIGNED
))
3510 error ("both signed and unsigned specified for `%s'", name
);
3511 else if (TREE_CODE (type
) != INTEGER_TYPE
)
3512 error ("long, short, signed or unsigned invalid for `%s'", name
);
3516 if (!explicit_int
&& !defaulted_int
&& !explicit_char
)
3518 error ("long, short, signed or unsigned used invalidly for `%s'",
3524 /* Discard the type modifiers if they are invalid. */
3527 specbits
&= ~((1 << (int) RID_LONG
) | (1 << (int) RID_SHORT
)
3528 | (1 << (int) RID_UNSIGNED
) | (1 << (int) RID_SIGNED
));
3533 if ((specbits
& (1 << (int) RID_COMPLEX
))
3534 && TREE_CODE (type
) != INTEGER_TYPE
&& TREE_CODE (type
) != REAL_TYPE
)
3536 error ("complex invalid for `%s'", name
);
3537 specbits
&= ~(1 << (int) RID_COMPLEX
);
3540 /* Decide whether an integer type is signed or not.
3541 Optionally treat bit-fields as signed by default. */
3542 if (specbits
& 1 << (int) RID_UNSIGNED
3543 || (bitfield
&& ! flag_signed_bitfields
3544 && (explicit_int
|| defaulted_int
|| explicit_char
3545 /* A typedef for plain `int' without `signed'
3546 can be controlled just like plain `int'. */
3547 || ! (typedef_decl
!= 0
3548 && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl
)))
3549 && TREE_CODE (type
) != ENUMERAL_TYPE
3550 && !(specbits
& 1 << (int) RID_SIGNED
)))
3553 type
= long_long_unsigned_type_node
;
3554 else if (specbits
& 1 << (int) RID_LONG
)
3555 type
= long_unsigned_type_node
;
3556 else if (specbits
& 1 << (int) RID_SHORT
)
3557 type
= short_unsigned_type_node
;
3558 else if (type
== char_type_node
)
3559 type
= unsigned_char_type_node
;
3560 else if (typedef_decl
)
3561 type
= c_common_unsigned_type (type
);
3563 type
= unsigned_type_node
;
3565 else if ((specbits
& 1 << (int) RID_SIGNED
)
3566 && type
== char_type_node
)
3567 type
= signed_char_type_node
;
3569 type
= long_long_integer_type_node
;
3570 else if (specbits
& 1 << (int) RID_LONG
)
3571 type
= long_integer_type_node
;
3572 else if (specbits
& 1 << (int) RID_SHORT
)
3573 type
= short_integer_type_node
;
3575 if (specbits
& 1 << (int) RID_COMPLEX
)
3577 if (pedantic
&& !flag_isoc99
)
3578 pedwarn ("ISO C90 does not support complex types");
3579 /* If we just have "complex", it is equivalent to
3580 "complex double", but if any modifiers at all are specified it is
3581 the complex form of TYPE. E.g, "complex short" is
3582 "complex short int". */
3584 if (defaulted_int
&& ! longlong
3585 && ! (specbits
& ((1 << (int) RID_LONG
) | (1 << (int) RID_SHORT
)
3586 | (1 << (int) RID_SIGNED
)
3587 | (1 << (int) RID_UNSIGNED
))))
3590 pedwarn ("ISO C does not support plain `complex' meaning `double complex'");
3591 type
= complex_double_type_node
;
3593 else if (type
== integer_type_node
)
3596 pedwarn ("ISO C does not support complex integer types");
3597 type
= complex_integer_type_node
;
3599 else if (type
== float_type_node
)
3600 type
= complex_float_type_node
;
3601 else if (type
== double_type_node
)
3602 type
= complex_double_type_node
;
3603 else if (type
== long_double_type_node
)
3604 type
= complex_long_double_type_node
;
3608 pedwarn ("ISO C does not support complex integer types");
3609 type
= build_complex_type (type
);
3613 /* Check the type and width of a bit-field. */
3615 check_bitfield_type_and_width (&type
, width
, orig_name
);
3617 /* Figure out the type qualifiers for the declaration. There are
3618 two ways a declaration can become qualified. One is something
3619 like `const int i' where the `const' is explicit. Another is
3620 something like `typedef const int CI; CI i' where the type of the
3621 declaration contains the `const'. A third possibility is that
3622 there is a type qualifier on the element type of a typedefed
3623 array type, in which case we should extract that qualifier so
3624 that c_apply_type_quals_to_decls receives the full list of
3625 qualifiers to work with (C90 is not entirely clear about whether
3626 duplicate qualifiers should be diagnosed in this case, but it
3627 seems most appropriate to do so). */
3628 element_type
= strip_array_types (type
);
3629 constp
= !! (specbits
& 1 << (int) RID_CONST
) + TYPE_READONLY (element_type
);
3631 = !! (specbits
& 1 << (int) RID_RESTRICT
) + TYPE_RESTRICT (element_type
);
3633 = !! (specbits
& 1 << (int) RID_VOLATILE
) + TYPE_VOLATILE (element_type
);
3634 inlinep
= !! (specbits
& (1 << (int) RID_INLINE
));
3635 if (constp
> 1 && ! flag_isoc99
)
3636 pedwarn ("duplicate `const'");
3637 if (restrictp
> 1 && ! flag_isoc99
)
3638 pedwarn ("duplicate `restrict'");
3639 if (volatilep
> 1 && ! flag_isoc99
)
3640 pedwarn ("duplicate `volatile'");
3641 if (! flag_gen_aux_info
&& (TYPE_QUALS (type
)))
3642 type
= TYPE_MAIN_VARIANT (type
);
3643 type_quals
= ((constp
? TYPE_QUAL_CONST
: 0)
3644 | (restrictp
? TYPE_QUAL_RESTRICT
: 0)
3645 | (volatilep
? TYPE_QUAL_VOLATILE
: 0));
3647 /* Warn if two storage classes are given. Default to `auto'. */
3652 if (specbits
& 1 << (int) RID_AUTO
) nclasses
++;
3653 if (specbits
& 1 << (int) RID_STATIC
) nclasses
++;
3654 if (specbits
& 1 << (int) RID_EXTERN
) nclasses
++;
3655 if (specbits
& 1 << (int) RID_REGISTER
) nclasses
++;
3656 if (specbits
& 1 << (int) RID_TYPEDEF
) nclasses
++;
3658 /* "static __thread" and "extern __thread" are allowed. */
3659 if ((specbits
& (1 << (int) RID_THREAD
3660 | 1 << (int) RID_STATIC
3661 | 1 << (int) RID_EXTERN
)) == (1 << (int) RID_THREAD
))
3664 /* Warn about storage classes that are invalid for certain
3665 kinds of declarations (parameters, typenames, etc.). */
3668 error ("multiple storage classes in declaration of `%s'", name
);
3669 else if (funcdef_flag
3671 & ((1 << (int) RID_REGISTER
)
3672 | (1 << (int) RID_AUTO
)
3673 | (1 << (int) RID_TYPEDEF
)
3674 | (1 << (int) RID_THREAD
))))
3676 if (specbits
& 1 << (int) RID_AUTO
3677 && (pedantic
|| current_scope
== global_scope
))
3678 pedwarn ("function definition declared `auto'");
3679 if (specbits
& 1 << (int) RID_REGISTER
)
3680 error ("function definition declared `register'");
3681 if (specbits
& 1 << (int) RID_TYPEDEF
)
3682 error ("function definition declared `typedef'");
3683 if (specbits
& 1 << (int) RID_THREAD
)
3684 error ("function definition declared `__thread'");
3685 specbits
&= ~((1 << (int) RID_TYPEDEF
) | (1 << (int) RID_REGISTER
)
3686 | (1 << (int) RID_AUTO
) | (1 << (int) RID_THREAD
));
3688 else if (decl_context
!= NORMAL
&& nclasses
> 0)
3690 if (decl_context
== PARM
&& specbits
& 1 << (int) RID_REGISTER
)
3694 switch (decl_context
)
3697 error ("storage class specified for structure field `%s'",
3701 error ("storage class specified for parameter `%s'", name
);
3704 error ("storage class specified for typename");
3707 specbits
&= ~((1 << (int) RID_TYPEDEF
) | (1 << (int) RID_REGISTER
)
3708 | (1 << (int) RID_AUTO
) | (1 << (int) RID_STATIC
)
3709 | (1 << (int) RID_EXTERN
) | (1 << (int) RID_THREAD
));
3712 else if (specbits
& 1 << (int) RID_EXTERN
&& initialized
&& ! funcdef_flag
)
3714 /* `extern' with initialization is invalid if not at file scope. */
3715 if (current_scope
== global_scope
)
3716 warning ("`%s' initialized and declared `extern'", name
);
3718 error ("`%s' has both `extern' and initializer", name
);
3720 else if (current_scope
== global_scope
)
3722 if (specbits
& 1 << (int) RID_AUTO
)
3723 error ("file-scope declaration of `%s' specifies `auto'", name
);
3727 if (specbits
& 1 << (int) RID_EXTERN
&& funcdef_flag
)
3728 error ("nested function `%s' declared `extern'", name
);
3729 else if ((specbits
& (1 << (int) RID_THREAD
3730 | 1 << (int) RID_EXTERN
3731 | 1 << (int) RID_STATIC
))
3732 == (1 << (int) RID_THREAD
))
3734 error ("function-scope `%s' implicitly auto and declared `__thread'",
3736 specbits
&= ~(1 << (int) RID_THREAD
);
3741 /* Now figure out the structure of the declarator proper.
3742 Descend through it, creating more complex types, until we reach
3743 the declared identifier (or NULL_TREE, in an absolute declarator). */
3745 while (declarator
&& TREE_CODE (declarator
) != IDENTIFIER_NODE
)
3747 if (type
== error_mark_node
)
3749 declarator
= TREE_OPERAND (declarator
, 0);
3753 /* Each level of DECLARATOR is either an ARRAY_REF (for ...[..]),
3754 an INDIRECT_REF (for *...),
3755 a CALL_EXPR (for ...(...)),
3756 a TREE_LIST (for nested attributes),
3757 an identifier (for the name being declared)
3758 or a null pointer (for the place in an absolute declarator
3759 where the name was omitted).
3760 For the last two cases, we have just exited the loop.
3762 At this point, TYPE is the type of elements of an array,
3763 or for a function to return, or for a pointer to point to.
3764 After this sequence of ifs, TYPE is the type of the
3765 array or function or pointer, and DECLARATOR has had its
3766 outermost layer removed. */
3768 if (array_ptr_quals
!= NULL_TREE
|| array_parm_static
)
3770 /* Only the innermost declarator (making a parameter be of
3771 array type which is converted to pointer type)
3772 may have static or type qualifiers. */
3773 error ("static or type qualifiers in non-parameter array declarator");
3774 array_ptr_quals
= NULL_TREE
;
3775 array_parm_static
= 0;
3778 if (TREE_CODE (declarator
) == TREE_LIST
)
3780 /* We encode a declarator with embedded attributes using
3782 tree attrs
= TREE_PURPOSE (declarator
);
3785 declarator
= TREE_VALUE (declarator
);
3786 inner_decl
= declarator
;
3787 while (inner_decl
!= NULL_TREE
3788 && TREE_CODE (inner_decl
) == TREE_LIST
)
3789 inner_decl
= TREE_VALUE (inner_decl
);
3790 if (inner_decl
== NULL_TREE
3791 || TREE_CODE (inner_decl
) == IDENTIFIER_NODE
)
3792 attr_flags
|= (int) ATTR_FLAG_DECL_NEXT
;
3793 else if (TREE_CODE (inner_decl
) == CALL_EXPR
)
3794 attr_flags
|= (int) ATTR_FLAG_FUNCTION_NEXT
;
3795 else if (TREE_CODE (inner_decl
) == ARRAY_REF
)
3796 attr_flags
|= (int) ATTR_FLAG_ARRAY_NEXT
;
3797 returned_attrs
= decl_attributes (&type
,
3798 chainon (returned_attrs
, attrs
),
3801 else if (TREE_CODE (declarator
) == ARRAY_REF
)
3803 tree itype
= NULL_TREE
;
3804 tree size
= TREE_OPERAND (declarator
, 1);
3805 /* The index is a signed object `sizetype' bits wide. */
3806 tree index_type
= c_common_signed_type (sizetype
);
3808 array_ptr_quals
= TREE_TYPE (declarator
);
3809 array_parm_static
= TREE_STATIC (declarator
);
3811 declarator
= TREE_OPERAND (declarator
, 0);
3813 /* Check for some types that there cannot be arrays of. */
3815 if (VOID_TYPE_P (type
))
3817 error ("declaration of `%s' as array of voids", name
);
3818 type
= error_mark_node
;
3821 if (TREE_CODE (type
) == FUNCTION_TYPE
)
3823 error ("declaration of `%s' as array of functions", name
);
3824 type
= error_mark_node
;
3827 if (pedantic
&& flexible_array_type_p (type
))
3828 pedwarn ("invalid use of structure with flexible array member");
3830 if (size
== error_mark_node
)
3831 type
= error_mark_node
;
3833 if (type
== error_mark_node
)
3836 /* If size was specified, set ITYPE to a range-type for that size.
3837 Otherwise, ITYPE remains null. finish_decl may figure it out
3838 from an initial value. */
3842 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue. */
3843 STRIP_TYPE_NOPS (size
);
3845 if (! INTEGRAL_TYPE_P (TREE_TYPE (size
)))
3847 error ("size of array `%s' has non-integer type", name
);
3848 size
= integer_one_node
;
3851 if (pedantic
&& integer_zerop (size
))
3852 pedwarn ("ISO C forbids zero-size array `%s'", name
);
3854 if (TREE_CODE (size
) == INTEGER_CST
)
3856 constant_expression_warning (size
);
3857 if (tree_int_cst_sgn (size
) < 0)
3859 error ("size of array `%s' is negative", name
);
3860 size
= integer_one_node
;
3865 /* Make sure the array size remains visibly nonconstant
3866 even if it is (eg) a const variable with known value. */
3869 if (!flag_isoc99
&& pedantic
)
3871 if (TREE_CONSTANT (size
))
3872 pedwarn ("ISO C90 forbids array `%s' whose size can't be evaluated",
3875 pedwarn ("ISO C90 forbids variable-size array `%s'",
3880 if (integer_zerop (size
))
3882 /* A zero-length array cannot be represented with an
3883 unsigned index type, which is what we'll get with
3884 build_index_type. Create an open-ended range instead. */
3885 itype
= build_range_type (sizetype
, size
, NULL_TREE
);
3889 /* Compute the maximum valid index, that is, size - 1.
3890 Do the calculation in index_type, so that if it is
3891 a variable the computations will be done in the
3893 itype
= fold (build (MINUS_EXPR
, index_type
,
3894 convert (index_type
, size
),
3895 convert (index_type
, size_one_node
)));
3897 /* If that overflowed, the array is too big.
3898 ??? While a size of INT_MAX+1 technically shouldn't
3899 cause an overflow (because we subtract 1), the overflow
3900 is recorded during the conversion to index_type, before
3901 the subtraction. Handling this case seems like an
3902 unnecessary complication. */
3903 if (TREE_OVERFLOW (itype
))
3905 error ("size of array `%s' is too large", name
);
3906 type
= error_mark_node
;
3912 /* We must be able to distinguish the
3913 SAVE_EXPR_CONTEXT for the variably-sized type
3914 so that we can set it correctly in
3915 set_save_expr_context. The convention is
3916 that all SAVE_EXPRs that need to be reset
3917 have NULL_TREE for their SAVE_EXPR_CONTEXT. */
3918 tree cfd
= current_function_decl
;
3919 if (decl_context
== PARM
)
3920 current_function_decl
= NULL_TREE
;
3921 itype
= variable_size (itype
);
3922 if (decl_context
== PARM
)
3923 current_function_decl
= cfd
;
3925 itype
= build_index_type (itype
);
3928 else if (decl_context
== FIELD
)
3930 if (pedantic
&& !flag_isoc99
&& !in_system_header
)
3931 pedwarn ("ISO C90 does not support flexible array members");
3933 /* ISO C99 Flexible array members are effectively identical
3934 to GCC's zero-length array extension. */
3935 itype
= build_range_type (sizetype
, size_zero_node
, NULL_TREE
);
3938 /* If pedantic, complain about arrays of incomplete types. */
3940 if (pedantic
&& !COMPLETE_TYPE_P (type
))
3941 pedwarn ("array type has incomplete element type");
3943 /* Build the array type itself, then merge any constancy or
3944 volatility into the target type. We must do it in this order
3945 to ensure that the TYPE_MAIN_VARIANT field of the array type
3946 is set correctly. */
3948 type
= build_array_type (type
, itype
);
3950 type
= c_build_qualified_type (type
, type_quals
);
3953 C_TYPE_VARIABLE_SIZE (type
) = 1;
3955 /* The GCC extension for zero-length arrays differs from
3956 ISO flexible array members in that sizeof yields zero. */
3957 if (size
&& integer_zerop (size
))
3960 TYPE_SIZE (type
) = bitsize_zero_node
;
3961 TYPE_SIZE_UNIT (type
) = size_zero_node
;
3963 if (decl_context
!= PARM
3964 && (array_ptr_quals
!= NULL_TREE
|| array_parm_static
))
3966 error ("static or type qualifiers in non-parameter array declarator");
3967 array_ptr_quals
= NULL_TREE
;
3968 array_parm_static
= 0;
3971 else if (TREE_CODE (declarator
) == CALL_EXPR
)
3975 /* Declaring a function type.
3976 Make sure we have a valid type for the function to return. */
3977 if (type
== error_mark_node
)
3982 /* Warn about some types functions can't return. */
3984 if (TREE_CODE (type
) == FUNCTION_TYPE
)
3986 error ("`%s' declared as function returning a function", name
);
3987 type
= integer_type_node
;
3989 if (TREE_CODE (type
) == ARRAY_TYPE
)
3991 error ("`%s' declared as function returning an array", name
);
3992 type
= integer_type_node
;
3995 /* Construct the function type and go to the next
3996 inner layer of declarator. */
3998 arg_types
= grokparms (TREE_OPERAND (declarator
, 1),
4000 /* Say it's a definition
4001 only for the CALL_EXPR
4002 closest to the identifier. */
4003 && TREE_CODE (TREE_OPERAND (declarator
, 0)) == IDENTIFIER_NODE
);
4004 /* Type qualifiers before the return type of the function
4005 qualify the return type, not the function type. */
4008 /* Type qualifiers on a function return type are normally
4009 permitted by the standard but have no effect, so give a
4010 warning at -Wextra. Qualifiers on a void return type have
4011 meaning as a GNU extension, and are banned on function
4012 definitions in ISO C. FIXME: strictly we shouldn't
4013 pedwarn for qualified void return types except on function
4014 definitions, but not doing so could lead to the undesirable
4015 state of a "volatile void" function return type not being
4016 warned about, and a use of the function being compiled
4017 with GNU semantics, with no diagnostics under -pedantic. */
4018 if (VOID_TYPE_P (type
) && pedantic
&& !in_system_header
)
4019 pedwarn ("ISO C forbids qualified void function return type");
4020 else if (extra_warnings
4021 && !(VOID_TYPE_P (type
)
4022 && type_quals
== TYPE_QUAL_VOLATILE
))
4023 warning ("type qualifiers ignored on function return type");
4025 type
= c_build_qualified_type (type
, type_quals
);
4027 type_quals
= TYPE_UNQUALIFIED
;
4029 type
= build_function_type (type
, arg_types
);
4030 declarator
= TREE_OPERAND (declarator
, 0);
4032 /* Set the TYPE_CONTEXTs for each tagged type which is local to
4033 the formal parameter list of this FUNCTION_TYPE to point to
4034 the FUNCTION_TYPE node itself. */
4039 for (link
= last_function_parm_tags
;
4041 link
= TREE_CHAIN (link
))
4042 TYPE_CONTEXT (TREE_VALUE (link
)) = type
;
4045 else if (TREE_CODE (declarator
) == INDIRECT_REF
)
4047 /* Merge any constancy or volatility into the target type
4050 if (pedantic
&& TREE_CODE (type
) == FUNCTION_TYPE
4052 pedwarn ("ISO C forbids qualified function types");
4054 type
= c_build_qualified_type (type
, type_quals
);
4055 type_quals
= TYPE_UNQUALIFIED
;
4058 type
= build_pointer_type (type
);
4060 /* Process a list of type modifier keywords
4061 (such as const or volatile) that were given inside the `*'. */
4063 if (TREE_TYPE (declarator
))
4071 for (typemodlist
= TREE_TYPE (declarator
); typemodlist
;
4072 typemodlist
= TREE_CHAIN (typemodlist
))
4074 tree qualifier
= TREE_VALUE (typemodlist
);
4076 if (C_IS_RESERVED_WORD (qualifier
))
4078 if (C_RID_CODE (qualifier
) == RID_CONST
)
4080 else if (C_RID_CODE (qualifier
) == RID_VOLATILE
)
4082 else if (C_RID_CODE (qualifier
) == RID_RESTRICT
)
4092 error ("invalid type modifier within pointer declarator");
4093 if (constp
> 1 && ! flag_isoc99
)
4094 pedwarn ("duplicate `const'");
4095 if (volatilep
> 1 && ! flag_isoc99
)
4096 pedwarn ("duplicate `volatile'");
4097 if (restrictp
> 1 && ! flag_isoc99
)
4098 pedwarn ("duplicate `restrict'");
4100 type_quals
= ((constp
? TYPE_QUAL_CONST
: 0)
4101 | (restrictp
? TYPE_QUAL_RESTRICT
: 0)
4102 | (volatilep
? TYPE_QUAL_VOLATILE
: 0));
4105 declarator
= TREE_OPERAND (declarator
, 0);
4112 /* Now TYPE has the actual type. */
4114 /* Did array size calculations overflow? */
4116 if (TREE_CODE (type
) == ARRAY_TYPE
4117 && COMPLETE_TYPE_P (type
)
4118 && TREE_OVERFLOW (TYPE_SIZE (type
)))
4120 error ("size of array `%s' is too large", name
);
4121 /* If we proceed with the array type as it is, we'll eventually
4122 crash in tree_low_cst(). */
4123 type
= error_mark_node
;
4126 /* If this is declaring a typedef name, return a TYPE_DECL. */
4128 if (specbits
& (1 << (int) RID_TYPEDEF
))
4131 /* Note that the grammar rejects storage classes
4132 in typenames, fields or parameters */
4133 if (pedantic
&& TREE_CODE (type
) == FUNCTION_TYPE
4135 pedwarn ("ISO C forbids qualified function types");
4137 type
= c_build_qualified_type (type
, type_quals
);
4138 decl
= build_decl (TYPE_DECL
, declarator
, type
);
4139 if ((specbits
& (1 << (int) RID_SIGNED
))
4140 || (typedef_decl
&& C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl
)))
4141 C_TYPEDEF_EXPLICITLY_SIGNED (decl
) = 1;
4142 decl_attributes (&decl
, returned_attrs
, 0);
4146 /* Detect the case of an array type of unspecified size
4147 which came, as such, direct from a typedef name.
4148 We must copy the type, so that each identifier gets
4149 a distinct type, so that each identifier's size can be
4150 controlled separately by its own initializer. */
4152 if (type
!= 0 && typedef_type
!= 0
4153 && TREE_CODE (type
) == ARRAY_TYPE
&& TYPE_DOMAIN (type
) == 0
4154 && TYPE_MAIN_VARIANT (type
) == TYPE_MAIN_VARIANT (typedef_type
))
4156 type
= build_array_type (TREE_TYPE (type
), 0);
4158 C_TYPE_VARIABLE_SIZE (type
) = 1;
4161 /* If this is a type name (such as, in a cast or sizeof),
4162 compute the type and return it now. */
4164 if (decl_context
== TYPENAME
)
4166 /* Note that the grammar rejects storage classes
4167 in typenames, fields or parameters */
4168 if (pedantic
&& TREE_CODE (type
) == FUNCTION_TYPE
4170 pedwarn ("ISO C forbids const or volatile function types");
4172 type
= c_build_qualified_type (type
, type_quals
);
4173 decl_attributes (&type
, returned_attrs
, 0);
4177 /* Aside from typedefs and type names (handle above),
4178 `void' at top level (not within pointer)
4179 is allowed only in public variables.
4180 We don't complain about parms either, but that is because
4181 a better error message can be made later. */
4183 if (VOID_TYPE_P (type
) && decl_context
!= PARM
4184 && ! ((decl_context
!= FIELD
&& TREE_CODE (type
) != FUNCTION_TYPE
)
4185 && ((specbits
& (1 << (int) RID_EXTERN
))
4186 || (current_scope
== global_scope
4188 & ((1 << (int) RID_STATIC
) | (1 << (int) RID_REGISTER
)))))))
4190 error ("variable or field `%s' declared void", name
);
4191 type
= integer_type_node
;
4194 /* Now create the decl, which may be a VAR_DECL, a PARM_DECL
4195 or a FUNCTION_DECL, depending on DECL_CONTEXT and TYPE. */
4200 if (decl_context
== PARM
)
4202 tree type_as_written
;
4205 /* A parameter declared as an array of T is really a pointer to T.
4206 One declared as a function is really a pointer to a function. */
4208 if (TREE_CODE (type
) == ARRAY_TYPE
)
4210 /* Transfer const-ness of array into that of type pointed to. */
4211 type
= TREE_TYPE (type
);
4213 type
= c_build_qualified_type (type
, type_quals
);
4214 type
= build_pointer_type (type
);
4215 type_quals
= TYPE_UNQUALIFIED
;
4216 if (array_ptr_quals
)
4218 tree new_ptr_quals
, new_ptr_attrs
;
4220 split_specs_attrs (array_ptr_quals
, &new_ptr_quals
, &new_ptr_attrs
);
4221 /* We don't yet implement attributes in this context. */
4222 if (new_ptr_attrs
!= NULL_TREE
)
4223 warning ("attributes in parameter array declarator ignored");
4228 for (; new_ptr_quals
; new_ptr_quals
= TREE_CHAIN (new_ptr_quals
))
4230 tree qualifier
= TREE_VALUE (new_ptr_quals
);
4232 if (C_IS_RESERVED_WORD (qualifier
))
4234 if (C_RID_CODE (qualifier
) == RID_CONST
)
4236 else if (C_RID_CODE (qualifier
) == RID_VOLATILE
)
4238 else if (C_RID_CODE (qualifier
) == RID_RESTRICT
)
4248 error ("invalid type modifier within array declarator");
4250 type_quals
= ((constp
? TYPE_QUAL_CONST
: 0)
4251 | (restrictp
? TYPE_QUAL_RESTRICT
: 0)
4252 | (volatilep
? TYPE_QUAL_VOLATILE
: 0));
4256 else if (TREE_CODE (type
) == FUNCTION_TYPE
)
4258 if (pedantic
&& type_quals
)
4259 pedwarn ("ISO C forbids qualified function types");
4261 type
= c_build_qualified_type (type
, type_quals
);
4262 type
= build_pointer_type (type
);
4263 type_quals
= TYPE_UNQUALIFIED
;
4265 else if (type_quals
)
4266 type
= c_build_qualified_type (type
, type_quals
);
4268 type_as_written
= type
;
4270 decl
= build_decl (PARM_DECL
, declarator
, type
);
4272 C_DECL_VARIABLE_SIZE (decl
) = 1;
4274 /* Compute the type actually passed in the parmlist,
4275 for the case where there is no prototype.
4276 (For example, shorts and chars are passed as ints.)
4277 When there is a prototype, this is overridden later. */
4279 if (type
== error_mark_node
)
4280 promoted_type
= type
;
4282 promoted_type
= c_type_promotes_to (type
);
4284 DECL_ARG_TYPE (decl
) = promoted_type
;
4285 DECL_ARG_TYPE_AS_WRITTEN (decl
) = type_as_written
;
4287 else if (decl_context
== FIELD
)
4289 /* Structure field. It may not be a function. */
4291 if (TREE_CODE (type
) == FUNCTION_TYPE
)
4293 error ("field `%s' declared as a function", name
);
4294 type
= build_pointer_type (type
);
4296 else if (TREE_CODE (type
) != ERROR_MARK
4297 && !COMPLETE_OR_UNBOUND_ARRAY_TYPE_P (type
))
4299 error ("field `%s' has incomplete type", name
);
4300 type
= error_mark_node
;
4302 /* Move type qualifiers down to element of an array. */
4303 if (TREE_CODE (type
) == ARRAY_TYPE
&& type_quals
)
4304 type
= build_array_type (c_build_qualified_type (TREE_TYPE (type
),
4306 TYPE_DOMAIN (type
));
4307 decl
= build_decl (FIELD_DECL
, declarator
, type
);
4308 DECL_NONADDRESSABLE_P (decl
) = bitfield
;
4311 C_DECL_VARIABLE_SIZE (decl
) = 1;
4313 else if (TREE_CODE (type
) == FUNCTION_TYPE
)
4315 /* Every function declaration is "external"
4316 except for those which are inside a function body
4317 in which `auto' is used.
4318 That is a case not specified by ANSI C,
4319 and we use it for forward declarations for nested functions. */
4320 int extern_ref
= (!(specbits
& (1 << (int) RID_AUTO
))
4321 || current_scope
== global_scope
);
4323 if (specbits
& (1 << (int) RID_AUTO
)
4324 && (pedantic
|| current_scope
== global_scope
))
4325 pedwarn ("invalid storage class for function `%s'", name
);
4326 if (specbits
& (1 << (int) RID_REGISTER
))
4327 error ("invalid storage class for function `%s'", name
);
4328 if (specbits
& (1 << (int) RID_THREAD
))
4329 error ("invalid storage class for function `%s'", name
);
4330 /* Function declaration not at file scope.
4331 Storage classes other than `extern' are not allowed
4332 and `extern' makes no difference. */
4333 if (current_scope
!= global_scope
4334 && (specbits
& ((1 << (int) RID_STATIC
) | (1 << (int) RID_INLINE
)))
4336 pedwarn ("invalid storage class for function `%s'", name
);
4338 decl
= build_decl (FUNCTION_DECL
, declarator
, type
);
4339 decl
= build_decl_attribute_variant (decl
, decl_attr
);
4341 DECL_LANG_SPECIFIC (decl
)
4342 = ggc_alloc_cleared (sizeof (struct lang_decl
));
4344 if (pedantic
&& type_quals
&& ! DECL_IN_SYSTEM_HEADER (decl
))
4345 pedwarn ("ISO C forbids qualified function types");
4347 /* GNU C interprets a `volatile void' return type to indicate
4348 that the function does not return. */
4349 if ((type_quals
& TYPE_QUAL_VOLATILE
)
4350 && !VOID_TYPE_P (TREE_TYPE (TREE_TYPE (decl
))))
4351 warning ("`noreturn' function returns non-void value");
4354 DECL_EXTERNAL (decl
) = 1;
4355 /* Record absence of global scope for `static' or `auto'. */
4357 = !(specbits
& ((1 << (int) RID_STATIC
) | (1 << (int) RID_AUTO
)));
4360 C_FUNCTION_IMPLICIT_INT (decl
) = 1;
4362 /* Record presence of `inline', if it is reasonable. */
4363 if (MAIN_NAME_P (declarator
))
4366 warning ("cannot inline function `main'");
4370 /* Record that the function is declared `inline'. */
4371 DECL_DECLARED_INLINE_P (decl
) = 1;
4373 /* Do not mark bare declarations as DECL_INLINE. Doing so
4374 in the presence of multiple declarations can result in
4375 the abstract origin pointing between the declarations,
4376 which will confuse dwarf2out. */
4379 DECL_INLINE (decl
) = 1;
4380 if (specbits
& (1 << (int) RID_EXTERN
))
4381 current_extern_inline
= 1;
4384 /* If -finline-functions, assume it can be inlined. This does
4385 two things: let the function be deferred until it is actually
4386 needed, and let dwarf2 know that the function is inlinable. */
4387 else if (flag_inline_trees
== 2 && initialized
)
4388 DECL_INLINE (decl
) = 1;
4392 /* It's a variable. */
4393 /* An uninitialized decl with `extern' is a reference. */
4394 int extern_ref
= !initialized
&& (specbits
& (1 << (int) RID_EXTERN
));
4396 /* Move type qualifiers down to element of an array. */
4397 if (TREE_CODE (type
) == ARRAY_TYPE
&& type_quals
)
4399 int saved_align
= TYPE_ALIGN(type
);
4400 type
= build_array_type (c_build_qualified_type (TREE_TYPE (type
),
4402 TYPE_DOMAIN (type
));
4403 TYPE_ALIGN (type
) = saved_align
;
4405 else if (type_quals
)
4406 type
= c_build_qualified_type (type
, type_quals
);
4408 /* It is invalid to create an `extern' declaration for a
4409 variable if there is a global declaration that is
4411 if (extern_ref
&& current_scope
!= global_scope
)
4415 global_decl
= identifier_global_value (declarator
);
4417 && TREE_CODE (global_decl
) == VAR_DECL
4418 && !TREE_PUBLIC (global_decl
))
4419 error ("variable previously declared `static' redeclared "
4423 decl
= build_decl (VAR_DECL
, declarator
, type
);
4425 C_DECL_VARIABLE_SIZE (decl
) = 1;
4428 pedwarn ("%Jvariable '%D' declared `inline'", decl
, decl
);
4430 DECL_EXTERNAL (decl
) = extern_ref
;
4432 /* At file scope, the presence of a `static' or `register' storage
4433 class specifier, or the absence of all storage class specifiers
4434 makes this declaration a definition (perhaps tentative). Also,
4435 the absence of both `static' and `register' makes it public. */
4436 if (current_scope
== global_scope
)
4438 TREE_PUBLIC (decl
) = !(specbits
& ((1 << (int) RID_STATIC
)
4439 | (1 << (int) RID_REGISTER
)));
4440 TREE_STATIC (decl
) = !extern_ref
;
4442 /* Not at file scope, only `static' makes a static definition. */
4445 TREE_STATIC (decl
) = (specbits
& (1 << (int) RID_STATIC
)) != 0;
4446 TREE_PUBLIC (decl
) = extern_ref
;
4449 if (specbits
& 1 << (int) RID_THREAD
)
4451 if (targetm
.have_tls
)
4452 DECL_THREAD_LOCAL (decl
) = 1;
4454 /* A mere warning is sure to result in improper semantics
4455 at runtime. Don't bother to allow this to compile. */
4456 error ("thread-local storage not supported for this target");
4460 /* Record `register' declaration for warnings on &
4461 and in case doing stupid register allocation. */
4463 if (specbits
& (1 << (int) RID_REGISTER
))
4464 DECL_REGISTER (decl
) = 1;
4466 /* Record constancy and volatility. */
4467 c_apply_type_quals_to_decl (type_quals
, decl
);
4469 /* If a type has volatile components, it should be stored in memory.
4470 Otherwise, the fact that those components are volatile
4471 will be ignored, and would even crash the compiler. */
4472 if (C_TYPE_FIELDS_VOLATILE (TREE_TYPE (decl
)))
4473 c_mark_addressable (decl
);
4475 #ifdef ENABLE_CHECKING
4476 /* This is the earliest point at which we might know the assembler
4477 name of a variable. Thus, if it's known before this, die horribly. */
4478 if (DECL_ASSEMBLER_NAME_SET_P (decl
))
4482 decl_attributes (&decl
, returned_attrs
, 0);
4488 /* Decode the parameter-list info for a function type or function definition.
4489 The argument is the value returned by `get_parm_info' (or made in parse.y
4490 if there is an identifier list instead of a parameter decl list).
4491 These two functions are separate because when a function returns
4492 or receives functions then each is called multiple times but the order
4493 of calls is different. The last call to `grokparms' is always the one
4494 that contains the formal parameter names of a function definition.
4496 Store in `last_function_parms' a chain of the decls of parms.
4497 Also store in `last_function_parm_tags' a chain of the struct, union,
4498 and enum tags declared among the parms.
4500 Return a list of arg types to use in the FUNCTION_TYPE for this function.
4502 FUNCDEF_FLAG is nonzero for a function definition, 0 for
4503 a mere declaration. A nonempty identifier-list gets an error message
4504 when FUNCDEF_FLAG is zero. */
4507 grokparms (tree parms_info
, int funcdef_flag
)
4509 tree first_parm
= TREE_CHAIN (parms_info
);
4511 last_function_parms
= TREE_PURPOSE (parms_info
);
4512 last_function_parm_tags
= TREE_VALUE (parms_info
);
4513 last_function_parm_others
= TREE_TYPE (parms_info
);
4515 if (warn_strict_prototypes
&& first_parm
== 0 && !funcdef_flag
4516 && !in_system_header
)
4517 warning ("function declaration isn't a prototype");
4520 && TREE_CODE (TREE_VALUE (first_parm
)) == IDENTIFIER_NODE
)
4523 pedwarn ("parameter names (without types) in function declaration");
4525 last_function_parms
= first_parm
;
4532 /* If the arg types are incomplete in a declaration,
4533 they must include undefined tags.
4534 These tags can never be defined in the scope of the declaration,
4535 so the types can never be completed,
4536 and no call can be compiled successfully. */
4538 for (parm
= last_function_parms
, typelt
= first_parm
;
4540 parm
= TREE_CHAIN (parm
))
4541 /* Skip over any enumeration constants declared here. */
4542 if (TREE_CODE (parm
) == PARM_DECL
)
4544 /* Barf if the parameter itself has an incomplete type. */
4545 tree type
= TREE_VALUE (typelt
);
4546 if (type
== error_mark_node
)
4548 if (!COMPLETE_TYPE_P (type
))
4550 if (funcdef_flag
&& DECL_NAME (parm
) != 0)
4551 error ("parameter `%s' has incomplete type",
4552 IDENTIFIER_POINTER (DECL_NAME (parm
)));
4554 warning ("parameter has incomplete type");
4557 TREE_VALUE (typelt
) = error_mark_node
;
4558 TREE_TYPE (parm
) = error_mark_node
;
4561 typelt
= TREE_CHAIN (typelt
);
4568 /* Return a tree_list node with info on a parameter list just parsed.
4569 The TREE_PURPOSE is a list of decls of those parms.
4570 The TREE_VALUE is a list of structure, union and enum tags defined.
4571 The TREE_CHAIN is a list of argument types to go in the FUNCTION_TYPE.
4572 The TREE_TYPE is a list of non-parameter decls which appeared with the
4574 This tree_list node is later fed to `grokparms'.
4576 VOID_AT_END nonzero means append `void' to the end of the type-list.
4577 Zero means the parmlist ended with an ellipsis so don't append `void'. */
4580 get_parm_info (int void_at_end
)
4582 tree decl
, type
, list
;
4584 tree
*last_type
= &types
;
4585 tree tags
= current_scope
->tags
;
4586 tree parms
= current_scope
->parms
;
4587 tree others
= current_scope
->names
;
4588 static bool explained_incomplete_types
= false;
4589 bool gave_void_only_once_err
= false;
4591 /* Just "void" (and no ellipsis) is special. There are really no parms.
4592 But if the "void" is qualified (by "const" or "volatile"), or has a
4593 storage class specifier ("register"), then the behavior is undefined;
4594 issue an error. Typedefs for "void" are OK (see DR#157). */
4595 if (void_at_end
&& parms
!= 0
4596 && TREE_CHAIN (parms
) == 0
4597 && VOID_TYPE_P (TREE_TYPE (parms
))
4598 && !DECL_NAME (parms
))
4600 if (TREE_THIS_VOLATILE (parms
)
4601 || TREE_READONLY (parms
)
4602 || DECL_REGISTER (parms
))
4603 error ("\"void\" as only parameter may not be qualified");
4605 return tree_cons (0, 0, tree_cons (0, void_type_node
, 0));
4608 /* Sanity check all of the parameter declarations. */
4609 for (decl
= parms
; decl
; decl
= TREE_CHAIN (decl
))
4611 if (TREE_CODE (decl
) != PARM_DECL
)
4613 if (TREE_ASM_WRITTEN (decl
))
4616 /* Since there is a prototype, args are passed in their
4617 declared types. The back end may override this. */
4618 type
= TREE_TYPE (decl
);
4619 DECL_ARG_TYPE (decl
) = type
;
4621 /* Check for (..., void, ...) and issue an error. */
4622 if (VOID_TYPE_P (type
) && !DECL_NAME (decl
) && !gave_void_only_once_err
)
4624 error ("\"void\" must be the only parameter");
4625 gave_void_only_once_err
= true;
4628 type
= build_tree_list (0, type
);
4630 last_type
= &TREE_CHAIN (type
);
4633 /* Check the list of non-parameter decls for any forward parm decls
4634 that never got real decls. */
4635 for (decl
= others
; decl
; decl
= TREE_CHAIN (decl
))
4636 if (TREE_CODE (decl
) == PARM_DECL
)
4638 if (!TREE_ASM_WRITTEN (decl
))
4641 error ("%Jparameter \"%D\" has just a forward declaration",
4645 /* Warn about any struct, union or enum tags defined within this
4646 list. The scope of such types is limited to this declaration,
4647 which is rarely if ever desirable (it's impossible to call such
4648 a function with type-correct arguments). */
4649 for (decl
= tags
; decl
; decl
= TREE_CHAIN (decl
))
4651 enum tree_code code
= TREE_CODE (TREE_VALUE (decl
));
4652 const char *keyword
;
4653 /* An anonymous union parm type is meaningful as a GNU extension.
4654 So don't warn for that. */
4655 if (code
== UNION_TYPE
&& TREE_PURPOSE (decl
) == 0 && !pedantic
)
4658 /* The keyword should not be translated. */
4661 case RECORD_TYPE
: keyword
= "struct"; break;
4662 case UNION_TYPE
: keyword
= "union"; break;
4663 case ENUMERAL_TYPE
: keyword
= "enum"; break;
4667 if (TREE_PURPOSE (decl
))
4668 /* The first %s will be one of 'struct', 'union', or 'enum'. */
4669 warning ("\"%s %s\" declared inside parameter list",
4670 keyword
, IDENTIFIER_POINTER (TREE_PURPOSE (decl
)));
4672 /* The %s will be one of 'struct', 'union', or 'enum'. */
4673 warning ("anonymous %s declared inside parameter list", keyword
);
4675 if (! explained_incomplete_types
)
4677 warning ("its scope is only this definition or declaration,"
4678 " which is probably not what you want");
4679 explained_incomplete_types
= true;
4686 type
= build_tree_list (0, void_type_node
);
4690 list
= tree_cons (parms
, tags
, types
);
4691 TREE_TYPE (list
) = others
;
4695 /* Get the struct, enum or union (CODE says which) with tag NAME.
4696 Define the tag as a forward-reference if it is not defined. */
4699 xref_tag (enum tree_code code
, tree name
)
4701 /* If a cross reference is requested, look up the type
4702 already defined for this tag and return it. */
4704 tree ref
= lookup_tag (code
, name
, 0);
4705 /* If this is the right type of tag, return what we found.
4706 (This reference will be shadowed by shadow_tag later if appropriate.)
4707 If this is the wrong type of tag, do not return it. If it was the
4708 wrong type in the same scope, we will have had an error
4709 message already; if in a different scope and declaring
4710 a name, pending_xref_error will give an error message; but if in a
4711 different scope and not declaring a name, this tag should
4712 shadow the previous declaration of a different type of tag, and
4713 this would not work properly if we return the reference found.
4714 (For example, with "struct foo" in an outer scope, "union foo;"
4715 must shadow that tag with a new one of union type.) */
4716 if (ref
&& TREE_CODE (ref
) == code
)
4719 /* If no such tag is yet defined, create a forward-reference node
4720 and record it as the "definition".
4721 When a real declaration of this type is found,
4722 the forward-reference will be altered into a real type. */
4724 ref
= make_node (code
);
4725 if (code
== ENUMERAL_TYPE
)
4727 /* Give the type a default layout like unsigned int
4728 to avoid crashing if it does not get defined. */
4729 TYPE_MODE (ref
) = TYPE_MODE (unsigned_type_node
);
4730 TYPE_ALIGN (ref
) = TYPE_ALIGN (unsigned_type_node
);
4731 TYPE_USER_ALIGN (ref
) = 0;
4732 TREE_UNSIGNED (ref
) = 1;
4733 TYPE_PRECISION (ref
) = TYPE_PRECISION (unsigned_type_node
);
4734 TYPE_MIN_VALUE (ref
) = TYPE_MIN_VALUE (unsigned_type_node
);
4735 TYPE_MAX_VALUE (ref
) = TYPE_MAX_VALUE (unsigned_type_node
);
4738 pushtag (name
, ref
);
4743 /* Make sure that the tag NAME is defined *in the current scope*
4744 at least as a forward reference.
4745 CODE says which kind of tag NAME ought to be. */
4748 start_struct (enum tree_code code
, tree name
)
4750 /* If there is already a tag defined at this scope
4751 (as a forward reference), just return it. */
4756 ref
= lookup_tag (code
, name
, 1);
4757 if (ref
&& TREE_CODE (ref
) == code
)
4759 if (TYPE_FIELDS (ref
))
4761 if (code
== UNION_TYPE
)
4762 error ("redefinition of `union %s'", IDENTIFIER_POINTER (name
));
4764 error ("redefinition of `struct %s'", IDENTIFIER_POINTER (name
));
4769 /* Otherwise create a forward-reference just so the tag is in scope. */
4771 ref
= make_node (code
);
4772 pushtag (name
, ref
);
4775 C_TYPE_BEING_DEFINED (ref
) = 1;
4776 TYPE_PACKED (ref
) = flag_pack_struct
;
4780 /* Process the specs, declarator (NULL if omitted) and width (NULL if omitted)
4781 of a structure component, returning a FIELD_DECL node.
4782 WIDTH is non-NULL for bit-fields only, and is an INTEGER_CST node.
4784 This is done during the parsing of the struct declaration.
4785 The FIELD_DECL nodes are chained together and the lot of them
4786 are ultimately passed to `build_struct' to make the RECORD_TYPE node. */
4789 grokfield (tree declarator
, tree declspecs
, tree width
)
4793 if (declarator
== NULL_TREE
&& width
== NULL_TREE
)
4795 /* This is an unnamed decl.
4797 If we have something of the form "union { list } ;" then this
4798 is the anonymous union extension. Similarly for struct.
4800 If this is something of the form "struct foo;", then
4801 If MS extensions are enabled, this is handled as an
4803 Otherwise this is a forward declaration of a structure tag.
4805 If this is something of the form "foo;" and foo is a TYPE_DECL, then
4806 If MS extensions are enabled and foo names a structure, then
4807 again this is an anonymous struct.
4808 Otherwise this is an error.
4810 Oh what a horrid tangled web we weave. I wonder if MS consciously
4811 took this from Plan 9 or if it was an accident of implementation
4812 that took root before someone noticed the bug... */
4814 tree type
= TREE_VALUE (declspecs
);
4816 if (flag_ms_extensions
&& TREE_CODE (type
) == TYPE_DECL
)
4817 type
= TREE_TYPE (type
);
4818 if (TREE_CODE (type
) == RECORD_TYPE
|| TREE_CODE (type
) == UNION_TYPE
)
4820 if (flag_ms_extensions
)
4823 goto warn_unnamed_field
;
4824 else if (TYPE_NAME (type
) == NULL
)
4827 goto warn_unnamed_field
;
4832 warning ("declaration does not declare anything");
4837 value
= grokdeclarator (declarator
, declspecs
, FIELD
, 0,
4838 width
? &width
: NULL
);
4840 finish_decl (value
, NULL_TREE
, NULL_TREE
);
4841 DECL_INITIAL (value
) = width
;
4846 /* Generate an error for any duplicate field names in FIELDLIST. Munge
4847 the list such that this does not present a problem later. */
4850 detect_field_duplicates (tree fieldlist
)
4855 /* First, see if there are more than "a few" fields.
4856 This is trivially true if there are zero or one fields. */
4859 x
= TREE_CHAIN (fieldlist
);
4865 } while (timeout
> 0 && x
);
4867 /* If there were "few" fields, avoid the overhead of allocating
4868 a hash table. Instead just do the nested traversal thing. */
4871 for (x
= TREE_CHAIN (fieldlist
); x
; x
= TREE_CHAIN (x
))
4874 for (y
= fieldlist
; y
!= x
; y
= TREE_CHAIN (y
))
4875 if (DECL_NAME (y
) == DECL_NAME (x
))
4877 error ("%Jduplicate member '%D'", x
, x
);
4878 DECL_NAME (x
) = NULL_TREE
;
4884 htab_t htab
= htab_create (37, htab_hash_pointer
, htab_eq_pointer
, NULL
);
4887 for (x
= fieldlist
; x
; x
= TREE_CHAIN (x
))
4888 if ((y
= DECL_NAME (x
)) != 0)
4890 slot
= htab_find_slot (htab
, y
, INSERT
);
4893 error ("%Jduplicate member '%D'", x
, x
);
4894 DECL_NAME (x
) = NULL_TREE
;
4903 /* Fill in the fields of a RECORD_TYPE or UNION_TYPE node, T.
4904 FIELDLIST is a chain of FIELD_DECL nodes for the fields.
4905 ATTRIBUTES are attributes to be applied to the structure. */
4908 finish_struct (tree t
, tree fieldlist
, tree attributes
)
4911 int toplevel
= global_scope
== current_scope
;
4912 int saw_named_field
;
4914 /* If this type was previously laid out as a forward reference,
4915 make sure we lay it out again. */
4919 decl_attributes (&t
, attributes
, (int) ATTR_FLAG_TYPE_IN_PLACE
);
4921 /* Nameless union parm types are useful as GCC extension. */
4922 if (! (TREE_CODE (t
) == UNION_TYPE
&& TYPE_NAME (t
) == 0) && !pedantic
)
4923 /* Otherwise, warn about any struct or union def. in parmlist. */
4924 if (in_parm_level_p ())
4927 pedwarn ("%s defined inside parms",
4928 TREE_CODE (t
) == UNION_TYPE
? _("union") : _("structure"));
4930 warning ("%s defined inside parms",
4931 TREE_CODE (t
) == UNION_TYPE
? _("union") : _("structure"));
4936 for (x
= fieldlist
; x
; x
= TREE_CHAIN (x
))
4937 if (DECL_NAME (x
) != 0)
4941 pedwarn ("%s has no %s",
4942 TREE_CODE (t
) == UNION_TYPE
? _("union") : _("struct"),
4943 fieldlist
? _("named members") : _("members"));
4946 /* Install struct as DECL_CONTEXT of each field decl.
4947 Also process specified field sizes,m which is found in the DECL_INITIAL.
4948 Store 0 there, except for ": 0" fields (so we can find them
4949 and delete them, below). */
4951 saw_named_field
= 0;
4952 for (x
= fieldlist
; x
; x
= TREE_CHAIN (x
))
4954 DECL_CONTEXT (x
) = t
;
4955 DECL_PACKED (x
) |= TYPE_PACKED (t
);
4957 /* If any field is const, the structure type is pseudo-const. */
4958 if (TREE_READONLY (x
))
4959 C_TYPE_FIELDS_READONLY (t
) = 1;
4962 /* A field that is pseudo-const makes the structure likewise. */
4963 tree t1
= TREE_TYPE (x
);
4964 while (TREE_CODE (t1
) == ARRAY_TYPE
)
4965 t1
= TREE_TYPE (t1
);
4966 if ((TREE_CODE (t1
) == RECORD_TYPE
|| TREE_CODE (t1
) == UNION_TYPE
)
4967 && C_TYPE_FIELDS_READONLY (t1
))
4968 C_TYPE_FIELDS_READONLY (t
) = 1;
4971 /* Any field that is volatile means variables of this type must be
4972 treated in some ways as volatile. */
4973 if (TREE_THIS_VOLATILE (x
))
4974 C_TYPE_FIELDS_VOLATILE (t
) = 1;
4976 /* Any field of nominal variable size implies structure is too. */
4977 if (C_DECL_VARIABLE_SIZE (x
))
4978 C_TYPE_VARIABLE_SIZE (t
) = 1;
4980 /* Detect invalid nested redefinition. */
4981 if (TREE_TYPE (x
) == t
)
4982 error ("nested redefinition of `%s'",
4983 IDENTIFIER_POINTER (TYPE_NAME (t
)));
4985 if (DECL_INITIAL (x
))
4987 unsigned HOST_WIDE_INT width
= tree_low_cst (DECL_INITIAL (x
), 1);
4988 DECL_SIZE (x
) = bitsize_int (width
);
4989 DECL_BIT_FIELD (x
) = 1;
4990 SET_DECL_C_BIT_FIELD (x
);
4993 DECL_INITIAL (x
) = 0;
4995 /* Detect flexible array member in an invalid context. */
4996 if (TREE_CODE (TREE_TYPE (x
)) == ARRAY_TYPE
4997 && TYPE_SIZE (TREE_TYPE (x
)) == NULL_TREE
4998 && TYPE_DOMAIN (TREE_TYPE (x
)) != NULL_TREE
4999 && TYPE_MAX_VALUE (TYPE_DOMAIN (TREE_TYPE (x
))) == NULL_TREE
)
5001 if (TREE_CODE (t
) == UNION_TYPE
)
5002 error ("%Jflexible array member in union", x
);
5003 else if (TREE_CHAIN (x
) != NULL_TREE
)
5004 error ("%Jflexible array member not at end of struct", x
);
5005 else if (! saw_named_field
)
5006 error ("%Jflexible array member in otherwise empty struct", x
);
5009 if (pedantic
&& TREE_CODE (t
) == RECORD_TYPE
5010 && flexible_array_type_p (TREE_TYPE (x
)))
5011 pedwarn ("%Jinvalid use of structure with flexible array member", x
);
5014 saw_named_field
= 1;
5017 detect_field_duplicates (fieldlist
);
5019 /* Now we have the nearly final fieldlist. Record it,
5020 then lay out the structure or union (including the fields). */
5022 TYPE_FIELDS (t
) = fieldlist
;
5026 /* Delete all zero-width bit-fields from the fieldlist. */
5028 tree
*fieldlistp
= &fieldlist
;
5030 if (TREE_CODE (*fieldlistp
) == FIELD_DECL
&& DECL_INITIAL (*fieldlistp
))
5031 *fieldlistp
= TREE_CHAIN (*fieldlistp
);
5033 fieldlistp
= &TREE_CHAIN (*fieldlistp
);
5036 /* Now we have the truly final field list.
5037 Store it in this type and in the variants. */
5039 TYPE_FIELDS (t
) = fieldlist
;
5041 /* If there are lots of fields, sort so we can look through them fast.
5042 We arbitrarily consider 16 or more elts to be "a lot". */
5047 for (x
= fieldlist
; x
; x
= TREE_CHAIN (x
))
5049 if (len
> 15 || DECL_NAME (x
) == NULL
)
5057 struct lang_type
*space
;
5058 struct sorted_fields_type
*space2
;
5060 len
+= list_length (x
);
5062 /* Use the same allocation policy here that make_node uses, to
5063 ensure that this lives as long as the rest of the struct decl.
5064 All decls in an inline function need to be saved. */
5066 space
= ggc_alloc (sizeof (struct lang_type
));
5067 space2
= ggc_alloc (sizeof (struct sorted_fields_type
) + len
* sizeof (tree
));
5071 field_array
= &space2
->elts
[0];
5072 for (x
= fieldlist
; x
; x
= TREE_CHAIN (x
))
5074 field_array
[len
++] = x
;
5076 /* If there is anonymous struct or union, break out of the loop. */
5077 if (DECL_NAME (x
) == NULL
)
5080 /* Found no anonymous struct/union. Add the TYPE_LANG_SPECIFIC. */
5083 TYPE_LANG_SPECIFIC (t
) = space
;
5084 TYPE_LANG_SPECIFIC (t
)->s
->len
= len
;
5085 field_array
= TYPE_LANG_SPECIFIC (t
)->s
->elts
;
5086 qsort (field_array
, len
, sizeof (tree
), field_decl_cmp
);
5091 for (x
= TYPE_MAIN_VARIANT (t
); x
; x
= TYPE_NEXT_VARIANT (x
))
5093 TYPE_FIELDS (x
) = TYPE_FIELDS (t
);
5094 TYPE_LANG_SPECIFIC (x
) = TYPE_LANG_SPECIFIC (t
);
5095 TYPE_ALIGN (x
) = TYPE_ALIGN (t
);
5096 TYPE_USER_ALIGN (x
) = TYPE_USER_ALIGN (t
);
5099 /* If this was supposed to be a transparent union, but we can't
5100 make it one, warn and turn off the flag. */
5101 if (TREE_CODE (t
) == UNION_TYPE
5102 && TYPE_TRANSPARENT_UNION (t
)
5103 && TYPE_MODE (t
) != DECL_MODE (TYPE_FIELDS (t
)))
5105 TYPE_TRANSPARENT_UNION (t
) = 0;
5106 warning ("union cannot be made transparent");
5109 /* If this structure or union completes the type of any previous
5110 variable declaration, lay it out and output its rtl. */
5111 for (x
= C_TYPE_INCOMPLETE_VARS (TYPE_MAIN_VARIANT (t
));
5115 tree decl
= TREE_VALUE (x
);
5116 if (TREE_CODE (TREE_TYPE (decl
)) == ARRAY_TYPE
)
5117 layout_array_type (TREE_TYPE (decl
));
5118 if (TREE_CODE (decl
) != TYPE_DECL
)
5120 layout_decl (decl
, 0);
5121 if (c_dialect_objc ())
5122 objc_check_decl (decl
);
5123 rest_of_decl_compilation (decl
, NULL
, toplevel
, 0);
5128 C_TYPE_INCOMPLETE_VARS (TYPE_MAIN_VARIANT (t
)) = 0;
5130 /* Finish debugging output for this type. */
5131 rest_of_type_compilation (t
, toplevel
);
5136 /* Lay out the type T, and its element type, and so on. */
5139 layout_array_type (tree t
)
5141 if (TREE_CODE (TREE_TYPE (t
)) == ARRAY_TYPE
)
5142 layout_array_type (TREE_TYPE (t
));
5146 /* Begin compiling the definition of an enumeration type.
5147 NAME is its name (or null if anonymous).
5148 Returns the type object, as yet incomplete.
5149 Also records info about it so that build_enumerator
5150 may be used to declare the individual values as they are read. */
5153 start_enum (tree name
)
5157 /* If this is the real definition for a previous forward reference,
5158 fill in the contents in the same object that used to be the
5159 forward reference. */
5162 enumtype
= lookup_tag (ENUMERAL_TYPE
, name
, 1);
5164 if (enumtype
== 0 || TREE_CODE (enumtype
) != ENUMERAL_TYPE
)
5166 enumtype
= make_node (ENUMERAL_TYPE
);
5167 pushtag (name
, enumtype
);
5170 C_TYPE_BEING_DEFINED (enumtype
) = 1;
5172 if (TYPE_VALUES (enumtype
) != 0)
5174 /* This enum is a named one that has been declared already. */
5175 error ("redeclaration of `enum %s'", IDENTIFIER_POINTER (name
));
5177 /* Completely replace its old definition.
5178 The old enumerators remain defined, however. */
5179 TYPE_VALUES (enumtype
) = 0;
5182 enum_next_value
= integer_zero_node
;
5185 if (flag_short_enums
)
5186 TYPE_PACKED (enumtype
) = 1;
5191 /* After processing and defining all the values of an enumeration type,
5192 install their decls in the enumeration type and finish it off.
5193 ENUMTYPE is the type object, VALUES a list of decl-value pairs,
5194 and ATTRIBUTES are the specified attributes.
5195 Returns ENUMTYPE. */
5198 finish_enum (tree enumtype
, tree values
, tree attributes
)
5201 tree minnode
= 0, maxnode
= 0, enum_value_type
;
5202 int precision
, unsign
;
5203 int toplevel
= (global_scope
== current_scope
);
5205 if (in_parm_level_p ())
5206 warning ("enum defined inside parms");
5208 decl_attributes (&enumtype
, attributes
, (int) ATTR_FLAG_TYPE_IN_PLACE
);
5210 /* Calculate the maximum value of any enumerator in this type. */
5212 if (values
== error_mark_node
)
5213 minnode
= maxnode
= integer_zero_node
;
5216 minnode
= maxnode
= TREE_VALUE (values
);
5217 for (pair
= TREE_CHAIN (values
); pair
; pair
= TREE_CHAIN (pair
))
5219 tree value
= TREE_VALUE (pair
);
5220 if (tree_int_cst_lt (maxnode
, value
))
5222 if (tree_int_cst_lt (value
, minnode
))
5227 /* Construct the final type of this enumeration. It is the same
5228 as one of the integral types - the narrowest one that fits, except
5229 that normally we only go as narrow as int - and signed iff any of
5230 the values are negative. */
5231 unsign
= (tree_int_cst_sgn (minnode
) >= 0);
5232 precision
= MAX (min_precision (minnode
, unsign
),
5233 min_precision (maxnode
, unsign
));
5234 if (TYPE_PACKED (enumtype
) || precision
> TYPE_PRECISION (integer_type_node
))
5236 tree narrowest
= c_common_type_for_size (precision
, unsign
);
5239 warning ("enumeration values exceed range of largest integer");
5240 narrowest
= long_long_integer_type_node
;
5243 precision
= TYPE_PRECISION (narrowest
);
5246 precision
= TYPE_PRECISION (integer_type_node
);
5248 if (precision
== TYPE_PRECISION (integer_type_node
))
5249 enum_value_type
= c_common_type_for_size (precision
, 0);
5251 enum_value_type
= enumtype
;
5253 TYPE_MIN_VALUE (enumtype
) = minnode
;
5254 TYPE_MAX_VALUE (enumtype
) = maxnode
;
5255 TYPE_PRECISION (enumtype
) = precision
;
5256 TREE_UNSIGNED (enumtype
) = unsign
;
5257 TYPE_SIZE (enumtype
) = 0;
5258 layout_type (enumtype
);
5260 if (values
!= error_mark_node
)
5262 /* Change the type of the enumerators to be the enum type. We
5263 need to do this irrespective of the size of the enum, for
5264 proper type checking. Replace the DECL_INITIALs of the
5265 enumerators, and the value slots of the list, with copies
5266 that have the enum type; they cannot be modified in place
5267 because they may be shared (e.g. integer_zero_node) Finally,
5268 change the purpose slots to point to the names of the decls. */
5269 for (pair
= values
; pair
; pair
= TREE_CHAIN (pair
))
5271 tree enu
= TREE_PURPOSE (pair
);
5273 TREE_TYPE (enu
) = enumtype
;
5275 /* The ISO C Standard mandates enumerators to have type int,
5276 even though the underlying type of an enum type is
5277 unspecified. Here we convert any enumerators that fit in
5278 an int to type int, to avoid promotions to unsigned types
5279 when comparing integers with enumerators that fit in the
5280 int range. When -pedantic is given, build_enumerator()
5281 would have already taken care of those that don't fit. */
5282 if (int_fits_type_p (DECL_INITIAL (enu
), enum_value_type
))
5283 DECL_INITIAL (enu
) = convert (enum_value_type
, DECL_INITIAL (enu
));
5285 DECL_INITIAL (enu
) = convert (enumtype
, DECL_INITIAL (enu
));
5287 TREE_PURPOSE (pair
) = DECL_NAME (enu
);
5288 TREE_VALUE (pair
) = DECL_INITIAL (enu
);
5291 TYPE_VALUES (enumtype
) = values
;
5294 /* Fix up all variant types of this enum type. */
5295 for (tem
= TYPE_MAIN_VARIANT (enumtype
); tem
; tem
= TYPE_NEXT_VARIANT (tem
))
5297 if (tem
== enumtype
)
5299 TYPE_VALUES (tem
) = TYPE_VALUES (enumtype
);
5300 TYPE_MIN_VALUE (tem
) = TYPE_MIN_VALUE (enumtype
);
5301 TYPE_MAX_VALUE (tem
) = TYPE_MAX_VALUE (enumtype
);
5302 TYPE_SIZE (tem
) = TYPE_SIZE (enumtype
);
5303 TYPE_SIZE_UNIT (tem
) = TYPE_SIZE_UNIT (enumtype
);
5304 TYPE_MODE (tem
) = TYPE_MODE (enumtype
);
5305 TYPE_PRECISION (tem
) = TYPE_PRECISION (enumtype
);
5306 TYPE_ALIGN (tem
) = TYPE_ALIGN (enumtype
);
5307 TYPE_USER_ALIGN (tem
) = TYPE_USER_ALIGN (enumtype
);
5308 TREE_UNSIGNED (tem
) = TREE_UNSIGNED (enumtype
);
5311 /* Finish debugging output for this type. */
5312 rest_of_type_compilation (enumtype
, toplevel
);
5317 /* Build and install a CONST_DECL for one value of the
5318 current enumeration type (one that was begun with start_enum).
5319 Return a tree-list containing the CONST_DECL and its value.
5320 Assignment of sequential values by default is handled here. */
5323 build_enumerator (tree name
, tree value
)
5327 /* Validate and default VALUE. */
5329 /* Remove no-op casts from the value. */
5331 STRIP_TYPE_NOPS (value
);
5335 if (TREE_CODE (value
) == INTEGER_CST
)
5337 value
= default_conversion (value
);
5338 constant_expression_warning (value
);
5342 error ("enumerator value for `%s' not integer constant",
5343 IDENTIFIER_POINTER (name
));
5348 /* Default based on previous value. */
5349 /* It should no longer be possible to have NON_LVALUE_EXPR
5353 value
= enum_next_value
;
5355 error ("overflow in enumeration values");
5358 if (pedantic
&& ! int_fits_type_p (value
, integer_type_node
))
5360 pedwarn ("ISO C restricts enumerator values to range of `int'");
5361 value
= convert (integer_type_node
, value
);
5364 /* Set basis for default for next value. */
5365 enum_next_value
= build_binary_op (PLUS_EXPR
, value
, integer_one_node
, 0);
5366 enum_overflow
= tree_int_cst_lt (enum_next_value
, value
);
5368 /* Now create a declaration for the enum value name. */
5370 type
= TREE_TYPE (value
);
5371 type
= c_common_type_for_size (MAX (TYPE_PRECISION (type
),
5372 TYPE_PRECISION (integer_type_node
)),
5373 (TYPE_PRECISION (type
)
5374 >= TYPE_PRECISION (integer_type_node
)
5375 && TREE_UNSIGNED (type
)));
5377 decl
= build_decl (CONST_DECL
, name
, type
);
5378 DECL_INITIAL (decl
) = convert (type
, value
);
5381 return tree_cons (decl
, value
, NULL_TREE
);
5385 /* Create the FUNCTION_DECL for a function definition.
5386 DECLSPECS, DECLARATOR and ATTRIBUTES are the parts of
5387 the declaration; they describe the function's name and the type it returns,
5388 but twisted together in a fashion that parallels the syntax of C.
5390 This function creates a binding context for the function body
5391 as well as setting up the FUNCTION_DECL in current_function_decl.
5393 Returns 1 on success. If the DECLARATOR is not suitable for a function
5394 (it defines a datum instead), we return 0, which tells
5395 yyparse to report a parse error. */
5398 start_function (tree declspecs
, tree declarator
, tree attributes
)
5400 tree decl1
, old_decl
;
5402 int old_immediate_size_expand
= immediate_size_expand
;
5404 current_function_returns_value
= 0; /* Assume, until we see it does. */
5405 current_function_returns_null
= 0;
5406 current_function_returns_abnormally
= 0;
5407 warn_about_return_type
= 0;
5408 current_extern_inline
= 0;
5409 c_in_iteration_stmt
= 0;
5412 /* Don't expand any sizes in the return type of the function. */
5413 immediate_size_expand
= 0;
5415 decl1
= grokdeclarator (declarator
, declspecs
, FUNCDEF
, 1, NULL
);
5417 /* If the declarator is not suitable for a function definition,
5418 cause a syntax error. */
5421 immediate_size_expand
= old_immediate_size_expand
;
5425 decl_attributes (&decl1
, attributes
, 0);
5427 if (DECL_DECLARED_INLINE_P (decl1
)
5428 && DECL_UNINLINABLE (decl1
)
5429 && lookup_attribute ("noinline", DECL_ATTRIBUTES (decl1
)))
5430 warning ("%Jinline function '%D' given attribute noinline", decl1
, decl1
);
5432 announce_function (decl1
);
5434 if (!COMPLETE_OR_VOID_TYPE_P (TREE_TYPE (TREE_TYPE (decl1
))))
5436 error ("return type is an incomplete type");
5437 /* Make it return void instead. */
5439 = build_function_type (void_type_node
,
5440 TYPE_ARG_TYPES (TREE_TYPE (decl1
)));
5443 if (warn_about_return_type
)
5444 pedwarn_c99 ("return type defaults to `int'");
5446 /* Save the parm names or decls from this function's declarator
5447 where store_parm_decls will find them. */
5448 current_function_parms
= last_function_parms
;
5449 current_function_parm_tags
= last_function_parm_tags
;
5450 current_function_parm_others
= last_function_parm_others
;
5452 /* Make the init_value nonzero so pushdecl knows this is not tentative.
5453 error_mark_node is replaced below (in poplevel) with the BLOCK. */
5454 DECL_INITIAL (decl1
) = error_mark_node
;
5456 /* If this definition isn't a prototype and we had a prototype declaration
5457 before, copy the arg type info from that prototype.
5458 But not if what we had before was a builtin function. */
5459 old_decl
= lookup_name_current_level (DECL_NAME (decl1
));
5460 if (old_decl
!= 0 && TREE_CODE (TREE_TYPE (old_decl
)) == FUNCTION_TYPE
5461 && !DECL_BUILT_IN (old_decl
)
5462 && (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (decl1
)))
5463 == TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (old_decl
))))
5464 && TYPE_ARG_TYPES (TREE_TYPE (decl1
)) == 0)
5466 TREE_TYPE (decl1
) = TREE_TYPE (old_decl
);
5467 current_function_prototype_locus
= DECL_SOURCE_LOCATION (old_decl
);
5470 /* Optionally warn of old-fashioned def with no previous prototype. */
5471 if (warn_strict_prototypes
5472 && TYPE_ARG_TYPES (TREE_TYPE (decl1
)) == 0
5473 && C_DECL_ISNT_PROTOTYPE (old_decl
))
5474 warning ("function declaration isn't a prototype");
5475 /* Optionally warn of any global def with no previous prototype. */
5476 else if (warn_missing_prototypes
5477 && TREE_PUBLIC (decl1
)
5478 && ! MAIN_NAME_P (DECL_NAME (decl1
))
5479 && C_DECL_ISNT_PROTOTYPE (old_decl
))
5480 warning ("%Jno previous prototype for '%D'", decl1
, decl1
);
5481 /* Optionally warn of any def with no previous prototype
5482 if the function has already been used. */
5483 else if (warn_missing_prototypes
5484 && old_decl
!= 0 && TREE_USED (old_decl
)
5485 && TYPE_ARG_TYPES (TREE_TYPE (old_decl
)) == 0)
5486 warning ("%J'%D' was used with no prototype before its definition",
5488 /* Optionally warn of any global def with no previous declaration. */
5489 else if (warn_missing_declarations
5490 && TREE_PUBLIC (decl1
)
5492 && ! MAIN_NAME_P (DECL_NAME (decl1
)))
5493 warning ("%Jno previous declaration for '%D'", decl1
, decl1
);
5494 /* Optionally warn of any def with no previous declaration
5495 if the function has already been used. */
5496 else if (warn_missing_declarations
5497 && old_decl
!= 0 && TREE_USED (old_decl
)
5498 && C_DECL_IMPLICIT (old_decl
))
5499 warning ("%J`%D' was used with no declaration before its definition",
5502 /* This is a definition, not a reference.
5503 So normally clear DECL_EXTERNAL.
5504 However, `extern inline' acts like a declaration
5505 except for defining how to inline. So set DECL_EXTERNAL in that case. */
5506 DECL_EXTERNAL (decl1
) = current_extern_inline
;
5508 /* This function exists in static storage.
5509 (This does not mean `static' in the C sense!) */
5510 TREE_STATIC (decl1
) = 1;
5512 /* A nested function is not global. */
5513 if (current_function_decl
!= 0)
5514 TREE_PUBLIC (decl1
) = 0;
5516 #ifdef ENABLE_CHECKING
5517 /* This is the earliest point at which we might know the assembler
5518 name of the function. Thus, if it's set before this, die horribly. */
5519 if (DECL_ASSEMBLER_NAME_SET_P (decl1
))
5523 /* If #pragma weak was used, mark the decl weak now. */
5524 if (current_scope
== global_scope
)
5525 maybe_apply_pragma_weak (decl1
);
5527 /* Warn for unlikely, improbable, or stupid declarations of `main'. */
5528 if (warn_main
> 0 && MAIN_NAME_P (DECL_NAME (decl1
)))
5533 if (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (decl1
)))
5534 != integer_type_node
)
5535 pedwarn ("%Jreturn type of '%D' is not `int'", decl1
, decl1
);
5537 for (args
= TYPE_ARG_TYPES (TREE_TYPE (decl1
)); args
;
5538 args
= TREE_CHAIN (args
))
5540 tree type
= args
? TREE_VALUE (args
) : 0;
5542 if (type
== void_type_node
)
5549 if (TYPE_MAIN_VARIANT (type
) != integer_type_node
)
5550 pedwarn ("%Jfirst argument of '%D' should be `int'",
5555 if (TREE_CODE (type
) != POINTER_TYPE
5556 || TREE_CODE (TREE_TYPE (type
)) != POINTER_TYPE
5557 || (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (type
)))
5559 pedwarn ("%Jsecond argument of '%D' should be 'char **'",
5564 if (TREE_CODE (type
) != POINTER_TYPE
5565 || TREE_CODE (TREE_TYPE (type
)) != POINTER_TYPE
5566 || (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (type
)))
5568 pedwarn ("%Jthird argument of '%D' should probably be "
5569 "'char **'", decl1
, decl1
);
5574 /* It is intentional that this message does not mention the third
5575 argument because it's only mentioned in an appendix of the
5577 if (argct
> 0 && (argct
< 2 || argct
> 3))
5578 pedwarn ("%J'%D' takes only zero or two arguments", decl1
, decl1
);
5580 if (! TREE_PUBLIC (decl1
))
5581 pedwarn ("%J'%D' is normally a non-static function", decl1
, decl1
);
5584 /* Record the decl so that the function name is defined.
5585 If we already have a decl for this name, and it is a FUNCTION_DECL,
5586 use the old decl. */
5588 current_function_decl
= pushdecl (decl1
);
5591 declare_parm_level ();
5593 make_decl_rtl (current_function_decl
, NULL
);
5595 restype
= TREE_TYPE (TREE_TYPE (current_function_decl
));
5596 /* Promote the value to int before returning it. */
5597 if (c_promoting_integer_type_p (restype
))
5599 /* It retains unsignedness if not really getting wider. */
5600 if (TREE_UNSIGNED (restype
)
5601 && (TYPE_PRECISION (restype
)
5602 == TYPE_PRECISION (integer_type_node
)))
5603 restype
= unsigned_type_node
;
5605 restype
= integer_type_node
;
5607 DECL_RESULT (current_function_decl
)
5608 = build_decl (RESULT_DECL
, NULL_TREE
, restype
);
5610 /* If this fcn was already referenced via a block-scope `extern' decl
5611 (or an implicit decl), propagate certain information about the usage. */
5612 if (TREE_ADDRESSABLE (DECL_ASSEMBLER_NAME (current_function_decl
)))
5613 TREE_ADDRESSABLE (current_function_decl
) = 1;
5615 immediate_size_expand
= old_immediate_size_expand
;
5617 start_fname_decls ();
5622 /* Subroutine of store_parm_decls which handles new-style function
5623 definitions (prototype format). The parms already have decls, so we
5624 need only record them as in effect and complain if any redundant
5625 old-style parm decls were written. */
5627 store_parm_decls_newstyle (void)
5630 tree fndecl
= current_function_decl
;
5631 tree parms
= current_function_parms
;
5632 tree tags
= current_function_parm_tags
;
5633 tree others
= current_function_parm_others
;
5635 if (current_scope
->parms
|| current_scope
->names
|| current_scope
->tags
)
5637 error ("%Jold-style parameter declarations in prototyped "
5638 "function definition", fndecl
);
5640 /* Get rid of the old-style declarations. */
5645 /* Now make all the parameter declarations visible in the function body.
5646 We can bypass most of the grunt work of pushdecl. */
5647 for (last
= 0, decl
= parms
; decl
; last
= decl
, decl
= TREE_CHAIN (decl
))
5649 DECL_CONTEXT (decl
) = current_function_decl
;
5650 if (DECL_NAME (decl
) == 0)
5651 error ("%Jparameter name omitted", decl
);
5654 if (IDENTIFIER_SYMBOL_VALUE (DECL_NAME (decl
)))
5655 current_scope
->shadowed
5656 = tree_cons (DECL_NAME (decl
),
5657 IDENTIFIER_SYMBOL_VALUE (DECL_NAME (decl
)),
5658 current_scope
->shadowed
);
5659 IDENTIFIER_SYMBOL_VALUE (DECL_NAME (decl
)) = decl
;
5662 current_scope
->parms
= parms
;
5663 current_scope
->parms_last
= last
;
5665 /* Record the parameter list in the function declaration. */
5666 DECL_ARGUMENTS (fndecl
) = parms
;
5668 /* Now make all the ancillary declarations visible, likewise. */
5669 for (last
= 0, decl
= others
; decl
; last
= decl
, decl
= TREE_CHAIN (decl
))
5671 DECL_CONTEXT (decl
) = current_function_decl
;
5672 if (DECL_NAME (decl
)
5673 && TYPE_MAIN_VARIANT (TREE_TYPE (decl
)) != void_type_node
)
5675 if (IDENTIFIER_SYMBOL_VALUE (DECL_NAME (decl
)))
5676 current_scope
->shadowed
5677 = tree_cons (DECL_NAME (decl
),
5678 IDENTIFIER_SYMBOL_VALUE (DECL_NAME (decl
)),
5679 current_scope
->shadowed
);
5680 IDENTIFIER_SYMBOL_VALUE (DECL_NAME (decl
)) = decl
;
5683 current_scope
->names
= others
;
5684 current_scope
->names_last
= last
;
5686 /* And all the tag declarations. */
5687 for (decl
= tags
; decl
; decl
= TREE_CHAIN (decl
))
5688 if (TREE_PURPOSE (decl
))
5690 if (IDENTIFIER_TAG_VALUE (TREE_PURPOSE (decl
)))
5691 current_scope
->shadowed_tags
5692 = tree_cons (TREE_PURPOSE (decl
),
5693 IDENTIFIER_SYMBOL_VALUE (TREE_PURPOSE (decl
)),
5694 current_scope
->shadowed_tags
);
5695 IDENTIFIER_TAG_VALUE (TREE_PURPOSE (decl
)) = TREE_VALUE (decl
);
5697 current_scope
->tags
= tags
;
5700 /* Subroutine of store_parm_decls which handles old-style function
5701 definitions (separate parameter list and declarations). */
5704 store_parm_decls_oldstyle (void)
5706 tree parm
, decl
, last
;
5707 tree fndecl
= current_function_decl
;
5709 /* This is the identifier list from the function declarator. */
5710 tree parmids
= current_function_parms
;
5712 /* We use DECL_WEAK as a flag to show which parameters have been
5713 seen already, since it is not used on PARM_DECL. */
5714 #ifdef ENABLE_CHECKING
5715 for (parm
= current_scope
->parms
; parm
; parm
= TREE_CHAIN (parm
))
5716 if (DECL_WEAK (parm
))
5720 /* Match each formal parameter name with its declaration. Save each
5721 decl in the appropriate TREE_PURPOSE slot of the parmids chain. */
5722 for (parm
= parmids
; parm
; parm
= TREE_CHAIN (parm
))
5724 if (TREE_VALUE (parm
) == 0)
5726 error ("%Jparameter name missing from parameter list", fndecl
);
5727 TREE_PURPOSE (parm
) = 0;
5731 decl
= IDENTIFIER_SYMBOL_VALUE (TREE_VALUE (parm
));
5732 if (decl
&& DECL_CONTEXT (decl
) == fndecl
)
5734 /* If we got something other than a PARM_DECL it is an error. */
5735 if (TREE_CODE (decl
) != PARM_DECL
)
5736 error ("%J\"%D\" declared as a non-parameter", decl
, decl
);
5737 /* If the declaration is already marked, we have a duplicate
5738 name. Complain and ignore the duplicate. */
5739 else if (DECL_WEAK (decl
))
5741 error ("%Jmultiple parameters named \"%D\"", decl
, decl
);
5742 TREE_PURPOSE (parm
) = 0;
5745 /* If the declaration says "void", complain and turn it into
5747 else if (VOID_TYPE_P (TREE_TYPE (decl
)))
5749 error ("%Jparameter \"%D\" declared void", decl
, decl
);
5750 TREE_TYPE (decl
) = integer_type_node
;
5751 DECL_ARG_TYPE (decl
) = integer_type_node
;
5752 layout_decl (decl
, 0);
5755 /* If no declaration found, default to int. */
5758 decl
= build_decl (PARM_DECL
, TREE_VALUE (parm
), integer_type_node
);
5759 DECL_ARG_TYPE (decl
) = TREE_TYPE (decl
);
5760 DECL_SOURCE_LOCATION (decl
) = DECL_SOURCE_LOCATION (fndecl
);
5764 pedwarn ("%Jtype of \"%D\" defaults to \"int\"", decl
, decl
);
5765 else if (extra_warnings
)
5766 warning ("%Jtype of \"%D\" defaults to \"int\"", decl
, decl
);
5769 TREE_PURPOSE (parm
) = decl
;
5770 DECL_WEAK (decl
) = 1;
5773 /* Now examine the parms chain for incomplete declarations
5774 and declarations with no corresponding names. */
5776 for (parm
= current_scope
->parms
; parm
; parm
= TREE_CHAIN (parm
))
5778 if (!COMPLETE_TYPE_P (TREE_TYPE (parm
)))
5780 error ("%Jparameter \"%D\" has incomplete type", parm
, parm
);
5781 TREE_TYPE (parm
) = error_mark_node
;
5784 if (! DECL_WEAK (parm
))
5786 error ("%Jdeclaration for parameter \"%D\" but no such parameter",
5789 /* Pretend the parameter was not missing.
5790 This gets us to a standard state and minimizes
5791 further error messages. */
5792 parmids
= chainon (parmids
, tree_cons (parm
, 0, 0));
5796 /* Chain the declarations together in the order of the list of
5797 names. Store that chain in the function decl, replacing the
5798 list of names. Update the current scope to match. */
5799 DECL_ARGUMENTS (fndecl
) = 0;
5801 for (parm
= parmids
; parm
; parm
= TREE_CHAIN (parm
))
5802 if (TREE_PURPOSE (parm
))
5804 if (parm
&& TREE_PURPOSE (parm
))
5806 last
= TREE_PURPOSE (parm
);
5807 DECL_ARGUMENTS (fndecl
) = last
;
5808 current_scope
->parms
= last
;
5809 DECL_WEAK (last
) = 0;
5811 for (parm
= TREE_CHAIN (parm
); parm
; parm
= TREE_CHAIN (parm
))
5812 if (TREE_PURPOSE (parm
))
5814 TREE_CHAIN (last
) = TREE_PURPOSE (parm
);
5815 last
= TREE_PURPOSE (parm
);
5816 DECL_WEAK (last
) = 0;
5818 current_scope
->parms_last
= last
;
5819 TREE_CHAIN (last
) = 0;
5822 /* If there was a previous prototype,
5823 set the DECL_ARG_TYPE of each argument according to
5824 the type previously specified, and report any mismatches. */
5826 if (TYPE_ARG_TYPES (TREE_TYPE (fndecl
)))
5829 for (parm
= DECL_ARGUMENTS (fndecl
),
5830 type
= TYPE_ARG_TYPES (TREE_TYPE (fndecl
));
5831 parm
|| (type
&& (TYPE_MAIN_VARIANT (TREE_VALUE (type
))
5832 != void_type_node
));
5833 parm
= TREE_CHAIN (parm
), type
= TREE_CHAIN (type
))
5835 if (parm
== 0 || type
== 0
5836 || TYPE_MAIN_VARIANT (TREE_VALUE (type
)) == void_type_node
)
5838 error ("number of arguments doesn't match prototype");
5839 error ("%Hprototype declaration",
5840 ¤t_function_prototype_locus
);
5843 /* Type for passing arg must be consistent with that
5844 declared for the arg. ISO C says we take the unqualified
5845 type for parameters declared with qualified type. */
5846 if (! comptypes (TYPE_MAIN_VARIANT (DECL_ARG_TYPE (parm
)),
5847 TYPE_MAIN_VARIANT (TREE_VALUE (type
)),
5850 if (TYPE_MAIN_VARIANT (TREE_TYPE (parm
))
5851 == TYPE_MAIN_VARIANT (TREE_VALUE (type
)))
5853 /* Adjust argument to match prototype. E.g. a previous
5854 `int foo(float);' prototype causes
5855 `int foo(x) float x; {...}' to be treated like
5856 `int foo(float x) {...}'. This is particularly
5857 useful for argument types like uid_t. */
5858 DECL_ARG_TYPE (parm
) = TREE_TYPE (parm
);
5860 if (targetm
.calls
.promote_prototypes (TREE_TYPE (current_function_decl
))
5861 && INTEGRAL_TYPE_P (TREE_TYPE (parm
))
5862 && TYPE_PRECISION (TREE_TYPE (parm
))
5863 < TYPE_PRECISION (integer_type_node
))
5864 DECL_ARG_TYPE (parm
) = integer_type_node
;
5868 pedwarn ("promoted argument \"%D\" "
5869 "doesn't match prototype", parm
);
5870 pedwarn ("%Hprototype declaration",
5871 ¤t_function_prototype_locus
);
5876 error ("argument \"%D\" doesn't match prototype", parm
);
5877 error ("%Hprototype declaration",
5878 ¤t_function_prototype_locus
);
5882 TYPE_ACTUAL_ARG_TYPES (TREE_TYPE (fndecl
)) = 0;
5885 /* Otherwise, create a prototype that would match. */
5889 tree actual
= 0, last
= 0, type
;
5891 for (parm
= DECL_ARGUMENTS (fndecl
); parm
; parm
= TREE_CHAIN (parm
))
5893 type
= tree_cons (NULL_TREE
, DECL_ARG_TYPE (parm
), NULL_TREE
);
5895 TREE_CHAIN (last
) = type
;
5900 type
= tree_cons (NULL_TREE
, void_type_node
, NULL_TREE
);
5902 TREE_CHAIN (last
) = type
;
5906 /* We are going to assign a new value for the TYPE_ACTUAL_ARG_TYPES
5907 of the type of this function, but we need to avoid having this
5908 affect the types of other similarly-typed functions, so we must
5909 first force the generation of an identical (but separate) type
5910 node for the relevant function type. The new node we create
5911 will be a variant of the main variant of the original function
5914 TREE_TYPE (fndecl
) = build_type_copy (TREE_TYPE (fndecl
));
5916 TYPE_ACTUAL_ARG_TYPES (TREE_TYPE (fndecl
)) = actual
;
5920 /* Store the parameter declarations into the current function declaration.
5921 This is called after parsing the parameter declarations, before
5922 digesting the body of the function.
5924 For an old-style definition, construct a prototype out of the old-style
5925 parameter declarations and inject it into the function's type. */
5928 store_parm_decls (void)
5930 tree fndecl
= current_function_decl
;
5932 /* The function containing FNDECL, if any. */
5933 tree context
= decl_function_context (fndecl
);
5935 /* True if this definition is written with a prototype. */
5936 bool prototype
= (current_function_parms
5937 && TREE_CODE (current_function_parms
) != TREE_LIST
);
5940 store_parm_decls_newstyle ();
5942 store_parm_decls_oldstyle ();
5944 /* The next call to pushlevel will be a function body. */
5946 next_is_function_body
= true;
5948 /* Write a record describing this function definition to the prototypes
5949 file (if requested). */
5951 gen_aux_info_record (fndecl
, 1, 0, prototype
);
5953 /* Initialize the RTL code for the function. */
5954 allocate_struct_function (fndecl
);
5956 /* Begin the statement tree for this function. */
5957 begin_stmt_tree (&DECL_SAVED_TREE (fndecl
));
5959 /* If this is a nested function, save away the sizes of any
5960 variable-size types so that we can expand them when generating
5966 DECL_LANG_SPECIFIC (fndecl
)->pending_sizes
5967 = nreverse (get_pending_sizes ());
5968 for (t
= DECL_LANG_SPECIFIC (fndecl
)->pending_sizes
;
5971 SAVE_EXPR_CONTEXT (TREE_VALUE (t
)) = context
;
5974 /* This function is being processed in whole-function mode. */
5975 cfun
->x_whole_function_mode_p
= 1;
5977 /* Even though we're inside a function body, we still don't want to
5978 call expand_expr to calculate the size of a variable-sized array.
5979 We haven't necessarily assigned RTL to all variables yet, so it's
5980 not safe to try to expand expressions involving them. */
5981 immediate_size_expand
= 0;
5982 cfun
->x_dont_save_pending_sizes_p
= 1;
5985 /* Finish up a function declaration and compile that function
5986 all the way to assembler language output. The free the storage
5987 for the function definition.
5989 This is called after parsing the body of the function definition. */
5992 finish_function (void)
5994 tree fndecl
= current_function_decl
;
5996 /* When a function declaration is totally empty, e.g.
5998 (the argument list is irrelevant) the compstmt rule will not
5999 bother calling pushlevel/poplevel, which means we get here with
6000 the scope stack out of sync. Detect this situation by noticing
6001 that current_scope is still as store_parm_decls left it, and do
6002 a dummy push/pop to get back to consistency.
6003 Note that the call to pushlevel does not actually push another
6004 scope - see there for details. */
6006 if (current_scope
->parm_flag
&& next_is_function_body
)
6012 if (TREE_CODE (fndecl
) == FUNCTION_DECL
6013 && targetm
.calls
.promote_prototypes (TREE_TYPE (fndecl
)))
6015 tree args
= DECL_ARGUMENTS (fndecl
);
6016 for (; args
; args
= TREE_CHAIN (args
))
6018 tree type
= TREE_TYPE (args
);
6019 if (INTEGRAL_TYPE_P (type
)
6020 && TYPE_PRECISION (type
) < TYPE_PRECISION (integer_type_node
))
6021 DECL_ARG_TYPE (args
) = integer_type_node
;
6025 if (DECL_INITIAL (fndecl
) && DECL_INITIAL (fndecl
) != error_mark_node
)
6026 BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl
)) = fndecl
;
6028 /* Must mark the RESULT_DECL as being in this function. */
6030 if (DECL_RESULT (fndecl
) && DECL_RESULT (fndecl
) != error_mark_node
)
6031 DECL_CONTEXT (DECL_RESULT (fndecl
)) = fndecl
;
6033 if (MAIN_NAME_P (DECL_NAME (fndecl
)) && flag_hosted
)
6035 if (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (fndecl
)))
6036 != integer_type_node
)
6038 /* If warn_main is 1 (-Wmain) or 2 (-Wall), we have already warned.
6039 If warn_main is -1 (-Wno-main) we don't want to be warned. */
6041 pedwarn ("%Jreturn type of '%D' is not `int'", fndecl
, fndecl
);
6045 #ifdef DEFAULT_MAIN_RETURN
6046 /* Make it so that `main' always returns success by default. */
6047 DEFAULT_MAIN_RETURN
;
6050 c_expand_return (integer_zero_node
);
6055 finish_fname_decls ();
6057 /* Tie off the statement tree for this function. */
6058 finish_stmt_tree (&DECL_SAVED_TREE (fndecl
));
6060 /* Complain if there's just no return statement. */
6061 if (warn_return_type
6062 && TREE_CODE (TREE_TYPE (TREE_TYPE (fndecl
))) != VOID_TYPE
6063 && !current_function_returns_value
&& !current_function_returns_null
6064 /* Don't complain if we abort. */
6065 && !current_function_returns_abnormally
6066 /* Don't warn for main(). */
6067 && !MAIN_NAME_P (DECL_NAME (fndecl
))
6068 /* Or if they didn't actually specify a return type. */
6069 && !C_FUNCTION_IMPLICIT_INT (fndecl
)
6070 /* Normally, with -Wreturn-type, flow will complain. Unless we're an
6071 inline function, as we might never be compiled separately. */
6072 && DECL_INLINE (fndecl
))
6073 warning ("no return statement in function returning non-void");
6075 /* With just -Wextra, complain only if function returns both with
6076 and without a value. */
6078 && current_function_returns_value
6079 && current_function_returns_null
)
6080 warning ("this function may return with or without a value");
6082 /* We're leaving the context of this function, so zap cfun.
6083 It's still in DECL_STRUCT_FUNCTION , and we'll restore it in
6084 tree_rest_of_compilation. */
6087 /* ??? Objc emits functions after finalizing the compilation unit.
6088 This should be cleaned up later and this conditional removed. */
6089 if (!cgraph_global_info_ready
)
6090 cgraph_finalize_function (fndecl
, false);
6092 c_expand_body (fndecl
);
6093 current_function_decl
= NULL
;
6096 /* Generate the RTL for the body of FNDECL. If NESTED_P is nonzero,
6097 then we are already in the process of generating RTL for another
6101 c_expand_body_1 (tree fndecl
, int nested_p
)
6105 /* Make sure that we will evaluate variable-sized types involved
6106 in our function's type. */
6107 expand_pending_sizes (DECL_LANG_SPECIFIC (fndecl
)->pending_sizes
);
6109 /* Squirrel away our current state. */
6110 push_function_context ();
6113 tree_rest_of_compilation (fndecl
, nested_p
);
6116 /* Return to the enclosing function. */
6117 pop_function_context ();
6119 if (DECL_STATIC_CONSTRUCTOR (fndecl
))
6121 if (targetm
.have_ctors_dtors
)
6122 (* targetm
.asm_out
.constructor
) (XEXP (DECL_RTL (fndecl
), 0),
6123 DEFAULT_INIT_PRIORITY
);
6125 static_ctors
= tree_cons (NULL_TREE
, fndecl
, static_ctors
);
6128 if (DECL_STATIC_DESTRUCTOR (fndecl
))
6130 if (targetm
.have_ctors_dtors
)
6131 (* targetm
.asm_out
.destructor
) (XEXP (DECL_RTL (fndecl
), 0),
6132 DEFAULT_INIT_PRIORITY
);
6134 static_dtors
= tree_cons (NULL_TREE
, fndecl
, static_dtors
);
6138 /* Like c_expand_body_1 but only for unnested functions. */
6141 c_expand_body (tree fndecl
)
6144 if (DECL_INITIAL (fndecl
) && DECL_INITIAL (fndecl
) != error_mark_node
)
6145 c_expand_body_1 (fndecl
, 0);
6148 /* Check the declarations given in a for-loop for satisfying the C99
6151 check_for_loop_decls (void)
6157 /* If we get here, declarations have been used in a for loop without
6158 the C99 for loop scope. This doesn't make much sense, so don't
6160 error ("'for' loop initial declaration used outside C99 mode");
6163 /* C99 subclause 6.8.5 paragraph 3:
6165 [#3] The declaration part of a for statement shall only
6166 declare identifiers for objects having storage class auto or
6169 It isn't clear whether, in this sentence, "identifiers" binds to
6170 "shall only declare" or to "objects" - that is, whether all identifiers
6171 declared must be identifiers for objects, or whether the restriction
6172 only applies to those that are. (A question on this in comp.std.c
6173 in November 2000 received no answer.) We implement the strictest
6174 interpretation, to avoid creating an extension which later causes
6177 for (t
= current_scope
->tags
; t
; t
= TREE_CHAIN (t
))
6179 if (TREE_PURPOSE (t
) != 0)
6181 enum tree_code code
= TREE_CODE (TREE_VALUE (t
));
6183 if (code
== RECORD_TYPE
)
6184 error ("'struct %s' declared in 'for' loop initial declaration",
6185 IDENTIFIER_POINTER (TREE_PURPOSE (t
)));
6186 else if (code
== UNION_TYPE
)
6187 error ("'union %s' declared in 'for' loop initial declaration",
6188 IDENTIFIER_POINTER (TREE_PURPOSE (t
)));
6190 error ("'enum %s' declared in 'for' loop initial declaration",
6191 IDENTIFIER_POINTER (TREE_PURPOSE (t
)));
6195 for (t
= current_scope
->names
; t
; t
= TREE_CHAIN (t
))
6197 if (TREE_CODE (t
) != VAR_DECL
&& DECL_NAME (t
))
6198 error ("%Jdeclaration of non-variable '%D' in 'for' loop "
6199 "initial declaration", t
, t
);
6200 else if (TREE_STATIC (t
))
6201 error ("%Jdeclaration of static variable '%D' in 'for' loop "
6202 "initial declaration", t
, t
);
6203 else if (DECL_EXTERNAL (t
))
6204 error ("%Jdeclaration of 'extern' variable '%D' in 'for' loop "
6205 "initial declaration", t
, t
);
6209 /* Save and reinitialize the variables
6210 used during compilation of a C function. */
6213 c_push_function_context (struct function
*f
)
6215 struct language_function
*p
;
6216 p
= ggc_alloc (sizeof (struct language_function
));
6219 p
->base
.x_stmt_tree
= c_stmt_tree
;
6220 p
->base
.x_scope_stmt_stack
= c_scope_stmt_stack
;
6221 p
->x_in_iteration_stmt
= c_in_iteration_stmt
;
6222 p
->x_in_case_stmt
= c_in_case_stmt
;
6223 p
->returns_value
= current_function_returns_value
;
6224 p
->returns_null
= current_function_returns_null
;
6225 p
->returns_abnormally
= current_function_returns_abnormally
;
6226 p
->warn_about_return_type
= warn_about_return_type
;
6227 p
->extern_inline
= current_extern_inline
;
6230 /* Restore the variables used during compilation of a C function. */
6233 c_pop_function_context (struct function
*f
)
6235 struct language_function
*p
= f
->language
;
6237 if (DECL_STRUCT_FUNCTION (current_function_decl
) == 0
6238 && DECL_SAVED_TREE (current_function_decl
) == NULL_TREE
)
6240 /* Stop pointing to the local nodes about to be freed. */
6241 /* But DECL_INITIAL must remain nonzero so we know this
6242 was an actual function definition. */
6243 DECL_INITIAL (current_function_decl
) = error_mark_node
;
6244 DECL_ARGUMENTS (current_function_decl
) = 0;
6247 c_stmt_tree
= p
->base
.x_stmt_tree
;
6248 c_scope_stmt_stack
= p
->base
.x_scope_stmt_stack
;
6249 c_in_iteration_stmt
= p
->x_in_iteration_stmt
;
6250 c_in_case_stmt
= p
->x_in_case_stmt
;
6251 current_function_returns_value
= p
->returns_value
;
6252 current_function_returns_null
= p
->returns_null
;
6253 current_function_returns_abnormally
= p
->returns_abnormally
;
6254 warn_about_return_type
= p
->warn_about_return_type
;
6255 current_extern_inline
= p
->extern_inline
;
6260 /* Copy the DECL_LANG_SPECIFIC data associated with DECL. */
6263 c_dup_lang_specific_decl (tree decl
)
6265 struct lang_decl
*ld
;
6267 if (!DECL_LANG_SPECIFIC (decl
))
6270 ld
= ggc_alloc (sizeof (struct lang_decl
));
6271 memcpy (ld
, DECL_LANG_SPECIFIC (decl
), sizeof (struct lang_decl
));
6272 DECL_LANG_SPECIFIC (decl
) = ld
;
6275 /* The functions below are required for functionality of doing
6276 function at once processing in the C front end. Currently these
6277 functions are not called from anywhere in the C front end, but as
6278 these changes continue, that will change. */
6280 /* Returns nonzero if the current statement is a full expression,
6281 i.e. temporaries created during that statement should be destroyed
6282 at the end of the statement. */
6285 stmts_are_full_exprs_p (void)
6290 /* Returns the stmt_tree (if any) to which statements are currently
6291 being added. If there is no active statement-tree, NULL is
6295 current_stmt_tree (void)
6297 return &c_stmt_tree
;
6300 /* Returns the stack of SCOPE_STMTs for the current function. */
6303 current_scope_stmt_stack (void)
6305 return &c_scope_stmt_stack
;
6308 /* Nonzero if TYPE is an anonymous union or struct type. Always 0 in
6312 anon_aggr_type_p (tree node ATTRIBUTE_UNUSED
)
6317 /* Dummy function in place of callback used by C++. */
6320 extract_interface_info (void)
6324 /* Return a new COMPOUND_STMT, after adding it to the current
6328 c_begin_compound_stmt (void)
6332 /* Create the COMPOUND_STMT. */
6333 stmt
= add_stmt (build_stmt (COMPOUND_STMT
, NULL_TREE
));
6338 /* Expand T (a DECL_STMT) if it declares an entity not handled by the
6342 c_expand_decl_stmt (tree t
)
6344 tree decl
= DECL_STMT_DECL (t
);
6346 /* Expand nested functions. */
6347 if (TREE_CODE (decl
) == FUNCTION_DECL
6348 && DECL_CONTEXT (decl
) == current_function_decl
6349 && DECL_SAVED_TREE (decl
))
6350 c_expand_body_1 (decl
, 1);
6353 /* Return the global value of T as a symbol. */
6356 identifier_global_value (tree t
)
6358 tree decl
= IDENTIFIER_SYMBOL_VALUE (t
);
6359 if (decl
== 0 || DECL_FILE_SCOPE_P (decl
))
6362 /* Shadowed by something else; find the true global value. */
6363 for (decl
= global_scope
->names
; decl
; decl
= TREE_CHAIN (decl
))
6364 if (DECL_NAME (decl
) == t
)
6367 /* Only local values for this decl. */
6371 /* Record a builtin type for C. If NAME is non-NULL, it is the name used;
6372 otherwise the name is found in ridpointers from RID_INDEX. */
6375 record_builtin_type (enum rid rid_index
, const char *name
, tree type
)
6380 id
= ridpointers
[(int) rid_index
];
6382 id
= get_identifier (name
);
6383 tdecl
= build_decl (TYPE_DECL
, id
, type
);
6385 debug_hooks
->type_decl (tdecl
, 0);
6388 /* Build the void_list_node (void_type_node having been created). */
6390 build_void_list_node (void)
6392 tree t
= build_tree_list (NULL_TREE
, void_type_node
);
6396 /* Return something to represent absolute declarators containing a *.
6397 TARGET is the absolute declarator that the * contains.
6398 TYPE_QUALS_ATTRS is a list of modifiers such as const or volatile
6399 to apply to the pointer type, represented as identifiers, possible mixed
6402 We return an INDIRECT_REF whose "contents" are TARGET (inside a TREE_LIST,
6403 if attributes are present) and whose type is the modifier list. */
6406 make_pointer_declarator (tree type_quals_attrs
, tree target
)
6409 tree itarget
= target
;
6410 split_specs_attrs (type_quals_attrs
, &quals
, &attrs
);
6411 if (attrs
!= NULL_TREE
)
6412 itarget
= tree_cons (attrs
, target
, NULL_TREE
);
6413 return build1 (INDIRECT_REF
, quals
, itarget
);
6416 /* A wrapper around lhd_set_decl_assembler_name that gives static
6417 variables their C names if they are at file scope and only one
6418 translation unit is being compiled, for backwards compatibility
6419 with certain bizarre assembler hacks (like crtstuff.c). */
6422 c_static_assembler_name (tree decl
)
6424 if (num_in_fnames
== 1
6425 && !TREE_PUBLIC (decl
) && DECL_CONTEXT (decl
)
6426 && TREE_CODE (DECL_CONTEXT (decl
)) == TRANSLATION_UNIT_DECL
)
6427 SET_DECL_ASSEMBLER_NAME (decl
, DECL_NAME (decl
));
6429 lhd_set_decl_assembler_name (decl
);
6432 /* Hash and equality functions for link_hash_table: key off
6433 DECL_ASSEMBLER_NAME. */
6436 link_hash_hash (const void *x_p
)
6439 return (hashval_t
) (long)DECL_ASSEMBLER_NAME (x
);
6443 link_hash_eq (const void *x1_p
, const void *x2_p
)
6445 tree x1
= (tree
)x1_p
;
6446 tree x2
= (tree
)x2_p
;
6447 return DECL_ASSEMBLER_NAME (x1
) == DECL_ASSEMBLER_NAME (x2
);
6450 /* Propagate information between definitions and uses between multiple
6451 translation units in TU_LIST based on linkage rules. */
6454 merge_translation_unit_decls (void)
6456 const tree tu_list
= current_file_decl
;
6459 htab_t link_hash_table
;
6462 /* Create the BLOCK that poplevel would have created, but don't
6463 actually call poplevel since that's expensive. */
6464 block
= make_node (BLOCK
);
6465 BLOCK_VARS (block
) = current_scope
->names
;
6466 TREE_USED (block
) = 1;
6467 DECL_INITIAL (current_file_decl
) = block
;
6469 /* If only one translation unit seen, no copying necessary. */
6470 if (TREE_CHAIN (tu_list
) == NULL_TREE
)
6473 link_hash_table
= htab_create (1021, link_hash_hash
, link_hash_eq
, NULL
);
6475 /* Enter any actual definitions into the hash table. */
6476 for (tu
= tu_list
; tu
; tu
= TREE_CHAIN (tu
))
6477 for (decl
= BLOCK_VARS (DECL_INITIAL (tu
)); decl
; decl
= TREE_CHAIN (decl
))
6478 if (TREE_PUBLIC (decl
) && ! DECL_EXTERNAL (decl
))
6481 slot
= htab_find_slot (link_hash_table
, decl
, INSERT
);
6483 /* If we've already got a definition, work out which one is
6484 the real one, put it into the hash table, and make the
6485 other one DECL_EXTERNAL. This is important to avoid
6486 putting out two definitions of the same symbol in the
6490 tree old_decl
= (tree
) *slot
;
6492 /* If this is weak or common or whatever, suppress it
6493 in favor of the other definition. */
6494 if (DECL_WEAK (decl
))
6495 DECL_EXTERNAL (decl
) = 1;
6496 else if (DECL_WEAK (old_decl
) && ! DECL_WEAK (decl
))
6497 DECL_EXTERNAL (old_decl
) = 1;
6498 else if (DECL_COMMON (decl
) || DECL_ONE_ONLY (decl
))
6499 DECL_EXTERNAL (decl
) = 1;
6500 else if (DECL_COMMON (old_decl
) || DECL_ONE_ONLY (old_decl
))
6501 DECL_EXTERNAL (old_decl
) = 1;
6503 if (DECL_EXTERNAL (decl
))
6505 DECL_INITIAL (decl
) = NULL_TREE
;
6506 DECL_COMMON (decl
) = 0;
6507 DECL_ONE_ONLY (decl
) = 0;
6508 DECL_WEAK (decl
) = 0;
6510 else if (DECL_EXTERNAL (old_decl
))
6512 DECL_INITIAL (old_decl
) = NULL_TREE
;
6513 DECL_COMMON (old_decl
) = 0;
6514 DECL_ONE_ONLY (old_decl
) = 0;
6515 DECL_WEAK (old_decl
) = 0;
6520 error ("%Jredefinition of global '%D'", decl
, decl
);
6521 error ("%J'%D' previously defined here", old_decl
, old_decl
);
6528 /* Now insert the desired information from all the definitions
6529 into any plain declarations. */
6530 for (tu
= tu_list
; tu
; tu
= TREE_CHAIN (tu
))
6531 for (decl
= BLOCK_VARS (DECL_INITIAL (tu
)); decl
; decl
= TREE_CHAIN (decl
))
6532 if (TREE_PUBLIC (decl
) && DECL_EXTERNAL (decl
))
6535 global_decl
= htab_find (link_hash_table
, decl
);
6540 /* Print any appropriate error messages, and partially merge
6542 (void) duplicate_decls (decl
, global_decl
);
6545 htab_delete (link_hash_table
);
6548 /* Perform final processing on file-scope data. */
6551 c_write_global_declarations(void)
6555 for (link
= current_file_decl
; link
; link
= TREE_CHAIN (link
))
6557 tree globals
= BLOCK_VARS (DECL_INITIAL (link
));
6558 int len
= list_length (globals
);
6559 tree
*vec
= xmalloc (sizeof (tree
) * len
);
6563 /* Process the decls in the order they were written. */
6565 for (i
= 0, decl
= globals
; i
< len
; i
++, decl
= TREE_CHAIN (decl
))
6568 wrapup_global_declarations (vec
, len
);
6570 check_global_declarations (vec
, len
);
6577 /* Reset the parser's state in preparation for a new file. */
6580 c_reset_state (void)
6583 tree file_scope_decl
;
6585 /* Pop the global scope. */
6586 if (current_scope
!= global_scope
)
6587 current_scope
= global_scope
;
6588 file_scope_decl
= current_file_decl
;
6589 DECL_INITIAL (file_scope_decl
) = poplevel (1, 0, 0);
6590 BLOCK_SUPERCONTEXT (DECL_INITIAL (file_scope_decl
)) = file_scope_decl
;
6591 truly_local_externals
= NULL_TREE
;
6593 /* Start a new global binding level. */
6595 global_scope
= current_scope
;
6596 current_file_decl
= build_decl (TRANSLATION_UNIT_DECL
, NULL
, NULL
);
6597 TREE_CHAIN (current_file_decl
) = file_scope_decl
;
6599 /* Reintroduce the builtin declarations. */
6600 for (link
= first_builtin_decl
;
6601 link
!= TREE_CHAIN (last_builtin_decl
);
6602 link
= TREE_CHAIN (link
))
6603 pushdecl (copy_node (link
));
6606 #include "gt-c-decl.h"