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, 2005, 2006, 2007, 2008, 2009
4 Free Software Foundation, Inc.
6 This file is part of GCC.
8 GCC is free software; you can redistribute it and/or modify it under
9 the terms of the GNU General Public License as published by the Free
10 Software Foundation; either version 3, or (at your option) any later
13 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
14 WARRANTY; without even the implied warranty of MERCHANTABILITY or
15 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING3. If not see
20 <http://www.gnu.org/licenses/>. */
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"
36 #include "tree-inline.h"
54 #include "langhooks.h"
55 #include "tree-mudflap.h"
57 #include "tree-iterator.h"
58 #include "diagnostic.h"
59 #include "tree-dump.h"
64 #include "langhooks-def.h"
65 #include "pointer-set.h"
69 /* In grokdeclarator, distinguish syntactic contexts of declarators. */
71 { NORMAL
, /* Ordinary declaration */
72 FUNCDEF
, /* Function definition */
73 PARM
, /* Declaration of parm before function body */
74 FIELD
, /* Declaration inside struct or union */
75 TYPENAME
}; /* Typename (inside cast or sizeof) */
77 /* States indicating how grokdeclarator() should handle declspecs marked
78 with __attribute__((deprecated)). An object declared as
79 __attribute__((deprecated)) suppresses warnings of uses of other
82 enum deprecated_states
{
88 /* Nonzero if we have seen an invalid cross reference
89 to a struct, union, or enum, but not yet printed the message. */
90 tree pending_invalid_xref
;
92 /* File and line to appear in the eventual error message. */
93 location_t pending_invalid_xref_location
;
95 /* True means we've initialized exception handling. */
96 bool c_eh_initialized_p
;
98 /* The file and line that the prototype came from if this is an
99 old-style definition; used for diagnostics in
100 store_parm_decls_oldstyle. */
102 static location_t current_function_prototype_locus
;
104 /* Whether this prototype was built-in. */
106 static bool current_function_prototype_built_in
;
108 /* The argument type information of this prototype. */
110 static tree current_function_prototype_arg_types
;
112 /* The argument information structure for the function currently being
115 static struct c_arg_info
*current_function_arg_info
;
117 /* The obstack on which parser and related data structures, which are
118 not live beyond their top-level declaration or definition, are
120 struct obstack parser_obstack
;
122 /* The current statement tree. */
124 static GTY(()) struct stmt_tree_s c_stmt_tree
;
126 /* State saving variables. */
130 /* Linked list of TRANSLATION_UNIT_DECLS for the translation units
131 included in this invocation. Note that the current translation
132 unit is not included in this list. */
134 static GTY(()) tree all_translation_units
;
136 /* A list of decls to be made automatically visible in each file scope. */
137 static GTY(()) tree visible_builtins
;
139 /* Set to 0 at beginning of a function definition, set to 1 if
140 a return statement that specifies a return value is seen. */
142 int current_function_returns_value
;
144 /* Set to 0 at beginning of a function definition, set to 1 if
145 a return statement with no argument is seen. */
147 int current_function_returns_null
;
149 /* Set to 0 at beginning of a function definition, set to 1 if
150 a call to a noreturn function is seen. */
152 int current_function_returns_abnormally
;
154 /* Set to nonzero by `grokdeclarator' for a function
155 whose return type is defaulted, if warnings for this are desired. */
157 static int warn_about_return_type
;
159 /* Nonzero when the current toplevel function contains a declaration
160 of a nested function which is never defined. */
162 static bool undef_nested_function
;
164 /* True means global_bindings_p should return false even if the scope stack
165 says we are in file scope. */
166 bool c_override_global_bindings_to_false
;
169 /* Each c_binding structure describes one binding of an identifier to
170 a decl. All the decls in a scope - irrespective of namespace - are
171 chained together by the ->prev field, which (as the name implies)
172 runs in reverse order. All the decls in a given namespace bound to
173 a given identifier are chained by the ->shadowed field, which runs
174 from inner to outer scopes.
176 The ->decl field usually points to a DECL node, but there are two
177 exceptions. In the namespace of type tags, the bound entity is a
178 RECORD_TYPE, UNION_TYPE, or ENUMERAL_TYPE node. If an undeclared
179 identifier is encountered, it is bound to error_mark_node to
180 suppress further errors about that identifier in the current
183 The ->u.type field stores the type of the declaration in this scope;
184 if NULL, the type is the type of the ->decl field. This is only of
185 relevance for objects with external or internal linkage which may
186 be redeclared in inner scopes, forming composite types that only
187 persist for the duration of those scopes. In the external scope,
188 this stores the composite of all the types declared for this
189 object, visible or not. The ->inner_comp field (used only at file
190 scope) stores whether an incomplete array type at file scope was
191 completed at an inner scope to an array size other than 1.
193 The ->u.label field is used for labels. It points to a structure
194 which stores additional information used for warnings.
196 The depth field is copied from the scope structure that holds this
197 decl. It is used to preserve the proper ordering of the ->shadowed
198 field (see bind()) and also for a handful of special-case checks.
199 Finally, the invisible bit is true for a decl which should be
200 ignored for purposes of normal name lookup, and the nested bit is
201 true for a decl that's been bound a second time in an inner scope;
202 in all such cases, the binding in the outer scope will have its
203 invisible bit true. */
205 struct GTY((chain_next ("%h.prev"))) c_binding
{
206 union GTY(()) { /* first so GTY desc can use decl */
207 tree
GTY((tag ("0"))) type
; /* the type in this scope */
208 struct c_label_vars
* GTY((tag ("1"))) label
; /* for warnings */
209 } GTY((desc ("TREE_CODE (%0.decl) == LABEL_DECL"))) u
;
210 tree decl
; /* the decl bound */
211 tree id
; /* the identifier it's bound to */
212 struct c_binding
*prev
; /* the previous decl in this scope */
213 struct c_binding
*shadowed
; /* the innermost decl shadowed by this one */
214 unsigned int depth
: 28; /* depth of this scope */
215 BOOL_BITFIELD invisible
: 1; /* normal lookup should ignore this binding */
216 BOOL_BITFIELD nested
: 1; /* do not set DECL_CONTEXT when popping */
217 BOOL_BITFIELD inner_comp
: 1; /* incomplete array completed in inner scope */
218 BOOL_BITFIELD in_struct
: 1; /* currently defined as struct field */
219 location_t locus
; /* location for nested bindings */
221 #define B_IN_SCOPE(b1, b2) ((b1)->depth == (b2)->depth)
222 #define B_IN_CURRENT_SCOPE(b) ((b)->depth == current_scope->depth)
223 #define B_IN_FILE_SCOPE(b) ((b)->depth == 1 /*file_scope->depth*/)
224 #define B_IN_EXTERNAL_SCOPE(b) ((b)->depth == 0 /*external_scope->depth*/)
226 #define I_SYMBOL_BINDING(node) \
227 (((struct lang_identifier *) IDENTIFIER_NODE_CHECK(node))->symbol_binding)
228 #define I_SYMBOL_DECL(node) \
229 (I_SYMBOL_BINDING(node) ? I_SYMBOL_BINDING(node)->decl : 0)
231 #define I_TAG_BINDING(node) \
232 (((struct lang_identifier *) IDENTIFIER_NODE_CHECK(node))->tag_binding)
233 #define I_TAG_DECL(node) \
234 (I_TAG_BINDING(node) ? I_TAG_BINDING(node)->decl : 0)
236 #define I_LABEL_BINDING(node) \
237 (((struct lang_identifier *) IDENTIFIER_NODE_CHECK(node))->label_binding)
238 #define I_LABEL_DECL(node) \
239 (I_LABEL_BINDING(node) ? I_LABEL_BINDING(node)->decl : 0)
241 /* Each C symbol points to three linked lists of c_binding structures.
242 These describe the values of the identifier in the three different
243 namespaces defined by the language. */
245 struct GTY(()) lang_identifier
{
246 struct c_common_identifier common_id
;
247 struct c_binding
*symbol_binding
; /* vars, funcs, constants, typedefs */
248 struct c_binding
*tag_binding
; /* struct/union/enum tags */
249 struct c_binding
*label_binding
; /* labels */
252 /* Validate c-lang.c's assumptions. */
253 extern char C_SIZEOF_STRUCT_LANG_IDENTIFIER_isnt_accurate
254 [(sizeof(struct lang_identifier
) == C_SIZEOF_STRUCT_LANG_IDENTIFIER
) ? 1 : -1];
256 /* The resulting tree type. */
258 union GTY((desc ("TREE_CODE (&%h.generic) == IDENTIFIER_NODE"),
259 chain_next ("TREE_CODE (&%h.generic) == INTEGER_TYPE ? (union lang_tree_node *) TYPE_NEXT_VARIANT (&%h.generic) : ((union lang_tree_node *) TREE_CHAIN (&%h.generic))"))) lang_tree_node
261 union tree_node
GTY ((tag ("0"),
262 desc ("tree_node_structure (&%h)")))
264 struct lang_identifier
GTY ((tag ("1"))) identifier
;
267 /* Track bindings and other things that matter for goto warnings. For
268 efficiency, we do not gather all the decls at the point of
269 definition. Instead, we point into the bindings structure. As
270 scopes are popped, we update these structures and gather the decls
271 that matter at that time. */
273 struct GTY(()) c_spot_bindings
{
274 /* The currently open scope which holds bindings defined when the
275 label was defined or the goto statement was found. */
276 struct c_scope
*scope
;
277 /* The bindings in the scope field which were defined at the point
278 of the label or goto. This lets us look at older or newer
279 bindings in the scope, as appropriate. */
280 struct c_binding
*bindings_in_scope
;
281 /* The number of statement expressions that have started since this
282 label or goto statement was defined. This is zero if we are at
283 the same statement expression level. It is positive if we are in
284 a statement expression started since this spot. It is negative
285 if this spot was in a statement expression and we have left
288 /* Whether we started in a statement expression but are no longer in
289 it. This is set to true if stmt_exprs ever goes negative. */
293 /* This structure is used to keep track of bindings seen when a goto
294 statement is defined. This is only used if we see the goto
295 statement before we see the label. */
297 struct GTY(()) c_goto_bindings
{
298 /* The location of the goto statement. */
300 /* The bindings of the goto statement. */
301 struct c_spot_bindings goto_bindings
;
304 typedef struct c_goto_bindings
*c_goto_bindings_p
;
305 DEF_VEC_P(c_goto_bindings_p
);
306 DEF_VEC_ALLOC_P(c_goto_bindings_p
,gc
);
308 /* The additional information we keep track of for a label binding.
309 These fields are updated as scopes are popped. */
311 struct GTY(()) c_label_vars
{
312 /* The shadowed c_label_vars, when one label shadows another (which
313 can only happen using a __label__ declaration). */
314 struct c_label_vars
*shadowed
;
315 /* The bindings when the label was defined. */
316 struct c_spot_bindings label_bindings
;
317 /* A list of decls that we care about: decls about which we should
318 warn if a goto branches to this label from later in the function.
319 Decls are added to this list as scopes are popped. We only add
320 the decls that matter. */
321 VEC(tree
,gc
) *decls_in_scope
;
322 /* A list of goto statements to this label. This is only used for
323 goto statements seen before the label was defined, so that we can
324 issue appropriate warnings for them. */
325 VEC(c_goto_bindings_p
,gc
) *gotos
;
328 /* Each c_scope structure describes the complete contents of one
329 scope. Four scopes are distinguished specially: the innermost or
330 current scope, the innermost function scope, the file scope (always
331 the second to outermost) and the outermost or external scope.
333 Most declarations are recorded in the current scope.
335 All normal label declarations are recorded in the innermost
336 function scope, as are bindings of undeclared identifiers to
337 error_mark_node. (GCC permits nested functions as an extension,
338 hence the 'innermost' qualifier.) Explicitly declared labels
339 (using the __label__ extension) appear in the current scope.
341 Being in the file scope (current_scope == file_scope) causes
342 special behavior in several places below. Also, under some
343 conditions the Objective-C front end records declarations in the
344 file scope even though that isn't the current scope.
346 All declarations with external linkage are recorded in the external
347 scope, even if they aren't visible there; this models the fact that
348 such declarations are visible to the entire program, and (with a
349 bit of cleverness, see pushdecl) allows diagnosis of some violations
350 of C99 6.2.2p7 and 6.2.7p2:
352 If, within the same translation unit, the same identifier appears
353 with both internal and external linkage, the behavior is
356 All declarations that refer to the same object or function shall
357 have compatible type; otherwise, the behavior is undefined.
359 Initially only the built-in declarations, which describe compiler
360 intrinsic functions plus a subset of the standard library, are in
363 The order of the blocks list matters, and it is frequently appended
364 to. To avoid having to walk all the way to the end of the list on
365 each insertion, or reverse the list later, we maintain a pointer to
366 the last list entry. (FIXME: It should be feasible to use a reversed
369 The bindings list is strictly in reverse order of declarations;
370 pop_scope relies on this. */
373 struct GTY((chain_next ("%h.outer"))) c_scope
{
374 /* The scope containing this one. */
375 struct c_scope
*outer
;
377 /* The next outermost function scope. */
378 struct c_scope
*outer_function
;
380 /* All bindings in this scope. */
381 struct c_binding
*bindings
;
383 /* For each scope (except the global one), a chain of BLOCK nodes
384 for all the scopes that were entered and exited one level down. */
388 /* The depth of this scope. Used to keep the ->shadowed chain of
389 bindings sorted innermost to outermost. */
390 unsigned int depth
: 28;
392 /* True if we are currently filling this scope with parameter
394 BOOL_BITFIELD parm_flag
: 1;
396 /* True if we saw [*] in this scope. Used to give an error messages
397 if these appears in a function definition. */
398 BOOL_BITFIELD had_vla_unspec
: 1;
400 /* True if we already complained about forward parameter decls
401 in this scope. This prevents double warnings on
402 foo (int a; int b; ...) */
403 BOOL_BITFIELD warned_forward_parm_decls
: 1;
405 /* True if this is the outermost block scope of a function body.
406 This scope contains the parameters, the local variables declared
407 in the outermost block, and all the labels (except those in
408 nested functions, or declared at block scope with __label__). */
409 BOOL_BITFIELD function_body
: 1;
411 /* True means make a BLOCK for this scope no matter what. */
412 BOOL_BITFIELD keep
: 1;
414 /* True means that an unsuffixed float constant is _Decimal64. */
415 BOOL_BITFIELD float_const_decimal64
: 1;
417 /* True if this scope has any label bindings. This is used to speed
418 up searching for labels when popping scopes, particularly since
419 labels are normally only found at function scope. */
420 BOOL_BITFIELD has_label_bindings
: 1;
423 /* The scope currently in effect. */
425 static GTY(()) struct c_scope
*current_scope
;
427 /* The innermost function scope. Ordinary (not explicitly declared)
428 labels, bindings to error_mark_node, and the lazily-created
429 bindings of __func__ and its friends get this scope. */
431 static GTY(()) struct c_scope
*current_function_scope
;
433 /* The C file scope. This is reset for each input translation unit. */
435 static GTY(()) struct c_scope
*file_scope
;
437 /* The outermost scope. This is used for all declarations with
438 external linkage, and only these, hence the name. */
440 static GTY(()) struct c_scope
*external_scope
;
442 /* A chain of c_scope structures awaiting reuse. */
444 static GTY((deletable
)) struct c_scope
*scope_freelist
;
446 /* A chain of c_binding structures awaiting reuse. */
448 static GTY((deletable
)) struct c_binding
*binding_freelist
;
450 /* Append VAR to LIST in scope SCOPE. */
451 #define SCOPE_LIST_APPEND(scope, list, decl) do { \
452 struct c_scope *s_ = (scope); \
454 if (s_->list##_last) \
455 BLOCK_CHAIN (s_->list##_last) = d_; \
458 s_->list##_last = d_; \
461 /* Concatenate FROM in scope FSCOPE onto TO in scope TSCOPE. */
462 #define SCOPE_LIST_CONCAT(tscope, to, fscope, from) do { \
463 struct c_scope *t_ = (tscope); \
464 struct c_scope *f_ = (fscope); \
466 BLOCK_CHAIN (t_->to##_last) = f_->from; \
469 t_->to##_last = f_->from##_last; \
472 /* A c_inline_static structure stores details of a static identifier
473 referenced in a definition of a function that may be an inline
474 definition if no subsequent declaration of that function uses
475 "extern" or does not use "inline". */
477 struct GTY((chain_next ("%h.next"))) c_inline_static
{
478 /* The location for a diagnostic. */
481 /* The function that may be an inline definition. */
484 /* The object or function referenced. */
487 /* What sort of reference this is. */
488 enum c_inline_static_type type
;
490 /* The next such structure or NULL. */
491 struct c_inline_static
*next
;
494 /* List of static identifiers used or referenced in functions that may
495 be inline definitions. */
496 static GTY(()) struct c_inline_static
*c_inline_statics
;
498 /* True means unconditionally make a BLOCK for the next scope pushed. */
500 static bool keep_next_level_flag
;
502 /* True means the next call to push_scope will be the outermost scope
503 of a function body, so do not push a new scope, merely cease
504 expecting parameter decls. */
506 static bool next_is_function_body
;
508 /* A VEC of pointers to c_binding structures. */
510 typedef struct c_binding
*c_binding_ptr
;
511 DEF_VEC_P(c_binding_ptr
);
512 DEF_VEC_ALLOC_P(c_binding_ptr
,heap
);
514 /* Information that we keep for a struct or union while it is being
517 struct c_struct_parse_info
519 /* If warn_cxx_compat, a list of types defined within this
521 VEC(tree
,heap
) *struct_types
;
522 /* If warn_cxx_compat, a list of field names which have bindings,
523 and which are defined in this struct, but which are not defined
524 in any enclosing struct. This is used to clear the in_struct
525 field of the c_bindings structure. */
526 VEC(c_binding_ptr
,heap
) *fields
;
527 /* If warn_cxx_compat, a list of typedef names used when defining
528 fields in this struct. */
529 VEC(tree
,heap
) *typedefs_seen
;
532 /* Information for the struct or union currently being parsed, or
533 NULL if not parsing a struct or union. */
534 static struct c_struct_parse_info
*struct_parse_info
;
536 /* Forward declarations. */
537 static tree
lookup_name_in_scope (tree
, struct c_scope
*);
538 static tree
c_make_fname_decl (location_t
, tree
, int);
539 static tree
grokdeclarator (const struct c_declarator
*,
540 struct c_declspecs
*,
541 enum decl_context
, bool, tree
*, tree
*, tree
*,
542 bool *, enum deprecated_states
);
543 static tree
grokparms (struct c_arg_info
*, bool);
544 static void layout_array_type (tree
);
546 /* T is a statement. Add it to the statement-tree. This is the
547 C/ObjC version--C++ has a slightly different version of this
553 enum tree_code code
= TREE_CODE (t
);
555 if (CAN_HAVE_LOCATION_P (t
) && code
!= LABEL_EXPR
)
557 if (!EXPR_HAS_LOCATION (t
))
558 SET_EXPR_LOCATION (t
, input_location
);
561 if (code
== LABEL_EXPR
|| code
== CASE_LABEL_EXPR
)
562 STATEMENT_LIST_HAS_LABEL (cur_stmt_list
) = 1;
564 /* Add T to the statement-tree. Non-side-effect statements need to be
565 recorded during statement expressions. */
566 append_to_statement_list_force (t
, &cur_stmt_list
);
573 c_print_identifier (FILE *file
, tree node
, int indent
)
575 print_node (file
, "symbol", I_SYMBOL_DECL (node
), indent
+ 4);
576 print_node (file
, "tag", I_TAG_DECL (node
), indent
+ 4);
577 print_node (file
, "label", I_LABEL_DECL (node
), indent
+ 4);
578 if (C_IS_RESERVED_WORD (node
) && C_RID_CODE (node
) != RID_CXX_COMPAT_WARN
)
580 tree rid
= ridpointers
[C_RID_CODE (node
)];
581 indent_to (file
, indent
+ 4);
582 fprintf (file
, "rid %p \"%s\"",
583 (void *) rid
, IDENTIFIER_POINTER (rid
));
587 /* Establish a binding between NAME, an IDENTIFIER_NODE, and DECL,
588 which may be any of several kinds of DECL or TYPE or error_mark_node,
589 in the scope SCOPE. */
591 bind (tree name
, tree decl
, struct c_scope
*scope
, bool invisible
,
592 bool nested
, location_t locus
)
594 struct c_binding
*b
, **here
;
596 if (binding_freelist
)
598 b
= binding_freelist
;
599 binding_freelist
= b
->prev
;
602 b
= GGC_NEW (struct c_binding
);
607 b
->depth
= scope
->depth
;
608 b
->invisible
= invisible
;
616 b
->prev
= scope
->bindings
;
622 switch (TREE_CODE (decl
))
624 case LABEL_DECL
: here
= &I_LABEL_BINDING (name
); break;
627 case RECORD_TYPE
: here
= &I_TAG_BINDING (name
); break;
633 case ERROR_MARK
: here
= &I_SYMBOL_BINDING (name
); break;
639 /* Locate the appropriate place in the chain of shadowed decls
640 to insert this binding. Normally, scope == current_scope and
641 this does nothing. */
642 while (*here
&& (*here
)->depth
> scope
->depth
)
643 here
= &(*here
)->shadowed
;
649 /* Clear the binding structure B, stick it on the binding_freelist,
650 and return the former value of b->prev. This is used by pop_scope
651 and get_parm_info to iterate destructively over all the bindings
652 from a given scope. */
653 static struct c_binding
*
654 free_binding_and_advance (struct c_binding
*b
)
656 struct c_binding
*prev
= b
->prev
;
658 memset (b
, 0, sizeof (struct c_binding
));
659 b
->prev
= binding_freelist
;
660 binding_freelist
= b
;
665 /* Bind a label. Like bind, but skip fields which aren't used for
666 labels, and add the LABEL_VARS value. */
668 bind_label (tree name
, tree label
, struct c_scope
*scope
,
669 struct c_label_vars
*label_vars
)
673 bind (name
, label
, scope
, /*invisible=*/false, /*nested=*/false,
676 scope
->has_label_bindings
= true;
679 gcc_assert (b
->decl
== label
);
680 label_vars
->shadowed
= b
->u
.label
;
681 b
->u
.label
= label_vars
;
684 /* Hook called at end of compilation to assume 1 elt
685 for a file-scope tentative array defn that wasn't complete before. */
688 c_finish_incomplete_decl (tree decl
)
690 if (TREE_CODE (decl
) == VAR_DECL
)
692 tree type
= TREE_TYPE (decl
);
693 if (type
!= error_mark_node
694 && TREE_CODE (type
) == ARRAY_TYPE
695 && !DECL_EXTERNAL (decl
)
696 && TYPE_DOMAIN (type
) == 0)
698 warning_at (DECL_SOURCE_LOCATION (decl
),
699 0, "array %q+D assumed to have one element", decl
);
701 complete_array_type (&TREE_TYPE (decl
), NULL_TREE
, true);
703 layout_decl (decl
, 0);
708 /* Record that inline function FUNC contains a reference (location
709 LOC) to static DECL (file-scope or function-local according to
713 record_inline_static (location_t loc
, tree func
, tree decl
,
714 enum c_inline_static_type type
)
716 struct c_inline_static
*csi
= GGC_NEW (struct c_inline_static
);
718 csi
->function
= func
;
719 csi
->static_decl
= decl
;
721 csi
->next
= c_inline_statics
;
722 c_inline_statics
= csi
;
725 /* Check for references to static declarations in inline functions at
726 the end of the translation unit and diagnose them if the functions
727 are still inline definitions. */
730 check_inline_statics (void)
732 struct c_inline_static
*csi
;
733 for (csi
= c_inline_statics
; csi
; csi
= csi
->next
)
735 if (DECL_EXTERNAL (csi
->function
))
739 pedwarn (csi
->location
, 0,
740 "%qD is static but used in inline function %qD "
741 "which is not static", csi
->static_decl
, csi
->function
);
744 pedwarn (csi
->location
, 0,
745 "%q+D is static but declared in inline function %qD "
746 "which is not static", csi
->static_decl
, csi
->function
);
752 c_inline_statics
= NULL
;
755 /* Fill in a c_spot_bindings structure. If DEFINING is true, set it
756 for the current state, otherwise set it to uninitialized. */
759 set_spot_bindings (struct c_spot_bindings
*p
, bool defining
)
763 p
->scope
= current_scope
;
764 p
->bindings_in_scope
= current_scope
->bindings
;
769 p
->bindings_in_scope
= NULL
;
772 p
->left_stmt_expr
= false;
775 /* Return true if we will want to say something if a goto statement
779 decl_jump_unsafe (tree decl
)
781 if (decl
== error_mark_node
|| TREE_TYPE (decl
) == error_mark_node
)
784 /* Always warn about crossing variably modified types. */
785 if ((TREE_CODE (decl
) == VAR_DECL
|| TREE_CODE (decl
) == TYPE_DECL
)
786 && variably_modified_type_p (TREE_TYPE (decl
), NULL_TREE
))
789 /* Otherwise, only warn if -Wgoto-misses-init and this is an
790 initialized automatic decl. */
791 if (warn_jump_misses_init
792 && TREE_CODE (decl
) == VAR_DECL
793 && !TREE_STATIC (decl
)
794 && DECL_INITIAL (decl
) != NULL_TREE
)
800 /* Update spot bindings P as we pop out of SCOPE. Return true if we
801 should push decls for a label. */
804 update_spot_bindings (struct c_scope
*scope
, struct c_spot_bindings
*p
)
806 if (p
->scope
!= scope
)
808 /* This label or goto is defined in some other scope, or it is a
809 label which is not yet defined. There is nothing to
814 /* Adjust the spot bindings to refer to the bindings already defined
815 in the enclosing scope. */
816 p
->scope
= scope
->outer
;
817 p
->bindings_in_scope
= p
->scope
->bindings
;
822 /* The Objective-C front-end often needs to determine the current scope. */
825 objc_get_current_scope (void)
827 return current_scope
;
830 /* The following function is used only by Objective-C. It needs to live here
831 because it accesses the innards of c_scope. */
834 objc_mark_locals_volatile (void *enclosing_blk
)
836 struct c_scope
*scope
;
839 for (scope
= current_scope
;
840 scope
&& scope
!= enclosing_blk
;
841 scope
= scope
->outer
)
843 for (b
= scope
->bindings
; b
; b
= b
->prev
)
844 objc_volatilize_decl (b
->decl
);
846 /* Do not climb up past the current function. */
847 if (scope
->function_body
)
852 /* Nonzero if we are currently in file scope. */
855 global_bindings_p (void)
857 return (current_scope
== file_scope
&& !c_override_global_bindings_to_false
863 keep_next_level (void)
865 keep_next_level_flag
= true;
868 /* Set the flag for the FLOAT_CONST_DECIMAL64 pragma being ON. */
871 set_float_const_decimal64 (void)
873 current_scope
->float_const_decimal64
= true;
876 /* Clear the flag for the FLOAT_CONST_DECIMAL64 pragma. */
879 clear_float_const_decimal64 (void)
881 current_scope
->float_const_decimal64
= false;
884 /* Return nonzero if an unsuffixed float constant is _Decimal64. */
887 float_const_decimal64_p (void)
889 return current_scope
->float_const_decimal64
;
892 /* Identify this scope as currently being filled with parameters. */
895 declare_parm_level (void)
897 current_scope
->parm_flag
= true;
903 if (next_is_function_body
)
905 /* This is the transition from the parameters to the top level
906 of the function body. These are the same scope
907 (C99 6.2.1p4,6) so we do not push another scope structure.
908 next_is_function_body is set only by store_parm_decls, which
909 in turn is called when and only when we are about to
910 encounter the opening curly brace for the function body.
912 The outermost block of a function always gets a BLOCK node,
913 because the debugging output routines expect that each
914 function has at least one BLOCK. */
915 current_scope
->parm_flag
= false;
916 current_scope
->function_body
= true;
917 current_scope
->keep
= true;
918 current_scope
->outer_function
= current_function_scope
;
919 current_function_scope
= current_scope
;
921 keep_next_level_flag
= false;
922 next_is_function_body
= false;
924 /* The FLOAT_CONST_DECIMAL64 pragma applies to nested scopes. */
925 if (current_scope
->outer
)
926 current_scope
->float_const_decimal64
927 = current_scope
->outer
->float_const_decimal64
;
929 current_scope
->float_const_decimal64
= false;
933 struct c_scope
*scope
;
936 scope
= scope_freelist
;
937 scope_freelist
= scope
->outer
;
940 scope
= GGC_CNEW (struct c_scope
);
942 /* The FLOAT_CONST_DECIMAL64 pragma applies to nested scopes. */
944 scope
->float_const_decimal64
= current_scope
->float_const_decimal64
;
946 scope
->float_const_decimal64
= false;
948 scope
->keep
= keep_next_level_flag
;
949 scope
->outer
= current_scope
;
950 scope
->depth
= current_scope
? (current_scope
->depth
+ 1) : 0;
952 /* Check for scope depth overflow. Unlikely (2^28 == 268,435,456) but
954 if (current_scope
&& scope
->depth
== 0)
957 sorry ("GCC supports only %u nested scopes", scope
->depth
);
960 current_scope
= scope
;
961 keep_next_level_flag
= false;
965 /* This is called when we are leaving SCOPE. For each label defined
966 in SCOPE, add any appropriate decls to its decls_in_scope fields.
967 These are the decls whose initialization will be skipped by a goto
968 later in the function. */
971 update_label_decls (struct c_scope
*scope
)
978 if (s
->has_label_bindings
)
982 for (b
= s
->bindings
; b
!= NULL
; b
= b
->prev
)
984 struct c_label_vars
*label_vars
;
985 struct c_binding
*b1
;
987 struct c_goto_bindings
*g
;
989 if (TREE_CODE (b
->decl
) != LABEL_DECL
)
991 label_vars
= b
->u
.label
;
993 b1
= label_vars
->label_bindings
.bindings_in_scope
;
994 if (update_spot_bindings (scope
, &label_vars
->label_bindings
))
996 /* This label is defined in this scope. */
997 for (; b1
!= NULL
; b1
= b1
->prev
)
999 /* A goto from later in the function to this
1000 label will never see the initialization of
1001 B1, if any. Save it to issue a warning if
1003 if (decl_jump_unsafe (b1
->decl
))
1004 VEC_safe_push (tree
, gc
, label_vars
->decls_in_scope
,
1009 /* Update the bindings of any goto statements associated
1012 VEC_iterate (c_goto_bindings_p
, label_vars
->gotos
, ix
, g
);
1014 update_spot_bindings (scope
, &g
->goto_bindings
);
1018 /* Don't search beyond the current function. */
1019 if (s
== current_function_scope
)
1026 /* Set the TYPE_CONTEXT of all of TYPE's variants to CONTEXT. */
1029 set_type_context (tree type
, tree context
)
1031 for (type
= TYPE_MAIN_VARIANT (type
); type
;
1032 type
= TYPE_NEXT_VARIANT (type
))
1033 TYPE_CONTEXT (type
) = context
;
1036 /* Exit a scope. Restore the state of the identifier-decl mappings
1037 that were in effect when this scope was entered. Return a BLOCK
1038 node containing all the DECLs in this scope that are of interest
1039 to debug info generation. */
1044 struct c_scope
*scope
= current_scope
;
1045 tree block
, context
, p
;
1046 struct c_binding
*b
;
1048 bool functionbody
= scope
->function_body
;
1049 bool keep
= functionbody
|| scope
->keep
|| scope
->bindings
;
1051 update_label_decls (scope
);
1053 /* If appropriate, create a BLOCK to record the decls for the life
1054 of this function. */
1058 block
= make_node (BLOCK
);
1059 BLOCK_SUBBLOCKS (block
) = scope
->blocks
;
1060 TREE_USED (block
) = 1;
1062 /* In each subblock, record that this is its superior. */
1063 for (p
= scope
->blocks
; p
; p
= BLOCK_CHAIN (p
))
1064 BLOCK_SUPERCONTEXT (p
) = block
;
1066 BLOCK_VARS (block
) = 0;
1069 /* The TYPE_CONTEXTs for all of the tagged types belonging to this
1070 scope must be set so that they point to the appropriate
1071 construct, i.e. either to the current FUNCTION_DECL node, or
1072 else to the BLOCK node we just constructed.
1074 Note that for tagged types whose scope is just the formal
1075 parameter list for some function type specification, we can't
1076 properly set their TYPE_CONTEXTs here, because we don't have a
1077 pointer to the appropriate FUNCTION_TYPE node readily available
1078 to us. For those cases, the TYPE_CONTEXTs of the relevant tagged
1079 type nodes get set in `grokdeclarator' as soon as we have created
1080 the FUNCTION_TYPE node which will represent the "scope" for these
1081 "parameter list local" tagged types. */
1082 if (scope
->function_body
)
1083 context
= current_function_decl
;
1084 else if (scope
== file_scope
)
1086 tree file_decl
= build_decl (UNKNOWN_LOCATION
,
1087 TRANSLATION_UNIT_DECL
, 0, 0);
1088 TREE_CHAIN (file_decl
) = all_translation_units
;
1089 all_translation_units
= file_decl
;
1090 context
= file_decl
;
1095 /* Clear all bindings in this scope. */
1096 for (b
= scope
->bindings
; b
; b
= free_binding_and_advance (b
))
1099 switch (TREE_CODE (p
))
1102 /* Warnings for unused labels, errors for undefined labels. */
1103 if (TREE_USED (p
) && !DECL_INITIAL (p
))
1105 error ("label %q+D used but not defined", p
);
1106 DECL_INITIAL (p
) = error_mark_node
;
1109 warn_for_unused_label (p
);
1111 /* Labels go in BLOCK_VARS. */
1112 TREE_CHAIN (p
) = BLOCK_VARS (block
);
1113 BLOCK_VARS (block
) = p
;
1114 gcc_assert (I_LABEL_BINDING (b
->id
) == b
);
1115 I_LABEL_BINDING (b
->id
) = b
->shadowed
;
1117 /* Also pop back to the shadowed label_vars. */
1118 release_tree_vector (b
->u
.label
->decls_in_scope
);
1119 b
->u
.label
= b
->u
.label
->shadowed
;
1125 set_type_context (p
, context
);
1127 /* Types may not have tag-names, in which case the type
1128 appears in the bindings list with b->id NULL. */
1131 gcc_assert (I_TAG_BINDING (b
->id
) == b
);
1132 I_TAG_BINDING (b
->id
) = b
->shadowed
;
1137 /* Propagate TREE_ADDRESSABLE from nested functions to their
1138 containing functions. */
1139 if (!TREE_ASM_WRITTEN (p
)
1140 && DECL_INITIAL (p
) != 0
1141 && TREE_ADDRESSABLE (p
)
1142 && DECL_ABSTRACT_ORIGIN (p
) != 0
1143 && DECL_ABSTRACT_ORIGIN (p
) != p
)
1144 TREE_ADDRESSABLE (DECL_ABSTRACT_ORIGIN (p
)) = 1;
1145 if (!DECL_EXTERNAL (p
)
1146 && !DECL_INITIAL (p
)
1147 && scope
!= file_scope
1148 && scope
!= external_scope
)
1150 error ("nested function %q+D declared but never defined", p
);
1151 undef_nested_function
= true;
1153 else if (DECL_DECLARED_INLINE_P (p
)
1155 && !DECL_INITIAL (p
))
1157 /* C99 6.7.4p6: "a function with external linkage... declared
1158 with an inline function specifier ... shall also be defined
1159 in the same translation unit." */
1160 if (!flag_gnu89_inline
)
1161 pedwarn (input_location
, 0,
1162 "inline function %q+D declared but never defined", p
);
1163 DECL_EXTERNAL (p
) = 1;
1169 /* Warnings for unused variables. */
1171 && !TREE_NO_WARNING (p
)
1172 && !DECL_IN_SYSTEM_HEADER (p
)
1174 && !DECL_ARTIFICIAL (p
)
1175 && scope
!= file_scope
1176 && scope
!= external_scope
)
1177 warning (OPT_Wunused_variable
, "unused variable %q+D", p
);
1181 error ("type of array %q+D completed incompatibly with"
1182 " implicit initialization", p
);
1189 /* All of these go in BLOCK_VARS, but only if this is the
1190 binding in the home scope. */
1193 TREE_CHAIN (p
) = BLOCK_VARS (block
);
1194 BLOCK_VARS (block
) = p
;
1196 else if (VAR_OR_FUNCTION_DECL_P (p
))
1198 /* For block local externs add a special
1199 DECL_EXTERNAL decl for debug info generation. */
1200 tree extp
= copy_node (p
);
1202 DECL_EXTERNAL (extp
) = 1;
1203 TREE_STATIC (extp
) = 0;
1204 TREE_PUBLIC (extp
) = 1;
1205 DECL_INITIAL (extp
) = NULL_TREE
;
1206 DECL_LANG_SPECIFIC (extp
) = NULL
;
1207 DECL_CONTEXT (extp
) = current_function_decl
;
1208 if (TREE_CODE (p
) == FUNCTION_DECL
)
1210 DECL_RESULT (extp
) = NULL_TREE
;
1211 DECL_SAVED_TREE (extp
) = NULL_TREE
;
1212 DECL_STRUCT_FUNCTION (extp
) = NULL
;
1214 if (b
->locus
!= UNKNOWN_LOCATION
)
1215 DECL_SOURCE_LOCATION (extp
) = b
->locus
;
1216 TREE_CHAIN (extp
) = BLOCK_VARS (block
);
1217 BLOCK_VARS (block
) = extp
;
1219 /* If this is the file scope, and we are processing more
1220 than one translation unit in this compilation, set
1221 DECL_CONTEXT of each decl to the TRANSLATION_UNIT_DECL.
1222 This makes same_translation_unit_p work, and causes
1223 static declarations to be given disambiguating suffixes. */
1224 if (scope
== file_scope
&& num_in_fnames
> 1)
1226 DECL_CONTEXT (p
) = context
;
1227 if (TREE_CODE (p
) == TYPE_DECL
)
1228 set_type_context (TREE_TYPE (p
), context
);
1232 /* Parameters go in DECL_ARGUMENTS, not BLOCK_VARS, and have
1233 already been put there by store_parm_decls. Unused-
1234 parameter warnings are handled by function.c.
1235 error_mark_node obviously does not go in BLOCK_VARS and
1236 does not get unused-variable warnings. */
1239 /* It is possible for a decl not to have a name. We get
1240 here with b->id NULL in this case. */
1243 gcc_assert (I_SYMBOL_BINDING (b
->id
) == b
);
1244 I_SYMBOL_BINDING (b
->id
) = b
->shadowed
;
1245 if (b
->shadowed
&& b
->shadowed
->u
.type
)
1246 TREE_TYPE (b
->shadowed
->decl
) = b
->shadowed
->u
.type
;
1256 /* Dispose of the block that we just made inside some higher level. */
1257 if ((scope
->function_body
|| scope
== file_scope
) && context
)
1259 DECL_INITIAL (context
) = block
;
1260 BLOCK_SUPERCONTEXT (block
) = context
;
1262 else if (scope
->outer
)
1265 SCOPE_LIST_APPEND (scope
->outer
, blocks
, block
);
1266 /* If we did not make a block for the scope just exited, any
1267 blocks made for inner scopes must be carried forward so they
1268 will later become subblocks of something else. */
1269 else if (scope
->blocks
)
1270 SCOPE_LIST_CONCAT (scope
->outer
, blocks
, scope
, blocks
);
1273 /* Pop the current scope, and free the structure for reuse. */
1274 current_scope
= scope
->outer
;
1275 if (scope
->function_body
)
1276 current_function_scope
= scope
->outer_function
;
1278 memset (scope
, 0, sizeof (struct c_scope
));
1279 scope
->outer
= scope_freelist
;
1280 scope_freelist
= scope
;
1286 push_file_scope (void)
1294 file_scope
= current_scope
;
1296 start_fname_decls ();
1298 for (decl
= visible_builtins
; decl
; decl
= TREE_CHAIN (decl
))
1299 bind (DECL_NAME (decl
), decl
, file_scope
,
1300 /*invisible=*/false, /*nested=*/true, DECL_SOURCE_LOCATION (decl
));
1304 pop_file_scope (void)
1306 /* In case there were missing closebraces, get us back to the global
1308 while (current_scope
!= file_scope
)
1311 /* __FUNCTION__ is defined at file scope (""). This
1312 call may not be necessary as my tests indicate it
1313 still works without it. */
1314 finish_fname_decls ();
1316 check_inline_statics ();
1318 /* This is the point to write out a PCH if we're doing that.
1319 In that case we do not want to do anything else. */
1322 c_common_write_pch ();
1326 /* Pop off the file scope and close this translation unit. */
1330 maybe_apply_pending_pragma_weaks ();
1333 /* Adjust the bindings for the start of a statement expression. */
1336 c_bindings_start_stmt_expr (struct c_spot_bindings
* switch_bindings
)
1338 struct c_scope
*scope
;
1340 for (scope
= current_scope
; scope
!= NULL
; scope
= scope
->outer
)
1342 struct c_binding
*b
;
1344 if (!scope
->has_label_bindings
)
1347 for (b
= scope
->bindings
; b
!= NULL
; b
= b
->prev
)
1349 struct c_label_vars
*label_vars
;
1351 struct c_goto_bindings
*g
;
1353 if (TREE_CODE (b
->decl
) != LABEL_DECL
)
1355 label_vars
= b
->u
.label
;
1356 ++label_vars
->label_bindings
.stmt_exprs
;
1358 VEC_iterate (c_goto_bindings_p
, label_vars
->gotos
, ix
, g
);
1360 ++g
->goto_bindings
.stmt_exprs
;
1364 if (switch_bindings
!= NULL
)
1365 ++switch_bindings
->stmt_exprs
;
1368 /* Adjust the bindings for the end of a statement expression. */
1371 c_bindings_end_stmt_expr (struct c_spot_bindings
*switch_bindings
)
1373 struct c_scope
*scope
;
1375 for (scope
= current_scope
; scope
!= NULL
; scope
= scope
->outer
)
1377 struct c_binding
*b
;
1379 if (!scope
->has_label_bindings
)
1382 for (b
= scope
->bindings
; b
!= NULL
; b
= b
->prev
)
1384 struct c_label_vars
*label_vars
;
1386 struct c_goto_bindings
*g
;
1388 if (TREE_CODE (b
->decl
) != LABEL_DECL
)
1390 label_vars
= b
->u
.label
;
1391 --label_vars
->label_bindings
.stmt_exprs
;
1392 if (label_vars
->label_bindings
.stmt_exprs
< 0)
1394 label_vars
->label_bindings
.left_stmt_expr
= true;
1395 label_vars
->label_bindings
.stmt_exprs
= 0;
1398 VEC_iterate (c_goto_bindings_p
, label_vars
->gotos
, ix
, g
);
1401 --g
->goto_bindings
.stmt_exprs
;
1402 if (g
->goto_bindings
.stmt_exprs
< 0)
1404 g
->goto_bindings
.left_stmt_expr
= true;
1405 g
->goto_bindings
.stmt_exprs
= 0;
1411 if (switch_bindings
!= NULL
)
1413 --switch_bindings
->stmt_exprs
;
1414 gcc_assert (switch_bindings
->stmt_exprs
>= 0);
1418 /* Push a definition or a declaration of struct, union or enum tag "name".
1419 "type" should be the type node.
1420 We assume that the tag "name" is not already defined, and has a location
1423 Note that the definition may really be just a forward reference.
1424 In that case, the TYPE_SIZE will be zero. */
1427 pushtag (location_t loc
, tree name
, tree type
)
1429 /* Record the identifier as the type's name if it has none. */
1430 if (name
&& !TYPE_NAME (type
))
1431 TYPE_NAME (type
) = name
;
1432 bind (name
, type
, current_scope
, /*invisible=*/false, /*nested=*/false, loc
);
1434 /* Create a fake NULL-named TYPE_DECL node whose TREE_TYPE will be the
1435 tagged type we just added to the current scope. This fake
1436 NULL-named TYPE_DECL node helps dwarfout.c to know when it needs
1437 to output a representation of a tagged type, and it also gives
1438 us a convenient place to record the "scope start" address for the
1441 TYPE_STUB_DECL (type
) = pushdecl (build_decl (loc
,
1442 TYPE_DECL
, NULL_TREE
, type
));
1444 /* An approximation for now, so we can tell this is a function-scope tag.
1445 This will be updated in pop_scope. */
1446 TYPE_CONTEXT (type
) = DECL_CONTEXT (TYPE_STUB_DECL (type
));
1448 if (warn_cxx_compat
&& name
!= NULL_TREE
)
1450 struct c_binding
*b
= I_SYMBOL_BINDING (name
);
1453 && b
->decl
!= NULL_TREE
1454 && TREE_CODE (b
->decl
) == TYPE_DECL
1455 && (B_IN_CURRENT_SCOPE (b
)
1456 || (current_scope
== file_scope
&& B_IN_EXTERNAL_SCOPE (b
)))
1457 && (TYPE_MAIN_VARIANT (TREE_TYPE (b
->decl
))
1458 != TYPE_MAIN_VARIANT (type
)))
1460 warning_at (loc
, OPT_Wc___compat
,
1461 ("using %qD as both a typedef and a tag is "
1464 if (b
->locus
!= UNKNOWN_LOCATION
)
1465 inform (b
->locus
, "originally defined here");
1470 /* Subroutine of compare_decls. Allow harmless mismatches in return
1471 and argument types provided that the type modes match. This function
1472 return a unified type given a suitable match, and 0 otherwise. */
1475 match_builtin_function_types (tree newtype
, tree oldtype
)
1477 tree newrettype
, oldrettype
;
1478 tree newargs
, oldargs
;
1479 tree trytype
, tryargs
;
1481 /* Accept the return type of the new declaration if same modes. */
1482 oldrettype
= TREE_TYPE (oldtype
);
1483 newrettype
= TREE_TYPE (newtype
);
1485 if (TYPE_MODE (oldrettype
) != TYPE_MODE (newrettype
))
1488 oldargs
= TYPE_ARG_TYPES (oldtype
);
1489 newargs
= TYPE_ARG_TYPES (newtype
);
1492 while (oldargs
|| newargs
)
1496 || !TREE_VALUE (oldargs
)
1497 || !TREE_VALUE (newargs
)
1498 || TYPE_MODE (TREE_VALUE (oldargs
))
1499 != TYPE_MODE (TREE_VALUE (newargs
)))
1502 oldargs
= TREE_CHAIN (oldargs
);
1503 newargs
= TREE_CHAIN (newargs
);
1506 trytype
= build_function_type (newrettype
, tryargs
);
1507 return build_type_attribute_variant (trytype
, TYPE_ATTRIBUTES (oldtype
));
1510 /* Subroutine of diagnose_mismatched_decls. Check for function type
1511 mismatch involving an empty arglist vs a nonempty one and give clearer
1514 diagnose_arglist_conflict (tree newdecl
, tree olddecl
,
1515 tree newtype
, tree oldtype
)
1519 if (TREE_CODE (olddecl
) != FUNCTION_DECL
1520 || !comptypes (TREE_TYPE (oldtype
), TREE_TYPE (newtype
))
1521 || !((TYPE_ARG_TYPES (oldtype
) == 0 && DECL_INITIAL (olddecl
) == 0)
1523 (TYPE_ARG_TYPES (newtype
) == 0 && DECL_INITIAL (newdecl
) == 0)))
1526 t
= TYPE_ARG_TYPES (oldtype
);
1528 t
= TYPE_ARG_TYPES (newtype
);
1529 for (; t
; t
= TREE_CHAIN (t
))
1531 tree type
= TREE_VALUE (t
);
1533 if (TREE_CHAIN (t
) == 0
1534 && TYPE_MAIN_VARIANT (type
) != void_type_node
)
1536 inform (input_location
, "a parameter list with an ellipsis can%'t match "
1537 "an empty parameter name list declaration");
1541 if (c_type_promotes_to (type
) != type
)
1543 inform (input_location
, "an argument type that has a default promotion can%'t match "
1544 "an empty parameter name list declaration");
1550 /* Another subroutine of diagnose_mismatched_decls. OLDDECL is an
1551 old-style function definition, NEWDECL is a prototype declaration.
1552 Diagnose inconsistencies in the argument list. Returns TRUE if
1553 the prototype is compatible, FALSE if not. */
1555 validate_proto_after_old_defn (tree newdecl
, tree newtype
, tree oldtype
)
1557 tree newargs
, oldargs
;
1560 #define END_OF_ARGLIST(t) ((t) == void_type_node)
1562 oldargs
= TYPE_ACTUAL_ARG_TYPES (oldtype
);
1563 newargs
= TYPE_ARG_TYPES (newtype
);
1568 tree oldargtype
= TREE_VALUE (oldargs
);
1569 tree newargtype
= TREE_VALUE (newargs
);
1571 if (oldargtype
== error_mark_node
|| newargtype
== error_mark_node
)
1574 oldargtype
= TYPE_MAIN_VARIANT (oldargtype
);
1575 newargtype
= TYPE_MAIN_VARIANT (newargtype
);
1577 if (END_OF_ARGLIST (oldargtype
) && END_OF_ARGLIST (newargtype
))
1580 /* Reaching the end of just one list means the two decls don't
1581 agree on the number of arguments. */
1582 if (END_OF_ARGLIST (oldargtype
))
1584 error ("prototype for %q+D declares more arguments "
1585 "than previous old-style definition", newdecl
);
1588 else if (END_OF_ARGLIST (newargtype
))
1590 error ("prototype for %q+D declares fewer arguments "
1591 "than previous old-style definition", newdecl
);
1595 /* Type for passing arg must be consistent with that declared
1597 else if (!comptypes (oldargtype
, newargtype
))
1599 error ("prototype for %q+D declares argument %d"
1600 " with incompatible type",
1605 oldargs
= TREE_CHAIN (oldargs
);
1606 newargs
= TREE_CHAIN (newargs
);
1610 /* If we get here, no errors were found, but do issue a warning
1611 for this poor-style construct. */
1612 warning (0, "prototype for %q+D follows non-prototype definition",
1615 #undef END_OF_ARGLIST
1618 /* Subroutine of diagnose_mismatched_decls. Report the location of DECL,
1619 first in a pair of mismatched declarations, using the diagnostic
1622 locate_old_decl (tree decl
)
1624 if (TREE_CODE (decl
) == FUNCTION_DECL
&& DECL_BUILT_IN (decl
))
1626 else if (DECL_INITIAL (decl
))
1627 inform (input_location
, "previous definition of %q+D was here", decl
);
1628 else if (C_DECL_IMPLICIT (decl
))
1629 inform (input_location
, "previous implicit declaration of %q+D was here", decl
);
1631 inform (input_location
, "previous declaration of %q+D was here", decl
);
1634 /* Subroutine of duplicate_decls. Compare NEWDECL to OLDDECL.
1635 Returns true if the caller should proceed to merge the two, false
1636 if OLDDECL should simply be discarded. As a side effect, issues
1637 all necessary diagnostics for invalid or poor-style combinations.
1638 If it returns true, writes the types of NEWDECL and OLDDECL to
1639 *NEWTYPEP and *OLDTYPEP - these may have been adjusted from
1640 TREE_TYPE (NEWDECL, OLDDECL) respectively. */
1643 diagnose_mismatched_decls (tree newdecl
, tree olddecl
,
1644 tree
*newtypep
, tree
*oldtypep
)
1646 tree newtype
, oldtype
;
1647 bool pedwarned
= false;
1648 bool warned
= false;
1651 #define DECL_EXTERN_INLINE(DECL) (DECL_DECLARED_INLINE_P (DECL) \
1652 && DECL_EXTERNAL (DECL))
1654 /* If we have error_mark_node for either decl or type, just discard
1655 the previous decl - we're in an error cascade already. */
1656 if (olddecl
== error_mark_node
|| newdecl
== error_mark_node
)
1658 *oldtypep
= oldtype
= TREE_TYPE (olddecl
);
1659 *newtypep
= newtype
= TREE_TYPE (newdecl
);
1660 if (oldtype
== error_mark_node
|| newtype
== error_mark_node
)
1663 /* Two different categories of symbol altogether. This is an error
1664 unless OLDDECL is a builtin. OLDDECL will be discarded in any case. */
1665 if (TREE_CODE (olddecl
) != TREE_CODE (newdecl
))
1667 if (!(TREE_CODE (olddecl
) == FUNCTION_DECL
1668 && DECL_BUILT_IN (olddecl
)
1669 && !C_DECL_DECLARED_BUILTIN (olddecl
)))
1671 error ("%q+D redeclared as different kind of symbol", newdecl
);
1672 locate_old_decl (olddecl
);
1674 else if (TREE_PUBLIC (newdecl
))
1675 warning (0, "built-in function %q+D declared as non-function",
1678 warning (OPT_Wshadow
, "declaration of %q+D shadows "
1679 "a built-in function", newdecl
);
1683 /* Enumerators have no linkage, so may only be declared once in a
1685 if (TREE_CODE (olddecl
) == CONST_DECL
)
1687 error ("redeclaration of enumerator %q+D", newdecl
);
1688 locate_old_decl (olddecl
);
1692 if (!comptypes (oldtype
, newtype
))
1694 if (TREE_CODE (olddecl
) == FUNCTION_DECL
1695 && DECL_BUILT_IN (olddecl
) && !C_DECL_DECLARED_BUILTIN (olddecl
))
1697 /* Accept harmless mismatch in function types.
1698 This is for the ffs and fprintf builtins. */
1699 tree trytype
= match_builtin_function_types (newtype
, oldtype
);
1701 if (trytype
&& comptypes (newtype
, trytype
))
1702 *oldtypep
= oldtype
= trytype
;
1705 /* If types don't match for a built-in, throw away the
1706 built-in. No point in calling locate_old_decl here, it
1707 won't print anything. */
1708 warning (0, "conflicting types for built-in function %q+D",
1713 else if (TREE_CODE (olddecl
) == FUNCTION_DECL
1714 && DECL_IS_BUILTIN (olddecl
))
1716 /* A conflicting function declaration for a predeclared
1717 function that isn't actually built in. Objective C uses
1718 these. The new declaration silently overrides everything
1719 but the volatility (i.e. noreturn) indication. See also
1720 below. FIXME: Make Objective C use normal builtins. */
1721 TREE_THIS_VOLATILE (newdecl
) |= TREE_THIS_VOLATILE (olddecl
);
1724 /* Permit void foo (...) to match int foo (...) if the latter is
1725 the definition and implicit int was used. See
1726 c-torture/compile/920625-2.c. */
1727 else if (TREE_CODE (newdecl
) == FUNCTION_DECL
&& DECL_INITIAL (newdecl
)
1728 && TYPE_MAIN_VARIANT (TREE_TYPE (oldtype
)) == void_type_node
1729 && TYPE_MAIN_VARIANT (TREE_TYPE (newtype
)) == integer_type_node
1730 && C_FUNCTION_IMPLICIT_INT (newdecl
) && !DECL_INITIAL (olddecl
))
1732 pedwarned
= pedwarn (input_location
, 0,
1733 "conflicting types for %q+D", newdecl
);
1734 /* Make sure we keep void as the return type. */
1735 TREE_TYPE (newdecl
) = *newtypep
= newtype
= oldtype
;
1736 C_FUNCTION_IMPLICIT_INT (newdecl
) = 0;
1738 /* Permit void foo (...) to match an earlier call to foo (...) with
1739 no declared type (thus, implicitly int). */
1740 else if (TREE_CODE (newdecl
) == FUNCTION_DECL
1741 && TYPE_MAIN_VARIANT (TREE_TYPE (newtype
)) == void_type_node
1742 && TYPE_MAIN_VARIANT (TREE_TYPE (oldtype
)) == integer_type_node
1743 && C_DECL_IMPLICIT (olddecl
) && !DECL_INITIAL (olddecl
))
1745 pedwarned
= pedwarn (input_location
, 0,
1746 "conflicting types for %q+D", newdecl
);
1747 /* Make sure we keep void as the return type. */
1748 TREE_TYPE (olddecl
) = *oldtypep
= oldtype
= newtype
;
1752 if (TYPE_QUALS (newtype
) != TYPE_QUALS (oldtype
))
1753 error ("conflicting type qualifiers for %q+D", newdecl
);
1755 error ("conflicting types for %q+D", newdecl
);
1756 diagnose_arglist_conflict (newdecl
, olddecl
, newtype
, oldtype
);
1757 locate_old_decl (olddecl
);
1762 /* Redeclaration of a type is a constraint violation (6.7.2.3p1),
1763 but silently ignore the redeclaration if either is in a system
1764 header. (Conflicting redeclarations were handled above.) */
1765 if (TREE_CODE (newdecl
) == TYPE_DECL
)
1767 if (DECL_IN_SYSTEM_HEADER (newdecl
)
1768 || DECL_IN_SYSTEM_HEADER (olddecl
)
1769 || TREE_NO_WARNING (newdecl
)
1770 || TREE_NO_WARNING (olddecl
))
1771 return true; /* Allow OLDDECL to continue in use. */
1773 error ("redefinition of typedef %q+D", newdecl
);
1774 locate_old_decl (olddecl
);
1778 /* Function declarations can either be 'static' or 'extern' (no
1779 qualifier is equivalent to 'extern' - C99 6.2.2p5) and therefore
1780 can never conflict with each other on account of linkage
1781 (6.2.2p4). Multiple definitions are not allowed (6.9p3,5) but
1782 gnu89 mode permits two definitions if one is 'extern inline' and
1783 one is not. The non- extern-inline definition supersedes the
1784 extern-inline definition. */
1786 else if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
1788 /* If you declare a built-in function name as static, or
1789 define the built-in with an old-style definition (so we
1790 can't validate the argument list) the built-in definition is
1791 overridden, but optionally warn this was a bad choice of name. */
1792 if (DECL_BUILT_IN (olddecl
)
1793 && !C_DECL_DECLARED_BUILTIN (olddecl
)
1794 && (!TREE_PUBLIC (newdecl
)
1795 || (DECL_INITIAL (newdecl
)
1796 && !TYPE_ARG_TYPES (TREE_TYPE (newdecl
)))))
1798 warning (OPT_Wshadow
, "declaration of %q+D shadows "
1799 "a built-in function", newdecl
);
1800 /* Discard the old built-in function. */
1804 if (DECL_INITIAL (newdecl
))
1806 if (DECL_INITIAL (olddecl
))
1808 /* If both decls are in the same TU and the new declaration
1809 isn't overriding an extern inline reject the new decl.
1810 In c99, no overriding is allowed in the same translation
1812 if ((!DECL_EXTERN_INLINE (olddecl
)
1813 || DECL_EXTERN_INLINE (newdecl
)
1814 || (!flag_gnu89_inline
1815 && (!DECL_DECLARED_INLINE_P (olddecl
)
1816 || !lookup_attribute ("gnu_inline",
1817 DECL_ATTRIBUTES (olddecl
)))
1818 && (!DECL_DECLARED_INLINE_P (newdecl
)
1819 || !lookup_attribute ("gnu_inline",
1820 DECL_ATTRIBUTES (newdecl
))))
1822 && same_translation_unit_p (newdecl
, olddecl
))
1824 error ("redefinition of %q+D", newdecl
);
1825 locate_old_decl (olddecl
);
1830 /* If we have a prototype after an old-style function definition,
1831 the argument types must be checked specially. */
1832 else if (DECL_INITIAL (olddecl
)
1833 && !TYPE_ARG_TYPES (oldtype
) && TYPE_ARG_TYPES (newtype
)
1834 && TYPE_ACTUAL_ARG_TYPES (oldtype
)
1835 && !validate_proto_after_old_defn (newdecl
, newtype
, oldtype
))
1837 locate_old_decl (olddecl
);
1840 /* A non-static declaration (even an "extern") followed by a
1841 static declaration is undefined behavior per C99 6.2.2p3-5,7.
1842 The same is true for a static forward declaration at block
1843 scope followed by a non-static declaration/definition at file
1844 scope. Static followed by non-static at the same scope is
1845 not undefined behavior, and is the most convenient way to get
1846 some effects (see e.g. what unwind-dw2-fde-glibc.c does to
1847 the definition of _Unwind_Find_FDE in unwind-dw2-fde.c), but
1848 we do diagnose it if -Wtraditional. */
1849 if (TREE_PUBLIC (olddecl
) && !TREE_PUBLIC (newdecl
))
1851 /* Two exceptions to the rule. If olddecl is an extern
1852 inline, or a predeclared function that isn't actually
1853 built in, newdecl silently overrides olddecl. The latter
1854 occur only in Objective C; see also above. (FIXME: Make
1855 Objective C use normal builtins.) */
1856 if (!DECL_IS_BUILTIN (olddecl
)
1857 && !DECL_EXTERN_INLINE (olddecl
))
1859 error ("static declaration of %q+D follows "
1860 "non-static declaration", newdecl
);
1861 locate_old_decl (olddecl
);
1865 else if (TREE_PUBLIC (newdecl
) && !TREE_PUBLIC (olddecl
))
1867 if (DECL_CONTEXT (olddecl
))
1869 error ("non-static declaration of %q+D follows "
1870 "static declaration", newdecl
);
1871 locate_old_decl (olddecl
);
1874 else if (warn_traditional
)
1876 warned
|= warning (OPT_Wtraditional
,
1877 "non-static declaration of %q+D "
1878 "follows static declaration", newdecl
);
1882 /* Make sure gnu_inline attribute is either not present, or
1883 present on all inline decls. */
1884 if (DECL_DECLARED_INLINE_P (olddecl
)
1885 && DECL_DECLARED_INLINE_P (newdecl
))
1887 bool newa
= lookup_attribute ("gnu_inline",
1888 DECL_ATTRIBUTES (newdecl
)) != NULL
;
1889 bool olda
= lookup_attribute ("gnu_inline",
1890 DECL_ATTRIBUTES (olddecl
)) != NULL
;
1893 error_at (input_location
, "%<gnu_inline%> attribute present on %q+D",
1894 newa
? newdecl
: olddecl
);
1895 error_at (DECL_SOURCE_LOCATION (newa
? olddecl
: newdecl
),
1900 else if (TREE_CODE (newdecl
) == VAR_DECL
)
1902 /* Only variables can be thread-local, and all declarations must
1903 agree on this property. */
1904 if (C_DECL_THREADPRIVATE_P (olddecl
) && !DECL_THREAD_LOCAL_P (newdecl
))
1906 /* Nothing to check. Since OLDDECL is marked threadprivate
1907 and NEWDECL does not have a thread-local attribute, we
1908 will merge the threadprivate attribute into NEWDECL. */
1911 else if (DECL_THREAD_LOCAL_P (newdecl
) != DECL_THREAD_LOCAL_P (olddecl
))
1913 if (DECL_THREAD_LOCAL_P (newdecl
))
1914 error ("thread-local declaration of %q+D follows "
1915 "non-thread-local declaration", newdecl
);
1917 error ("non-thread-local declaration of %q+D follows "
1918 "thread-local declaration", newdecl
);
1920 locate_old_decl (olddecl
);
1924 /* Multiple initialized definitions are not allowed (6.9p3,5). */
1925 if (DECL_INITIAL (newdecl
) && DECL_INITIAL (olddecl
))
1927 error ("redefinition of %q+D", newdecl
);
1928 locate_old_decl (olddecl
);
1932 /* Objects declared at file scope: if the first declaration had
1933 external linkage (even if it was an external reference) the
1934 second must have external linkage as well, or the behavior is
1935 undefined. If the first declaration had internal linkage, then
1936 the second must too, or else be an external reference (in which
1937 case the composite declaration still has internal linkage).
1938 As for function declarations, we warn about the static-then-
1939 extern case only for -Wtraditional. See generally 6.2.2p3-5,7. */
1940 if (DECL_FILE_SCOPE_P (newdecl
)
1941 && TREE_PUBLIC (newdecl
) != TREE_PUBLIC (olddecl
))
1943 if (DECL_EXTERNAL (newdecl
))
1945 if (!DECL_FILE_SCOPE_P (olddecl
))
1947 error ("extern declaration of %q+D follows "
1948 "declaration with no linkage", newdecl
);
1949 locate_old_decl (olddecl
);
1952 else if (warn_traditional
)
1954 warned
|= warning (OPT_Wtraditional
,
1955 "non-static declaration of %q+D "
1956 "follows static declaration", newdecl
);
1961 if (TREE_PUBLIC (newdecl
))
1962 error ("non-static declaration of %q+D follows "
1963 "static declaration", newdecl
);
1965 error ("static declaration of %q+D follows "
1966 "non-static declaration", newdecl
);
1968 locate_old_decl (olddecl
);
1972 /* Two objects with the same name declared at the same block
1973 scope must both be external references (6.7p3). */
1974 else if (!DECL_FILE_SCOPE_P (newdecl
))
1976 if (DECL_EXTERNAL (newdecl
))
1978 /* Extern with initializer at block scope, which will
1979 already have received an error. */
1981 else if (DECL_EXTERNAL (olddecl
))
1983 error ("declaration of %q+D with no linkage follows "
1984 "extern declaration", newdecl
);
1985 locate_old_decl (olddecl
);
1989 error ("redeclaration of %q+D with no linkage", newdecl
);
1990 locate_old_decl (olddecl
);
1996 /* C++ does not permit a decl to appear multiple times at file
1999 && DECL_FILE_SCOPE_P (newdecl
)
2000 && !DECL_EXTERNAL (newdecl
)
2001 && !DECL_EXTERNAL (olddecl
))
2002 warned
|= warning_at (DECL_SOURCE_LOCATION (newdecl
),
2004 ("duplicate declaration of %qD is "
2010 /* All decls must agree on a visibility. */
2011 if (CODE_CONTAINS_STRUCT (TREE_CODE (newdecl
), TS_DECL_WITH_VIS
)
2012 && DECL_VISIBILITY_SPECIFIED (newdecl
) && DECL_VISIBILITY_SPECIFIED (olddecl
)
2013 && DECL_VISIBILITY (newdecl
) != DECL_VISIBILITY (olddecl
))
2015 warned
|= warning (0, "redeclaration of %q+D with different visibility "
2016 "(old visibility preserved)", newdecl
);
2019 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
2021 /* Diagnose inline __attribute__ ((noinline)) which is silly. */
2022 if (DECL_DECLARED_INLINE_P (newdecl
)
2023 && lookup_attribute ("noinline", DECL_ATTRIBUTES (olddecl
)))
2025 warned
|= warning (OPT_Wattributes
,
2026 "inline declaration of %qD follows "
2027 "declaration with attribute noinline", newdecl
);
2029 else if (DECL_DECLARED_INLINE_P (olddecl
)
2030 && lookup_attribute ("noinline", DECL_ATTRIBUTES (newdecl
)))
2032 warned
|= warning (OPT_Wattributes
,
2033 "declaration of %q+D with attribute "
2034 "noinline follows inline declaration ", newdecl
);
2037 else /* PARM_DECL, VAR_DECL */
2039 /* Redeclaration of a parameter is a constraint violation (this is
2040 not explicitly stated, but follows from C99 6.7p3 [no more than
2041 one declaration of the same identifier with no linkage in the
2042 same scope, except type tags] and 6.2.2p6 [parameters have no
2043 linkage]). We must check for a forward parameter declaration,
2044 indicated by TREE_ASM_WRITTEN on the old declaration - this is
2045 an extension, the mandatory diagnostic for which is handled by
2046 mark_forward_parm_decls. */
2048 if (TREE_CODE (newdecl
) == PARM_DECL
2049 && (!TREE_ASM_WRITTEN (olddecl
) || TREE_ASM_WRITTEN (newdecl
)))
2051 error ("redefinition of parameter %q+D", newdecl
);
2052 locate_old_decl (olddecl
);
2057 /* Optional warning for completely redundant decls. */
2058 if (!warned
&& !pedwarned
2059 && warn_redundant_decls
2060 /* Don't warn about a function declaration followed by a
2062 && !(TREE_CODE (newdecl
) == FUNCTION_DECL
2063 && DECL_INITIAL (newdecl
) && !DECL_INITIAL (olddecl
))
2064 /* Don't warn about redundant redeclarations of builtins. */
2065 && !(TREE_CODE (newdecl
) == FUNCTION_DECL
2066 && !DECL_BUILT_IN (newdecl
)
2067 && DECL_BUILT_IN (olddecl
)
2068 && !C_DECL_DECLARED_BUILTIN (olddecl
))
2069 /* Don't warn about an extern followed by a definition. */
2070 && !(DECL_EXTERNAL (olddecl
) && !DECL_EXTERNAL (newdecl
))
2071 /* Don't warn about forward parameter decls. */
2072 && !(TREE_CODE (newdecl
) == PARM_DECL
2073 && TREE_ASM_WRITTEN (olddecl
) && !TREE_ASM_WRITTEN (newdecl
))
2074 /* Don't warn about a variable definition following a declaration. */
2075 && !(TREE_CODE (newdecl
) == VAR_DECL
2076 && DECL_INITIAL (newdecl
) && !DECL_INITIAL (olddecl
)))
2078 warned
= warning (OPT_Wredundant_decls
, "redundant redeclaration of %q+D",
2082 /* Report location of previous decl/defn. */
2083 if (warned
|| pedwarned
)
2084 locate_old_decl (olddecl
);
2086 #undef DECL_EXTERN_INLINE
2091 /* Subroutine of duplicate_decls. NEWDECL has been found to be
2092 consistent with OLDDECL, but carries new information. Merge the
2093 new information into OLDDECL. This function issues no
2097 merge_decls (tree newdecl
, tree olddecl
, tree newtype
, tree oldtype
)
2099 bool new_is_definition
= (TREE_CODE (newdecl
) == FUNCTION_DECL
2100 && DECL_INITIAL (newdecl
) != 0);
2101 bool new_is_prototype
= (TREE_CODE (newdecl
) == FUNCTION_DECL
2102 && TYPE_ARG_TYPES (TREE_TYPE (newdecl
)) != 0);
2103 bool old_is_prototype
= (TREE_CODE (olddecl
) == FUNCTION_DECL
2104 && TYPE_ARG_TYPES (TREE_TYPE (olddecl
)) != 0);
2105 bool extern_changed
= false;
2107 /* For real parm decl following a forward decl, rechain the old decl
2108 in its new location and clear TREE_ASM_WRITTEN (it's not a
2109 forward decl anymore). */
2110 if (TREE_CODE (newdecl
) == PARM_DECL
2111 && TREE_ASM_WRITTEN (olddecl
) && !TREE_ASM_WRITTEN (newdecl
))
2113 struct c_binding
*b
, **here
;
2115 for (here
= ¤t_scope
->bindings
; *here
; here
= &(*here
)->prev
)
2116 if ((*here
)->decl
== olddecl
)
2123 b
->prev
= current_scope
->bindings
;
2124 current_scope
->bindings
= b
;
2126 TREE_ASM_WRITTEN (olddecl
) = 0;
2129 DECL_ATTRIBUTES (newdecl
)
2130 = targetm
.merge_decl_attributes (olddecl
, newdecl
);
2132 /* Merge the data types specified in the two decls. */
2134 = TREE_TYPE (olddecl
)
2135 = composite_type (newtype
, oldtype
);
2137 /* Lay the type out, unless already done. */
2138 if (!comptypes (oldtype
, TREE_TYPE (newdecl
)))
2140 if (TREE_TYPE (newdecl
) != error_mark_node
)
2141 layout_type (TREE_TYPE (newdecl
));
2142 if (TREE_CODE (newdecl
) != FUNCTION_DECL
2143 && TREE_CODE (newdecl
) != TYPE_DECL
2144 && TREE_CODE (newdecl
) != CONST_DECL
)
2145 layout_decl (newdecl
, 0);
2149 /* Since the type is OLDDECL's, make OLDDECL's size go with. */
2150 DECL_SIZE (newdecl
) = DECL_SIZE (olddecl
);
2151 DECL_SIZE_UNIT (newdecl
) = DECL_SIZE_UNIT (olddecl
);
2152 DECL_MODE (newdecl
) = DECL_MODE (olddecl
);
2153 if (DECL_ALIGN (olddecl
) > DECL_ALIGN (newdecl
))
2155 DECL_ALIGN (newdecl
) = DECL_ALIGN (olddecl
);
2156 DECL_USER_ALIGN (newdecl
) |= DECL_USER_ALIGN (olddecl
);
2160 /* Keep the old rtl since we can safely use it. */
2161 if (HAS_RTL_P (olddecl
))
2162 COPY_DECL_RTL (olddecl
, newdecl
);
2164 /* Merge the type qualifiers. */
2165 if (TREE_READONLY (newdecl
))
2166 TREE_READONLY (olddecl
) = 1;
2168 if (TREE_THIS_VOLATILE (newdecl
))
2169 TREE_THIS_VOLATILE (olddecl
) = 1;
2171 /* Merge deprecatedness. */
2172 if (TREE_DEPRECATED (newdecl
))
2173 TREE_DEPRECATED (olddecl
) = 1;
2175 /* If a decl is in a system header and the other isn't, keep the one on the
2176 system header. Otherwise, keep source location of definition rather than
2177 declaration and of prototype rather than non-prototype unless that
2178 prototype is built-in. */
2179 if (CODE_CONTAINS_STRUCT (TREE_CODE (olddecl
), TS_DECL_WITH_VIS
)
2180 && DECL_IN_SYSTEM_HEADER (olddecl
)
2181 && !DECL_IN_SYSTEM_HEADER (newdecl
) )
2182 DECL_SOURCE_LOCATION (newdecl
) = DECL_SOURCE_LOCATION (olddecl
);
2183 else if (CODE_CONTAINS_STRUCT (TREE_CODE (olddecl
), TS_DECL_WITH_VIS
)
2184 && DECL_IN_SYSTEM_HEADER (newdecl
)
2185 && !DECL_IN_SYSTEM_HEADER (olddecl
))
2186 DECL_SOURCE_LOCATION (olddecl
) = DECL_SOURCE_LOCATION (newdecl
);
2187 else if ((DECL_INITIAL (newdecl
) == 0 && DECL_INITIAL (olddecl
) != 0)
2188 || (old_is_prototype
&& !new_is_prototype
2189 && !C_DECL_BUILTIN_PROTOTYPE (olddecl
)))
2190 DECL_SOURCE_LOCATION (newdecl
) = DECL_SOURCE_LOCATION (olddecl
);
2192 /* Merge the initialization information. */
2193 if (DECL_INITIAL (newdecl
) == 0)
2194 DECL_INITIAL (newdecl
) = DECL_INITIAL (olddecl
);
2196 /* Merge the threadprivate attribute. */
2197 if (TREE_CODE (olddecl
) == VAR_DECL
&& C_DECL_THREADPRIVATE_P (olddecl
))
2199 DECL_TLS_MODEL (newdecl
) = DECL_TLS_MODEL (olddecl
);
2200 C_DECL_THREADPRIVATE_P (newdecl
) = 1;
2203 if (CODE_CONTAINS_STRUCT (TREE_CODE (olddecl
), TS_DECL_WITH_VIS
))
2205 /* Merge the section attribute.
2206 We want to issue an error if the sections conflict but that
2207 must be done later in decl_attributes since we are called
2208 before attributes are assigned. */
2209 if (DECL_SECTION_NAME (newdecl
) == NULL_TREE
)
2210 DECL_SECTION_NAME (newdecl
) = DECL_SECTION_NAME (olddecl
);
2212 /* Copy the assembler name.
2213 Currently, it can only be defined in the prototype. */
2214 COPY_DECL_ASSEMBLER_NAME (olddecl
, newdecl
);
2216 /* Use visibility of whichever declaration had it specified */
2217 if (DECL_VISIBILITY_SPECIFIED (olddecl
))
2219 DECL_VISIBILITY (newdecl
) = DECL_VISIBILITY (olddecl
);
2220 DECL_VISIBILITY_SPECIFIED (newdecl
) = 1;
2223 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
2225 DECL_STATIC_CONSTRUCTOR(newdecl
) |= DECL_STATIC_CONSTRUCTOR(olddecl
);
2226 DECL_STATIC_DESTRUCTOR (newdecl
) |= DECL_STATIC_DESTRUCTOR (olddecl
);
2227 DECL_NO_LIMIT_STACK (newdecl
) |= DECL_NO_LIMIT_STACK (olddecl
);
2228 DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (newdecl
)
2229 |= DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (olddecl
);
2230 TREE_THIS_VOLATILE (newdecl
) |= TREE_THIS_VOLATILE (olddecl
);
2231 DECL_IS_MALLOC (newdecl
) |= DECL_IS_MALLOC (olddecl
);
2232 DECL_IS_OPERATOR_NEW (newdecl
) |= DECL_IS_OPERATOR_NEW (olddecl
);
2233 TREE_READONLY (newdecl
) |= TREE_READONLY (olddecl
);
2234 DECL_PURE_P (newdecl
) |= DECL_PURE_P (olddecl
);
2235 DECL_IS_NOVOPS (newdecl
) |= DECL_IS_NOVOPS (olddecl
);
2238 /* Merge the storage class information. */
2239 merge_weak (newdecl
, olddecl
);
2241 /* For functions, static overrides non-static. */
2242 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
2244 TREE_PUBLIC (newdecl
) &= TREE_PUBLIC (olddecl
);
2245 /* This is since we don't automatically
2246 copy the attributes of NEWDECL into OLDDECL. */
2247 TREE_PUBLIC (olddecl
) = TREE_PUBLIC (newdecl
);
2248 /* If this clears `static', clear it in the identifier too. */
2249 if (!TREE_PUBLIC (olddecl
))
2250 TREE_PUBLIC (DECL_NAME (olddecl
)) = 0;
2254 /* In c99, 'extern' declaration before (or after) 'inline' means this
2255 function is not DECL_EXTERNAL, unless 'gnu_inline' attribute
2257 if (TREE_CODE (newdecl
) == FUNCTION_DECL
2258 && !flag_gnu89_inline
2259 && (DECL_DECLARED_INLINE_P (newdecl
)
2260 || DECL_DECLARED_INLINE_P (olddecl
))
2261 && (!DECL_DECLARED_INLINE_P (newdecl
)
2262 || !DECL_DECLARED_INLINE_P (olddecl
)
2263 || !DECL_EXTERNAL (olddecl
))
2264 && DECL_EXTERNAL (newdecl
)
2265 && !lookup_attribute ("gnu_inline", DECL_ATTRIBUTES (newdecl
))
2266 && !current_function_decl
)
2267 DECL_EXTERNAL (newdecl
) = 0;
2269 if (DECL_EXTERNAL (newdecl
))
2271 TREE_STATIC (newdecl
) = TREE_STATIC (olddecl
);
2272 DECL_EXTERNAL (newdecl
) = DECL_EXTERNAL (olddecl
);
2274 /* An extern decl does not override previous storage class. */
2275 TREE_PUBLIC (newdecl
) = TREE_PUBLIC (olddecl
);
2276 if (!DECL_EXTERNAL (newdecl
))
2278 DECL_CONTEXT (newdecl
) = DECL_CONTEXT (olddecl
);
2279 DECL_COMMON (newdecl
) = DECL_COMMON (olddecl
);
2284 TREE_STATIC (olddecl
) = TREE_STATIC (newdecl
);
2285 TREE_PUBLIC (olddecl
) = TREE_PUBLIC (newdecl
);
2288 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
2290 /* If we're redefining a function previously defined as extern
2291 inline, make sure we emit debug info for the inline before we
2292 throw it away, in case it was inlined into a function that
2293 hasn't been written out yet. */
2294 if (new_is_definition
&& DECL_INITIAL (olddecl
))
2295 /* The new defn must not be inline. */
2296 DECL_UNINLINABLE (newdecl
) = 1;
2299 /* If either decl says `inline', this fn is inline, unless
2300 its definition was passed already. */
2301 if (DECL_DECLARED_INLINE_P (newdecl
)
2302 || DECL_DECLARED_INLINE_P (olddecl
))
2303 DECL_DECLARED_INLINE_P (newdecl
) = 1;
2305 DECL_UNINLINABLE (newdecl
) = DECL_UNINLINABLE (olddecl
)
2306 = (DECL_UNINLINABLE (newdecl
) || DECL_UNINLINABLE (olddecl
));
2308 DECL_DISREGARD_INLINE_LIMITS (newdecl
)
2309 = DECL_DISREGARD_INLINE_LIMITS (olddecl
)
2310 = (DECL_DISREGARD_INLINE_LIMITS (newdecl
)
2311 || DECL_DISREGARD_INLINE_LIMITS (olddecl
));
2314 if (DECL_BUILT_IN (olddecl
))
2316 /* If redeclaring a builtin function, it stays built in.
2317 But it gets tagged as having been declared. */
2318 DECL_BUILT_IN_CLASS (newdecl
) = DECL_BUILT_IN_CLASS (olddecl
);
2319 DECL_FUNCTION_CODE (newdecl
) = DECL_FUNCTION_CODE (olddecl
);
2320 C_DECL_DECLARED_BUILTIN (newdecl
) = 1;
2321 if (new_is_prototype
)
2322 C_DECL_BUILTIN_PROTOTYPE (newdecl
) = 0;
2324 C_DECL_BUILTIN_PROTOTYPE (newdecl
)
2325 = C_DECL_BUILTIN_PROTOTYPE (olddecl
);
2328 /* Preserve function specific target and optimization options */
2329 if (DECL_FUNCTION_SPECIFIC_TARGET (olddecl
)
2330 && !DECL_FUNCTION_SPECIFIC_TARGET (newdecl
))
2331 DECL_FUNCTION_SPECIFIC_TARGET (newdecl
)
2332 = DECL_FUNCTION_SPECIFIC_TARGET (olddecl
);
2334 if (DECL_FUNCTION_SPECIFIC_OPTIMIZATION (olddecl
)
2335 && !DECL_FUNCTION_SPECIFIC_OPTIMIZATION (newdecl
))
2336 DECL_FUNCTION_SPECIFIC_OPTIMIZATION (newdecl
)
2337 = DECL_FUNCTION_SPECIFIC_OPTIMIZATION (olddecl
);
2339 /* Also preserve various other info from the definition. */
2340 if (!new_is_definition
)
2343 DECL_RESULT (newdecl
) = DECL_RESULT (olddecl
);
2344 DECL_INITIAL (newdecl
) = DECL_INITIAL (olddecl
);
2345 DECL_STRUCT_FUNCTION (newdecl
) = DECL_STRUCT_FUNCTION (olddecl
);
2346 DECL_SAVED_TREE (newdecl
) = DECL_SAVED_TREE (olddecl
);
2347 gimple_set_body (newdecl
, gimple_body (olddecl
));
2348 DECL_ARGUMENTS (newdecl
) = copy_list (DECL_ARGUMENTS (olddecl
));
2349 for (t
= DECL_ARGUMENTS (newdecl
); t
; t
= TREE_CHAIN (t
))
2350 DECL_CONTEXT (t
) = newdecl
;
2352 /* See if we've got a function to instantiate from. */
2353 if (DECL_SAVED_TREE (olddecl
))
2354 DECL_ABSTRACT_ORIGIN (newdecl
)
2355 = DECL_ABSTRACT_ORIGIN (olddecl
);
2359 extern_changed
= DECL_EXTERNAL (olddecl
) && !DECL_EXTERNAL (newdecl
);
2361 /* Merge the USED information. */
2362 if (TREE_USED (olddecl
))
2363 TREE_USED (newdecl
) = 1;
2364 else if (TREE_USED (newdecl
))
2365 TREE_USED (olddecl
) = 1;
2367 /* Copy most of the decl-specific fields of NEWDECL into OLDDECL.
2368 But preserve OLDDECL's DECL_UID and DECL_CONTEXT. */
2370 unsigned olddecl_uid
= DECL_UID (olddecl
);
2371 tree olddecl_context
= DECL_CONTEXT (olddecl
);
2372 tree olddecl_arguments
= NULL
;
2373 if (TREE_CODE (olddecl
) == FUNCTION_DECL
)
2374 olddecl_arguments
= DECL_ARGUMENTS (olddecl
);
2376 memcpy ((char *) olddecl
+ sizeof (struct tree_common
),
2377 (char *) newdecl
+ sizeof (struct tree_common
),
2378 sizeof (struct tree_decl_common
) - sizeof (struct tree_common
));
2379 switch (TREE_CODE (olddecl
))
2382 gimple_set_body (olddecl
, gimple_body (newdecl
));
2392 memcpy ((char *) olddecl
+ sizeof (struct tree_decl_common
),
2393 (char *) newdecl
+ sizeof (struct tree_decl_common
),
2394 tree_code_size (TREE_CODE (olddecl
)) - sizeof (struct tree_decl_common
));
2399 memcpy ((char *) olddecl
+ sizeof (struct tree_decl_common
),
2400 (char *) newdecl
+ sizeof (struct tree_decl_common
),
2401 sizeof (struct tree_decl_non_common
) - sizeof (struct tree_decl_common
));
2403 DECL_UID (olddecl
) = olddecl_uid
;
2404 DECL_CONTEXT (olddecl
) = olddecl_context
;
2405 if (TREE_CODE (olddecl
) == FUNCTION_DECL
)
2406 DECL_ARGUMENTS (olddecl
) = olddecl_arguments
;
2409 /* If OLDDECL had its DECL_RTL instantiated, re-invoke make_decl_rtl
2410 so that encode_section_info has a chance to look at the new decl
2411 flags and attributes. */
2412 if (DECL_RTL_SET_P (olddecl
)
2413 && (TREE_CODE (olddecl
) == FUNCTION_DECL
2414 || (TREE_CODE (olddecl
) == VAR_DECL
2415 && TREE_STATIC (olddecl
))))
2416 make_decl_rtl (olddecl
);
2418 /* If we changed a function from DECL_EXTERNAL to !DECL_EXTERNAL,
2419 and the definition is coming from the old version, cgraph needs
2420 to be called again. */
2421 if (extern_changed
&& !new_is_definition
2422 && TREE_CODE (olddecl
) == FUNCTION_DECL
&& DECL_INITIAL (olddecl
))
2423 cgraph_mark_if_needed (olddecl
);
2426 /* Handle when a new declaration NEWDECL has the same name as an old
2427 one OLDDECL in the same binding contour. Prints an error message
2430 If safely possible, alter OLDDECL to look like NEWDECL, and return
2431 true. Otherwise, return false. */
2434 duplicate_decls (tree newdecl
, tree olddecl
)
2436 tree newtype
= NULL
, oldtype
= NULL
;
2438 if (!diagnose_mismatched_decls (newdecl
, olddecl
, &newtype
, &oldtype
))
2440 /* Avoid `unused variable' and other warnings for OLDDECL. */
2441 TREE_NO_WARNING (olddecl
) = 1;
2445 merge_decls (newdecl
, olddecl
, newtype
, oldtype
);
2450 /* Check whether decl-node NEW_DECL shadows an existing declaration. */
2452 warn_if_shadowing (tree new_decl
)
2454 struct c_binding
*b
;
2456 /* Shadow warnings wanted? */
2458 /* No shadow warnings for internally generated vars. */
2459 || DECL_IS_BUILTIN (new_decl
)
2460 /* No shadow warnings for vars made for inlining. */
2461 || DECL_FROM_INLINE (new_decl
))
2464 /* Is anything being shadowed? Invisible decls do not count. */
2465 for (b
= I_SYMBOL_BINDING (DECL_NAME (new_decl
)); b
; b
= b
->shadowed
)
2466 if (b
->decl
&& b
->decl
!= new_decl
&& !b
->invisible
)
2468 tree old_decl
= b
->decl
;
2470 if (old_decl
== error_mark_node
)
2472 warning (OPT_Wshadow
, "declaration of %q+D shadows previous "
2473 "non-variable", new_decl
);
2476 else if (TREE_CODE (old_decl
) == PARM_DECL
)
2477 warning (OPT_Wshadow
, "declaration of %q+D shadows a parameter",
2479 else if (DECL_FILE_SCOPE_P (old_decl
))
2480 warning (OPT_Wshadow
, "declaration of %q+D shadows a global "
2481 "declaration", new_decl
);
2482 else if (TREE_CODE (old_decl
) == FUNCTION_DECL
2483 && DECL_BUILT_IN (old_decl
))
2485 warning (OPT_Wshadow
, "declaration of %q+D shadows "
2486 "a built-in function", new_decl
);
2490 warning (OPT_Wshadow
, "declaration of %q+D shadows a previous local",
2493 warning_at (DECL_SOURCE_LOCATION (old_decl
), OPT_Wshadow
,
2494 "shadowed declaration is here");
2500 /* Record a decl-node X as belonging to the current lexical scope.
2501 Check for errors (such as an incompatible declaration for the same
2502 name already seen in the same scope).
2504 Returns either X or an old decl for the same name.
2505 If an old decl is returned, it may have been smashed
2506 to agree with what X says. */
2511 tree name
= DECL_NAME (x
);
2512 struct c_scope
*scope
= current_scope
;
2513 struct c_binding
*b
;
2514 bool nested
= false;
2515 location_t locus
= DECL_SOURCE_LOCATION (x
);
2517 /* Must set DECL_CONTEXT for everything not at file scope or
2518 DECL_FILE_SCOPE_P won't work. Local externs don't count
2519 unless they have initializers (which generate code). */
2520 if (current_function_decl
2521 && ((TREE_CODE (x
) != FUNCTION_DECL
&& TREE_CODE (x
) != VAR_DECL
)
2522 || DECL_INITIAL (x
) || !DECL_EXTERNAL (x
)))
2523 DECL_CONTEXT (x
) = current_function_decl
;
2525 /* Anonymous decls are just inserted in the scope. */
2528 bind (name
, x
, scope
, /*invisible=*/false, /*nested=*/false,
2533 /* First, see if there is another declaration with the same name in
2534 the current scope. If there is, duplicate_decls may do all the
2535 work for us. If duplicate_decls returns false, that indicates
2536 two incompatible decls in the same scope; we are to silently
2537 replace the old one (duplicate_decls has issued all appropriate
2538 diagnostics). In particular, we should not consider possible
2539 duplicates in the external scope, or shadowing. */
2540 b
= I_SYMBOL_BINDING (name
);
2541 if (b
&& B_IN_SCOPE (b
, scope
))
2543 struct c_binding
*b_ext
, *b_use
;
2544 tree type
= TREE_TYPE (x
);
2545 tree visdecl
= b
->decl
;
2546 tree vistype
= TREE_TYPE (visdecl
);
2547 if (TREE_CODE (TREE_TYPE (x
)) == ARRAY_TYPE
2548 && COMPLETE_TYPE_P (TREE_TYPE (x
)))
2549 b
->inner_comp
= false;
2552 /* If this is an external linkage declaration, we should check
2553 for compatibility with the type in the external scope before
2554 setting the type at this scope based on the visible
2555 information only. */
2556 if (TREE_PUBLIC (x
) && TREE_PUBLIC (visdecl
))
2558 while (b_ext
&& !B_IN_EXTERNAL_SCOPE (b_ext
))
2559 b_ext
= b_ext
->shadowed
;
2564 TREE_TYPE (b_use
->decl
) = b_use
->u
.type
;
2567 if (duplicate_decls (x
, b_use
->decl
))
2571 /* Save the updated type in the external scope and
2572 restore the proper type for this scope. */
2574 if (comptypes (vistype
, type
))
2575 thistype
= composite_type (vistype
, type
);
2577 thistype
= TREE_TYPE (b_use
->decl
);
2578 b_use
->u
.type
= TREE_TYPE (b_use
->decl
);
2579 if (TREE_CODE (b_use
->decl
) == FUNCTION_DECL
2580 && DECL_BUILT_IN (b_use
->decl
))
2582 = build_type_attribute_variant (thistype
,
2585 TREE_TYPE (b_use
->decl
) = thistype
;
2590 goto skip_external_and_shadow_checks
;
2593 /* All declarations with external linkage, and all external
2594 references, go in the external scope, no matter what scope is
2595 current. However, the binding in that scope is ignored for
2596 purposes of normal name lookup. A separate binding structure is
2597 created in the requested scope; this governs the normal
2598 visibility of the symbol.
2600 The binding in the externals scope is used exclusively for
2601 detecting duplicate declarations of the same object, no matter
2602 what scope they are in; this is what we do here. (C99 6.2.7p2:
2603 All declarations that refer to the same object or function shall
2604 have compatible type; otherwise, the behavior is undefined.) */
2605 if (DECL_EXTERNAL (x
) || scope
== file_scope
)
2607 tree type
= TREE_TYPE (x
);
2610 bool type_saved
= false;
2611 if (b
&& !B_IN_EXTERNAL_SCOPE (b
)
2612 && (TREE_CODE (b
->decl
) == FUNCTION_DECL
2613 || TREE_CODE (b
->decl
) == VAR_DECL
)
2614 && DECL_FILE_SCOPE_P (b
->decl
))
2617 vistype
= TREE_TYPE (visdecl
);
2619 if (scope
!= file_scope
2620 && !DECL_IN_SYSTEM_HEADER (x
))
2621 warning (OPT_Wnested_externs
, "nested extern declaration of %qD", x
);
2623 while (b
&& !B_IN_EXTERNAL_SCOPE (b
))
2625 /* If this decl might be modified, save its type. This is
2626 done here rather than when the decl is first bound
2627 because the type may change after first binding, through
2628 being completed or through attributes being added. If we
2629 encounter multiple such decls, only the first should have
2630 its type saved; the others will already have had their
2631 proper types saved and the types will not have changed as
2632 their scopes will not have been re-entered. */
2633 if (DECL_P (b
->decl
) && DECL_FILE_SCOPE_P (b
->decl
) && !type_saved
)
2635 b
->u
.type
= TREE_TYPE (b
->decl
);
2638 if (B_IN_FILE_SCOPE (b
)
2639 && TREE_CODE (b
->decl
) == VAR_DECL
2640 && TREE_STATIC (b
->decl
)
2641 && TREE_CODE (TREE_TYPE (b
->decl
)) == ARRAY_TYPE
2642 && !TYPE_DOMAIN (TREE_TYPE (b
->decl
))
2643 && TREE_CODE (type
) == ARRAY_TYPE
2644 && TYPE_DOMAIN (type
)
2645 && TYPE_MAX_VALUE (TYPE_DOMAIN (type
))
2646 && !integer_zerop (TYPE_MAX_VALUE (TYPE_DOMAIN (type
))))
2648 /* Array type completed in inner scope, which should be
2649 diagnosed if the completion does not have size 1 and
2650 it does not get completed in the file scope. */
2651 b
->inner_comp
= true;
2656 /* If a matching external declaration has been found, set its
2657 type to the composite of all the types of that declaration.
2658 After the consistency checks, it will be reset to the
2659 composite of the visible types only. */
2660 if (b
&& (TREE_PUBLIC (x
) || same_translation_unit_p (x
, b
->decl
))
2662 TREE_TYPE (b
->decl
) = b
->u
.type
;
2664 /* The point of the same_translation_unit_p check here is,
2665 we want to detect a duplicate decl for a construct like
2666 foo() { extern bar(); } ... static bar(); but not if
2667 they are in different translation units. In any case,
2668 the static does not go in the externals scope. */
2670 && (TREE_PUBLIC (x
) || same_translation_unit_p (x
, b
->decl
))
2671 && duplicate_decls (x
, b
->decl
))
2676 if (comptypes (vistype
, type
))
2677 thistype
= composite_type (vistype
, type
);
2679 thistype
= TREE_TYPE (b
->decl
);
2683 b
->u
.type
= TREE_TYPE (b
->decl
);
2684 if (TREE_CODE (b
->decl
) == FUNCTION_DECL
&& DECL_BUILT_IN (b
->decl
))
2686 = build_type_attribute_variant (thistype
,
2687 TYPE_ATTRIBUTES (b
->u
.type
));
2688 TREE_TYPE (b
->decl
) = thistype
;
2689 bind (name
, b
->decl
, scope
, /*invisible=*/false, /*nested=*/true,
2693 else if (TREE_PUBLIC (x
))
2695 if (visdecl
&& !b
&& duplicate_decls (x
, visdecl
))
2697 /* An external declaration at block scope referring to a
2698 visible entity with internal linkage. The composite
2699 type will already be correct for this scope, so we
2700 just need to fall through to make the declaration in
2707 bind (name
, x
, external_scope
, /*invisible=*/true,
2708 /*nested=*/false, locus
);
2714 if (TREE_CODE (x
) != PARM_DECL
)
2715 warn_if_shadowing (x
);
2717 skip_external_and_shadow_checks
:
2718 if (TREE_CODE (x
) == TYPE_DECL
)
2719 set_underlying_type (x
);
2721 bind (name
, x
, scope
, /*invisible=*/false, nested
, locus
);
2723 /* If x's type is incomplete because it's based on a
2724 structure or union which has not yet been fully declared,
2725 attach it to that structure or union type, so we can go
2726 back and complete the variable declaration later, if the
2727 structure or union gets fully declared.
2729 If the input is erroneous, we can have error_mark in the type
2730 slot (e.g. "f(void a, ...)") - that doesn't count as an
2732 if (TREE_TYPE (x
) != error_mark_node
2733 && !COMPLETE_TYPE_P (TREE_TYPE (x
)))
2735 tree element
= TREE_TYPE (x
);
2737 while (TREE_CODE (element
) == ARRAY_TYPE
)
2738 element
= TREE_TYPE (element
);
2739 element
= TYPE_MAIN_VARIANT (element
);
2741 if ((TREE_CODE (element
) == RECORD_TYPE
2742 || TREE_CODE (element
) == UNION_TYPE
)
2743 && (TREE_CODE (x
) != TYPE_DECL
2744 || TREE_CODE (TREE_TYPE (x
)) == ARRAY_TYPE
)
2745 && !COMPLETE_TYPE_P (element
))
2746 C_TYPE_INCOMPLETE_VARS (element
)
2747 = tree_cons (NULL_TREE
, x
, C_TYPE_INCOMPLETE_VARS (element
));
2752 /* Record X as belonging to file scope.
2753 This is used only internally by the Objective-C front end,
2754 and is limited to its needs. duplicate_decls is not called;
2755 if there is any preexisting decl for this identifier, it is an ICE. */
2758 pushdecl_top_level (tree x
)
2761 bool nested
= false;
2762 gcc_assert (TREE_CODE (x
) == VAR_DECL
|| TREE_CODE (x
) == CONST_DECL
);
2764 name
= DECL_NAME (x
);
2766 gcc_assert (TREE_CODE (x
) == CONST_DECL
|| !I_SYMBOL_BINDING (name
));
2768 if (TREE_PUBLIC (x
))
2770 bind (name
, x
, external_scope
, /*invisible=*/true, /*nested=*/false,
2775 bind (name
, x
, file_scope
, /*invisible=*/false, nested
, UNKNOWN_LOCATION
);
2781 implicit_decl_warning (tree id
, tree olddecl
)
2783 if (warn_implicit_function_declaration
)
2788 warned
= pedwarn (input_location
, OPT_Wimplicit_function_declaration
,
2789 "implicit declaration of function %qE", id
);
2791 warned
= warning (OPT_Wimplicit_function_declaration
,
2792 G_("implicit declaration of function %qE"), id
);
2793 if (olddecl
&& warned
)
2794 locate_old_decl (olddecl
);
2798 /* Generate an implicit declaration for identifier FUNCTIONID at LOC as a
2799 function of type int (). */
2802 implicitly_declare (location_t loc
, tree functionid
)
2804 struct c_binding
*b
;
2808 for (b
= I_SYMBOL_BINDING (functionid
); b
; b
= b
->shadowed
)
2810 if (B_IN_SCOPE (b
, external_scope
))
2819 if (decl
== error_mark_node
)
2822 /* FIXME: Objective-C has weird not-really-builtin functions
2823 which are supposed to be visible automatically. They wind up
2824 in the external scope because they're pushed before the file
2825 scope gets created. Catch this here and rebind them into the
2827 if (!DECL_BUILT_IN (decl
) && DECL_IS_BUILTIN (decl
))
2829 bind (functionid
, decl
, file_scope
,
2830 /*invisible=*/false, /*nested=*/true,
2831 DECL_SOURCE_LOCATION (decl
));
2836 tree newtype
= default_function_type
;
2838 TREE_TYPE (decl
) = b
->u
.type
;
2839 /* Implicit declaration of a function already declared
2840 (somehow) in a different scope, or as a built-in.
2841 If this is the first time this has happened, warn;
2842 then recycle the old declaration but with the new type. */
2843 if (!C_DECL_IMPLICIT (decl
))
2845 implicit_decl_warning (functionid
, decl
);
2846 C_DECL_IMPLICIT (decl
) = 1;
2848 if (DECL_BUILT_IN (decl
))
2850 newtype
= build_type_attribute_variant (newtype
,
2852 (TREE_TYPE (decl
)));
2853 if (!comptypes (newtype
, TREE_TYPE (decl
)))
2855 warning_at (loc
, 0, "incompatible implicit declaration of "
2856 "built-in function %qD", decl
);
2857 newtype
= TREE_TYPE (decl
);
2862 if (!comptypes (newtype
, TREE_TYPE (decl
)))
2864 error_at (loc
, "incompatible implicit declaration of function %qD", decl
);
2865 locate_old_decl (decl
);
2868 b
->u
.type
= TREE_TYPE (decl
);
2869 TREE_TYPE (decl
) = newtype
;
2870 bind (functionid
, decl
, current_scope
,
2871 /*invisible=*/false, /*nested=*/true,
2872 DECL_SOURCE_LOCATION (decl
));
2877 /* Not seen before. */
2878 decl
= build_decl (loc
, FUNCTION_DECL
, functionid
, default_function_type
);
2879 DECL_EXTERNAL (decl
) = 1;
2880 TREE_PUBLIC (decl
) = 1;
2881 C_DECL_IMPLICIT (decl
) = 1;
2882 implicit_decl_warning (functionid
, 0);
2883 asmspec_tree
= maybe_apply_renaming_pragma (decl
, /*asmname=*/NULL
);
2885 set_user_assembler_name (decl
, TREE_STRING_POINTER (asmspec_tree
));
2887 /* C89 says implicit declarations are in the innermost block.
2888 So we record the decl in the standard fashion. */
2889 decl
= pushdecl (decl
);
2891 /* No need to call objc_check_decl here - it's a function type. */
2892 rest_of_decl_compilation (decl
, 0, 0);
2894 /* Write a record describing this implicit function declaration
2895 to the prototypes file (if requested). */
2896 gen_aux_info_record (decl
, 0, 1, 0);
2898 /* Possibly apply some default attributes to this implicit declaration. */
2899 decl_attributes (&decl
, NULL_TREE
, 0);
2904 /* Issue an error message for a reference to an undeclared variable
2905 ID, including a reference to a builtin outside of function-call
2906 context. Establish a binding of the identifier to error_mark_node
2907 in an appropriate scope, which will suppress further errors for the
2908 same identifier. The error message should be given location LOC. */
2910 undeclared_variable (location_t loc
, tree id
)
2912 static bool already
= false;
2913 struct c_scope
*scope
;
2915 if (current_function_decl
== 0)
2917 error_at (loc
, "%qE undeclared here (not in a function)", id
);
2918 scope
= current_scope
;
2922 error_at (loc
, "%qE undeclared (first use in this function)", id
);
2926 error_at (loc
, "(Each undeclared identifier is reported only once");
2927 error_at (loc
, "for each function it appears in.)");
2931 /* If we are parsing old-style parameter decls, current_function_decl
2932 will be nonnull but current_function_scope will be null. */
2933 scope
= current_function_scope
? current_function_scope
: current_scope
;
2935 bind (id
, error_mark_node
, scope
, /*invisible=*/false, /*nested=*/false,
2939 /* Subroutine of lookup_label, declare_label, define_label: construct a
2940 LABEL_DECL with all the proper frills. Also create a struct
2941 c_label_vars initialized for the current scope. */
2944 make_label (location_t location
, tree name
, bool defining
,
2945 struct c_label_vars
**p_label_vars
)
2947 tree label
= build_decl (location
, LABEL_DECL
, name
, void_type_node
);
2948 struct c_label_vars
*label_vars
;
2950 DECL_CONTEXT (label
) = current_function_decl
;
2951 DECL_MODE (label
) = VOIDmode
;
2953 label_vars
= GGC_NEW (struct c_label_vars
);
2954 label_vars
->shadowed
= NULL
;
2955 set_spot_bindings (&label_vars
->label_bindings
, defining
);
2956 label_vars
->decls_in_scope
= make_tree_vector ();
2957 label_vars
->gotos
= VEC_alloc (c_goto_bindings_p
, gc
, 0);
2958 *p_label_vars
= label_vars
;
2963 /* Get the LABEL_DECL corresponding to identifier NAME as a label.
2964 Create one if none exists so far for the current function.
2965 This is called when a label is used in a goto expression or
2966 has its address taken. */
2969 lookup_label (tree name
)
2972 struct c_label_vars
*label_vars
;
2974 if (current_function_decl
== 0)
2976 error ("label %qE referenced outside of any function", name
);
2980 /* Use a label already defined or ref'd with this name, but not if
2981 it is inherited from a containing function and wasn't declared
2983 label
= I_LABEL_DECL (name
);
2984 if (label
&& (DECL_CONTEXT (label
) == current_function_decl
2985 || C_DECLARED_LABEL_FLAG (label
)))
2987 /* If the label has only been declared, update its apparent
2988 location to point here, for better diagnostics if it
2989 turns out not to have been defined. */
2990 if (DECL_INITIAL (label
) == NULL_TREE
)
2991 DECL_SOURCE_LOCATION (label
) = input_location
;
2995 /* No label binding for that identifier; make one. */
2996 label
= make_label (input_location
, name
, false, &label_vars
);
2998 /* Ordinary labels go in the current function scope. */
2999 bind_label (name
, label
, current_function_scope
, label_vars
);
3004 /* Issue a warning about DECL for a goto statement at GOTO_LOC going
3008 warn_about_goto (location_t goto_loc
, tree label
, tree decl
)
3010 if (variably_modified_type_p (TREE_TYPE (decl
), NULL_TREE
))
3012 "jump into scope of identifier with variably modified type");
3014 warning_at (goto_loc
, OPT_Wjump_misses_init
,
3015 "jump skips variable initialization");
3016 inform (DECL_SOURCE_LOCATION (label
), "label %qD defined here", label
);
3017 inform (DECL_SOURCE_LOCATION (decl
), "%qD declared here", decl
);
3020 /* Look up a label because of a goto statement. This is like
3021 lookup_label, but also issues any appropriate warnings. */
3024 lookup_label_for_goto (location_t loc
, tree name
)
3027 struct c_label_vars
*label_vars
;
3031 label
= lookup_label (name
);
3032 if (label
== NULL_TREE
)
3035 /* If we are jumping to a different function, we can't issue any
3037 if (DECL_CONTEXT (label
) != current_function_decl
)
3039 gcc_assert (C_DECLARED_LABEL_FLAG (label
));
3043 label_vars
= I_LABEL_BINDING (name
)->u
.label
;
3045 /* If the label has not yet been defined, then push this goto on a
3046 list for possible later warnings. */
3047 if (label_vars
->label_bindings
.scope
== NULL
)
3049 struct c_goto_bindings
*g
;
3051 g
= GGC_NEW (struct c_goto_bindings
);
3053 set_spot_bindings (&g
->goto_bindings
, true);
3054 VEC_safe_push (c_goto_bindings_p
, gc
, label_vars
->gotos
, g
);
3058 /* If there are any decls in label_vars->decls_in_scope, then this
3059 goto has missed the declaration of the decl. This happens for a
3065 Issue a warning or error. */
3066 for (ix
= 0; VEC_iterate (tree
, label_vars
->decls_in_scope
, ix
, decl
); ++ix
)
3067 warn_about_goto (loc
, label
, decl
);
3069 if (label_vars
->label_bindings
.left_stmt_expr
)
3071 error_at (loc
, "jump into statement expression");
3072 inform (DECL_SOURCE_LOCATION (label
), "label %qD defined here", label
);
3078 /* Make a label named NAME in the current function, shadowing silently
3079 any that may be inherited from containing functions or containing
3080 scopes. This is called for __label__ declarations. */
3083 declare_label (tree name
)
3085 struct c_binding
*b
= I_LABEL_BINDING (name
);
3087 struct c_label_vars
*label_vars
;
3089 /* Check to make sure that the label hasn't already been declared
3091 if (b
&& B_IN_CURRENT_SCOPE (b
))
3093 error ("duplicate label declaration %qE", name
);
3094 locate_old_decl (b
->decl
);
3096 /* Just use the previous declaration. */
3100 label
= make_label (input_location
, name
, false, &label_vars
);
3101 C_DECLARED_LABEL_FLAG (label
) = 1;
3103 /* Declared labels go in the current scope. */
3104 bind_label (name
, label
, current_scope
, label_vars
);
3109 /* When we define a label, issue any appropriate warnings if there are
3110 any gotos earlier in the function which jump to this label. */
3113 check_earlier_gotos (tree label
, struct c_label_vars
* label_vars
)
3116 struct c_goto_bindings
*g
;
3119 VEC_iterate (c_goto_bindings_p
, label_vars
->gotos
, ix
, g
);
3122 struct c_binding
*b
;
3123 struct c_scope
*scope
;
3125 /* We have a goto to this label. The goto is going forward. In
3126 g->scope, the goto is going to skip any binding which was
3127 defined after g->bindings_in_scope. */
3128 for (b
= g
->goto_bindings
.scope
->bindings
;
3129 b
!= g
->goto_bindings
.bindings_in_scope
;
3132 if (decl_jump_unsafe (b
->decl
))
3133 warn_about_goto (g
->loc
, label
, b
->decl
);
3136 /* We also need to warn about decls defined in any scopes
3137 between the scope of the label and the scope of the goto. */
3138 for (scope
= label_vars
->label_bindings
.scope
;
3139 scope
!= g
->goto_bindings
.scope
;
3140 scope
= scope
->outer
)
3142 gcc_assert (scope
!= NULL
);
3143 if (scope
== label_vars
->label_bindings
.scope
)
3144 b
= label_vars
->label_bindings
.bindings_in_scope
;
3146 b
= scope
->bindings
;
3147 for (; b
!= NULL
; b
= b
->prev
)
3149 if (decl_jump_unsafe (b
->decl
))
3150 warn_about_goto (g
->loc
, label
, b
->decl
);
3154 if (g
->goto_bindings
.stmt_exprs
> 0)
3156 error_at (g
->loc
, "jump into statement expression");
3157 inform (DECL_SOURCE_LOCATION (label
), "label %qD defined here",
3162 /* Now that the label is defined, we will issue warnings about
3163 subsequent gotos to this label when we see them. */
3164 VEC_truncate (c_goto_bindings_p
, label_vars
->gotos
, 0);
3165 label_vars
->gotos
= NULL
;
3168 /* Define a label, specifying the location in the source file.
3169 Return the LABEL_DECL node for the label, if the definition is valid.
3170 Otherwise return 0. */
3173 define_label (location_t location
, tree name
)
3175 /* Find any preexisting label with this name. It is an error
3176 if that label has already been defined in this function, or
3177 if there is a containing function with a declared label with
3179 tree label
= I_LABEL_DECL (name
);
3182 && ((DECL_CONTEXT (label
) == current_function_decl
3183 && DECL_INITIAL (label
) != 0)
3184 || (DECL_CONTEXT (label
) != current_function_decl
3185 && C_DECLARED_LABEL_FLAG (label
))))
3187 error_at (location
, "duplicate label %qD", label
);
3188 locate_old_decl (label
);
3191 else if (label
&& DECL_CONTEXT (label
) == current_function_decl
)
3193 struct c_label_vars
*label_vars
= I_LABEL_BINDING (name
)->u
.label
;
3195 /* The label has been used or declared already in this function,
3196 but not defined. Update its location to point to this
3198 DECL_SOURCE_LOCATION (label
) = location
;
3199 set_spot_bindings (&label_vars
->label_bindings
, true);
3201 /* Issue warnings as required about any goto statements from
3202 earlier in the function. */
3203 check_earlier_gotos (label
, label_vars
);
3207 struct c_label_vars
*label_vars
;
3209 /* No label binding for that identifier; make one. */
3210 label
= make_label (location
, name
, true, &label_vars
);
3212 /* Ordinary labels go in the current function scope. */
3213 bind_label (name
, label
, current_function_scope
, label_vars
);
3216 if (!in_system_header
&& lookup_name (name
))
3217 warning_at (location
, OPT_Wtraditional
,
3218 "traditional C lacks a separate namespace "
3219 "for labels, identifier %qE conflicts", name
);
3221 /* Mark label as having been defined. */
3222 DECL_INITIAL (label
) = error_mark_node
;
3226 /* Get the bindings for a new switch statement. This is used to issue
3227 warnings as appropriate for jumps from the switch to case or
3230 struct c_spot_bindings
*
3231 c_get_switch_bindings (void)
3233 struct c_spot_bindings
*switch_bindings
;
3235 switch_bindings
= XNEW (struct c_spot_bindings
);
3236 set_spot_bindings (switch_bindings
, true);
3237 return switch_bindings
;
3241 c_release_switch_bindings (struct c_spot_bindings
*bindings
)
3243 gcc_assert (bindings
->stmt_exprs
== 0 && !bindings
->left_stmt_expr
);
3247 /* This is called at the point of a case or default label to issue
3248 warnings about decls as needed. It returns true if it found an
3249 error, not just a warning. */
3252 c_check_switch_jump_warnings (struct c_spot_bindings
*switch_bindings
,
3253 location_t switch_loc
, location_t case_loc
)
3256 struct c_scope
*scope
;
3259 for (scope
= current_scope
;
3260 scope
!= switch_bindings
->scope
;
3261 scope
= scope
->outer
)
3263 struct c_binding
*b
;
3265 gcc_assert (scope
!= NULL
);
3266 for (b
= scope
->bindings
; b
!= NULL
; b
= b
->prev
)
3268 if (decl_jump_unsafe (b
->decl
))
3270 if (variably_modified_type_p (TREE_TYPE (b
->decl
), NULL_TREE
))
3274 ("switch jumps into scope of identifier with "
3275 "variably modified type"));
3278 warning_at (case_loc
, OPT_Wjump_misses_init
,
3279 "switch jumps over variable initialization");
3280 inform (switch_loc
, "switch starts here");
3281 inform (DECL_SOURCE_LOCATION (b
->decl
), "%qD declared here",
3287 if (switch_bindings
->stmt_exprs
> 0)
3290 error_at (case_loc
, "switch jumps into statement expression");
3291 inform (switch_loc
, "switch starts here");
3297 /* Given NAME, an IDENTIFIER_NODE,
3298 return the structure (or union or enum) definition for that name.
3299 If THISLEVEL_ONLY is nonzero, searches only the current_scope.
3300 CODE says which kind of type the caller wants;
3301 it is RECORD_TYPE or UNION_TYPE or ENUMERAL_TYPE.
3302 If PLOC is not NULL and this returns non-null, it sets *PLOC to the
3303 location where the tag was defined.
3304 If the wrong kind of type is found, an error is reported. */
3307 lookup_tag (enum tree_code code
, tree name
, int thislevel_only
,
3310 struct c_binding
*b
= I_TAG_BINDING (name
);
3316 /* We only care about whether it's in this level if
3317 thislevel_only was set or it might be a type clash. */
3318 if (thislevel_only
|| TREE_CODE (b
->decl
) != code
)
3320 /* For our purposes, a tag in the external scope is the same as
3321 a tag in the file scope. (Primarily relevant to Objective-C
3322 and its builtin structure tags, which get pushed before the
3323 file scope is created.) */
3324 if (B_IN_CURRENT_SCOPE (b
)
3325 || (current_scope
== file_scope
&& B_IN_EXTERNAL_SCOPE (b
)))
3329 if (thislevel_only
&& !thislevel
)
3332 if (TREE_CODE (b
->decl
) != code
)
3334 /* Definition isn't the kind we were looking for. */
3335 pending_invalid_xref
= name
;
3336 pending_invalid_xref_location
= input_location
;
3338 /* If in the same binding level as a declaration as a tag
3339 of a different type, this must not be allowed to
3340 shadow that tag, so give the error immediately.
3341 (For example, "struct foo; union foo;" is invalid.) */
3343 pending_xref_error ();
3352 /* Print an error message now
3353 for a recent invalid struct, union or enum cross reference.
3354 We don't print them immediately because they are not invalid
3355 when used in the `struct foo;' construct for shadowing. */
3358 pending_xref_error (void)
3360 if (pending_invalid_xref
!= 0)
3361 error_at (pending_invalid_xref_location
, "%qE defined as wrong kind of tag",
3362 pending_invalid_xref
);
3363 pending_invalid_xref
= 0;
3367 /* Look up NAME in the current scope and its superiors
3368 in the namespace of variables, functions and typedefs.
3369 Return a ..._DECL node of some kind representing its definition,
3370 or return 0 if it is undefined. */
3373 lookup_name (tree name
)
3375 struct c_binding
*b
= I_SYMBOL_BINDING (name
);
3376 if (b
&& !b
->invisible
)
3381 /* Similar to `lookup_name' but look only at the indicated scope. */
3384 lookup_name_in_scope (tree name
, struct c_scope
*scope
)
3386 struct c_binding
*b
;
3388 for (b
= I_SYMBOL_BINDING (name
); b
; b
= b
->shadowed
)
3389 if (B_IN_SCOPE (b
, scope
))
3394 /* Create the predefined scalar types of C,
3395 and some nodes representing standard constants (0, 1, (void *) 0).
3396 Initialize the global scope.
3397 Make definitions for built-in primitive functions. */
3400 c_init_decl_processing (void)
3402 location_t save_loc
= input_location
;
3404 /* Initialize reserved words for parser. */
3407 current_function_decl
= 0;
3409 gcc_obstack_init (&parser_obstack
);
3411 /* Make the externals scope. */
3413 external_scope
= current_scope
;
3415 /* Declarations from c_common_nodes_and_builtins must not be associated
3416 with this input file, lest we get differences between using and not
3417 using preprocessed headers. */
3418 input_location
= BUILTINS_LOCATION
;
3420 build_common_tree_nodes (flag_signed_char
, false);
3422 c_common_nodes_and_builtins ();
3424 /* In C, comparisons and TRUTH_* expressions have type int. */
3425 truthvalue_type_node
= integer_type_node
;
3426 truthvalue_true_node
= integer_one_node
;
3427 truthvalue_false_node
= integer_zero_node
;
3429 /* Even in C99, which has a real boolean type. */
3430 pushdecl (build_decl (UNKNOWN_LOCATION
, TYPE_DECL
, get_identifier ("_Bool"),
3431 boolean_type_node
));
3433 input_location
= save_loc
;
3435 pedantic_lvalues
= true;
3437 make_fname_decl
= c_make_fname_decl
;
3438 start_fname_decls ();
3441 /* Create the VAR_DECL at LOC for __FUNCTION__ etc. ID is the name to
3442 give the decl, NAME is the initialization string and TYPE_DEP
3443 indicates whether NAME depended on the type of the function. As we
3444 don't yet implement delayed emission of static data, we mark the
3445 decl as emitted so it is not placed in the output. Anything using
3446 it must therefore pull out the STRING_CST initializer directly.
3450 c_make_fname_decl (location_t loc
, tree id
, int type_dep
)
3452 const char *name
= fname_as_string (type_dep
);
3453 tree decl
, type
, init
;
3454 size_t length
= strlen (name
);
3456 type
= build_array_type (char_type_node
,
3457 build_index_type (size_int (length
)));
3458 type
= c_build_qualified_type (type
, TYPE_QUAL_CONST
);
3460 decl
= build_decl (loc
, VAR_DECL
, id
, type
);
3462 TREE_STATIC (decl
) = 1;
3463 TREE_READONLY (decl
) = 1;
3464 DECL_ARTIFICIAL (decl
) = 1;
3466 init
= build_string (length
+ 1, name
);
3467 free (CONST_CAST (char *, name
));
3468 TREE_TYPE (init
) = type
;
3469 DECL_INITIAL (decl
) = init
;
3471 TREE_USED (decl
) = 1;
3473 if (current_function_decl
3474 /* For invalid programs like this:
3477 const char* p = __FUNCTION__;
3479 the __FUNCTION__ is believed to appear in K&R style function
3480 parameter declarator. In that case we still don't have
3482 && (!errorcount
|| current_function_scope
))
3484 DECL_CONTEXT (decl
) = current_function_decl
;
3485 bind (id
, decl
, current_function_scope
,
3486 /*invisible=*/false, /*nested=*/false, UNKNOWN_LOCATION
);
3489 finish_decl (decl
, loc
, init
, NULL_TREE
, NULL_TREE
);
3495 c_builtin_function (tree decl
)
3497 tree type
= TREE_TYPE (decl
);
3498 tree id
= DECL_NAME (decl
);
3500 const char *name
= IDENTIFIER_POINTER (id
);
3501 C_DECL_BUILTIN_PROTOTYPE (decl
) = (TYPE_ARG_TYPES (type
) != 0);
3503 /* Should never be called on a symbol with a preexisting meaning. */
3504 gcc_assert (!I_SYMBOL_BINDING (id
));
3506 bind (id
, decl
, external_scope
, /*invisible=*/true, /*nested=*/false,
3509 /* Builtins in the implementation namespace are made visible without
3510 needing to be explicitly declared. See push_file_scope. */
3511 if (name
[0] == '_' && (name
[1] == '_' || ISUPPER (name
[1])))
3513 TREE_CHAIN (decl
) = visible_builtins
;
3514 visible_builtins
= decl
;
3521 c_builtin_function_ext_scope (tree decl
)
3523 tree type
= TREE_TYPE (decl
);
3524 tree id
= DECL_NAME (decl
);
3526 const char *name
= IDENTIFIER_POINTER (id
);
3527 C_DECL_BUILTIN_PROTOTYPE (decl
) = (TYPE_ARG_TYPES (type
) != 0);
3529 /* Should never be called on a symbol with a preexisting meaning. */
3530 gcc_assert (!I_SYMBOL_BINDING (id
));
3532 bind (id
, decl
, external_scope
, /*invisible=*/false, /*nested=*/false,
3535 /* Builtins in the implementation namespace are made visible without
3536 needing to be explicitly declared. See push_file_scope. */
3537 if (name
[0] == '_' && (name
[1] == '_' || ISUPPER (name
[1])))
3539 TREE_CHAIN (decl
) = visible_builtins
;
3540 visible_builtins
= decl
;
3546 /* Called when a declaration is seen that contains no names to declare.
3547 If its type is a reference to a structure, union or enum inherited
3548 from a containing scope, shadow that tag name for the current scope
3549 with a forward reference.
3550 If its type defines a new named structure or union
3551 or defines an enum, it is valid but we need not do anything here.
3552 Otherwise, it is an error. */
3555 shadow_tag (const struct c_declspecs
*declspecs
)
3557 shadow_tag_warned (declspecs
, 0);
3560 /* WARNED is 1 if we have done a pedwarn, 2 if we have done a warning,
3563 shadow_tag_warned (const struct c_declspecs
*declspecs
, int warned
)
3565 bool found_tag
= false;
3567 if (declspecs
->type
&& !declspecs
->default_int_p
&& !declspecs
->typedef_p
)
3569 tree value
= declspecs
->type
;
3570 enum tree_code code
= TREE_CODE (value
);
3572 if (code
== RECORD_TYPE
|| code
== UNION_TYPE
|| code
== ENUMERAL_TYPE
)
3573 /* Used to test also that TYPE_SIZE (value) != 0.
3574 That caused warning for `struct foo;' at top level in the file. */
3576 tree name
= TYPE_NAME (value
);
3581 if (declspecs
->restrict_p
)
3583 error ("invalid use of %<restrict%>");
3589 if (warned
!= 1 && code
!= ENUMERAL_TYPE
)
3590 /* Empty unnamed enum OK */
3592 pedwarn (input_location
, 0,
3593 "unnamed struct/union that defines no instances");
3597 else if (!declspecs
->tag_defined_p
3598 && declspecs
->storage_class
!= csc_none
)
3601 pedwarn (input_location
, 0,
3602 "empty declaration with storage class specifier "
3603 "does not redeclare tag");
3605 pending_xref_error ();
3607 else if (!declspecs
->tag_defined_p
3608 && (declspecs
->const_p
3609 || declspecs
->volatile_p
3610 || declspecs
->restrict_p
))
3613 pedwarn (input_location
, 0,
3614 "empty declaration with type qualifier "
3615 "does not redeclare tag");
3617 pending_xref_error ();
3621 pending_invalid_xref
= 0;
3622 t
= lookup_tag (code
, name
, 1, NULL
);
3626 t
= make_node (code
);
3627 pushtag (input_location
, name
, t
);
3633 if (warned
!= 1 && !in_system_header
)
3635 pedwarn (input_location
, 0,
3636 "useless type name in empty declaration");
3641 else if (warned
!= 1 && !in_system_header
&& declspecs
->typedef_p
)
3643 pedwarn (input_location
, 0, "useless type name in empty declaration");
3647 pending_invalid_xref
= 0;
3649 if (declspecs
->inline_p
)
3651 error ("%<inline%> in empty declaration");
3655 if (current_scope
== file_scope
&& declspecs
->storage_class
== csc_auto
)
3657 error ("%<auto%> in file-scope empty declaration");
3661 if (current_scope
== file_scope
&& declspecs
->storage_class
== csc_register
)
3663 error ("%<register%> in file-scope empty declaration");
3667 if (!warned
&& !in_system_header
&& declspecs
->storage_class
!= csc_none
)
3669 warning (0, "useless storage class specifier in empty declaration");
3673 if (!warned
&& !in_system_header
&& declspecs
->thread_p
)
3675 warning (0, "useless %<__thread%> in empty declaration");
3679 if (!warned
&& !in_system_header
&& (declspecs
->const_p
3680 || declspecs
->volatile_p
3681 || declspecs
->restrict_p
))
3683 warning (0, "useless type qualifier in empty declaration");
3690 pedwarn (input_location
, 0, "empty declaration");
3695 /* Return the qualifiers from SPECS as a bitwise OR of TYPE_QUAL_*
3696 bits. SPECS represents declaration specifiers that the grammar
3697 only permits to contain type qualifiers and attributes. */
3700 quals_from_declspecs (const struct c_declspecs
*specs
)
3702 int quals
= ((specs
->const_p
? TYPE_QUAL_CONST
: 0)
3703 | (specs
->volatile_p
? TYPE_QUAL_VOLATILE
: 0)
3704 | (specs
->restrict_p
? TYPE_QUAL_RESTRICT
: 0));
3705 gcc_assert (!specs
->type
3706 && !specs
->decl_attr
3707 && specs
->typespec_word
== cts_none
3708 && specs
->storage_class
== csc_none
3709 && !specs
->typedef_p
3710 && !specs
->explicit_signed_p
3711 && !specs
->deprecated_p
3713 && !specs
->long_long_p
3716 && !specs
->unsigned_p
3717 && !specs
->complex_p
3719 && !specs
->thread_p
);
3723 /* Construct an array declarator. LOC is the location of the
3724 beginning of the array (usually the opening brace). EXPR is the
3725 expression inside [], or NULL_TREE. QUALS are the type qualifiers
3726 inside the [] (to be applied to the pointer to which a parameter
3727 array is converted). STATIC_P is true if "static" is inside the
3728 [], false otherwise. VLA_UNSPEC_P is true if the array is [*], a
3729 VLA of unspecified length which is nevertheless a complete type,
3730 false otherwise. The field for the contained declarator is left to
3731 be filled in by set_array_declarator_inner. */
3733 struct c_declarator
*
3734 build_array_declarator (location_t loc
,
3735 tree expr
, struct c_declspecs
*quals
, bool static_p
,
3738 struct c_declarator
*declarator
= XOBNEW (&parser_obstack
,
3739 struct c_declarator
);
3740 declarator
->id_loc
= loc
;
3741 declarator
->kind
= cdk_array
;
3742 declarator
->declarator
= 0;
3743 declarator
->u
.array
.dimen
= expr
;
3746 declarator
->u
.array
.attrs
= quals
->attrs
;
3747 declarator
->u
.array
.quals
= quals_from_declspecs (quals
);
3751 declarator
->u
.array
.attrs
= NULL_TREE
;
3752 declarator
->u
.array
.quals
= 0;
3754 declarator
->u
.array
.static_p
= static_p
;
3755 declarator
->u
.array
.vla_unspec_p
= vla_unspec_p
;
3758 if (static_p
|| quals
!= NULL
)
3759 pedwarn (loc
, OPT_pedantic
,
3760 "ISO C90 does not support %<static%> or type "
3761 "qualifiers in parameter array declarators");
3763 pedwarn (loc
, OPT_pedantic
,
3764 "ISO C90 does not support %<[*]%> array declarators");
3768 if (!current_scope
->parm_flag
)
3771 error_at (loc
, "%<[*]%> not allowed in other than "
3772 "function prototype scope");
3773 declarator
->u
.array
.vla_unspec_p
= false;
3776 current_scope
->had_vla_unspec
= true;
3781 /* Set the contained declarator of an array declarator. DECL is the
3782 declarator, as constructed by build_array_declarator; INNER is what
3783 appears on the left of the []. */
3785 struct c_declarator
*
3786 set_array_declarator_inner (struct c_declarator
*decl
,
3787 struct c_declarator
*inner
)
3789 decl
->declarator
= inner
;
3793 /* INIT is a constructor that forms DECL's initializer. If the final
3794 element initializes a flexible array field, add the size of that
3795 initializer to DECL's size. */
3798 add_flexible_array_elts_to_size (tree decl
, tree init
)
3802 if (VEC_empty (constructor_elt
, CONSTRUCTOR_ELTS (init
)))
3805 elt
= VEC_last (constructor_elt
, CONSTRUCTOR_ELTS (init
))->value
;
3806 type
= TREE_TYPE (elt
);
3807 if (TREE_CODE (type
) == ARRAY_TYPE
3808 && TYPE_SIZE (type
) == NULL_TREE
3809 && TYPE_DOMAIN (type
) != NULL_TREE
3810 && TYPE_MAX_VALUE (TYPE_DOMAIN (type
)) == NULL_TREE
)
3812 complete_array_type (&type
, elt
, false);
3814 = size_binop (PLUS_EXPR
, DECL_SIZE (decl
), TYPE_SIZE (type
));
3815 DECL_SIZE_UNIT (decl
)
3816 = size_binop (PLUS_EXPR
, DECL_SIZE_UNIT (decl
), TYPE_SIZE_UNIT (type
));
3820 /* Decode a "typename", such as "int **", returning a ..._TYPE node.
3821 Set *EXPR, if EXPR not NULL, to any expression to be evaluated
3822 before the type name, and set *EXPR_CONST_OPERANDS, if
3823 EXPR_CONST_OPERANDS not NULL, to indicate whether the type name may
3824 appear in a constant expression. */
3827 groktypename (struct c_type_name
*type_name
, tree
*expr
,
3828 bool *expr_const_operands
)
3831 tree attrs
= type_name
->specs
->attrs
;
3833 type_name
->specs
->attrs
= NULL_TREE
;
3835 type
= grokdeclarator (type_name
->declarator
, type_name
->specs
, TYPENAME
,
3836 false, NULL
, &attrs
, expr
, expr_const_operands
,
3839 /* Apply attributes. */
3840 decl_attributes (&type
, attrs
, 0);
3845 /* Decode a declarator in an ordinary declaration or data definition.
3846 This is called as soon as the type information and variable name
3847 have been parsed, before parsing the initializer if any.
3848 Here we create the ..._DECL node, fill in its type,
3849 and put it on the list of decls for the current context.
3850 The ..._DECL node is returned as the value.
3852 Exception: for arrays where the length is not specified,
3853 the type is left null, to be filled in by `finish_decl'.
3855 Function definitions do not come here; they go to start_function
3856 instead. However, external and forward declarations of functions
3857 do go through here. Structure field declarations are done by
3858 grokfield and not through here. */
3861 start_decl (struct c_declarator
*declarator
, struct c_declspecs
*declspecs
,
3862 bool initialized
, tree attributes
)
3866 tree expr
= NULL_TREE
;
3867 enum deprecated_states deprecated_state
= DEPRECATED_NORMAL
;
3869 /* An object declared as __attribute__((deprecated)) suppresses
3870 warnings of uses of other deprecated items. */
3871 if (lookup_attribute ("deprecated", attributes
))
3872 deprecated_state
= DEPRECATED_SUPPRESS
;
3874 decl
= grokdeclarator (declarator
, declspecs
,
3875 NORMAL
, initialized
, NULL
, &attributes
, &expr
, NULL
,
3883 if (TREE_CODE (decl
) != FUNCTION_DECL
&& MAIN_NAME_P (DECL_NAME (decl
)))
3884 warning (OPT_Wmain
, "%q+D is usually a function", decl
);
3887 /* Is it valid for this decl to have an initializer at all?
3888 If not, set INITIALIZED to zero, which will indirectly
3889 tell 'finish_decl' to ignore the initializer once it is parsed. */
3890 switch (TREE_CODE (decl
))
3893 error ("typedef %qD is initialized (use __typeof__ instead)", decl
);
3898 error ("function %qD is initialized like a variable", decl
);
3903 /* DECL_INITIAL in a PARM_DECL is really DECL_ARG_TYPE. */
3904 error ("parameter %qD is initialized", decl
);
3909 /* Don't allow initializations for incomplete types except for
3910 arrays which might be completed by the initialization. */
3912 /* This can happen if the array size is an undefined macro.
3913 We already gave a warning, so we don't need another one. */
3914 if (TREE_TYPE (decl
) == error_mark_node
)
3916 else if (COMPLETE_TYPE_P (TREE_TYPE (decl
)))
3918 /* A complete type is ok if size is fixed. */
3920 if (TREE_CODE (TYPE_SIZE (TREE_TYPE (decl
))) != INTEGER_CST
3921 || C_DECL_VARIABLE_SIZE (decl
))
3923 error ("variable-sized object may not be initialized");
3927 else if (TREE_CODE (TREE_TYPE (decl
)) != ARRAY_TYPE
)
3929 error ("variable %qD has initializer but incomplete type", decl
);
3932 else if (C_DECL_VARIABLE_SIZE (decl
))
3934 /* Although C99 is unclear about whether incomplete arrays
3935 of VLAs themselves count as VLAs, it does not make
3936 sense to permit them to be initialized given that
3937 ordinary VLAs may not be initialized. */
3938 error ("variable-sized object may not be initialized");
3945 if (current_scope
== file_scope
)
3946 TREE_STATIC (decl
) = 1;
3948 /* Tell 'pushdecl' this is an initialized decl
3949 even though we don't yet have the initializer expression.
3950 Also tell 'finish_decl' it may store the real initializer. */
3951 DECL_INITIAL (decl
) = error_mark_node
;
3954 /* If this is a function declaration, write a record describing it to the
3955 prototypes file (if requested). */
3957 if (TREE_CODE (decl
) == FUNCTION_DECL
)
3958 gen_aux_info_record (decl
, 0, 0, TYPE_ARG_TYPES (TREE_TYPE (decl
)) != 0);
3960 /* ANSI specifies that a tentative definition which is not merged with
3961 a non-tentative definition behaves exactly like a definition with an
3962 initializer equal to zero. (Section 3.7.2)
3964 -fno-common gives strict ANSI behavior, though this tends to break
3965 a large body of code that grew up without this rule.
3967 Thread-local variables are never common, since there's no entrenched
3968 body of code to break, and it allows more efficient variable references
3969 in the presence of dynamic linking. */
3971 if (TREE_CODE (decl
) == VAR_DECL
3973 && TREE_PUBLIC (decl
)
3974 && !DECL_THREAD_LOCAL_P (decl
)
3976 DECL_COMMON (decl
) = 1;
3978 /* Set attributes here so if duplicate decl, will have proper attributes. */
3979 decl_attributes (&decl
, attributes
, 0);
3981 /* Handle gnu_inline attribute. */
3982 if (declspecs
->inline_p
3983 && !flag_gnu89_inline
3984 && TREE_CODE (decl
) == FUNCTION_DECL
3985 && (lookup_attribute ("gnu_inline", DECL_ATTRIBUTES (decl
))
3986 || current_function_decl
))
3988 if (declspecs
->storage_class
== csc_auto
&& current_scope
!= file_scope
)
3990 else if (declspecs
->storage_class
!= csc_static
)
3991 DECL_EXTERNAL (decl
) = !DECL_EXTERNAL (decl
);
3994 if (TREE_CODE (decl
) == FUNCTION_DECL
3995 && targetm
.calls
.promote_prototypes (TREE_TYPE (decl
)))
3997 struct c_declarator
*ce
= declarator
;
3999 if (ce
->kind
== cdk_pointer
)
4000 ce
= declarator
->declarator
;
4001 if (ce
->kind
== cdk_function
)
4003 tree args
= ce
->u
.arg_info
->parms
;
4004 for (; args
; args
= TREE_CHAIN (args
))
4006 tree type
= TREE_TYPE (args
);
4007 if (type
&& INTEGRAL_TYPE_P (type
)
4008 && TYPE_PRECISION (type
) < TYPE_PRECISION (integer_type_node
))
4009 DECL_ARG_TYPE (args
) = integer_type_node
;
4014 if (TREE_CODE (decl
) == FUNCTION_DECL
4015 && DECL_DECLARED_INLINE_P (decl
)
4016 && DECL_UNINLINABLE (decl
)
4017 && lookup_attribute ("noinline", DECL_ATTRIBUTES (decl
)))
4018 warning (OPT_Wattributes
, "inline function %q+D given attribute noinline",
4021 /* C99 6.7.4p3: An inline definition of a function with external
4022 linkage shall not contain a definition of a modifiable object
4023 with static storage duration... */
4024 if (TREE_CODE (decl
) == VAR_DECL
4025 && current_scope
!= file_scope
4026 && TREE_STATIC (decl
)
4027 && !TREE_READONLY (decl
)
4028 && DECL_DECLARED_INLINE_P (current_function_decl
)
4029 && DECL_EXTERNAL (current_function_decl
))
4030 record_inline_static (input_location
, current_function_decl
,
4031 decl
, csi_modifiable
);
4033 /* Add this decl to the current scope.
4034 TEM may equal DECL or it may be a previous decl of the same name. */
4035 tem
= pushdecl (decl
);
4037 if (initialized
&& DECL_EXTERNAL (tem
))
4039 DECL_EXTERNAL (tem
) = 0;
4040 TREE_STATIC (tem
) = 1;
4046 /* Initialize EH if not initialized yet and exceptions are enabled. */
4049 c_maybe_initialize_eh (void)
4051 if (!flag_exceptions
|| c_eh_initialized_p
)
4054 c_eh_initialized_p
= true;
4055 eh_personality_libfunc
4056 = init_one_libfunc (USING_SJLJ_EXCEPTIONS
4057 ? "__gcc_personality_sj0"
4058 : "__gcc_personality_v0");
4059 default_init_unwind_resume_libfunc ();
4060 using_eh_for_cleanups ();
4063 /* Finish processing of a declaration;
4064 install its initial value.
4065 If ORIGTYPE is not NULL_TREE, it is the original type of INIT.
4066 If the length of an array type is not known before,
4067 it must be determined now, from the initial value, or it is an error.
4069 INIT_LOC is the location of the initial value. */
4072 finish_decl (tree decl
, location_t init_loc
, tree init
,
4073 tree origtype
, tree asmspec_tree
)
4076 bool was_incomplete
= (DECL_SIZE (decl
) == 0);
4077 const char *asmspec
= 0;
4079 /* If a name was specified, get the string. */
4080 if ((TREE_CODE (decl
) == FUNCTION_DECL
|| TREE_CODE (decl
) == VAR_DECL
)
4081 && DECL_FILE_SCOPE_P (decl
))
4082 asmspec_tree
= maybe_apply_renaming_pragma (decl
, asmspec_tree
);
4084 asmspec
= TREE_STRING_POINTER (asmspec_tree
);
4086 /* If `start_decl' didn't like having an initialization, ignore it now. */
4087 if (init
!= 0 && DECL_INITIAL (decl
) == 0)
4090 /* Don't crash if parm is initialized. */
4091 if (TREE_CODE (decl
) == PARM_DECL
)
4095 store_init_value (init_loc
, decl
, init
, origtype
);
4097 if (c_dialect_objc () && (TREE_CODE (decl
) == VAR_DECL
4098 || TREE_CODE (decl
) == FUNCTION_DECL
4099 || TREE_CODE (decl
) == FIELD_DECL
))
4100 objc_check_decl (decl
);
4102 type
= TREE_TYPE (decl
);
4104 /* Deduce size of array from initialization, if not already known. */
4105 if (TREE_CODE (type
) == ARRAY_TYPE
4106 && TYPE_DOMAIN (type
) == 0
4107 && TREE_CODE (decl
) != TYPE_DECL
)
4110 = (TREE_STATIC (decl
)
4111 /* Even if pedantic, an external linkage array
4112 may have incomplete type at first. */
4113 ? pedantic
&& !TREE_PUBLIC (decl
)
4114 : !DECL_EXTERNAL (decl
));
4116 = complete_array_type (&TREE_TYPE (decl
), DECL_INITIAL (decl
),
4119 /* Get the completed type made by complete_array_type. */
4120 type
= TREE_TYPE (decl
);
4125 error ("initializer fails to determine size of %q+D", decl
);
4130 error ("array size missing in %q+D", decl
);
4131 /* If a `static' var's size isn't known,
4132 make it extern as well as static, so it does not get
4134 If it is not `static', then do not mark extern;
4135 finish_incomplete_decl will give it a default size
4136 and it will get allocated. */
4137 else if (!pedantic
&& TREE_STATIC (decl
) && !TREE_PUBLIC (decl
))
4138 DECL_EXTERNAL (decl
) = 1;
4142 error ("zero or negative size array %q+D", decl
);
4146 /* For global variables, update the copy of the type that
4147 exists in the binding. */
4148 if (TREE_PUBLIC (decl
))
4150 struct c_binding
*b_ext
= I_SYMBOL_BINDING (DECL_NAME (decl
));
4151 while (b_ext
&& !B_IN_EXTERNAL_SCOPE (b_ext
))
4152 b_ext
= b_ext
->shadowed
;
4156 b_ext
->u
.type
= composite_type (b_ext
->u
.type
, type
);
4158 b_ext
->u
.type
= type
;
4167 if (DECL_INITIAL (decl
))
4168 TREE_TYPE (DECL_INITIAL (decl
)) = type
;
4170 layout_decl (decl
, 0);
4173 if (TREE_CODE (decl
) == VAR_DECL
)
4175 if (init
&& TREE_CODE (init
) == CONSTRUCTOR
)
4176 add_flexible_array_elts_to_size (decl
, init
);
4178 if (DECL_SIZE (decl
) == 0 && TREE_TYPE (decl
) != error_mark_node
4179 && COMPLETE_TYPE_P (TREE_TYPE (decl
)))
4180 layout_decl (decl
, 0);
4182 if (DECL_SIZE (decl
) == 0
4183 /* Don't give an error if we already gave one earlier. */
4184 && TREE_TYPE (decl
) != error_mark_node
4185 && (TREE_STATIC (decl
)
4186 /* A static variable with an incomplete type
4187 is an error if it is initialized.
4188 Also if it is not file scope.
4189 Otherwise, let it through, but if it is not `extern'
4190 then it may cause an error message later. */
4191 ? (DECL_INITIAL (decl
) != 0
4192 || !DECL_FILE_SCOPE_P (decl
))
4193 /* An automatic variable with an incomplete type
4195 : !DECL_EXTERNAL (decl
)))
4197 error ("storage size of %q+D isn%'t known", decl
);
4198 TREE_TYPE (decl
) = error_mark_node
;
4201 if ((DECL_EXTERNAL (decl
) || TREE_STATIC (decl
))
4202 && DECL_SIZE (decl
) != 0)
4204 if (TREE_CODE (DECL_SIZE (decl
)) == INTEGER_CST
)
4205 constant_expression_warning (DECL_SIZE (decl
));
4208 error ("storage size of %q+D isn%'t constant", decl
);
4209 TREE_TYPE (decl
) = error_mark_node
;
4213 if (TREE_USED (type
))
4214 TREE_USED (decl
) = 1;
4217 /* If this is a function and an assembler name is specified, reset DECL_RTL
4218 so we can give it its new name. Also, update built_in_decls if it
4219 was a normal built-in. */
4220 if (TREE_CODE (decl
) == FUNCTION_DECL
&& asmspec
)
4222 if (DECL_BUILT_IN_CLASS (decl
) == BUILT_IN_NORMAL
)
4223 set_builtin_user_assembler_name (decl
, asmspec
);
4224 set_user_assembler_name (decl
, asmspec
);
4227 /* If #pragma weak was used, mark the decl weak now. */
4228 maybe_apply_pragma_weak (decl
);
4230 /* Output the assembler code and/or RTL code for variables and functions,
4231 unless the type is an undefined structure or union.
4232 If not, it will get done when the type is completed. */
4234 if (TREE_CODE (decl
) == VAR_DECL
|| TREE_CODE (decl
) == FUNCTION_DECL
)
4236 /* Determine the ELF visibility. */
4237 if (TREE_PUBLIC (decl
))
4238 c_determine_visibility (decl
);
4240 /* This is a no-op in c-lang.c or something real in objc-act.c. */
4241 if (c_dialect_objc ())
4242 objc_check_decl (decl
);
4246 /* If this is not a static variable, issue a warning.
4247 It doesn't make any sense to give an ASMSPEC for an
4248 ordinary, non-register local variable. Historically,
4249 GCC has accepted -- but ignored -- the ASMSPEC in
4251 if (!DECL_FILE_SCOPE_P (decl
)
4252 && TREE_CODE (decl
) == VAR_DECL
4253 && !C_DECL_REGISTER (decl
)
4254 && !TREE_STATIC (decl
))
4255 warning (0, "ignoring asm-specifier for non-static local "
4256 "variable %q+D", decl
);
4258 set_user_assembler_name (decl
, asmspec
);
4261 if (DECL_FILE_SCOPE_P (decl
))
4263 if (DECL_INITIAL (decl
) == NULL_TREE
4264 || DECL_INITIAL (decl
) == error_mark_node
)
4265 /* Don't output anything
4266 when a tentative file-scope definition is seen.
4267 But at end of compilation, do output code for them. */
4268 DECL_DEFER_OUTPUT (decl
) = 1;
4269 rest_of_decl_compilation (decl
, true, 0);
4273 /* In conjunction with an ASMSPEC, the `register'
4274 keyword indicates that we should place the variable
4275 in a particular register. */
4276 if (asmspec
&& C_DECL_REGISTER (decl
))
4278 DECL_HARD_REGISTER (decl
) = 1;
4279 /* This cannot be done for a structure with volatile
4280 fields, on which DECL_REGISTER will have been
4282 if (!DECL_REGISTER (decl
))
4283 error ("cannot put object with volatile field into register");
4286 if (TREE_CODE (decl
) != FUNCTION_DECL
)
4288 /* If we're building a variable sized type, and we might be
4289 reachable other than via the top of the current binding
4290 level, then create a new BIND_EXPR so that we deallocate
4291 the object at the right time. */
4292 /* Note that DECL_SIZE can be null due to errors. */
4293 if (DECL_SIZE (decl
)
4294 && !TREE_CONSTANT (DECL_SIZE (decl
))
4295 && STATEMENT_LIST_HAS_LABEL (cur_stmt_list
))
4298 bind
= build3 (BIND_EXPR
, void_type_node
, NULL
, NULL
, NULL
);
4299 TREE_SIDE_EFFECTS (bind
) = 1;
4301 BIND_EXPR_BODY (bind
) = push_stmt_list ();
4303 add_stmt (build_stmt (DECL_SOURCE_LOCATION (decl
),
4309 if (!DECL_FILE_SCOPE_P (decl
))
4311 /* Recompute the RTL of a local array now
4312 if it used to be an incomplete type. */
4314 && !TREE_STATIC (decl
) && !DECL_EXTERNAL (decl
))
4316 /* If we used it already as memory, it must stay in memory. */
4317 TREE_ADDRESSABLE (decl
) = TREE_USED (decl
);
4318 /* If it's still incomplete now, no init will save it. */
4319 if (DECL_SIZE (decl
) == 0)
4320 DECL_INITIAL (decl
) = 0;
4325 if (TREE_CODE (decl
) == TYPE_DECL
)
4327 if (!DECL_FILE_SCOPE_P (decl
)
4328 && variably_modified_type_p (TREE_TYPE (decl
), NULL_TREE
))
4329 add_stmt (build_stmt (DECL_SOURCE_LOCATION (decl
), DECL_EXPR
, decl
));
4331 rest_of_decl_compilation (decl
, DECL_FILE_SCOPE_P (decl
), 0);
4334 /* At the end of a declaration, throw away any variable type sizes
4335 of types defined inside that declaration. There is no use
4336 computing them in the following function definition. */
4337 if (current_scope
== file_scope
)
4338 get_pending_sizes ();
4340 /* Install a cleanup (aka destructor) if one was given. */
4341 if (TREE_CODE (decl
) == VAR_DECL
&& !TREE_STATIC (decl
))
4343 tree attr
= lookup_attribute ("cleanup", DECL_ATTRIBUTES (decl
));
4346 tree cleanup_id
= TREE_VALUE (TREE_VALUE (attr
));
4347 tree cleanup_decl
= lookup_name (cleanup_id
);
4351 /* Build "cleanup(&decl)" for the destructor. */
4352 cleanup
= build_unary_op (input_location
, ADDR_EXPR
, decl
, 0);
4353 vec
= VEC_alloc (tree
, gc
, 1);
4354 VEC_quick_push (tree
, vec
, cleanup
);
4355 cleanup
= build_function_call_vec (DECL_SOURCE_LOCATION (decl
),
4356 cleanup_decl
, vec
, NULL
);
4357 VEC_free (tree
, gc
, vec
);
4359 /* Don't warn about decl unused; the cleanup uses it. */
4360 TREE_USED (decl
) = 1;
4361 TREE_USED (cleanup_decl
) = 1;
4363 /* Initialize EH, if we've been told to do so. */
4364 c_maybe_initialize_eh ();
4366 push_cleanup (decl
, cleanup
, false);
4371 && TREE_CODE (decl
) == VAR_DECL
4372 && TREE_READONLY (decl
)
4373 && !DECL_EXTERNAL (decl
)
4374 && DECL_INITIAL (decl
) == NULL_TREE
)
4375 warning_at (DECL_SOURCE_LOCATION (decl
), OPT_Wc___compat
,
4376 "uninitialized const %qD is invalid in C++", decl
);
4379 /* Given a parsed parameter declaration, decode it into a PARM_DECL. */
4382 grokparm (const struct c_parm
*parm
)
4384 tree attrs
= parm
->attrs
;
4385 tree decl
= grokdeclarator (parm
->declarator
, parm
->specs
, PARM
, false,
4386 NULL
, &attrs
, NULL
, NULL
, DEPRECATED_NORMAL
);
4388 decl_attributes (&decl
, attrs
, 0);
4393 /* Given a parsed parameter declaration, decode it into a PARM_DECL
4394 and push that on the current scope. */
4397 push_parm_decl (const struct c_parm
*parm
)
4399 tree attrs
= parm
->attrs
;
4402 decl
= grokdeclarator (parm
->declarator
, parm
->specs
, PARM
, false, NULL
,
4403 &attrs
, NULL
, NULL
, DEPRECATED_NORMAL
);
4404 decl_attributes (&decl
, attrs
, 0);
4406 decl
= pushdecl (decl
);
4408 finish_decl (decl
, input_location
, NULL_TREE
, NULL_TREE
, NULL_TREE
);
4411 /* Mark all the parameter declarations to date as forward decls.
4412 Also diagnose use of this extension. */
4415 mark_forward_parm_decls (void)
4417 struct c_binding
*b
;
4419 if (pedantic
&& !current_scope
->warned_forward_parm_decls
)
4421 pedwarn (input_location
, OPT_pedantic
,
4422 "ISO C forbids forward parameter declarations");
4423 current_scope
->warned_forward_parm_decls
= true;
4426 for (b
= current_scope
->bindings
; b
; b
= b
->prev
)
4427 if (TREE_CODE (b
->decl
) == PARM_DECL
)
4428 TREE_ASM_WRITTEN (b
->decl
) = 1;
4431 /* Build a COMPOUND_LITERAL_EXPR. TYPE is the type given in the compound
4432 literal, which may be an incomplete array type completed by the
4433 initializer; INIT is a CONSTRUCTOR at LOC that initializes the compound
4434 literal. NON_CONST is true if the initializers contain something
4435 that cannot occur in a constant expression. */
4438 build_compound_literal (location_t loc
, tree type
, tree init
, bool non_const
)
4440 /* We do not use start_decl here because we have a type, not a declarator;
4441 and do not use finish_decl because the decl should be stored inside
4442 the COMPOUND_LITERAL_EXPR rather than added elsewhere as a DECL_EXPR. */
4447 if (type
== error_mark_node
)
4448 return error_mark_node
;
4450 decl
= build_decl (loc
, VAR_DECL
, NULL_TREE
, type
);
4451 DECL_EXTERNAL (decl
) = 0;
4452 TREE_PUBLIC (decl
) = 0;
4453 TREE_STATIC (decl
) = (current_scope
== file_scope
);
4454 DECL_CONTEXT (decl
) = current_function_decl
;
4455 TREE_USED (decl
) = 1;
4456 TREE_TYPE (decl
) = type
;
4457 TREE_READONLY (decl
) = TYPE_READONLY (type
);
4458 store_init_value (loc
, decl
, init
, NULL_TREE
);
4460 if (TREE_CODE (type
) == ARRAY_TYPE
&& !COMPLETE_TYPE_P (type
))
4462 int failure
= complete_array_type (&TREE_TYPE (decl
),
4463 DECL_INITIAL (decl
), true);
4464 gcc_assert (!failure
);
4466 type
= TREE_TYPE (decl
);
4467 TREE_TYPE (DECL_INITIAL (decl
)) = type
;
4470 if (type
== error_mark_node
|| !COMPLETE_TYPE_P (type
))
4471 return error_mark_node
;
4473 stmt
= build_stmt (DECL_SOURCE_LOCATION (decl
), DECL_EXPR
, decl
);
4474 complit
= build1 (COMPOUND_LITERAL_EXPR
, type
, stmt
);
4475 TREE_SIDE_EFFECTS (complit
) = 1;
4477 layout_decl (decl
, 0);
4479 if (TREE_STATIC (decl
))
4481 /* This decl needs a name for the assembler output. */
4482 set_compound_literal_name (decl
);
4483 DECL_DEFER_OUTPUT (decl
) = 1;
4484 DECL_COMDAT (decl
) = 1;
4485 DECL_ARTIFICIAL (decl
) = 1;
4486 DECL_IGNORED_P (decl
) = 1;
4488 rest_of_decl_compilation (decl
, 1, 0);
4493 complit
= build2 (C_MAYBE_CONST_EXPR
, type
, NULL
, complit
);
4494 C_MAYBE_CONST_EXPR_NON_CONST (complit
) = 1;
4500 /* Check the type of a compound literal. Here we just check that it
4501 is valid for C++. */
4504 check_compound_literal_type (location_t loc
, struct c_type_name
*type_name
)
4506 if (warn_cxx_compat
&& type_name
->specs
->tag_defined_p
)
4507 warning_at (loc
, OPT_Wc___compat
,
4508 "defining a type in a compound literal is invalid in C++");
4511 /* Determine whether TYPE is a structure with a flexible array member,
4512 or a union containing such a structure (possibly recursively). */
4515 flexible_array_type_p (tree type
)
4518 switch (TREE_CODE (type
))
4521 x
= TYPE_FIELDS (type
);
4524 while (TREE_CHAIN (x
) != NULL_TREE
)
4526 if (TREE_CODE (TREE_TYPE (x
)) == ARRAY_TYPE
4527 && TYPE_SIZE (TREE_TYPE (x
)) == NULL_TREE
4528 && TYPE_DOMAIN (TREE_TYPE (x
)) != NULL_TREE
4529 && TYPE_MAX_VALUE (TYPE_DOMAIN (TREE_TYPE (x
))) == NULL_TREE
)
4533 for (x
= TYPE_FIELDS (type
); x
!= NULL_TREE
; x
= TREE_CHAIN (x
))
4535 if (flexible_array_type_p (TREE_TYPE (x
)))
4544 /* Performs sanity checks on the TYPE and WIDTH of the bit-field NAME,
4545 replacing with appropriate values if they are invalid. */
4547 check_bitfield_type_and_width (tree
*type
, tree
*width
, tree orig_name
)
4550 unsigned int max_width
;
4551 unsigned HOST_WIDE_INT w
;
4552 const char *name
= (orig_name
4553 ? identifier_to_locale (IDENTIFIER_POINTER (orig_name
))
4554 : _("<anonymous>"));
4556 /* Detect and ignore out of range field width and process valid
4558 if (!INTEGRAL_TYPE_P (TREE_TYPE (*width
))
4559 || TREE_CODE (*width
) != INTEGER_CST
)
4561 error ("bit-field %qs width not an integer constant", name
);
4562 *width
= integer_one_node
;
4566 constant_expression_warning (*width
);
4567 if (tree_int_cst_sgn (*width
) < 0)
4569 error ("negative width in bit-field %qs", name
);
4570 *width
= integer_one_node
;
4572 else if (integer_zerop (*width
) && orig_name
)
4574 error ("zero width for bit-field %qs", name
);
4575 *width
= integer_one_node
;
4579 /* Detect invalid bit-field type. */
4580 if (TREE_CODE (*type
) != INTEGER_TYPE
4581 && TREE_CODE (*type
) != BOOLEAN_TYPE
4582 && TREE_CODE (*type
) != ENUMERAL_TYPE
)
4584 error ("bit-field %qs has invalid type", name
);
4585 *type
= unsigned_type_node
;
4588 type_mv
= TYPE_MAIN_VARIANT (*type
);
4589 if (!in_system_header
4590 && type_mv
!= integer_type_node
4591 && type_mv
!= unsigned_type_node
4592 && type_mv
!= boolean_type_node
)
4593 pedwarn (input_location
, OPT_pedantic
,
4594 "type of bit-field %qs is a GCC extension", name
);
4596 max_width
= TYPE_PRECISION (*type
);
4598 if (0 < compare_tree_int (*width
, max_width
))
4600 error ("width of %qs exceeds its type", name
);
4602 *width
= build_int_cst (NULL_TREE
, w
);
4605 w
= tree_low_cst (*width
, 1);
4607 if (TREE_CODE (*type
) == ENUMERAL_TYPE
)
4609 struct lang_type
*lt
= TYPE_LANG_SPECIFIC (*type
);
4611 || w
< tree_int_cst_min_precision (lt
->enum_min
, TYPE_UNSIGNED (*type
))
4612 || w
< tree_int_cst_min_precision (lt
->enum_max
, TYPE_UNSIGNED (*type
)))
4613 warning (0, "%qs is narrower than values of its type", name
);
4619 /* Print warning about variable length array if necessary. */
4622 warn_variable_length_array (tree name
, tree size
)
4624 int const_size
= TREE_CONSTANT (size
);
4626 if (!flag_isoc99
&& pedantic
&& warn_vla
!= 0)
4631 pedwarn (input_location
, OPT_Wvla
,
4632 "ISO C90 forbids array %qE whose size "
4633 "can%'t be evaluated",
4636 pedwarn (input_location
, OPT_Wvla
, "ISO C90 forbids array whose size "
4637 "can%'t be evaluated");
4642 pedwarn (input_location
, OPT_Wvla
,
4643 "ISO C90 forbids variable length array %qE",
4646 pedwarn (input_location
, OPT_Wvla
, "ISO C90 forbids variable length array");
4649 else if (warn_vla
> 0)
4655 "the size of array %qE can"
4656 "%'t be evaluated", name
);
4659 "the size of array can %'t be evaluated");
4665 "variable length array %qE is used",
4669 "variable length array is used");
4674 /* Given a size SIZE that may not be a constant, return a SAVE_EXPR to
4675 serve as the actual size-expression for a type or decl. This is
4676 like variable_size in stor-layout.c, but we make global_bindings_p
4677 return negative to avoid calls to that function from outside the
4678 front end resulting in errors at file scope, then call this version
4679 instead from front-end code. */
4682 c_variable_size (tree size
)
4686 if (TREE_CONSTANT (size
))
4689 size
= save_expr (size
);
4691 save
= skip_simple_arithmetic (size
);
4693 if (cfun
&& cfun
->dont_save_pending_sizes_p
)
4696 if (!global_bindings_p ())
4697 put_pending_size (save
);
4702 /* Given declspecs and a declarator,
4703 determine the name and type of the object declared
4704 and construct a ..._DECL node for it.
4705 (In one case we can return a ..._TYPE node instead.
4706 For invalid input we sometimes return 0.)
4708 DECLSPECS is a c_declspecs structure for the declaration specifiers.
4710 DECL_CONTEXT says which syntactic context this declaration is in:
4711 NORMAL for most contexts. Make a VAR_DECL or FUNCTION_DECL or TYPE_DECL.
4712 FUNCDEF for a function definition. Like NORMAL but a few different
4713 error messages in each case. Return value may be zero meaning
4714 this definition is too screwy to try to parse.
4715 PARM for a parameter declaration (either within a function prototype
4716 or before a function body). Make a PARM_DECL, or return void_type_node.
4717 TYPENAME if for a typename (in a cast or sizeof).
4718 Don't make a DECL node; just return the ..._TYPE node.
4719 FIELD for a struct or union field; make a FIELD_DECL.
4720 INITIALIZED is true if the decl has an initializer.
4721 WIDTH is non-NULL for bit-fields, and is a pointer to an INTEGER_CST node
4722 representing the width of the bit-field.
4723 DECL_ATTRS points to the list of attributes that should be added to this
4724 decl. Any nested attributes that belong on the decl itself will be
4726 If EXPR is not NULL, any expressions that need to be evaluated as
4727 part of evaluating variably modified types will be stored in *EXPR.
4728 If EXPR_CONST_OPERANDS is not NULL, *EXPR_CONST_OPERANDS will be
4729 set to indicate whether operands in *EXPR can be used in constant
4731 DEPRECATED_STATE is a deprecated_states value indicating whether
4732 deprecation warnings should be suppressed.
4734 In the TYPENAME case, DECLARATOR is really an absolute declarator.
4735 It may also be so in the PARM case, for a prototype where the
4736 argument type is specified but not the name.
4738 This function is where the complicated C meanings of `static'
4739 and `extern' are interpreted. */
4742 grokdeclarator (const struct c_declarator
*declarator
,
4743 struct c_declspecs
*declspecs
,
4744 enum decl_context decl_context
, bool initialized
, tree
*width
,
4745 tree
*decl_attrs
, tree
*expr
, bool *expr_const_operands
,
4746 enum deprecated_states deprecated_state
)
4748 tree type
= declspecs
->type
;
4749 bool threadp
= declspecs
->thread_p
;
4750 enum c_storage_class storage_class
= declspecs
->storage_class
;
4754 int type_quals
= TYPE_UNQUALIFIED
;
4755 tree name
= NULL_TREE
;
4756 bool funcdef_flag
= false;
4757 bool funcdef_syntax
= false;
4758 bool size_varies
= false;
4759 tree decl_attr
= declspecs
->decl_attr
;
4760 int array_ptr_quals
= TYPE_UNQUALIFIED
;
4761 tree array_ptr_attrs
= NULL_TREE
;
4762 int array_parm_static
= 0;
4763 bool array_parm_vla_unspec_p
= false;
4764 tree returned_attrs
= NULL_TREE
;
4765 bool bitfield
= width
!= NULL
;
4767 struct c_arg_info
*arg_info
= 0;
4768 location_t loc
= UNKNOWN_LOCATION
;
4771 bool expr_const_operands_dummy
;
4775 if (expr_const_operands
== NULL
)
4776 expr_const_operands
= &expr_const_operands_dummy
;
4778 *expr
= declspecs
->expr
;
4779 *expr_const_operands
= declspecs
->expr_const_operands
;
4781 if (decl_context
== FUNCDEF
)
4782 funcdef_flag
= true, decl_context
= NORMAL
;
4784 /* Look inside a declarator for the name being declared
4785 and get it as an IDENTIFIER_NODE, for an error message. */
4787 const struct c_declarator
*decl
= declarator
;
4798 funcdef_syntax
= (decl
->kind
== cdk_function
);
4799 decl
= decl
->declarator
;
4803 decl
= decl
->declarator
;
4818 gcc_assert (decl_context
== PARM
4819 || decl_context
== TYPENAME
4820 || (decl_context
== FIELD
4821 && declarator
->kind
== cdk_id
));
4822 gcc_assert (!initialized
);
4826 /* A function definition's declarator must have the form of
4827 a function declarator. */
4829 if (funcdef_flag
&& !funcdef_syntax
)
4832 /* If this looks like a function definition, make it one,
4833 even if it occurs where parms are expected.
4834 Then store_parm_decls will reject it and not use it as a parm. */
4835 if (decl_context
== NORMAL
&& !funcdef_flag
&& current_scope
->parm_flag
)
4836 decl_context
= PARM
;
4838 if (declspecs
->deprecated_p
&& deprecated_state
!= DEPRECATED_SUPPRESS
)
4839 warn_deprecated_use (declspecs
->type
, declspecs
->decl_attr
);
4841 if ((decl_context
== NORMAL
|| decl_context
== FIELD
)
4842 && current_scope
== file_scope
4843 && variably_modified_type_p (type
, NULL_TREE
))
4846 error_at (loc
, "variably modified %qE at file scope", name
);
4848 error_at (loc
, "variably modified field at file scope");
4849 type
= integer_type_node
;
4852 size_varies
= C_TYPE_VARIABLE_SIZE (type
) != 0;
4854 /* Diagnose defaulting to "int". */
4856 if (declspecs
->default_int_p
&& !in_system_header
)
4858 /* Issue a warning if this is an ISO C 99 program or if
4859 -Wreturn-type and this is a function, or if -Wimplicit;
4860 prefer the former warning since it is more explicit. */
4861 if ((warn_implicit_int
|| warn_return_type
|| flag_isoc99
)
4863 warn_about_return_type
= 1;
4867 pedwarn_c99 (loc
, flag_isoc99
? 0 : OPT_Wimplicit_int
,
4868 "type defaults to %<int%> in declaration of %qE",
4871 pedwarn_c99 (input_location
, flag_isoc99
? 0 : OPT_Wimplicit_int
,
4872 "type defaults to %<int%> in type name");
4876 /* Adjust the type if a bit-field is being declared,
4877 -funsigned-bitfields applied and the type is not explicitly
4879 if (bitfield
&& !flag_signed_bitfields
&& !declspecs
->explicit_signed_p
4880 && TREE_CODE (type
) == INTEGER_TYPE
)
4881 type
= unsigned_type_for (type
);
4883 /* Figure out the type qualifiers for the declaration. There are
4884 two ways a declaration can become qualified. One is something
4885 like `const int i' where the `const' is explicit. Another is
4886 something like `typedef const int CI; CI i' where the type of the
4887 declaration contains the `const'. A third possibility is that
4888 there is a type qualifier on the element type of a typedefed
4889 array type, in which case we should extract that qualifier so
4890 that c_apply_type_quals_to_decl receives the full list of
4891 qualifiers to work with (C90 is not entirely clear about whether
4892 duplicate qualifiers should be diagnosed in this case, but it
4893 seems most appropriate to do so). */
4894 element_type
= strip_array_types (type
);
4895 constp
= declspecs
->const_p
+ TYPE_READONLY (element_type
);
4896 restrictp
= declspecs
->restrict_p
+ TYPE_RESTRICT (element_type
);
4897 volatilep
= declspecs
->volatile_p
+ TYPE_VOLATILE (element_type
);
4898 if (pedantic
&& !flag_isoc99
)
4901 pedwarn (loc
, OPT_pedantic
, "duplicate %<const%>");
4903 pedwarn (loc
, OPT_pedantic
, "duplicate %<restrict%>");
4905 pedwarn (loc
, OPT_pedantic
, "duplicate %<volatile%>");
4907 if (!flag_gen_aux_info
&& (TYPE_QUALS (element_type
)))
4908 type
= TYPE_MAIN_VARIANT (type
);
4909 type_quals
= ((constp
? TYPE_QUAL_CONST
: 0)
4910 | (restrictp
? TYPE_QUAL_RESTRICT
: 0)
4911 | (volatilep
? TYPE_QUAL_VOLATILE
: 0));
4913 /* Warn about storage classes that are invalid for certain
4914 kinds of declarations (parameters, typenames, etc.). */
4918 || storage_class
== csc_auto
4919 || storage_class
== csc_register
4920 || storage_class
== csc_typedef
))
4922 if (storage_class
== csc_auto
)
4924 (current_scope
== file_scope
) ? 0 : OPT_pedantic
,
4925 "function definition declared %<auto%>");
4926 if (storage_class
== csc_register
)
4927 error_at (loc
, "function definition declared %<register%>");
4928 if (storage_class
== csc_typedef
)
4929 error_at (loc
, "function definition declared %<typedef%>");
4931 error_at (loc
, "function definition declared %<__thread%>");
4933 if (storage_class
== csc_auto
4934 || storage_class
== csc_register
4935 || storage_class
== csc_typedef
)
4936 storage_class
= csc_none
;
4938 else if (decl_context
!= NORMAL
&& (storage_class
!= csc_none
|| threadp
))
4940 if (decl_context
== PARM
&& storage_class
== csc_register
)
4944 switch (decl_context
)
4948 error_at (loc
, "storage class specified for structure "
4951 error_at (loc
, "storage class specified for structure field");
4955 error_at (loc
, "storage class specified for parameter %qE",
4958 error_at (loc
, "storage class specified for unnamed parameter");
4961 error_at (loc
, "storage class specified for typename");
4964 storage_class
= csc_none
;
4968 else if (storage_class
== csc_extern
4972 /* 'extern' with initialization is invalid if not at file scope. */
4973 if (current_scope
== file_scope
)
4975 /* It is fine to have 'extern const' when compiling at C
4976 and C++ intersection. */
4977 if (!(warn_cxx_compat
&& constp
))
4978 warning_at (loc
, 0, "%qE initialized and declared %<extern%>",
4982 error_at (loc
, "%qE has both %<extern%> and initializer", name
);
4984 else if (current_scope
== file_scope
)
4986 if (storage_class
== csc_auto
)
4987 error_at (loc
, "file-scope declaration of %qE specifies %<auto%>",
4989 if (pedantic
&& storage_class
== csc_register
)
4990 pedwarn (input_location
, OPT_pedantic
,
4991 "file-scope declaration of %qE specifies %<register%>", name
);
4995 if (storage_class
== csc_extern
&& funcdef_flag
)
4996 error_at (loc
, "nested function %qE declared %<extern%>", name
);
4997 else if (threadp
&& storage_class
== csc_none
)
4999 error_at (loc
, "function-scope %qE implicitly auto and declared "
5006 /* Now figure out the structure of the declarator proper.
5007 Descend through it, creating more complex types, until we reach
5008 the declared identifier (or NULL_TREE, in an absolute declarator).
5009 At each stage we maintain an unqualified version of the type
5010 together with any qualifiers that should be applied to it with
5011 c_build_qualified_type; this way, array types including
5012 multidimensional array types are first built up in unqualified
5013 form and then the qualified form is created with
5014 TYPE_MAIN_VARIANT pointing to the unqualified form. */
5016 while (declarator
&& declarator
->kind
!= cdk_id
)
5018 if (type
== error_mark_node
)
5020 declarator
= declarator
->declarator
;
5024 /* Each level of DECLARATOR is either a cdk_array (for ...[..]),
5025 a cdk_pointer (for *...),
5026 a cdk_function (for ...(...)),
5027 a cdk_attrs (for nested attributes),
5028 or a cdk_id (for the name being declared
5029 or the place in an absolute declarator
5030 where the name was omitted).
5031 For the last case, we have just exited the loop.
5033 At this point, TYPE is the type of elements of an array,
5034 or for a function to return, or for a pointer to point to.
5035 After this sequence of ifs, TYPE is the type of the
5036 array or function or pointer, and DECLARATOR has had its
5037 outermost layer removed. */
5039 if (array_ptr_quals
!= TYPE_UNQUALIFIED
5040 || array_ptr_attrs
!= NULL_TREE
5041 || array_parm_static
)
5043 /* Only the innermost declarator (making a parameter be of
5044 array type which is converted to pointer type)
5045 may have static or type qualifiers. */
5046 error_at (loc
, "static or type qualifiers in non-parameter array declarator");
5047 array_ptr_quals
= TYPE_UNQUALIFIED
;
5048 array_ptr_attrs
= NULL_TREE
;
5049 array_parm_static
= 0;
5052 switch (declarator
->kind
)
5056 /* A declarator with embedded attributes. */
5057 tree attrs
= declarator
->u
.attrs
;
5058 const struct c_declarator
*inner_decl
;
5060 declarator
= declarator
->declarator
;
5061 inner_decl
= declarator
;
5062 while (inner_decl
->kind
== cdk_attrs
)
5063 inner_decl
= inner_decl
->declarator
;
5064 if (inner_decl
->kind
== cdk_id
)
5065 attr_flags
|= (int) ATTR_FLAG_DECL_NEXT
;
5066 else if (inner_decl
->kind
== cdk_function
)
5067 attr_flags
|= (int) ATTR_FLAG_FUNCTION_NEXT
;
5068 else if (inner_decl
->kind
== cdk_array
)
5069 attr_flags
|= (int) ATTR_FLAG_ARRAY_NEXT
;
5070 returned_attrs
= decl_attributes (&type
,
5071 chainon (returned_attrs
, attrs
),
5077 tree itype
= NULL_TREE
;
5078 tree size
= declarator
->u
.array
.dimen
;
5079 /* The index is a signed object `sizetype' bits wide. */
5080 tree index_type
= c_common_signed_type (sizetype
);
5082 array_ptr_quals
= declarator
->u
.array
.quals
;
5083 array_ptr_attrs
= declarator
->u
.array
.attrs
;
5084 array_parm_static
= declarator
->u
.array
.static_p
;
5085 array_parm_vla_unspec_p
= declarator
->u
.array
.vla_unspec_p
;
5087 declarator
= declarator
->declarator
;
5089 /* Check for some types that there cannot be arrays of. */
5091 if (VOID_TYPE_P (type
))
5094 error_at (loc
, "declaration of %qE as array of voids", name
);
5096 error_at (loc
, "declaration of type name as array of voids");
5097 type
= error_mark_node
;
5100 if (TREE_CODE (type
) == FUNCTION_TYPE
)
5103 error_at (loc
, "declaration of %qE as array of functions",
5106 error_at (loc
, "declaration of type name as array of "
5108 type
= error_mark_node
;
5111 if (pedantic
&& !in_system_header
&& flexible_array_type_p (type
))
5112 pedwarn (loc
, OPT_pedantic
,
5113 "invalid use of structure with flexible array member");
5115 if (size
== error_mark_node
)
5116 type
= error_mark_node
;
5118 if (type
== error_mark_node
)
5121 /* If size was specified, set ITYPE to a range-type for
5122 that size. Otherwise, ITYPE remains null. finish_decl
5123 may figure it out from an initial value. */
5127 bool size_maybe_const
= true;
5128 bool size_int_const
= (TREE_CODE (size
) == INTEGER_CST
5129 && !TREE_OVERFLOW (size
));
5130 bool this_size_varies
= false;
5132 /* Strip NON_LVALUE_EXPRs since we aren't using as an
5134 STRIP_TYPE_NOPS (size
);
5136 if (!INTEGRAL_TYPE_P (TREE_TYPE (size
)))
5139 error_at (loc
, "size of array %qE has non-integer type",
5143 "size of unnamed array has non-integer type");
5144 size
= integer_one_node
;
5147 size
= c_fully_fold (size
, false, &size_maybe_const
);
5149 if (pedantic
&& size_maybe_const
&& integer_zerop (size
))
5152 pedwarn (loc
, OPT_pedantic
,
5153 "ISO C forbids zero-size array %qE", name
);
5155 pedwarn (loc
, OPT_pedantic
,
5156 "ISO C forbids zero-size array");
5159 if (TREE_CODE (size
) == INTEGER_CST
&& size_maybe_const
)
5161 constant_expression_warning (size
);
5162 if (tree_int_cst_sgn (size
) < 0)
5165 error_at (loc
, "size of array %qE is negative", name
);
5167 error_at (loc
, "size of unnamed array is negative");
5168 size
= integer_one_node
;
5170 /* Handle a size folded to an integer constant but
5171 not an integer constant expression. */
5172 if (!size_int_const
)
5174 /* If this is a file scope declaration of an
5175 ordinary identifier, this is invalid code;
5176 diagnosing it here and not subsequently
5177 treating the type as variable-length avoids
5178 more confusing diagnostics later. */
5179 if ((decl_context
== NORMAL
|| decl_context
== FIELD
)
5180 && current_scope
== file_scope
)
5181 pedwarn (input_location
, 0,
5182 "variably modified %qE at file scope",
5185 this_size_varies
= size_varies
= true;
5186 warn_variable_length_array (name
, size
);
5189 else if ((decl_context
== NORMAL
|| decl_context
== FIELD
)
5190 && current_scope
== file_scope
)
5192 error_at (loc
, "variably modified %qE at file scope", name
);
5193 size
= integer_one_node
;
5197 /* Make sure the array size remains visibly
5198 nonconstant even if it is (eg) a const variable
5199 with known value. */
5200 this_size_varies
= size_varies
= true;
5201 warn_variable_length_array (name
, size
);
5204 if (integer_zerop (size
) && !this_size_varies
)
5206 /* A zero-length array cannot be represented with
5207 an unsigned index type, which is what we'll
5208 get with build_index_type. Create an
5209 open-ended range instead. */
5210 itype
= build_range_type (sizetype
, size
, NULL_TREE
);
5214 /* Arrange for the SAVE_EXPR on the inside of the
5215 MINUS_EXPR, which allows the -1 to get folded
5216 with the +1 that happens when building TYPE_SIZE. */
5218 size
= c_variable_size (size
);
5219 if (this_size_varies
&& TREE_CODE (size
) == INTEGER_CST
)
5220 size
= build2 (COMPOUND_EXPR
, TREE_TYPE (size
),
5221 integer_zero_node
, size
);
5223 /* Compute the maximum valid index, that is, size
5224 - 1. Do the calculation in index_type, so that
5225 if it is a variable the computations will be
5226 done in the proper mode. */
5227 itype
= fold_build2_loc (loc
, MINUS_EXPR
, index_type
,
5228 convert (index_type
, size
),
5229 convert (index_type
,
5232 /* If that overflowed, the array is too big. ???
5233 While a size of INT_MAX+1 technically shouldn't
5234 cause an overflow (because we subtract 1), the
5235 overflow is recorded during the conversion to
5236 index_type, before the subtraction. Handling
5237 this case seems like an unnecessary
5239 if (TREE_CODE (itype
) == INTEGER_CST
5240 && TREE_OVERFLOW (itype
))
5243 error_at (loc
, "size of array %qE is too large",
5246 error_at (loc
, "size of unnamed array is too large");
5247 type
= error_mark_node
;
5251 itype
= build_index_type (itype
);
5253 if (this_size_varies
)
5256 *expr
= build2 (COMPOUND_EXPR
, TREE_TYPE (size
),
5260 *expr_const_operands
&= size_maybe_const
;
5263 else if (decl_context
== FIELD
)
5265 bool flexible_array_member
= false;
5266 if (array_parm_vla_unspec_p
)
5267 /* Field names can in fact have function prototype
5268 scope so [*] is disallowed here through making
5269 the field variably modified, not through being
5270 something other than a declaration with function
5275 const struct c_declarator
*t
= declarator
;
5276 while (t
->kind
== cdk_attrs
)
5278 flexible_array_member
= (t
->kind
== cdk_id
);
5280 if (flexible_array_member
5281 && pedantic
&& !flag_isoc99
&& !in_system_header
)
5282 pedwarn (loc
, OPT_pedantic
,
5283 "ISO C90 does not support flexible array members");
5285 /* ISO C99 Flexible array members are effectively
5286 identical to GCC's zero-length array extension. */
5287 if (flexible_array_member
|| array_parm_vla_unspec_p
)
5288 itype
= build_range_type (sizetype
, size_zero_node
,
5291 else if (decl_context
== PARM
)
5293 if (array_parm_vla_unspec_p
)
5295 itype
= build_range_type (sizetype
, size_zero_node
, NULL_TREE
);
5299 else if (decl_context
== TYPENAME
)
5301 if (array_parm_vla_unspec_p
)
5304 warning (0, "%<[*]%> not in a declaration");
5305 /* We use this to avoid messing up with incomplete
5306 array types of the same type, that would
5307 otherwise be modified below. */
5308 itype
= build_range_type (sizetype
, size_zero_node
,
5314 /* Complain about arrays of incomplete types. */
5315 if (!COMPLETE_TYPE_P (type
))
5317 error_at (loc
, "array type has incomplete element type");
5318 type
= error_mark_node
;
5321 /* When itype is NULL, a shared incomplete array type is
5322 returned for all array of a given type. Elsewhere we
5323 make sure we don't complete that type before copying
5324 it, but here we want to make sure we don't ever
5325 modify the shared type, so we gcc_assert (itype)
5327 type
= build_array_type (type
, itype
);
5329 if (type
!= error_mark_node
)
5333 /* It is ok to modify type here even if itype is
5334 NULL: if size_varies, we're in a
5335 multi-dimensional array and the inner type has
5336 variable size, so the enclosing shared array type
5338 if (size
&& TREE_CODE (size
) == INTEGER_CST
)
5340 = build_distinct_type_copy (TYPE_MAIN_VARIANT (type
));
5341 C_TYPE_VARIABLE_SIZE (type
) = 1;
5344 /* The GCC extension for zero-length arrays differs from
5345 ISO flexible array members in that sizeof yields
5347 if (size
&& integer_zerop (size
))
5350 TYPE_SIZE (type
) = bitsize_zero_node
;
5351 TYPE_SIZE_UNIT (type
) = size_zero_node
;
5353 if (array_parm_vla_unspec_p
)
5356 /* The type is complete. C99 6.7.5.2p4 */
5357 TYPE_SIZE (type
) = bitsize_zero_node
;
5358 TYPE_SIZE_UNIT (type
) = size_zero_node
;
5362 if (decl_context
!= PARM
5363 && (array_ptr_quals
!= TYPE_UNQUALIFIED
5364 || array_ptr_attrs
!= NULL_TREE
5365 || array_parm_static
))
5367 error_at (loc
, "static or type qualifiers in non-parameter array declarator");
5368 array_ptr_quals
= TYPE_UNQUALIFIED
;
5369 array_ptr_attrs
= NULL_TREE
;
5370 array_parm_static
= 0;
5376 /* Say it's a definition only for the declarator closest
5377 to the identifier, apart possibly from some
5379 bool really_funcdef
= false;
5383 const struct c_declarator
*t
= declarator
->declarator
;
5384 while (t
->kind
== cdk_attrs
)
5386 really_funcdef
= (t
->kind
== cdk_id
);
5389 /* Declaring a function type. Make sure we have a valid
5390 type for the function to return. */
5391 if (type
== error_mark_node
)
5394 size_varies
= false;
5396 /* Warn about some types functions can't return. */
5397 if (TREE_CODE (type
) == FUNCTION_TYPE
)
5400 error_at (loc
, "%qE declared as function returning a "
5403 error_at (loc
, "type name declared as function "
5404 "returning a function");
5405 type
= integer_type_node
;
5407 if (TREE_CODE (type
) == ARRAY_TYPE
)
5410 error_at (loc
, "%qE declared as function returning an array",
5413 error_at (loc
, "type name declared as function returning "
5415 type
= integer_type_node
;
5417 errmsg
= targetm
.invalid_return_type (type
);
5421 type
= integer_type_node
;
5424 /* Construct the function type and go to the next
5425 inner layer of declarator. */
5426 arg_info
= declarator
->u
.arg_info
;
5427 arg_types
= grokparms (arg_info
, really_funcdef
);
5429 put_pending_sizes (arg_info
->pending_sizes
);
5431 /* Type qualifiers before the return type of the function
5432 qualify the return type, not the function type. */
5435 /* Type qualifiers on a function return type are
5436 normally permitted by the standard but have no
5437 effect, so give a warning at -Wreturn-type.
5438 Qualifiers on a void return type are banned on
5439 function definitions in ISO C; GCC used to used
5440 them for noreturn functions. */
5441 if (VOID_TYPE_P (type
) && really_funcdef
)
5443 "function definition has qualified void return type");
5445 warning_at (loc
, OPT_Wignored_qualifiers
,
5446 "type qualifiers ignored on function return type");
5448 type
= c_build_qualified_type (type
, type_quals
);
5450 type_quals
= TYPE_UNQUALIFIED
;
5452 type
= build_function_type (type
, arg_types
);
5453 declarator
= declarator
->declarator
;
5455 /* Set the TYPE_CONTEXTs for each tagged type which is local to
5456 the formal parameter list of this FUNCTION_TYPE to point to
5457 the FUNCTION_TYPE node itself. */
5461 for (link
= arg_info
->tags
;
5463 link
= TREE_CHAIN (link
))
5464 TYPE_CONTEXT (TREE_VALUE (link
)) = type
;
5470 /* Merge any constancy or volatility into the target type
5473 if (pedantic
&& TREE_CODE (type
) == FUNCTION_TYPE
5475 pedwarn (loc
, OPT_pedantic
,
5476 "ISO C forbids qualified function types");
5478 type
= c_build_qualified_type (type
, type_quals
);
5479 size_varies
= false;
5481 /* When the pointed-to type involves components of variable size,
5482 care must be taken to ensure that the size evaluation code is
5483 emitted early enough to dominate all the possible later uses
5484 and late enough for the variables on which it depends to have
5487 This is expected to happen automatically when the pointed-to
5488 type has a name/declaration of it's own, but special attention
5489 is required if the type is anonymous.
5491 We handle the NORMAL and FIELD contexts here by attaching an
5492 artificial TYPE_DECL to such pointed-to type. This forces the
5493 sizes evaluation at a safe point and ensures it is not deferred
5494 until e.g. within a deeper conditional context.
5496 We expect nothing to be needed here for PARM or TYPENAME.
5497 Pushing a TYPE_DECL at this point for TYPENAME would actually
5498 be incorrect, as we might be in the middle of an expression
5499 with side effects on the pointed-to type size "arguments" prior
5500 to the pointer declaration point and the fake TYPE_DECL in the
5501 enclosing context would force the size evaluation prior to the
5504 if (!TYPE_NAME (type
)
5505 && (decl_context
== NORMAL
|| decl_context
== FIELD
)
5506 && variably_modified_type_p (type
, NULL_TREE
))
5508 tree decl
= build_decl (loc
, TYPE_DECL
, NULL_TREE
, type
);
5509 DECL_ARTIFICIAL (decl
) = 1;
5511 finish_decl (decl
, loc
, NULL_TREE
, NULL_TREE
, NULL_TREE
);
5512 TYPE_NAME (type
) = decl
;
5515 type
= build_pointer_type (type
);
5517 /* Process type qualifiers (such as const or volatile)
5518 that were given inside the `*'. */
5519 type_quals
= declarator
->u
.pointer_quals
;
5521 declarator
= declarator
->declarator
;
5528 *decl_attrs
= chainon (returned_attrs
, *decl_attrs
);
5530 /* Now TYPE has the actual type, apart from any qualifiers in
5533 /* Check the type and width of a bit-field. */
5535 check_bitfield_type_and_width (&type
, width
, name
);
5537 /* Did array size calculations overflow? */
5539 if (TREE_CODE (type
) == ARRAY_TYPE
5540 && COMPLETE_TYPE_P (type
)
5541 && TREE_CODE (TYPE_SIZE_UNIT (type
)) == INTEGER_CST
5542 && TREE_OVERFLOW (TYPE_SIZE_UNIT (type
)))
5545 error_at (loc
, "size of array %qE is too large", name
);
5547 error_at (loc
, "size of unnamed array is too large");
5548 /* If we proceed with the array type as it is, we'll eventually
5549 crash in tree_low_cst(). */
5550 type
= error_mark_node
;
5553 /* If this is declaring a typedef name, return a TYPE_DECL. */
5555 if (storage_class
== csc_typedef
)
5558 if (pedantic
&& TREE_CODE (type
) == FUNCTION_TYPE
5560 pedwarn (loc
, OPT_pedantic
,
5561 "ISO C forbids qualified function types");
5563 type
= c_build_qualified_type (type
, type_quals
);
5564 decl
= build_decl (declarator
->id_loc
,
5565 TYPE_DECL
, declarator
->u
.id
, type
);
5566 if (declspecs
->explicit_signed_p
)
5567 C_TYPEDEF_EXPLICITLY_SIGNED (decl
) = 1;
5568 if (declspecs
->inline_p
)
5569 pedwarn (loc
, 0,"typedef %q+D declared %<inline%>", decl
);
5571 if (warn_cxx_compat
&& declarator
->u
.id
!= NULL_TREE
)
5573 struct c_binding
*b
= I_TAG_BINDING (declarator
->u
.id
);
5576 && b
->decl
!= NULL_TREE
5577 && (B_IN_CURRENT_SCOPE (b
)
5578 || (current_scope
== file_scope
&& B_IN_EXTERNAL_SCOPE (b
)))
5579 && TYPE_MAIN_VARIANT (b
->decl
) != TYPE_MAIN_VARIANT (type
))
5581 warning_at (declarator
->id_loc
, OPT_Wc___compat
,
5582 ("using %qD as both a typedef and a tag is "
5585 if (b
->locus
!= UNKNOWN_LOCATION
)
5586 inform (b
->locus
, "originally defined here");
5593 /* If this is a type name (such as, in a cast or sizeof),
5594 compute the type and return it now. */
5596 if (decl_context
== TYPENAME
)
5598 /* Note that the grammar rejects storage classes in typenames
5600 gcc_assert (storage_class
== csc_none
&& !threadp
5601 && !declspecs
->inline_p
);
5602 if (pedantic
&& TREE_CODE (type
) == FUNCTION_TYPE
5604 pedwarn (loc
, OPT_pedantic
,
5605 "ISO C forbids const or volatile function types");
5607 type
= c_build_qualified_type (type
, type_quals
);
5611 if (pedantic
&& decl_context
== FIELD
5612 && variably_modified_type_p (type
, NULL_TREE
))
5615 pedwarn (loc
, OPT_pedantic
, "a member of a structure or union cannot "
5616 "have a variably modified type");
5619 /* Aside from typedefs and type names (handle above),
5620 `void' at top level (not within pointer)
5621 is allowed only in public variables.
5622 We don't complain about parms either, but that is because
5623 a better error message can be made later. */
5625 if (VOID_TYPE_P (type
) && decl_context
!= PARM
5626 && !((decl_context
!= FIELD
&& TREE_CODE (type
) != FUNCTION_TYPE
)
5627 && (storage_class
== csc_extern
5628 || (current_scope
== file_scope
5629 && !(storage_class
== csc_static
5630 || storage_class
== csc_register
)))))
5632 error_at (loc
, "variable or field %qE declared void", name
);
5633 type
= integer_type_node
;
5636 /* Now create the decl, which may be a VAR_DECL, a PARM_DECL
5637 or a FUNCTION_DECL, depending on DECL_CONTEXT and TYPE. */
5642 if (decl_context
== PARM
)
5646 /* A parameter declared as an array of T is really a pointer to T.
5647 One declared as a function is really a pointer to a function. */
5649 if (TREE_CODE (type
) == ARRAY_TYPE
)
5651 /* Transfer const-ness of array into that of type pointed to. */
5652 type
= TREE_TYPE (type
);
5654 type
= c_build_qualified_type (type
, type_quals
);
5655 type
= build_pointer_type (type
);
5656 type_quals
= array_ptr_quals
;
5658 type
= c_build_qualified_type (type
, type_quals
);
5660 /* We don't yet implement attributes in this context. */
5661 if (array_ptr_attrs
!= NULL_TREE
)
5662 warning_at (loc
, OPT_Wattributes
,
5663 "attributes in parameter array declarator ignored");
5665 size_varies
= false;
5667 else if (TREE_CODE (type
) == FUNCTION_TYPE
)
5670 pedwarn (loc
, OPT_pedantic
,
5671 "ISO C forbids qualified function types");
5673 type
= c_build_qualified_type (type
, type_quals
);
5674 type
= build_pointer_type (type
);
5675 type_quals
= TYPE_UNQUALIFIED
;
5677 else if (type_quals
)
5678 type
= c_build_qualified_type (type
, type_quals
);
5680 decl
= build_decl (declarator
->id_loc
,
5681 PARM_DECL
, declarator
->u
.id
, type
);
5683 C_DECL_VARIABLE_SIZE (decl
) = 1;
5685 /* Compute the type actually passed in the parmlist,
5686 for the case where there is no prototype.
5687 (For example, shorts and chars are passed as ints.)
5688 When there is a prototype, this is overridden later. */
5690 if (type
== error_mark_node
)
5691 promoted_type
= type
;
5693 promoted_type
= c_type_promotes_to (type
);
5695 DECL_ARG_TYPE (decl
) = promoted_type
;
5696 if (declspecs
->inline_p
)
5697 pedwarn (loc
, 0, "parameter %q+D declared %<inline%>", decl
);
5699 else if (decl_context
== FIELD
)
5701 /* Note that the grammar rejects storage classes in typenames
5703 gcc_assert (storage_class
== csc_none
&& !threadp
5704 && !declspecs
->inline_p
);
5706 /* Structure field. It may not be a function. */
5708 if (TREE_CODE (type
) == FUNCTION_TYPE
)
5710 error_at (loc
, "field %qE declared as a function", name
);
5711 type
= build_pointer_type (type
);
5713 else if (TREE_CODE (type
) != ERROR_MARK
5714 && !COMPLETE_OR_UNBOUND_ARRAY_TYPE_P (type
))
5717 error_at (loc
, "field %qE has incomplete type", name
);
5719 error_at (loc
, "unnamed field has incomplete type");
5720 type
= error_mark_node
;
5722 type
= c_build_qualified_type (type
, type_quals
);
5723 decl
= build_decl (declarator
->id_loc
,
5724 FIELD_DECL
, declarator
->u
.id
, type
);
5725 DECL_NONADDRESSABLE_P (decl
) = bitfield
;
5726 if (bitfield
&& !declarator
->u
.id
)
5727 TREE_NO_WARNING (decl
) = 1;
5730 C_DECL_VARIABLE_SIZE (decl
) = 1;
5732 else if (TREE_CODE (type
) == FUNCTION_TYPE
)
5734 if (storage_class
== csc_register
|| threadp
)
5736 error_at (loc
, "invalid storage class for function %qE", name
);
5738 else if (current_scope
!= file_scope
)
5740 /* Function declaration not at file scope. Storage
5741 classes other than `extern' are not allowed, C99
5742 6.7.1p5, and `extern' makes no difference. However,
5743 GCC allows 'auto', perhaps with 'inline', to support
5744 nested functions. */
5745 if (storage_class
== csc_auto
)
5746 pedwarn (loc
, OPT_pedantic
,
5747 "invalid storage class for function %qE", name
);
5748 else if (storage_class
== csc_static
)
5750 error_at (loc
, "invalid storage class for function %qE", name
);
5752 storage_class
= declspecs
->storage_class
= csc_none
;
5758 decl
= build_decl (declarator
->id_loc
,
5759 FUNCTION_DECL
, declarator
->u
.id
, type
);
5760 decl
= build_decl_attribute_variant (decl
, decl_attr
);
5762 if (pedantic
&& type_quals
&& !DECL_IN_SYSTEM_HEADER (decl
))
5763 pedwarn (loc
, OPT_pedantic
,
5764 "ISO C forbids qualified function types");
5766 /* GNU C interprets a volatile-qualified function type to indicate
5767 that the function does not return. */
5768 if ((type_quals
& TYPE_QUAL_VOLATILE
)
5769 && !VOID_TYPE_P (TREE_TYPE (TREE_TYPE (decl
))))
5770 warning_at (loc
, 0, "%<noreturn%> function returns non-void value");
5772 /* Every function declaration is an external reference
5773 (DECL_EXTERNAL) except for those which are not at file
5774 scope and are explicitly declared "auto". This is
5775 forbidden by standard C (C99 6.7.1p5) and is interpreted by
5776 GCC to signify a forward declaration of a nested function. */
5777 if (storage_class
== csc_auto
&& current_scope
!= file_scope
)
5778 DECL_EXTERNAL (decl
) = 0;
5779 /* In C99, a function which is declared 'inline' with 'extern'
5780 is not an external reference (which is confusing). It
5781 means that the later definition of the function must be output
5782 in this file, C99 6.7.4p6. In GNU C89, a function declared
5783 'extern inline' is an external reference. */
5784 else if (declspecs
->inline_p
&& storage_class
!= csc_static
)
5785 DECL_EXTERNAL (decl
) = ((storage_class
== csc_extern
)
5786 == flag_gnu89_inline
);
5788 DECL_EXTERNAL (decl
) = !initialized
;
5790 /* Record absence of global scope for `static' or `auto'. */
5792 = !(storage_class
== csc_static
|| storage_class
== csc_auto
);
5794 /* For a function definition, record the argument information
5795 block where store_parm_decls will look for it. */
5797 current_function_arg_info
= arg_info
;
5799 if (declspecs
->default_int_p
)
5800 C_FUNCTION_IMPLICIT_INT (decl
) = 1;
5802 /* Record presence of `inline', if it is reasonable. */
5803 if (flag_hosted
&& MAIN_NAME_P (declarator
->u
.id
))
5805 if (declspecs
->inline_p
)
5806 pedwarn (loc
, 0, "cannot inline function %<main%>");
5808 else if (declspecs
->inline_p
)
5809 /* Record that the function is declared `inline'. */
5810 DECL_DECLARED_INLINE_P (decl
) = 1;
5814 /* It's a variable. */
5815 /* An uninitialized decl with `extern' is a reference. */
5816 int extern_ref
= !initialized
&& storage_class
== csc_extern
;
5818 type
= c_build_qualified_type (type
, type_quals
);
5820 /* C99 6.2.2p7: It is invalid (compile-time undefined
5821 behavior) to create an 'extern' declaration for a
5822 variable if there is a global declaration that is
5823 'static' and the global declaration is not visible.
5824 (If the static declaration _is_ currently visible,
5825 the 'extern' declaration is taken to refer to that decl.) */
5826 if (extern_ref
&& current_scope
!= file_scope
)
5828 tree global_decl
= identifier_global_value (declarator
->u
.id
);
5829 tree visible_decl
= lookup_name (declarator
->u
.id
);
5832 && global_decl
!= visible_decl
5833 && TREE_CODE (global_decl
) == VAR_DECL
5834 && !TREE_PUBLIC (global_decl
))
5835 error_at (loc
, "variable previously declared %<static%> "
5836 "redeclared %<extern%>");
5839 decl
= build_decl (declarator
->id_loc
,
5840 VAR_DECL
, declarator
->u
.id
, type
);
5842 C_DECL_VARIABLE_SIZE (decl
) = 1;
5844 if (declspecs
->inline_p
)
5845 pedwarn (loc
, 0, "variable %q+D declared %<inline%>", decl
);
5847 /* At file scope, an initialized extern declaration may follow
5848 a static declaration. In that case, DECL_EXTERNAL will be
5849 reset later in start_decl. */
5850 DECL_EXTERNAL (decl
) = (storage_class
== csc_extern
);
5852 /* At file scope, the presence of a `static' or `register' storage
5853 class specifier, or the absence of all storage class specifiers
5854 makes this declaration a definition (perhaps tentative). Also,
5855 the absence of `static' makes it public. */
5856 if (current_scope
== file_scope
)
5858 TREE_PUBLIC (decl
) = storage_class
!= csc_static
;
5859 TREE_STATIC (decl
) = !extern_ref
;
5861 /* Not at file scope, only `static' makes a static definition. */
5864 TREE_STATIC (decl
) = (storage_class
== csc_static
);
5865 TREE_PUBLIC (decl
) = extern_ref
;
5869 DECL_TLS_MODEL (decl
) = decl_default_tls_model (decl
);
5872 if ((storage_class
== csc_extern
5873 || (storage_class
== csc_none
5874 && TREE_CODE (type
) == FUNCTION_TYPE
5876 && variably_modified_type_p (type
, NULL_TREE
))
5879 if (TREE_CODE (type
) == FUNCTION_TYPE
)
5880 error_at (loc
, "non-nested function with variably modified type");
5882 error_at (loc
, "object with variably modified type must have "
5886 /* Record `register' declaration for warnings on &
5887 and in case doing stupid register allocation. */
5889 if (storage_class
== csc_register
)
5891 C_DECL_REGISTER (decl
) = 1;
5892 DECL_REGISTER (decl
) = 1;
5895 /* Record constancy and volatility. */
5896 c_apply_type_quals_to_decl (type_quals
, decl
);
5898 /* If a type has volatile components, it should be stored in memory.
5899 Otherwise, the fact that those components are volatile
5900 will be ignored, and would even crash the compiler.
5901 Of course, this only makes sense on VAR,PARM, and RESULT decl's. */
5902 if (C_TYPE_FIELDS_VOLATILE (TREE_TYPE (decl
))
5903 && (TREE_CODE (decl
) == VAR_DECL
|| TREE_CODE (decl
) == PARM_DECL
5904 || TREE_CODE (decl
) == RESULT_DECL
))
5906 /* It is not an error for a structure with volatile fields to
5907 be declared register, but reset DECL_REGISTER since it
5908 cannot actually go in a register. */
5909 int was_reg
= C_DECL_REGISTER (decl
);
5910 C_DECL_REGISTER (decl
) = 0;
5911 DECL_REGISTER (decl
) = 0;
5912 c_mark_addressable (decl
);
5913 C_DECL_REGISTER (decl
) = was_reg
;
5916 /* This is the earliest point at which we might know the assembler
5917 name of a variable. Thus, if it's known before this, die horribly. */
5918 gcc_assert (!DECL_ASSEMBLER_NAME_SET_P (decl
));
5921 && TREE_CODE (decl
) == VAR_DECL
5922 && TREE_PUBLIC (decl
)
5923 && TREE_STATIC (decl
)
5924 && (TREE_CODE (TREE_TYPE (decl
)) == RECORD_TYPE
5925 || TREE_CODE (TREE_TYPE (decl
)) == UNION_TYPE
5926 || TREE_CODE (TREE_TYPE (decl
)) == ENUMERAL_TYPE
)
5927 && TYPE_NAME (TREE_TYPE (decl
)) == NULL_TREE
)
5928 warning_at (DECL_SOURCE_LOCATION (decl
), OPT_Wc___compat
,
5929 ("non-local variable %qD with anonymous type is "
5930 "questionable in C++"),
5937 /* Decode the parameter-list info for a function type or function definition.
5938 The argument is the value returned by `get_parm_info' (or made in c-parse.c
5939 if there is an identifier list instead of a parameter decl list).
5940 These two functions are separate because when a function returns
5941 or receives functions then each is called multiple times but the order
5942 of calls is different. The last call to `grokparms' is always the one
5943 that contains the formal parameter names of a function definition.
5945 Return a list of arg types to use in the FUNCTION_TYPE for this function.
5947 FUNCDEF_FLAG is true for a function definition, false for
5948 a mere declaration. A nonempty identifier-list gets an error message
5949 when FUNCDEF_FLAG is false. */
5952 grokparms (struct c_arg_info
*arg_info
, bool funcdef_flag
)
5954 tree arg_types
= arg_info
->types
;
5956 if (funcdef_flag
&& arg_info
->had_vla_unspec
)
5958 /* A function definition isn't function prototype scope C99 6.2.1p4. */
5960 error ("%<[*]%> not allowed in other than function prototype scope");
5963 if (arg_types
== 0 && !funcdef_flag
&& !in_system_header
)
5964 warning (OPT_Wstrict_prototypes
,
5965 "function declaration isn%'t a prototype");
5967 if (arg_types
== error_mark_node
)
5968 return 0; /* don't set TYPE_ARG_TYPES in this case */
5970 else if (arg_types
&& TREE_CODE (TREE_VALUE (arg_types
)) == IDENTIFIER_NODE
)
5973 pedwarn (input_location
, 0, "parameter names (without types) in function declaration");
5975 arg_info
->parms
= arg_info
->types
;
5976 arg_info
->types
= 0;
5981 tree parm
, type
, typelt
;
5982 unsigned int parmno
;
5985 /* If there is a parameter of incomplete type in a definition,
5986 this is an error. In a declaration this is valid, and a
5987 struct or union type may be completed later, before any calls
5988 or definition of the function. In the case where the tag was
5989 first declared within the parameter list, a warning has
5990 already been given. If a parameter has void type, then
5991 however the function cannot be defined or called, so
5994 for (parm
= arg_info
->parms
, typelt
= arg_types
, parmno
= 1;
5996 parm
= TREE_CHAIN (parm
), typelt
= TREE_CHAIN (typelt
), parmno
++)
5998 type
= TREE_VALUE (typelt
);
5999 if (type
== error_mark_node
)
6002 if (!COMPLETE_TYPE_P (type
))
6006 if (DECL_NAME (parm
))
6007 error_at (input_location
,
6008 "parameter %u (%q+D) has incomplete type",
6011 error_at (DECL_SOURCE_LOCATION (parm
),
6012 "parameter %u has incomplete type",
6015 TREE_VALUE (typelt
) = error_mark_node
;
6016 TREE_TYPE (parm
) = error_mark_node
;
6018 else if (VOID_TYPE_P (type
))
6020 if (DECL_NAME (parm
))
6021 warning_at (input_location
, 0,
6022 "parameter %u (%q+D) has void type",
6025 warning_at (DECL_SOURCE_LOCATION (parm
), 0,
6026 "parameter %u has void type",
6031 errmsg
= targetm
.invalid_parameter_type (type
);
6035 TREE_VALUE (typelt
) = error_mark_node
;
6036 TREE_TYPE (parm
) = error_mark_node
;
6039 if (DECL_NAME (parm
) && TREE_USED (parm
))
6040 warn_if_shadowing (parm
);
6046 /* Take apart the current scope and return a c_arg_info structure with
6047 info on a parameter list just parsed.
6049 This structure is later fed to 'grokparms' and 'store_parm_decls'.
6051 ELLIPSIS being true means the argument list ended in '...' so don't
6052 append a sentinel (void_list_node) to the end of the type-list. */
6055 get_parm_info (bool ellipsis
)
6057 struct c_binding
*b
= current_scope
->bindings
;
6058 struct c_arg_info
*arg_info
= XOBNEW (&parser_obstack
,
6065 static bool explained_incomplete_types
= false;
6066 bool gave_void_only_once_err
= false;
6068 arg_info
->parms
= 0;
6070 arg_info
->types
= 0;
6071 arg_info
->others
= 0;
6072 arg_info
->pending_sizes
= 0;
6073 arg_info
->had_vla_unspec
= current_scope
->had_vla_unspec
;
6075 /* The bindings in this scope must not get put into a block.
6076 We will take care of deleting the binding nodes. */
6077 current_scope
->bindings
= 0;
6079 /* This function is only called if there was *something* on the
6083 /* A parameter list consisting solely of 'void' indicates that the
6084 function takes no arguments. But if the 'void' is qualified
6085 (by 'const' or 'volatile'), or has a storage class specifier
6086 ('register'), then the behavior is undefined; issue an error.
6087 Typedefs for 'void' are OK (see DR#157). */
6088 if (b
->prev
== 0 /* one binding */
6089 && TREE_CODE (b
->decl
) == PARM_DECL
/* which is a parameter */
6090 && !DECL_NAME (b
->decl
) /* anonymous */
6091 && VOID_TYPE_P (TREE_TYPE (b
->decl
))) /* of void type */
6093 if (TREE_THIS_VOLATILE (b
->decl
)
6094 || TREE_READONLY (b
->decl
)
6095 || C_DECL_REGISTER (b
->decl
))
6096 error ("%<void%> as only parameter may not be qualified");
6098 /* There cannot be an ellipsis. */
6100 error ("%<void%> must be the only parameter");
6102 arg_info
->types
= void_list_node
;
6107 types
= void_list_node
;
6109 /* Break up the bindings list into parms, tags, types, and others;
6110 apply sanity checks; purge the name-to-decl bindings. */
6113 tree decl
= b
->decl
;
6114 tree type
= TREE_TYPE (decl
);
6115 const char *keyword
;
6117 switch (TREE_CODE (decl
))
6122 gcc_assert (I_SYMBOL_BINDING (b
->id
) == b
);
6123 I_SYMBOL_BINDING (b
->id
) = b
->shadowed
;
6126 /* Check for forward decls that never got their actual decl. */
6127 if (TREE_ASM_WRITTEN (decl
))
6128 error ("parameter %q+D has just a forward declaration", decl
);
6129 /* Check for (..., void, ...) and issue an error. */
6130 else if (VOID_TYPE_P (type
) && !DECL_NAME (decl
))
6132 if (!gave_void_only_once_err
)
6134 error ("%<void%> must be the only parameter");
6135 gave_void_only_once_err
= true;
6140 /* Valid parameter, add it to the list. */
6141 TREE_CHAIN (decl
) = parms
;
6144 /* Since there is a prototype, args are passed in their
6145 declared types. The back end may override this later. */
6146 DECL_ARG_TYPE (decl
) = type
;
6147 types
= tree_cons (0, type
, types
);
6151 case ENUMERAL_TYPE
: keyword
= "enum"; goto tag
;
6152 case UNION_TYPE
: keyword
= "union"; goto tag
;
6153 case RECORD_TYPE
: keyword
= "struct"; goto tag
;
6155 /* Types may not have tag-names, in which case the type
6156 appears in the bindings list with b->id NULL. */
6159 gcc_assert (I_TAG_BINDING (b
->id
) == b
);
6160 I_TAG_BINDING (b
->id
) = b
->shadowed
;
6163 /* Warn about any struct, union or enum tags defined in a
6164 parameter list. The scope of such types is limited to
6165 the parameter list, which is rarely if ever desirable
6166 (it's impossible to call such a function with type-
6167 correct arguments). An anonymous union parm type is
6168 meaningful as a GNU extension, so don't warn for that. */
6169 if (TREE_CODE (decl
) != UNION_TYPE
|| b
->id
!= 0)
6172 /* The %s will be one of 'struct', 'union', or 'enum'. */
6173 warning (0, "%<%s %E%> declared inside parameter list",
6176 /* The %s will be one of 'struct', 'union', or 'enum'. */
6177 warning (0, "anonymous %s declared inside parameter list",
6180 if (!explained_incomplete_types
)
6182 warning (0, "its scope is only this definition or declaration,"
6183 " which is probably not what you want");
6184 explained_incomplete_types
= true;
6188 tags
= tree_cons (b
->id
, decl
, tags
);
6194 /* CONST_DECLs appear here when we have an embedded enum,
6195 and TYPE_DECLs appear here when we have an embedded struct
6196 or union. No warnings for this - we already warned about the
6197 type itself. FUNCTION_DECLs appear when there is an implicit
6198 function declaration in the parameter list. */
6200 TREE_CHAIN (decl
) = others
;
6205 /* error_mark_node appears here when we have an undeclared
6206 variable. Just throw it away. */
6209 gcc_assert (I_SYMBOL_BINDING (b
->id
) == b
);
6210 I_SYMBOL_BINDING (b
->id
) = b
->shadowed
;
6214 /* Other things that might be encountered. */
6221 b
= free_binding_and_advance (b
);
6224 arg_info
->parms
= parms
;
6225 arg_info
->tags
= tags
;
6226 arg_info
->types
= types
;
6227 arg_info
->others
= others
;
6228 arg_info
->pending_sizes
= get_pending_sizes ();
6232 /* Get the struct, enum or union (CODE says which) with tag NAME.
6233 Define the tag as a forward-reference with location LOC if it is
6234 not defined. Return a c_typespec structure for the type
6238 parser_xref_tag (location_t loc
, enum tree_code code
, tree name
)
6240 struct c_typespec ret
;
6244 ret
.expr
= NULL_TREE
;
6245 ret
.expr_const_operands
= true;
6247 /* If a cross reference is requested, look up the type
6248 already defined for this tag and return it. */
6250 ref
= lookup_tag (code
, name
, 0, &refloc
);
6251 /* If this is the right type of tag, return what we found.
6252 (This reference will be shadowed by shadow_tag later if appropriate.)
6253 If this is the wrong type of tag, do not return it. If it was the
6254 wrong type in the same scope, we will have had an error
6255 message already; if in a different scope and declaring
6256 a name, pending_xref_error will give an error message; but if in a
6257 different scope and not declaring a name, this tag should
6258 shadow the previous declaration of a different type of tag, and
6259 this would not work properly if we return the reference found.
6260 (For example, with "struct foo" in an outer scope, "union foo;"
6261 must shadow that tag with a new one of union type.) */
6262 ret
.kind
= (ref
? ctsk_tagref
: ctsk_tagfirstref
);
6263 if (ref
&& TREE_CODE (ref
) == code
)
6265 if (C_TYPE_DEFINED_IN_STRUCT (ref
)
6266 && loc
!= UNKNOWN_LOCATION
6272 warning_at (loc
, OPT_Wc___compat
,
6273 ("enum type defined in struct or union "
6274 "is not visible in C++"));
6275 inform (refloc
, "enum type defined here");
6278 warning_at (loc
, OPT_Wc___compat
,
6279 ("struct defined in struct or union "
6280 "is not visible in C++"));
6281 inform (refloc
, "struct defined here");
6284 warning_at (loc
, OPT_Wc___compat
,
6285 ("union defined in struct or union "
6286 "is not visible in C++"));
6287 inform (refloc
, "union defined here");
6298 /* If no such tag is yet defined, create a forward-reference node
6299 and record it as the "definition".
6300 When a real declaration of this type is found,
6301 the forward-reference will be altered into a real type. */
6303 ref
= make_node (code
);
6304 if (code
== ENUMERAL_TYPE
)
6306 /* Give the type a default layout like unsigned int
6307 to avoid crashing if it does not get defined. */
6308 SET_TYPE_MODE (ref
, TYPE_MODE (unsigned_type_node
));
6309 TYPE_ALIGN (ref
) = TYPE_ALIGN (unsigned_type_node
);
6310 TYPE_USER_ALIGN (ref
) = 0;
6311 TYPE_UNSIGNED (ref
) = 1;
6312 TYPE_PRECISION (ref
) = TYPE_PRECISION (unsigned_type_node
);
6313 TYPE_MIN_VALUE (ref
) = TYPE_MIN_VALUE (unsigned_type_node
);
6314 TYPE_MAX_VALUE (ref
) = TYPE_MAX_VALUE (unsigned_type_node
);
6317 pushtag (loc
, name
, ref
);
6323 /* Get the struct, enum or union (CODE says which) with tag NAME.
6324 Define the tag as a forward-reference if it is not defined.
6325 Return a tree for the type. */
6328 xref_tag (enum tree_code code
, tree name
)
6330 return parser_xref_tag (input_location
, code
, name
).spec
;
6333 /* Make sure that the tag NAME is defined *in the current scope*
6334 at least as a forward reference.
6335 LOC is the location of the struct's definition.
6336 CODE says which kind of tag NAME ought to be.
6338 This stores the current value of the file static STRUCT_PARSE_INFO
6339 in *ENCLOSING_STRUCT_PARSE_INFO, and points STRUCT_PARSE_INFO at a
6340 new c_struct_parse_info structure. The old value of
6341 STRUCT_PARSE_INFO is restored in finish_struct. */
6344 start_struct (location_t loc
, enum tree_code code
, tree name
,
6345 struct c_struct_parse_info
**enclosing_struct_parse_info
)
6347 /* If there is already a tag defined at this scope
6348 (as a forward reference), just return it. */
6350 tree ref
= NULL_TREE
;
6351 location_t refloc
= UNKNOWN_LOCATION
;
6353 if (name
!= NULL_TREE
)
6354 ref
= lookup_tag (code
, name
, 1, &refloc
);
6355 if (ref
&& TREE_CODE (ref
) == code
)
6357 if (TYPE_SIZE (ref
))
6359 if (code
== UNION_TYPE
)
6360 error_at (loc
, "redefinition of %<union %E%>", name
);
6362 error_at (loc
, "redefinition of %<struct %E%>", name
);
6363 if (refloc
!= UNKNOWN_LOCATION
)
6364 inform (refloc
, "originally defined here");
6365 /* Don't create structures using a name already in use. */
6368 else if (C_TYPE_BEING_DEFINED (ref
))
6370 if (code
== UNION_TYPE
)
6371 error_at (loc
, "nested redefinition of %<union %E%>", name
);
6373 error_at (loc
, "nested redefinition of %<struct %E%>", name
);
6374 /* Don't bother to report "originally defined here" for a
6375 nested redefinition; the original definition should be
6377 /* Don't create structures that contain themselves. */
6382 /* Otherwise create a forward-reference just so the tag is in scope. */
6384 if (ref
== NULL_TREE
|| TREE_CODE (ref
) != code
)
6386 ref
= make_node (code
);
6387 pushtag (loc
, name
, ref
);
6390 C_TYPE_BEING_DEFINED (ref
) = 1;
6391 TYPE_PACKED (ref
) = flag_pack_struct
;
6393 *enclosing_struct_parse_info
= struct_parse_info
;
6394 struct_parse_info
= XNEW (struct c_struct_parse_info
);
6395 struct_parse_info
->struct_types
= VEC_alloc (tree
, heap
, 0);
6396 struct_parse_info
->fields
= VEC_alloc (c_binding_ptr
, heap
, 0);
6397 struct_parse_info
->typedefs_seen
= VEC_alloc (tree
, heap
, 0);
6399 /* FIXME: This will issue a warning for a use of a type defined
6400 within a statement expr used within sizeof, et. al. This is not
6401 terribly serious as C++ doesn't permit statement exprs within
6403 if (warn_cxx_compat
&& (in_sizeof
|| in_typeof
|| in_alignof
))
6404 warning_at (loc
, OPT_Wc___compat
,
6405 "defining type in %qs expression is invalid in C++",
6408 : (in_typeof
? "typeof" : "alignof")));
6413 /* Process the specs, declarator and width (NULL if omitted)
6414 of a structure component, returning a FIELD_DECL node.
6415 WIDTH is non-NULL for bit-fields only, and is an INTEGER_CST node.
6416 DECL_ATTRS is as for grokdeclarator.
6418 LOC is the location of the structure component.
6420 This is done during the parsing of the struct declaration.
6421 The FIELD_DECL nodes are chained together and the lot of them
6422 are ultimately passed to `build_struct' to make the RECORD_TYPE node. */
6425 grokfield (location_t loc
,
6426 struct c_declarator
*declarator
, struct c_declspecs
*declspecs
,
6427 tree width
, tree
*decl_attrs
)
6431 if (declarator
->kind
== cdk_id
&& declarator
->u
.id
== NULL_TREE
6432 && width
== NULL_TREE
)
6434 /* This is an unnamed decl.
6436 If we have something of the form "union { list } ;" then this
6437 is the anonymous union extension. Similarly for struct.
6439 If this is something of the form "struct foo;", then
6440 If MS extensions are enabled, this is handled as an
6442 Otherwise this is a forward declaration of a structure tag.
6444 If this is something of the form "foo;" and foo is a TYPE_DECL, then
6445 If MS extensions are enabled and foo names a structure, then
6446 again this is an anonymous struct.
6447 Otherwise this is an error.
6449 Oh what a horrid tangled web we weave. I wonder if MS consciously
6450 took this from Plan 9 or if it was an accident of implementation
6451 that took root before someone noticed the bug... */
6453 tree type
= declspecs
->type
;
6454 bool type_ok
= (TREE_CODE (type
) == RECORD_TYPE
6455 || TREE_CODE (type
) == UNION_TYPE
);
6459 && (flag_ms_extensions
|| !declspecs
->typedef_p
))
6461 if (flag_ms_extensions
)
6465 else if (TYPE_NAME (type
) == NULL
)
6472 pedwarn (loc
, 0, "declaration does not declare anything");
6475 pedwarn (loc
, OPT_pedantic
, "ISO C doesn%'t support unnamed structs/unions");
6478 value
= grokdeclarator (declarator
, declspecs
, FIELD
, false,
6479 width
? &width
: NULL
, decl_attrs
, NULL
, NULL
,
6482 finish_decl (value
, loc
, NULL_TREE
, NULL_TREE
, NULL_TREE
);
6483 DECL_INITIAL (value
) = width
;
6485 if (warn_cxx_compat
&& DECL_NAME (value
) != NULL_TREE
)
6487 /* If we currently have a binding for this field, set the
6488 in_struct field in the binding, so that we warn about lookups
6490 struct c_binding
*b
= I_SYMBOL_BINDING (DECL_NAME (value
));
6493 /* If the in_struct field is not yet set, push it on a list
6494 to be cleared when this struct is finished. */
6497 VEC_safe_push (c_binding_ptr
, heap
,
6498 struct_parse_info
->fields
, b
);
6507 /* Generate an error for any duplicate field names in FIELDLIST. Munge
6508 the list such that this does not present a problem later. */
6511 detect_field_duplicates (tree fieldlist
)
6516 /* First, see if there are more than "a few" fields.
6517 This is trivially true if there are zero or one fields. */
6520 x
= TREE_CHAIN (fieldlist
);
6526 } while (timeout
> 0 && x
);
6528 /* If there were "few" fields, avoid the overhead of allocating
6529 a hash table. Instead just do the nested traversal thing. */
6532 for (x
= TREE_CHAIN (fieldlist
); x
; x
= TREE_CHAIN (x
))
6535 for (y
= fieldlist
; y
!= x
; y
= TREE_CHAIN (y
))
6536 if (DECL_NAME (y
) == DECL_NAME (x
))
6538 error ("duplicate member %q+D", x
);
6539 DECL_NAME (x
) = NULL_TREE
;
6545 htab_t htab
= htab_create (37, htab_hash_pointer
, htab_eq_pointer
, NULL
);
6548 for (x
= fieldlist
; x
; x
= TREE_CHAIN (x
))
6549 if ((y
= DECL_NAME (x
)) != 0)
6551 slot
= htab_find_slot (htab
, y
, INSERT
);
6554 error ("duplicate member %q+D", x
);
6555 DECL_NAME (x
) = NULL_TREE
;
6564 /* Finish up struct info used by -Wc++-compat. */
6567 warn_cxx_compat_finish_struct (tree fieldlist
)
6571 struct c_binding
*b
;
6573 /* Set the C_TYPE_DEFINED_IN_STRUCT flag for each type defined in
6574 the current struct. We do this now at the end of the struct
6575 because the flag is used to issue visibility warnings, and we
6576 only want to issue those warnings if the type is referenced
6577 outside of the struct declaration. */
6578 for (ix
= 0; VEC_iterate (tree
, struct_parse_info
->struct_types
, ix
, x
); ++ix
)
6579 C_TYPE_DEFINED_IN_STRUCT (x
) = 1;
6581 /* The TYPEDEFS_SEEN field of STRUCT_PARSE_INFO is a list of
6582 typedefs used when declaring fields in this struct. If the name
6583 of any of the fields is also a typedef name then the struct would
6584 not parse in C++, because the C++ lookup rules say that the
6585 typedef name would be looked up in the context of the struct, and
6586 would thus be the field rather than the typedef. */
6587 if (!VEC_empty (tree
, struct_parse_info
->typedefs_seen
)
6588 && fieldlist
!= NULL_TREE
)
6590 /* Use a pointer_set using the name of the typedef. We can use
6591 a pointer_set because identifiers are interned. */
6592 struct pointer_set_t
*tset
= pointer_set_create ();
6595 VEC_iterate (tree
, struct_parse_info
->typedefs_seen
, ix
, x
);
6597 pointer_set_insert (tset
, DECL_NAME (x
));
6599 for (x
= fieldlist
; x
!= NULL_TREE
; x
= TREE_CHAIN (x
))
6601 if (pointer_set_contains (tset
, DECL_NAME (x
)))
6603 warning_at (DECL_SOURCE_LOCATION (x
), OPT_Wc___compat
,
6604 ("using %qD as both field and typedef name is "
6607 /* FIXME: It would be nice to report the location where
6608 the typedef name is used. */
6612 pointer_set_destroy (tset
);
6615 /* For each field which has a binding and which was not defined in
6616 an enclosing struct, clear the in_struct field. */
6618 VEC_iterate (c_binding_ptr
, struct_parse_info
->fields
, ix
, b
);
6623 /* Fill in the fields of a RECORD_TYPE or UNION_TYPE node, T.
6624 LOC is the location of the RECORD_TYPE or UNION_TYPE's definition.
6625 FIELDLIST is a chain of FIELD_DECL nodes for the fields.
6626 ATTRIBUTES are attributes to be applied to the structure.
6628 ENCLOSING_STRUCT_PARSE_INFO is the value of STRUCT_PARSE_INFO when
6629 the struct was started. */
6632 finish_struct (location_t loc
, tree t
, tree fieldlist
, tree attributes
,
6633 struct c_struct_parse_info
*enclosing_struct_parse_info
)
6636 bool toplevel
= file_scope
== current_scope
;
6637 int saw_named_field
;
6639 /* If this type was previously laid out as a forward reference,
6640 make sure we lay it out again. */
6644 decl_attributes (&t
, attributes
, (int) ATTR_FLAG_TYPE_IN_PLACE
);
6648 for (x
= fieldlist
; x
; x
= TREE_CHAIN (x
))
6649 if (DECL_NAME (x
) != 0)
6654 if (TREE_CODE (t
) == UNION_TYPE
)
6657 pedwarn (loc
, OPT_pedantic
, "union has no named members");
6659 pedwarn (loc
, OPT_pedantic
, "union has no members");
6664 pedwarn (loc
, OPT_pedantic
, "struct has no named members");
6666 pedwarn (loc
, OPT_pedantic
, "struct has no members");
6671 /* Install struct as DECL_CONTEXT of each field decl.
6672 Also process specified field sizes, found in the DECL_INITIAL,
6673 storing 0 there after the type has been changed to precision equal
6674 to its width, rather than the precision of the specified standard
6675 type. (Correct layout requires the original type to have been preserved
6678 saw_named_field
= 0;
6679 for (x
= fieldlist
; x
; x
= TREE_CHAIN (x
))
6681 if (TREE_TYPE (x
) == error_mark_node
)
6684 DECL_CONTEXT (x
) = t
;
6686 /* If any field is const, the structure type is pseudo-const. */
6687 if (TREE_READONLY (x
))
6688 C_TYPE_FIELDS_READONLY (t
) = 1;
6691 /* A field that is pseudo-const makes the structure likewise. */
6692 tree t1
= TREE_TYPE (x
);
6693 while (TREE_CODE (t1
) == ARRAY_TYPE
)
6694 t1
= TREE_TYPE (t1
);
6695 if ((TREE_CODE (t1
) == RECORD_TYPE
|| TREE_CODE (t1
) == UNION_TYPE
)
6696 && C_TYPE_FIELDS_READONLY (t1
))
6697 C_TYPE_FIELDS_READONLY (t
) = 1;
6700 /* Any field that is volatile means variables of this type must be
6701 treated in some ways as volatile. */
6702 if (TREE_THIS_VOLATILE (x
))
6703 C_TYPE_FIELDS_VOLATILE (t
) = 1;
6705 /* Any field of nominal variable size implies structure is too. */
6706 if (C_DECL_VARIABLE_SIZE (x
))
6707 C_TYPE_VARIABLE_SIZE (t
) = 1;
6709 if (DECL_INITIAL (x
))
6711 unsigned HOST_WIDE_INT width
= tree_low_cst (DECL_INITIAL (x
), 1);
6712 DECL_SIZE (x
) = bitsize_int (width
);
6713 DECL_BIT_FIELD (x
) = 1;
6714 SET_DECL_C_BIT_FIELD (x
);
6718 && (DECL_BIT_FIELD (x
)
6719 || TYPE_ALIGN (TREE_TYPE (x
)) > BITS_PER_UNIT
))
6720 DECL_PACKED (x
) = 1;
6722 /* Detect flexible array member in an invalid context. */
6723 if (TREE_CODE (TREE_TYPE (x
)) == ARRAY_TYPE
6724 && TYPE_SIZE (TREE_TYPE (x
)) == NULL_TREE
6725 && TYPE_DOMAIN (TREE_TYPE (x
)) != NULL_TREE
6726 && TYPE_MAX_VALUE (TYPE_DOMAIN (TREE_TYPE (x
))) == NULL_TREE
)
6728 if (TREE_CODE (t
) == UNION_TYPE
)
6730 error_at (DECL_SOURCE_LOCATION (x
),
6731 "flexible array member in union");
6732 TREE_TYPE (x
) = error_mark_node
;
6734 else if (TREE_CHAIN (x
) != NULL_TREE
)
6736 error_at (DECL_SOURCE_LOCATION (x
),
6737 "flexible array member not at end of struct");
6738 TREE_TYPE (x
) = error_mark_node
;
6740 else if (!saw_named_field
)
6742 error_at (DECL_SOURCE_LOCATION (x
),
6743 "flexible array member in otherwise empty struct");
6744 TREE_TYPE (x
) = error_mark_node
;
6748 if (pedantic
&& TREE_CODE (t
) == RECORD_TYPE
6749 && flexible_array_type_p (TREE_TYPE (x
)))
6750 pedwarn (DECL_SOURCE_LOCATION (x
), OPT_pedantic
,
6751 "invalid use of structure with flexible array member");
6754 saw_named_field
= 1;
6757 detect_field_duplicates (fieldlist
);
6759 /* Now we have the nearly final fieldlist. Record it,
6760 then lay out the structure or union (including the fields). */
6762 TYPE_FIELDS (t
) = fieldlist
;
6766 /* Give bit-fields their proper types. */
6768 tree
*fieldlistp
= &fieldlist
;
6770 if (TREE_CODE (*fieldlistp
) == FIELD_DECL
&& DECL_INITIAL (*fieldlistp
)
6771 && TREE_TYPE (*fieldlistp
) != error_mark_node
)
6773 unsigned HOST_WIDE_INT width
6774 = tree_low_cst (DECL_INITIAL (*fieldlistp
), 1);
6775 tree type
= TREE_TYPE (*fieldlistp
);
6776 if (width
!= TYPE_PRECISION (type
))
6778 TREE_TYPE (*fieldlistp
)
6779 = c_build_bitfield_integer_type (width
, TYPE_UNSIGNED (type
));
6780 DECL_MODE (*fieldlistp
) = TYPE_MODE (TREE_TYPE (*fieldlistp
));
6782 DECL_INITIAL (*fieldlistp
) = 0;
6785 fieldlistp
= &TREE_CHAIN (*fieldlistp
);
6788 /* Now we have the truly final field list.
6789 Store it in this type and in the variants. */
6791 TYPE_FIELDS (t
) = fieldlist
;
6793 /* If there are lots of fields, sort so we can look through them fast.
6794 We arbitrarily consider 16 or more elts to be "a lot". */
6799 for (x
= fieldlist
; x
; x
= TREE_CHAIN (x
))
6801 if (len
> 15 || DECL_NAME (x
) == NULL
)
6809 struct lang_type
*space
;
6810 struct sorted_fields_type
*space2
;
6812 len
+= list_length (x
);
6814 /* Use the same allocation policy here that make_node uses, to
6815 ensure that this lives as long as the rest of the struct decl.
6816 All decls in an inline function need to be saved. */
6818 space
= GGC_CNEW (struct lang_type
);
6819 space2
= GGC_NEWVAR (struct sorted_fields_type
,
6820 sizeof (struct sorted_fields_type
) + len
* sizeof (tree
));
6824 field_array
= &space2
->elts
[0];
6825 for (x
= fieldlist
; x
; x
= TREE_CHAIN (x
))
6827 field_array
[len
++] = x
;
6829 /* If there is anonymous struct or union, break out of the loop. */
6830 if (DECL_NAME (x
) == NULL
)
6833 /* Found no anonymous struct/union. Add the TYPE_LANG_SPECIFIC. */
6836 TYPE_LANG_SPECIFIC (t
) = space
;
6837 TYPE_LANG_SPECIFIC (t
)->s
->len
= len
;
6838 field_array
= TYPE_LANG_SPECIFIC (t
)->s
->elts
;
6839 qsort (field_array
, len
, sizeof (tree
), field_decl_cmp
);
6844 for (x
= TYPE_MAIN_VARIANT (t
); x
; x
= TYPE_NEXT_VARIANT (x
))
6846 TYPE_FIELDS (x
) = TYPE_FIELDS (t
);
6847 TYPE_LANG_SPECIFIC (x
) = TYPE_LANG_SPECIFIC (t
);
6848 C_TYPE_FIELDS_READONLY (x
) = C_TYPE_FIELDS_READONLY (t
);
6849 C_TYPE_FIELDS_VOLATILE (x
) = C_TYPE_FIELDS_VOLATILE (t
);
6850 C_TYPE_VARIABLE_SIZE (x
) = C_TYPE_VARIABLE_SIZE (t
);
6853 /* If this was supposed to be a transparent union, but we can't
6854 make it one, warn and turn off the flag. */
6855 if (TREE_CODE (t
) == UNION_TYPE
6856 && TYPE_TRANSPARENT_UNION (t
)
6857 && (!TYPE_FIELDS (t
) || TYPE_MODE (t
) != DECL_MODE (TYPE_FIELDS (t
))))
6859 TYPE_TRANSPARENT_UNION (t
) = 0;
6860 warning_at (loc
, 0, "union cannot be made transparent");
6863 /* If this structure or union completes the type of any previous
6864 variable declaration, lay it out and output its rtl. */
6865 for (x
= C_TYPE_INCOMPLETE_VARS (TYPE_MAIN_VARIANT (t
));
6869 tree decl
= TREE_VALUE (x
);
6870 if (TREE_CODE (TREE_TYPE (decl
)) == ARRAY_TYPE
)
6871 layout_array_type (TREE_TYPE (decl
));
6872 if (TREE_CODE (decl
) != TYPE_DECL
)
6874 layout_decl (decl
, 0);
6875 if (c_dialect_objc ())
6876 objc_check_decl (decl
);
6877 rest_of_decl_compilation (decl
, toplevel
, 0);
6882 C_TYPE_INCOMPLETE_VARS (TYPE_MAIN_VARIANT (t
)) = 0;
6884 /* Finish debugging output for this type. */
6885 rest_of_type_compilation (t
, toplevel
);
6887 /* If we're inside a function proper, i.e. not file-scope and not still
6888 parsing parameters, then arrange for the size of a variable sized type
6890 if (cur_stmt_list
&& variably_modified_type_p (t
, NULL_TREE
))
6891 add_stmt (build_stmt (loc
,
6892 DECL_EXPR
, build_decl (loc
, TYPE_DECL
, NULL
, t
)));
6894 if (warn_cxx_compat
)
6895 warn_cxx_compat_finish_struct (fieldlist
);
6897 VEC_free (tree
, heap
, struct_parse_info
->struct_types
);
6898 VEC_free (c_binding_ptr
, heap
, struct_parse_info
->fields
);
6899 VEC_free (tree
, heap
, struct_parse_info
->typedefs_seen
);
6900 XDELETE (struct_parse_info
);
6902 struct_parse_info
= enclosing_struct_parse_info
;
6904 /* If this struct is defined inside a struct, add it to
6907 && struct_parse_info
!= NULL
6908 && !in_sizeof
&& !in_typeof
&& !in_alignof
)
6909 VEC_safe_push (tree
, heap
, struct_parse_info
->struct_types
, t
);
6914 /* Lay out the type T, and its element type, and so on. */
6917 layout_array_type (tree t
)
6919 if (TREE_CODE (TREE_TYPE (t
)) == ARRAY_TYPE
)
6920 layout_array_type (TREE_TYPE (t
));
6924 /* Begin compiling the definition of an enumeration type.
6925 NAME is its name (or null if anonymous).
6926 LOC is the enum's location.
6927 Returns the type object, as yet incomplete.
6928 Also records info about it so that build_enumerator
6929 may be used to declare the individual values as they are read. */
6932 start_enum (location_t loc
, struct c_enum_contents
*the_enum
, tree name
)
6934 tree enumtype
= NULL_TREE
;
6935 location_t enumloc
= UNKNOWN_LOCATION
;
6937 /* If this is the real definition for a previous forward reference,
6938 fill in the contents in the same object that used to be the
6939 forward reference. */
6941 if (name
!= NULL_TREE
)
6942 enumtype
= lookup_tag (ENUMERAL_TYPE
, name
, 1, &enumloc
);
6944 if (enumtype
== 0 || TREE_CODE (enumtype
) != ENUMERAL_TYPE
)
6946 enumtype
= make_node (ENUMERAL_TYPE
);
6947 pushtag (loc
, name
, enumtype
);
6950 if (C_TYPE_BEING_DEFINED (enumtype
))
6951 error_at (loc
, "nested redefinition of %<enum %E%>", name
);
6953 C_TYPE_BEING_DEFINED (enumtype
) = 1;
6955 if (TYPE_VALUES (enumtype
) != 0)
6957 /* This enum is a named one that has been declared already. */
6958 error_at (loc
, "redeclaration of %<enum %E%>", name
);
6959 if (enumloc
!= UNKNOWN_LOCATION
)
6960 inform (enumloc
, "originally defined here");
6962 /* Completely replace its old definition.
6963 The old enumerators remain defined, however. */
6964 TYPE_VALUES (enumtype
) = 0;
6967 the_enum
->enum_next_value
= integer_zero_node
;
6968 the_enum
->enum_overflow
= 0;
6970 if (flag_short_enums
)
6971 TYPE_PACKED (enumtype
) = 1;
6973 /* FIXME: This will issue a warning for a use of a type defined
6974 within sizeof in a statement expr. This is not terribly serious
6975 as C++ doesn't permit statement exprs within sizeof anyhow. */
6976 if (warn_cxx_compat
&& (in_sizeof
|| in_typeof
|| in_alignof
))
6977 warning_at (loc
, OPT_Wc___compat
,
6978 "defining type in %qs expression is invalid in C++",
6981 : (in_typeof
? "typeof" : "alignof")));
6986 /* After processing and defining all the values of an enumeration type,
6987 install their decls in the enumeration type and finish it off.
6988 ENUMTYPE is the type object, VALUES a list of decl-value pairs,
6989 and ATTRIBUTES are the specified attributes.
6990 Returns ENUMTYPE. */
6993 finish_enum (tree enumtype
, tree values
, tree attributes
)
6996 tree minnode
= 0, maxnode
= 0;
6997 int precision
, unsign
;
6998 bool toplevel
= (file_scope
== current_scope
);
6999 struct lang_type
*lt
;
7001 decl_attributes (&enumtype
, attributes
, (int) ATTR_FLAG_TYPE_IN_PLACE
);
7003 /* Calculate the maximum value of any enumerator in this type. */
7005 if (values
== error_mark_node
)
7006 minnode
= maxnode
= integer_zero_node
;
7009 minnode
= maxnode
= TREE_VALUE (values
);
7010 for (pair
= TREE_CHAIN (values
); pair
; pair
= TREE_CHAIN (pair
))
7012 tree value
= TREE_VALUE (pair
);
7013 if (tree_int_cst_lt (maxnode
, value
))
7015 if (tree_int_cst_lt (value
, minnode
))
7020 /* Construct the final type of this enumeration. It is the same
7021 as one of the integral types - the narrowest one that fits, except
7022 that normally we only go as narrow as int - and signed iff any of
7023 the values are negative. */
7024 unsign
= (tree_int_cst_sgn (minnode
) >= 0);
7025 precision
= MAX (tree_int_cst_min_precision (minnode
, unsign
),
7026 tree_int_cst_min_precision (maxnode
, unsign
));
7028 if (TYPE_PACKED (enumtype
) || precision
> TYPE_PRECISION (integer_type_node
))
7030 tem
= c_common_type_for_size (precision
, unsign
);
7033 warning (0, "enumeration values exceed range of largest integer");
7034 tem
= long_long_integer_type_node
;
7038 tem
= unsign
? unsigned_type_node
: integer_type_node
;
7040 TYPE_MIN_VALUE (enumtype
) = TYPE_MIN_VALUE (tem
);
7041 TYPE_MAX_VALUE (enumtype
) = TYPE_MAX_VALUE (tem
);
7042 TYPE_UNSIGNED (enumtype
) = TYPE_UNSIGNED (tem
);
7043 TYPE_SIZE (enumtype
) = 0;
7045 /* If the precision of the type was specific with an attribute and it
7046 was too small, give an error. Otherwise, use it. */
7047 if (TYPE_PRECISION (enumtype
))
7049 if (precision
> TYPE_PRECISION (enumtype
))
7050 error ("specified mode too small for enumeral values");
7053 TYPE_PRECISION (enumtype
) = TYPE_PRECISION (tem
);
7055 layout_type (enumtype
);
7057 if (values
!= error_mark_node
)
7059 /* Change the type of the enumerators to be the enum type. We
7060 need to do this irrespective of the size of the enum, for
7061 proper type checking. Replace the DECL_INITIALs of the
7062 enumerators, and the value slots of the list, with copies
7063 that have the enum type; they cannot be modified in place
7064 because they may be shared (e.g. integer_zero_node) Finally,
7065 change the purpose slots to point to the names of the decls. */
7066 for (pair
= values
; pair
; pair
= TREE_CHAIN (pair
))
7068 tree enu
= TREE_PURPOSE (pair
);
7069 tree ini
= DECL_INITIAL (enu
);
7071 TREE_TYPE (enu
) = enumtype
;
7073 /* The ISO C Standard mandates enumerators to have type int,
7074 even though the underlying type of an enum type is
7075 unspecified. However, GCC allows enumerators of any
7076 integer type as an extensions. build_enumerator()
7077 converts any enumerators that fit in an int to type int,
7078 to avoid promotions to unsigned types when comparing
7079 integers with enumerators that fit in the int range.
7080 When -pedantic is given, build_enumerator() would have
7081 already warned about those that don't fit. Here we
7082 convert the rest to the enumerator type. */
7083 if (TREE_TYPE (ini
) != integer_type_node
)
7084 ini
= convert (enumtype
, ini
);
7086 DECL_INITIAL (enu
) = ini
;
7087 TREE_PURPOSE (pair
) = DECL_NAME (enu
);
7088 TREE_VALUE (pair
) = ini
;
7091 TYPE_VALUES (enumtype
) = values
;
7094 /* Record the min/max values so that we can warn about bit-field
7095 enumerations that are too small for the values. */
7096 lt
= GGC_CNEW (struct lang_type
);
7097 lt
->enum_min
= minnode
;
7098 lt
->enum_max
= maxnode
;
7099 TYPE_LANG_SPECIFIC (enumtype
) = lt
;
7101 /* Fix up all variant types of this enum type. */
7102 for (tem
= TYPE_MAIN_VARIANT (enumtype
); tem
; tem
= TYPE_NEXT_VARIANT (tem
))
7104 if (tem
== enumtype
)
7106 TYPE_VALUES (tem
) = TYPE_VALUES (enumtype
);
7107 TYPE_MIN_VALUE (tem
) = TYPE_MIN_VALUE (enumtype
);
7108 TYPE_MAX_VALUE (tem
) = TYPE_MAX_VALUE (enumtype
);
7109 TYPE_SIZE (tem
) = TYPE_SIZE (enumtype
);
7110 TYPE_SIZE_UNIT (tem
) = TYPE_SIZE_UNIT (enumtype
);
7111 SET_TYPE_MODE (tem
, TYPE_MODE (enumtype
));
7112 TYPE_PRECISION (tem
) = TYPE_PRECISION (enumtype
);
7113 TYPE_ALIGN (tem
) = TYPE_ALIGN (enumtype
);
7114 TYPE_USER_ALIGN (tem
) = TYPE_USER_ALIGN (enumtype
);
7115 TYPE_UNSIGNED (tem
) = TYPE_UNSIGNED (enumtype
);
7116 TYPE_LANG_SPECIFIC (tem
) = TYPE_LANG_SPECIFIC (enumtype
);
7119 /* Finish debugging output for this type. */
7120 rest_of_type_compilation (enumtype
, toplevel
);
7122 /* If this enum is defined inside a struct, add it to
7125 && struct_parse_info
!= NULL
7126 && !in_sizeof
&& !in_typeof
&& !in_alignof
)
7127 VEC_safe_push (tree
, heap
, struct_parse_info
->struct_types
, enumtype
);
7132 /* Build and install a CONST_DECL for one value of the
7133 current enumeration type (one that was begun with start_enum).
7134 LOC is the location of the enumerator.
7135 Return a tree-list containing the CONST_DECL and its value.
7136 Assignment of sequential values by default is handled here. */
7139 build_enumerator (location_t loc
,
7140 struct c_enum_contents
*the_enum
, tree name
, tree value
)
7144 /* Validate and default VALUE. */
7148 /* Don't issue more errors for error_mark_node (i.e. an
7149 undeclared identifier) - just ignore the value expression. */
7150 if (value
== error_mark_node
)
7152 else if (!INTEGRAL_TYPE_P (TREE_TYPE (value
)))
7154 error_at (loc
, "enumerator value for %qE is not an integer constant",
7160 if (TREE_CODE (value
) != INTEGER_CST
)
7162 value
= c_fully_fold (value
, false, NULL
);
7163 if (TREE_CODE (value
) == INTEGER_CST
)
7164 pedwarn (loc
, OPT_pedantic
,
7165 "enumerator value for %qE is not an integer "
7166 "constant expression", name
);
7168 if (TREE_CODE (value
) != INTEGER_CST
)
7170 error ("enumerator value for %qE is not an integer constant",
7176 value
= default_conversion (value
);
7177 constant_expression_warning (value
);
7182 /* Default based on previous value. */
7183 /* It should no longer be possible to have NON_LVALUE_EXPR
7187 value
= the_enum
->enum_next_value
;
7188 if (the_enum
->enum_overflow
)
7189 error_at (loc
, "overflow in enumeration values");
7191 /* Even though the underlying type of an enum is unspecified, the
7192 type of enumeration constants is explicitly defined as int
7193 (6.4.4.3/2 in the C99 Standard). GCC allows any integer type as
7195 else if (!int_fits_type_p (value
, integer_type_node
))
7196 pedwarn (loc
, OPT_pedantic
,
7197 "ISO C restricts enumerator values to range of %<int%>");
7199 /* The ISO C Standard mandates enumerators to have type int, even
7200 though the underlying type of an enum type is unspecified.
7201 However, GCC allows enumerators of any integer type as an
7202 extensions. Here we convert any enumerators that fit in an int
7203 to type int, to avoid promotions to unsigned types when comparing
7204 integers with enumerators that fit in the int range. When
7205 -pedantic is given, we would have already warned about those that
7206 don't fit. We have to do this here rather than in finish_enum
7207 because this value may be used to define more enumerators. */
7208 if (int_fits_type_p (value
, integer_type_node
))
7209 value
= convert (integer_type_node
, value
);
7211 /* Set basis for default for next value. */
7212 the_enum
->enum_next_value
7214 (EXPR_HAS_LOCATION (value
) ? EXPR_LOCATION (value
) : input_location
,
7215 PLUS_EXPR
, value
, integer_one_node
, 0);
7216 the_enum
->enum_overflow
= tree_int_cst_lt (the_enum
->enum_next_value
, value
);
7218 /* Now create a declaration for the enum value name. */
7220 type
= TREE_TYPE (value
);
7221 type
= c_common_type_for_size (MAX (TYPE_PRECISION (type
),
7222 TYPE_PRECISION (integer_type_node
)),
7223 (TYPE_PRECISION (type
)
7224 >= TYPE_PRECISION (integer_type_node
)
7225 && TYPE_UNSIGNED (type
)));
7227 decl
= build_decl (loc
, CONST_DECL
, name
, type
);
7228 DECL_INITIAL (decl
) = convert (type
, value
);
7231 return tree_cons (decl
, value
, NULL_TREE
);
7235 /* Create the FUNCTION_DECL for a function definition.
7236 DECLSPECS, DECLARATOR and ATTRIBUTES are the parts of
7237 the declaration; they describe the function's name and the type it returns,
7238 but twisted together in a fashion that parallels the syntax of C.
7240 This function creates a binding context for the function body
7241 as well as setting up the FUNCTION_DECL in current_function_decl.
7243 Returns 1 on success. If the DECLARATOR is not suitable for a function
7244 (it defines a datum instead), we return 0, which tells
7245 yyparse to report a parse error. */
7248 start_function (struct c_declspecs
*declspecs
, struct c_declarator
*declarator
,
7251 tree decl1
, old_decl
;
7252 tree restype
, resdecl
;
7255 current_function_returns_value
= 0; /* Assume, until we see it does. */
7256 current_function_returns_null
= 0;
7257 current_function_returns_abnormally
= 0;
7258 warn_about_return_type
= 0;
7259 c_switch_stack
= NULL
;
7261 /* Indicate no valid break/continue context by setting these variables
7262 to some non-null, non-label value. We'll notice and emit the proper
7263 error message in c_finish_bc_stmt. */
7264 c_break_label
= c_cont_label
= size_zero_node
;
7266 decl1
= grokdeclarator (declarator
, declspecs
, FUNCDEF
, true, NULL
,
7267 &attributes
, NULL
, NULL
, DEPRECATED_NORMAL
);
7269 /* If the declarator is not suitable for a function definition,
7270 cause a syntax error. */
7274 loc
= DECL_SOURCE_LOCATION (decl1
);
7276 decl_attributes (&decl1
, attributes
, 0);
7278 if (DECL_DECLARED_INLINE_P (decl1
)
7279 && DECL_UNINLINABLE (decl1
)
7280 && lookup_attribute ("noinline", DECL_ATTRIBUTES (decl1
)))
7281 warning_at (loc
, OPT_Wattributes
,
7282 "inline function %qD given attribute noinline",
7285 /* Handle gnu_inline attribute. */
7286 if (declspecs
->inline_p
7287 && !flag_gnu89_inline
7288 && TREE_CODE (decl1
) == FUNCTION_DECL
7289 && (lookup_attribute ("gnu_inline", DECL_ATTRIBUTES (decl1
))
7290 || current_function_decl
))
7292 if (declspecs
->storage_class
!= csc_static
)
7293 DECL_EXTERNAL (decl1
) = !DECL_EXTERNAL (decl1
);
7296 announce_function (decl1
);
7298 if (!COMPLETE_OR_VOID_TYPE_P (TREE_TYPE (TREE_TYPE (decl1
))))
7300 error_at (loc
, "return type is an incomplete type");
7301 /* Make it return void instead. */
7303 = build_function_type (void_type_node
,
7304 TYPE_ARG_TYPES (TREE_TYPE (decl1
)));
7307 if (warn_about_return_type
)
7308 pedwarn_c99 (loc
, flag_isoc99
? 0
7309 : (warn_return_type
? OPT_Wreturn_type
: OPT_Wimplicit_int
),
7310 "return type defaults to %<int%>");
7312 /* Make the init_value nonzero so pushdecl knows this is not tentative.
7313 error_mark_node is replaced below (in pop_scope) with the BLOCK. */
7314 DECL_INITIAL (decl1
) = error_mark_node
;
7316 /* If this definition isn't a prototype and we had a prototype declaration
7317 before, copy the arg type info from that prototype. */
7318 old_decl
= lookup_name_in_scope (DECL_NAME (decl1
), current_scope
);
7319 if (old_decl
&& TREE_CODE (old_decl
) != FUNCTION_DECL
)
7321 current_function_prototype_locus
= UNKNOWN_LOCATION
;
7322 current_function_prototype_built_in
= false;
7323 current_function_prototype_arg_types
= NULL_TREE
;
7324 if (TYPE_ARG_TYPES (TREE_TYPE (decl1
)) == 0)
7326 if (old_decl
!= 0 && TREE_CODE (TREE_TYPE (old_decl
)) == FUNCTION_TYPE
7327 && comptypes (TREE_TYPE (TREE_TYPE (decl1
)),
7328 TREE_TYPE (TREE_TYPE (old_decl
))))
7330 TREE_TYPE (decl1
) = composite_type (TREE_TYPE (old_decl
),
7332 current_function_prototype_locus
= DECL_SOURCE_LOCATION (old_decl
);
7333 current_function_prototype_built_in
7334 = C_DECL_BUILTIN_PROTOTYPE (old_decl
);
7335 current_function_prototype_arg_types
7336 = TYPE_ARG_TYPES (TREE_TYPE (decl1
));
7338 if (TREE_PUBLIC (decl1
))
7340 /* If there is an external prototype declaration of this
7341 function, record its location but do not copy information
7342 to this decl. This may be an invisible declaration
7343 (built-in or in a scope which has finished) or simply
7344 have more refined argument types than any declaration
7346 struct c_binding
*b
;
7347 for (b
= I_SYMBOL_BINDING (DECL_NAME (decl1
)); b
; b
= b
->shadowed
)
7348 if (B_IN_SCOPE (b
, external_scope
))
7352 tree ext_decl
, ext_type
;
7354 ext_type
= b
->u
.type
? b
->u
.type
: TREE_TYPE (ext_decl
);
7355 if (TREE_CODE (ext_type
) == FUNCTION_TYPE
7356 && comptypes (TREE_TYPE (TREE_TYPE (decl1
)),
7357 TREE_TYPE (ext_type
)))
7359 current_function_prototype_locus
7360 = DECL_SOURCE_LOCATION (ext_decl
);
7361 current_function_prototype_built_in
7362 = C_DECL_BUILTIN_PROTOTYPE (ext_decl
);
7363 current_function_prototype_arg_types
7364 = TYPE_ARG_TYPES (ext_type
);
7370 /* Optionally warn of old-fashioned def with no previous prototype. */
7371 if (warn_strict_prototypes
7372 && old_decl
!= error_mark_node
7373 && TYPE_ARG_TYPES (TREE_TYPE (decl1
)) == 0
7374 && C_DECL_ISNT_PROTOTYPE (old_decl
))
7375 warning_at (loc
, OPT_Wstrict_prototypes
,
7376 "function declaration isn%'t a prototype");
7377 /* Optionally warn of any global def with no previous prototype. */
7378 else if (warn_missing_prototypes
7379 && old_decl
!= error_mark_node
7380 && TREE_PUBLIC (decl1
)
7381 && !MAIN_NAME_P (DECL_NAME (decl1
))
7382 && C_DECL_ISNT_PROTOTYPE (old_decl
))
7383 warning_at (loc
, OPT_Wmissing_prototypes
,
7384 "no previous prototype for %qD", decl1
);
7385 /* Optionally warn of any def with no previous prototype
7386 if the function has already been used. */
7387 else if (warn_missing_prototypes
7389 && old_decl
!= error_mark_node
7390 && TREE_USED (old_decl
)
7391 && TYPE_ARG_TYPES (TREE_TYPE (old_decl
)) == 0)
7392 warning_at (loc
, OPT_Wmissing_prototypes
,
7393 "%qD was used with no prototype before its definition", decl1
);
7394 /* Optionally warn of any global def with no previous declaration. */
7395 else if (warn_missing_declarations
7396 && TREE_PUBLIC (decl1
)
7398 && !MAIN_NAME_P (DECL_NAME (decl1
)))
7399 warning_at (loc
, OPT_Wmissing_declarations
,
7400 "no previous declaration for %qD",
7402 /* Optionally warn of any def with no previous declaration
7403 if the function has already been used. */
7404 else if (warn_missing_declarations
7406 && old_decl
!= error_mark_node
7407 && TREE_USED (old_decl
)
7408 && C_DECL_IMPLICIT (old_decl
))
7409 warning_at (loc
, OPT_Wmissing_declarations
,
7410 "%qD was used with no declaration before its definition", decl1
);
7412 /* This function exists in static storage.
7413 (This does not mean `static' in the C sense!) */
7414 TREE_STATIC (decl1
) = 1;
7416 /* A nested function is not global. */
7417 if (current_function_decl
!= 0)
7418 TREE_PUBLIC (decl1
) = 0;
7420 /* This is the earliest point at which we might know the assembler
7421 name of the function. Thus, if it's set before this, die horribly. */
7422 gcc_assert (!DECL_ASSEMBLER_NAME_SET_P (decl1
));
7424 /* If #pragma weak was used, mark the decl weak now. */
7425 if (current_scope
== file_scope
)
7426 maybe_apply_pragma_weak (decl1
);
7428 /* Warn for unlikely, improbable, or stupid declarations of `main'. */
7429 if (warn_main
&& MAIN_NAME_P (DECL_NAME (decl1
)))
7431 if (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (decl1
)))
7432 != integer_type_node
)
7433 pedwarn (loc
, OPT_Wmain
, "return type of %qD is not %<int%>", decl1
);
7435 check_main_parameter_types (decl1
);
7437 if (!TREE_PUBLIC (decl1
))
7438 pedwarn (loc
, OPT_Wmain
,
7439 "%qD is normally a non-static function", decl1
);
7442 /* Record the decl so that the function name is defined.
7443 If we already have a decl for this name, and it is a FUNCTION_DECL,
7444 use the old decl. */
7446 current_function_decl
= pushdecl (decl1
);
7449 declare_parm_level ();
7451 restype
= TREE_TYPE (TREE_TYPE (current_function_decl
));
7452 resdecl
= build_decl (loc
, RESULT_DECL
, NULL_TREE
, restype
);
7453 DECL_ARTIFICIAL (resdecl
) = 1;
7454 DECL_IGNORED_P (resdecl
) = 1;
7455 DECL_RESULT (current_function_decl
) = resdecl
;
7457 start_fname_decls ();
7462 /* Subroutine of store_parm_decls which handles new-style function
7463 definitions (prototype format). The parms already have decls, so we
7464 need only record them as in effect and complain if any redundant
7465 old-style parm decls were written. */
7467 store_parm_decls_newstyle (tree fndecl
, const struct c_arg_info
*arg_info
)
7471 if (current_scope
->bindings
)
7473 error_at (DECL_SOURCE_LOCATION (fndecl
),
7474 "old-style parameter declarations in prototyped "
7475 "function definition");
7477 /* Get rid of the old-style declarations. */
7481 /* Don't issue this warning for nested functions, and don't issue this
7482 warning if we got here because ARG_INFO_TYPES was error_mark_node
7483 (this happens when a function definition has just an ellipsis in
7484 its parameter list). */
7485 else if (!in_system_header
&& !current_function_scope
7486 && arg_info
->types
!= error_mark_node
)
7487 warning_at (DECL_SOURCE_LOCATION (fndecl
), OPT_Wtraditional
,
7488 "traditional C rejects ISO C style function definitions");
7490 /* Now make all the parameter declarations visible in the function body.
7491 We can bypass most of the grunt work of pushdecl. */
7492 for (decl
= arg_info
->parms
; decl
; decl
= TREE_CHAIN (decl
))
7494 DECL_CONTEXT (decl
) = current_function_decl
;
7495 if (DECL_NAME (decl
))
7497 bind (DECL_NAME (decl
), decl
, current_scope
,
7498 /*invisible=*/false, /*nested=*/false,
7500 if (!TREE_USED (decl
))
7501 warn_if_shadowing (decl
);
7504 error_at (DECL_SOURCE_LOCATION (decl
), "parameter name omitted");
7507 /* Record the parameter list in the function declaration. */
7508 DECL_ARGUMENTS (fndecl
) = arg_info
->parms
;
7510 /* Now make all the ancillary declarations visible, likewise. */
7511 for (decl
= arg_info
->others
; decl
; decl
= TREE_CHAIN (decl
))
7513 DECL_CONTEXT (decl
) = current_function_decl
;
7514 if (DECL_NAME (decl
))
7515 bind (DECL_NAME (decl
), decl
, current_scope
,
7516 /*invisible=*/false, /*nested=*/false, UNKNOWN_LOCATION
);
7519 /* And all the tag declarations. */
7520 for (decl
= arg_info
->tags
; decl
; decl
= TREE_CHAIN (decl
))
7521 if (TREE_PURPOSE (decl
))
7522 bind (TREE_PURPOSE (decl
), TREE_VALUE (decl
), current_scope
,
7523 /*invisible=*/false, /*nested=*/false, UNKNOWN_LOCATION
);
7526 /* Subroutine of store_parm_decls which handles old-style function
7527 definitions (separate parameter list and declarations). */
7530 store_parm_decls_oldstyle (tree fndecl
, const struct c_arg_info
*arg_info
)
7532 struct c_binding
*b
;
7533 tree parm
, decl
, last
;
7534 tree parmids
= arg_info
->parms
;
7535 struct pointer_set_t
*seen_args
= pointer_set_create ();
7537 if (!in_system_header
)
7538 warning_at (DECL_SOURCE_LOCATION (fndecl
),
7539 OPT_Wold_style_definition
, "old-style function definition");
7541 /* Match each formal parameter name with its declaration. Save each
7542 decl in the appropriate TREE_PURPOSE slot of the parmids chain. */
7543 for (parm
= parmids
; parm
; parm
= TREE_CHAIN (parm
))
7545 if (TREE_VALUE (parm
) == 0)
7547 error_at (DECL_SOURCE_LOCATION (fndecl
),
7548 "parameter name missing from parameter list");
7549 TREE_PURPOSE (parm
) = 0;
7553 b
= I_SYMBOL_BINDING (TREE_VALUE (parm
));
7554 if (b
&& B_IN_CURRENT_SCOPE (b
))
7557 /* If we got something other than a PARM_DECL it is an error. */
7558 if (TREE_CODE (decl
) != PARM_DECL
)
7559 error_at (DECL_SOURCE_LOCATION (decl
),
7560 "%qD declared as a non-parameter", decl
);
7561 /* If the declaration is already marked, we have a duplicate
7562 name. Complain and ignore the duplicate. */
7563 else if (pointer_set_contains (seen_args
, decl
))
7565 error_at (DECL_SOURCE_LOCATION (decl
),
7566 "multiple parameters named %qD", decl
);
7567 TREE_PURPOSE (parm
) = 0;
7570 /* If the declaration says "void", complain and turn it into
7572 else if (VOID_TYPE_P (TREE_TYPE (decl
)))
7574 error_at (DECL_SOURCE_LOCATION (decl
),
7575 "parameter %qD declared with void type", decl
);
7576 TREE_TYPE (decl
) = integer_type_node
;
7577 DECL_ARG_TYPE (decl
) = integer_type_node
;
7578 layout_decl (decl
, 0);
7580 warn_if_shadowing (decl
);
7582 /* If no declaration found, default to int. */
7585 /* FIXME diagnostics: This should be the location of the argument,
7586 not the FNDECL. E.g., for an old-style declaration
7588 int f10(v) { blah; }
7590 We should use the location of the V, not the F10.
7591 Unfortunately, the V is an IDENTIFIER_NODE which has no
7592 location. In the future we need locations for c_arg_info
7595 See gcc.dg/Wshadow-3.c for an example of this problem. */
7596 decl
= build_decl (DECL_SOURCE_LOCATION (fndecl
),
7597 PARM_DECL
, TREE_VALUE (parm
), integer_type_node
);
7598 DECL_ARG_TYPE (decl
) = TREE_TYPE (decl
);
7600 warn_if_shadowing (decl
);
7603 pedwarn (DECL_SOURCE_LOCATION (decl
),
7604 0, "type of %qD defaults to %<int%>", decl
);
7606 warning_at (DECL_SOURCE_LOCATION (decl
),
7607 OPT_Wmissing_parameter_type
,
7608 "type of %qD defaults to %<int%>", decl
);
7611 TREE_PURPOSE (parm
) = decl
;
7612 pointer_set_insert (seen_args
, decl
);
7615 /* Now examine the parms chain for incomplete declarations
7616 and declarations with no corresponding names. */
7618 for (b
= current_scope
->bindings
; b
; b
= b
->prev
)
7621 if (TREE_CODE (parm
) != PARM_DECL
)
7624 if (TREE_TYPE (parm
) != error_mark_node
7625 && !COMPLETE_TYPE_P (TREE_TYPE (parm
)))
7627 error_at (DECL_SOURCE_LOCATION (parm
),
7628 "parameter %qD has incomplete type", parm
);
7629 TREE_TYPE (parm
) = error_mark_node
;
7632 if (!pointer_set_contains (seen_args
, parm
))
7634 error_at (DECL_SOURCE_LOCATION (parm
),
7635 "declaration for parameter %qD but no such parameter",
7638 /* Pretend the parameter was not missing.
7639 This gets us to a standard state and minimizes
7640 further error messages. */
7641 parmids
= chainon (parmids
, tree_cons (parm
, 0, 0));
7645 /* Chain the declarations together in the order of the list of
7646 names. Store that chain in the function decl, replacing the
7647 list of names. Update the current scope to match. */
7648 DECL_ARGUMENTS (fndecl
) = 0;
7650 for (parm
= parmids
; parm
; parm
= TREE_CHAIN (parm
))
7651 if (TREE_PURPOSE (parm
))
7653 if (parm
&& TREE_PURPOSE (parm
))
7655 last
= TREE_PURPOSE (parm
);
7656 DECL_ARGUMENTS (fndecl
) = last
;
7658 for (parm
= TREE_CHAIN (parm
); parm
; parm
= TREE_CHAIN (parm
))
7659 if (TREE_PURPOSE (parm
))
7661 TREE_CHAIN (last
) = TREE_PURPOSE (parm
);
7662 last
= TREE_PURPOSE (parm
);
7664 TREE_CHAIN (last
) = 0;
7667 pointer_set_destroy (seen_args
);
7669 /* If there was a previous prototype,
7670 set the DECL_ARG_TYPE of each argument according to
7671 the type previously specified, and report any mismatches. */
7673 if (current_function_prototype_arg_types
)
7676 for (parm
= DECL_ARGUMENTS (fndecl
),
7677 type
= current_function_prototype_arg_types
;
7678 parm
|| (type
&& TREE_VALUE (type
) != error_mark_node
7679 && (TYPE_MAIN_VARIANT (TREE_VALUE (type
)) != void_type_node
));
7680 parm
= TREE_CHAIN (parm
), type
= TREE_CHAIN (type
))
7682 if (parm
== 0 || type
== 0
7683 || TYPE_MAIN_VARIANT (TREE_VALUE (type
)) == void_type_node
)
7685 if (current_function_prototype_built_in
)
7686 warning_at (DECL_SOURCE_LOCATION (fndecl
),
7687 0, "number of arguments doesn%'t match "
7688 "built-in prototype");
7691 /* FIXME diagnostics: This should be the location of
7692 FNDECL, but there is bug when a prototype is
7693 declared inside function context, but defined
7694 outside of it (e.g., gcc.dg/pr15698-2.c). In
7695 which case FNDECL gets the location of the
7696 prototype, not the definition. */
7697 error_at (input_location
,
7698 "number of arguments doesn%'t match prototype");
7700 error_at (current_function_prototype_locus
,
7701 "prototype declaration");
7705 /* Type for passing arg must be consistent with that
7706 declared for the arg. ISO C says we take the unqualified
7707 type for parameters declared with qualified type. */
7708 if (TREE_TYPE (parm
) != error_mark_node
7709 && TREE_TYPE (type
) != error_mark_node
7710 && !comptypes (TYPE_MAIN_VARIANT (DECL_ARG_TYPE (parm
)),
7711 TYPE_MAIN_VARIANT (TREE_VALUE (type
))))
7713 if (TYPE_MAIN_VARIANT (TREE_TYPE (parm
))
7714 == TYPE_MAIN_VARIANT (TREE_VALUE (type
)))
7716 /* Adjust argument to match prototype. E.g. a previous
7717 `int foo(float);' prototype causes
7718 `int foo(x) float x; {...}' to be treated like
7719 `int foo(float x) {...}'. This is particularly
7720 useful for argument types like uid_t. */
7721 DECL_ARG_TYPE (parm
) = TREE_TYPE (parm
);
7723 if (targetm
.calls
.promote_prototypes (TREE_TYPE (current_function_decl
))
7724 && INTEGRAL_TYPE_P (TREE_TYPE (parm
))
7725 && TYPE_PRECISION (TREE_TYPE (parm
))
7726 < TYPE_PRECISION (integer_type_node
))
7727 DECL_ARG_TYPE (parm
) = integer_type_node
;
7729 /* ??? Is it possible to get here with a
7730 built-in prototype or will it always have
7731 been diagnosed as conflicting with an
7732 old-style definition and discarded? */
7733 if (current_function_prototype_built_in
)
7734 warning_at (DECL_SOURCE_LOCATION (parm
),
7735 OPT_pedantic
, "promoted argument %qD "
7736 "doesn%'t match built-in prototype", parm
);
7739 pedwarn (DECL_SOURCE_LOCATION (parm
),
7740 OPT_pedantic
, "promoted argument %qD "
7741 "doesn%'t match prototype", parm
);
7742 pedwarn (current_function_prototype_locus
, OPT_pedantic
,
7743 "prototype declaration");
7748 if (current_function_prototype_built_in
)
7749 warning_at (DECL_SOURCE_LOCATION (parm
),
7750 0, "argument %qD doesn%'t match "
7751 "built-in prototype", parm
);
7754 error_at (DECL_SOURCE_LOCATION (parm
),
7755 "argument %qD doesn%'t match prototype", parm
);
7756 error_at (current_function_prototype_locus
,
7757 "prototype declaration");
7762 TYPE_ACTUAL_ARG_TYPES (TREE_TYPE (fndecl
)) = 0;
7765 /* Otherwise, create a prototype that would match. */
7769 tree actual
= 0, last
= 0, type
;
7771 for (parm
= DECL_ARGUMENTS (fndecl
); parm
; parm
= TREE_CHAIN (parm
))
7773 type
= tree_cons (NULL_TREE
, DECL_ARG_TYPE (parm
), NULL_TREE
);
7775 TREE_CHAIN (last
) = type
;
7780 type
= tree_cons (NULL_TREE
, void_type_node
, NULL_TREE
);
7782 TREE_CHAIN (last
) = type
;
7786 /* We are going to assign a new value for the TYPE_ACTUAL_ARG_TYPES
7787 of the type of this function, but we need to avoid having this
7788 affect the types of other similarly-typed functions, so we must
7789 first force the generation of an identical (but separate) type
7790 node for the relevant function type. The new node we create
7791 will be a variant of the main variant of the original function
7794 TREE_TYPE (fndecl
) = build_variant_type_copy (TREE_TYPE (fndecl
));
7796 TYPE_ACTUAL_ARG_TYPES (TREE_TYPE (fndecl
)) = actual
;
7800 /* Store parameter declarations passed in ARG_INFO into the current
7801 function declaration. */
7804 store_parm_decls_from (struct c_arg_info
*arg_info
)
7806 current_function_arg_info
= arg_info
;
7807 store_parm_decls ();
7810 /* Store the parameter declarations into the current function declaration.
7811 This is called after parsing the parameter declarations, before
7812 digesting the body of the function.
7814 For an old-style definition, construct a prototype out of the old-style
7815 parameter declarations and inject it into the function's type. */
7818 store_parm_decls (void)
7820 tree fndecl
= current_function_decl
;
7823 /* The argument information block for FNDECL. */
7824 struct c_arg_info
*arg_info
= current_function_arg_info
;
7825 current_function_arg_info
= 0;
7827 /* True if this definition is written with a prototype. Note:
7828 despite C99 6.7.5.3p14, we can *not* treat an empty argument
7829 list in a function definition as equivalent to (void) -- an
7830 empty argument list specifies the function has no parameters,
7831 but only (void) sets up a prototype for future calls. */
7832 proto
= arg_info
->types
!= 0;
7835 store_parm_decls_newstyle (fndecl
, arg_info
);
7837 store_parm_decls_oldstyle (fndecl
, arg_info
);
7839 /* The next call to push_scope will be a function body. */
7841 next_is_function_body
= true;
7843 /* Write a record describing this function definition to the prototypes
7844 file (if requested). */
7846 gen_aux_info_record (fndecl
, 1, 0, proto
);
7848 /* Initialize the RTL code for the function. */
7849 allocate_struct_function (fndecl
, false);
7851 /* Begin the statement tree for this function. */
7852 DECL_SAVED_TREE (fndecl
) = push_stmt_list ();
7854 /* ??? Insert the contents of the pending sizes list into the function
7855 to be evaluated. The only reason left to have this is
7856 void foo(int n, int array[n++])
7857 because we throw away the array type in favor of a pointer type, and
7858 thus won't naturally see the SAVE_EXPR containing the increment. All
7859 other pending sizes would be handled by gimplify_parameters. */
7862 for (t
= nreverse (get_pending_sizes ()); t
; t
= TREE_CHAIN (t
))
7863 add_stmt (TREE_VALUE (t
));
7866 /* Even though we're inside a function body, we still don't want to
7867 call expand_expr to calculate the size of a variable-sized array.
7868 We haven't necessarily assigned RTL to all variables yet, so it's
7869 not safe to try to expand expressions involving them. */
7870 cfun
->dont_save_pending_sizes_p
= 1;
7874 /* Finish up a function declaration and compile that function
7875 all the way to assembler language output. The free the storage
7876 for the function definition.
7878 This is called after parsing the body of the function definition. */
7881 finish_function (void)
7883 tree fndecl
= current_function_decl
;
7885 if (TREE_CODE (fndecl
) == FUNCTION_DECL
7886 && targetm
.calls
.promote_prototypes (TREE_TYPE (fndecl
)))
7888 tree args
= DECL_ARGUMENTS (fndecl
);
7889 for (; args
; args
= TREE_CHAIN (args
))
7891 tree type
= TREE_TYPE (args
);
7892 if (INTEGRAL_TYPE_P (type
)
7893 && TYPE_PRECISION (type
) < TYPE_PRECISION (integer_type_node
))
7894 DECL_ARG_TYPE (args
) = integer_type_node
;
7898 if (DECL_INITIAL (fndecl
) && DECL_INITIAL (fndecl
) != error_mark_node
)
7899 BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl
)) = fndecl
;
7901 /* Must mark the RESULT_DECL as being in this function. */
7903 if (DECL_RESULT (fndecl
) && DECL_RESULT (fndecl
) != error_mark_node
)
7904 DECL_CONTEXT (DECL_RESULT (fndecl
)) = fndecl
;
7906 if (MAIN_NAME_P (DECL_NAME (fndecl
)) && flag_hosted
7907 && TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (fndecl
)))
7908 == integer_type_node
&& flag_isoc99
)
7910 /* Hack. We don't want the middle-end to warn that this return
7911 is unreachable, so we mark its location as special. Using
7912 UNKNOWN_LOCATION has the problem that it gets clobbered in
7913 annotate_one_with_locus. A cleaner solution might be to
7914 ensure ! should_carry_locus_p (stmt), but that needs a flag.
7916 c_finish_return (BUILTINS_LOCATION
, integer_zero_node
, NULL_TREE
);
7919 /* Tie off the statement tree for this function. */
7920 DECL_SAVED_TREE (fndecl
) = pop_stmt_list (DECL_SAVED_TREE (fndecl
));
7922 finish_fname_decls ();
7924 /* Complain if there's just no return statement. */
7925 if (warn_return_type
7926 && TREE_CODE (TREE_TYPE (TREE_TYPE (fndecl
))) != VOID_TYPE
7927 && !current_function_returns_value
&& !current_function_returns_null
7928 /* Don't complain if we are no-return. */
7929 && !current_function_returns_abnormally
7930 /* Don't warn for main(). */
7931 && !MAIN_NAME_P (DECL_NAME (fndecl
))
7932 /* Or if they didn't actually specify a return type. */
7933 && !C_FUNCTION_IMPLICIT_INT (fndecl
)
7934 /* Normally, with -Wreturn-type, flow will complain, but we might
7935 optimize out static functions. */
7936 && !TREE_PUBLIC (fndecl
))
7938 warning (OPT_Wreturn_type
,
7939 "no return statement in function returning non-void");
7940 TREE_NO_WARNING (fndecl
) = 1;
7943 /* Store the end of the function, so that we get good line number
7944 info for the epilogue. */
7945 cfun
->function_end_locus
= input_location
;
7947 /* Finalize the ELF visibility for the function. */
7948 c_determine_visibility (fndecl
);
7950 /* For GNU C extern inline functions disregard inline limits. */
7951 if (DECL_EXTERNAL (fndecl
)
7952 && DECL_DECLARED_INLINE_P (fndecl
))
7953 DECL_DISREGARD_INLINE_LIMITS (fndecl
) = 1;
7955 /* Genericize before inlining. Delay genericizing nested functions
7956 until their parent function is genericized. Since finalizing
7957 requires GENERIC, delay that as well. */
7959 if (DECL_INITIAL (fndecl
) && DECL_INITIAL (fndecl
) != error_mark_node
7960 && !undef_nested_function
)
7962 if (!decl_function_context (fndecl
))
7964 c_genericize (fndecl
);
7966 /* ??? Objc emits functions after finalizing the compilation unit.
7967 This should be cleaned up later and this conditional removed. */
7968 if (cgraph_global_info_ready
)
7970 cgraph_add_new_function (fndecl
, false);
7973 cgraph_finalize_function (fndecl
, false);
7977 /* Register this function with cgraph just far enough to get it
7978 added to our parent's nested function list. Handy, since the
7979 C front end doesn't have such a list. */
7980 (void) cgraph_node (fndecl
);
7984 if (!decl_function_context (fndecl
))
7985 undef_nested_function
= false;
7987 /* We're leaving the context of this function, so zap cfun.
7988 It's still in DECL_STRUCT_FUNCTION, and we'll restore it in
7989 tree_rest_of_compilation. */
7991 current_function_decl
= NULL
;
7994 /* Check the declarations given in a for-loop for satisfying the C99
7995 constraints. If exactly one such decl is found, return it. LOC is
7996 the location of the opening parenthesis of the for loop. */
7999 check_for_loop_decls (location_t loc
)
8001 struct c_binding
*b
;
8002 tree one_decl
= NULL_TREE
;
8007 static bool hint
= true;
8008 /* If we get here, declarations have been used in a for loop without
8009 the C99 for loop scope. This doesn't make much sense, so don't
8011 error_at (loc
, "%<for%> loop initial declarations "
8012 "are only allowed in C99 mode");
8016 "use option -std=c99 or -std=gnu99 to compile your code");
8021 /* C99 subclause 6.8.5 paragraph 3:
8023 [#3] The declaration part of a for statement shall only
8024 declare identifiers for objects having storage class auto or
8027 It isn't clear whether, in this sentence, "identifiers" binds to
8028 "shall only declare" or to "objects" - that is, whether all identifiers
8029 declared must be identifiers for objects, or whether the restriction
8030 only applies to those that are. (A question on this in comp.std.c
8031 in November 2000 received no answer.) We implement the strictest
8032 interpretation, to avoid creating an extension which later causes
8035 for (b
= current_scope
->bindings
; b
; b
= b
->prev
)
8038 tree decl
= b
->decl
;
8043 switch (TREE_CODE (decl
))
8047 location_t decl_loc
= DECL_SOURCE_LOCATION (decl
);
8048 if (TREE_STATIC (decl
))
8050 "declaration of static variable %qD in %<for%> loop "
8051 "initial declaration", decl
);
8052 else if (DECL_EXTERNAL (decl
))
8054 "declaration of %<extern%> variable %qD in %<for%> loop "
8055 "initial declaration", decl
);
8061 "%<struct %E%> declared in %<for%> loop initial "
8066 "%<union %E%> declared in %<for%> loop initial declaration",
8070 error_at (loc
, "%<enum %E%> declared in %<for%> loop "
8071 "initial declaration", id
);
8074 error_at (loc
, "declaration of non-variable "
8075 "%qD in %<for%> loop initial declaration", decl
);
8082 return n_decls
== 1 ? one_decl
: NULL_TREE
;
8085 /* Save and reinitialize the variables
8086 used during compilation of a C function. */
8089 c_push_function_context (void)
8091 struct language_function
*p
;
8092 p
= GGC_NEW (struct language_function
);
8095 p
->base
.x_stmt_tree
= c_stmt_tree
;
8096 p
->x_break_label
= c_break_label
;
8097 p
->x_cont_label
= c_cont_label
;
8098 p
->x_switch_stack
= c_switch_stack
;
8099 p
->arg_info
= current_function_arg_info
;
8100 p
->returns_value
= current_function_returns_value
;
8101 p
->returns_null
= current_function_returns_null
;
8102 p
->returns_abnormally
= current_function_returns_abnormally
;
8103 p
->warn_about_return_type
= warn_about_return_type
;
8105 push_function_context ();
8108 /* Restore the variables used during compilation of a C function. */
8111 c_pop_function_context (void)
8113 struct language_function
*p
;
8115 pop_function_context ();
8117 cfun
->language
= NULL
;
8119 if (DECL_STRUCT_FUNCTION (current_function_decl
) == 0
8120 && DECL_SAVED_TREE (current_function_decl
) == NULL_TREE
)
8122 /* Stop pointing to the local nodes about to be freed. */
8123 /* But DECL_INITIAL must remain nonzero so we know this
8124 was an actual function definition. */
8125 DECL_INITIAL (current_function_decl
) = error_mark_node
;
8126 DECL_ARGUMENTS (current_function_decl
) = 0;
8129 c_stmt_tree
= p
->base
.x_stmt_tree
;
8130 c_break_label
= p
->x_break_label
;
8131 c_cont_label
= p
->x_cont_label
;
8132 c_switch_stack
= p
->x_switch_stack
;
8133 current_function_arg_info
= p
->arg_info
;
8134 current_function_returns_value
= p
->returns_value
;
8135 current_function_returns_null
= p
->returns_null
;
8136 current_function_returns_abnormally
= p
->returns_abnormally
;
8137 warn_about_return_type
= p
->warn_about_return_type
;
8140 /* The functions below are required for functionality of doing
8141 function at once processing in the C front end. Currently these
8142 functions are not called from anywhere in the C front end, but as
8143 these changes continue, that will change. */
8145 /* Returns the stmt_tree (if any) to which statements are currently
8146 being added. If there is no active statement-tree, NULL is
8150 current_stmt_tree (void)
8152 return &c_stmt_tree
;
8155 /* Return the global value of T as a symbol. */
8158 identifier_global_value (tree t
)
8160 struct c_binding
*b
;
8162 for (b
= I_SYMBOL_BINDING (t
); b
; b
= b
->shadowed
)
8163 if (B_IN_FILE_SCOPE (b
) || B_IN_EXTERNAL_SCOPE (b
))
8169 /* Record a builtin type for C. If NAME is non-NULL, it is the name used;
8170 otherwise the name is found in ridpointers from RID_INDEX. */
8173 record_builtin_type (enum rid rid_index
, const char *name
, tree type
)
8177 id
= ridpointers
[(int) rid_index
];
8179 id
= get_identifier (name
);
8180 decl
= build_decl (UNKNOWN_LOCATION
, TYPE_DECL
, id
, type
);
8182 if (debug_hooks
->type_decl
)
8183 debug_hooks
->type_decl (decl
, false);
8186 /* Build the void_list_node (void_type_node having been created). */
8188 build_void_list_node (void)
8190 tree t
= build_tree_list (NULL_TREE
, void_type_node
);
8194 /* Return a c_parm structure with the given SPECS, ATTRS and DECLARATOR. */
8197 build_c_parm (struct c_declspecs
*specs
, tree attrs
,
8198 struct c_declarator
*declarator
)
8200 struct c_parm
*ret
= XOBNEW (&parser_obstack
, struct c_parm
);
8203 ret
->declarator
= declarator
;
8207 /* Return a declarator with nested attributes. TARGET is the inner
8208 declarator to which these attributes apply. ATTRS are the
8211 struct c_declarator
*
8212 build_attrs_declarator (tree attrs
, struct c_declarator
*target
)
8214 struct c_declarator
*ret
= XOBNEW (&parser_obstack
, struct c_declarator
);
8215 ret
->kind
= cdk_attrs
;
8216 ret
->declarator
= target
;
8217 ret
->u
.attrs
= attrs
;
8221 /* Return a declarator for a function with arguments specified by ARGS
8222 and return type specified by TARGET. */
8224 struct c_declarator
*
8225 build_function_declarator (struct c_arg_info
*args
,
8226 struct c_declarator
*target
)
8228 struct c_declarator
*ret
= XOBNEW (&parser_obstack
, struct c_declarator
);
8229 ret
->kind
= cdk_function
;
8230 ret
->declarator
= target
;
8231 ret
->u
.arg_info
= args
;
8235 /* Return a declarator for the identifier IDENT (which may be
8236 NULL_TREE for an abstract declarator). */
8238 struct c_declarator
*
8239 build_id_declarator (tree ident
)
8241 struct c_declarator
*ret
= XOBNEW (&parser_obstack
, struct c_declarator
);
8243 ret
->declarator
= 0;
8245 /* Default value - may get reset to a more precise location. */
8246 ret
->id_loc
= input_location
;
8250 /* Return something to represent absolute declarators containing a *.
8251 TARGET is the absolute declarator that the * contains.
8252 TYPE_QUALS_ATTRS is a structure for type qualifiers and attributes
8253 to apply to the pointer type. */
8255 struct c_declarator
*
8256 make_pointer_declarator (struct c_declspecs
*type_quals_attrs
,
8257 struct c_declarator
*target
)
8261 struct c_declarator
*itarget
= target
;
8262 struct c_declarator
*ret
= XOBNEW (&parser_obstack
, struct c_declarator
);
8263 if (type_quals_attrs
)
8265 attrs
= type_quals_attrs
->attrs
;
8266 quals
= quals_from_declspecs (type_quals_attrs
);
8267 if (attrs
!= NULL_TREE
)
8268 itarget
= build_attrs_declarator (attrs
, target
);
8270 ret
->kind
= cdk_pointer
;
8271 ret
->declarator
= itarget
;
8272 ret
->u
.pointer_quals
= quals
;
8276 /* Return a pointer to a structure for an empty list of declaration
8279 struct c_declspecs
*
8280 build_null_declspecs (void)
8282 struct c_declspecs
*ret
= XOBNEW (&parser_obstack
, struct c_declspecs
);
8287 ret
->typespec_word
= cts_none
;
8288 ret
->storage_class
= csc_none
;
8289 ret
->expr_const_operands
= true;
8290 ret
->declspecs_seen_p
= false;
8291 ret
->type_seen_p
= false;
8292 ret
->non_sc_seen_p
= false;
8293 ret
->typedef_p
= false;
8294 ret
->tag_defined_p
= false;
8295 ret
->explicit_signed_p
= false;
8296 ret
->deprecated_p
= false;
8297 ret
->default_int_p
= false;
8298 ret
->long_p
= false;
8299 ret
->long_long_p
= false;
8300 ret
->short_p
= false;
8301 ret
->signed_p
= false;
8302 ret
->unsigned_p
= false;
8303 ret
->complex_p
= false;
8304 ret
->inline_p
= false;
8305 ret
->thread_p
= false;
8306 ret
->const_p
= false;
8307 ret
->volatile_p
= false;
8308 ret
->restrict_p
= false;
8309 ret
->saturating_p
= false;
8313 /* Add the type qualifier QUAL to the declaration specifiers SPECS,
8316 struct c_declspecs
*
8317 declspecs_add_qual (struct c_declspecs
*specs
, tree qual
)
8321 specs
->non_sc_seen_p
= true;
8322 specs
->declspecs_seen_p
= true;
8323 gcc_assert (TREE_CODE (qual
) == IDENTIFIER_NODE
8324 && C_IS_RESERVED_WORD (qual
));
8325 i
= C_RID_CODE (qual
);
8329 dupe
= specs
->const_p
;
8330 specs
->const_p
= true;
8333 dupe
= specs
->volatile_p
;
8334 specs
->volatile_p
= true;
8337 dupe
= specs
->restrict_p
;
8338 specs
->restrict_p
= true;
8343 if (dupe
&& !flag_isoc99
)
8344 pedwarn (input_location
, OPT_pedantic
, "duplicate %qE", qual
);
8348 /* Add the type specifier TYPE to the declaration specifiers SPECS,
8351 struct c_declspecs
*
8352 declspecs_add_type (location_t loc
, struct c_declspecs
*specs
,
8353 struct c_typespec spec
)
8355 tree type
= spec
.spec
;
8356 specs
->non_sc_seen_p
= true;
8357 specs
->declspecs_seen_p
= true;
8358 specs
->type_seen_p
= true;
8359 if (TREE_DEPRECATED (type
))
8360 specs
->deprecated_p
= true;
8362 /* Handle type specifier keywords. */
8363 if (TREE_CODE (type
) == IDENTIFIER_NODE
8364 && C_IS_RESERVED_WORD (type
)
8365 && C_RID_CODE (type
) != RID_CXX_COMPAT_WARN
)
8367 enum rid i
= C_RID_CODE (type
);
8370 error_at (loc
, "two or more data types in declaration specifiers");
8373 if ((int) i
<= (int) RID_LAST_MODIFIER
)
8375 /* "long", "short", "signed", "unsigned", "_Complex" or "_Sat". */
8380 if (specs
->long_long_p
)
8382 error_at (loc
, "%<long long long%> is too long for GCC");
8387 if (specs
->typespec_word
== cts_double
)
8390 ("both %<long long%> and %<double%> in "
8391 "declaration specifiers"));
8394 pedwarn_c90 (loc
, OPT_Wlong_long
,
8395 "ISO C90 does not support %<long long%>");
8396 specs
->long_long_p
= 1;
8401 ("both %<long%> and %<short%> in "
8402 "declaration specifiers"));
8403 else if (specs
->typespec_word
== cts_void
)
8405 ("both %<long%> and %<void%> in "
8406 "declaration specifiers"));
8407 else if (specs
->typespec_word
== cts_bool
)
8409 ("both %<long%> and %<_Bool%> in "
8410 "declaration specifiers"));
8411 else if (specs
->typespec_word
== cts_char
)
8413 ("both %<long%> and %<char%> in "
8414 "declaration specifiers"));
8415 else if (specs
->typespec_word
== cts_float
)
8417 ("both %<long%> and %<float%> in "
8418 "declaration specifiers"));
8419 else if (specs
->typespec_word
== cts_dfloat32
)
8421 ("both %<long%> and %<_Decimal32%> in "
8422 "declaration specifiers"));
8423 else if (specs
->typespec_word
== cts_dfloat64
)
8425 ("both %<long%> and %<_Decimal64%> in "
8426 "declaration specifiers"));
8427 else if (specs
->typespec_word
== cts_dfloat128
)
8429 ("both %<long%> and %<_Decimal128%> in "
8430 "declaration specifiers"));
8432 specs
->long_p
= true;
8435 dupe
= specs
->short_p
;
8438 ("both %<long%> and %<short%> in "
8439 "declaration specifiers"));
8440 else if (specs
->typespec_word
== cts_void
)
8442 ("both %<short%> and %<void%> in "
8443 "declaration specifiers"));
8444 else if (specs
->typespec_word
== cts_bool
)
8446 ("both %<short%> and %<_Bool%> in "
8447 "declaration specifiers"));
8448 else if (specs
->typespec_word
== cts_char
)
8450 ("both %<short%> and %<char%> in "
8451 "declaration specifiers"));
8452 else if (specs
->typespec_word
== cts_float
)
8454 ("both %<short%> and %<float%> in "
8455 "declaration specifiers"));
8456 else if (specs
->typespec_word
== cts_double
)
8458 ("both %<short%> and %<double%> in "
8459 "declaration specifiers"));
8460 else if (specs
->typespec_word
== cts_dfloat32
)
8462 ("both %<short%> and %<_Decimal32%> in "
8463 "declaration specifiers"));
8464 else if (specs
->typespec_word
== cts_dfloat64
)
8466 ("both %<short%> and %<_Decimal64%> in "
8467 "declaration specifiers"));
8468 else if (specs
->typespec_word
== cts_dfloat128
)
8470 ("both %<short%> and %<_Decimal128%> in "
8471 "declaration specifiers"));
8473 specs
->short_p
= true;
8476 dupe
= specs
->signed_p
;
8477 if (specs
->unsigned_p
)
8479 ("both %<signed%> and %<unsigned%> in "
8480 "declaration specifiers"));
8481 else if (specs
->typespec_word
== cts_void
)
8483 ("both %<signed%> and %<void%> in "
8484 "declaration specifiers"));
8485 else if (specs
->typespec_word
== cts_bool
)
8487 ("both %<signed%> and %<_Bool%> in "
8488 "declaration specifiers"));
8489 else if (specs
->typespec_word
== cts_float
)
8491 ("both %<signed%> and %<float%> in "
8492 "declaration specifiers"));
8493 else if (specs
->typespec_word
== cts_double
)
8495 ("both %<signed%> and %<double%> in "
8496 "declaration specifiers"));
8497 else if (specs
->typespec_word
== cts_dfloat32
)
8499 ("both %<signed%> and %<_Decimal32%> in "
8500 "declaration specifiers"));
8501 else if (specs
->typespec_word
== cts_dfloat64
)
8503 ("both %<signed%> and %<_Decimal64%> in "
8504 "declaration specifiers"));
8505 else if (specs
->typespec_word
== cts_dfloat128
)
8507 ("both %<signed%> and %<_Decimal128%> in "
8508 "declaration specifiers"));
8510 specs
->signed_p
= true;
8513 dupe
= specs
->unsigned_p
;
8514 if (specs
->signed_p
)
8516 ("both %<signed%> and %<unsigned%> in "
8517 "declaration specifiers"));
8518 else if (specs
->typespec_word
== cts_void
)
8520 ("both %<unsigned%> and %<void%> in "
8521 "declaration specifiers"));
8522 else if (specs
->typespec_word
== cts_bool
)
8524 ("both %<unsigned%> and %<_Bool%> in "
8525 "declaration specifiers"));
8526 else if (specs
->typespec_word
== cts_float
)
8528 ("both %<unsigned%> and %<float%> in "
8529 "declaration specifiers"));
8530 else if (specs
->typespec_word
== cts_double
)
8532 ("both %<unsigned%> and %<double%> in "
8533 "declaration specifiers"));
8534 else if (specs
->typespec_word
== cts_dfloat32
)
8536 ("both %<unsigned%> and %<_Decimal32%> in "
8537 "declaration specifiers"));
8538 else if (specs
->typespec_word
== cts_dfloat64
)
8540 ("both %<unsigned%> and %<_Decimal64%> in "
8541 "declaration specifiers"));
8542 else if (specs
->typespec_word
== cts_dfloat128
)
8544 ("both %<unsigned%> and %<_Decimal128%> in "
8545 "declaration specifiers"));
8547 specs
->unsigned_p
= true;
8550 dupe
= specs
->complex_p
;
8551 if (!flag_isoc99
&& !in_system_header
)
8552 pedwarn (loc
, OPT_pedantic
,
8553 "ISO C90 does not support complex types");
8554 if (specs
->typespec_word
== cts_void
)
8556 ("both %<complex%> and %<void%> in "
8557 "declaration specifiers"));
8558 else if (specs
->typespec_word
== cts_bool
)
8560 ("both %<complex%> and %<_Bool%> in "
8561 "declaration specifiers"));
8562 else if (specs
->typespec_word
== cts_dfloat32
)
8564 ("both %<complex%> and %<_Decimal32%> in "
8565 "declaration specifiers"));
8566 else if (specs
->typespec_word
== cts_dfloat64
)
8568 ("both %<complex%> and %<_Decimal64%> in "
8569 "declaration specifiers"));
8570 else if (specs
->typespec_word
== cts_dfloat128
)
8572 ("both %<complex%> and %<_Decimal128%> in "
8573 "declaration specifiers"));
8574 else if (specs
->typespec_word
== cts_fract
)
8576 ("both %<complex%> and %<_Fract%> in "
8577 "declaration specifiers"));
8578 else if (specs
->typespec_word
== cts_accum
)
8580 ("both %<complex%> and %<_Accum%> in "
8581 "declaration specifiers"));
8582 else if (specs
->saturating_p
)
8584 ("both %<complex%> and %<_Sat%> in "
8585 "declaration specifiers"));
8587 specs
->complex_p
= true;
8590 dupe
= specs
->saturating_p
;
8591 pedwarn (loc
, OPT_pedantic
,
8592 "ISO C does not support saturating types");
8593 if (specs
->typespec_word
== cts_void
)
8595 ("both %<_Sat%> and %<void%> in "
8596 "declaration specifiers"));
8597 else if (specs
->typespec_word
== cts_bool
)
8599 ("both %<_Sat%> and %<_Bool%> in "
8600 "declaration specifiers"));
8601 else if (specs
->typespec_word
== cts_char
)
8603 ("both %<_Sat%> and %<char%> in "
8604 "declaration specifiers"));
8605 else if (specs
->typespec_word
== cts_int
)
8607 ("both %<_Sat%> and %<int%> in "
8608 "declaration specifiers"));
8609 else if (specs
->typespec_word
== cts_float
)
8611 ("both %<_Sat%> and %<float%> in "
8612 "declaration specifiers"));
8613 else if (specs
->typespec_word
== cts_double
)
8615 ("both %<_Sat%> and %<double%> in "
8616 "declaration specifiers"));
8617 else if (specs
->typespec_word
== cts_dfloat32
)
8619 ("both %<_Sat%> and %<_Decimal32%> in "
8620 "declaration specifiers"));
8621 else if (specs
->typespec_word
== cts_dfloat64
)
8623 ("both %<_Sat%> and %<_Decimal64%> in "
8624 "declaration specifiers"));
8625 else if (specs
->typespec_word
== cts_dfloat128
)
8627 ("both %<_Sat%> and %<_Decimal128%> in "
8628 "declaration specifiers"));
8629 else if (specs
->complex_p
)
8631 ("both %<_Sat%> and %<complex%> in "
8632 "declaration specifiers"));
8634 specs
->saturating_p
= true;
8641 error_at (loc
, "duplicate %qE", type
);
8647 /* "void", "_Bool", "char", "int", "float", "double", "_Decimal32",
8648 "_Decimal64", "_Decimal128", "_Fract" or "_Accum". */
8649 if (specs
->typespec_word
!= cts_none
)
8652 "two or more data types in declaration specifiers");
8660 ("both %<long%> and %<void%> in "
8661 "declaration specifiers"));
8662 else if (specs
->short_p
)
8664 ("both %<short%> and %<void%> in "
8665 "declaration specifiers"));
8666 else if (specs
->signed_p
)
8668 ("both %<signed%> and %<void%> in "
8669 "declaration specifiers"));
8670 else if (specs
->unsigned_p
)
8672 ("both %<unsigned%> and %<void%> in "
8673 "declaration specifiers"));
8674 else if (specs
->complex_p
)
8676 ("both %<complex%> and %<void%> in "
8677 "declaration specifiers"));
8678 else if (specs
->saturating_p
)
8680 ("both %<_Sat%> and %<void%> in "
8681 "declaration specifiers"));
8683 specs
->typespec_word
= cts_void
;
8688 ("both %<long%> and %<_Bool%> in "
8689 "declaration specifiers"));
8690 else if (specs
->short_p
)
8692 ("both %<short%> and %<_Bool%> in "
8693 "declaration specifiers"));
8694 else if (specs
->signed_p
)
8696 ("both %<signed%> and %<_Bool%> in "
8697 "declaration specifiers"));
8698 else if (specs
->unsigned_p
)
8700 ("both %<unsigned%> and %<_Bool%> in "
8701 "declaration specifiers"));
8702 else if (specs
->complex_p
)
8704 ("both %<complex%> and %<_Bool%> in "
8705 "declaration specifiers"));
8706 else if (specs
->saturating_p
)
8708 ("both %<_Sat%> and %<_Bool%> in "
8709 "declaration specifiers"));
8711 specs
->typespec_word
= cts_bool
;
8716 ("both %<long%> and %<char%> in "
8717 "declaration specifiers"));
8718 else if (specs
->short_p
)
8720 ("both %<short%> and %<char%> in "
8721 "declaration specifiers"));
8722 else if (specs
->saturating_p
)
8724 ("both %<_Sat%> and %<char%> in "
8725 "declaration specifiers"));
8727 specs
->typespec_word
= cts_char
;
8730 if (specs
->saturating_p
)
8732 ("both %<_Sat%> and %<int%> in "
8733 "declaration specifiers"));
8735 specs
->typespec_word
= cts_int
;
8740 ("both %<long%> and %<float%> in "
8741 "declaration specifiers"));
8742 else if (specs
->short_p
)
8744 ("both %<short%> and %<float%> in "
8745 "declaration specifiers"));
8746 else if (specs
->signed_p
)
8748 ("both %<signed%> and %<float%> in "
8749 "declaration specifiers"));
8750 else if (specs
->unsigned_p
)
8752 ("both %<unsigned%> and %<float%> in "
8753 "declaration specifiers"));
8754 else if (specs
->saturating_p
)
8756 ("both %<_Sat%> and %<float%> in "
8757 "declaration specifiers"));
8759 specs
->typespec_word
= cts_float
;
8762 if (specs
->long_long_p
)
8764 ("both %<long long%> and %<double%> in "
8765 "declaration specifiers"));
8766 else if (specs
->short_p
)
8768 ("both %<short%> and %<double%> in "
8769 "declaration specifiers"));
8770 else if (specs
->signed_p
)
8772 ("both %<signed%> and %<double%> in "
8773 "declaration specifiers"));
8774 else if (specs
->unsigned_p
)
8776 ("both %<unsigned%> and %<double%> in "
8777 "declaration specifiers"));
8778 else if (specs
->saturating_p
)
8780 ("both %<_Sat%> and %<double%> in "
8781 "declaration specifiers"));
8783 specs
->typespec_word
= cts_double
;
8790 if (i
== RID_DFLOAT32
)
8792 else if (i
== RID_DFLOAT64
)
8795 str
= "_Decimal128";
8796 if (specs
->long_long_p
)
8798 ("both %<long long%> and %<%s%> in "
8799 "declaration specifiers"),
8803 ("both %<long%> and %<%s%> in "
8804 "declaration specifiers"),
8806 else if (specs
->short_p
)
8808 ("both %<short%> and %<%s%> in "
8809 "declaration specifiers"),
8811 else if (specs
->signed_p
)
8813 ("both %<signed%> and %<%s%> in "
8814 "declaration specifiers"),
8816 else if (specs
->unsigned_p
)
8818 ("both %<unsigned%> and %<%s%> in "
8819 "declaration specifiers"),
8821 else if (specs
->complex_p
)
8823 ("both %<complex%> and %<%s%> in "
8824 "declaration specifiers"),
8826 else if (specs
->saturating_p
)
8828 ("both %<_Sat%> and %<%s%> in "
8829 "declaration specifiers"),
8831 else if (i
== RID_DFLOAT32
)
8832 specs
->typespec_word
= cts_dfloat32
;
8833 else if (i
== RID_DFLOAT64
)
8834 specs
->typespec_word
= cts_dfloat64
;
8836 specs
->typespec_word
= cts_dfloat128
;
8838 if (!targetm
.decimal_float_supported_p ())
8840 ("decimal floating point not supported "
8841 "for this target"));
8842 pedwarn (loc
, OPT_pedantic
,
8843 "ISO C does not support decimal floating point");
8853 if (specs
->complex_p
)
8855 ("both %<complex%> and %<%s%> in "
8856 "declaration specifiers"),
8858 else if (i
== RID_FRACT
)
8859 specs
->typespec_word
= cts_fract
;
8861 specs
->typespec_word
= cts_accum
;
8863 if (!targetm
.fixed_point_supported_p ())
8865 "fixed-point types not supported for this target");
8866 pedwarn (loc
, OPT_pedantic
,
8867 "ISO C does not support fixed-point types");
8870 /* ObjC reserved word "id", handled below. */
8876 /* Now we have a typedef (a TYPE_DECL node), an identifier (some
8877 form of ObjC type, cases such as "int" and "long" being handled
8878 above), a TYPE (struct, union, enum and typeof specifiers) or an
8879 ERROR_MARK. In none of these cases may there have previously
8880 been any type specifiers. */
8881 if (specs
->type
|| specs
->typespec_word
!= cts_none
8882 || specs
->long_p
|| specs
->short_p
|| specs
->signed_p
8883 || specs
->unsigned_p
|| specs
->complex_p
)
8884 error_at (loc
, "two or more data types in declaration specifiers");
8885 else if (TREE_CODE (type
) == TYPE_DECL
)
8887 if (TREE_TYPE (type
) == error_mark_node
)
8888 ; /* Allow the type to default to int to avoid cascading errors. */
8891 specs
->type
= TREE_TYPE (type
);
8892 specs
->decl_attr
= DECL_ATTRIBUTES (type
);
8893 specs
->typedef_p
= true;
8894 specs
->explicit_signed_p
= C_TYPEDEF_EXPLICITLY_SIGNED (type
);
8896 /* If this typedef name is defined in a struct, then a C++
8897 lookup would return a different value. */
8899 && I_SYMBOL_BINDING (DECL_NAME (type
))->in_struct
)
8900 warning_at (loc
, OPT_Wc___compat
,
8901 "C++ lookup of %qD would return a field, not a type",
8904 /* If we are parsing a struct, record that a struct field
8906 if (warn_cxx_compat
&& struct_parse_info
!= NULL
)
8907 VEC_safe_push (tree
, heap
, struct_parse_info
->typedefs_seen
, type
);
8910 else if (TREE_CODE (type
) == IDENTIFIER_NODE
)
8912 tree t
= lookup_name (type
);
8913 if (!t
|| TREE_CODE (t
) != TYPE_DECL
)
8914 error_at (loc
, "%qE fails to be a typedef or built in type", type
);
8915 else if (TREE_TYPE (t
) == error_mark_node
)
8918 specs
->type
= TREE_TYPE (t
);
8920 else if (TREE_CODE (type
) != ERROR_MARK
)
8922 if (spec
.kind
== ctsk_tagdef
|| spec
.kind
== ctsk_tagfirstref
)
8923 specs
->tag_defined_p
= true;
8924 if (spec
.kind
== ctsk_typeof
)
8926 specs
->typedef_p
= true;
8930 specs
->expr
= build2 (COMPOUND_EXPR
, TREE_TYPE (spec
.expr
),
8931 specs
->expr
, spec
.expr
);
8933 specs
->expr
= spec
.expr
;
8934 specs
->expr_const_operands
&= spec
.expr_const_operands
;
8943 /* Add the storage class specifier or function specifier SCSPEC to the
8944 declaration specifiers SPECS, returning SPECS. */
8946 struct c_declspecs
*
8947 declspecs_add_scspec (struct c_declspecs
*specs
, tree scspec
)
8950 enum c_storage_class n
= csc_none
;
8952 specs
->declspecs_seen_p
= true;
8953 gcc_assert (TREE_CODE (scspec
) == IDENTIFIER_NODE
8954 && C_IS_RESERVED_WORD (scspec
));
8955 i
= C_RID_CODE (scspec
);
8956 if (specs
->non_sc_seen_p
)
8957 warning (OPT_Wold_style_declaration
,
8958 "%qE is not at beginning of declaration", scspec
);
8962 /* C99 permits duplicate inline. Although of doubtful utility,
8963 it seems simplest to permit it in gnu89 mode as well, as
8964 there is also little utility in maintaining this as a
8965 difference between gnu89 and C99 inline. */
8967 specs
->inline_p
= true;
8970 dupe
= specs
->thread_p
;
8971 if (specs
->storage_class
== csc_auto
)
8972 error ("%<__thread%> used with %<auto%>");
8973 else if (specs
->storage_class
== csc_register
)
8974 error ("%<__thread%> used with %<register%>");
8975 else if (specs
->storage_class
== csc_typedef
)
8976 error ("%<__thread%> used with %<typedef%>");
8978 specs
->thread_p
= true;
8985 /* Diagnose "__thread extern". */
8986 if (specs
->thread_p
)
8987 error ("%<__thread%> before %<extern%>");
8994 /* Diagnose "__thread static". */
8995 if (specs
->thread_p
)
8996 error ("%<__thread%> before %<static%>");
9004 if (n
!= csc_none
&& n
== specs
->storage_class
)
9007 error ("duplicate %qE", scspec
);
9010 if (specs
->storage_class
!= csc_none
&& n
!= specs
->storage_class
)
9012 error ("multiple storage classes in declaration specifiers");
9016 specs
->storage_class
= n
;
9017 if (n
!= csc_extern
&& n
!= csc_static
&& specs
->thread_p
)
9019 error ("%<__thread%> used with %qE", scspec
);
9020 specs
->thread_p
= false;
9027 /* Add the attributes ATTRS to the declaration specifiers SPECS,
9030 struct c_declspecs
*
9031 declspecs_add_attrs (struct c_declspecs
*specs
, tree attrs
)
9033 specs
->attrs
= chainon (attrs
, specs
->attrs
);
9034 specs
->declspecs_seen_p
= true;
9038 /* Combine "long", "short", "signed", "unsigned" and "_Complex" type
9039 specifiers with any other type specifier to determine the resulting
9040 type. This is where ISO C checks on complex types are made, since
9041 "_Complex long" is a prefix of the valid ISO C type "_Complex long
9044 struct c_declspecs
*
9045 finish_declspecs (struct c_declspecs
*specs
)
9047 /* If a type was specified as a whole, we have no modifiers and are
9049 if (specs
->type
!= NULL_TREE
)
9051 gcc_assert (!specs
->long_p
&& !specs
->long_long_p
&& !specs
->short_p
9052 && !specs
->signed_p
&& !specs
->unsigned_p
9053 && !specs
->complex_p
);
9057 /* If none of "void", "_Bool", "char", "int", "float" or "double"
9058 has been specified, treat it as "int" unless "_Complex" is
9059 present and there are no other specifiers. If we just have
9060 "_Complex", it is equivalent to "_Complex double", but e.g.
9061 "_Complex short" is equivalent to "_Complex short int". */
9062 if (specs
->typespec_word
== cts_none
)
9064 if (specs
->saturating_p
)
9066 error ("%<_Sat%> is used without %<_Fract%> or %<_Accum%>");
9067 if (!targetm
.fixed_point_supported_p ())
9068 error ("fixed-point types not supported for this target");
9069 specs
->typespec_word
= cts_fract
;
9071 else if (specs
->long_p
|| specs
->short_p
9072 || specs
->signed_p
|| specs
->unsigned_p
)
9074 specs
->typespec_word
= cts_int
;
9076 else if (specs
->complex_p
)
9078 specs
->typespec_word
= cts_double
;
9079 pedwarn (input_location
, OPT_pedantic
,
9080 "ISO C does not support plain %<complex%> meaning "
9081 "%<double complex%>");
9085 specs
->typespec_word
= cts_int
;
9086 specs
->default_int_p
= true;
9087 /* We don't diagnose this here because grokdeclarator will
9088 give more specific diagnostics according to whether it is
9089 a function definition. */
9093 /* If "signed" was specified, record this to distinguish "int" and
9094 "signed int" in the case of a bit-field with
9095 -funsigned-bitfields. */
9096 specs
->explicit_signed_p
= specs
->signed_p
;
9098 /* Now compute the actual type. */
9099 switch (specs
->typespec_word
)
9102 gcc_assert (!specs
->long_p
&& !specs
->short_p
9103 && !specs
->signed_p
&& !specs
->unsigned_p
9104 && !specs
->complex_p
);
9105 specs
->type
= void_type_node
;
9108 gcc_assert (!specs
->long_p
&& !specs
->short_p
9109 && !specs
->signed_p
&& !specs
->unsigned_p
9110 && !specs
->complex_p
);
9111 specs
->type
= boolean_type_node
;
9114 gcc_assert (!specs
->long_p
&& !specs
->short_p
);
9115 gcc_assert (!(specs
->signed_p
&& specs
->unsigned_p
));
9116 if (specs
->signed_p
)
9117 specs
->type
= signed_char_type_node
;
9118 else if (specs
->unsigned_p
)
9119 specs
->type
= unsigned_char_type_node
;
9121 specs
->type
= char_type_node
;
9122 if (specs
->complex_p
)
9124 pedwarn (input_location
, OPT_pedantic
,
9125 "ISO C does not support complex integer types");
9126 specs
->type
= build_complex_type (specs
->type
);
9130 gcc_assert (!(specs
->long_p
&& specs
->short_p
));
9131 gcc_assert (!(specs
->signed_p
&& specs
->unsigned_p
));
9132 if (specs
->long_long_p
)
9133 specs
->type
= (specs
->unsigned_p
9134 ? long_long_unsigned_type_node
9135 : long_long_integer_type_node
);
9136 else if (specs
->long_p
)
9137 specs
->type
= (specs
->unsigned_p
9138 ? long_unsigned_type_node
9139 : long_integer_type_node
);
9140 else if (specs
->short_p
)
9141 specs
->type
= (specs
->unsigned_p
9142 ? short_unsigned_type_node
9143 : short_integer_type_node
);
9145 specs
->type
= (specs
->unsigned_p
9146 ? unsigned_type_node
9147 : integer_type_node
);
9148 if (specs
->complex_p
)
9150 pedwarn (input_location
, OPT_pedantic
,
9151 "ISO C does not support complex integer types");
9152 specs
->type
= build_complex_type (specs
->type
);
9156 gcc_assert (!specs
->long_p
&& !specs
->short_p
9157 && !specs
->signed_p
&& !specs
->unsigned_p
);
9158 specs
->type
= (specs
->complex_p
9159 ? complex_float_type_node
9163 gcc_assert (!specs
->long_long_p
&& !specs
->short_p
9164 && !specs
->signed_p
&& !specs
->unsigned_p
);
9167 specs
->type
= (specs
->complex_p
9168 ? complex_long_double_type_node
9169 : long_double_type_node
);
9173 specs
->type
= (specs
->complex_p
9174 ? complex_double_type_node
9175 : double_type_node
);
9181 gcc_assert (!specs
->long_p
&& !specs
->long_long_p
&& !specs
->short_p
9182 && !specs
->signed_p
&& !specs
->unsigned_p
&& !specs
->complex_p
);
9183 if (specs
->typespec_word
== cts_dfloat32
)
9184 specs
->type
= dfloat32_type_node
;
9185 else if (specs
->typespec_word
== cts_dfloat64
)
9186 specs
->type
= dfloat64_type_node
;
9188 specs
->type
= dfloat128_type_node
;
9191 gcc_assert (!specs
->complex_p
);
9192 if (!targetm
.fixed_point_supported_p ())
9193 specs
->type
= integer_type_node
;
9194 else if (specs
->saturating_p
)
9196 if (specs
->long_long_p
)
9197 specs
->type
= specs
->unsigned_p
9198 ? sat_unsigned_long_long_fract_type_node
9199 : sat_long_long_fract_type_node
;
9200 else if (specs
->long_p
)
9201 specs
->type
= specs
->unsigned_p
9202 ? sat_unsigned_long_fract_type_node
9203 : sat_long_fract_type_node
;
9204 else if (specs
->short_p
)
9205 specs
->type
= specs
->unsigned_p
9206 ? sat_unsigned_short_fract_type_node
9207 : sat_short_fract_type_node
;
9209 specs
->type
= specs
->unsigned_p
9210 ? sat_unsigned_fract_type_node
9211 : sat_fract_type_node
;
9215 if (specs
->long_long_p
)
9216 specs
->type
= specs
->unsigned_p
9217 ? unsigned_long_long_fract_type_node
9218 : long_long_fract_type_node
;
9219 else if (specs
->long_p
)
9220 specs
->type
= specs
->unsigned_p
9221 ? unsigned_long_fract_type_node
9222 : long_fract_type_node
;
9223 else if (specs
->short_p
)
9224 specs
->type
= specs
->unsigned_p
9225 ? unsigned_short_fract_type_node
9226 : short_fract_type_node
;
9228 specs
->type
= specs
->unsigned_p
9229 ? unsigned_fract_type_node
9234 gcc_assert (!specs
->complex_p
);
9235 if (!targetm
.fixed_point_supported_p ())
9236 specs
->type
= integer_type_node
;
9237 else if (specs
->saturating_p
)
9239 if (specs
->long_long_p
)
9240 specs
->type
= specs
->unsigned_p
9241 ? sat_unsigned_long_long_accum_type_node
9242 : sat_long_long_accum_type_node
;
9243 else if (specs
->long_p
)
9244 specs
->type
= specs
->unsigned_p
9245 ? sat_unsigned_long_accum_type_node
9246 : sat_long_accum_type_node
;
9247 else if (specs
->short_p
)
9248 specs
->type
= specs
->unsigned_p
9249 ? sat_unsigned_short_accum_type_node
9250 : sat_short_accum_type_node
;
9252 specs
->type
= specs
->unsigned_p
9253 ? sat_unsigned_accum_type_node
9254 : sat_accum_type_node
;
9258 if (specs
->long_long_p
)
9259 specs
->type
= specs
->unsigned_p
9260 ? unsigned_long_long_accum_type_node
9261 : long_long_accum_type_node
;
9262 else if (specs
->long_p
)
9263 specs
->type
= specs
->unsigned_p
9264 ? unsigned_long_accum_type_node
9265 : long_accum_type_node
;
9266 else if (specs
->short_p
)
9267 specs
->type
= specs
->unsigned_p
9268 ? unsigned_short_accum_type_node
9269 : short_accum_type_node
;
9271 specs
->type
= specs
->unsigned_p
9272 ? unsigned_accum_type_node
9283 /* A subroutine of c_write_global_declarations. Perform final processing
9284 on one file scope's declarations (or the external scope's declarations),
9288 c_write_global_declarations_1 (tree globals
)
9293 /* Process the decls in the order they were written. */
9294 for (decl
= globals
; decl
; decl
= TREE_CHAIN (decl
))
9296 /* Check for used but undefined static functions using the C
9297 standard's definition of "used", and set TREE_NO_WARNING so
9298 that check_global_declarations doesn't repeat the check. */
9299 if (TREE_CODE (decl
) == FUNCTION_DECL
9300 && DECL_INITIAL (decl
) == 0
9301 && DECL_EXTERNAL (decl
)
9302 && !TREE_PUBLIC (decl
)
9303 && C_DECL_USED (decl
))
9305 pedwarn (input_location
, 0, "%q+F used but never defined", decl
);
9306 TREE_NO_WARNING (decl
) = 1;
9309 wrapup_global_declaration_1 (decl
);
9315 for (decl
= globals
; decl
; decl
= TREE_CHAIN (decl
))
9316 reconsider
|= wrapup_global_declaration_2 (decl
);
9320 for (decl
= globals
; decl
; decl
= TREE_CHAIN (decl
))
9321 check_global_declaration_1 (decl
);
9324 /* A subroutine of c_write_global_declarations Emit debug information for each
9325 of the declarations in GLOBALS. */
9328 c_write_global_declarations_2 (tree globals
)
9332 for (decl
= globals
; decl
; decl
= TREE_CHAIN (decl
))
9333 debug_hooks
->global_decl (decl
);
9336 /* Preserve the external declarations scope across a garbage collect. */
9337 static GTY(()) tree ext_block
;
9340 c_write_global_declarations (void)
9344 /* We don't want to do this if generating a PCH. */
9348 /* Don't waste time on further processing if -fsyntax-only.
9349 Continue for warning and errors issued during lowering though. */
9350 if (flag_syntax_only
)
9353 /* Close the external scope. */
9354 ext_block
= pop_scope ();
9356 gcc_assert (!current_scope
);
9360 tree tmp
= BLOCK_VARS (ext_block
);
9362 FILE * stream
= dump_begin (TDI_tu
, &flags
);
9365 dump_node (tmp
, flags
& ~TDF_SLIM
, stream
);
9366 dump_end (TDI_tu
, stream
);
9370 /* Process all file scopes in this compilation, and the external_scope,
9371 through wrapup_global_declarations and check_global_declarations. */
9372 for (t
= all_translation_units
; t
; t
= TREE_CHAIN (t
))
9373 c_write_global_declarations_1 (BLOCK_VARS (DECL_INITIAL (t
)));
9374 c_write_global_declarations_1 (BLOCK_VARS (ext_block
));
9376 /* We're done parsing; proceed to optimize and emit assembly.
9377 FIXME: shouldn't be the front end's responsibility to call this. */
9378 cgraph_finalize_compilation_unit ();
9380 /* After cgraph has had a chance to emit everything that's going to
9381 be emitted, output debug information for globals. */
9382 if (errorcount
== 0 && sorrycount
== 0)
9384 timevar_push (TV_SYMOUT
);
9385 for (t
= all_translation_units
; t
; t
= TREE_CHAIN (t
))
9386 c_write_global_declarations_2 (BLOCK_VARS (DECL_INITIAL (t
)));
9387 c_write_global_declarations_2 (BLOCK_VARS (ext_block
));
9388 timevar_pop (TV_SYMOUT
);
9394 #include "gt-c-decl.h"