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, 2010
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"
48 #include "c-family/c-common.h"
49 #include "c-family/c-objc.h"
50 #include "c-family/c-pragma.h"
52 #include "langhooks.h"
53 #include "tree-mudflap.h"
54 #include "tree-iterator.h"
55 #include "diagnostic-core.h"
56 #include "tree-dump.h"
59 #include "langhooks-def.h"
60 #include "pointer-set.h"
62 #include "c-family/c-ada-spec.h"
64 /* In grokdeclarator, distinguish syntactic contexts of declarators. */
66 { NORMAL
, /* Ordinary declaration */
67 FUNCDEF
, /* Function definition */
68 PARM
, /* Declaration of parm before function body */
69 FIELD
, /* Declaration inside struct or union */
70 TYPENAME
}; /* Typename (inside cast or sizeof) */
72 /* States indicating how grokdeclarator() should handle declspecs marked
73 with __attribute__((deprecated)). An object declared as
74 __attribute__((deprecated)) suppresses warnings of uses of other
77 enum deprecated_states
{
83 /* Nonzero if we have seen an invalid cross reference
84 to a struct, union, or enum, but not yet printed the message. */
85 tree pending_invalid_xref
;
87 /* File and line to appear in the eventual error message. */
88 location_t pending_invalid_xref_location
;
90 /* The file and line that the prototype came from if this is an
91 old-style definition; used for diagnostics in
92 store_parm_decls_oldstyle. */
94 static location_t current_function_prototype_locus
;
96 /* Whether this prototype was built-in. */
98 static bool current_function_prototype_built_in
;
100 /* The argument type information of this prototype. */
102 static tree current_function_prototype_arg_types
;
104 /* The argument information structure for the function currently being
107 static struct c_arg_info
*current_function_arg_info
;
109 /* The obstack on which parser and related data structures, which are
110 not live beyond their top-level declaration or definition, are
112 struct obstack parser_obstack
;
114 /* The current statement tree. */
116 static GTY(()) struct stmt_tree_s c_stmt_tree
;
118 /* State saving variables. */
122 /* A list of decls to be made automatically visible in each file scope. */
123 static GTY(()) tree visible_builtins
;
125 /* Set to 0 at beginning of a function definition, set to 1 if
126 a return statement that specifies a return value is seen. */
128 int current_function_returns_value
;
130 /* Set to 0 at beginning of a function definition, set to 1 if
131 a return statement with no argument is seen. */
133 int current_function_returns_null
;
135 /* Set to 0 at beginning of a function definition, set to 1 if
136 a call to a noreturn function is seen. */
138 int current_function_returns_abnormally
;
140 /* Set to nonzero by `grokdeclarator' for a function
141 whose return type is defaulted, if warnings for this are desired. */
143 static int warn_about_return_type
;
145 /* Nonzero when the current toplevel function contains a declaration
146 of a nested function which is never defined. */
148 static bool undef_nested_function
;
150 /* True means global_bindings_p should return false even if the scope stack
151 says we are in file scope. */
152 bool c_override_global_bindings_to_false
;
155 /* Each c_binding structure describes one binding of an identifier to
156 a decl. All the decls in a scope - irrespective of namespace - are
157 chained together by the ->prev field, which (as the name implies)
158 runs in reverse order. All the decls in a given namespace bound to
159 a given identifier are chained by the ->shadowed field, which runs
160 from inner to outer scopes.
162 The ->decl field usually points to a DECL node, but there are two
163 exceptions. In the namespace of type tags, the bound entity is a
164 RECORD_TYPE, UNION_TYPE, or ENUMERAL_TYPE node. If an undeclared
165 identifier is encountered, it is bound to error_mark_node to
166 suppress further errors about that identifier in the current
169 The ->u.type field stores the type of the declaration in this scope;
170 if NULL, the type is the type of the ->decl field. This is only of
171 relevance for objects with external or internal linkage which may
172 be redeclared in inner scopes, forming composite types that only
173 persist for the duration of those scopes. In the external scope,
174 this stores the composite of all the types declared for this
175 object, visible or not. The ->inner_comp field (used only at file
176 scope) stores whether an incomplete array type at file scope was
177 completed at an inner scope to an array size other than 1.
179 The ->u.label field is used for labels. It points to a structure
180 which stores additional information used for warnings.
182 The depth field is copied from the scope structure that holds this
183 decl. It is used to preserve the proper ordering of the ->shadowed
184 field (see bind()) and also for a handful of special-case checks.
185 Finally, the invisible bit is true for a decl which should be
186 ignored for purposes of normal name lookup, and the nested bit is
187 true for a decl that's been bound a second time in an inner scope;
188 in all such cases, the binding in the outer scope will have its
189 invisible bit true. */
191 struct GTY((chain_next ("%h.prev"))) c_binding
{
192 union GTY(()) { /* first so GTY desc can use decl */
193 tree
GTY((tag ("0"))) type
; /* the type in this scope */
194 struct c_label_vars
* GTY((tag ("1"))) label
; /* for warnings */
195 } GTY((desc ("TREE_CODE (%0.decl) == LABEL_DECL"))) u
;
196 tree decl
; /* the decl bound */
197 tree id
; /* the identifier it's bound to */
198 struct c_binding
*prev
; /* the previous decl in this scope */
199 struct c_binding
*shadowed
; /* the innermost decl shadowed by this one */
200 unsigned int depth
: 28; /* depth of this scope */
201 BOOL_BITFIELD invisible
: 1; /* normal lookup should ignore this binding */
202 BOOL_BITFIELD nested
: 1; /* do not set DECL_CONTEXT when popping */
203 BOOL_BITFIELD inner_comp
: 1; /* incomplete array completed in inner scope */
204 BOOL_BITFIELD in_struct
: 1; /* currently defined as struct field */
205 location_t locus
; /* location for nested bindings */
207 #define B_IN_SCOPE(b1, b2) ((b1)->depth == (b2)->depth)
208 #define B_IN_CURRENT_SCOPE(b) ((b)->depth == current_scope->depth)
209 #define B_IN_FILE_SCOPE(b) ((b)->depth == 1 /*file_scope->depth*/)
210 #define B_IN_EXTERNAL_SCOPE(b) ((b)->depth == 0 /*external_scope->depth*/)
212 #define I_SYMBOL_BINDING(node) \
213 (((struct lang_identifier *) IDENTIFIER_NODE_CHECK(node))->symbol_binding)
214 #define I_SYMBOL_DECL(node) \
215 (I_SYMBOL_BINDING(node) ? I_SYMBOL_BINDING(node)->decl : 0)
217 #define I_TAG_BINDING(node) \
218 (((struct lang_identifier *) IDENTIFIER_NODE_CHECK(node))->tag_binding)
219 #define I_TAG_DECL(node) \
220 (I_TAG_BINDING(node) ? I_TAG_BINDING(node)->decl : 0)
222 #define I_LABEL_BINDING(node) \
223 (((struct lang_identifier *) IDENTIFIER_NODE_CHECK(node))->label_binding)
224 #define I_LABEL_DECL(node) \
225 (I_LABEL_BINDING(node) ? I_LABEL_BINDING(node)->decl : 0)
227 /* Each C symbol points to three linked lists of c_binding structures.
228 These describe the values of the identifier in the three different
229 namespaces defined by the language. */
231 struct GTY(()) lang_identifier
{
232 struct c_common_identifier common_id
;
233 struct c_binding
*symbol_binding
; /* vars, funcs, constants, typedefs */
234 struct c_binding
*tag_binding
; /* struct/union/enum tags */
235 struct c_binding
*label_binding
; /* labels */
238 /* Validate c-lang.c's assumptions. */
239 extern char C_SIZEOF_STRUCT_LANG_IDENTIFIER_isnt_accurate
240 [(sizeof(struct lang_identifier
) == C_SIZEOF_STRUCT_LANG_IDENTIFIER
) ? 1 : -1];
242 /* The resulting tree type. */
244 union GTY((desc ("TREE_CODE (&%h.generic) == IDENTIFIER_NODE"),
245 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
247 union tree_node
GTY ((tag ("0"),
248 desc ("tree_node_structure (&%h)")))
250 struct lang_identifier
GTY ((tag ("1"))) identifier
;
253 /* Track bindings and other things that matter for goto warnings. For
254 efficiency, we do not gather all the decls at the point of
255 definition. Instead, we point into the bindings structure. As
256 scopes are popped, we update these structures and gather the decls
257 that matter at that time. */
259 struct GTY(()) c_spot_bindings
{
260 /* The currently open scope which holds bindings defined when the
261 label was defined or the goto statement was found. */
262 struct c_scope
*scope
;
263 /* The bindings in the scope field which were defined at the point
264 of the label or goto. This lets us look at older or newer
265 bindings in the scope, as appropriate. */
266 struct c_binding
*bindings_in_scope
;
267 /* The number of statement expressions that have started since this
268 label or goto statement was defined. This is zero if we are at
269 the same statement expression level. It is positive if we are in
270 a statement expression started since this spot. It is negative
271 if this spot was in a statement expression and we have left
274 /* Whether we started in a statement expression but are no longer in
275 it. This is set to true if stmt_exprs ever goes negative. */
279 /* This structure is used to keep track of bindings seen when a goto
280 statement is defined. This is only used if we see the goto
281 statement before we see the label. */
283 struct GTY(()) c_goto_bindings
{
284 /* The location of the goto statement. */
286 /* The bindings of the goto statement. */
287 struct c_spot_bindings goto_bindings
;
290 typedef struct c_goto_bindings
*c_goto_bindings_p
;
291 DEF_VEC_P(c_goto_bindings_p
);
292 DEF_VEC_ALLOC_P(c_goto_bindings_p
,gc
);
294 /* The additional information we keep track of for a label binding.
295 These fields are updated as scopes are popped. */
297 struct GTY(()) c_label_vars
{
298 /* The shadowed c_label_vars, when one label shadows another (which
299 can only happen using a __label__ declaration). */
300 struct c_label_vars
*shadowed
;
301 /* The bindings when the label was defined. */
302 struct c_spot_bindings label_bindings
;
303 /* A list of decls that we care about: decls about which we should
304 warn if a goto branches to this label from later in the function.
305 Decls are added to this list as scopes are popped. We only add
306 the decls that matter. */
307 VEC(tree
,gc
) *decls_in_scope
;
308 /* A list of goto statements to this label. This is only used for
309 goto statements seen before the label was defined, so that we can
310 issue appropriate warnings for them. */
311 VEC(c_goto_bindings_p
,gc
) *gotos
;
314 /* Each c_scope structure describes the complete contents of one
315 scope. Four scopes are distinguished specially: the innermost or
316 current scope, the innermost function scope, the file scope (always
317 the second to outermost) and the outermost or external scope.
319 Most declarations are recorded in the current scope.
321 All normal label declarations are recorded in the innermost
322 function scope, as are bindings of undeclared identifiers to
323 error_mark_node. (GCC permits nested functions as an extension,
324 hence the 'innermost' qualifier.) Explicitly declared labels
325 (using the __label__ extension) appear in the current scope.
327 Being in the file scope (current_scope == file_scope) causes
328 special behavior in several places below. Also, under some
329 conditions the Objective-C front end records declarations in the
330 file scope even though that isn't the current scope.
332 All declarations with external linkage are recorded in the external
333 scope, even if they aren't visible there; this models the fact that
334 such declarations are visible to the entire program, and (with a
335 bit of cleverness, see pushdecl) allows diagnosis of some violations
336 of C99 6.2.2p7 and 6.2.7p2:
338 If, within the same translation unit, the same identifier appears
339 with both internal and external linkage, the behavior is
342 All declarations that refer to the same object or function shall
343 have compatible type; otherwise, the behavior is undefined.
345 Initially only the built-in declarations, which describe compiler
346 intrinsic functions plus a subset of the standard library, are in
349 The order of the blocks list matters, and it is frequently appended
350 to. To avoid having to walk all the way to the end of the list on
351 each insertion, or reverse the list later, we maintain a pointer to
352 the last list entry. (FIXME: It should be feasible to use a reversed
355 The bindings list is strictly in reverse order of declarations;
356 pop_scope relies on this. */
359 struct GTY((chain_next ("%h.outer"))) c_scope
{
360 /* The scope containing this one. */
361 struct c_scope
*outer
;
363 /* The next outermost function scope. */
364 struct c_scope
*outer_function
;
366 /* All bindings in this scope. */
367 struct c_binding
*bindings
;
369 /* For each scope (except the global one), a chain of BLOCK nodes
370 for all the scopes that were entered and exited one level down. */
374 /* The depth of this scope. Used to keep the ->shadowed chain of
375 bindings sorted innermost to outermost. */
376 unsigned int depth
: 28;
378 /* True if we are currently filling this scope with parameter
380 BOOL_BITFIELD parm_flag
: 1;
382 /* True if we saw [*] in this scope. Used to give an error messages
383 if these appears in a function definition. */
384 BOOL_BITFIELD had_vla_unspec
: 1;
386 /* True if we already complained about forward parameter decls
387 in this scope. This prevents double warnings on
388 foo (int a; int b; ...) */
389 BOOL_BITFIELD warned_forward_parm_decls
: 1;
391 /* True if this is the outermost block scope of a function body.
392 This scope contains the parameters, the local variables declared
393 in the outermost block, and all the labels (except those in
394 nested functions, or declared at block scope with __label__). */
395 BOOL_BITFIELD function_body
: 1;
397 /* True means make a BLOCK for this scope no matter what. */
398 BOOL_BITFIELD keep
: 1;
400 /* True means that an unsuffixed float constant is _Decimal64. */
401 BOOL_BITFIELD float_const_decimal64
: 1;
403 /* True if this scope has any label bindings. This is used to speed
404 up searching for labels when popping scopes, particularly since
405 labels are normally only found at function scope. */
406 BOOL_BITFIELD has_label_bindings
: 1;
408 /* True if we should issue a warning if a goto statement crosses any
409 of the bindings. We still need to check the list of bindings to
410 find the specific ones we need to warn about. This is true if
411 decl_jump_unsafe would return true for any of the bindings. This
412 is used to avoid looping over all the bindings unnecessarily. */
413 BOOL_BITFIELD has_jump_unsafe_decl
: 1;
416 /* The scope currently in effect. */
418 static GTY(()) struct c_scope
*current_scope
;
420 /* The innermost function scope. Ordinary (not explicitly declared)
421 labels, bindings to error_mark_node, and the lazily-created
422 bindings of __func__ and its friends get this scope. */
424 static GTY(()) struct c_scope
*current_function_scope
;
426 /* The C file scope. This is reset for each input translation unit. */
428 static GTY(()) struct c_scope
*file_scope
;
430 /* The outermost scope. This is used for all declarations with
431 external linkage, and only these, hence the name. */
433 static GTY(()) struct c_scope
*external_scope
;
435 /* A chain of c_scope structures awaiting reuse. */
437 static GTY((deletable
)) struct c_scope
*scope_freelist
;
439 /* A chain of c_binding structures awaiting reuse. */
441 static GTY((deletable
)) struct c_binding
*binding_freelist
;
443 /* Append VAR to LIST in scope SCOPE. */
444 #define SCOPE_LIST_APPEND(scope, list, decl) do { \
445 struct c_scope *s_ = (scope); \
447 if (s_->list##_last) \
448 BLOCK_CHAIN (s_->list##_last) = d_; \
451 s_->list##_last = d_; \
454 /* Concatenate FROM in scope FSCOPE onto TO in scope TSCOPE. */
455 #define SCOPE_LIST_CONCAT(tscope, to, fscope, from) do { \
456 struct c_scope *t_ = (tscope); \
457 struct c_scope *f_ = (fscope); \
459 BLOCK_CHAIN (t_->to##_last) = f_->from; \
462 t_->to##_last = f_->from##_last; \
465 /* A c_inline_static structure stores details of a static identifier
466 referenced in a definition of a function that may be an inline
467 definition if no subsequent declaration of that function uses
468 "extern" or does not use "inline". */
470 struct GTY((chain_next ("%h.next"))) c_inline_static
{
471 /* The location for a diagnostic. */
474 /* The function that may be an inline definition. */
477 /* The object or function referenced. */
480 /* What sort of reference this is. */
481 enum c_inline_static_type type
;
483 /* The next such structure or NULL. */
484 struct c_inline_static
*next
;
487 /* List of static identifiers used or referenced in functions that may
488 be inline definitions. */
489 static GTY(()) struct c_inline_static
*c_inline_statics
;
491 /* True means unconditionally make a BLOCK for the next scope pushed. */
493 static bool keep_next_level_flag
;
495 /* True means the next call to push_scope will be the outermost scope
496 of a function body, so do not push a new scope, merely cease
497 expecting parameter decls. */
499 static bool next_is_function_body
;
501 /* A VEC of pointers to c_binding structures. */
503 typedef struct c_binding
*c_binding_ptr
;
504 DEF_VEC_P(c_binding_ptr
);
505 DEF_VEC_ALLOC_P(c_binding_ptr
,heap
);
507 /* Information that we keep for a struct or union while it is being
510 struct c_struct_parse_info
512 /* If warn_cxx_compat, a list of types defined within this
514 VEC(tree
,heap
) *struct_types
;
515 /* If warn_cxx_compat, a list of field names which have bindings,
516 and which are defined in this struct, but which are not defined
517 in any enclosing struct. This is used to clear the in_struct
518 field of the c_bindings structure. */
519 VEC(c_binding_ptr
,heap
) *fields
;
520 /* If warn_cxx_compat, a list of typedef names used when defining
521 fields in this struct. */
522 VEC(tree
,heap
) *typedefs_seen
;
525 /* Information for the struct or union currently being parsed, or
526 NULL if not parsing a struct or union. */
527 static struct c_struct_parse_info
*struct_parse_info
;
529 /* Forward declarations. */
530 static tree
lookup_name_in_scope (tree
, struct c_scope
*);
531 static tree
c_make_fname_decl (location_t
, tree
, int);
532 static tree
grokdeclarator (const struct c_declarator
*,
533 struct c_declspecs
*,
534 enum decl_context
, bool, tree
*, tree
*, tree
*,
535 bool *, enum deprecated_states
);
536 static tree
grokparms (struct c_arg_info
*, bool);
537 static void layout_array_type (tree
);
539 /* T is a statement. Add it to the statement-tree. This is the
540 C/ObjC version--C++ has a slightly different version of this
546 enum tree_code code
= TREE_CODE (t
);
548 if (CAN_HAVE_LOCATION_P (t
) && code
!= LABEL_EXPR
)
550 if (!EXPR_HAS_LOCATION (t
))
551 SET_EXPR_LOCATION (t
, input_location
);
554 if (code
== LABEL_EXPR
|| code
== CASE_LABEL_EXPR
)
555 STATEMENT_LIST_HAS_LABEL (cur_stmt_list
) = 1;
557 /* Add T to the statement-tree. Non-side-effect statements need to be
558 recorded during statement expressions. */
559 append_to_statement_list_force (t
, &cur_stmt_list
);
564 /* Return true if we will want to say something if a goto statement
568 decl_jump_unsafe (tree decl
)
570 if (decl
== error_mark_node
|| TREE_TYPE (decl
) == error_mark_node
)
573 /* Always warn about crossing variably modified types. */
574 if ((TREE_CODE (decl
) == VAR_DECL
|| TREE_CODE (decl
) == TYPE_DECL
)
575 && variably_modified_type_p (TREE_TYPE (decl
), NULL_TREE
))
578 /* Otherwise, only warn if -Wgoto-misses-init and this is an
579 initialized automatic decl. */
580 if (warn_jump_misses_init
581 && TREE_CODE (decl
) == VAR_DECL
582 && !TREE_STATIC (decl
)
583 && DECL_INITIAL (decl
) != NULL_TREE
)
591 c_print_identifier (FILE *file
, tree node
, int indent
)
593 print_node (file
, "symbol", I_SYMBOL_DECL (node
), indent
+ 4);
594 print_node (file
, "tag", I_TAG_DECL (node
), indent
+ 4);
595 print_node (file
, "label", I_LABEL_DECL (node
), indent
+ 4);
596 if (C_IS_RESERVED_WORD (node
) && C_RID_CODE (node
) != RID_CXX_COMPAT_WARN
)
598 tree rid
= ridpointers
[C_RID_CODE (node
)];
599 indent_to (file
, indent
+ 4);
600 fprintf (file
, "rid " HOST_PTR_PRINTF
" \"%s\"",
601 (void *) rid
, IDENTIFIER_POINTER (rid
));
605 /* Establish a binding between NAME, an IDENTIFIER_NODE, and DECL,
606 which may be any of several kinds of DECL or TYPE or error_mark_node,
607 in the scope SCOPE. */
609 bind (tree name
, tree decl
, struct c_scope
*scope
, bool invisible
,
610 bool nested
, location_t locus
)
612 struct c_binding
*b
, **here
;
614 if (binding_freelist
)
616 b
= binding_freelist
;
617 binding_freelist
= b
->prev
;
620 b
= ggc_alloc_c_binding ();
625 b
->depth
= scope
->depth
;
626 b
->invisible
= invisible
;
634 b
->prev
= scope
->bindings
;
637 if (decl_jump_unsafe (decl
))
638 scope
->has_jump_unsafe_decl
= 1;
643 switch (TREE_CODE (decl
))
645 case LABEL_DECL
: here
= &I_LABEL_BINDING (name
); break;
648 case RECORD_TYPE
: here
= &I_TAG_BINDING (name
); break;
654 case ERROR_MARK
: here
= &I_SYMBOL_BINDING (name
); break;
660 /* Locate the appropriate place in the chain of shadowed decls
661 to insert this binding. Normally, scope == current_scope and
662 this does nothing. */
663 while (*here
&& (*here
)->depth
> scope
->depth
)
664 here
= &(*here
)->shadowed
;
670 /* Clear the binding structure B, stick it on the binding_freelist,
671 and return the former value of b->prev. This is used by pop_scope
672 and get_parm_info to iterate destructively over all the bindings
673 from a given scope. */
674 static struct c_binding
*
675 free_binding_and_advance (struct c_binding
*b
)
677 struct c_binding
*prev
= b
->prev
;
679 memset (b
, 0, sizeof (struct c_binding
));
680 b
->prev
= binding_freelist
;
681 binding_freelist
= b
;
686 /* Bind a label. Like bind, but skip fields which aren't used for
687 labels, and add the LABEL_VARS value. */
689 bind_label (tree name
, tree label
, struct c_scope
*scope
,
690 struct c_label_vars
*label_vars
)
694 bind (name
, label
, scope
, /*invisible=*/false, /*nested=*/false,
697 scope
->has_label_bindings
= true;
700 gcc_assert (b
->decl
== label
);
701 label_vars
->shadowed
= b
->u
.label
;
702 b
->u
.label
= label_vars
;
705 /* Hook called at end of compilation to assume 1 elt
706 for a file-scope tentative array defn that wasn't complete before. */
709 c_finish_incomplete_decl (tree decl
)
711 if (TREE_CODE (decl
) == VAR_DECL
)
713 tree type
= TREE_TYPE (decl
);
714 if (type
!= error_mark_node
715 && TREE_CODE (type
) == ARRAY_TYPE
716 && !DECL_EXTERNAL (decl
)
717 && TYPE_DOMAIN (type
) == 0)
719 warning_at (DECL_SOURCE_LOCATION (decl
),
720 0, "array %q+D assumed to have one element", decl
);
722 complete_array_type (&TREE_TYPE (decl
), NULL_TREE
, true);
724 layout_decl (decl
, 0);
729 /* Record that inline function FUNC contains a reference (location
730 LOC) to static DECL (file-scope or function-local according to
734 record_inline_static (location_t loc
, tree func
, tree decl
,
735 enum c_inline_static_type type
)
737 struct c_inline_static
*csi
= ggc_alloc_c_inline_static ();
739 csi
->function
= func
;
740 csi
->static_decl
= decl
;
742 csi
->next
= c_inline_statics
;
743 c_inline_statics
= csi
;
746 /* Check for references to static declarations in inline functions at
747 the end of the translation unit and diagnose them if the functions
748 are still inline definitions. */
751 check_inline_statics (void)
753 struct c_inline_static
*csi
;
754 for (csi
= c_inline_statics
; csi
; csi
= csi
->next
)
756 if (DECL_EXTERNAL (csi
->function
))
760 pedwarn (csi
->location
, 0,
761 "%qD is static but used in inline function %qD "
762 "which is not static", csi
->static_decl
, csi
->function
);
765 pedwarn (csi
->location
, 0,
766 "%q+D is static but declared in inline function %qD "
767 "which is not static", csi
->static_decl
, csi
->function
);
773 c_inline_statics
= NULL
;
776 /* Fill in a c_spot_bindings structure. If DEFINING is true, set it
777 for the current state, otherwise set it to uninitialized. */
780 set_spot_bindings (struct c_spot_bindings
*p
, bool defining
)
784 p
->scope
= current_scope
;
785 p
->bindings_in_scope
= current_scope
->bindings
;
790 p
->bindings_in_scope
= NULL
;
793 p
->left_stmt_expr
= false;
796 /* Update spot bindings P as we pop out of SCOPE. Return true if we
797 should push decls for a label. */
800 update_spot_bindings (struct c_scope
*scope
, struct c_spot_bindings
*p
)
802 if (p
->scope
!= scope
)
804 /* This label or goto is defined in some other scope, or it is a
805 label which is not yet defined. There is nothing to
810 /* Adjust the spot bindings to refer to the bindings already defined
811 in the enclosing scope. */
812 p
->scope
= scope
->outer
;
813 p
->bindings_in_scope
= p
->scope
->bindings
;
818 /* The Objective-C front-end often needs to determine the current scope. */
821 objc_get_current_scope (void)
823 return current_scope
;
826 /* The following function is used only by Objective-C. It needs to live here
827 because it accesses the innards of c_scope. */
830 objc_mark_locals_volatile (void *enclosing_blk
)
832 struct c_scope
*scope
;
835 for (scope
= current_scope
;
836 scope
&& scope
!= enclosing_blk
;
837 scope
= scope
->outer
)
839 for (b
= scope
->bindings
; b
; b
= b
->prev
)
840 objc_volatilize_decl (b
->decl
);
842 /* Do not climb up past the current function. */
843 if (scope
->function_body
)
848 /* Nonzero if we are currently in file scope. */
851 global_bindings_p (void)
853 return (current_scope
== file_scope
&& !c_override_global_bindings_to_false
859 keep_next_level (void)
861 keep_next_level_flag
= true;
864 /* Set the flag for the FLOAT_CONST_DECIMAL64 pragma being ON. */
867 set_float_const_decimal64 (void)
869 current_scope
->float_const_decimal64
= true;
872 /* Clear the flag for the FLOAT_CONST_DECIMAL64 pragma. */
875 clear_float_const_decimal64 (void)
877 current_scope
->float_const_decimal64
= false;
880 /* Return nonzero if an unsuffixed float constant is _Decimal64. */
883 float_const_decimal64_p (void)
885 return current_scope
->float_const_decimal64
;
888 /* Identify this scope as currently being filled with parameters. */
891 declare_parm_level (void)
893 current_scope
->parm_flag
= true;
899 if (next_is_function_body
)
901 /* This is the transition from the parameters to the top level
902 of the function body. These are the same scope
903 (C99 6.2.1p4,6) so we do not push another scope structure.
904 next_is_function_body is set only by store_parm_decls, which
905 in turn is called when and only when we are about to
906 encounter the opening curly brace for the function body.
908 The outermost block of a function always gets a BLOCK node,
909 because the debugging output routines expect that each
910 function has at least one BLOCK. */
911 current_scope
->parm_flag
= false;
912 current_scope
->function_body
= true;
913 current_scope
->keep
= true;
914 current_scope
->outer_function
= current_function_scope
;
915 current_function_scope
= current_scope
;
917 keep_next_level_flag
= false;
918 next_is_function_body
= false;
920 /* The FLOAT_CONST_DECIMAL64 pragma applies to nested scopes. */
921 if (current_scope
->outer
)
922 current_scope
->float_const_decimal64
923 = current_scope
->outer
->float_const_decimal64
;
925 current_scope
->float_const_decimal64
= false;
929 struct c_scope
*scope
;
932 scope
= scope_freelist
;
933 scope_freelist
= scope
->outer
;
936 scope
= ggc_alloc_cleared_c_scope ();
938 /* The FLOAT_CONST_DECIMAL64 pragma applies to nested scopes. */
940 scope
->float_const_decimal64
= current_scope
->float_const_decimal64
;
942 scope
->float_const_decimal64
= false;
944 scope
->keep
= keep_next_level_flag
;
945 scope
->outer
= current_scope
;
946 scope
->depth
= current_scope
? (current_scope
->depth
+ 1) : 0;
948 /* Check for scope depth overflow. Unlikely (2^28 == 268,435,456) but
950 if (current_scope
&& scope
->depth
== 0)
953 sorry ("GCC supports only %u nested scopes", scope
->depth
);
956 current_scope
= scope
;
957 keep_next_level_flag
= false;
961 /* This is called when we are leaving SCOPE. For each label defined
962 in SCOPE, add any appropriate decls to its decls_in_scope fields.
963 These are the decls whose initialization will be skipped by a goto
964 later in the function. */
967 update_label_decls (struct c_scope
*scope
)
974 if (s
->has_label_bindings
)
978 for (b
= s
->bindings
; b
!= NULL
; b
= b
->prev
)
980 struct c_label_vars
*label_vars
;
981 struct c_binding
*b1
;
984 struct c_goto_bindings
*g
;
986 if (TREE_CODE (b
->decl
) != LABEL_DECL
)
988 label_vars
= b
->u
.label
;
990 b1
= label_vars
->label_bindings
.bindings_in_scope
;
991 if (label_vars
->label_bindings
.scope
== NULL
)
994 hjud
= label_vars
->label_bindings
.scope
->has_jump_unsafe_decl
;
995 if (update_spot_bindings (scope
, &label_vars
->label_bindings
))
997 /* This label is defined in this scope. */
1000 for (; b1
!= NULL
; b1
= b1
->prev
)
1002 /* A goto from later in the function to this
1003 label will never see the initialization
1004 of B1, if any. Save it to issue a
1005 warning if needed. */
1006 if (decl_jump_unsafe (b1
->decl
))
1007 VEC_safe_push (tree
, gc
,
1008 label_vars
->decls_in_scope
,
1014 /* Update the bindings of any goto statements associated
1016 FOR_EACH_VEC_ELT (c_goto_bindings_p
, label_vars
->gotos
, ix
, g
)
1017 update_spot_bindings (scope
, &g
->goto_bindings
);
1021 /* Don't search beyond the current function. */
1022 if (s
== current_function_scope
)
1029 /* Set the TYPE_CONTEXT of all of TYPE's variants to CONTEXT. */
1032 set_type_context (tree type
, tree context
)
1034 for (type
= TYPE_MAIN_VARIANT (type
); type
;
1035 type
= TYPE_NEXT_VARIANT (type
))
1036 TYPE_CONTEXT (type
) = context
;
1039 /* Exit a scope. Restore the state of the identifier-decl mappings
1040 that were in effect when this scope was entered. Return a BLOCK
1041 node containing all the DECLs in this scope that are of interest
1042 to debug info generation. */
1047 struct c_scope
*scope
= current_scope
;
1048 tree block
, context
, p
;
1049 struct c_binding
*b
;
1051 bool functionbody
= scope
->function_body
;
1052 bool keep
= functionbody
|| scope
->keep
|| scope
->bindings
;
1054 update_label_decls (scope
);
1056 /* If appropriate, create a BLOCK to record the decls for the life
1057 of this function. */
1061 block
= make_node (BLOCK
);
1062 BLOCK_SUBBLOCKS (block
) = scope
->blocks
;
1063 TREE_USED (block
) = 1;
1065 /* In each subblock, record that this is its superior. */
1066 for (p
= scope
->blocks
; p
; p
= BLOCK_CHAIN (p
))
1067 BLOCK_SUPERCONTEXT (p
) = block
;
1069 BLOCK_VARS (block
) = 0;
1072 /* The TYPE_CONTEXTs for all of the tagged types belonging to this
1073 scope must be set so that they point to the appropriate
1074 construct, i.e. either to the current FUNCTION_DECL node, or
1075 else to the BLOCK node we just constructed.
1077 Note that for tagged types whose scope is just the formal
1078 parameter list for some function type specification, we can't
1079 properly set their TYPE_CONTEXTs here, because we don't have a
1080 pointer to the appropriate FUNCTION_TYPE node readily available
1081 to us. For those cases, the TYPE_CONTEXTs of the relevant tagged
1082 type nodes get set in `grokdeclarator' as soon as we have created
1083 the FUNCTION_TYPE node which will represent the "scope" for these
1084 "parameter list local" tagged types. */
1085 if (scope
->function_body
)
1086 context
= current_function_decl
;
1087 else if (scope
== file_scope
)
1089 tree file_decl
= build_translation_unit_decl (NULL_TREE
);
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 DECL_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. */
1170 if ((!TREE_USED (p
) || !DECL_READ_P (p
))
1171 && !TREE_NO_WARNING (p
)
1172 && !DECL_IN_SYSTEM_HEADER (p
)
1174 && !DECL_ARTIFICIAL (p
)
1175 && scope
!= file_scope
1176 && scope
!= external_scope
)
1179 warning (OPT_Wunused_variable
, "unused variable %q+D", p
);
1180 else if (DECL_CONTEXT (p
) == current_function_decl
)
1181 warning_at (DECL_SOURCE_LOCATION (p
),
1182 OPT_Wunused_but_set_variable
,
1183 "variable %qD set but not used", p
);
1188 error ("type of array %q+D completed incompatibly with"
1189 " implicit initialization", p
);
1196 /* All of these go in BLOCK_VARS, but only if this is the
1197 binding in the home scope. */
1200 DECL_CHAIN (p
) = BLOCK_VARS (block
);
1201 BLOCK_VARS (block
) = p
;
1203 else if (VAR_OR_FUNCTION_DECL_P (p
))
1205 /* For block local externs add a special
1206 DECL_EXTERNAL decl for debug info generation. */
1207 tree extp
= copy_node (p
);
1209 DECL_EXTERNAL (extp
) = 1;
1210 TREE_STATIC (extp
) = 0;
1211 TREE_PUBLIC (extp
) = 1;
1212 DECL_INITIAL (extp
) = NULL_TREE
;
1213 DECL_LANG_SPECIFIC (extp
) = NULL
;
1214 DECL_CONTEXT (extp
) = current_function_decl
;
1215 if (TREE_CODE (p
) == FUNCTION_DECL
)
1217 DECL_RESULT (extp
) = NULL_TREE
;
1218 DECL_SAVED_TREE (extp
) = NULL_TREE
;
1219 DECL_STRUCT_FUNCTION (extp
) = NULL
;
1221 if (b
->locus
!= UNKNOWN_LOCATION
)
1222 DECL_SOURCE_LOCATION (extp
) = b
->locus
;
1223 DECL_CHAIN (extp
) = BLOCK_VARS (block
);
1224 BLOCK_VARS (block
) = extp
;
1226 /* If this is the file scope set DECL_CONTEXT of each decl to
1227 the TRANSLATION_UNIT_DECL. This makes same_translation_unit_p
1229 if (scope
== file_scope
)
1231 DECL_CONTEXT (p
) = context
;
1232 if (TREE_CODE (p
) == TYPE_DECL
1233 && TREE_TYPE (p
) != error_mark_node
)
1234 set_type_context (TREE_TYPE (p
), context
);
1238 /* Parameters go in DECL_ARGUMENTS, not BLOCK_VARS, and have
1239 already been put there by store_parm_decls. Unused-
1240 parameter warnings are handled by function.c.
1241 error_mark_node obviously does not go in BLOCK_VARS and
1242 does not get unused-variable warnings. */
1245 /* It is possible for a decl not to have a name. We get
1246 here with b->id NULL in this case. */
1249 gcc_assert (I_SYMBOL_BINDING (b
->id
) == b
);
1250 I_SYMBOL_BINDING (b
->id
) = b
->shadowed
;
1251 if (b
->shadowed
&& b
->shadowed
->u
.type
)
1252 TREE_TYPE (b
->shadowed
->decl
) = b
->shadowed
->u
.type
;
1262 /* Dispose of the block that we just made inside some higher level. */
1263 if ((scope
->function_body
|| scope
== file_scope
) && context
)
1265 DECL_INITIAL (context
) = block
;
1266 BLOCK_SUPERCONTEXT (block
) = context
;
1268 else if (scope
->outer
)
1271 SCOPE_LIST_APPEND (scope
->outer
, blocks
, block
);
1272 /* If we did not make a block for the scope just exited, any
1273 blocks made for inner scopes must be carried forward so they
1274 will later become subblocks of something else. */
1275 else if (scope
->blocks
)
1276 SCOPE_LIST_CONCAT (scope
->outer
, blocks
, scope
, blocks
);
1279 /* Pop the current scope, and free the structure for reuse. */
1280 current_scope
= scope
->outer
;
1281 if (scope
->function_body
)
1282 current_function_scope
= scope
->outer_function
;
1284 memset (scope
, 0, sizeof (struct c_scope
));
1285 scope
->outer
= scope_freelist
;
1286 scope_freelist
= scope
;
1292 push_file_scope (void)
1300 file_scope
= current_scope
;
1302 start_fname_decls ();
1304 for (decl
= visible_builtins
; decl
; decl
= DECL_CHAIN (decl
))
1305 bind (DECL_NAME (decl
), decl
, file_scope
,
1306 /*invisible=*/false, /*nested=*/true, DECL_SOURCE_LOCATION (decl
));
1310 pop_file_scope (void)
1312 /* In case there were missing closebraces, get us back to the global
1314 while (current_scope
!= file_scope
)
1317 /* __FUNCTION__ is defined at file scope (""). This
1318 call may not be necessary as my tests indicate it
1319 still works without it. */
1320 finish_fname_decls ();
1322 check_inline_statics ();
1324 /* This is the point to write out a PCH if we're doing that.
1325 In that case we do not want to do anything else. */
1328 c_common_write_pch ();
1332 /* Pop off the file scope and close this translation unit. */
1336 maybe_apply_pending_pragma_weaks ();
1339 /* Adjust the bindings for the start of a statement expression. */
1342 c_bindings_start_stmt_expr (struct c_spot_bindings
* switch_bindings
)
1344 struct c_scope
*scope
;
1346 for (scope
= current_scope
; scope
!= NULL
; scope
= scope
->outer
)
1348 struct c_binding
*b
;
1350 if (!scope
->has_label_bindings
)
1353 for (b
= scope
->bindings
; b
!= NULL
; b
= b
->prev
)
1355 struct c_label_vars
*label_vars
;
1357 struct c_goto_bindings
*g
;
1359 if (TREE_CODE (b
->decl
) != LABEL_DECL
)
1361 label_vars
= b
->u
.label
;
1362 ++label_vars
->label_bindings
.stmt_exprs
;
1363 FOR_EACH_VEC_ELT (c_goto_bindings_p
, label_vars
->gotos
, ix
, g
)
1364 ++g
->goto_bindings
.stmt_exprs
;
1368 if (switch_bindings
!= NULL
)
1369 ++switch_bindings
->stmt_exprs
;
1372 /* Adjust the bindings for the end of a statement expression. */
1375 c_bindings_end_stmt_expr (struct c_spot_bindings
*switch_bindings
)
1377 struct c_scope
*scope
;
1379 for (scope
= current_scope
; scope
!= NULL
; scope
= scope
->outer
)
1381 struct c_binding
*b
;
1383 if (!scope
->has_label_bindings
)
1386 for (b
= scope
->bindings
; b
!= NULL
; b
= b
->prev
)
1388 struct c_label_vars
*label_vars
;
1390 struct c_goto_bindings
*g
;
1392 if (TREE_CODE (b
->decl
) != LABEL_DECL
)
1394 label_vars
= b
->u
.label
;
1395 --label_vars
->label_bindings
.stmt_exprs
;
1396 if (label_vars
->label_bindings
.stmt_exprs
< 0)
1398 label_vars
->label_bindings
.left_stmt_expr
= true;
1399 label_vars
->label_bindings
.stmt_exprs
= 0;
1401 FOR_EACH_VEC_ELT (c_goto_bindings_p
, label_vars
->gotos
, ix
, g
)
1403 --g
->goto_bindings
.stmt_exprs
;
1404 if (g
->goto_bindings
.stmt_exprs
< 0)
1406 g
->goto_bindings
.left_stmt_expr
= true;
1407 g
->goto_bindings
.stmt_exprs
= 0;
1413 if (switch_bindings
!= NULL
)
1415 --switch_bindings
->stmt_exprs
;
1416 gcc_assert (switch_bindings
->stmt_exprs
>= 0);
1420 /* Push a definition or a declaration of struct, union or enum tag "name".
1421 "type" should be the type node.
1422 We assume that the tag "name" is not already defined, and has a location
1425 Note that the definition may really be just a forward reference.
1426 In that case, the TYPE_SIZE will be zero. */
1429 pushtag (location_t loc
, tree name
, tree type
)
1431 /* Record the identifier as the type's name if it has none. */
1432 if (name
&& !TYPE_NAME (type
))
1433 TYPE_NAME (type
) = name
;
1434 bind (name
, type
, current_scope
, /*invisible=*/false, /*nested=*/false, loc
);
1436 /* Create a fake NULL-named TYPE_DECL node whose TREE_TYPE will be the
1437 tagged type we just added to the current scope. This fake
1438 NULL-named TYPE_DECL node helps dwarfout.c to know when it needs
1439 to output a representation of a tagged type, and it also gives
1440 us a convenient place to record the "scope start" address for the
1443 TYPE_STUB_DECL (type
) = pushdecl (build_decl (loc
,
1444 TYPE_DECL
, NULL_TREE
, type
));
1446 /* An approximation for now, so we can tell this is a function-scope tag.
1447 This will be updated in pop_scope. */
1448 TYPE_CONTEXT (type
) = DECL_CONTEXT (TYPE_STUB_DECL (type
));
1450 if (warn_cxx_compat
&& name
!= NULL_TREE
)
1452 struct c_binding
*b
= I_SYMBOL_BINDING (name
);
1455 && b
->decl
!= NULL_TREE
1456 && TREE_CODE (b
->decl
) == TYPE_DECL
1457 && (B_IN_CURRENT_SCOPE (b
)
1458 || (current_scope
== file_scope
&& B_IN_EXTERNAL_SCOPE (b
)))
1459 && (TYPE_MAIN_VARIANT (TREE_TYPE (b
->decl
))
1460 != TYPE_MAIN_VARIANT (type
)))
1462 warning_at (loc
, OPT_Wc___compat
,
1463 ("using %qD as both a typedef and a tag is "
1466 if (b
->locus
!= UNKNOWN_LOCATION
)
1467 inform (b
->locus
, "originally defined here");
1472 /* Subroutine of compare_decls. Allow harmless mismatches in return
1473 and argument types provided that the type modes match. This function
1474 return a unified type given a suitable match, and 0 otherwise. */
1477 match_builtin_function_types (tree newtype
, tree oldtype
)
1479 tree newrettype
, oldrettype
;
1480 tree newargs
, oldargs
;
1481 tree trytype
, tryargs
;
1483 /* Accept the return type of the new declaration if same modes. */
1484 oldrettype
= TREE_TYPE (oldtype
);
1485 newrettype
= TREE_TYPE (newtype
);
1487 if (TYPE_MODE (oldrettype
) != TYPE_MODE (newrettype
))
1490 oldargs
= TYPE_ARG_TYPES (oldtype
);
1491 newargs
= TYPE_ARG_TYPES (newtype
);
1494 while (oldargs
|| newargs
)
1498 || !TREE_VALUE (oldargs
)
1499 || !TREE_VALUE (newargs
)
1500 || TYPE_MODE (TREE_VALUE (oldargs
))
1501 != TYPE_MODE (TREE_VALUE (newargs
)))
1504 oldargs
= TREE_CHAIN (oldargs
);
1505 newargs
= TREE_CHAIN (newargs
);
1508 trytype
= build_function_type (newrettype
, tryargs
);
1509 return build_type_attribute_variant (trytype
, TYPE_ATTRIBUTES (oldtype
));
1512 /* Subroutine of diagnose_mismatched_decls. Check for function type
1513 mismatch involving an empty arglist vs a nonempty one and give clearer
1516 diagnose_arglist_conflict (tree newdecl
, tree olddecl
,
1517 tree newtype
, tree oldtype
)
1521 if (TREE_CODE (olddecl
) != FUNCTION_DECL
1522 || !comptypes (TREE_TYPE (oldtype
), TREE_TYPE (newtype
))
1523 || !((!prototype_p (oldtype
) && DECL_INITIAL (olddecl
) == 0)
1524 || (!prototype_p (newtype
) && DECL_INITIAL (newdecl
) == 0)))
1527 t
= TYPE_ARG_TYPES (oldtype
);
1529 t
= TYPE_ARG_TYPES (newtype
);
1530 for (; t
; t
= TREE_CHAIN (t
))
1532 tree type
= TREE_VALUE (t
);
1534 if (TREE_CHAIN (t
) == 0
1535 && TYPE_MAIN_VARIANT (type
) != void_type_node
)
1537 inform (input_location
, "a parameter list with an ellipsis can%'t match "
1538 "an empty parameter name list declaration");
1542 if (c_type_promotes_to (type
) != type
)
1544 inform (input_location
, "an argument type that has a default promotion can%'t match "
1545 "an empty parameter name list declaration");
1551 /* Another subroutine of diagnose_mismatched_decls. OLDDECL is an
1552 old-style function definition, NEWDECL is a prototype declaration.
1553 Diagnose inconsistencies in the argument list. Returns TRUE if
1554 the prototype is compatible, FALSE if not. */
1556 validate_proto_after_old_defn (tree newdecl
, tree newtype
, tree oldtype
)
1558 tree newargs
, oldargs
;
1561 #define END_OF_ARGLIST(t) ((t) == void_type_node)
1563 oldargs
= TYPE_ACTUAL_ARG_TYPES (oldtype
);
1564 newargs
= TYPE_ARG_TYPES (newtype
);
1569 tree oldargtype
= TREE_VALUE (oldargs
);
1570 tree newargtype
= TREE_VALUE (newargs
);
1572 if (oldargtype
== error_mark_node
|| newargtype
== error_mark_node
)
1575 oldargtype
= TYPE_MAIN_VARIANT (oldargtype
);
1576 newargtype
= TYPE_MAIN_VARIANT (newargtype
);
1578 if (END_OF_ARGLIST (oldargtype
) && END_OF_ARGLIST (newargtype
))
1581 /* Reaching the end of just one list means the two decls don't
1582 agree on the number of arguments. */
1583 if (END_OF_ARGLIST (oldargtype
))
1585 error ("prototype for %q+D declares more arguments "
1586 "than previous old-style definition", newdecl
);
1589 else if (END_OF_ARGLIST (newargtype
))
1591 error ("prototype for %q+D declares fewer arguments "
1592 "than previous old-style definition", newdecl
);
1596 /* Type for passing arg must be consistent with that declared
1598 else if (!comptypes (oldargtype
, newargtype
))
1600 error ("prototype for %q+D declares argument %d"
1601 " with incompatible type",
1606 oldargs
= TREE_CHAIN (oldargs
);
1607 newargs
= TREE_CHAIN (newargs
);
1611 /* If we get here, no errors were found, but do issue a warning
1612 for this poor-style construct. */
1613 warning (0, "prototype for %q+D follows non-prototype definition",
1616 #undef END_OF_ARGLIST
1619 /* Subroutine of diagnose_mismatched_decls. Report the location of DECL,
1620 first in a pair of mismatched declarations, using the diagnostic
1623 locate_old_decl (tree decl
)
1625 if (TREE_CODE (decl
) == FUNCTION_DECL
&& DECL_BUILT_IN (decl
))
1627 else if (DECL_INITIAL (decl
))
1628 inform (input_location
, "previous definition of %q+D was here", decl
);
1629 else if (C_DECL_IMPLICIT (decl
))
1630 inform (input_location
, "previous implicit declaration of %q+D was here", decl
);
1632 inform (input_location
, "previous declaration of %q+D was here", decl
);
1635 /* Subroutine of duplicate_decls. Compare NEWDECL to OLDDECL.
1636 Returns true if the caller should proceed to merge the two, false
1637 if OLDDECL should simply be discarded. As a side effect, issues
1638 all necessary diagnostics for invalid or poor-style combinations.
1639 If it returns true, writes the types of NEWDECL and OLDDECL to
1640 *NEWTYPEP and *OLDTYPEP - these may have been adjusted from
1641 TREE_TYPE (NEWDECL, OLDDECL) respectively. */
1644 diagnose_mismatched_decls (tree newdecl
, tree olddecl
,
1645 tree
*newtypep
, tree
*oldtypep
)
1647 tree newtype
, oldtype
;
1648 bool pedwarned
= false;
1649 bool warned
= false;
1652 #define DECL_EXTERN_INLINE(DECL) (DECL_DECLARED_INLINE_P (DECL) \
1653 && DECL_EXTERNAL (DECL))
1655 /* If we have error_mark_node for either decl or type, just discard
1656 the previous decl - we're in an error cascade already. */
1657 if (olddecl
== error_mark_node
|| newdecl
== error_mark_node
)
1659 *oldtypep
= oldtype
= TREE_TYPE (olddecl
);
1660 *newtypep
= newtype
= TREE_TYPE (newdecl
);
1661 if (oldtype
== error_mark_node
|| newtype
== error_mark_node
)
1664 /* Two different categories of symbol altogether. This is an error
1665 unless OLDDECL is a builtin. OLDDECL will be discarded in any case. */
1666 if (TREE_CODE (olddecl
) != TREE_CODE (newdecl
))
1668 if (!(TREE_CODE (olddecl
) == FUNCTION_DECL
1669 && DECL_BUILT_IN (olddecl
)
1670 && !C_DECL_DECLARED_BUILTIN (olddecl
)))
1672 error ("%q+D redeclared as different kind of symbol", newdecl
);
1673 locate_old_decl (olddecl
);
1675 else if (TREE_PUBLIC (newdecl
))
1676 warning (0, "built-in function %q+D declared as non-function",
1679 warning (OPT_Wshadow
, "declaration of %q+D shadows "
1680 "a built-in function", newdecl
);
1684 /* Enumerators have no linkage, so may only be declared once in a
1686 if (TREE_CODE (olddecl
) == CONST_DECL
)
1688 error ("redeclaration of enumerator %q+D", newdecl
);
1689 locate_old_decl (olddecl
);
1693 if (!comptypes (oldtype
, newtype
))
1695 if (TREE_CODE (olddecl
) == FUNCTION_DECL
1696 && DECL_BUILT_IN (olddecl
) && !C_DECL_DECLARED_BUILTIN (olddecl
))
1698 /* Accept harmless mismatch in function types.
1699 This is for the ffs and fprintf builtins. */
1700 tree trytype
= match_builtin_function_types (newtype
, oldtype
);
1702 if (trytype
&& comptypes (newtype
, trytype
))
1703 *oldtypep
= oldtype
= trytype
;
1706 /* If types don't match for a built-in, throw away the
1707 built-in. No point in calling locate_old_decl here, it
1708 won't print anything. */
1709 warning (0, "conflicting types for built-in function %q+D",
1714 else if (TREE_CODE (olddecl
) == FUNCTION_DECL
1715 && DECL_IS_BUILTIN (olddecl
))
1717 /* A conflicting function declaration for a predeclared
1718 function that isn't actually built in. Objective C uses
1719 these. The new declaration silently overrides everything
1720 but the volatility (i.e. noreturn) indication. See also
1721 below. FIXME: Make Objective C use normal builtins. */
1722 TREE_THIS_VOLATILE (newdecl
) |= TREE_THIS_VOLATILE (olddecl
);
1725 /* Permit void foo (...) to match int foo (...) if the latter is
1726 the definition and implicit int was used. See
1727 c-torture/compile/920625-2.c. */
1728 else if (TREE_CODE (newdecl
) == FUNCTION_DECL
&& DECL_INITIAL (newdecl
)
1729 && TYPE_MAIN_VARIANT (TREE_TYPE (oldtype
)) == void_type_node
1730 && TYPE_MAIN_VARIANT (TREE_TYPE (newtype
)) == integer_type_node
1731 && C_FUNCTION_IMPLICIT_INT (newdecl
) && !DECL_INITIAL (olddecl
))
1733 pedwarned
= pedwarn (input_location
, 0,
1734 "conflicting types for %q+D", newdecl
);
1735 /* Make sure we keep void as the return type. */
1736 TREE_TYPE (newdecl
) = *newtypep
= newtype
= oldtype
;
1737 C_FUNCTION_IMPLICIT_INT (newdecl
) = 0;
1739 /* Permit void foo (...) to match an earlier call to foo (...) with
1740 no declared type (thus, implicitly int). */
1741 else if (TREE_CODE (newdecl
) == FUNCTION_DECL
1742 && TYPE_MAIN_VARIANT (TREE_TYPE (newtype
)) == void_type_node
1743 && TYPE_MAIN_VARIANT (TREE_TYPE (oldtype
)) == integer_type_node
1744 && C_DECL_IMPLICIT (olddecl
) && !DECL_INITIAL (olddecl
))
1746 pedwarned
= pedwarn (input_location
, 0,
1747 "conflicting types for %q+D", newdecl
);
1748 /* Make sure we keep void as the return type. */
1749 TREE_TYPE (olddecl
) = *oldtypep
= oldtype
= newtype
;
1753 int new_quals
= TYPE_QUALS (newtype
);
1754 int old_quals
= TYPE_QUALS (oldtype
);
1756 if (new_quals
!= old_quals
)
1758 addr_space_t new_addr
= DECODE_QUAL_ADDR_SPACE (new_quals
);
1759 addr_space_t old_addr
= DECODE_QUAL_ADDR_SPACE (old_quals
);
1760 if (new_addr
!= old_addr
)
1762 if (ADDR_SPACE_GENERIC_P (new_addr
))
1763 error ("conflicting named address spaces (generic vs %s) "
1765 c_addr_space_name (old_addr
), newdecl
);
1766 else if (ADDR_SPACE_GENERIC_P (old_addr
))
1767 error ("conflicting named address spaces (%s vs generic) "
1769 c_addr_space_name (new_addr
), newdecl
);
1771 error ("conflicting named address spaces (%s vs %s) "
1773 c_addr_space_name (new_addr
),
1774 c_addr_space_name (old_addr
),
1778 if (CLEAR_QUAL_ADDR_SPACE (new_quals
)
1779 != CLEAR_QUAL_ADDR_SPACE (old_quals
))
1780 error ("conflicting type qualifiers for %q+D", newdecl
);
1783 error ("conflicting types for %q+D", newdecl
);
1784 diagnose_arglist_conflict (newdecl
, olddecl
, newtype
, oldtype
);
1785 locate_old_decl (olddecl
);
1790 /* Redeclaration of a type is a constraint violation (6.7.2.3p1),
1791 but silently ignore the redeclaration if either is in a system
1792 header. (Conflicting redeclarations were handled above.) This
1793 is allowed for C1X if the types are the same, not just
1795 if (TREE_CODE (newdecl
) == TYPE_DECL
)
1797 bool types_different
= false;
1798 int comptypes_result
;
1801 = comptypes_check_different_types (oldtype
, newtype
, &types_different
);
1803 if (comptypes_result
!= 1 || types_different
)
1805 error ("redefinition of typedef %q+D with different type", newdecl
);
1806 locate_old_decl (olddecl
);
1810 if (DECL_IN_SYSTEM_HEADER (newdecl
)
1811 || DECL_IN_SYSTEM_HEADER (olddecl
)
1812 || TREE_NO_WARNING (newdecl
)
1813 || TREE_NO_WARNING (olddecl
))
1814 return true; /* Allow OLDDECL to continue in use. */
1816 if (variably_modified_type_p (newtype
, NULL
))
1818 error ("redefinition of typedef %q+D with variably modified type",
1820 locate_old_decl (olddecl
);
1822 else if (pedantic
&& !flag_isoc1x
)
1824 pedwarn (input_location
, OPT_pedantic
,
1825 "redefinition of typedef %q+D", newdecl
);
1826 locate_old_decl (olddecl
);
1832 /* Function declarations can either be 'static' or 'extern' (no
1833 qualifier is equivalent to 'extern' - C99 6.2.2p5) and therefore
1834 can never conflict with each other on account of linkage
1835 (6.2.2p4). Multiple definitions are not allowed (6.9p3,5) but
1836 gnu89 mode permits two definitions if one is 'extern inline' and
1837 one is not. The non- extern-inline definition supersedes the
1838 extern-inline definition. */
1840 else if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
1842 /* If you declare a built-in function name as static, or
1843 define the built-in with an old-style definition (so we
1844 can't validate the argument list) the built-in definition is
1845 overridden, but optionally warn this was a bad choice of name. */
1846 if (DECL_BUILT_IN (olddecl
)
1847 && !C_DECL_DECLARED_BUILTIN (olddecl
)
1848 && (!TREE_PUBLIC (newdecl
)
1849 || (DECL_INITIAL (newdecl
)
1850 && !prototype_p (TREE_TYPE (newdecl
)))))
1852 warning (OPT_Wshadow
, "declaration of %q+D shadows "
1853 "a built-in function", newdecl
);
1854 /* Discard the old built-in function. */
1858 if (DECL_INITIAL (newdecl
))
1860 if (DECL_INITIAL (olddecl
))
1862 /* If both decls are in the same TU and the new declaration
1863 isn't overriding an extern inline reject the new decl.
1864 In c99, no overriding is allowed in the same translation
1866 if ((!DECL_EXTERN_INLINE (olddecl
)
1867 || DECL_EXTERN_INLINE (newdecl
)
1868 || (!flag_gnu89_inline
1869 && (!DECL_DECLARED_INLINE_P (olddecl
)
1870 || !lookup_attribute ("gnu_inline",
1871 DECL_ATTRIBUTES (olddecl
)))
1872 && (!DECL_DECLARED_INLINE_P (newdecl
)
1873 || !lookup_attribute ("gnu_inline",
1874 DECL_ATTRIBUTES (newdecl
))))
1876 && same_translation_unit_p (newdecl
, olddecl
))
1878 error ("redefinition of %q+D", newdecl
);
1879 locate_old_decl (olddecl
);
1884 /* If we have a prototype after an old-style function definition,
1885 the argument types must be checked specially. */
1886 else if (DECL_INITIAL (olddecl
)
1887 && !prototype_p (oldtype
) && prototype_p (newtype
)
1888 && TYPE_ACTUAL_ARG_TYPES (oldtype
)
1889 && !validate_proto_after_old_defn (newdecl
, newtype
, oldtype
))
1891 locate_old_decl (olddecl
);
1894 /* A non-static declaration (even an "extern") followed by a
1895 static declaration is undefined behavior per C99 6.2.2p3-5,7.
1896 The same is true for a static forward declaration at block
1897 scope followed by a non-static declaration/definition at file
1898 scope. Static followed by non-static at the same scope is
1899 not undefined behavior, and is the most convenient way to get
1900 some effects (see e.g. what unwind-dw2-fde-glibc.c does to
1901 the definition of _Unwind_Find_FDE in unwind-dw2-fde.c), but
1902 we do diagnose it if -Wtraditional. */
1903 if (TREE_PUBLIC (olddecl
) && !TREE_PUBLIC (newdecl
))
1905 /* Two exceptions to the rule. If olddecl is an extern
1906 inline, or a predeclared function that isn't actually
1907 built in, newdecl silently overrides olddecl. The latter
1908 occur only in Objective C; see also above. (FIXME: Make
1909 Objective C use normal builtins.) */
1910 if (!DECL_IS_BUILTIN (olddecl
)
1911 && !DECL_EXTERN_INLINE (olddecl
))
1913 error ("static declaration of %q+D follows "
1914 "non-static declaration", newdecl
);
1915 locate_old_decl (olddecl
);
1919 else if (TREE_PUBLIC (newdecl
) && !TREE_PUBLIC (olddecl
))
1921 if (DECL_CONTEXT (olddecl
))
1923 error ("non-static declaration of %q+D follows "
1924 "static declaration", newdecl
);
1925 locate_old_decl (olddecl
);
1928 else if (warn_traditional
)
1930 warned
|= warning (OPT_Wtraditional
,
1931 "non-static declaration of %q+D "
1932 "follows static declaration", newdecl
);
1936 /* Make sure gnu_inline attribute is either not present, or
1937 present on all inline decls. */
1938 if (DECL_DECLARED_INLINE_P (olddecl
)
1939 && DECL_DECLARED_INLINE_P (newdecl
))
1941 bool newa
= lookup_attribute ("gnu_inline",
1942 DECL_ATTRIBUTES (newdecl
)) != NULL
;
1943 bool olda
= lookup_attribute ("gnu_inline",
1944 DECL_ATTRIBUTES (olddecl
)) != NULL
;
1947 error_at (input_location
, "%<gnu_inline%> attribute present on %q+D",
1948 newa
? newdecl
: olddecl
);
1949 error_at (DECL_SOURCE_LOCATION (newa
? olddecl
: newdecl
),
1954 else if (TREE_CODE (newdecl
) == VAR_DECL
)
1956 /* Only variables can be thread-local, and all declarations must
1957 agree on this property. */
1958 if (C_DECL_THREADPRIVATE_P (olddecl
) && !DECL_THREAD_LOCAL_P (newdecl
))
1960 /* Nothing to check. Since OLDDECL is marked threadprivate
1961 and NEWDECL does not have a thread-local attribute, we
1962 will merge the threadprivate attribute into NEWDECL. */
1965 else if (DECL_THREAD_LOCAL_P (newdecl
) != DECL_THREAD_LOCAL_P (olddecl
))
1967 if (DECL_THREAD_LOCAL_P (newdecl
))
1968 error ("thread-local declaration of %q+D follows "
1969 "non-thread-local declaration", newdecl
);
1971 error ("non-thread-local declaration of %q+D follows "
1972 "thread-local declaration", newdecl
);
1974 locate_old_decl (olddecl
);
1978 /* Multiple initialized definitions are not allowed (6.9p3,5). */
1979 if (DECL_INITIAL (newdecl
) && DECL_INITIAL (olddecl
))
1981 error ("redefinition of %q+D", newdecl
);
1982 locate_old_decl (olddecl
);
1986 /* Objects declared at file scope: if the first declaration had
1987 external linkage (even if it was an external reference) the
1988 second must have external linkage as well, or the behavior is
1989 undefined. If the first declaration had internal linkage, then
1990 the second must too, or else be an external reference (in which
1991 case the composite declaration still has internal linkage).
1992 As for function declarations, we warn about the static-then-
1993 extern case only for -Wtraditional. See generally 6.2.2p3-5,7. */
1994 if (DECL_FILE_SCOPE_P (newdecl
)
1995 && TREE_PUBLIC (newdecl
) != TREE_PUBLIC (olddecl
))
1997 if (DECL_EXTERNAL (newdecl
))
1999 if (!DECL_FILE_SCOPE_P (olddecl
))
2001 error ("extern declaration of %q+D follows "
2002 "declaration with no linkage", newdecl
);
2003 locate_old_decl (olddecl
);
2006 else if (warn_traditional
)
2008 warned
|= warning (OPT_Wtraditional
,
2009 "non-static declaration of %q+D "
2010 "follows static declaration", newdecl
);
2015 if (TREE_PUBLIC (newdecl
))
2016 error ("non-static declaration of %q+D follows "
2017 "static declaration", newdecl
);
2019 error ("static declaration of %q+D follows "
2020 "non-static declaration", newdecl
);
2022 locate_old_decl (olddecl
);
2026 /* Two objects with the same name declared at the same block
2027 scope must both be external references (6.7p3). */
2028 else if (!DECL_FILE_SCOPE_P (newdecl
))
2030 if (DECL_EXTERNAL (newdecl
))
2032 /* Extern with initializer at block scope, which will
2033 already have received an error. */
2035 else if (DECL_EXTERNAL (olddecl
))
2037 error ("declaration of %q+D with no linkage follows "
2038 "extern declaration", newdecl
);
2039 locate_old_decl (olddecl
);
2043 error ("redeclaration of %q+D with no linkage", newdecl
);
2044 locate_old_decl (olddecl
);
2050 /* C++ does not permit a decl to appear multiple times at file
2053 && DECL_FILE_SCOPE_P (newdecl
)
2054 && !DECL_EXTERNAL (newdecl
)
2055 && !DECL_EXTERNAL (olddecl
))
2056 warned
|= warning_at (DECL_SOURCE_LOCATION (newdecl
),
2058 ("duplicate declaration of %qD is "
2064 /* All decls must agree on a visibility. */
2065 if (CODE_CONTAINS_STRUCT (TREE_CODE (newdecl
), TS_DECL_WITH_VIS
)
2066 && DECL_VISIBILITY_SPECIFIED (newdecl
) && DECL_VISIBILITY_SPECIFIED (olddecl
)
2067 && DECL_VISIBILITY (newdecl
) != DECL_VISIBILITY (olddecl
))
2069 warned
|= warning (0, "redeclaration of %q+D with different visibility "
2070 "(old visibility preserved)", newdecl
);
2073 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
2075 /* Diagnose inline __attribute__ ((noinline)) which is silly. */
2076 if (DECL_DECLARED_INLINE_P (newdecl
)
2077 && lookup_attribute ("noinline", DECL_ATTRIBUTES (olddecl
)))
2079 warned
|= warning (OPT_Wattributes
,
2080 "inline declaration of %qD follows "
2081 "declaration with attribute noinline", newdecl
);
2083 else if (DECL_DECLARED_INLINE_P (olddecl
)
2084 && lookup_attribute ("noinline", DECL_ATTRIBUTES (newdecl
)))
2086 warned
|= warning (OPT_Wattributes
,
2087 "declaration of %q+D with attribute "
2088 "noinline follows inline declaration ", newdecl
);
2091 else /* PARM_DECL, VAR_DECL */
2093 /* Redeclaration of a parameter is a constraint violation (this is
2094 not explicitly stated, but follows from C99 6.7p3 [no more than
2095 one declaration of the same identifier with no linkage in the
2096 same scope, except type tags] and 6.2.2p6 [parameters have no
2097 linkage]). We must check for a forward parameter declaration,
2098 indicated by TREE_ASM_WRITTEN on the old declaration - this is
2099 an extension, the mandatory diagnostic for which is handled by
2100 mark_forward_parm_decls. */
2102 if (TREE_CODE (newdecl
) == PARM_DECL
2103 && (!TREE_ASM_WRITTEN (olddecl
) || TREE_ASM_WRITTEN (newdecl
)))
2105 error ("redefinition of parameter %q+D", newdecl
);
2106 locate_old_decl (olddecl
);
2111 /* Optional warning for completely redundant decls. */
2112 if (!warned
&& !pedwarned
2113 && warn_redundant_decls
2114 /* Don't warn about a function declaration followed by a
2116 && !(TREE_CODE (newdecl
) == FUNCTION_DECL
2117 && DECL_INITIAL (newdecl
) && !DECL_INITIAL (olddecl
))
2118 /* Don't warn about redundant redeclarations of builtins. */
2119 && !(TREE_CODE (newdecl
) == FUNCTION_DECL
2120 && !DECL_BUILT_IN (newdecl
)
2121 && DECL_BUILT_IN (olddecl
)
2122 && !C_DECL_DECLARED_BUILTIN (olddecl
))
2123 /* Don't warn about an extern followed by a definition. */
2124 && !(DECL_EXTERNAL (olddecl
) && !DECL_EXTERNAL (newdecl
))
2125 /* Don't warn about forward parameter decls. */
2126 && !(TREE_CODE (newdecl
) == PARM_DECL
2127 && TREE_ASM_WRITTEN (olddecl
) && !TREE_ASM_WRITTEN (newdecl
))
2128 /* Don't warn about a variable definition following a declaration. */
2129 && !(TREE_CODE (newdecl
) == VAR_DECL
2130 && DECL_INITIAL (newdecl
) && !DECL_INITIAL (olddecl
)))
2132 warned
= warning (OPT_Wredundant_decls
, "redundant redeclaration of %q+D",
2136 /* Report location of previous decl/defn. */
2137 if (warned
|| pedwarned
)
2138 locate_old_decl (olddecl
);
2140 #undef DECL_EXTERN_INLINE
2145 /* Subroutine of duplicate_decls. NEWDECL has been found to be
2146 consistent with OLDDECL, but carries new information. Merge the
2147 new information into OLDDECL. This function issues no
2151 merge_decls (tree newdecl
, tree olddecl
, tree newtype
, tree oldtype
)
2153 bool new_is_definition
= (TREE_CODE (newdecl
) == FUNCTION_DECL
2154 && DECL_INITIAL (newdecl
) != 0);
2155 bool new_is_prototype
= (TREE_CODE (newdecl
) == FUNCTION_DECL
2156 && prototype_p (TREE_TYPE (newdecl
)));
2157 bool old_is_prototype
= (TREE_CODE (olddecl
) == FUNCTION_DECL
2158 && prototype_p (TREE_TYPE (olddecl
)));
2159 bool extern_changed
= false;
2161 /* For real parm decl following a forward decl, rechain the old decl
2162 in its new location and clear TREE_ASM_WRITTEN (it's not a
2163 forward decl anymore). */
2164 if (TREE_CODE (newdecl
) == PARM_DECL
2165 && TREE_ASM_WRITTEN (olddecl
) && !TREE_ASM_WRITTEN (newdecl
))
2167 struct c_binding
*b
, **here
;
2169 for (here
= ¤t_scope
->bindings
; *here
; here
= &(*here
)->prev
)
2170 if ((*here
)->decl
== olddecl
)
2177 b
->prev
= current_scope
->bindings
;
2178 current_scope
->bindings
= b
;
2180 TREE_ASM_WRITTEN (olddecl
) = 0;
2183 DECL_ATTRIBUTES (newdecl
)
2184 = targetm
.merge_decl_attributes (olddecl
, newdecl
);
2186 /* Merge the data types specified in the two decls. */
2188 = TREE_TYPE (olddecl
)
2189 = composite_type (newtype
, oldtype
);
2191 /* Lay the type out, unless already done. */
2192 if (!comptypes (oldtype
, TREE_TYPE (newdecl
)))
2194 if (TREE_TYPE (newdecl
) != error_mark_node
)
2195 layout_type (TREE_TYPE (newdecl
));
2196 if (TREE_CODE (newdecl
) != FUNCTION_DECL
2197 && TREE_CODE (newdecl
) != TYPE_DECL
2198 && TREE_CODE (newdecl
) != CONST_DECL
)
2199 layout_decl (newdecl
, 0);
2203 /* Since the type is OLDDECL's, make OLDDECL's size go with. */
2204 DECL_SIZE (newdecl
) = DECL_SIZE (olddecl
);
2205 DECL_SIZE_UNIT (newdecl
) = DECL_SIZE_UNIT (olddecl
);
2206 DECL_MODE (newdecl
) = DECL_MODE (olddecl
);
2207 if (DECL_ALIGN (olddecl
) > DECL_ALIGN (newdecl
))
2209 DECL_ALIGN (newdecl
) = DECL_ALIGN (olddecl
);
2210 DECL_USER_ALIGN (newdecl
) |= DECL_USER_ALIGN (olddecl
);
2214 /* Keep the old rtl since we can safely use it. */
2215 if (HAS_RTL_P (olddecl
))
2216 COPY_DECL_RTL (olddecl
, newdecl
);
2218 /* Merge the type qualifiers. */
2219 if (TREE_READONLY (newdecl
))
2220 TREE_READONLY (olddecl
) = 1;
2222 if (TREE_THIS_VOLATILE (newdecl
))
2223 TREE_THIS_VOLATILE (olddecl
) = 1;
2225 /* Merge deprecatedness. */
2226 if (TREE_DEPRECATED (newdecl
))
2227 TREE_DEPRECATED (olddecl
) = 1;
2229 /* If a decl is in a system header and the other isn't, keep the one on the
2230 system header. Otherwise, keep source location of definition rather than
2231 declaration and of prototype rather than non-prototype unless that
2232 prototype is built-in. */
2233 if (CODE_CONTAINS_STRUCT (TREE_CODE (olddecl
), TS_DECL_WITH_VIS
)
2234 && DECL_IN_SYSTEM_HEADER (olddecl
)
2235 && !DECL_IN_SYSTEM_HEADER (newdecl
) )
2236 DECL_SOURCE_LOCATION (newdecl
) = DECL_SOURCE_LOCATION (olddecl
);
2237 else if (CODE_CONTAINS_STRUCT (TREE_CODE (olddecl
), TS_DECL_WITH_VIS
)
2238 && DECL_IN_SYSTEM_HEADER (newdecl
)
2239 && !DECL_IN_SYSTEM_HEADER (olddecl
))
2240 DECL_SOURCE_LOCATION (olddecl
) = DECL_SOURCE_LOCATION (newdecl
);
2241 else if ((DECL_INITIAL (newdecl
) == 0 && DECL_INITIAL (olddecl
) != 0)
2242 || (old_is_prototype
&& !new_is_prototype
2243 && !C_DECL_BUILTIN_PROTOTYPE (olddecl
)))
2244 DECL_SOURCE_LOCATION (newdecl
) = DECL_SOURCE_LOCATION (olddecl
);
2246 /* Merge the initialization information. */
2247 if (DECL_INITIAL (newdecl
) == 0)
2248 DECL_INITIAL (newdecl
) = DECL_INITIAL (olddecl
);
2250 /* Merge the threadprivate attribute. */
2251 if (TREE_CODE (olddecl
) == VAR_DECL
&& C_DECL_THREADPRIVATE_P (olddecl
))
2253 DECL_TLS_MODEL (newdecl
) = DECL_TLS_MODEL (olddecl
);
2254 C_DECL_THREADPRIVATE_P (newdecl
) = 1;
2257 if (CODE_CONTAINS_STRUCT (TREE_CODE (olddecl
), TS_DECL_WITH_VIS
))
2259 /* Merge the section attribute.
2260 We want to issue an error if the sections conflict but that
2261 must be done later in decl_attributes since we are called
2262 before attributes are assigned. */
2263 if (DECL_SECTION_NAME (newdecl
) == NULL_TREE
)
2264 DECL_SECTION_NAME (newdecl
) = DECL_SECTION_NAME (olddecl
);
2266 /* Copy the assembler name.
2267 Currently, it can only be defined in the prototype. */
2268 COPY_DECL_ASSEMBLER_NAME (olddecl
, newdecl
);
2270 /* Use visibility of whichever declaration had it specified */
2271 if (DECL_VISIBILITY_SPECIFIED (olddecl
))
2273 DECL_VISIBILITY (newdecl
) = DECL_VISIBILITY (olddecl
);
2274 DECL_VISIBILITY_SPECIFIED (newdecl
) = 1;
2277 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
2279 DECL_STATIC_CONSTRUCTOR(newdecl
) |= DECL_STATIC_CONSTRUCTOR(olddecl
);
2280 DECL_STATIC_DESTRUCTOR (newdecl
) |= DECL_STATIC_DESTRUCTOR (olddecl
);
2281 DECL_NO_LIMIT_STACK (newdecl
) |= DECL_NO_LIMIT_STACK (olddecl
);
2282 DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (newdecl
)
2283 |= DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (olddecl
);
2284 TREE_THIS_VOLATILE (newdecl
) |= TREE_THIS_VOLATILE (olddecl
);
2285 DECL_IS_MALLOC (newdecl
) |= DECL_IS_MALLOC (olddecl
);
2286 DECL_IS_OPERATOR_NEW (newdecl
) |= DECL_IS_OPERATOR_NEW (olddecl
);
2287 TREE_READONLY (newdecl
) |= TREE_READONLY (olddecl
);
2288 DECL_PURE_P (newdecl
) |= DECL_PURE_P (olddecl
);
2289 DECL_IS_NOVOPS (newdecl
) |= DECL_IS_NOVOPS (olddecl
);
2292 /* Merge the storage class information. */
2293 merge_weak (newdecl
, olddecl
);
2295 /* For functions, static overrides non-static. */
2296 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
2298 TREE_PUBLIC (newdecl
) &= TREE_PUBLIC (olddecl
);
2299 /* This is since we don't automatically
2300 copy the attributes of NEWDECL into OLDDECL. */
2301 TREE_PUBLIC (olddecl
) = TREE_PUBLIC (newdecl
);
2302 /* If this clears `static', clear it in the identifier too. */
2303 if (!TREE_PUBLIC (olddecl
))
2304 TREE_PUBLIC (DECL_NAME (olddecl
)) = 0;
2308 /* In c99, 'extern' declaration before (or after) 'inline' means this
2309 function is not DECL_EXTERNAL, unless 'gnu_inline' attribute
2311 if (TREE_CODE (newdecl
) == FUNCTION_DECL
2312 && !flag_gnu89_inline
2313 && (DECL_DECLARED_INLINE_P (newdecl
)
2314 || DECL_DECLARED_INLINE_P (olddecl
))
2315 && (!DECL_DECLARED_INLINE_P (newdecl
)
2316 || !DECL_DECLARED_INLINE_P (olddecl
)
2317 || !DECL_EXTERNAL (olddecl
))
2318 && DECL_EXTERNAL (newdecl
)
2319 && !lookup_attribute ("gnu_inline", DECL_ATTRIBUTES (newdecl
))
2320 && !current_function_decl
)
2321 DECL_EXTERNAL (newdecl
) = 0;
2323 if (DECL_EXTERNAL (newdecl
))
2325 TREE_STATIC (newdecl
) = TREE_STATIC (olddecl
);
2326 DECL_EXTERNAL (newdecl
) = DECL_EXTERNAL (olddecl
);
2328 /* An extern decl does not override previous storage class. */
2329 TREE_PUBLIC (newdecl
) = TREE_PUBLIC (olddecl
);
2330 if (!DECL_EXTERNAL (newdecl
))
2332 DECL_CONTEXT (newdecl
) = DECL_CONTEXT (olddecl
);
2333 DECL_COMMON (newdecl
) = DECL_COMMON (olddecl
);
2338 TREE_STATIC (olddecl
) = TREE_STATIC (newdecl
);
2339 TREE_PUBLIC (olddecl
) = TREE_PUBLIC (newdecl
);
2342 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
2344 /* If we're redefining a function previously defined as extern
2345 inline, make sure we emit debug info for the inline before we
2346 throw it away, in case it was inlined into a function that
2347 hasn't been written out yet. */
2348 if (new_is_definition
&& DECL_INITIAL (olddecl
))
2349 /* The new defn must not be inline. */
2350 DECL_UNINLINABLE (newdecl
) = 1;
2353 /* If either decl says `inline', this fn is inline, unless
2354 its definition was passed already. */
2355 if (DECL_DECLARED_INLINE_P (newdecl
)
2356 || DECL_DECLARED_INLINE_P (olddecl
))
2357 DECL_DECLARED_INLINE_P (newdecl
) = 1;
2359 DECL_UNINLINABLE (newdecl
) = DECL_UNINLINABLE (olddecl
)
2360 = (DECL_UNINLINABLE (newdecl
) || DECL_UNINLINABLE (olddecl
));
2362 DECL_DISREGARD_INLINE_LIMITS (newdecl
)
2363 = DECL_DISREGARD_INLINE_LIMITS (olddecl
)
2364 = (DECL_DISREGARD_INLINE_LIMITS (newdecl
)
2365 || DECL_DISREGARD_INLINE_LIMITS (olddecl
));
2368 if (DECL_BUILT_IN (olddecl
))
2370 /* If redeclaring a builtin function, it stays built in.
2371 But it gets tagged as having been declared. */
2372 DECL_BUILT_IN_CLASS (newdecl
) = DECL_BUILT_IN_CLASS (olddecl
);
2373 DECL_FUNCTION_CODE (newdecl
) = DECL_FUNCTION_CODE (olddecl
);
2374 C_DECL_DECLARED_BUILTIN (newdecl
) = 1;
2375 if (new_is_prototype
)
2376 C_DECL_BUILTIN_PROTOTYPE (newdecl
) = 0;
2378 C_DECL_BUILTIN_PROTOTYPE (newdecl
)
2379 = C_DECL_BUILTIN_PROTOTYPE (olddecl
);
2382 /* Preserve function specific target and optimization options */
2383 if (DECL_FUNCTION_SPECIFIC_TARGET (olddecl
)
2384 && !DECL_FUNCTION_SPECIFIC_TARGET (newdecl
))
2385 DECL_FUNCTION_SPECIFIC_TARGET (newdecl
)
2386 = DECL_FUNCTION_SPECIFIC_TARGET (olddecl
);
2388 if (DECL_FUNCTION_SPECIFIC_OPTIMIZATION (olddecl
)
2389 && !DECL_FUNCTION_SPECIFIC_OPTIMIZATION (newdecl
))
2390 DECL_FUNCTION_SPECIFIC_OPTIMIZATION (newdecl
)
2391 = DECL_FUNCTION_SPECIFIC_OPTIMIZATION (olddecl
);
2393 /* Also preserve various other info from the definition. */
2394 if (!new_is_definition
)
2397 DECL_RESULT (newdecl
) = DECL_RESULT (olddecl
);
2398 DECL_INITIAL (newdecl
) = DECL_INITIAL (olddecl
);
2399 DECL_STRUCT_FUNCTION (newdecl
) = DECL_STRUCT_FUNCTION (olddecl
);
2400 DECL_SAVED_TREE (newdecl
) = DECL_SAVED_TREE (olddecl
);
2401 DECL_ARGUMENTS (newdecl
) = copy_list (DECL_ARGUMENTS (olddecl
));
2402 for (t
= DECL_ARGUMENTS (newdecl
); t
; t
= DECL_CHAIN (t
))
2403 DECL_CONTEXT (t
) = newdecl
;
2405 /* See if we've got a function to instantiate from. */
2406 if (DECL_SAVED_TREE (olddecl
))
2407 DECL_ABSTRACT_ORIGIN (newdecl
)
2408 = DECL_ABSTRACT_ORIGIN (olddecl
);
2412 extern_changed
= DECL_EXTERNAL (olddecl
) && !DECL_EXTERNAL (newdecl
);
2414 /* Merge the USED information. */
2415 if (TREE_USED (olddecl
))
2416 TREE_USED (newdecl
) = 1;
2417 else if (TREE_USED (newdecl
))
2418 TREE_USED (olddecl
) = 1;
2419 if (TREE_CODE (olddecl
) == VAR_DECL
|| TREE_CODE (olddecl
) == PARM_DECL
)
2420 DECL_READ_P (newdecl
) |= DECL_READ_P (olddecl
);
2421 if (DECL_PRESERVE_P (olddecl
))
2422 DECL_PRESERVE_P (newdecl
) = 1;
2423 else if (DECL_PRESERVE_P (newdecl
))
2424 DECL_PRESERVE_P (olddecl
) = 1;
2426 /* Copy most of the decl-specific fields of NEWDECL into OLDDECL.
2427 But preserve OLDDECL's DECL_UID, DECL_CONTEXT and
2428 DECL_ARGUMENTS (if appropriate). */
2430 unsigned olddecl_uid
= DECL_UID (olddecl
);
2431 tree olddecl_context
= DECL_CONTEXT (olddecl
);
2432 tree olddecl_arguments
= NULL
;
2433 if (TREE_CODE (olddecl
) == FUNCTION_DECL
)
2434 olddecl_arguments
= DECL_ARGUMENTS (olddecl
);
2436 memcpy ((char *) olddecl
+ sizeof (struct tree_common
),
2437 (char *) newdecl
+ sizeof (struct tree_common
),
2438 sizeof (struct tree_decl_common
) - sizeof (struct tree_common
));
2439 switch (TREE_CODE (olddecl
))
2449 memcpy ((char *) olddecl
+ sizeof (struct tree_decl_common
),
2450 (char *) newdecl
+ sizeof (struct tree_decl_common
),
2451 tree_code_size (TREE_CODE (olddecl
)) - sizeof (struct tree_decl_common
));
2456 memcpy ((char *) olddecl
+ sizeof (struct tree_decl_common
),
2457 (char *) newdecl
+ sizeof (struct tree_decl_common
),
2458 sizeof (struct tree_decl_non_common
) - sizeof (struct tree_decl_common
));
2460 DECL_UID (olddecl
) = olddecl_uid
;
2461 DECL_CONTEXT (olddecl
) = olddecl_context
;
2462 if (TREE_CODE (olddecl
) == FUNCTION_DECL
)
2463 DECL_ARGUMENTS (olddecl
) = olddecl_arguments
;
2466 /* If OLDDECL had its DECL_RTL instantiated, re-invoke make_decl_rtl
2467 so that encode_section_info has a chance to look at the new decl
2468 flags and attributes. */
2469 if (DECL_RTL_SET_P (olddecl
)
2470 && (TREE_CODE (olddecl
) == FUNCTION_DECL
2471 || (TREE_CODE (olddecl
) == VAR_DECL
2472 && TREE_STATIC (olddecl
))))
2473 make_decl_rtl (olddecl
);
2475 /* If we changed a function from DECL_EXTERNAL to !DECL_EXTERNAL,
2476 and the definition is coming from the old version, cgraph needs
2477 to be called again. */
2478 if (extern_changed
&& !new_is_definition
2479 && TREE_CODE (olddecl
) == FUNCTION_DECL
&& DECL_INITIAL (olddecl
))
2480 cgraph_mark_if_needed (olddecl
);
2483 /* Handle when a new declaration NEWDECL has the same name as an old
2484 one OLDDECL in the same binding contour. Prints an error message
2487 If safely possible, alter OLDDECL to look like NEWDECL, and return
2488 true. Otherwise, return false. */
2491 duplicate_decls (tree newdecl
, tree olddecl
)
2493 tree newtype
= NULL
, oldtype
= NULL
;
2495 if (!diagnose_mismatched_decls (newdecl
, olddecl
, &newtype
, &oldtype
))
2497 /* Avoid `unused variable' and other warnings for OLDDECL. */
2498 TREE_NO_WARNING (olddecl
) = 1;
2502 merge_decls (newdecl
, olddecl
, newtype
, oldtype
);
2507 /* Check whether decl-node NEW_DECL shadows an existing declaration. */
2509 warn_if_shadowing (tree new_decl
)
2511 struct c_binding
*b
;
2513 /* Shadow warnings wanted? */
2515 /* No shadow warnings for internally generated vars. */
2516 || DECL_IS_BUILTIN (new_decl
)
2517 /* No shadow warnings for vars made for inlining. */
2518 || DECL_FROM_INLINE (new_decl
))
2521 /* Is anything being shadowed? Invisible decls do not count. */
2522 for (b
= I_SYMBOL_BINDING (DECL_NAME (new_decl
)); b
; b
= b
->shadowed
)
2523 if (b
->decl
&& b
->decl
!= new_decl
&& !b
->invisible
)
2525 tree old_decl
= b
->decl
;
2527 if (old_decl
== error_mark_node
)
2529 warning (OPT_Wshadow
, "declaration of %q+D shadows previous "
2530 "non-variable", new_decl
);
2533 else if (TREE_CODE (old_decl
) == PARM_DECL
)
2534 warning (OPT_Wshadow
, "declaration of %q+D shadows a parameter",
2536 else if (DECL_FILE_SCOPE_P (old_decl
))
2537 warning (OPT_Wshadow
, "declaration of %q+D shadows a global "
2538 "declaration", new_decl
);
2539 else if (TREE_CODE (old_decl
) == FUNCTION_DECL
2540 && DECL_BUILT_IN (old_decl
))
2542 warning (OPT_Wshadow
, "declaration of %q+D shadows "
2543 "a built-in function", new_decl
);
2547 warning (OPT_Wshadow
, "declaration of %q+D shadows a previous local",
2550 warning_at (DECL_SOURCE_LOCATION (old_decl
), OPT_Wshadow
,
2551 "shadowed declaration is here");
2557 /* Record a decl-node X as belonging to the current lexical scope.
2558 Check for errors (such as an incompatible declaration for the same
2559 name already seen in the same scope).
2561 Returns either X or an old decl for the same name.
2562 If an old decl is returned, it may have been smashed
2563 to agree with what X says. */
2568 tree name
= DECL_NAME (x
);
2569 struct c_scope
*scope
= current_scope
;
2570 struct c_binding
*b
;
2571 bool nested
= false;
2572 location_t locus
= DECL_SOURCE_LOCATION (x
);
2574 /* Must set DECL_CONTEXT for everything not at file scope or
2575 DECL_FILE_SCOPE_P won't work. Local externs don't count
2576 unless they have initializers (which generate code). */
2577 if (current_function_decl
2578 && ((TREE_CODE (x
) != FUNCTION_DECL
&& TREE_CODE (x
) != VAR_DECL
)
2579 || DECL_INITIAL (x
) || !DECL_EXTERNAL (x
)))
2580 DECL_CONTEXT (x
) = current_function_decl
;
2582 /* Anonymous decls are just inserted in the scope. */
2585 bind (name
, x
, scope
, /*invisible=*/false, /*nested=*/false,
2590 /* First, see if there is another declaration with the same name in
2591 the current scope. If there is, duplicate_decls may do all the
2592 work for us. If duplicate_decls returns false, that indicates
2593 two incompatible decls in the same scope; we are to silently
2594 replace the old one (duplicate_decls has issued all appropriate
2595 diagnostics). In particular, we should not consider possible
2596 duplicates in the external scope, or shadowing. */
2597 b
= I_SYMBOL_BINDING (name
);
2598 if (b
&& B_IN_SCOPE (b
, scope
))
2600 struct c_binding
*b_ext
, *b_use
;
2601 tree type
= TREE_TYPE (x
);
2602 tree visdecl
= b
->decl
;
2603 tree vistype
= TREE_TYPE (visdecl
);
2604 if (TREE_CODE (TREE_TYPE (x
)) == ARRAY_TYPE
2605 && COMPLETE_TYPE_P (TREE_TYPE (x
)))
2606 b
->inner_comp
= false;
2609 /* If this is an external linkage declaration, we should check
2610 for compatibility with the type in the external scope before
2611 setting the type at this scope based on the visible
2612 information only. */
2613 if (TREE_PUBLIC (x
) && TREE_PUBLIC (visdecl
))
2615 while (b_ext
&& !B_IN_EXTERNAL_SCOPE (b_ext
))
2616 b_ext
= b_ext
->shadowed
;
2621 TREE_TYPE (b_use
->decl
) = b_use
->u
.type
;
2624 if (duplicate_decls (x
, b_use
->decl
))
2628 /* Save the updated type in the external scope and
2629 restore the proper type for this scope. */
2631 if (comptypes (vistype
, type
))
2632 thistype
= composite_type (vistype
, type
);
2634 thistype
= TREE_TYPE (b_use
->decl
);
2635 b_use
->u
.type
= TREE_TYPE (b_use
->decl
);
2636 if (TREE_CODE (b_use
->decl
) == FUNCTION_DECL
2637 && DECL_BUILT_IN (b_use
->decl
))
2639 = build_type_attribute_variant (thistype
,
2642 TREE_TYPE (b_use
->decl
) = thistype
;
2647 goto skip_external_and_shadow_checks
;
2650 /* All declarations with external linkage, and all external
2651 references, go in the external scope, no matter what scope is
2652 current. However, the binding in that scope is ignored for
2653 purposes of normal name lookup. A separate binding structure is
2654 created in the requested scope; this governs the normal
2655 visibility of the symbol.
2657 The binding in the externals scope is used exclusively for
2658 detecting duplicate declarations of the same object, no matter
2659 what scope they are in; this is what we do here. (C99 6.2.7p2:
2660 All declarations that refer to the same object or function shall
2661 have compatible type; otherwise, the behavior is undefined.) */
2662 if (DECL_EXTERNAL (x
) || scope
== file_scope
)
2664 tree type
= TREE_TYPE (x
);
2667 bool type_saved
= false;
2668 if (b
&& !B_IN_EXTERNAL_SCOPE (b
)
2669 && (TREE_CODE (b
->decl
) == FUNCTION_DECL
2670 || TREE_CODE (b
->decl
) == VAR_DECL
)
2671 && DECL_FILE_SCOPE_P (b
->decl
))
2674 vistype
= TREE_TYPE (visdecl
);
2676 if (scope
!= file_scope
2677 && !DECL_IN_SYSTEM_HEADER (x
))
2678 warning (OPT_Wnested_externs
, "nested extern declaration of %qD", x
);
2680 while (b
&& !B_IN_EXTERNAL_SCOPE (b
))
2682 /* If this decl might be modified, save its type. This is
2683 done here rather than when the decl is first bound
2684 because the type may change after first binding, through
2685 being completed or through attributes being added. If we
2686 encounter multiple such decls, only the first should have
2687 its type saved; the others will already have had their
2688 proper types saved and the types will not have changed as
2689 their scopes will not have been re-entered. */
2690 if (DECL_P (b
->decl
) && DECL_FILE_SCOPE_P (b
->decl
) && !type_saved
)
2692 b
->u
.type
= TREE_TYPE (b
->decl
);
2695 if (B_IN_FILE_SCOPE (b
)
2696 && TREE_CODE (b
->decl
) == VAR_DECL
2697 && TREE_STATIC (b
->decl
)
2698 && TREE_CODE (TREE_TYPE (b
->decl
)) == ARRAY_TYPE
2699 && !TYPE_DOMAIN (TREE_TYPE (b
->decl
))
2700 && TREE_CODE (type
) == ARRAY_TYPE
2701 && TYPE_DOMAIN (type
)
2702 && TYPE_MAX_VALUE (TYPE_DOMAIN (type
))
2703 && !integer_zerop (TYPE_MAX_VALUE (TYPE_DOMAIN (type
))))
2705 /* Array type completed in inner scope, which should be
2706 diagnosed if the completion does not have size 1 and
2707 it does not get completed in the file scope. */
2708 b
->inner_comp
= true;
2713 /* If a matching external declaration has been found, set its
2714 type to the composite of all the types of that declaration.
2715 After the consistency checks, it will be reset to the
2716 composite of the visible types only. */
2717 if (b
&& (TREE_PUBLIC (x
) || same_translation_unit_p (x
, b
->decl
))
2719 TREE_TYPE (b
->decl
) = b
->u
.type
;
2721 /* The point of the same_translation_unit_p check here is,
2722 we want to detect a duplicate decl for a construct like
2723 foo() { extern bar(); } ... static bar(); but not if
2724 they are in different translation units. In any case,
2725 the static does not go in the externals scope. */
2727 && (TREE_PUBLIC (x
) || same_translation_unit_p (x
, b
->decl
))
2728 && duplicate_decls (x
, b
->decl
))
2733 if (comptypes (vistype
, type
))
2734 thistype
= composite_type (vistype
, type
);
2736 thistype
= TREE_TYPE (b
->decl
);
2740 b
->u
.type
= TREE_TYPE (b
->decl
);
2741 if (TREE_CODE (b
->decl
) == FUNCTION_DECL
&& DECL_BUILT_IN (b
->decl
))
2743 = build_type_attribute_variant (thistype
,
2744 TYPE_ATTRIBUTES (b
->u
.type
));
2745 TREE_TYPE (b
->decl
) = thistype
;
2746 bind (name
, b
->decl
, scope
, /*invisible=*/false, /*nested=*/true,
2750 else if (TREE_PUBLIC (x
))
2752 if (visdecl
&& !b
&& duplicate_decls (x
, visdecl
))
2754 /* An external declaration at block scope referring to a
2755 visible entity with internal linkage. The composite
2756 type will already be correct for this scope, so we
2757 just need to fall through to make the declaration in
2764 bind (name
, x
, external_scope
, /*invisible=*/true,
2765 /*nested=*/false, locus
);
2771 if (TREE_CODE (x
) != PARM_DECL
)
2772 warn_if_shadowing (x
);
2774 skip_external_and_shadow_checks
:
2775 if (TREE_CODE (x
) == TYPE_DECL
)
2776 set_underlying_type (x
);
2778 bind (name
, x
, scope
, /*invisible=*/false, nested
, locus
);
2780 /* If x's type is incomplete because it's based on a
2781 structure or union which has not yet been fully declared,
2782 attach it to that structure or union type, so we can go
2783 back and complete the variable declaration later, if the
2784 structure or union gets fully declared.
2786 If the input is erroneous, we can have error_mark in the type
2787 slot (e.g. "f(void a, ...)") - that doesn't count as an
2789 if (TREE_TYPE (x
) != error_mark_node
2790 && !COMPLETE_TYPE_P (TREE_TYPE (x
)))
2792 tree element
= TREE_TYPE (x
);
2794 while (TREE_CODE (element
) == ARRAY_TYPE
)
2795 element
= TREE_TYPE (element
);
2796 element
= TYPE_MAIN_VARIANT (element
);
2798 if ((TREE_CODE (element
) == RECORD_TYPE
2799 || TREE_CODE (element
) == UNION_TYPE
)
2800 && (TREE_CODE (x
) != TYPE_DECL
2801 || TREE_CODE (TREE_TYPE (x
)) == ARRAY_TYPE
)
2802 && !COMPLETE_TYPE_P (element
))
2803 C_TYPE_INCOMPLETE_VARS (element
)
2804 = tree_cons (NULL_TREE
, x
, C_TYPE_INCOMPLETE_VARS (element
));
2809 /* Record X as belonging to file scope.
2810 This is used only internally by the Objective-C front end,
2811 and is limited to its needs. duplicate_decls is not called;
2812 if there is any preexisting decl for this identifier, it is an ICE. */
2815 pushdecl_top_level (tree x
)
2818 bool nested
= false;
2819 gcc_assert (TREE_CODE (x
) == VAR_DECL
|| TREE_CODE (x
) == CONST_DECL
);
2821 name
= DECL_NAME (x
);
2823 gcc_assert (TREE_CODE (x
) == CONST_DECL
|| !I_SYMBOL_BINDING (name
));
2825 if (TREE_PUBLIC (x
))
2827 bind (name
, x
, external_scope
, /*invisible=*/true, /*nested=*/false,
2832 bind (name
, x
, file_scope
, /*invisible=*/false, nested
, UNKNOWN_LOCATION
);
2838 implicit_decl_warning (tree id
, tree olddecl
)
2840 if (warn_implicit_function_declaration
)
2845 warned
= pedwarn (input_location
, OPT_Wimplicit_function_declaration
,
2846 "implicit declaration of function %qE", id
);
2848 warned
= warning (OPT_Wimplicit_function_declaration
,
2849 G_("implicit declaration of function %qE"), id
);
2850 if (olddecl
&& warned
)
2851 locate_old_decl (olddecl
);
2855 /* Generate an implicit declaration for identifier FUNCTIONID at LOC as a
2856 function of type int (). */
2859 implicitly_declare (location_t loc
, tree functionid
)
2861 struct c_binding
*b
;
2865 for (b
= I_SYMBOL_BINDING (functionid
); b
; b
= b
->shadowed
)
2867 if (B_IN_SCOPE (b
, external_scope
))
2876 if (decl
== error_mark_node
)
2879 /* FIXME: Objective-C has weird not-really-builtin functions
2880 which are supposed to be visible automatically. They wind up
2881 in the external scope because they're pushed before the file
2882 scope gets created. Catch this here and rebind them into the
2884 if (!DECL_BUILT_IN (decl
) && DECL_IS_BUILTIN (decl
))
2886 bind (functionid
, decl
, file_scope
,
2887 /*invisible=*/false, /*nested=*/true,
2888 DECL_SOURCE_LOCATION (decl
));
2893 tree newtype
= default_function_type
;
2895 TREE_TYPE (decl
) = b
->u
.type
;
2896 /* Implicit declaration of a function already declared
2897 (somehow) in a different scope, or as a built-in.
2898 If this is the first time this has happened, warn;
2899 then recycle the old declaration but with the new type. */
2900 if (!C_DECL_IMPLICIT (decl
))
2902 implicit_decl_warning (functionid
, decl
);
2903 C_DECL_IMPLICIT (decl
) = 1;
2905 if (DECL_BUILT_IN (decl
))
2907 newtype
= build_type_attribute_variant (newtype
,
2909 (TREE_TYPE (decl
)));
2910 if (!comptypes (newtype
, TREE_TYPE (decl
)))
2912 warning_at (loc
, 0, "incompatible implicit declaration of "
2913 "built-in function %qD", decl
);
2914 newtype
= TREE_TYPE (decl
);
2919 if (!comptypes (newtype
, TREE_TYPE (decl
)))
2921 error_at (loc
, "incompatible implicit declaration of function %qD", decl
);
2922 locate_old_decl (decl
);
2925 b
->u
.type
= TREE_TYPE (decl
);
2926 TREE_TYPE (decl
) = newtype
;
2927 bind (functionid
, decl
, current_scope
,
2928 /*invisible=*/false, /*nested=*/true,
2929 DECL_SOURCE_LOCATION (decl
));
2934 /* Not seen before. */
2935 decl
= build_decl (loc
, FUNCTION_DECL
, functionid
, default_function_type
);
2936 DECL_EXTERNAL (decl
) = 1;
2937 TREE_PUBLIC (decl
) = 1;
2938 C_DECL_IMPLICIT (decl
) = 1;
2939 implicit_decl_warning (functionid
, 0);
2940 asmspec_tree
= maybe_apply_renaming_pragma (decl
, /*asmname=*/NULL
);
2942 set_user_assembler_name (decl
, TREE_STRING_POINTER (asmspec_tree
));
2944 /* C89 says implicit declarations are in the innermost block.
2945 So we record the decl in the standard fashion. */
2946 decl
= pushdecl (decl
);
2948 /* No need to call objc_check_decl here - it's a function type. */
2949 rest_of_decl_compilation (decl
, 0, 0);
2951 /* Write a record describing this implicit function declaration
2952 to the prototypes file (if requested). */
2953 gen_aux_info_record (decl
, 0, 1, 0);
2955 /* Possibly apply some default attributes to this implicit declaration. */
2956 decl_attributes (&decl
, NULL_TREE
, 0);
2961 /* Issue an error message for a reference to an undeclared variable
2962 ID, including a reference to a builtin outside of function-call
2963 context. Establish a binding of the identifier to error_mark_node
2964 in an appropriate scope, which will suppress further errors for the
2965 same identifier. The error message should be given location LOC. */
2967 undeclared_variable (location_t loc
, tree id
)
2969 static bool already
= false;
2970 struct c_scope
*scope
;
2972 if (current_function_decl
== 0)
2974 error_at (loc
, "%qE undeclared here (not in a function)", id
);
2975 scope
= current_scope
;
2979 if (!objc_diagnose_private_ivar (id
))
2980 error_at (loc
, "%qE undeclared (first use in this function)", id
);
2983 inform (loc
, "each undeclared identifier is reported only"
2984 " once for each function it appears in");
2988 /* If we are parsing old-style parameter decls, current_function_decl
2989 will be nonnull but current_function_scope will be null. */
2990 scope
= current_function_scope
? current_function_scope
: current_scope
;
2992 bind (id
, error_mark_node
, scope
, /*invisible=*/false, /*nested=*/false,
2996 /* Subroutine of lookup_label, declare_label, define_label: construct a
2997 LABEL_DECL with all the proper frills. Also create a struct
2998 c_label_vars initialized for the current scope. */
3001 make_label (location_t location
, tree name
, bool defining
,
3002 struct c_label_vars
**p_label_vars
)
3004 tree label
= build_decl (location
, LABEL_DECL
, name
, void_type_node
);
3005 struct c_label_vars
*label_vars
;
3007 DECL_CONTEXT (label
) = current_function_decl
;
3008 DECL_MODE (label
) = VOIDmode
;
3010 label_vars
= ggc_alloc_c_label_vars ();
3011 label_vars
->shadowed
= NULL
;
3012 set_spot_bindings (&label_vars
->label_bindings
, defining
);
3013 label_vars
->decls_in_scope
= make_tree_vector ();
3014 label_vars
->gotos
= VEC_alloc (c_goto_bindings_p
, gc
, 0);
3015 *p_label_vars
= label_vars
;
3020 /* Get the LABEL_DECL corresponding to identifier NAME as a label.
3021 Create one if none exists so far for the current function.
3022 This is called when a label is used in a goto expression or
3023 has its address taken. */
3026 lookup_label (tree name
)
3029 struct c_label_vars
*label_vars
;
3031 if (current_function_scope
== 0)
3033 error ("label %qE referenced outside of any function", name
);
3037 /* Use a label already defined or ref'd with this name, but not if
3038 it is inherited from a containing function and wasn't declared
3040 label
= I_LABEL_DECL (name
);
3041 if (label
&& (DECL_CONTEXT (label
) == current_function_decl
3042 || C_DECLARED_LABEL_FLAG (label
)))
3044 /* If the label has only been declared, update its apparent
3045 location to point here, for better diagnostics if it
3046 turns out not to have been defined. */
3047 if (DECL_INITIAL (label
) == NULL_TREE
)
3048 DECL_SOURCE_LOCATION (label
) = input_location
;
3052 /* No label binding for that identifier; make one. */
3053 label
= make_label (input_location
, name
, false, &label_vars
);
3055 /* Ordinary labels go in the current function scope. */
3056 bind_label (name
, label
, current_function_scope
, label_vars
);
3061 /* Issue a warning about DECL for a goto statement at GOTO_LOC going
3065 warn_about_goto (location_t goto_loc
, tree label
, tree decl
)
3067 if (variably_modified_type_p (TREE_TYPE (decl
), NULL_TREE
))
3069 "jump into scope of identifier with variably modified type");
3071 warning_at (goto_loc
, OPT_Wjump_misses_init
,
3072 "jump skips variable initialization");
3073 inform (DECL_SOURCE_LOCATION (label
), "label %qD defined here", label
);
3074 inform (DECL_SOURCE_LOCATION (decl
), "%qD declared here", decl
);
3077 /* Look up a label because of a goto statement. This is like
3078 lookup_label, but also issues any appropriate warnings. */
3081 lookup_label_for_goto (location_t loc
, tree name
)
3084 struct c_label_vars
*label_vars
;
3088 label
= lookup_label (name
);
3089 if (label
== NULL_TREE
)
3092 /* If we are jumping to a different function, we can't issue any
3094 if (DECL_CONTEXT (label
) != current_function_decl
)
3096 gcc_assert (C_DECLARED_LABEL_FLAG (label
));
3100 label_vars
= I_LABEL_BINDING (name
)->u
.label
;
3102 /* If the label has not yet been defined, then push this goto on a
3103 list for possible later warnings. */
3104 if (label_vars
->label_bindings
.scope
== NULL
)
3106 struct c_goto_bindings
*g
;
3108 g
= ggc_alloc_c_goto_bindings ();
3110 set_spot_bindings (&g
->goto_bindings
, true);
3111 VEC_safe_push (c_goto_bindings_p
, gc
, label_vars
->gotos
, g
);
3115 /* If there are any decls in label_vars->decls_in_scope, then this
3116 goto has missed the declaration of the decl. This happens for a
3122 Issue a warning or error. */
3123 FOR_EACH_VEC_ELT (tree
, label_vars
->decls_in_scope
, ix
, decl
)
3124 warn_about_goto (loc
, label
, decl
);
3126 if (label_vars
->label_bindings
.left_stmt_expr
)
3128 error_at (loc
, "jump into statement expression");
3129 inform (DECL_SOURCE_LOCATION (label
), "label %qD defined here", label
);
3135 /* Make a label named NAME in the current function, shadowing silently
3136 any that may be inherited from containing functions or containing
3137 scopes. This is called for __label__ declarations. */
3140 declare_label (tree name
)
3142 struct c_binding
*b
= I_LABEL_BINDING (name
);
3144 struct c_label_vars
*label_vars
;
3146 /* Check to make sure that the label hasn't already been declared
3148 if (b
&& B_IN_CURRENT_SCOPE (b
))
3150 error ("duplicate label declaration %qE", name
);
3151 locate_old_decl (b
->decl
);
3153 /* Just use the previous declaration. */
3157 label
= make_label (input_location
, name
, false, &label_vars
);
3158 C_DECLARED_LABEL_FLAG (label
) = 1;
3160 /* Declared labels go in the current scope. */
3161 bind_label (name
, label
, current_scope
, label_vars
);
3166 /* When we define a label, issue any appropriate warnings if there are
3167 any gotos earlier in the function which jump to this label. */
3170 check_earlier_gotos (tree label
, struct c_label_vars
* label_vars
)
3173 struct c_goto_bindings
*g
;
3175 FOR_EACH_VEC_ELT (c_goto_bindings_p
, label_vars
->gotos
, ix
, g
)
3177 struct c_binding
*b
;
3178 struct c_scope
*scope
;
3180 /* We have a goto to this label. The goto is going forward. In
3181 g->scope, the goto is going to skip any binding which was
3182 defined after g->bindings_in_scope. */
3183 if (g
->goto_bindings
.scope
->has_jump_unsafe_decl
)
3185 for (b
= g
->goto_bindings
.scope
->bindings
;
3186 b
!= g
->goto_bindings
.bindings_in_scope
;
3189 if (decl_jump_unsafe (b
->decl
))
3190 warn_about_goto (g
->loc
, label
, b
->decl
);
3194 /* We also need to warn about decls defined in any scopes
3195 between the scope of the label and the scope of the goto. */
3196 for (scope
= label_vars
->label_bindings
.scope
;
3197 scope
!= g
->goto_bindings
.scope
;
3198 scope
= scope
->outer
)
3200 gcc_assert (scope
!= NULL
);
3201 if (scope
->has_jump_unsafe_decl
)
3203 if (scope
== label_vars
->label_bindings
.scope
)
3204 b
= label_vars
->label_bindings
.bindings_in_scope
;
3206 b
= scope
->bindings
;
3207 for (; b
!= NULL
; b
= b
->prev
)
3209 if (decl_jump_unsafe (b
->decl
))
3210 warn_about_goto (g
->loc
, label
, b
->decl
);
3215 if (g
->goto_bindings
.stmt_exprs
> 0)
3217 error_at (g
->loc
, "jump into statement expression");
3218 inform (DECL_SOURCE_LOCATION (label
), "label %qD defined here",
3223 /* Now that the label is defined, we will issue warnings about
3224 subsequent gotos to this label when we see them. */
3225 VEC_truncate (c_goto_bindings_p
, label_vars
->gotos
, 0);
3226 label_vars
->gotos
= NULL
;
3229 /* Define a label, specifying the location in the source file.
3230 Return the LABEL_DECL node for the label, if the definition is valid.
3231 Otherwise return 0. */
3234 define_label (location_t location
, tree name
)
3236 /* Find any preexisting label with this name. It is an error
3237 if that label has already been defined in this function, or
3238 if there is a containing function with a declared label with
3240 tree label
= I_LABEL_DECL (name
);
3243 && ((DECL_CONTEXT (label
) == current_function_decl
3244 && DECL_INITIAL (label
) != 0)
3245 || (DECL_CONTEXT (label
) != current_function_decl
3246 && C_DECLARED_LABEL_FLAG (label
))))
3248 error_at (location
, "duplicate label %qD", label
);
3249 locate_old_decl (label
);
3252 else if (label
&& DECL_CONTEXT (label
) == current_function_decl
)
3254 struct c_label_vars
*label_vars
= I_LABEL_BINDING (name
)->u
.label
;
3256 /* The label has been used or declared already in this function,
3257 but not defined. Update its location to point to this
3259 DECL_SOURCE_LOCATION (label
) = location
;
3260 set_spot_bindings (&label_vars
->label_bindings
, true);
3262 /* Issue warnings as required about any goto statements from
3263 earlier in the function. */
3264 check_earlier_gotos (label
, label_vars
);
3268 struct c_label_vars
*label_vars
;
3270 /* No label binding for that identifier; make one. */
3271 label
= make_label (location
, name
, true, &label_vars
);
3273 /* Ordinary labels go in the current function scope. */
3274 bind_label (name
, label
, current_function_scope
, label_vars
);
3277 if (!in_system_header
&& lookup_name (name
))
3278 warning_at (location
, OPT_Wtraditional
,
3279 "traditional C lacks a separate namespace "
3280 "for labels, identifier %qE conflicts", name
);
3282 /* Mark label as having been defined. */
3283 DECL_INITIAL (label
) = error_mark_node
;
3287 /* Get the bindings for a new switch statement. This is used to issue
3288 warnings as appropriate for jumps from the switch to case or
3291 struct c_spot_bindings
*
3292 c_get_switch_bindings (void)
3294 struct c_spot_bindings
*switch_bindings
;
3296 switch_bindings
= XNEW (struct c_spot_bindings
);
3297 set_spot_bindings (switch_bindings
, true);
3298 return switch_bindings
;
3302 c_release_switch_bindings (struct c_spot_bindings
*bindings
)
3304 gcc_assert (bindings
->stmt_exprs
== 0 && !bindings
->left_stmt_expr
);
3308 /* This is called at the point of a case or default label to issue
3309 warnings about decls as needed. It returns true if it found an
3310 error, not just a warning. */
3313 c_check_switch_jump_warnings (struct c_spot_bindings
*switch_bindings
,
3314 location_t switch_loc
, location_t case_loc
)
3317 struct c_scope
*scope
;
3320 for (scope
= current_scope
;
3321 scope
!= switch_bindings
->scope
;
3322 scope
= scope
->outer
)
3324 struct c_binding
*b
;
3326 gcc_assert (scope
!= NULL
);
3328 if (!scope
->has_jump_unsafe_decl
)
3331 for (b
= scope
->bindings
; b
!= NULL
; b
= b
->prev
)
3333 if (decl_jump_unsafe (b
->decl
))
3335 if (variably_modified_type_p (TREE_TYPE (b
->decl
), NULL_TREE
))
3339 ("switch jumps into scope of identifier with "
3340 "variably modified type"));
3343 warning_at (case_loc
, OPT_Wjump_misses_init
,
3344 "switch jumps over variable initialization");
3345 inform (switch_loc
, "switch starts here");
3346 inform (DECL_SOURCE_LOCATION (b
->decl
), "%qD declared here",
3352 if (switch_bindings
->stmt_exprs
> 0)
3355 error_at (case_loc
, "switch jumps into statement expression");
3356 inform (switch_loc
, "switch starts here");
3362 /* Given NAME, an IDENTIFIER_NODE,
3363 return the structure (or union or enum) definition for that name.
3364 If THISLEVEL_ONLY is nonzero, searches only the current_scope.
3365 CODE says which kind of type the caller wants;
3366 it is RECORD_TYPE or UNION_TYPE or ENUMERAL_TYPE.
3367 If PLOC is not NULL and this returns non-null, it sets *PLOC to the
3368 location where the tag was defined.
3369 If the wrong kind of type is found, an error is reported. */
3372 lookup_tag (enum tree_code code
, tree name
, int thislevel_only
,
3375 struct c_binding
*b
= I_TAG_BINDING (name
);
3381 /* We only care about whether it's in this level if
3382 thislevel_only was set or it might be a type clash. */
3383 if (thislevel_only
|| TREE_CODE (b
->decl
) != code
)
3385 /* For our purposes, a tag in the external scope is the same as
3386 a tag in the file scope. (Primarily relevant to Objective-C
3387 and its builtin structure tags, which get pushed before the
3388 file scope is created.) */
3389 if (B_IN_CURRENT_SCOPE (b
)
3390 || (current_scope
== file_scope
&& B_IN_EXTERNAL_SCOPE (b
)))
3394 if (thislevel_only
&& !thislevel
)
3397 if (TREE_CODE (b
->decl
) != code
)
3399 /* Definition isn't the kind we were looking for. */
3400 pending_invalid_xref
= name
;
3401 pending_invalid_xref_location
= input_location
;
3403 /* If in the same binding level as a declaration as a tag
3404 of a different type, this must not be allowed to
3405 shadow that tag, so give the error immediately.
3406 (For example, "struct foo; union foo;" is invalid.) */
3408 pending_xref_error ();
3417 /* Print an error message now
3418 for a recent invalid struct, union or enum cross reference.
3419 We don't print them immediately because they are not invalid
3420 when used in the `struct foo;' construct for shadowing. */
3423 pending_xref_error (void)
3425 if (pending_invalid_xref
!= 0)
3426 error_at (pending_invalid_xref_location
, "%qE defined as wrong kind of tag",
3427 pending_invalid_xref
);
3428 pending_invalid_xref
= 0;
3432 /* Look up NAME in the current scope and its superiors
3433 in the namespace of variables, functions and typedefs.
3434 Return a ..._DECL node of some kind representing its definition,
3435 or return 0 if it is undefined. */
3438 lookup_name (tree name
)
3440 struct c_binding
*b
= I_SYMBOL_BINDING (name
);
3441 if (b
&& !b
->invisible
)
3446 /* Similar to `lookup_name' but look only at the indicated scope. */
3449 lookup_name_in_scope (tree name
, struct c_scope
*scope
)
3451 struct c_binding
*b
;
3453 for (b
= I_SYMBOL_BINDING (name
); b
; b
= b
->shadowed
)
3454 if (B_IN_SCOPE (b
, scope
))
3459 /* Create the predefined scalar types of C,
3460 and some nodes representing standard constants (0, 1, (void *) 0).
3461 Initialize the global scope.
3462 Make definitions for built-in primitive functions. */
3465 c_init_decl_processing (void)
3467 location_t save_loc
= input_location
;
3469 /* Initialize reserved words for parser. */
3472 current_function_decl
= 0;
3474 gcc_obstack_init (&parser_obstack
);
3476 /* Make the externals scope. */
3478 external_scope
= current_scope
;
3480 /* Declarations from c_common_nodes_and_builtins must not be associated
3481 with this input file, lest we get differences between using and not
3482 using preprocessed headers. */
3483 input_location
= BUILTINS_LOCATION
;
3485 build_common_tree_nodes (flag_signed_char
);
3487 c_common_nodes_and_builtins ();
3489 /* In C, comparisons and TRUTH_* expressions have type int. */
3490 truthvalue_type_node
= integer_type_node
;
3491 truthvalue_true_node
= integer_one_node
;
3492 truthvalue_false_node
= integer_zero_node
;
3494 /* Even in C99, which has a real boolean type. */
3495 pushdecl (build_decl (UNKNOWN_LOCATION
, TYPE_DECL
, get_identifier ("_Bool"),
3496 boolean_type_node
));
3498 input_location
= save_loc
;
3500 pedantic_lvalues
= true;
3502 make_fname_decl
= c_make_fname_decl
;
3503 start_fname_decls ();
3506 /* Create the VAR_DECL at LOC for __FUNCTION__ etc. ID is the name to
3507 give the decl, NAME is the initialization string and TYPE_DEP
3508 indicates whether NAME depended on the type of the function. As we
3509 don't yet implement delayed emission of static data, we mark the
3510 decl as emitted so it is not placed in the output. Anything using
3511 it must therefore pull out the STRING_CST initializer directly.
3515 c_make_fname_decl (location_t loc
, tree id
, int type_dep
)
3517 const char *name
= fname_as_string (type_dep
);
3518 tree decl
, type
, init
;
3519 size_t length
= strlen (name
);
3521 type
= build_array_type (char_type_node
,
3522 build_index_type (size_int (length
)));
3523 type
= c_build_qualified_type (type
, TYPE_QUAL_CONST
);
3525 decl
= build_decl (loc
, VAR_DECL
, id
, type
);
3527 TREE_STATIC (decl
) = 1;
3528 TREE_READONLY (decl
) = 1;
3529 DECL_ARTIFICIAL (decl
) = 1;
3531 init
= build_string (length
+ 1, name
);
3532 free (CONST_CAST (char *, name
));
3533 TREE_TYPE (init
) = type
;
3534 DECL_INITIAL (decl
) = init
;
3536 TREE_USED (decl
) = 1;
3538 if (current_function_decl
3539 /* For invalid programs like this:
3542 const char* p = __FUNCTION__;
3544 the __FUNCTION__ is believed to appear in K&R style function
3545 parameter declarator. In that case we still don't have
3547 && (!seen_error () || current_function_scope
))
3549 DECL_CONTEXT (decl
) = current_function_decl
;
3550 bind (id
, decl
, current_function_scope
,
3551 /*invisible=*/false, /*nested=*/false, UNKNOWN_LOCATION
);
3554 finish_decl (decl
, loc
, init
, NULL_TREE
, NULL_TREE
);
3560 c_builtin_function (tree decl
)
3562 tree type
= TREE_TYPE (decl
);
3563 tree id
= DECL_NAME (decl
);
3565 const char *name
= IDENTIFIER_POINTER (id
);
3566 C_DECL_BUILTIN_PROTOTYPE (decl
) = prototype_p (type
);
3568 /* Should never be called on a symbol with a preexisting meaning. */
3569 gcc_assert (!I_SYMBOL_BINDING (id
));
3571 bind (id
, decl
, external_scope
, /*invisible=*/true, /*nested=*/false,
3574 /* Builtins in the implementation namespace are made visible without
3575 needing to be explicitly declared. See push_file_scope. */
3576 if (name
[0] == '_' && (name
[1] == '_' || ISUPPER (name
[1])))
3578 DECL_CHAIN (decl
) = visible_builtins
;
3579 visible_builtins
= decl
;
3586 c_builtin_function_ext_scope (tree decl
)
3588 tree type
= TREE_TYPE (decl
);
3589 tree id
= DECL_NAME (decl
);
3591 const char *name
= IDENTIFIER_POINTER (id
);
3592 C_DECL_BUILTIN_PROTOTYPE (decl
) = prototype_p (type
);
3594 /* Should never be called on a symbol with a preexisting meaning. */
3595 gcc_assert (!I_SYMBOL_BINDING (id
));
3597 bind (id
, decl
, external_scope
, /*invisible=*/false, /*nested=*/false,
3600 /* Builtins in the implementation namespace are made visible without
3601 needing to be explicitly declared. See push_file_scope. */
3602 if (name
[0] == '_' && (name
[1] == '_' || ISUPPER (name
[1])))
3604 DECL_CHAIN (decl
) = visible_builtins
;
3605 visible_builtins
= decl
;
3611 /* Called when a declaration is seen that contains no names to declare.
3612 If its type is a reference to a structure, union or enum inherited
3613 from a containing scope, shadow that tag name for the current scope
3614 with a forward reference.
3615 If its type defines a new named structure or union
3616 or defines an enum, it is valid but we need not do anything here.
3617 Otherwise, it is an error. */
3620 shadow_tag (const struct c_declspecs
*declspecs
)
3622 shadow_tag_warned (declspecs
, 0);
3625 /* WARNED is 1 if we have done a pedwarn, 2 if we have done a warning,
3628 shadow_tag_warned (const struct c_declspecs
*declspecs
, int warned
)
3630 bool found_tag
= false;
3632 if (declspecs
->type
&& !declspecs
->default_int_p
&& !declspecs
->typedef_p
)
3634 tree value
= declspecs
->type
;
3635 enum tree_code code
= TREE_CODE (value
);
3637 if (code
== RECORD_TYPE
|| code
== UNION_TYPE
|| code
== ENUMERAL_TYPE
)
3638 /* Used to test also that TYPE_SIZE (value) != 0.
3639 That caused warning for `struct foo;' at top level in the file. */
3641 tree name
= TYPE_NAME (value
);
3646 if (declspecs
->restrict_p
)
3648 error ("invalid use of %<restrict%>");
3654 if (warned
!= 1 && code
!= ENUMERAL_TYPE
)
3655 /* Empty unnamed enum OK */
3657 pedwarn (input_location
, 0,
3658 "unnamed struct/union that defines no instances");
3662 else if (declspecs
->typespec_kind
!= ctsk_tagdef
3663 && declspecs
->typespec_kind
!= ctsk_tagfirstref
3664 && declspecs
->storage_class
!= csc_none
)
3667 pedwarn (input_location
, 0,
3668 "empty declaration with storage class specifier "
3669 "does not redeclare tag");
3671 pending_xref_error ();
3673 else if (declspecs
->typespec_kind
!= ctsk_tagdef
3674 && declspecs
->typespec_kind
!= ctsk_tagfirstref
3675 && (declspecs
->const_p
3676 || declspecs
->volatile_p
3677 || declspecs
->restrict_p
3678 || declspecs
->address_space
))
3681 pedwarn (input_location
, 0,
3682 "empty declaration with type qualifier "
3683 "does not redeclare tag");
3685 pending_xref_error ();
3689 pending_invalid_xref
= 0;
3690 t
= lookup_tag (code
, name
, 1, NULL
);
3694 t
= make_node (code
);
3695 pushtag (input_location
, name
, t
);
3701 if (warned
!= 1 && !in_system_header
)
3703 pedwarn (input_location
, 0,
3704 "useless type name in empty declaration");
3709 else if (warned
!= 1 && !in_system_header
&& declspecs
->typedef_p
)
3711 pedwarn (input_location
, 0, "useless type name in empty declaration");
3715 pending_invalid_xref
= 0;
3717 if (declspecs
->inline_p
)
3719 error ("%<inline%> in empty declaration");
3723 if (current_scope
== file_scope
&& declspecs
->storage_class
== csc_auto
)
3725 error ("%<auto%> in file-scope empty declaration");
3729 if (current_scope
== file_scope
&& declspecs
->storage_class
== csc_register
)
3731 error ("%<register%> in file-scope empty declaration");
3735 if (!warned
&& !in_system_header
&& declspecs
->storage_class
!= csc_none
)
3737 warning (0, "useless storage class specifier in empty declaration");
3741 if (!warned
&& !in_system_header
&& declspecs
->thread_p
)
3743 warning (0, "useless %<__thread%> in empty declaration");
3747 if (!warned
&& !in_system_header
&& (declspecs
->const_p
3748 || declspecs
->volatile_p
3749 || declspecs
->restrict_p
3750 || declspecs
->address_space
))
3752 warning (0, "useless type qualifier in empty declaration");
3759 pedwarn (input_location
, 0, "empty declaration");
3764 /* Return the qualifiers from SPECS as a bitwise OR of TYPE_QUAL_*
3765 bits. SPECS represents declaration specifiers that the grammar
3766 only permits to contain type qualifiers and attributes. */
3769 quals_from_declspecs (const struct c_declspecs
*specs
)
3771 int quals
= ((specs
->const_p
? TYPE_QUAL_CONST
: 0)
3772 | (specs
->volatile_p
? TYPE_QUAL_VOLATILE
: 0)
3773 | (specs
->restrict_p
? TYPE_QUAL_RESTRICT
: 0)
3774 | (ENCODE_QUAL_ADDR_SPACE (specs
->address_space
)));
3775 gcc_assert (!specs
->type
3776 && !specs
->decl_attr
3777 && specs
->typespec_word
== cts_none
3778 && specs
->storage_class
== csc_none
3779 && !specs
->typedef_p
3780 && !specs
->explicit_signed_p
3781 && !specs
->deprecated_p
3783 && !specs
->long_long_p
3786 && !specs
->unsigned_p
3787 && !specs
->complex_p
3789 && !specs
->thread_p
);
3793 /* Construct an array declarator. LOC is the location of the
3794 beginning of the array (usually the opening brace). EXPR is the
3795 expression inside [], or NULL_TREE. QUALS are the type qualifiers
3796 inside the [] (to be applied to the pointer to which a parameter
3797 array is converted). STATIC_P is true if "static" is inside the
3798 [], false otherwise. VLA_UNSPEC_P is true if the array is [*], a
3799 VLA of unspecified length which is nevertheless a complete type,
3800 false otherwise. The field for the contained declarator is left to
3801 be filled in by set_array_declarator_inner. */
3803 struct c_declarator
*
3804 build_array_declarator (location_t loc
,
3805 tree expr
, struct c_declspecs
*quals
, bool static_p
,
3808 struct c_declarator
*declarator
= XOBNEW (&parser_obstack
,
3809 struct c_declarator
);
3810 declarator
->id_loc
= loc
;
3811 declarator
->kind
= cdk_array
;
3812 declarator
->declarator
= 0;
3813 declarator
->u
.array
.dimen
= expr
;
3816 declarator
->u
.array
.attrs
= quals
->attrs
;
3817 declarator
->u
.array
.quals
= quals_from_declspecs (quals
);
3821 declarator
->u
.array
.attrs
= NULL_TREE
;
3822 declarator
->u
.array
.quals
= 0;
3824 declarator
->u
.array
.static_p
= static_p
;
3825 declarator
->u
.array
.vla_unspec_p
= vla_unspec_p
;
3828 if (static_p
|| quals
!= NULL
)
3829 pedwarn (loc
, OPT_pedantic
,
3830 "ISO C90 does not support %<static%> or type "
3831 "qualifiers in parameter array declarators");
3833 pedwarn (loc
, OPT_pedantic
,
3834 "ISO C90 does not support %<[*]%> array declarators");
3838 if (!current_scope
->parm_flag
)
3841 error_at (loc
, "%<[*]%> not allowed in other than "
3842 "function prototype scope");
3843 declarator
->u
.array
.vla_unspec_p
= false;
3846 current_scope
->had_vla_unspec
= true;
3851 /* Set the contained declarator of an array declarator. DECL is the
3852 declarator, as constructed by build_array_declarator; INNER is what
3853 appears on the left of the []. */
3855 struct c_declarator
*
3856 set_array_declarator_inner (struct c_declarator
*decl
,
3857 struct c_declarator
*inner
)
3859 decl
->declarator
= inner
;
3863 /* INIT is a constructor that forms DECL's initializer. If the final
3864 element initializes a flexible array field, add the size of that
3865 initializer to DECL's size. */
3868 add_flexible_array_elts_to_size (tree decl
, tree init
)
3872 if (VEC_empty (constructor_elt
, CONSTRUCTOR_ELTS (init
)))
3875 elt
= VEC_last (constructor_elt
, CONSTRUCTOR_ELTS (init
))->value
;
3876 type
= TREE_TYPE (elt
);
3877 if (TREE_CODE (type
) == ARRAY_TYPE
3878 && TYPE_SIZE (type
) == NULL_TREE
3879 && TYPE_DOMAIN (type
) != NULL_TREE
3880 && TYPE_MAX_VALUE (TYPE_DOMAIN (type
)) == NULL_TREE
)
3882 complete_array_type (&type
, elt
, false);
3884 = size_binop (PLUS_EXPR
, DECL_SIZE (decl
), TYPE_SIZE (type
));
3885 DECL_SIZE_UNIT (decl
)
3886 = size_binop (PLUS_EXPR
, DECL_SIZE_UNIT (decl
), TYPE_SIZE_UNIT (type
));
3890 /* Decode a "typename", such as "int **", returning a ..._TYPE node.
3891 Set *EXPR, if EXPR not NULL, to any expression to be evaluated
3892 before the type name, and set *EXPR_CONST_OPERANDS, if
3893 EXPR_CONST_OPERANDS not NULL, to indicate whether the type name may
3894 appear in a constant expression. */
3897 groktypename (struct c_type_name
*type_name
, tree
*expr
,
3898 bool *expr_const_operands
)
3901 tree attrs
= type_name
->specs
->attrs
;
3903 type_name
->specs
->attrs
= NULL_TREE
;
3905 type
= grokdeclarator (type_name
->declarator
, type_name
->specs
, TYPENAME
,
3906 false, NULL
, &attrs
, expr
, expr_const_operands
,
3909 /* Apply attributes. */
3910 decl_attributes (&type
, attrs
, 0);
3915 /* Decode a declarator in an ordinary declaration or data definition.
3916 This is called as soon as the type information and variable name
3917 have been parsed, before parsing the initializer if any.
3918 Here we create the ..._DECL node, fill in its type,
3919 and put it on the list of decls for the current context.
3920 The ..._DECL node is returned as the value.
3922 Exception: for arrays where the length is not specified,
3923 the type is left null, to be filled in by `finish_decl'.
3925 Function definitions do not come here; they go to start_function
3926 instead. However, external and forward declarations of functions
3927 do go through here. Structure field declarations are done by
3928 grokfield and not through here. */
3931 start_decl (struct c_declarator
*declarator
, struct c_declspecs
*declspecs
,
3932 bool initialized
, tree attributes
)
3936 tree expr
= NULL_TREE
;
3937 enum deprecated_states deprecated_state
= DEPRECATED_NORMAL
;
3939 /* An object declared as __attribute__((deprecated)) suppresses
3940 warnings of uses of other deprecated items. */
3941 if (lookup_attribute ("deprecated", attributes
))
3942 deprecated_state
= DEPRECATED_SUPPRESS
;
3944 decl
= grokdeclarator (declarator
, declspecs
,
3945 NORMAL
, initialized
, NULL
, &attributes
, &expr
, NULL
,
3953 if (TREE_CODE (decl
) != FUNCTION_DECL
&& MAIN_NAME_P (DECL_NAME (decl
)))
3954 warning (OPT_Wmain
, "%q+D is usually a function", decl
);
3957 /* Is it valid for this decl to have an initializer at all?
3958 If not, set INITIALIZED to zero, which will indirectly
3959 tell 'finish_decl' to ignore the initializer once it is parsed. */
3960 switch (TREE_CODE (decl
))
3963 error ("typedef %qD is initialized (use __typeof__ instead)", decl
);
3968 error ("function %qD is initialized like a variable", decl
);
3973 /* DECL_INITIAL in a PARM_DECL is really DECL_ARG_TYPE. */
3974 error ("parameter %qD is initialized", decl
);
3979 /* Don't allow initializations for incomplete types except for
3980 arrays which might be completed by the initialization. */
3982 /* This can happen if the array size is an undefined macro.
3983 We already gave a warning, so we don't need another one. */
3984 if (TREE_TYPE (decl
) == error_mark_node
)
3986 else if (COMPLETE_TYPE_P (TREE_TYPE (decl
)))
3988 /* A complete type is ok if size is fixed. */
3990 if (TREE_CODE (TYPE_SIZE (TREE_TYPE (decl
))) != INTEGER_CST
3991 || C_DECL_VARIABLE_SIZE (decl
))
3993 error ("variable-sized object may not be initialized");
3997 else if (TREE_CODE (TREE_TYPE (decl
)) != ARRAY_TYPE
)
3999 error ("variable %qD has initializer but incomplete type", decl
);
4002 else if (C_DECL_VARIABLE_SIZE (decl
))
4004 /* Although C99 is unclear about whether incomplete arrays
4005 of VLAs themselves count as VLAs, it does not make
4006 sense to permit them to be initialized given that
4007 ordinary VLAs may not be initialized. */
4008 error ("variable-sized object may not be initialized");
4015 if (current_scope
== file_scope
)
4016 TREE_STATIC (decl
) = 1;
4018 /* Tell 'pushdecl' this is an initialized decl
4019 even though we don't yet have the initializer expression.
4020 Also tell 'finish_decl' it may store the real initializer. */
4021 DECL_INITIAL (decl
) = error_mark_node
;
4024 /* If this is a function declaration, write a record describing it to the
4025 prototypes file (if requested). */
4027 if (TREE_CODE (decl
) == FUNCTION_DECL
)
4028 gen_aux_info_record (decl
, 0, 0, prototype_p (TREE_TYPE (decl
)));
4030 /* ANSI specifies that a tentative definition which is not merged with
4031 a non-tentative definition behaves exactly like a definition with an
4032 initializer equal to zero. (Section 3.7.2)
4034 -fno-common gives strict ANSI behavior, though this tends to break
4035 a large body of code that grew up without this rule.
4037 Thread-local variables are never common, since there's no entrenched
4038 body of code to break, and it allows more efficient variable references
4039 in the presence of dynamic linking. */
4041 if (TREE_CODE (decl
) == VAR_DECL
4043 && TREE_PUBLIC (decl
)
4044 && !DECL_THREAD_LOCAL_P (decl
)
4046 DECL_COMMON (decl
) = 1;
4048 /* Set attributes here so if duplicate decl, will have proper attributes. */
4049 decl_attributes (&decl
, attributes
, 0);
4051 /* Handle gnu_inline attribute. */
4052 if (declspecs
->inline_p
4053 && !flag_gnu89_inline
4054 && TREE_CODE (decl
) == FUNCTION_DECL
4055 && (lookup_attribute ("gnu_inline", DECL_ATTRIBUTES (decl
))
4056 || current_function_decl
))
4058 if (declspecs
->storage_class
== csc_auto
&& current_scope
!= file_scope
)
4060 else if (declspecs
->storage_class
!= csc_static
)
4061 DECL_EXTERNAL (decl
) = !DECL_EXTERNAL (decl
);
4064 if (TREE_CODE (decl
) == FUNCTION_DECL
4065 && targetm
.calls
.promote_prototypes (TREE_TYPE (decl
)))
4067 struct c_declarator
*ce
= declarator
;
4069 if (ce
->kind
== cdk_pointer
)
4070 ce
= declarator
->declarator
;
4071 if (ce
->kind
== cdk_function
)
4073 tree args
= ce
->u
.arg_info
->parms
;
4074 for (; args
; args
= DECL_CHAIN (args
))
4076 tree type
= TREE_TYPE (args
);
4077 if (type
&& INTEGRAL_TYPE_P (type
)
4078 && TYPE_PRECISION (type
) < TYPE_PRECISION (integer_type_node
))
4079 DECL_ARG_TYPE (args
) = integer_type_node
;
4084 if (TREE_CODE (decl
) == FUNCTION_DECL
4085 && DECL_DECLARED_INLINE_P (decl
)
4086 && DECL_UNINLINABLE (decl
)
4087 && lookup_attribute ("noinline", DECL_ATTRIBUTES (decl
)))
4088 warning (OPT_Wattributes
, "inline function %q+D given attribute noinline",
4091 /* C99 6.7.4p3: An inline definition of a function with external
4092 linkage shall not contain a definition of a modifiable object
4093 with static storage duration... */
4094 if (TREE_CODE (decl
) == VAR_DECL
4095 && current_scope
!= file_scope
4096 && TREE_STATIC (decl
)
4097 && !TREE_READONLY (decl
)
4098 && DECL_DECLARED_INLINE_P (current_function_decl
)
4099 && DECL_EXTERNAL (current_function_decl
))
4100 record_inline_static (input_location
, current_function_decl
,
4101 decl
, csi_modifiable
);
4103 if (c_dialect_objc ()
4104 && (TREE_CODE (decl
) == VAR_DECL
4105 || TREE_CODE (decl
) == FUNCTION_DECL
))
4106 objc_check_global_decl (decl
);
4108 /* Add this decl to the current scope.
4109 TEM may equal DECL or it may be a previous decl of the same name. */
4110 tem
= pushdecl (decl
);
4112 if (initialized
&& DECL_EXTERNAL (tem
))
4114 DECL_EXTERNAL (tem
) = 0;
4115 TREE_STATIC (tem
) = 1;
4121 /* Subroutine of finish_decl. TYPE is the type of an uninitialized object
4122 DECL or the non-array element type if DECL is an uninitialized array.
4123 If that type has a const member, diagnose this. */
4126 diagnose_uninitialized_cst_member (tree decl
, tree type
)
4129 for (field
= TYPE_FIELDS (type
); field
; field
= TREE_CHAIN (field
))
4132 if (TREE_CODE (field
) != FIELD_DECL
)
4134 field_type
= strip_array_types (TREE_TYPE (field
));
4136 if (TYPE_QUALS (field_type
) & TYPE_QUAL_CONST
)
4138 warning_at (DECL_SOURCE_LOCATION (decl
), OPT_Wc___compat
,
4139 "uninitialized const member in %qT is invalid in C++",
4140 strip_array_types (TREE_TYPE (decl
)));
4141 inform (DECL_SOURCE_LOCATION (field
), "%qD should be initialized", field
);
4144 if (TREE_CODE (field_type
) == RECORD_TYPE
4145 || TREE_CODE (field_type
) == UNION_TYPE
)
4146 diagnose_uninitialized_cst_member (decl
, field_type
);
4150 /* Finish processing of a declaration;
4151 install its initial value.
4152 If ORIGTYPE is not NULL_TREE, it is the original type of INIT.
4153 If the length of an array type is not known before,
4154 it must be determined now, from the initial value, or it is an error.
4156 INIT_LOC is the location of the initial value. */
4159 finish_decl (tree decl
, location_t init_loc
, tree init
,
4160 tree origtype
, tree asmspec_tree
)
4163 bool was_incomplete
= (DECL_SIZE (decl
) == 0);
4164 const char *asmspec
= 0;
4166 /* If a name was specified, get the string. */
4167 if ((TREE_CODE (decl
) == FUNCTION_DECL
|| TREE_CODE (decl
) == VAR_DECL
)
4168 && DECL_FILE_SCOPE_P (decl
))
4169 asmspec_tree
= maybe_apply_renaming_pragma (decl
, asmspec_tree
);
4171 asmspec
= TREE_STRING_POINTER (asmspec_tree
);
4173 if (TREE_CODE (decl
) == VAR_DECL
4174 && TREE_STATIC (decl
)
4175 && global_bindings_p ())
4176 /* So decl is a global variable. Record the types it uses
4177 so that we can decide later to emit debug info for them. */
4178 record_types_used_by_current_var_decl (decl
);
4180 /* If `start_decl' didn't like having an initialization, ignore it now. */
4181 if (init
!= 0 && DECL_INITIAL (decl
) == 0)
4184 /* Don't crash if parm is initialized. */
4185 if (TREE_CODE (decl
) == PARM_DECL
)
4189 store_init_value (init_loc
, decl
, init
, origtype
);
4191 if (c_dialect_objc () && (TREE_CODE (decl
) == VAR_DECL
4192 || TREE_CODE (decl
) == FUNCTION_DECL
4193 || TREE_CODE (decl
) == FIELD_DECL
))
4194 objc_check_decl (decl
);
4196 type
= TREE_TYPE (decl
);
4198 /* Deduce size of array from initialization, if not already known. */
4199 if (TREE_CODE (type
) == ARRAY_TYPE
4200 && TYPE_DOMAIN (type
) == 0
4201 && TREE_CODE (decl
) != TYPE_DECL
)
4204 = (TREE_STATIC (decl
)
4205 /* Even if pedantic, an external linkage array
4206 may have incomplete type at first. */
4207 ? pedantic
&& !TREE_PUBLIC (decl
)
4208 : !DECL_EXTERNAL (decl
));
4210 = complete_array_type (&TREE_TYPE (decl
), DECL_INITIAL (decl
),
4213 /* Get the completed type made by complete_array_type. */
4214 type
= TREE_TYPE (decl
);
4219 error ("initializer fails to determine size of %q+D", decl
);
4224 error ("array size missing in %q+D", decl
);
4225 /* If a `static' var's size isn't known,
4226 make it extern as well as static, so it does not get
4228 If it is not `static', then do not mark extern;
4229 finish_incomplete_decl will give it a default size
4230 and it will get allocated. */
4231 else if (!pedantic
&& TREE_STATIC (decl
) && !TREE_PUBLIC (decl
))
4232 DECL_EXTERNAL (decl
) = 1;
4236 error ("zero or negative size array %q+D", decl
);
4240 /* For global variables, update the copy of the type that
4241 exists in the binding. */
4242 if (TREE_PUBLIC (decl
))
4244 struct c_binding
*b_ext
= I_SYMBOL_BINDING (DECL_NAME (decl
));
4245 while (b_ext
&& !B_IN_EXTERNAL_SCOPE (b_ext
))
4246 b_ext
= b_ext
->shadowed
;
4250 b_ext
->u
.type
= composite_type (b_ext
->u
.type
, type
);
4252 b_ext
->u
.type
= type
;
4261 if (DECL_INITIAL (decl
))
4262 TREE_TYPE (DECL_INITIAL (decl
)) = type
;
4264 layout_decl (decl
, 0);
4267 if (TREE_CODE (decl
) == VAR_DECL
)
4269 if (init
&& TREE_CODE (init
) == CONSTRUCTOR
)
4270 add_flexible_array_elts_to_size (decl
, init
);
4272 if (DECL_SIZE (decl
) == 0 && TREE_TYPE (decl
) != error_mark_node
4273 && COMPLETE_TYPE_P (TREE_TYPE (decl
)))
4274 layout_decl (decl
, 0);
4276 if (DECL_SIZE (decl
) == 0
4277 /* Don't give an error if we already gave one earlier. */
4278 && TREE_TYPE (decl
) != error_mark_node
4279 && (TREE_STATIC (decl
)
4280 /* A static variable with an incomplete type
4281 is an error if it is initialized.
4282 Also if it is not file scope.
4283 Otherwise, let it through, but if it is not `extern'
4284 then it may cause an error message later. */
4285 ? (DECL_INITIAL (decl
) != 0
4286 || !DECL_FILE_SCOPE_P (decl
))
4287 /* An automatic variable with an incomplete type
4289 : !DECL_EXTERNAL (decl
)))
4291 error ("storage size of %q+D isn%'t known", decl
);
4292 TREE_TYPE (decl
) = error_mark_node
;
4295 if ((DECL_EXTERNAL (decl
) || TREE_STATIC (decl
))
4296 && DECL_SIZE (decl
) != 0)
4298 if (TREE_CODE (DECL_SIZE (decl
)) == INTEGER_CST
)
4299 constant_expression_warning (DECL_SIZE (decl
));
4302 error ("storage size of %q+D isn%'t constant", decl
);
4303 TREE_TYPE (decl
) = error_mark_node
;
4307 if (TREE_USED (type
))
4309 TREE_USED (decl
) = 1;
4310 DECL_READ_P (decl
) = 1;
4314 /* If this is a function and an assembler name is specified, reset DECL_RTL
4315 so we can give it its new name. Also, update built_in_decls if it
4316 was a normal built-in. */
4317 if (TREE_CODE (decl
) == FUNCTION_DECL
&& asmspec
)
4319 if (DECL_BUILT_IN_CLASS (decl
) == BUILT_IN_NORMAL
)
4320 set_builtin_user_assembler_name (decl
, asmspec
);
4321 set_user_assembler_name (decl
, asmspec
);
4324 /* If #pragma weak was used, mark the decl weak now. */
4325 maybe_apply_pragma_weak (decl
);
4327 /* Output the assembler code and/or RTL code for variables and functions,
4328 unless the type is an undefined structure or union.
4329 If not, it will get done when the type is completed. */
4331 if (TREE_CODE (decl
) == VAR_DECL
|| TREE_CODE (decl
) == FUNCTION_DECL
)
4333 /* Determine the ELF visibility. */
4334 if (TREE_PUBLIC (decl
))
4335 c_determine_visibility (decl
);
4337 /* This is a no-op in c-lang.c or something real in objc-act.c. */
4338 if (c_dialect_objc ())
4339 objc_check_decl (decl
);
4343 /* If this is not a static variable, issue a warning.
4344 It doesn't make any sense to give an ASMSPEC for an
4345 ordinary, non-register local variable. Historically,
4346 GCC has accepted -- but ignored -- the ASMSPEC in
4348 if (!DECL_FILE_SCOPE_P (decl
)
4349 && TREE_CODE (decl
) == VAR_DECL
4350 && !C_DECL_REGISTER (decl
)
4351 && !TREE_STATIC (decl
))
4352 warning (0, "ignoring asm-specifier for non-static local "
4353 "variable %q+D", decl
);
4355 set_user_assembler_name (decl
, asmspec
);
4358 if (DECL_FILE_SCOPE_P (decl
))
4360 if (DECL_INITIAL (decl
) == NULL_TREE
4361 || DECL_INITIAL (decl
) == error_mark_node
)
4362 /* Don't output anything
4363 when a tentative file-scope definition is seen.
4364 But at end of compilation, do output code for them. */
4365 DECL_DEFER_OUTPUT (decl
) = 1;
4366 rest_of_decl_compilation (decl
, true, 0);
4370 /* In conjunction with an ASMSPEC, the `register'
4371 keyword indicates that we should place the variable
4372 in a particular register. */
4373 if (asmspec
&& C_DECL_REGISTER (decl
))
4375 DECL_HARD_REGISTER (decl
) = 1;
4376 /* This cannot be done for a structure with volatile
4377 fields, on which DECL_REGISTER will have been
4379 if (!DECL_REGISTER (decl
))
4380 error ("cannot put object with volatile field into register");
4383 if (TREE_CODE (decl
) != FUNCTION_DECL
)
4385 /* If we're building a variable sized type, and we might be
4386 reachable other than via the top of the current binding
4387 level, then create a new BIND_EXPR so that we deallocate
4388 the object at the right time. */
4389 /* Note that DECL_SIZE can be null due to errors. */
4390 if (DECL_SIZE (decl
)
4391 && !TREE_CONSTANT (DECL_SIZE (decl
))
4392 && STATEMENT_LIST_HAS_LABEL (cur_stmt_list
))
4395 bind
= build3 (BIND_EXPR
, void_type_node
, NULL
, NULL
, NULL
);
4396 TREE_SIDE_EFFECTS (bind
) = 1;
4398 BIND_EXPR_BODY (bind
) = push_stmt_list ();
4400 add_stmt (build_stmt (DECL_SOURCE_LOCATION (decl
),
4406 if (!DECL_FILE_SCOPE_P (decl
))
4408 /* Recompute the RTL of a local array now
4409 if it used to be an incomplete type. */
4411 && !TREE_STATIC (decl
) && !DECL_EXTERNAL (decl
))
4413 /* If we used it already as memory, it must stay in memory. */
4414 TREE_ADDRESSABLE (decl
) = TREE_USED (decl
);
4415 /* If it's still incomplete now, no init will save it. */
4416 if (DECL_SIZE (decl
) == 0)
4417 DECL_INITIAL (decl
) = 0;
4422 if (TREE_CODE (decl
) == TYPE_DECL
)
4424 if (!DECL_FILE_SCOPE_P (decl
)
4425 && variably_modified_type_p (TREE_TYPE (decl
), NULL_TREE
))
4426 add_stmt (build_stmt (DECL_SOURCE_LOCATION (decl
), DECL_EXPR
, decl
));
4428 rest_of_decl_compilation (decl
, DECL_FILE_SCOPE_P (decl
), 0);
4431 /* At the end of a declaration, throw away any variable type sizes
4432 of types defined inside that declaration. There is no use
4433 computing them in the following function definition. */
4434 if (current_scope
== file_scope
)
4435 get_pending_sizes ();
4437 /* Install a cleanup (aka destructor) if one was given. */
4438 if (TREE_CODE (decl
) == VAR_DECL
&& !TREE_STATIC (decl
))
4440 tree attr
= lookup_attribute ("cleanup", DECL_ATTRIBUTES (decl
));
4443 tree cleanup_id
= TREE_VALUE (TREE_VALUE (attr
));
4444 tree cleanup_decl
= lookup_name (cleanup_id
);
4448 /* Build "cleanup(&decl)" for the destructor. */
4449 cleanup
= build_unary_op (input_location
, ADDR_EXPR
, decl
, 0);
4450 vec
= VEC_alloc (tree
, gc
, 1);
4451 VEC_quick_push (tree
, vec
, cleanup
);
4452 cleanup
= build_function_call_vec (DECL_SOURCE_LOCATION (decl
),
4453 cleanup_decl
, vec
, NULL
);
4454 VEC_free (tree
, gc
, vec
);
4456 /* Don't warn about decl unused; the cleanup uses it. */
4457 TREE_USED (decl
) = 1;
4458 TREE_USED (cleanup_decl
) = 1;
4459 DECL_READ_P (decl
) = 1;
4461 push_cleanup (decl
, cleanup
, false);
4466 && TREE_CODE (decl
) == VAR_DECL
4467 && !DECL_EXTERNAL (decl
)
4468 && DECL_INITIAL (decl
) == NULL_TREE
)
4470 type
= strip_array_types (type
);
4471 if (TREE_READONLY (decl
))
4472 warning_at (DECL_SOURCE_LOCATION (decl
), OPT_Wc___compat
,
4473 "uninitialized const %qD is invalid in C++", decl
);
4474 else if ((TREE_CODE (type
) == RECORD_TYPE
4475 || TREE_CODE (type
) == UNION_TYPE
)
4476 && C_TYPE_FIELDS_READONLY (type
))
4477 diagnose_uninitialized_cst_member (decl
, type
);
4481 /* Given a parsed parameter declaration, decode it into a PARM_DECL. */
4484 grokparm (const struct c_parm
*parm
)
4486 tree attrs
= parm
->attrs
;
4487 tree decl
= grokdeclarator (parm
->declarator
, parm
->specs
, PARM
, false,
4488 NULL
, &attrs
, NULL
, NULL
, DEPRECATED_NORMAL
);
4490 decl_attributes (&decl
, attrs
, 0);
4495 /* Given a parsed parameter declaration, decode it into a PARM_DECL
4496 and push that on the current scope. */
4499 push_parm_decl (const struct c_parm
*parm
)
4501 tree attrs
= parm
->attrs
;
4504 decl
= grokdeclarator (parm
->declarator
, parm
->specs
, PARM
, false, NULL
,
4505 &attrs
, NULL
, NULL
, DEPRECATED_NORMAL
);
4506 decl_attributes (&decl
, attrs
, 0);
4508 decl
= pushdecl (decl
);
4510 finish_decl (decl
, input_location
, NULL_TREE
, NULL_TREE
, NULL_TREE
);
4513 /* Mark all the parameter declarations to date as forward decls.
4514 Also diagnose use of this extension. */
4517 mark_forward_parm_decls (void)
4519 struct c_binding
*b
;
4521 if (pedantic
&& !current_scope
->warned_forward_parm_decls
)
4523 pedwarn (input_location
, OPT_pedantic
,
4524 "ISO C forbids forward parameter declarations");
4525 current_scope
->warned_forward_parm_decls
= true;
4528 for (b
= current_scope
->bindings
; b
; b
= b
->prev
)
4529 if (TREE_CODE (b
->decl
) == PARM_DECL
)
4530 TREE_ASM_WRITTEN (b
->decl
) = 1;
4533 /* Build a COMPOUND_LITERAL_EXPR. TYPE is the type given in the compound
4534 literal, which may be an incomplete array type completed by the
4535 initializer; INIT is a CONSTRUCTOR at LOC that initializes the compound
4536 literal. NON_CONST is true if the initializers contain something
4537 that cannot occur in a constant expression. */
4540 build_compound_literal (location_t loc
, tree type
, tree init
, bool non_const
)
4542 /* We do not use start_decl here because we have a type, not a declarator;
4543 and do not use finish_decl because the decl should be stored inside
4544 the COMPOUND_LITERAL_EXPR rather than added elsewhere as a DECL_EXPR. */
4549 if (type
== error_mark_node
4550 || init
== error_mark_node
)
4551 return error_mark_node
;
4553 decl
= build_decl (loc
, VAR_DECL
, NULL_TREE
, type
);
4554 DECL_EXTERNAL (decl
) = 0;
4555 TREE_PUBLIC (decl
) = 0;
4556 TREE_STATIC (decl
) = (current_scope
== file_scope
);
4557 DECL_CONTEXT (decl
) = current_function_decl
;
4558 TREE_USED (decl
) = 1;
4559 DECL_READ_P (decl
) = 1;
4560 TREE_TYPE (decl
) = type
;
4561 TREE_READONLY (decl
) = TYPE_READONLY (type
);
4562 store_init_value (loc
, decl
, init
, NULL_TREE
);
4564 if (TREE_CODE (type
) == ARRAY_TYPE
&& !COMPLETE_TYPE_P (type
))
4566 int failure
= complete_array_type (&TREE_TYPE (decl
),
4567 DECL_INITIAL (decl
), true);
4568 gcc_assert (!failure
);
4570 type
= TREE_TYPE (decl
);
4571 TREE_TYPE (DECL_INITIAL (decl
)) = type
;
4574 if (type
== error_mark_node
|| !COMPLETE_TYPE_P (type
))
4575 return error_mark_node
;
4577 stmt
= build_stmt (DECL_SOURCE_LOCATION (decl
), DECL_EXPR
, decl
);
4578 complit
= build1 (COMPOUND_LITERAL_EXPR
, type
, stmt
);
4579 TREE_SIDE_EFFECTS (complit
) = 1;
4581 layout_decl (decl
, 0);
4583 if (TREE_STATIC (decl
))
4585 /* This decl needs a name for the assembler output. */
4586 set_compound_literal_name (decl
);
4587 DECL_DEFER_OUTPUT (decl
) = 1;
4588 DECL_COMDAT (decl
) = 1;
4589 DECL_ARTIFICIAL (decl
) = 1;
4590 DECL_IGNORED_P (decl
) = 1;
4592 rest_of_decl_compilation (decl
, 1, 0);
4597 complit
= build2 (C_MAYBE_CONST_EXPR
, type
, NULL
, complit
);
4598 C_MAYBE_CONST_EXPR_NON_CONST (complit
) = 1;
4604 /* Check the type of a compound literal. Here we just check that it
4605 is valid for C++. */
4608 check_compound_literal_type (location_t loc
, struct c_type_name
*type_name
)
4611 && (type_name
->specs
->typespec_kind
== ctsk_tagdef
4612 || type_name
->specs
->typespec_kind
== ctsk_tagfirstref
))
4613 warning_at (loc
, OPT_Wc___compat
,
4614 "defining a type in a compound literal is invalid in C++");
4617 /* Determine whether TYPE is a structure with a flexible array member,
4618 or a union containing such a structure (possibly recursively). */
4621 flexible_array_type_p (tree type
)
4624 switch (TREE_CODE (type
))
4627 x
= TYPE_FIELDS (type
);
4630 while (DECL_CHAIN (x
) != NULL_TREE
)
4632 if (TREE_CODE (TREE_TYPE (x
)) == ARRAY_TYPE
4633 && TYPE_SIZE (TREE_TYPE (x
)) == NULL_TREE
4634 && TYPE_DOMAIN (TREE_TYPE (x
)) != NULL_TREE
4635 && TYPE_MAX_VALUE (TYPE_DOMAIN (TREE_TYPE (x
))) == NULL_TREE
)
4639 for (x
= TYPE_FIELDS (type
); x
!= NULL_TREE
; x
= DECL_CHAIN (x
))
4641 if (flexible_array_type_p (TREE_TYPE (x
)))
4650 /* Performs sanity checks on the TYPE and WIDTH of the bit-field NAME,
4651 replacing with appropriate values if they are invalid. */
4653 check_bitfield_type_and_width (tree
*type
, tree
*width
, tree orig_name
)
4656 unsigned int max_width
;
4657 unsigned HOST_WIDE_INT w
;
4658 const char *name
= (orig_name
4659 ? identifier_to_locale (IDENTIFIER_POINTER (orig_name
))
4660 : _("<anonymous>"));
4662 /* Detect and ignore out of range field width and process valid
4664 if (!INTEGRAL_TYPE_P (TREE_TYPE (*width
)))
4666 error ("bit-field %qs width not an integer constant", name
);
4667 *width
= integer_one_node
;
4671 if (TREE_CODE (*width
) != INTEGER_CST
)
4673 *width
= c_fully_fold (*width
, false, NULL
);
4674 if (TREE_CODE (*width
) == INTEGER_CST
)
4675 pedwarn (input_location
, OPT_pedantic
,
4676 "bit-field %qs width not an integer constant expression",
4679 if (TREE_CODE (*width
) != INTEGER_CST
)
4681 error ("bit-field %qs width not an integer constant", name
);
4682 *width
= integer_one_node
;
4684 constant_expression_warning (*width
);
4685 if (tree_int_cst_sgn (*width
) < 0)
4687 error ("negative width in bit-field %qs", name
);
4688 *width
= integer_one_node
;
4690 else if (integer_zerop (*width
) && orig_name
)
4692 error ("zero width for bit-field %qs", name
);
4693 *width
= integer_one_node
;
4697 /* Detect invalid bit-field type. */
4698 if (TREE_CODE (*type
) != INTEGER_TYPE
4699 && TREE_CODE (*type
) != BOOLEAN_TYPE
4700 && TREE_CODE (*type
) != ENUMERAL_TYPE
)
4702 error ("bit-field %qs has invalid type", name
);
4703 *type
= unsigned_type_node
;
4706 type_mv
= TYPE_MAIN_VARIANT (*type
);
4707 if (!in_system_header
4708 && type_mv
!= integer_type_node
4709 && type_mv
!= unsigned_type_node
4710 && type_mv
!= boolean_type_node
)
4711 pedwarn (input_location
, OPT_pedantic
,
4712 "type of bit-field %qs is a GCC extension", name
);
4714 max_width
= TYPE_PRECISION (*type
);
4716 if (0 < compare_tree_int (*width
, max_width
))
4718 error ("width of %qs exceeds its type", name
);
4720 *width
= build_int_cst (NULL_TREE
, w
);
4723 w
= tree_low_cst (*width
, 1);
4725 if (TREE_CODE (*type
) == ENUMERAL_TYPE
)
4727 struct lang_type
*lt
= TYPE_LANG_SPECIFIC (*type
);
4729 || w
< tree_int_cst_min_precision (lt
->enum_min
, TYPE_UNSIGNED (*type
))
4730 || w
< tree_int_cst_min_precision (lt
->enum_max
, TYPE_UNSIGNED (*type
)))
4731 warning (0, "%qs is narrower than values of its type", name
);
4737 /* Print warning about variable length array if necessary. */
4740 warn_variable_length_array (tree name
, tree size
)
4742 int const_size
= TREE_CONSTANT (size
);
4744 if (!flag_isoc99
&& pedantic
&& warn_vla
!= 0)
4749 pedwarn (input_location
, OPT_Wvla
,
4750 "ISO C90 forbids array %qE whose size "
4751 "can%'t be evaluated",
4754 pedwarn (input_location
, OPT_Wvla
, "ISO C90 forbids array whose size "
4755 "can%'t be evaluated");
4760 pedwarn (input_location
, OPT_Wvla
,
4761 "ISO C90 forbids variable length array %qE",
4764 pedwarn (input_location
, OPT_Wvla
, "ISO C90 forbids variable length array");
4767 else if (warn_vla
> 0)
4773 "the size of array %qE can"
4774 "%'t be evaluated", name
);
4777 "the size of array can %'t be evaluated");
4783 "variable length array %qE is used",
4787 "variable length array is used");
4792 /* Given a size SIZE that may not be a constant, return a SAVE_EXPR to
4793 serve as the actual size-expression for a type or decl. This is
4794 like variable_size in stor-layout.c, but we make global_bindings_p
4795 return negative to avoid calls to that function from outside the
4796 front end resulting in errors at file scope, then call this version
4797 instead from front-end code. */
4800 c_variable_size (tree size
)
4804 if (TREE_CONSTANT (size
))
4807 size
= save_expr (size
);
4809 save
= skip_simple_arithmetic (size
);
4811 if (cfun
&& cfun
->dont_save_pending_sizes_p
)
4814 if (!global_bindings_p ())
4815 put_pending_size (save
);
4820 /* Given declspecs and a declarator,
4821 determine the name and type of the object declared
4822 and construct a ..._DECL node for it.
4823 (In one case we can return a ..._TYPE node instead.
4824 For invalid input we sometimes return 0.)
4826 DECLSPECS is a c_declspecs structure for the declaration specifiers.
4828 DECL_CONTEXT says which syntactic context this declaration is in:
4829 NORMAL for most contexts. Make a VAR_DECL or FUNCTION_DECL or TYPE_DECL.
4830 FUNCDEF for a function definition. Like NORMAL but a few different
4831 error messages in each case. Return value may be zero meaning
4832 this definition is too screwy to try to parse.
4833 PARM for a parameter declaration (either within a function prototype
4834 or before a function body). Make a PARM_DECL, or return void_type_node.
4835 TYPENAME if for a typename (in a cast or sizeof).
4836 Don't make a DECL node; just return the ..._TYPE node.
4837 FIELD for a struct or union field; make a FIELD_DECL.
4838 INITIALIZED is true if the decl has an initializer.
4839 WIDTH is non-NULL for bit-fields, and is a pointer to an INTEGER_CST node
4840 representing the width of the bit-field.
4841 DECL_ATTRS points to the list of attributes that should be added to this
4842 decl. Any nested attributes that belong on the decl itself will be
4844 If EXPR is not NULL, any expressions that need to be evaluated as
4845 part of evaluating variably modified types will be stored in *EXPR.
4846 If EXPR_CONST_OPERANDS is not NULL, *EXPR_CONST_OPERANDS will be
4847 set to indicate whether operands in *EXPR can be used in constant
4849 DEPRECATED_STATE is a deprecated_states value indicating whether
4850 deprecation warnings should be suppressed.
4852 In the TYPENAME case, DECLARATOR is really an absolute declarator.
4853 It may also be so in the PARM case, for a prototype where the
4854 argument type is specified but not the name.
4856 This function is where the complicated C meanings of `static'
4857 and `extern' are interpreted. */
4860 grokdeclarator (const struct c_declarator
*declarator
,
4861 struct c_declspecs
*declspecs
,
4862 enum decl_context decl_context
, bool initialized
, tree
*width
,
4863 tree
*decl_attrs
, tree
*expr
, bool *expr_const_operands
,
4864 enum deprecated_states deprecated_state
)
4866 tree type
= declspecs
->type
;
4867 bool threadp
= declspecs
->thread_p
;
4868 enum c_storage_class storage_class
= declspecs
->storage_class
;
4872 int type_quals
= TYPE_UNQUALIFIED
;
4873 tree name
= NULL_TREE
;
4874 bool funcdef_flag
= false;
4875 bool funcdef_syntax
= false;
4876 bool size_varies
= false;
4877 tree decl_attr
= declspecs
->decl_attr
;
4878 int array_ptr_quals
= TYPE_UNQUALIFIED
;
4879 tree array_ptr_attrs
= NULL_TREE
;
4880 int array_parm_static
= 0;
4881 bool array_parm_vla_unspec_p
= false;
4882 tree returned_attrs
= NULL_TREE
;
4883 bool bitfield
= width
!= NULL
;
4885 struct c_arg_info
*arg_info
= 0;
4886 addr_space_t as1
, as2
, address_space
;
4887 location_t loc
= UNKNOWN_LOCATION
;
4890 bool expr_const_operands_dummy
;
4891 enum c_declarator_kind first_non_attr_kind
;
4893 if (TREE_CODE (type
) == ERROR_MARK
)
4894 return error_mark_node
;
4897 if (expr_const_operands
== NULL
)
4898 expr_const_operands
= &expr_const_operands_dummy
;
4900 *expr
= declspecs
->expr
;
4901 *expr_const_operands
= declspecs
->expr_const_operands
;
4903 if (decl_context
== FUNCDEF
)
4904 funcdef_flag
= true, decl_context
= NORMAL
;
4906 /* Look inside a declarator for the name being declared
4907 and get it as an IDENTIFIER_NODE, for an error message. */
4909 const struct c_declarator
*decl
= declarator
;
4911 first_non_attr_kind
= cdk_attrs
;
4921 funcdef_syntax
= (decl
->kind
== cdk_function
);
4922 decl
= decl
->declarator
;
4923 if (first_non_attr_kind
== cdk_attrs
)
4924 first_non_attr_kind
= decl
->kind
;
4928 decl
= decl
->declarator
;
4935 if (first_non_attr_kind
== cdk_attrs
)
4936 first_non_attr_kind
= decl
->kind
;
4945 gcc_assert (decl_context
== PARM
4946 || decl_context
== TYPENAME
4947 || (decl_context
== FIELD
4948 && declarator
->kind
== cdk_id
));
4949 gcc_assert (!initialized
);
4953 /* A function definition's declarator must have the form of
4954 a function declarator. */
4956 if (funcdef_flag
&& !funcdef_syntax
)
4959 /* If this looks like a function definition, make it one,
4960 even if it occurs where parms are expected.
4961 Then store_parm_decls will reject it and not use it as a parm. */
4962 if (decl_context
== NORMAL
&& !funcdef_flag
&& current_scope
->parm_flag
)
4963 decl_context
= PARM
;
4965 if (declspecs
->deprecated_p
&& deprecated_state
!= DEPRECATED_SUPPRESS
)
4966 warn_deprecated_use (declspecs
->type
, declspecs
->decl_attr
);
4968 if ((decl_context
== NORMAL
|| decl_context
== FIELD
)
4969 && current_scope
== file_scope
4970 && variably_modified_type_p (type
, NULL_TREE
))
4973 error_at (loc
, "variably modified %qE at file scope", name
);
4975 error_at (loc
, "variably modified field at file scope");
4976 type
= integer_type_node
;
4979 size_varies
= C_TYPE_VARIABLE_SIZE (type
) != 0;
4981 /* Diagnose defaulting to "int". */
4983 if (declspecs
->default_int_p
&& !in_system_header
)
4985 /* Issue a warning if this is an ISO C 99 program or if
4986 -Wreturn-type and this is a function, or if -Wimplicit;
4987 prefer the former warning since it is more explicit. */
4988 if ((warn_implicit_int
|| warn_return_type
|| flag_isoc99
)
4990 warn_about_return_type
= 1;
4994 pedwarn_c99 (loc
, flag_isoc99
? 0 : OPT_Wimplicit_int
,
4995 "type defaults to %<int%> in declaration of %qE",
4998 pedwarn_c99 (input_location
, flag_isoc99
? 0 : OPT_Wimplicit_int
,
4999 "type defaults to %<int%> in type name");
5003 /* Adjust the type if a bit-field is being declared,
5004 -funsigned-bitfields applied and the type is not explicitly
5006 if (bitfield
&& !flag_signed_bitfields
&& !declspecs
->explicit_signed_p
5007 && TREE_CODE (type
) == INTEGER_TYPE
)
5008 type
= unsigned_type_for (type
);
5010 /* Figure out the type qualifiers for the declaration. There are
5011 two ways a declaration can become qualified. One is something
5012 like `const int i' where the `const' is explicit. Another is
5013 something like `typedef const int CI; CI i' where the type of the
5014 declaration contains the `const'. A third possibility is that
5015 there is a type qualifier on the element type of a typedefed
5016 array type, in which case we should extract that qualifier so
5017 that c_apply_type_quals_to_decl receives the full list of
5018 qualifiers to work with (C90 is not entirely clear about whether
5019 duplicate qualifiers should be diagnosed in this case, but it
5020 seems most appropriate to do so). */
5021 element_type
= strip_array_types (type
);
5022 constp
= declspecs
->const_p
+ TYPE_READONLY (element_type
);
5023 restrictp
= declspecs
->restrict_p
+ TYPE_RESTRICT (element_type
);
5024 volatilep
= declspecs
->volatile_p
+ TYPE_VOLATILE (element_type
);
5025 as1
= declspecs
->address_space
;
5026 as2
= TYPE_ADDR_SPACE (element_type
);
5027 address_space
= ADDR_SPACE_GENERIC_P (as1
)? as2
: as1
;
5029 if (pedantic
&& !flag_isoc99
)
5032 pedwarn (loc
, OPT_pedantic
, "duplicate %<const%>");
5034 pedwarn (loc
, OPT_pedantic
, "duplicate %<restrict%>");
5036 pedwarn (loc
, OPT_pedantic
, "duplicate %<volatile%>");
5039 if (!ADDR_SPACE_GENERIC_P (as1
) && !ADDR_SPACE_GENERIC_P (as2
) && as1
!= as2
)
5040 error_at (loc
, "conflicting named address spaces (%s vs %s)",
5041 c_addr_space_name (as1
), c_addr_space_name (as2
));
5043 if ((TREE_CODE (type
) == ARRAY_TYPE
5044 || first_non_attr_kind
== cdk_array
)
5045 && TYPE_QUALS (element_type
))
5046 type
= TYPE_MAIN_VARIANT (type
);
5047 type_quals
= ((constp
? TYPE_QUAL_CONST
: 0)
5048 | (restrictp
? TYPE_QUAL_RESTRICT
: 0)
5049 | (volatilep
? TYPE_QUAL_VOLATILE
: 0)
5050 | ENCODE_QUAL_ADDR_SPACE (address_space
));
5052 /* Warn about storage classes that are invalid for certain
5053 kinds of declarations (parameters, typenames, etc.). */
5057 || storage_class
== csc_auto
5058 || storage_class
== csc_register
5059 || storage_class
== csc_typedef
))
5061 if (storage_class
== csc_auto
)
5063 (current_scope
== file_scope
) ? 0 : OPT_pedantic
,
5064 "function definition declared %<auto%>");
5065 if (storage_class
== csc_register
)
5066 error_at (loc
, "function definition declared %<register%>");
5067 if (storage_class
== csc_typedef
)
5068 error_at (loc
, "function definition declared %<typedef%>");
5070 error_at (loc
, "function definition declared %<__thread%>");
5072 if (storage_class
== csc_auto
5073 || storage_class
== csc_register
5074 || storage_class
== csc_typedef
)
5075 storage_class
= csc_none
;
5077 else if (decl_context
!= NORMAL
&& (storage_class
!= csc_none
|| threadp
))
5079 if (decl_context
== PARM
&& storage_class
== csc_register
)
5083 switch (decl_context
)
5087 error_at (loc
, "storage class specified for structure "
5090 error_at (loc
, "storage class specified for structure field");
5094 error_at (loc
, "storage class specified for parameter %qE",
5097 error_at (loc
, "storage class specified for unnamed parameter");
5100 error_at (loc
, "storage class specified for typename");
5103 storage_class
= csc_none
;
5107 else if (storage_class
== csc_extern
5111 /* 'extern' with initialization is invalid if not at file scope. */
5112 if (current_scope
== file_scope
)
5114 /* It is fine to have 'extern const' when compiling at C
5115 and C++ intersection. */
5116 if (!(warn_cxx_compat
&& constp
))
5117 warning_at (loc
, 0, "%qE initialized and declared %<extern%>",
5121 error_at (loc
, "%qE has both %<extern%> and initializer", name
);
5123 else if (current_scope
== file_scope
)
5125 if (storage_class
== csc_auto
)
5126 error_at (loc
, "file-scope declaration of %qE specifies %<auto%>",
5128 if (pedantic
&& storage_class
== csc_register
)
5129 pedwarn (input_location
, OPT_pedantic
,
5130 "file-scope declaration of %qE specifies %<register%>", name
);
5134 if (storage_class
== csc_extern
&& funcdef_flag
)
5135 error_at (loc
, "nested function %qE declared %<extern%>", name
);
5136 else if (threadp
&& storage_class
== csc_none
)
5138 error_at (loc
, "function-scope %qE implicitly auto and declared "
5145 /* Now figure out the structure of the declarator proper.
5146 Descend through it, creating more complex types, until we reach
5147 the declared identifier (or NULL_TREE, in an absolute declarator).
5148 At each stage we maintain an unqualified version of the type
5149 together with any qualifiers that should be applied to it with
5150 c_build_qualified_type; this way, array types including
5151 multidimensional array types are first built up in unqualified
5152 form and then the qualified form is created with
5153 TYPE_MAIN_VARIANT pointing to the unqualified form. */
5155 while (declarator
&& declarator
->kind
!= cdk_id
)
5157 if (type
== error_mark_node
)
5159 declarator
= declarator
->declarator
;
5163 /* Each level of DECLARATOR is either a cdk_array (for ...[..]),
5164 a cdk_pointer (for *...),
5165 a cdk_function (for ...(...)),
5166 a cdk_attrs (for nested attributes),
5167 or a cdk_id (for the name being declared
5168 or the place in an absolute declarator
5169 where the name was omitted).
5170 For the last case, we have just exited the loop.
5172 At this point, TYPE is the type of elements of an array,
5173 or for a function to return, or for a pointer to point to.
5174 After this sequence of ifs, TYPE is the type of the
5175 array or function or pointer, and DECLARATOR has had its
5176 outermost layer removed. */
5178 if (array_ptr_quals
!= TYPE_UNQUALIFIED
5179 || array_ptr_attrs
!= NULL_TREE
5180 || array_parm_static
)
5182 /* Only the innermost declarator (making a parameter be of
5183 array type which is converted to pointer type)
5184 may have static or type qualifiers. */
5185 error_at (loc
, "static or type qualifiers in non-parameter array declarator");
5186 array_ptr_quals
= TYPE_UNQUALIFIED
;
5187 array_ptr_attrs
= NULL_TREE
;
5188 array_parm_static
= 0;
5191 switch (declarator
->kind
)
5195 /* A declarator with embedded attributes. */
5196 tree attrs
= declarator
->u
.attrs
;
5197 const struct c_declarator
*inner_decl
;
5199 declarator
= declarator
->declarator
;
5200 inner_decl
= declarator
;
5201 while (inner_decl
->kind
== cdk_attrs
)
5202 inner_decl
= inner_decl
->declarator
;
5203 if (inner_decl
->kind
== cdk_id
)
5204 attr_flags
|= (int) ATTR_FLAG_DECL_NEXT
;
5205 else if (inner_decl
->kind
== cdk_function
)
5206 attr_flags
|= (int) ATTR_FLAG_FUNCTION_NEXT
;
5207 else if (inner_decl
->kind
== cdk_array
)
5208 attr_flags
|= (int) ATTR_FLAG_ARRAY_NEXT
;
5209 returned_attrs
= decl_attributes (&type
,
5210 chainon (returned_attrs
, attrs
),
5216 tree itype
= NULL_TREE
;
5217 tree size
= declarator
->u
.array
.dimen
;
5218 /* The index is a signed object `sizetype' bits wide. */
5219 tree index_type
= c_common_signed_type (sizetype
);
5221 array_ptr_quals
= declarator
->u
.array
.quals
;
5222 array_ptr_attrs
= declarator
->u
.array
.attrs
;
5223 array_parm_static
= declarator
->u
.array
.static_p
;
5224 array_parm_vla_unspec_p
= declarator
->u
.array
.vla_unspec_p
;
5226 declarator
= declarator
->declarator
;
5228 /* Check for some types that there cannot be arrays of. */
5230 if (VOID_TYPE_P (type
))
5233 error_at (loc
, "declaration of %qE as array of voids", name
);
5235 error_at (loc
, "declaration of type name as array of voids");
5236 type
= error_mark_node
;
5239 if (TREE_CODE (type
) == FUNCTION_TYPE
)
5242 error_at (loc
, "declaration of %qE as array of functions",
5245 error_at (loc
, "declaration of type name as array of "
5247 type
= error_mark_node
;
5250 if (pedantic
&& !in_system_header
&& flexible_array_type_p (type
))
5251 pedwarn (loc
, OPT_pedantic
,
5252 "invalid use of structure with flexible array member");
5254 if (size
== error_mark_node
)
5255 type
= error_mark_node
;
5257 if (type
== error_mark_node
)
5260 /* If size was specified, set ITYPE to a range-type for
5261 that size. Otherwise, ITYPE remains null. finish_decl
5262 may figure it out from an initial value. */
5266 bool size_maybe_const
= true;
5267 bool size_int_const
= (TREE_CODE (size
) == INTEGER_CST
5268 && !TREE_OVERFLOW (size
));
5269 bool this_size_varies
= false;
5271 /* Strip NON_LVALUE_EXPRs since we aren't using as an
5273 STRIP_TYPE_NOPS (size
);
5275 if (!INTEGRAL_TYPE_P (TREE_TYPE (size
)))
5278 error_at (loc
, "size of array %qE has non-integer type",
5282 "size of unnamed array has non-integer type");
5283 size
= integer_one_node
;
5286 size
= c_fully_fold (size
, false, &size_maybe_const
);
5288 if (pedantic
&& size_maybe_const
&& integer_zerop (size
))
5291 pedwarn (loc
, OPT_pedantic
,
5292 "ISO C forbids zero-size array %qE", name
);
5294 pedwarn (loc
, OPT_pedantic
,
5295 "ISO C forbids zero-size array");
5298 if (TREE_CODE (size
) == INTEGER_CST
&& size_maybe_const
)
5300 constant_expression_warning (size
);
5301 if (tree_int_cst_sgn (size
) < 0)
5304 error_at (loc
, "size of array %qE is negative", name
);
5306 error_at (loc
, "size of unnamed array is negative");
5307 size
= integer_one_node
;
5309 /* Handle a size folded to an integer constant but
5310 not an integer constant expression. */
5311 if (!size_int_const
)
5313 /* If this is a file scope declaration of an
5314 ordinary identifier, this is invalid code;
5315 diagnosing it here and not subsequently
5316 treating the type as variable-length avoids
5317 more confusing diagnostics later. */
5318 if ((decl_context
== NORMAL
|| decl_context
== FIELD
)
5319 && current_scope
== file_scope
)
5320 pedwarn (input_location
, 0,
5321 "variably modified %qE at file scope",
5324 this_size_varies
= size_varies
= true;
5325 warn_variable_length_array (name
, size
);
5328 else if ((decl_context
== NORMAL
|| decl_context
== FIELD
)
5329 && current_scope
== file_scope
)
5331 error_at (loc
, "variably modified %qE at file scope", name
);
5332 size
= integer_one_node
;
5336 /* Make sure the array size remains visibly
5337 nonconstant even if it is (eg) a const variable
5338 with known value. */
5339 this_size_varies
= size_varies
= true;
5340 warn_variable_length_array (name
, size
);
5343 if (integer_zerop (size
) && !this_size_varies
)
5345 /* A zero-length array cannot be represented with
5346 an unsigned index type, which is what we'll
5347 get with build_index_type. Create an
5348 open-ended range instead. */
5349 itype
= build_range_type (sizetype
, size
, NULL_TREE
);
5353 /* Arrange for the SAVE_EXPR on the inside of the
5354 MINUS_EXPR, which allows the -1 to get folded
5355 with the +1 that happens when building TYPE_SIZE. */
5357 size
= c_variable_size (size
);
5358 if (this_size_varies
&& TREE_CODE (size
) == INTEGER_CST
)
5359 size
= build2 (COMPOUND_EXPR
, TREE_TYPE (size
),
5360 integer_zero_node
, size
);
5362 /* Compute the maximum valid index, that is, size
5363 - 1. Do the calculation in index_type, so that
5364 if it is a variable the computations will be
5365 done in the proper mode. */
5366 itype
= fold_build2_loc (loc
, MINUS_EXPR
, index_type
,
5367 convert (index_type
, size
),
5368 convert (index_type
,
5371 /* If that overflowed, the array is too big. ???
5372 While a size of INT_MAX+1 technically shouldn't
5373 cause an overflow (because we subtract 1), the
5374 overflow is recorded during the conversion to
5375 index_type, before the subtraction. Handling
5376 this case seems like an unnecessary
5378 if (TREE_CODE (itype
) == INTEGER_CST
5379 && TREE_OVERFLOW (itype
))
5382 error_at (loc
, "size of array %qE is too large",
5385 error_at (loc
, "size of unnamed array is too large");
5386 type
= error_mark_node
;
5390 itype
= build_index_type (itype
);
5392 if (this_size_varies
)
5395 *expr
= build2 (COMPOUND_EXPR
, TREE_TYPE (size
),
5399 *expr_const_operands
&= size_maybe_const
;
5402 else if (decl_context
== FIELD
)
5404 bool flexible_array_member
= false;
5405 if (array_parm_vla_unspec_p
)
5406 /* Field names can in fact have function prototype
5407 scope so [*] is disallowed here through making
5408 the field variably modified, not through being
5409 something other than a declaration with function
5414 const struct c_declarator
*t
= declarator
;
5415 while (t
->kind
== cdk_attrs
)
5417 flexible_array_member
= (t
->kind
== cdk_id
);
5419 if (flexible_array_member
5420 && pedantic
&& !flag_isoc99
&& !in_system_header
)
5421 pedwarn (loc
, OPT_pedantic
,
5422 "ISO C90 does not support flexible array members");
5424 /* ISO C99 Flexible array members are effectively
5425 identical to GCC's zero-length array extension. */
5426 if (flexible_array_member
|| array_parm_vla_unspec_p
)
5427 itype
= build_range_type (sizetype
, size_zero_node
,
5430 else if (decl_context
== PARM
)
5432 if (array_parm_vla_unspec_p
)
5434 itype
= build_range_type (sizetype
, size_zero_node
, NULL_TREE
);
5438 else if (decl_context
== TYPENAME
)
5440 if (array_parm_vla_unspec_p
)
5443 warning (0, "%<[*]%> not in a declaration");
5444 /* We use this to avoid messing up with incomplete
5445 array types of the same type, that would
5446 otherwise be modified below. */
5447 itype
= build_range_type (sizetype
, size_zero_node
,
5453 /* Complain about arrays of incomplete types. */
5454 if (!COMPLETE_TYPE_P (type
))
5456 error_at (loc
, "array type has incomplete element type");
5457 type
= error_mark_node
;
5460 /* When itype is NULL, a shared incomplete array type is
5461 returned for all array of a given type. Elsewhere we
5462 make sure we don't complete that type before copying
5463 it, but here we want to make sure we don't ever
5464 modify the shared type, so we gcc_assert (itype)
5467 addr_space_t as
= DECODE_QUAL_ADDR_SPACE (type_quals
);
5468 if (!ADDR_SPACE_GENERIC_P (as
) && as
!= TYPE_ADDR_SPACE (type
))
5469 type
= build_qualified_type (type
,
5470 ENCODE_QUAL_ADDR_SPACE (as
));
5472 type
= build_array_type (type
, itype
);
5475 if (type
!= error_mark_node
)
5479 /* It is ok to modify type here even if itype is
5480 NULL: if size_varies, we're in a
5481 multi-dimensional array and the inner type has
5482 variable size, so the enclosing shared array type
5484 if (size
&& TREE_CODE (size
) == INTEGER_CST
)
5486 = build_distinct_type_copy (TYPE_MAIN_VARIANT (type
));
5487 C_TYPE_VARIABLE_SIZE (type
) = 1;
5490 /* The GCC extension for zero-length arrays differs from
5491 ISO flexible array members in that sizeof yields
5493 if (size
&& integer_zerop (size
))
5496 type
= build_distinct_type_copy (TYPE_MAIN_VARIANT (type
));
5497 TYPE_SIZE (type
) = bitsize_zero_node
;
5498 TYPE_SIZE_UNIT (type
) = size_zero_node
;
5499 SET_TYPE_STRUCTURAL_EQUALITY (type
);
5501 if (array_parm_vla_unspec_p
)
5504 /* The type is complete. C99 6.7.5.2p4 */
5505 type
= build_distinct_type_copy (TYPE_MAIN_VARIANT (type
));
5506 TYPE_SIZE (type
) = bitsize_zero_node
;
5507 TYPE_SIZE_UNIT (type
) = size_zero_node
;
5508 SET_TYPE_STRUCTURAL_EQUALITY (type
);
5512 if (decl_context
!= PARM
5513 && (array_ptr_quals
!= TYPE_UNQUALIFIED
5514 || array_ptr_attrs
!= NULL_TREE
5515 || array_parm_static
))
5517 error_at (loc
, "static or type qualifiers in non-parameter array declarator");
5518 array_ptr_quals
= TYPE_UNQUALIFIED
;
5519 array_ptr_attrs
= NULL_TREE
;
5520 array_parm_static
= 0;
5526 /* Say it's a definition only for the declarator closest
5527 to the identifier, apart possibly from some
5529 bool really_funcdef
= false;
5533 const struct c_declarator
*t
= declarator
->declarator
;
5534 while (t
->kind
== cdk_attrs
)
5536 really_funcdef
= (t
->kind
== cdk_id
);
5539 /* Declaring a function type. Make sure we have a valid
5540 type for the function to return. */
5541 if (type
== error_mark_node
)
5544 size_varies
= false;
5546 /* Warn about some types functions can't return. */
5547 if (TREE_CODE (type
) == FUNCTION_TYPE
)
5550 error_at (loc
, "%qE declared as function returning a "
5553 error_at (loc
, "type name declared as function "
5554 "returning a function");
5555 type
= integer_type_node
;
5557 if (TREE_CODE (type
) == ARRAY_TYPE
)
5560 error_at (loc
, "%qE declared as function returning an array",
5563 error_at (loc
, "type name declared as function returning "
5565 type
= integer_type_node
;
5567 errmsg
= targetm
.invalid_return_type (type
);
5571 type
= integer_type_node
;
5574 /* Construct the function type and go to the next
5575 inner layer of declarator. */
5576 arg_info
= declarator
->u
.arg_info
;
5577 arg_types
= grokparms (arg_info
, really_funcdef
);
5579 put_pending_sizes (arg_info
->pending_sizes
);
5581 /* Type qualifiers before the return type of the function
5582 qualify the return type, not the function type. */
5585 /* Type qualifiers on a function return type are
5586 normally permitted by the standard but have no
5587 effect, so give a warning at -Wreturn-type.
5588 Qualifiers on a void return type are banned on
5589 function definitions in ISO C; GCC used to used
5590 them for noreturn functions. */
5591 if (VOID_TYPE_P (type
) && really_funcdef
)
5593 "function definition has qualified void return type");
5595 warning_at (loc
, OPT_Wignored_qualifiers
,
5596 "type qualifiers ignored on function return type");
5598 type
= c_build_qualified_type (type
, type_quals
);
5600 type_quals
= TYPE_UNQUALIFIED
;
5602 type
= build_function_type (type
, arg_types
);
5603 declarator
= declarator
->declarator
;
5605 /* Set the TYPE_CONTEXTs for each tagged type which is local to
5606 the formal parameter list of this FUNCTION_TYPE to point to
5607 the FUNCTION_TYPE node itself. */
5612 FOR_EACH_VEC_ELT_REVERSE (c_arg_tag
, arg_info
->tags
, ix
, tag
)
5613 TYPE_CONTEXT (tag
->type
) = type
;
5619 /* Merge any constancy or volatility into the target type
5622 if (pedantic
&& TREE_CODE (type
) == FUNCTION_TYPE
5624 pedwarn (loc
, OPT_pedantic
,
5625 "ISO C forbids qualified function types");
5627 type
= c_build_qualified_type (type
, type_quals
);
5628 size_varies
= false;
5630 /* When the pointed-to type involves components of variable size,
5631 care must be taken to ensure that the size evaluation code is
5632 emitted early enough to dominate all the possible later uses
5633 and late enough for the variables on which it depends to have
5636 This is expected to happen automatically when the pointed-to
5637 type has a name/declaration of it's own, but special attention
5638 is required if the type is anonymous.
5640 We handle the NORMAL and FIELD contexts here by attaching an
5641 artificial TYPE_DECL to such pointed-to type. This forces the
5642 sizes evaluation at a safe point and ensures it is not deferred
5643 until e.g. within a deeper conditional context.
5645 We expect nothing to be needed here for PARM or TYPENAME.
5646 Pushing a TYPE_DECL at this point for TYPENAME would actually
5647 be incorrect, as we might be in the middle of an expression
5648 with side effects on the pointed-to type size "arguments" prior
5649 to the pointer declaration point and the fake TYPE_DECL in the
5650 enclosing context would force the size evaluation prior to the
5653 if (!TYPE_NAME (type
)
5654 && (decl_context
== NORMAL
|| decl_context
== FIELD
)
5655 && variably_modified_type_p (type
, NULL_TREE
))
5657 tree decl
= build_decl (loc
, TYPE_DECL
, NULL_TREE
, type
);
5658 DECL_ARTIFICIAL (decl
) = 1;
5660 finish_decl (decl
, loc
, NULL_TREE
, NULL_TREE
, NULL_TREE
);
5661 TYPE_NAME (type
) = decl
;
5664 type
= build_pointer_type (type
);
5666 /* Process type qualifiers (such as const or volatile)
5667 that were given inside the `*'. */
5668 type_quals
= declarator
->u
.pointer_quals
;
5670 declarator
= declarator
->declarator
;
5677 *decl_attrs
= chainon (returned_attrs
, *decl_attrs
);
5679 /* Now TYPE has the actual type, apart from any qualifiers in
5682 /* Warn about address space used for things other than static memory or
5684 address_space
= DECODE_QUAL_ADDR_SPACE (type_quals
);
5685 if (!ADDR_SPACE_GENERIC_P (address_space
))
5687 if (decl_context
== NORMAL
)
5689 switch (storage_class
)
5692 error ("%qs combined with %<auto%> qualifier for %qE",
5693 c_addr_space_name (address_space
), name
);
5696 error ("%qs combined with %<register%> qualifier for %qE",
5697 c_addr_space_name (address_space
), name
);
5700 if (current_function_scope
)
5702 error ("%qs specified for auto variable %qE",
5703 c_addr_space_name (address_space
), name
);
5715 else if (decl_context
== PARM
&& TREE_CODE (type
) != ARRAY_TYPE
)
5718 error ("%qs specified for parameter %qE",
5719 c_addr_space_name (address_space
), name
);
5721 error ("%qs specified for unnamed parameter",
5722 c_addr_space_name (address_space
));
5724 else if (decl_context
== FIELD
)
5727 error ("%qs specified for structure field %qE",
5728 c_addr_space_name (address_space
), name
);
5730 error ("%qs specified for structure field",
5731 c_addr_space_name (address_space
));
5735 /* Check the type and width of a bit-field. */
5737 check_bitfield_type_and_width (&type
, width
, name
);
5739 /* Did array size calculations overflow? */
5741 if (TREE_CODE (type
) == ARRAY_TYPE
5742 && COMPLETE_TYPE_P (type
)
5743 && TREE_CODE (TYPE_SIZE_UNIT (type
)) == INTEGER_CST
5744 && TREE_OVERFLOW (TYPE_SIZE_UNIT (type
)))
5747 error_at (loc
, "size of array %qE is too large", name
);
5749 error_at (loc
, "size of unnamed array is too large");
5750 /* If we proceed with the array type as it is, we'll eventually
5751 crash in tree_low_cst(). */
5752 type
= error_mark_node
;
5755 /* If this is declaring a typedef name, return a TYPE_DECL. */
5757 if (storage_class
== csc_typedef
)
5760 if (pedantic
&& TREE_CODE (type
) == FUNCTION_TYPE
5762 pedwarn (loc
, OPT_pedantic
,
5763 "ISO C forbids qualified function types");
5765 type
= c_build_qualified_type (type
, type_quals
);
5766 decl
= build_decl (declarator
->id_loc
,
5767 TYPE_DECL
, declarator
->u
.id
, type
);
5768 if (declspecs
->explicit_signed_p
)
5769 C_TYPEDEF_EXPLICITLY_SIGNED (decl
) = 1;
5770 if (declspecs
->inline_p
)
5771 pedwarn (loc
, 0,"typedef %q+D declared %<inline%>", decl
);
5773 if (warn_cxx_compat
&& declarator
->u
.id
!= NULL_TREE
)
5775 struct c_binding
*b
= I_TAG_BINDING (declarator
->u
.id
);
5778 && b
->decl
!= NULL_TREE
5779 && (B_IN_CURRENT_SCOPE (b
)
5780 || (current_scope
== file_scope
&& B_IN_EXTERNAL_SCOPE (b
)))
5781 && TYPE_MAIN_VARIANT (b
->decl
) != TYPE_MAIN_VARIANT (type
))
5783 warning_at (declarator
->id_loc
, OPT_Wc___compat
,
5784 ("using %qD as both a typedef and a tag is "
5787 if (b
->locus
!= UNKNOWN_LOCATION
)
5788 inform (b
->locus
, "originally defined here");
5795 /* If this is a type name (such as, in a cast or sizeof),
5796 compute the type and return it now. */
5798 if (decl_context
== TYPENAME
)
5800 /* Note that the grammar rejects storage classes in typenames
5802 gcc_assert (storage_class
== csc_none
&& !threadp
5803 && !declspecs
->inline_p
);
5804 if (pedantic
&& TREE_CODE (type
) == FUNCTION_TYPE
5806 pedwarn (loc
, OPT_pedantic
,
5807 "ISO C forbids const or volatile function types");
5809 type
= c_build_qualified_type (type
, type_quals
);
5813 if (pedantic
&& decl_context
== FIELD
5814 && variably_modified_type_p (type
, NULL_TREE
))
5817 pedwarn (loc
, OPT_pedantic
, "a member of a structure or union cannot "
5818 "have a variably modified type");
5821 /* Aside from typedefs and type names (handle above),
5822 `void' at top level (not within pointer)
5823 is allowed only in public variables.
5824 We don't complain about parms either, but that is because
5825 a better error message can be made later. */
5827 if (VOID_TYPE_P (type
) && decl_context
!= PARM
5828 && !((decl_context
!= FIELD
&& TREE_CODE (type
) != FUNCTION_TYPE
)
5829 && (storage_class
== csc_extern
5830 || (current_scope
== file_scope
5831 && !(storage_class
== csc_static
5832 || storage_class
== csc_register
)))))
5834 error_at (loc
, "variable or field %qE declared void", name
);
5835 type
= integer_type_node
;
5838 /* Now create the decl, which may be a VAR_DECL, a PARM_DECL
5839 or a FUNCTION_DECL, depending on DECL_CONTEXT and TYPE. */
5844 if (decl_context
== PARM
)
5848 /* A parameter declared as an array of T is really a pointer to T.
5849 One declared as a function is really a pointer to a function. */
5851 if (TREE_CODE (type
) == ARRAY_TYPE
)
5853 /* Transfer const-ness of array into that of type pointed to. */
5854 type
= TREE_TYPE (type
);
5856 type
= c_build_qualified_type (type
, type_quals
);
5857 type
= build_pointer_type (type
);
5858 type_quals
= array_ptr_quals
;
5860 type
= c_build_qualified_type (type
, type_quals
);
5862 /* We don't yet implement attributes in this context. */
5863 if (array_ptr_attrs
!= NULL_TREE
)
5864 warning_at (loc
, OPT_Wattributes
,
5865 "attributes in parameter array declarator ignored");
5867 size_varies
= false;
5869 else if (TREE_CODE (type
) == FUNCTION_TYPE
)
5872 pedwarn (loc
, OPT_pedantic
,
5873 "ISO C forbids qualified function types");
5875 type
= c_build_qualified_type (type
, type_quals
);
5876 type
= build_pointer_type (type
);
5877 type_quals
= TYPE_UNQUALIFIED
;
5879 else if (type_quals
)
5880 type
= c_build_qualified_type (type
, type_quals
);
5882 decl
= build_decl (declarator
->id_loc
,
5883 PARM_DECL
, declarator
->u
.id
, type
);
5885 C_DECL_VARIABLE_SIZE (decl
) = 1;
5887 /* Compute the type actually passed in the parmlist,
5888 for the case where there is no prototype.
5889 (For example, shorts and chars are passed as ints.)
5890 When there is a prototype, this is overridden later. */
5892 if (type
== error_mark_node
)
5893 promoted_type
= type
;
5895 promoted_type
= c_type_promotes_to (type
);
5897 DECL_ARG_TYPE (decl
) = promoted_type
;
5898 if (declspecs
->inline_p
)
5899 pedwarn (loc
, 0, "parameter %q+D declared %<inline%>", decl
);
5901 else if (decl_context
== FIELD
)
5903 /* Note that the grammar rejects storage classes in typenames
5905 gcc_assert (storage_class
== csc_none
&& !threadp
5906 && !declspecs
->inline_p
);
5908 /* Structure field. It may not be a function. */
5910 if (TREE_CODE (type
) == FUNCTION_TYPE
)
5912 error_at (loc
, "field %qE declared as a function", name
);
5913 type
= build_pointer_type (type
);
5915 else if (TREE_CODE (type
) != ERROR_MARK
5916 && !COMPLETE_OR_UNBOUND_ARRAY_TYPE_P (type
))
5919 error_at (loc
, "field %qE has incomplete type", name
);
5921 error_at (loc
, "unnamed field has incomplete type");
5922 type
= error_mark_node
;
5924 type
= c_build_qualified_type (type
, type_quals
);
5925 decl
= build_decl (declarator
->id_loc
,
5926 FIELD_DECL
, declarator
->u
.id
, type
);
5927 DECL_NONADDRESSABLE_P (decl
) = bitfield
;
5928 if (bitfield
&& !declarator
->u
.id
)
5929 TREE_NO_WARNING (decl
) = 1;
5932 C_DECL_VARIABLE_SIZE (decl
) = 1;
5934 else if (TREE_CODE (type
) == FUNCTION_TYPE
)
5936 if (storage_class
== csc_register
|| threadp
)
5938 error_at (loc
, "invalid storage class for function %qE", name
);
5940 else if (current_scope
!= file_scope
)
5942 /* Function declaration not at file scope. Storage
5943 classes other than `extern' are not allowed, C99
5944 6.7.1p5, and `extern' makes no difference. However,
5945 GCC allows 'auto', perhaps with 'inline', to support
5946 nested functions. */
5947 if (storage_class
== csc_auto
)
5948 pedwarn (loc
, OPT_pedantic
,
5949 "invalid storage class for function %qE", name
);
5950 else if (storage_class
== csc_static
)
5952 error_at (loc
, "invalid storage class for function %qE", name
);
5954 storage_class
= declspecs
->storage_class
= csc_none
;
5960 decl
= build_decl (declarator
->id_loc
,
5961 FUNCTION_DECL
, declarator
->u
.id
, type
);
5962 decl
= build_decl_attribute_variant (decl
, decl_attr
);
5964 if (pedantic
&& type_quals
&& !DECL_IN_SYSTEM_HEADER (decl
))
5965 pedwarn (loc
, OPT_pedantic
,
5966 "ISO C forbids qualified function types");
5968 /* Every function declaration is an external reference
5969 (DECL_EXTERNAL) except for those which are not at file
5970 scope and are explicitly declared "auto". This is
5971 forbidden by standard C (C99 6.7.1p5) and is interpreted by
5972 GCC to signify a forward declaration of a nested function. */
5973 if (storage_class
== csc_auto
&& current_scope
!= file_scope
)
5974 DECL_EXTERNAL (decl
) = 0;
5975 /* In C99, a function which is declared 'inline' with 'extern'
5976 is not an external reference (which is confusing). It
5977 means that the later definition of the function must be output
5978 in this file, C99 6.7.4p6. In GNU C89, a function declared
5979 'extern inline' is an external reference. */
5980 else if (declspecs
->inline_p
&& storage_class
!= csc_static
)
5981 DECL_EXTERNAL (decl
) = ((storage_class
== csc_extern
)
5982 == flag_gnu89_inline
);
5984 DECL_EXTERNAL (decl
) = !initialized
;
5986 /* Record absence of global scope for `static' or `auto'. */
5988 = !(storage_class
== csc_static
|| storage_class
== csc_auto
);
5990 /* For a function definition, record the argument information
5991 block where store_parm_decls will look for it. */
5993 current_function_arg_info
= arg_info
;
5995 if (declspecs
->default_int_p
)
5996 C_FUNCTION_IMPLICIT_INT (decl
) = 1;
5998 /* Record presence of `inline', if it is reasonable. */
5999 if (flag_hosted
&& MAIN_NAME_P (declarator
->u
.id
))
6001 if (declspecs
->inline_p
)
6002 pedwarn (loc
, 0, "cannot inline function %<main%>");
6004 else if (declspecs
->inline_p
)
6005 /* Record that the function is declared `inline'. */
6006 DECL_DECLARED_INLINE_P (decl
) = 1;
6010 /* It's a variable. */
6011 /* An uninitialized decl with `extern' is a reference. */
6012 int extern_ref
= !initialized
&& storage_class
== csc_extern
;
6014 type
= c_build_qualified_type (type
, type_quals
);
6016 /* C99 6.2.2p7: It is invalid (compile-time undefined
6017 behavior) to create an 'extern' declaration for a
6018 variable if there is a global declaration that is
6019 'static' and the global declaration is not visible.
6020 (If the static declaration _is_ currently visible,
6021 the 'extern' declaration is taken to refer to that decl.) */
6022 if (extern_ref
&& current_scope
!= file_scope
)
6024 tree global_decl
= identifier_global_value (declarator
->u
.id
);
6025 tree visible_decl
= lookup_name (declarator
->u
.id
);
6028 && global_decl
!= visible_decl
6029 && TREE_CODE (global_decl
) == VAR_DECL
6030 && !TREE_PUBLIC (global_decl
))
6031 error_at (loc
, "variable previously declared %<static%> "
6032 "redeclared %<extern%>");
6035 decl
= build_decl (declarator
->id_loc
,
6036 VAR_DECL
, declarator
->u
.id
, type
);
6038 C_DECL_VARIABLE_SIZE (decl
) = 1;
6040 if (declspecs
->inline_p
)
6041 pedwarn (loc
, 0, "variable %q+D declared %<inline%>", decl
);
6043 /* At file scope, an initialized extern declaration may follow
6044 a static declaration. In that case, DECL_EXTERNAL will be
6045 reset later in start_decl. */
6046 DECL_EXTERNAL (decl
) = (storage_class
== csc_extern
);
6048 /* At file scope, the presence of a `static' or `register' storage
6049 class specifier, or the absence of all storage class specifiers
6050 makes this declaration a definition (perhaps tentative). Also,
6051 the absence of `static' makes it public. */
6052 if (current_scope
== file_scope
)
6054 TREE_PUBLIC (decl
) = storage_class
!= csc_static
;
6055 TREE_STATIC (decl
) = !extern_ref
;
6057 /* Not at file scope, only `static' makes a static definition. */
6060 TREE_STATIC (decl
) = (storage_class
== csc_static
);
6061 TREE_PUBLIC (decl
) = extern_ref
;
6065 DECL_TLS_MODEL (decl
) = decl_default_tls_model (decl
);
6068 if ((storage_class
== csc_extern
6069 || (storage_class
== csc_none
6070 && TREE_CODE (type
) == FUNCTION_TYPE
6072 && variably_modified_type_p (type
, NULL_TREE
))
6075 if (TREE_CODE (type
) == FUNCTION_TYPE
)
6076 error_at (loc
, "non-nested function with variably modified type");
6078 error_at (loc
, "object with variably modified type must have "
6082 /* Record `register' declaration for warnings on &
6083 and in case doing stupid register allocation. */
6085 if (storage_class
== csc_register
)
6087 C_DECL_REGISTER (decl
) = 1;
6088 DECL_REGISTER (decl
) = 1;
6091 /* Record constancy and volatility. */
6092 c_apply_type_quals_to_decl (type_quals
, decl
);
6094 /* If a type has volatile components, it should be stored in memory.
6095 Otherwise, the fact that those components are volatile
6096 will be ignored, and would even crash the compiler.
6097 Of course, this only makes sense on VAR,PARM, and RESULT decl's. */
6098 if (C_TYPE_FIELDS_VOLATILE (TREE_TYPE (decl
))
6099 && (TREE_CODE (decl
) == VAR_DECL
|| TREE_CODE (decl
) == PARM_DECL
6100 || TREE_CODE (decl
) == RESULT_DECL
))
6102 /* It is not an error for a structure with volatile fields to
6103 be declared register, but reset DECL_REGISTER since it
6104 cannot actually go in a register. */
6105 int was_reg
= C_DECL_REGISTER (decl
);
6106 C_DECL_REGISTER (decl
) = 0;
6107 DECL_REGISTER (decl
) = 0;
6108 c_mark_addressable (decl
);
6109 C_DECL_REGISTER (decl
) = was_reg
;
6112 /* This is the earliest point at which we might know the assembler
6113 name of a variable. Thus, if it's known before this, die horribly. */
6114 gcc_assert (!DECL_ASSEMBLER_NAME_SET_P (decl
));
6117 && TREE_CODE (decl
) == VAR_DECL
6118 && TREE_PUBLIC (decl
)
6119 && TREE_STATIC (decl
)
6120 && (TREE_CODE (TREE_TYPE (decl
)) == RECORD_TYPE
6121 || TREE_CODE (TREE_TYPE (decl
)) == UNION_TYPE
6122 || TREE_CODE (TREE_TYPE (decl
)) == ENUMERAL_TYPE
)
6123 && TYPE_NAME (TREE_TYPE (decl
)) == NULL_TREE
)
6124 warning_at (DECL_SOURCE_LOCATION (decl
), OPT_Wc___compat
,
6125 ("non-local variable %qD with anonymous type is "
6126 "questionable in C++"),
6133 /* Decode the parameter-list info for a function type or function definition.
6134 The argument is the value returned by `get_parm_info' (or made in c-parse.c
6135 if there is an identifier list instead of a parameter decl list).
6136 These two functions are separate because when a function returns
6137 or receives functions then each is called multiple times but the order
6138 of calls is different. The last call to `grokparms' is always the one
6139 that contains the formal parameter names of a function definition.
6141 Return a list of arg types to use in the FUNCTION_TYPE for this function.
6143 FUNCDEF_FLAG is true for a function definition, false for
6144 a mere declaration. A nonempty identifier-list gets an error message
6145 when FUNCDEF_FLAG is false. */
6148 grokparms (struct c_arg_info
*arg_info
, bool funcdef_flag
)
6150 tree arg_types
= arg_info
->types
;
6152 if (funcdef_flag
&& arg_info
->had_vla_unspec
)
6154 /* A function definition isn't function prototype scope C99 6.2.1p4. */
6156 error ("%<[*]%> not allowed in other than function prototype scope");
6159 if (arg_types
== 0 && !funcdef_flag
&& !in_system_header
)
6160 warning (OPT_Wstrict_prototypes
,
6161 "function declaration isn%'t a prototype");
6163 if (arg_types
== error_mark_node
)
6164 return 0; /* don't set TYPE_ARG_TYPES in this case */
6166 else if (arg_types
&& TREE_CODE (TREE_VALUE (arg_types
)) == IDENTIFIER_NODE
)
6170 pedwarn (input_location
, 0, "parameter names (without types) in function declaration");
6171 arg_info
->parms
= NULL_TREE
;
6174 arg_info
->parms
= arg_info
->types
;
6176 arg_info
->types
= 0;
6181 tree parm
, type
, typelt
;
6182 unsigned int parmno
;
6185 /* If there is a parameter of incomplete type in a definition,
6186 this is an error. In a declaration this is valid, and a
6187 struct or union type may be completed later, before any calls
6188 or definition of the function. In the case where the tag was
6189 first declared within the parameter list, a warning has
6190 already been given. If a parameter has void type, then
6191 however the function cannot be defined or called, so
6194 for (parm
= arg_info
->parms
, typelt
= arg_types
, parmno
= 1;
6196 parm
= DECL_CHAIN (parm
), typelt
= TREE_CHAIN (typelt
), parmno
++)
6198 type
= TREE_VALUE (typelt
);
6199 if (type
== error_mark_node
)
6202 if (!COMPLETE_TYPE_P (type
))
6206 if (DECL_NAME (parm
))
6207 error_at (input_location
,
6208 "parameter %u (%q+D) has incomplete type",
6211 error_at (DECL_SOURCE_LOCATION (parm
),
6212 "parameter %u has incomplete type",
6215 TREE_VALUE (typelt
) = error_mark_node
;
6216 TREE_TYPE (parm
) = error_mark_node
;
6217 arg_types
= NULL_TREE
;
6219 else if (VOID_TYPE_P (type
))
6221 if (DECL_NAME (parm
))
6222 warning_at (input_location
, 0,
6223 "parameter %u (%q+D) has void type",
6226 warning_at (DECL_SOURCE_LOCATION (parm
), 0,
6227 "parameter %u has void type",
6232 errmsg
= targetm
.invalid_parameter_type (type
);
6236 TREE_VALUE (typelt
) = error_mark_node
;
6237 TREE_TYPE (parm
) = error_mark_node
;
6238 arg_types
= NULL_TREE
;
6241 if (DECL_NAME (parm
) && TREE_USED (parm
))
6242 warn_if_shadowing (parm
);
6248 /* Allocate and initialize a c_arg_info structure from the parser's
6252 build_arg_info (void)
6254 struct c_arg_info
*ret
= XOBNEW (&parser_obstack
, struct c_arg_info
);
6255 ret
->parms
= NULL_TREE
;
6257 ret
->types
= NULL_TREE
;
6258 ret
->others
= NULL_TREE
;
6259 ret
->pending_sizes
= NULL
;
6260 ret
->had_vla_unspec
= 0;
6264 /* Take apart the current scope and return a c_arg_info structure with
6265 info on a parameter list just parsed.
6267 This structure is later fed to 'grokparms' and 'store_parm_decls'.
6269 ELLIPSIS being true means the argument list ended in '...' so don't
6270 append a sentinel (void_list_node) to the end of the type-list. */
6273 get_parm_info (bool ellipsis
)
6275 struct c_binding
*b
= current_scope
->bindings
;
6276 struct c_arg_info
*arg_info
= build_arg_info ();
6279 VEC(c_arg_tag
,gc
) *tags
= NULL
;
6283 static bool explained_incomplete_types
= false;
6284 bool gave_void_only_once_err
= false;
6286 arg_info
->had_vla_unspec
= current_scope
->had_vla_unspec
;
6288 /* The bindings in this scope must not get put into a block.
6289 We will take care of deleting the binding nodes. */
6290 current_scope
->bindings
= 0;
6292 /* This function is only called if there was *something* on the
6296 /* A parameter list consisting solely of 'void' indicates that the
6297 function takes no arguments. But if the 'void' is qualified
6298 (by 'const' or 'volatile'), or has a storage class specifier
6299 ('register'), then the behavior is undefined; issue an error.
6300 Typedefs for 'void' are OK (see DR#157). */
6301 if (b
->prev
== 0 /* one binding */
6302 && TREE_CODE (b
->decl
) == PARM_DECL
/* which is a parameter */
6303 && !DECL_NAME (b
->decl
) /* anonymous */
6304 && VOID_TYPE_P (TREE_TYPE (b
->decl
))) /* of void type */
6306 if (TREE_THIS_VOLATILE (b
->decl
)
6307 || TREE_READONLY (b
->decl
)
6308 || C_DECL_REGISTER (b
->decl
))
6309 error ("%<void%> as only parameter may not be qualified");
6311 /* There cannot be an ellipsis. */
6313 error ("%<void%> must be the only parameter");
6315 arg_info
->types
= void_list_node
;
6320 types
= void_list_node
;
6322 /* Break up the bindings list into parms, tags, types, and others;
6323 apply sanity checks; purge the name-to-decl bindings. */
6326 tree decl
= b
->decl
;
6327 tree type
= TREE_TYPE (decl
);
6329 const char *keyword
;
6331 switch (TREE_CODE (decl
))
6336 gcc_assert (I_SYMBOL_BINDING (b
->id
) == b
);
6337 I_SYMBOL_BINDING (b
->id
) = b
->shadowed
;
6340 /* Check for forward decls that never got their actual decl. */
6341 if (TREE_ASM_WRITTEN (decl
))
6342 error ("parameter %q+D has just a forward declaration", decl
);
6343 /* Check for (..., void, ...) and issue an error. */
6344 else if (VOID_TYPE_P (type
) && !DECL_NAME (decl
))
6346 if (!gave_void_only_once_err
)
6348 error ("%<void%> must be the only parameter");
6349 gave_void_only_once_err
= true;
6354 /* Valid parameter, add it to the list. */
6355 DECL_CHAIN (decl
) = parms
;
6358 /* Since there is a prototype, args are passed in their
6359 declared types. The back end may override this later. */
6360 DECL_ARG_TYPE (decl
) = type
;
6361 types
= tree_cons (0, type
, types
);
6365 case ENUMERAL_TYPE
: keyword
= "enum"; goto tag
;
6366 case UNION_TYPE
: keyword
= "union"; goto tag
;
6367 case RECORD_TYPE
: keyword
= "struct"; goto tag
;
6369 /* Types may not have tag-names, in which case the type
6370 appears in the bindings list with b->id NULL. */
6373 gcc_assert (I_TAG_BINDING (b
->id
) == b
);
6374 I_TAG_BINDING (b
->id
) = b
->shadowed
;
6377 /* Warn about any struct, union or enum tags defined in a
6378 parameter list. The scope of such types is limited to
6379 the parameter list, which is rarely if ever desirable
6380 (it's impossible to call such a function with type-
6381 correct arguments). An anonymous union parm type is
6382 meaningful as a GNU extension, so don't warn for that. */
6383 if (TREE_CODE (decl
) != UNION_TYPE
|| b
->id
!= 0)
6386 /* The %s will be one of 'struct', 'union', or 'enum'. */
6387 warning (0, "%<%s %E%> declared inside parameter list",
6390 /* The %s will be one of 'struct', 'union', or 'enum'. */
6391 warning (0, "anonymous %s declared inside parameter list",
6394 if (!explained_incomplete_types
)
6396 warning (0, "its scope is only this definition or declaration,"
6397 " which is probably not what you want");
6398 explained_incomplete_types
= true;
6402 tag
= VEC_safe_push (c_arg_tag
, gc
, tags
, NULL
);
6410 /* CONST_DECLs appear here when we have an embedded enum,
6411 and TYPE_DECLs appear here when we have an embedded struct
6412 or union. No warnings for this - we already warned about the
6413 type itself. FUNCTION_DECLs appear when there is an implicit
6414 function declaration in the parameter list. */
6416 /* When we reinsert this decl in the function body, we need
6417 to reconstruct whether it was marked as nested. */
6418 gcc_assert (TREE_CODE (decl
) == FUNCTION_DECL
6421 DECL_CHAIN (decl
) = others
;
6426 /* error_mark_node appears here when we have an undeclared
6427 variable. Just throw it away. */
6430 gcc_assert (I_SYMBOL_BINDING (b
->id
) == b
);
6431 I_SYMBOL_BINDING (b
->id
) = b
->shadowed
;
6435 /* Other things that might be encountered. */
6442 b
= free_binding_and_advance (b
);
6445 arg_info
->parms
= parms
;
6446 arg_info
->tags
= tags
;
6447 arg_info
->types
= types
;
6448 arg_info
->others
= others
;
6449 arg_info
->pending_sizes
= get_pending_sizes ();
6453 /* Get the struct, enum or union (CODE says which) with tag NAME.
6454 Define the tag as a forward-reference with location LOC if it is
6455 not defined. Return a c_typespec structure for the type
6459 parser_xref_tag (location_t loc
, enum tree_code code
, tree name
)
6461 struct c_typespec ret
;
6465 ret
.expr
= NULL_TREE
;
6466 ret
.expr_const_operands
= true;
6468 /* If a cross reference is requested, look up the type
6469 already defined for this tag and return it. */
6471 ref
= lookup_tag (code
, name
, 0, &refloc
);
6472 /* If this is the right type of tag, return what we found.
6473 (This reference will be shadowed by shadow_tag later if appropriate.)
6474 If this is the wrong type of tag, do not return it. If it was the
6475 wrong type in the same scope, we will have had an error
6476 message already; if in a different scope and declaring
6477 a name, pending_xref_error will give an error message; but if in a
6478 different scope and not declaring a name, this tag should
6479 shadow the previous declaration of a different type of tag, and
6480 this would not work properly if we return the reference found.
6481 (For example, with "struct foo" in an outer scope, "union foo;"
6482 must shadow that tag with a new one of union type.) */
6483 ret
.kind
= (ref
? ctsk_tagref
: ctsk_tagfirstref
);
6484 if (ref
&& TREE_CODE (ref
) == code
)
6486 if (C_TYPE_DEFINED_IN_STRUCT (ref
)
6487 && loc
!= UNKNOWN_LOCATION
6493 warning_at (loc
, OPT_Wc___compat
,
6494 ("enum type defined in struct or union "
6495 "is not visible in C++"));
6496 inform (refloc
, "enum type defined here");
6499 warning_at (loc
, OPT_Wc___compat
,
6500 ("struct defined in struct or union "
6501 "is not visible in C++"));
6502 inform (refloc
, "struct defined here");
6505 warning_at (loc
, OPT_Wc___compat
,
6506 ("union defined in struct or union "
6507 "is not visible in C++"));
6508 inform (refloc
, "union defined here");
6519 /* If no such tag is yet defined, create a forward-reference node
6520 and record it as the "definition".
6521 When a real declaration of this type is found,
6522 the forward-reference will be altered into a real type. */
6524 ref
= make_node (code
);
6525 if (code
== ENUMERAL_TYPE
)
6527 /* Give the type a default layout like unsigned int
6528 to avoid crashing if it does not get defined. */
6529 SET_TYPE_MODE (ref
, TYPE_MODE (unsigned_type_node
));
6530 TYPE_ALIGN (ref
) = TYPE_ALIGN (unsigned_type_node
);
6531 TYPE_USER_ALIGN (ref
) = 0;
6532 TYPE_UNSIGNED (ref
) = 1;
6533 TYPE_PRECISION (ref
) = TYPE_PRECISION (unsigned_type_node
);
6534 TYPE_MIN_VALUE (ref
) = TYPE_MIN_VALUE (unsigned_type_node
);
6535 TYPE_MAX_VALUE (ref
) = TYPE_MAX_VALUE (unsigned_type_node
);
6538 pushtag (loc
, name
, ref
);
6544 /* Get the struct, enum or union (CODE says which) with tag NAME.
6545 Define the tag as a forward-reference if it is not defined.
6546 Return a tree for the type. */
6549 xref_tag (enum tree_code code
, tree name
)
6551 return parser_xref_tag (input_location
, code
, name
).spec
;
6554 /* Make sure that the tag NAME is defined *in the current scope*
6555 at least as a forward reference.
6556 LOC is the location of the struct's definition.
6557 CODE says which kind of tag NAME ought to be.
6559 This stores the current value of the file static STRUCT_PARSE_INFO
6560 in *ENCLOSING_STRUCT_PARSE_INFO, and points STRUCT_PARSE_INFO at a
6561 new c_struct_parse_info structure. The old value of
6562 STRUCT_PARSE_INFO is restored in finish_struct. */
6565 start_struct (location_t loc
, enum tree_code code
, tree name
,
6566 struct c_struct_parse_info
**enclosing_struct_parse_info
)
6568 /* If there is already a tag defined at this scope
6569 (as a forward reference), just return it. */
6571 tree ref
= NULL_TREE
;
6572 location_t refloc
= UNKNOWN_LOCATION
;
6574 if (name
!= NULL_TREE
)
6575 ref
= lookup_tag (code
, name
, 1, &refloc
);
6576 if (ref
&& TREE_CODE (ref
) == code
)
6578 if (TYPE_SIZE (ref
))
6580 if (code
== UNION_TYPE
)
6581 error_at (loc
, "redefinition of %<union %E%>", name
);
6583 error_at (loc
, "redefinition of %<struct %E%>", name
);
6584 if (refloc
!= UNKNOWN_LOCATION
)
6585 inform (refloc
, "originally defined here");
6586 /* Don't create structures using a name already in use. */
6589 else if (C_TYPE_BEING_DEFINED (ref
))
6591 if (code
== UNION_TYPE
)
6592 error_at (loc
, "nested redefinition of %<union %E%>", name
);
6594 error_at (loc
, "nested redefinition of %<struct %E%>", name
);
6595 /* Don't bother to report "originally defined here" for a
6596 nested redefinition; the original definition should be
6598 /* Don't create structures that contain themselves. */
6603 /* Otherwise create a forward-reference just so the tag is in scope. */
6605 if (ref
== NULL_TREE
|| TREE_CODE (ref
) != code
)
6607 ref
= make_node (code
);
6608 pushtag (loc
, name
, ref
);
6611 C_TYPE_BEING_DEFINED (ref
) = 1;
6612 TYPE_PACKED (ref
) = flag_pack_struct
;
6614 *enclosing_struct_parse_info
= struct_parse_info
;
6615 struct_parse_info
= XNEW (struct c_struct_parse_info
);
6616 struct_parse_info
->struct_types
= VEC_alloc (tree
, heap
, 0);
6617 struct_parse_info
->fields
= VEC_alloc (c_binding_ptr
, heap
, 0);
6618 struct_parse_info
->typedefs_seen
= VEC_alloc (tree
, heap
, 0);
6620 /* FIXME: This will issue a warning for a use of a type defined
6621 within a statement expr used within sizeof, et. al. This is not
6622 terribly serious as C++ doesn't permit statement exprs within
6624 if (warn_cxx_compat
&& (in_sizeof
|| in_typeof
|| in_alignof
))
6625 warning_at (loc
, OPT_Wc___compat
,
6626 "defining type in %qs expression is invalid in C++",
6629 : (in_typeof
? "typeof" : "alignof")));
6634 /* Process the specs, declarator and width (NULL if omitted)
6635 of a structure component, returning a FIELD_DECL node.
6636 WIDTH is non-NULL for bit-fields only, and is an INTEGER_CST node.
6637 DECL_ATTRS is as for grokdeclarator.
6639 LOC is the location of the structure component.
6641 This is done during the parsing of the struct declaration.
6642 The FIELD_DECL nodes are chained together and the lot of them
6643 are ultimately passed to `build_struct' to make the RECORD_TYPE node. */
6646 grokfield (location_t loc
,
6647 struct c_declarator
*declarator
, struct c_declspecs
*declspecs
,
6648 tree width
, tree
*decl_attrs
)
6652 if (declarator
->kind
== cdk_id
&& declarator
->u
.id
== NULL_TREE
6653 && width
== NULL_TREE
)
6655 /* This is an unnamed decl.
6657 If we have something of the form "union { list } ;" then this
6658 is the anonymous union extension. Similarly for struct.
6660 If this is something of the form "struct foo;", then
6661 If MS or Plan 9 extensions are enabled, this is handled as
6662 an anonymous struct.
6663 Otherwise this is a forward declaration of a structure tag.
6665 If this is something of the form "foo;" and foo is a TYPE_DECL, then
6666 If foo names a structure or union without a tag, then this
6667 is an anonymous struct (this is permitted by C1X).
6668 If MS or Plan 9 extensions are enabled and foo names a
6669 structure, then again this is an anonymous struct.
6670 Otherwise this is an error.
6672 Oh what a horrid tangled web we weave. I wonder if MS consciously
6673 took this from Plan 9 or if it was an accident of implementation
6674 that took root before someone noticed the bug... */
6676 tree type
= declspecs
->type
;
6677 bool type_ok
= (TREE_CODE (type
) == RECORD_TYPE
6678 || TREE_CODE (type
) == UNION_TYPE
);
6682 && (flag_ms_extensions
6683 || flag_plan9_extensions
6684 || !declspecs
->typedef_p
))
6686 if (flag_ms_extensions
|| flag_plan9_extensions
)
6688 else if (TYPE_NAME (type
) == NULL
)
6695 pedwarn (loc
, 0, "declaration does not declare anything");
6701 pedwarn (loc
, OPT_pedantic
,
6702 "ISO C99 doesn%'t support unnamed structs/unions");
6704 pedwarn (loc
, OPT_pedantic
,
6705 "ISO C90 doesn%'t support unnamed structs/unions");
6709 value
= grokdeclarator (declarator
, declspecs
, FIELD
, false,
6710 width
? &width
: NULL
, decl_attrs
, NULL
, NULL
,
6713 finish_decl (value
, loc
, NULL_TREE
, NULL_TREE
, NULL_TREE
);
6714 DECL_INITIAL (value
) = width
;
6716 if (warn_cxx_compat
&& DECL_NAME (value
) != NULL_TREE
)
6718 /* If we currently have a binding for this field, set the
6719 in_struct field in the binding, so that we warn about lookups
6721 struct c_binding
*b
= I_SYMBOL_BINDING (DECL_NAME (value
));
6724 /* If the in_struct field is not yet set, push it on a list
6725 to be cleared when this struct is finished. */
6728 VEC_safe_push (c_binding_ptr
, heap
,
6729 struct_parse_info
->fields
, b
);
6738 /* Subroutine of detect_field_duplicates: return whether X and Y,
6739 which are both fields in the same struct, have duplicate field
6743 is_duplicate_field (tree x
, tree y
)
6745 if (DECL_NAME (x
) != NULL_TREE
&& DECL_NAME (x
) == DECL_NAME (y
))
6748 /* When using -fplan9-extensions, an anonymous field whose name is a
6749 typedef can duplicate a field name. */
6750 if (flag_plan9_extensions
6751 && (DECL_NAME (x
) == NULL_TREE
|| DECL_NAME (y
) == NULL_TREE
))
6753 tree xt
, xn
, yt
, yn
;
6756 if (DECL_NAME (x
) != NULL_TREE
)
6758 else if ((TREE_CODE (xt
) == RECORD_TYPE
|| TREE_CODE (xt
) == UNION_TYPE
)
6759 && TYPE_NAME (xt
) != NULL_TREE
6760 && TREE_CODE (TYPE_NAME (xt
)) == TYPE_DECL
)
6761 xn
= DECL_NAME (TYPE_NAME (xt
));
6766 if (DECL_NAME (y
) != NULL_TREE
)
6768 else if ((TREE_CODE (yt
) == RECORD_TYPE
|| TREE_CODE (yt
) == UNION_TYPE
)
6769 && TYPE_NAME (yt
) != NULL_TREE
6770 && TREE_CODE (TYPE_NAME (yt
)) == TYPE_DECL
)
6771 yn
= DECL_NAME (TYPE_NAME (yt
));
6775 if (xn
!= NULL_TREE
&& xn
== yn
)
6782 /* Subroutine of detect_field_duplicates: add the fields of FIELDLIST
6783 to HTAB, giving errors for any duplicates. */
6786 detect_field_duplicates_hash (tree fieldlist
, htab_t htab
)
6791 for (x
= fieldlist
; x
; x
= DECL_CHAIN (x
))
6792 if ((y
= DECL_NAME (x
)) != 0)
6794 slot
= htab_find_slot (htab
, y
, INSERT
);
6797 error ("duplicate member %q+D", x
);
6798 DECL_NAME (x
) = NULL_TREE
;
6802 else if (TREE_CODE (TREE_TYPE (x
)) == RECORD_TYPE
6803 || TREE_CODE (TREE_TYPE (x
)) == UNION_TYPE
)
6805 detect_field_duplicates_hash (TYPE_FIELDS (TREE_TYPE (x
)), htab
);
6807 /* When using -fplan9-extensions, an anonymous field whose
6808 name is a typedef can duplicate a field name. */
6809 if (flag_plan9_extensions
6810 && TYPE_NAME (TREE_TYPE (x
)) != NULL_TREE
6811 && TREE_CODE (TYPE_NAME (TREE_TYPE (x
))) == TYPE_DECL
)
6813 tree xn
= DECL_NAME (TYPE_NAME (TREE_TYPE (x
)));
6814 slot
= htab_find_slot (htab
, xn
, INSERT
);
6816 error ("duplicate member %q+D", TYPE_NAME (TREE_TYPE (x
)));
6822 /* Generate an error for any duplicate field names in FIELDLIST. Munge
6823 the list such that this does not present a problem later. */
6826 detect_field_duplicates (tree fieldlist
)
6831 /* If the struct is the list of instance variables of an Objective-C
6832 class, then we need to add all the instance variables of
6833 superclasses before checking for duplicates (since you can't have
6834 an instance variable in a subclass with the same name as an
6835 instance variable in a superclass). objc_get_interface_ivars()
6836 leaves fieldlist unchanged if we are not in this case, so in that
6837 case nothing changes compared to C.
6839 if (c_dialect_objc ())
6840 fieldlist
= objc_get_interface_ivars (fieldlist
);
6842 /* First, see if there are more than "a few" fields.
6843 This is trivially true if there are zero or one fields. */
6844 if (!fieldlist
|| !DECL_CHAIN (fieldlist
))
6849 if (DECL_NAME (x
) == NULL_TREE
6850 && (TREE_CODE (TREE_TYPE (x
)) == RECORD_TYPE
6851 || TREE_CODE (TREE_TYPE (x
)) == UNION_TYPE
))
6854 } while (timeout
> 0 && x
);
6856 /* If there were "few" fields and no anonymous structures or unions,
6857 avoid the overhead of allocating a hash table. Instead just do
6858 the nested traversal thing. */
6861 for (x
= DECL_CHAIN (fieldlist
); x
; x
= DECL_CHAIN (x
))
6862 /* When using -fplan9-extensions, we can have duplicates
6863 between typedef names and fields. */
6865 || (flag_plan9_extensions
6866 && DECL_NAME (x
) == NULL_TREE
6867 && (TREE_CODE (TREE_TYPE (x
)) == RECORD_TYPE
6868 || TREE_CODE (TREE_TYPE (x
)) == UNION_TYPE
)
6869 && TYPE_NAME (TREE_TYPE (x
)) != NULL_TREE
6870 && TREE_CODE (TYPE_NAME (TREE_TYPE (x
))) == TYPE_DECL
))
6872 for (y
= fieldlist
; y
!= x
; y
= TREE_CHAIN (y
))
6873 if (is_duplicate_field (y
, x
))
6875 error ("duplicate member %q+D", x
);
6876 DECL_NAME (x
) = NULL_TREE
;
6882 htab_t htab
= htab_create (37, htab_hash_pointer
, htab_eq_pointer
, NULL
);
6884 detect_field_duplicates_hash (fieldlist
, htab
);
6889 /* Finish up struct info used by -Wc++-compat. */
6892 warn_cxx_compat_finish_struct (tree fieldlist
)
6896 struct c_binding
*b
;
6898 /* Set the C_TYPE_DEFINED_IN_STRUCT flag for each type defined in
6899 the current struct. We do this now at the end of the struct
6900 because the flag is used to issue visibility warnings, and we
6901 only want to issue those warnings if the type is referenced
6902 outside of the struct declaration. */
6903 FOR_EACH_VEC_ELT (tree
, struct_parse_info
->struct_types
, ix
, x
)
6904 C_TYPE_DEFINED_IN_STRUCT (x
) = 1;
6906 /* The TYPEDEFS_SEEN field of STRUCT_PARSE_INFO is a list of
6907 typedefs used when declaring fields in this struct. If the name
6908 of any of the fields is also a typedef name then the struct would
6909 not parse in C++, because the C++ lookup rules say that the
6910 typedef name would be looked up in the context of the struct, and
6911 would thus be the field rather than the typedef. */
6912 if (!VEC_empty (tree
, struct_parse_info
->typedefs_seen
)
6913 && fieldlist
!= NULL_TREE
)
6915 /* Use a pointer_set using the name of the typedef. We can use
6916 a pointer_set because identifiers are interned. */
6917 struct pointer_set_t
*tset
= pointer_set_create ();
6919 FOR_EACH_VEC_ELT (tree
, struct_parse_info
->typedefs_seen
, ix
, x
)
6920 pointer_set_insert (tset
, DECL_NAME (x
));
6922 for (x
= fieldlist
; x
!= NULL_TREE
; x
= DECL_CHAIN (x
))
6924 if (DECL_NAME (x
) != NULL_TREE
6925 && pointer_set_contains (tset
, DECL_NAME (x
)))
6927 warning_at (DECL_SOURCE_LOCATION (x
), OPT_Wc___compat
,
6928 ("using %qD as both field and typedef name is "
6931 /* FIXME: It would be nice to report the location where
6932 the typedef name is used. */
6936 pointer_set_destroy (tset
);
6939 /* For each field which has a binding and which was not defined in
6940 an enclosing struct, clear the in_struct field. */
6941 FOR_EACH_VEC_ELT (c_binding_ptr
, struct_parse_info
->fields
, ix
, b
)
6945 /* Fill in the fields of a RECORD_TYPE or UNION_TYPE node, T.
6946 LOC is the location of the RECORD_TYPE or UNION_TYPE's definition.
6947 FIELDLIST is a chain of FIELD_DECL nodes for the fields.
6948 ATTRIBUTES are attributes to be applied to the structure.
6950 ENCLOSING_STRUCT_PARSE_INFO is the value of STRUCT_PARSE_INFO when
6951 the struct was started. */
6954 finish_struct (location_t loc
, tree t
, tree fieldlist
, tree attributes
,
6955 struct c_struct_parse_info
*enclosing_struct_parse_info
)
6958 bool toplevel
= file_scope
== current_scope
;
6959 int saw_named_field
;
6961 /* If this type was previously laid out as a forward reference,
6962 make sure we lay it out again. */
6966 decl_attributes (&t
, attributes
, (int) ATTR_FLAG_TYPE_IN_PLACE
);
6970 for (x
= fieldlist
; x
; x
= DECL_CHAIN (x
))
6972 if (DECL_NAME (x
) != 0)
6975 && (TREE_CODE (TREE_TYPE (x
)) == RECORD_TYPE
6976 || TREE_CODE (TREE_TYPE (x
)) == UNION_TYPE
))
6982 if (TREE_CODE (t
) == UNION_TYPE
)
6985 pedwarn (loc
, OPT_pedantic
, "union has no named members");
6987 pedwarn (loc
, OPT_pedantic
, "union has no members");
6992 pedwarn (loc
, OPT_pedantic
, "struct has no named members");
6994 pedwarn (loc
, OPT_pedantic
, "struct has no members");
6999 /* Install struct as DECL_CONTEXT of each field decl.
7000 Also process specified field sizes, found in the DECL_INITIAL,
7001 storing 0 there after the type has been changed to precision equal
7002 to its width, rather than the precision of the specified standard
7003 type. (Correct layout requires the original type to have been preserved
7006 saw_named_field
= 0;
7007 for (x
= fieldlist
; x
; x
= DECL_CHAIN (x
))
7009 if (TREE_TYPE (x
) == error_mark_node
)
7012 DECL_CONTEXT (x
) = t
;
7014 /* If any field is const, the structure type is pseudo-const. */
7015 if (TREE_READONLY (x
))
7016 C_TYPE_FIELDS_READONLY (t
) = 1;
7019 /* A field that is pseudo-const makes the structure likewise. */
7020 tree t1
= strip_array_types (TREE_TYPE (x
));
7021 if ((TREE_CODE (t1
) == RECORD_TYPE
|| TREE_CODE (t1
) == UNION_TYPE
)
7022 && C_TYPE_FIELDS_READONLY (t1
))
7023 C_TYPE_FIELDS_READONLY (t
) = 1;
7026 /* Any field that is volatile means variables of this type must be
7027 treated in some ways as volatile. */
7028 if (TREE_THIS_VOLATILE (x
))
7029 C_TYPE_FIELDS_VOLATILE (t
) = 1;
7031 /* Any field of nominal variable size implies structure is too. */
7032 if (C_DECL_VARIABLE_SIZE (x
))
7033 C_TYPE_VARIABLE_SIZE (t
) = 1;
7035 if (DECL_INITIAL (x
))
7037 unsigned HOST_WIDE_INT width
= tree_low_cst (DECL_INITIAL (x
), 1);
7038 DECL_SIZE (x
) = bitsize_int (width
);
7039 DECL_BIT_FIELD (x
) = 1;
7040 SET_DECL_C_BIT_FIELD (x
);
7044 && (DECL_BIT_FIELD (x
)
7045 || TYPE_ALIGN (TREE_TYPE (x
)) > BITS_PER_UNIT
))
7046 DECL_PACKED (x
) = 1;
7048 /* Detect flexible array member in an invalid context. */
7049 if (TREE_CODE (TREE_TYPE (x
)) == ARRAY_TYPE
7050 && TYPE_SIZE (TREE_TYPE (x
)) == NULL_TREE
7051 && TYPE_DOMAIN (TREE_TYPE (x
)) != NULL_TREE
7052 && TYPE_MAX_VALUE (TYPE_DOMAIN (TREE_TYPE (x
))) == NULL_TREE
)
7054 if (TREE_CODE (t
) == UNION_TYPE
)
7056 error_at (DECL_SOURCE_LOCATION (x
),
7057 "flexible array member in union");
7058 TREE_TYPE (x
) = error_mark_node
;
7060 else if (DECL_CHAIN (x
) != NULL_TREE
)
7062 error_at (DECL_SOURCE_LOCATION (x
),
7063 "flexible array member not at end of struct");
7064 TREE_TYPE (x
) = error_mark_node
;
7066 else if (!saw_named_field
)
7068 error_at (DECL_SOURCE_LOCATION (x
),
7069 "flexible array member in otherwise empty struct");
7070 TREE_TYPE (x
) = error_mark_node
;
7074 if (pedantic
&& TREE_CODE (t
) == RECORD_TYPE
7075 && flexible_array_type_p (TREE_TYPE (x
)))
7076 pedwarn (DECL_SOURCE_LOCATION (x
), OPT_pedantic
,
7077 "invalid use of structure with flexible array member");
7080 || TREE_CODE (TREE_TYPE (x
)) == RECORD_TYPE
7081 || TREE_CODE (TREE_TYPE (x
)) == UNION_TYPE
)
7082 saw_named_field
= 1;
7085 detect_field_duplicates (fieldlist
);
7087 /* Now we have the nearly final fieldlist. Record it,
7088 then lay out the structure or union (including the fields). */
7090 TYPE_FIELDS (t
) = fieldlist
;
7094 /* Give bit-fields their proper types. */
7096 tree
*fieldlistp
= &fieldlist
;
7098 if (TREE_CODE (*fieldlistp
) == FIELD_DECL
&& DECL_INITIAL (*fieldlistp
)
7099 && TREE_TYPE (*fieldlistp
) != error_mark_node
)
7101 unsigned HOST_WIDE_INT width
7102 = tree_low_cst (DECL_INITIAL (*fieldlistp
), 1);
7103 tree type
= TREE_TYPE (*fieldlistp
);
7104 if (width
!= TYPE_PRECISION (type
))
7106 TREE_TYPE (*fieldlistp
)
7107 = c_build_bitfield_integer_type (width
, TYPE_UNSIGNED (type
));
7108 DECL_MODE (*fieldlistp
) = TYPE_MODE (TREE_TYPE (*fieldlistp
));
7110 DECL_INITIAL (*fieldlistp
) = 0;
7113 fieldlistp
= &DECL_CHAIN (*fieldlistp
);
7116 /* Now we have the truly final field list.
7117 Store it in this type and in the variants. */
7119 TYPE_FIELDS (t
) = fieldlist
;
7121 /* If there are lots of fields, sort so we can look through them fast.
7122 We arbitrarily consider 16 or more elts to be "a lot". */
7127 for (x
= fieldlist
; x
; x
= DECL_CHAIN (x
))
7129 if (len
> 15 || DECL_NAME (x
) == NULL
)
7137 struct lang_type
*space
;
7138 struct sorted_fields_type
*space2
;
7140 len
+= list_length (x
);
7142 /* Use the same allocation policy here that make_node uses, to
7143 ensure that this lives as long as the rest of the struct decl.
7144 All decls in an inline function need to be saved. */
7146 space
= ggc_alloc_cleared_lang_type (sizeof (struct lang_type
));
7147 space2
= ggc_alloc_sorted_fields_type
7148 (sizeof (struct sorted_fields_type
) + len
* sizeof (tree
));
7152 field_array
= &space2
->elts
[0];
7153 for (x
= fieldlist
; x
; x
= DECL_CHAIN (x
))
7155 field_array
[len
++] = x
;
7157 /* If there is anonymous struct or union, break out of the loop. */
7158 if (DECL_NAME (x
) == NULL
)
7161 /* Found no anonymous struct/union. Add the TYPE_LANG_SPECIFIC. */
7164 TYPE_LANG_SPECIFIC (t
) = space
;
7165 TYPE_LANG_SPECIFIC (t
)->s
->len
= len
;
7166 field_array
= TYPE_LANG_SPECIFIC (t
)->s
->elts
;
7167 qsort (field_array
, len
, sizeof (tree
), field_decl_cmp
);
7172 for (x
= TYPE_MAIN_VARIANT (t
); x
; x
= TYPE_NEXT_VARIANT (x
))
7174 TYPE_FIELDS (x
) = TYPE_FIELDS (t
);
7175 TYPE_LANG_SPECIFIC (x
) = TYPE_LANG_SPECIFIC (t
);
7176 C_TYPE_FIELDS_READONLY (x
) = C_TYPE_FIELDS_READONLY (t
);
7177 C_TYPE_FIELDS_VOLATILE (x
) = C_TYPE_FIELDS_VOLATILE (t
);
7178 C_TYPE_VARIABLE_SIZE (x
) = C_TYPE_VARIABLE_SIZE (t
);
7181 /* If this was supposed to be a transparent union, but we can't
7182 make it one, warn and turn off the flag. */
7183 if (TREE_CODE (t
) == UNION_TYPE
7184 && TYPE_TRANSPARENT_AGGR (t
)
7185 && (!TYPE_FIELDS (t
) || TYPE_MODE (t
) != DECL_MODE (TYPE_FIELDS (t
))))
7187 TYPE_TRANSPARENT_AGGR (t
) = 0;
7188 warning_at (loc
, 0, "union cannot be made transparent");
7191 /* If this structure or union completes the type of any previous
7192 variable declaration, lay it out and output its rtl. */
7193 for (x
= C_TYPE_INCOMPLETE_VARS (TYPE_MAIN_VARIANT (t
));
7197 tree decl
= TREE_VALUE (x
);
7198 if (TREE_CODE (TREE_TYPE (decl
)) == ARRAY_TYPE
)
7199 layout_array_type (TREE_TYPE (decl
));
7200 if (TREE_CODE (decl
) != TYPE_DECL
)
7202 layout_decl (decl
, 0);
7203 if (c_dialect_objc ())
7204 objc_check_decl (decl
);
7205 rest_of_decl_compilation (decl
, toplevel
, 0);
7210 C_TYPE_INCOMPLETE_VARS (TYPE_MAIN_VARIANT (t
)) = 0;
7212 /* Update type location to the one of the definition, instead of e.g.
7213 a forward declaration. */
7214 if (TYPE_STUB_DECL (t
))
7215 DECL_SOURCE_LOCATION (TYPE_STUB_DECL (t
)) = loc
;
7217 /* Finish debugging output for this type. */
7218 rest_of_type_compilation (t
, toplevel
);
7220 /* If we're inside a function proper, i.e. not file-scope and not still
7221 parsing parameters, then arrange for the size of a variable sized type
7223 if (cur_stmt_list
&& variably_modified_type_p (t
, NULL_TREE
))
7224 add_stmt (build_stmt (loc
,
7225 DECL_EXPR
, build_decl (loc
, TYPE_DECL
, NULL
, t
)));
7227 if (warn_cxx_compat
)
7228 warn_cxx_compat_finish_struct (fieldlist
);
7230 VEC_free (tree
, heap
, struct_parse_info
->struct_types
);
7231 VEC_free (c_binding_ptr
, heap
, struct_parse_info
->fields
);
7232 VEC_free (tree
, heap
, struct_parse_info
->typedefs_seen
);
7233 XDELETE (struct_parse_info
);
7235 struct_parse_info
= enclosing_struct_parse_info
;
7237 /* If this struct is defined inside a struct, add it to
7240 && struct_parse_info
!= NULL
7241 && !in_sizeof
&& !in_typeof
&& !in_alignof
)
7242 VEC_safe_push (tree
, heap
, struct_parse_info
->struct_types
, t
);
7247 /* Lay out the type T, and its element type, and so on. */
7250 layout_array_type (tree t
)
7252 if (TREE_CODE (TREE_TYPE (t
)) == ARRAY_TYPE
)
7253 layout_array_type (TREE_TYPE (t
));
7257 /* Begin compiling the definition of an enumeration type.
7258 NAME is its name (or null if anonymous).
7259 LOC is the enum's location.
7260 Returns the type object, as yet incomplete.
7261 Also records info about it so that build_enumerator
7262 may be used to declare the individual values as they are read. */
7265 start_enum (location_t loc
, struct c_enum_contents
*the_enum
, tree name
)
7267 tree enumtype
= NULL_TREE
;
7268 location_t enumloc
= UNKNOWN_LOCATION
;
7270 /* If this is the real definition for a previous forward reference,
7271 fill in the contents in the same object that used to be the
7272 forward reference. */
7274 if (name
!= NULL_TREE
)
7275 enumtype
= lookup_tag (ENUMERAL_TYPE
, name
, 1, &enumloc
);
7277 if (enumtype
== 0 || TREE_CODE (enumtype
) != ENUMERAL_TYPE
)
7279 enumtype
= make_node (ENUMERAL_TYPE
);
7280 pushtag (loc
, name
, enumtype
);
7283 if (C_TYPE_BEING_DEFINED (enumtype
))
7284 error_at (loc
, "nested redefinition of %<enum %E%>", name
);
7286 C_TYPE_BEING_DEFINED (enumtype
) = 1;
7288 if (TYPE_VALUES (enumtype
) != 0)
7290 /* This enum is a named one that has been declared already. */
7291 error_at (loc
, "redeclaration of %<enum %E%>", name
);
7292 if (enumloc
!= UNKNOWN_LOCATION
)
7293 inform (enumloc
, "originally defined here");
7295 /* Completely replace its old definition.
7296 The old enumerators remain defined, however. */
7297 TYPE_VALUES (enumtype
) = 0;
7300 the_enum
->enum_next_value
= integer_zero_node
;
7301 the_enum
->enum_overflow
= 0;
7303 if (flag_short_enums
)
7304 TYPE_PACKED (enumtype
) = 1;
7306 /* FIXME: This will issue a warning for a use of a type defined
7307 within sizeof in a statement expr. This is not terribly serious
7308 as C++ doesn't permit statement exprs within sizeof anyhow. */
7309 if (warn_cxx_compat
&& (in_sizeof
|| in_typeof
|| in_alignof
))
7310 warning_at (loc
, OPT_Wc___compat
,
7311 "defining type in %qs expression is invalid in C++",
7314 : (in_typeof
? "typeof" : "alignof")));
7319 /* After processing and defining all the values of an enumeration type,
7320 install their decls in the enumeration type and finish it off.
7321 ENUMTYPE is the type object, VALUES a list of decl-value pairs,
7322 and ATTRIBUTES are the specified attributes.
7323 Returns ENUMTYPE. */
7326 finish_enum (tree enumtype
, tree values
, tree attributes
)
7329 tree minnode
= 0, maxnode
= 0;
7330 int precision
, unsign
;
7331 bool toplevel
= (file_scope
== current_scope
);
7332 struct lang_type
*lt
;
7334 decl_attributes (&enumtype
, attributes
, (int) ATTR_FLAG_TYPE_IN_PLACE
);
7336 /* Calculate the maximum value of any enumerator in this type. */
7338 if (values
== error_mark_node
)
7339 minnode
= maxnode
= integer_zero_node
;
7342 minnode
= maxnode
= TREE_VALUE (values
);
7343 for (pair
= TREE_CHAIN (values
); pair
; pair
= TREE_CHAIN (pair
))
7345 tree value
= TREE_VALUE (pair
);
7346 if (tree_int_cst_lt (maxnode
, value
))
7348 if (tree_int_cst_lt (value
, minnode
))
7353 /* Construct the final type of this enumeration. It is the same
7354 as one of the integral types - the narrowest one that fits, except
7355 that normally we only go as narrow as int - and signed iff any of
7356 the values are negative. */
7357 unsign
= (tree_int_cst_sgn (minnode
) >= 0);
7358 precision
= MAX (tree_int_cst_min_precision (minnode
, unsign
),
7359 tree_int_cst_min_precision (maxnode
, unsign
));
7361 if (TYPE_PACKED (enumtype
) || precision
> TYPE_PRECISION (integer_type_node
))
7363 tem
= c_common_type_for_size (precision
, unsign
);
7366 warning (0, "enumeration values exceed range of largest integer");
7367 tem
= long_long_integer_type_node
;
7371 tem
= unsign
? unsigned_type_node
: integer_type_node
;
7373 TYPE_MIN_VALUE (enumtype
) = TYPE_MIN_VALUE (tem
);
7374 TYPE_MAX_VALUE (enumtype
) = TYPE_MAX_VALUE (tem
);
7375 TYPE_UNSIGNED (enumtype
) = TYPE_UNSIGNED (tem
);
7376 TYPE_SIZE (enumtype
) = 0;
7378 /* If the precision of the type was specific with an attribute and it
7379 was too small, give an error. Otherwise, use it. */
7380 if (TYPE_PRECISION (enumtype
))
7382 if (precision
> TYPE_PRECISION (enumtype
))
7383 error ("specified mode too small for enumeral values");
7386 TYPE_PRECISION (enumtype
) = TYPE_PRECISION (tem
);
7388 layout_type (enumtype
);
7390 if (values
!= error_mark_node
)
7392 /* Change the type of the enumerators to be the enum type. We
7393 need to do this irrespective of the size of the enum, for
7394 proper type checking. Replace the DECL_INITIALs of the
7395 enumerators, and the value slots of the list, with copies
7396 that have the enum type; they cannot be modified in place
7397 because they may be shared (e.g. integer_zero_node) Finally,
7398 change the purpose slots to point to the names of the decls. */
7399 for (pair
= values
; pair
; pair
= TREE_CHAIN (pair
))
7401 tree enu
= TREE_PURPOSE (pair
);
7402 tree ini
= DECL_INITIAL (enu
);
7404 TREE_TYPE (enu
) = enumtype
;
7406 /* The ISO C Standard mandates enumerators to have type int,
7407 even though the underlying type of an enum type is
7408 unspecified. However, GCC allows enumerators of any
7409 integer type as an extensions. build_enumerator()
7410 converts any enumerators that fit in an int to type int,
7411 to avoid promotions to unsigned types when comparing
7412 integers with enumerators that fit in the int range.
7413 When -pedantic is given, build_enumerator() would have
7414 already warned about those that don't fit. Here we
7415 convert the rest to the enumerator type. */
7416 if (TREE_TYPE (ini
) != integer_type_node
)
7417 ini
= convert (enumtype
, ini
);
7419 DECL_INITIAL (enu
) = ini
;
7420 TREE_PURPOSE (pair
) = DECL_NAME (enu
);
7421 TREE_VALUE (pair
) = ini
;
7424 TYPE_VALUES (enumtype
) = values
;
7427 /* Record the min/max values so that we can warn about bit-field
7428 enumerations that are too small for the values. */
7429 lt
= ggc_alloc_cleared_lang_type (sizeof (struct lang_type
));
7430 lt
->enum_min
= minnode
;
7431 lt
->enum_max
= maxnode
;
7432 TYPE_LANG_SPECIFIC (enumtype
) = lt
;
7434 /* Fix up all variant types of this enum type. */
7435 for (tem
= TYPE_MAIN_VARIANT (enumtype
); tem
; tem
= TYPE_NEXT_VARIANT (tem
))
7437 if (tem
== enumtype
)
7439 TYPE_VALUES (tem
) = TYPE_VALUES (enumtype
);
7440 TYPE_MIN_VALUE (tem
) = TYPE_MIN_VALUE (enumtype
);
7441 TYPE_MAX_VALUE (tem
) = TYPE_MAX_VALUE (enumtype
);
7442 TYPE_SIZE (tem
) = TYPE_SIZE (enumtype
);
7443 TYPE_SIZE_UNIT (tem
) = TYPE_SIZE_UNIT (enumtype
);
7444 SET_TYPE_MODE (tem
, TYPE_MODE (enumtype
));
7445 TYPE_PRECISION (tem
) = TYPE_PRECISION (enumtype
);
7446 TYPE_ALIGN (tem
) = TYPE_ALIGN (enumtype
);
7447 TYPE_USER_ALIGN (tem
) = TYPE_USER_ALIGN (enumtype
);
7448 TYPE_UNSIGNED (tem
) = TYPE_UNSIGNED (enumtype
);
7449 TYPE_LANG_SPECIFIC (tem
) = TYPE_LANG_SPECIFIC (enumtype
);
7452 /* Finish debugging output for this type. */
7453 rest_of_type_compilation (enumtype
, toplevel
);
7455 /* If this enum is defined inside a struct, add it to
7458 && struct_parse_info
!= NULL
7459 && !in_sizeof
&& !in_typeof
&& !in_alignof
)
7460 VEC_safe_push (tree
, heap
, struct_parse_info
->struct_types
, enumtype
);
7465 /* Build and install a CONST_DECL for one value of the
7466 current enumeration type (one that was begun with start_enum).
7467 DECL_LOC is the location of the enumerator.
7468 LOC is the location of the '=' operator if any, DECL_LOC otherwise.
7469 Return a tree-list containing the CONST_DECL and its value.
7470 Assignment of sequential values by default is handled here. */
7473 build_enumerator (location_t decl_loc
, location_t loc
,
7474 struct c_enum_contents
*the_enum
, tree name
, tree value
)
7478 /* Validate and default VALUE. */
7482 /* Don't issue more errors for error_mark_node (i.e. an
7483 undeclared identifier) - just ignore the value expression. */
7484 if (value
== error_mark_node
)
7486 else if (!INTEGRAL_TYPE_P (TREE_TYPE (value
)))
7488 error_at (loc
, "enumerator value for %qE is not an integer constant",
7494 if (TREE_CODE (value
) != INTEGER_CST
)
7496 value
= c_fully_fold (value
, false, NULL
);
7497 if (TREE_CODE (value
) == INTEGER_CST
)
7498 pedwarn (loc
, OPT_pedantic
,
7499 "enumerator value for %qE is not an integer "
7500 "constant expression", name
);
7502 if (TREE_CODE (value
) != INTEGER_CST
)
7504 error ("enumerator value for %qE is not an integer constant",
7510 value
= default_conversion (value
);
7511 constant_expression_warning (value
);
7516 /* Default based on previous value. */
7517 /* It should no longer be possible to have NON_LVALUE_EXPR
7521 value
= the_enum
->enum_next_value
;
7522 if (the_enum
->enum_overflow
)
7523 error_at (loc
, "overflow in enumeration values");
7525 /* Even though the underlying type of an enum is unspecified, the
7526 type of enumeration constants is explicitly defined as int
7527 (6.4.4.3/2 in the C99 Standard). GCC allows any integer type as
7529 else if (!int_fits_type_p (value
, integer_type_node
))
7530 pedwarn (loc
, OPT_pedantic
,
7531 "ISO C restricts enumerator values to range of %<int%>");
7533 /* The ISO C Standard mandates enumerators to have type int, even
7534 though the underlying type of an enum type is unspecified.
7535 However, GCC allows enumerators of any integer type as an
7536 extensions. Here we convert any enumerators that fit in an int
7537 to type int, to avoid promotions to unsigned types when comparing
7538 integers with enumerators that fit in the int range. When
7539 -pedantic is given, we would have already warned about those that
7540 don't fit. We have to do this here rather than in finish_enum
7541 because this value may be used to define more enumerators. */
7542 if (int_fits_type_p (value
, integer_type_node
))
7543 value
= convert (integer_type_node
, value
);
7545 /* Set basis for default for next value. */
7546 the_enum
->enum_next_value
7547 = build_binary_op (EXPR_LOC_OR_HERE (value
),
7548 PLUS_EXPR
, value
, integer_one_node
, 0);
7549 the_enum
->enum_overflow
= tree_int_cst_lt (the_enum
->enum_next_value
, value
);
7551 /* Now create a declaration for the enum value name. */
7553 type
= TREE_TYPE (value
);
7554 type
= c_common_type_for_size (MAX (TYPE_PRECISION (type
),
7555 TYPE_PRECISION (integer_type_node
)),
7556 (TYPE_PRECISION (type
)
7557 >= TYPE_PRECISION (integer_type_node
)
7558 && TYPE_UNSIGNED (type
)));
7560 decl
= build_decl (decl_loc
, CONST_DECL
, name
, type
);
7561 DECL_INITIAL (decl
) = convert (type
, value
);
7564 return tree_cons (decl
, value
, NULL_TREE
);
7568 /* Create the FUNCTION_DECL for a function definition.
7569 DECLSPECS, DECLARATOR and ATTRIBUTES are the parts of
7570 the declaration; they describe the function's name and the type it returns,
7571 but twisted together in a fashion that parallels the syntax of C.
7573 This function creates a binding context for the function body
7574 as well as setting up the FUNCTION_DECL in current_function_decl.
7576 Returns 1 on success. If the DECLARATOR is not suitable for a function
7577 (it defines a datum instead), we return 0, which tells
7578 yyparse to report a parse error. */
7581 start_function (struct c_declspecs
*declspecs
, struct c_declarator
*declarator
,
7584 tree decl1
, old_decl
;
7585 tree restype
, resdecl
;
7588 current_function_returns_value
= 0; /* Assume, until we see it does. */
7589 current_function_returns_null
= 0;
7590 current_function_returns_abnormally
= 0;
7591 warn_about_return_type
= 0;
7592 c_switch_stack
= NULL
;
7594 /* Indicate no valid break/continue context by setting these variables
7595 to some non-null, non-label value. We'll notice and emit the proper
7596 error message in c_finish_bc_stmt. */
7597 c_break_label
= c_cont_label
= size_zero_node
;
7599 decl1
= grokdeclarator (declarator
, declspecs
, FUNCDEF
, true, NULL
,
7600 &attributes
, NULL
, NULL
, DEPRECATED_NORMAL
);
7602 /* If the declarator is not suitable for a function definition,
7603 cause a syntax error. */
7607 loc
= DECL_SOURCE_LOCATION (decl1
);
7609 decl_attributes (&decl1
, attributes
, 0);
7611 if (DECL_DECLARED_INLINE_P (decl1
)
7612 && DECL_UNINLINABLE (decl1
)
7613 && lookup_attribute ("noinline", DECL_ATTRIBUTES (decl1
)))
7614 warning_at (loc
, OPT_Wattributes
,
7615 "inline function %qD given attribute noinline",
7618 /* Handle gnu_inline attribute. */
7619 if (declspecs
->inline_p
7620 && !flag_gnu89_inline
7621 && TREE_CODE (decl1
) == FUNCTION_DECL
7622 && (lookup_attribute ("gnu_inline", DECL_ATTRIBUTES (decl1
))
7623 || current_function_decl
))
7625 if (declspecs
->storage_class
!= csc_static
)
7626 DECL_EXTERNAL (decl1
) = !DECL_EXTERNAL (decl1
);
7629 announce_function (decl1
);
7631 if (!COMPLETE_OR_VOID_TYPE_P (TREE_TYPE (TREE_TYPE (decl1
))))
7633 error_at (loc
, "return type is an incomplete type");
7634 /* Make it return void instead. */
7636 = build_function_type (void_type_node
,
7637 TYPE_ARG_TYPES (TREE_TYPE (decl1
)));
7640 if (warn_about_return_type
)
7641 pedwarn_c99 (loc
, flag_isoc99
? 0
7642 : (warn_return_type
? OPT_Wreturn_type
: OPT_Wimplicit_int
),
7643 "return type defaults to %<int%>");
7645 /* Make the init_value nonzero so pushdecl knows this is not tentative.
7646 error_mark_node is replaced below (in pop_scope) with the BLOCK. */
7647 DECL_INITIAL (decl1
) = error_mark_node
;
7649 /* A nested function is not global. */
7650 if (current_function_decl
!= 0)
7651 TREE_PUBLIC (decl1
) = 0;
7653 /* If this definition isn't a prototype and we had a prototype declaration
7654 before, copy the arg type info from that prototype. */
7655 old_decl
= lookup_name_in_scope (DECL_NAME (decl1
), current_scope
);
7656 if (old_decl
&& TREE_CODE (old_decl
) != FUNCTION_DECL
)
7658 current_function_prototype_locus
= UNKNOWN_LOCATION
;
7659 current_function_prototype_built_in
= false;
7660 current_function_prototype_arg_types
= NULL_TREE
;
7661 if (!prototype_p (TREE_TYPE (decl1
)))
7663 if (old_decl
!= 0 && TREE_CODE (TREE_TYPE (old_decl
)) == FUNCTION_TYPE
7664 && comptypes (TREE_TYPE (TREE_TYPE (decl1
)),
7665 TREE_TYPE (TREE_TYPE (old_decl
))))
7667 TREE_TYPE (decl1
) = composite_type (TREE_TYPE (old_decl
),
7669 current_function_prototype_locus
= DECL_SOURCE_LOCATION (old_decl
);
7670 current_function_prototype_built_in
7671 = C_DECL_BUILTIN_PROTOTYPE (old_decl
);
7672 current_function_prototype_arg_types
7673 = TYPE_ARG_TYPES (TREE_TYPE (decl1
));
7675 if (TREE_PUBLIC (decl1
))
7677 /* If there is an external prototype declaration of this
7678 function, record its location but do not copy information
7679 to this decl. This may be an invisible declaration
7680 (built-in or in a scope which has finished) or simply
7681 have more refined argument types than any declaration
7683 struct c_binding
*b
;
7684 for (b
= I_SYMBOL_BINDING (DECL_NAME (decl1
)); b
; b
= b
->shadowed
)
7685 if (B_IN_SCOPE (b
, external_scope
))
7689 tree ext_decl
, ext_type
;
7691 ext_type
= b
->u
.type
? b
->u
.type
: TREE_TYPE (ext_decl
);
7692 if (TREE_CODE (ext_type
) == FUNCTION_TYPE
7693 && comptypes (TREE_TYPE (TREE_TYPE (decl1
)),
7694 TREE_TYPE (ext_type
)))
7696 current_function_prototype_locus
7697 = DECL_SOURCE_LOCATION (ext_decl
);
7698 current_function_prototype_built_in
7699 = C_DECL_BUILTIN_PROTOTYPE (ext_decl
);
7700 current_function_prototype_arg_types
7701 = TYPE_ARG_TYPES (ext_type
);
7707 /* Optionally warn of old-fashioned def with no previous prototype. */
7708 if (warn_strict_prototypes
7709 && old_decl
!= error_mark_node
7710 && !prototype_p (TREE_TYPE (decl1
))
7711 && C_DECL_ISNT_PROTOTYPE (old_decl
))
7712 warning_at (loc
, OPT_Wstrict_prototypes
,
7713 "function declaration isn%'t a prototype");
7714 /* Optionally warn of any global def with no previous prototype. */
7715 else if (warn_missing_prototypes
7716 && old_decl
!= error_mark_node
7717 && TREE_PUBLIC (decl1
)
7718 && !MAIN_NAME_P (DECL_NAME (decl1
))
7719 && C_DECL_ISNT_PROTOTYPE (old_decl
))
7720 warning_at (loc
, OPT_Wmissing_prototypes
,
7721 "no previous prototype for %qD", decl1
);
7722 /* Optionally warn of any def with no previous prototype
7723 if the function has already been used. */
7724 else if (warn_missing_prototypes
7726 && old_decl
!= error_mark_node
7727 && TREE_USED (old_decl
)
7728 && !prototype_p (TREE_TYPE (old_decl
)))
7729 warning_at (loc
, OPT_Wmissing_prototypes
,
7730 "%qD was used with no prototype before its definition", decl1
);
7731 /* Optionally warn of any global def with no previous declaration. */
7732 else if (warn_missing_declarations
7733 && TREE_PUBLIC (decl1
)
7735 && !MAIN_NAME_P (DECL_NAME (decl1
)))
7736 warning_at (loc
, OPT_Wmissing_declarations
,
7737 "no previous declaration for %qD",
7739 /* Optionally warn of any def with no previous declaration
7740 if the function has already been used. */
7741 else if (warn_missing_declarations
7743 && old_decl
!= error_mark_node
7744 && TREE_USED (old_decl
)
7745 && C_DECL_IMPLICIT (old_decl
))
7746 warning_at (loc
, OPT_Wmissing_declarations
,
7747 "%qD was used with no declaration before its definition", decl1
);
7749 /* This function exists in static storage.
7750 (This does not mean `static' in the C sense!) */
7751 TREE_STATIC (decl1
) = 1;
7753 /* This is the earliest point at which we might know the assembler
7754 name of the function. Thus, if it's set before this, die horribly. */
7755 gcc_assert (!DECL_ASSEMBLER_NAME_SET_P (decl1
));
7757 /* If #pragma weak was used, mark the decl weak now. */
7758 if (current_scope
== file_scope
)
7759 maybe_apply_pragma_weak (decl1
);
7761 /* Warn for unlikely, improbable, or stupid declarations of `main'. */
7762 if (warn_main
&& MAIN_NAME_P (DECL_NAME (decl1
)))
7764 if (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (decl1
)))
7765 != integer_type_node
)
7766 pedwarn (loc
, OPT_Wmain
, "return type of %qD is not %<int%>", decl1
);
7768 check_main_parameter_types (decl1
);
7770 if (!TREE_PUBLIC (decl1
))
7771 pedwarn (loc
, OPT_Wmain
,
7772 "%qD is normally a non-static function", decl1
);
7775 /* Record the decl so that the function name is defined.
7776 If we already have a decl for this name, and it is a FUNCTION_DECL,
7777 use the old decl. */
7779 current_function_decl
= pushdecl (decl1
);
7782 declare_parm_level ();
7784 restype
= TREE_TYPE (TREE_TYPE (current_function_decl
));
7785 resdecl
= build_decl (loc
, RESULT_DECL
, NULL_TREE
, restype
);
7786 DECL_ARTIFICIAL (resdecl
) = 1;
7787 DECL_IGNORED_P (resdecl
) = 1;
7788 DECL_RESULT (current_function_decl
) = resdecl
;
7790 start_fname_decls ();
7795 /* Subroutine of store_parm_decls which handles new-style function
7796 definitions (prototype format). The parms already have decls, so we
7797 need only record them as in effect and complain if any redundant
7798 old-style parm decls were written. */
7800 store_parm_decls_newstyle (tree fndecl
, const struct c_arg_info
*arg_info
)
7806 if (current_scope
->bindings
)
7808 error_at (DECL_SOURCE_LOCATION (fndecl
),
7809 "old-style parameter declarations in prototyped "
7810 "function definition");
7812 /* Get rid of the old-style declarations. */
7816 /* Don't issue this warning for nested functions, and don't issue this
7817 warning if we got here because ARG_INFO_TYPES was error_mark_node
7818 (this happens when a function definition has just an ellipsis in
7819 its parameter list). */
7820 else if (!in_system_header
&& !current_function_scope
7821 && arg_info
->types
!= error_mark_node
)
7822 warning_at (DECL_SOURCE_LOCATION (fndecl
), OPT_Wtraditional
,
7823 "traditional C rejects ISO C style function definitions");
7825 /* Now make all the parameter declarations visible in the function body.
7826 We can bypass most of the grunt work of pushdecl. */
7827 for (decl
= arg_info
->parms
; decl
; decl
= DECL_CHAIN (decl
))
7829 DECL_CONTEXT (decl
) = current_function_decl
;
7830 if (DECL_NAME (decl
))
7832 bind (DECL_NAME (decl
), decl
, current_scope
,
7833 /*invisible=*/false, /*nested=*/false,
7835 if (!TREE_USED (decl
))
7836 warn_if_shadowing (decl
);
7839 error_at (DECL_SOURCE_LOCATION (decl
), "parameter name omitted");
7842 /* Record the parameter list in the function declaration. */
7843 DECL_ARGUMENTS (fndecl
) = arg_info
->parms
;
7845 /* Now make all the ancillary declarations visible, likewise. */
7846 for (decl
= arg_info
->others
; decl
; decl
= DECL_CHAIN (decl
))
7848 DECL_CONTEXT (decl
) = current_function_decl
;
7849 if (DECL_NAME (decl
))
7850 bind (DECL_NAME (decl
), decl
, current_scope
,
7851 /*invisible=*/false,
7852 /*nested=*/(TREE_CODE (decl
) == FUNCTION_DECL
),
7856 /* And all the tag declarations. */
7857 FOR_EACH_VEC_ELT_REVERSE (c_arg_tag
, arg_info
->tags
, ix
, tag
)
7859 bind (tag
->id
, tag
->type
, current_scope
,
7860 /*invisible=*/false, /*nested=*/false, UNKNOWN_LOCATION
);
7863 /* Subroutine of store_parm_decls which handles old-style function
7864 definitions (separate parameter list and declarations). */
7867 store_parm_decls_oldstyle (tree fndecl
, const struct c_arg_info
*arg_info
)
7869 struct c_binding
*b
;
7870 tree parm
, decl
, last
;
7871 tree parmids
= arg_info
->parms
;
7872 struct pointer_set_t
*seen_args
= pointer_set_create ();
7874 if (!in_system_header
)
7875 warning_at (DECL_SOURCE_LOCATION (fndecl
),
7876 OPT_Wold_style_definition
, "old-style function definition");
7878 /* Match each formal parameter name with its declaration. Save each
7879 decl in the appropriate TREE_PURPOSE slot of the parmids chain. */
7880 for (parm
= parmids
; parm
; parm
= TREE_CHAIN (parm
))
7882 if (TREE_VALUE (parm
) == 0)
7884 error_at (DECL_SOURCE_LOCATION (fndecl
),
7885 "parameter name missing from parameter list");
7886 TREE_PURPOSE (parm
) = 0;
7890 b
= I_SYMBOL_BINDING (TREE_VALUE (parm
));
7891 if (b
&& B_IN_CURRENT_SCOPE (b
))
7894 /* Skip erroneous parameters. */
7895 if (decl
== error_mark_node
)
7897 /* If we got something other than a PARM_DECL it is an error. */
7898 if (TREE_CODE (decl
) != PARM_DECL
)
7899 error_at (DECL_SOURCE_LOCATION (decl
),
7900 "%qD declared as a non-parameter", decl
);
7901 /* If the declaration is already marked, we have a duplicate
7902 name. Complain and ignore the duplicate. */
7903 else if (pointer_set_contains (seen_args
, decl
))
7905 error_at (DECL_SOURCE_LOCATION (decl
),
7906 "multiple parameters named %qD", decl
);
7907 TREE_PURPOSE (parm
) = 0;
7910 /* If the declaration says "void", complain and turn it into
7912 else if (VOID_TYPE_P (TREE_TYPE (decl
)))
7914 error_at (DECL_SOURCE_LOCATION (decl
),
7915 "parameter %qD declared with void type", decl
);
7916 TREE_TYPE (decl
) = integer_type_node
;
7917 DECL_ARG_TYPE (decl
) = integer_type_node
;
7918 layout_decl (decl
, 0);
7920 warn_if_shadowing (decl
);
7922 /* If no declaration found, default to int. */
7925 /* FIXME diagnostics: This should be the location of the argument,
7926 not the FNDECL. E.g., for an old-style declaration
7928 int f10(v) { blah; }
7930 We should use the location of the V, not the F10.
7931 Unfortunately, the V is an IDENTIFIER_NODE which has no
7932 location. In the future we need locations for c_arg_info
7935 See gcc.dg/Wshadow-3.c for an example of this problem. */
7936 decl
= build_decl (DECL_SOURCE_LOCATION (fndecl
),
7937 PARM_DECL
, TREE_VALUE (parm
), integer_type_node
);
7938 DECL_ARG_TYPE (decl
) = TREE_TYPE (decl
);
7940 warn_if_shadowing (decl
);
7943 pedwarn (DECL_SOURCE_LOCATION (decl
),
7944 0, "type of %qD defaults to %<int%>", decl
);
7946 warning_at (DECL_SOURCE_LOCATION (decl
),
7947 OPT_Wmissing_parameter_type
,
7948 "type of %qD defaults to %<int%>", decl
);
7951 TREE_PURPOSE (parm
) = decl
;
7952 pointer_set_insert (seen_args
, decl
);
7955 /* Now examine the parms chain for incomplete declarations
7956 and declarations with no corresponding names. */
7958 for (b
= current_scope
->bindings
; b
; b
= b
->prev
)
7961 if (TREE_CODE (parm
) != PARM_DECL
)
7964 if (TREE_TYPE (parm
) != error_mark_node
7965 && !COMPLETE_TYPE_P (TREE_TYPE (parm
)))
7967 error_at (DECL_SOURCE_LOCATION (parm
),
7968 "parameter %qD has incomplete type", parm
);
7969 TREE_TYPE (parm
) = error_mark_node
;
7972 if (!pointer_set_contains (seen_args
, parm
))
7974 error_at (DECL_SOURCE_LOCATION (parm
),
7975 "declaration for parameter %qD but no such parameter",
7978 /* Pretend the parameter was not missing.
7979 This gets us to a standard state and minimizes
7980 further error messages. */
7981 parmids
= chainon (parmids
, tree_cons (parm
, 0, 0));
7985 /* Chain the declarations together in the order of the list of
7986 names. Store that chain in the function decl, replacing the
7987 list of names. Update the current scope to match. */
7988 DECL_ARGUMENTS (fndecl
) = 0;
7990 for (parm
= parmids
; parm
; parm
= TREE_CHAIN (parm
))
7991 if (TREE_PURPOSE (parm
))
7993 if (parm
&& TREE_PURPOSE (parm
))
7995 last
= TREE_PURPOSE (parm
);
7996 DECL_ARGUMENTS (fndecl
) = last
;
7998 for (parm
= TREE_CHAIN (parm
); parm
; parm
= TREE_CHAIN (parm
))
7999 if (TREE_PURPOSE (parm
))
8001 DECL_CHAIN (last
) = TREE_PURPOSE (parm
);
8002 last
= TREE_PURPOSE (parm
);
8004 DECL_CHAIN (last
) = 0;
8007 pointer_set_destroy (seen_args
);
8009 /* If there was a previous prototype,
8010 set the DECL_ARG_TYPE of each argument according to
8011 the type previously specified, and report any mismatches. */
8013 if (current_function_prototype_arg_types
)
8016 for (parm
= DECL_ARGUMENTS (fndecl
),
8017 type
= current_function_prototype_arg_types
;
8018 parm
|| (type
&& TREE_VALUE (type
) != error_mark_node
8019 && (TYPE_MAIN_VARIANT (TREE_VALUE (type
)) != void_type_node
));
8020 parm
= DECL_CHAIN (parm
), type
= TREE_CHAIN (type
))
8022 if (parm
== 0 || type
== 0
8023 || TYPE_MAIN_VARIANT (TREE_VALUE (type
)) == void_type_node
)
8025 if (current_function_prototype_built_in
)
8026 warning_at (DECL_SOURCE_LOCATION (fndecl
),
8027 0, "number of arguments doesn%'t match "
8028 "built-in prototype");
8031 /* FIXME diagnostics: This should be the location of
8032 FNDECL, but there is bug when a prototype is
8033 declared inside function context, but defined
8034 outside of it (e.g., gcc.dg/pr15698-2.c). In
8035 which case FNDECL gets the location of the
8036 prototype, not the definition. */
8037 error_at (input_location
,
8038 "number of arguments doesn%'t match prototype");
8040 error_at (current_function_prototype_locus
,
8041 "prototype declaration");
8045 /* Type for passing arg must be consistent with that
8046 declared for the arg. ISO C says we take the unqualified
8047 type for parameters declared with qualified type. */
8048 if (TREE_TYPE (parm
) != error_mark_node
8049 && TREE_TYPE (type
) != error_mark_node
8050 && !comptypes (TYPE_MAIN_VARIANT (DECL_ARG_TYPE (parm
)),
8051 TYPE_MAIN_VARIANT (TREE_VALUE (type
))))
8053 if (TYPE_MAIN_VARIANT (TREE_TYPE (parm
))
8054 == TYPE_MAIN_VARIANT (TREE_VALUE (type
)))
8056 /* Adjust argument to match prototype. E.g. a previous
8057 `int foo(float);' prototype causes
8058 `int foo(x) float x; {...}' to be treated like
8059 `int foo(float x) {...}'. This is particularly
8060 useful for argument types like uid_t. */
8061 DECL_ARG_TYPE (parm
) = TREE_TYPE (parm
);
8063 if (targetm
.calls
.promote_prototypes (TREE_TYPE (current_function_decl
))
8064 && INTEGRAL_TYPE_P (TREE_TYPE (parm
))
8065 && TYPE_PRECISION (TREE_TYPE (parm
))
8066 < TYPE_PRECISION (integer_type_node
))
8067 DECL_ARG_TYPE (parm
) = integer_type_node
;
8069 /* ??? Is it possible to get here with a
8070 built-in prototype or will it always have
8071 been diagnosed as conflicting with an
8072 old-style definition and discarded? */
8073 if (current_function_prototype_built_in
)
8074 warning_at (DECL_SOURCE_LOCATION (parm
),
8075 OPT_pedantic
, "promoted argument %qD "
8076 "doesn%'t match built-in prototype", parm
);
8079 pedwarn (DECL_SOURCE_LOCATION (parm
),
8080 OPT_pedantic
, "promoted argument %qD "
8081 "doesn%'t match prototype", parm
);
8082 pedwarn (current_function_prototype_locus
, OPT_pedantic
,
8083 "prototype declaration");
8088 if (current_function_prototype_built_in
)
8089 warning_at (DECL_SOURCE_LOCATION (parm
),
8090 0, "argument %qD doesn%'t match "
8091 "built-in prototype", parm
);
8094 error_at (DECL_SOURCE_LOCATION (parm
),
8095 "argument %qD doesn%'t match prototype", parm
);
8096 error_at (current_function_prototype_locus
,
8097 "prototype declaration");
8102 TYPE_ACTUAL_ARG_TYPES (TREE_TYPE (fndecl
)) = 0;
8105 /* Otherwise, create a prototype that would match. */
8109 tree actual
= 0, last
= 0, type
;
8111 for (parm
= DECL_ARGUMENTS (fndecl
); parm
; parm
= DECL_CHAIN (parm
))
8113 type
= tree_cons (NULL_TREE
, DECL_ARG_TYPE (parm
), NULL_TREE
);
8115 TREE_CHAIN (last
) = type
;
8120 type
= tree_cons (NULL_TREE
, void_type_node
, NULL_TREE
);
8122 TREE_CHAIN (last
) = type
;
8126 /* We are going to assign a new value for the TYPE_ACTUAL_ARG_TYPES
8127 of the type of this function, but we need to avoid having this
8128 affect the types of other similarly-typed functions, so we must
8129 first force the generation of an identical (but separate) type
8130 node for the relevant function type. The new node we create
8131 will be a variant of the main variant of the original function
8134 TREE_TYPE (fndecl
) = build_variant_type_copy (TREE_TYPE (fndecl
));
8136 TYPE_ACTUAL_ARG_TYPES (TREE_TYPE (fndecl
)) = actual
;
8140 /* Store parameter declarations passed in ARG_INFO into the current
8141 function declaration. */
8144 store_parm_decls_from (struct c_arg_info
*arg_info
)
8146 current_function_arg_info
= arg_info
;
8147 store_parm_decls ();
8150 /* Store the parameter declarations into the current function declaration.
8151 This is called after parsing the parameter declarations, before
8152 digesting the body of the function.
8154 For an old-style definition, construct a prototype out of the old-style
8155 parameter declarations and inject it into the function's type. */
8158 store_parm_decls (void)
8160 tree fndecl
= current_function_decl
;
8163 /* The argument information block for FNDECL. */
8164 struct c_arg_info
*arg_info
= current_function_arg_info
;
8165 current_function_arg_info
= 0;
8167 /* True if this definition is written with a prototype. Note:
8168 despite C99 6.7.5.3p14, we can *not* treat an empty argument
8169 list in a function definition as equivalent to (void) -- an
8170 empty argument list specifies the function has no parameters,
8171 but only (void) sets up a prototype for future calls. */
8172 proto
= arg_info
->types
!= 0;
8175 store_parm_decls_newstyle (fndecl
, arg_info
);
8177 store_parm_decls_oldstyle (fndecl
, arg_info
);
8179 /* The next call to push_scope will be a function body. */
8181 next_is_function_body
= true;
8183 /* Write a record describing this function definition to the prototypes
8184 file (if requested). */
8186 gen_aux_info_record (fndecl
, 1, 0, proto
);
8188 /* Initialize the RTL code for the function. */
8189 allocate_struct_function (fndecl
, false);
8191 /* Begin the statement tree for this function. */
8192 DECL_SAVED_TREE (fndecl
) = push_stmt_list ();
8194 /* ??? Insert the contents of the pending sizes list into the function
8195 to be evaluated. The only reason left to have this is
8196 void foo(int n, int array[n++])
8197 because we throw away the array type in favor of a pointer type, and
8198 thus won't naturally see the SAVE_EXPR containing the increment. All
8199 other pending sizes would be handled by gimplify_parameters. */
8201 VEC(tree
,gc
) *pending_sizes
= get_pending_sizes ();
8205 FOR_EACH_VEC_ELT (tree
, pending_sizes
, i
, t
)
8209 /* Even though we're inside a function body, we still don't want to
8210 call expand_expr to calculate the size of a variable-sized array.
8211 We haven't necessarily assigned RTL to all variables yet, so it's
8212 not safe to try to expand expressions involving them. */
8213 cfun
->dont_save_pending_sizes_p
= 1;
8217 /* Finish up a function declaration and compile that function
8218 all the way to assembler language output. Then free the storage
8219 for the function definition.
8221 This is called after parsing the body of the function definition. */
8224 finish_function (void)
8226 tree fndecl
= current_function_decl
;
8228 if (c_dialect_objc ())
8229 objc_finish_function ();
8231 if (TREE_CODE (fndecl
) == FUNCTION_DECL
8232 && targetm
.calls
.promote_prototypes (TREE_TYPE (fndecl
)))
8234 tree args
= DECL_ARGUMENTS (fndecl
);
8235 for (; args
; args
= DECL_CHAIN (args
))
8237 tree type
= TREE_TYPE (args
);
8238 if (INTEGRAL_TYPE_P (type
)
8239 && TYPE_PRECISION (type
) < TYPE_PRECISION (integer_type_node
))
8240 DECL_ARG_TYPE (args
) = integer_type_node
;
8244 if (DECL_INITIAL (fndecl
) && DECL_INITIAL (fndecl
) != error_mark_node
)
8245 BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl
)) = fndecl
;
8247 /* Must mark the RESULT_DECL as being in this function. */
8249 if (DECL_RESULT (fndecl
) && DECL_RESULT (fndecl
) != error_mark_node
)
8250 DECL_CONTEXT (DECL_RESULT (fndecl
)) = fndecl
;
8252 if (MAIN_NAME_P (DECL_NAME (fndecl
)) && flag_hosted
8253 && TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (fndecl
)))
8254 == integer_type_node
&& flag_isoc99
)
8256 /* Hack. We don't want the middle-end to warn that this return
8257 is unreachable, so we mark its location as special. Using
8258 UNKNOWN_LOCATION has the problem that it gets clobbered in
8259 annotate_one_with_locus. A cleaner solution might be to
8260 ensure ! should_carry_locus_p (stmt), but that needs a flag.
8262 c_finish_return (BUILTINS_LOCATION
, integer_zero_node
, NULL_TREE
);
8265 /* Tie off the statement tree for this function. */
8266 DECL_SAVED_TREE (fndecl
) = pop_stmt_list (DECL_SAVED_TREE (fndecl
));
8268 finish_fname_decls ();
8270 /* Complain if there's just no return statement. */
8271 if (warn_return_type
8272 && TREE_CODE (TREE_TYPE (TREE_TYPE (fndecl
))) != VOID_TYPE
8273 && !current_function_returns_value
&& !current_function_returns_null
8274 /* Don't complain if we are no-return. */
8275 && !current_function_returns_abnormally
8276 /* Don't complain if we are declared noreturn. */
8277 && !TREE_THIS_VOLATILE (fndecl
)
8278 /* Don't warn for main(). */
8279 && !MAIN_NAME_P (DECL_NAME (fndecl
))
8280 /* Or if they didn't actually specify a return type. */
8281 && !C_FUNCTION_IMPLICIT_INT (fndecl
)
8282 /* Normally, with -Wreturn-type, flow will complain, but we might
8283 optimize out static functions. */
8284 && !TREE_PUBLIC (fndecl
))
8286 warning (OPT_Wreturn_type
,
8287 "no return statement in function returning non-void");
8288 TREE_NO_WARNING (fndecl
) = 1;
8291 /* Complain about parameters that are only set, but never otherwise used. */
8292 if (warn_unused_but_set_parameter
)
8296 for (decl
= DECL_ARGUMENTS (fndecl
);
8298 decl
= DECL_CHAIN (decl
))
8299 if (TREE_USED (decl
)
8300 && TREE_CODE (decl
) == PARM_DECL
8301 && !DECL_READ_P (decl
)
8303 && !DECL_ARTIFICIAL (decl
)
8304 && !TREE_NO_WARNING (decl
))
8305 warning_at (DECL_SOURCE_LOCATION (decl
),
8306 OPT_Wunused_but_set_parameter
,
8307 "parameter %qD set but not used", decl
);
8310 /* Store the end of the function, so that we get good line number
8311 info for the epilogue. */
8312 cfun
->function_end_locus
= input_location
;
8314 /* Finalize the ELF visibility for the function. */
8315 c_determine_visibility (fndecl
);
8317 /* For GNU C extern inline functions disregard inline limits. */
8318 if (DECL_EXTERNAL (fndecl
)
8319 && DECL_DECLARED_INLINE_P (fndecl
))
8320 DECL_DISREGARD_INLINE_LIMITS (fndecl
) = 1;
8322 /* Genericize before inlining. Delay genericizing nested functions
8323 until their parent function is genericized. Since finalizing
8324 requires GENERIC, delay that as well. */
8326 if (DECL_INITIAL (fndecl
) && DECL_INITIAL (fndecl
) != error_mark_node
8327 && !undef_nested_function
)
8329 if (!decl_function_context (fndecl
))
8331 invoke_plugin_callbacks (PLUGIN_PRE_GENERICIZE
, fndecl
);
8332 c_genericize (fndecl
);
8334 /* ??? Objc emits functions after finalizing the compilation unit.
8335 This should be cleaned up later and this conditional removed. */
8336 if (cgraph_global_info_ready
)
8338 cgraph_add_new_function (fndecl
, false);
8341 cgraph_finalize_function (fndecl
, false);
8345 /* Register this function with cgraph just far enough to get it
8346 added to our parent's nested function list. Handy, since the
8347 C front end doesn't have such a list. */
8348 (void) cgraph_node (fndecl
);
8352 if (!decl_function_context (fndecl
))
8353 undef_nested_function
= false;
8355 /* We're leaving the context of this function, so zap cfun.
8356 It's still in DECL_STRUCT_FUNCTION, and we'll restore it in
8357 tree_rest_of_compilation. */
8359 current_function_decl
= NULL
;
8362 /* Check the declarations given in a for-loop for satisfying the C99
8363 constraints. If exactly one such decl is found, return it. LOC is
8364 the location of the opening parenthesis of the for loop. The last
8365 parameter allows you to control the "for loop initial declarations
8366 are only allowed in C99 mode". Normally, you should pass
8367 flag_isoc99 as that parameter. But in some cases (Objective-C
8368 foreach loop, for example) we want to run the checks in this
8369 function even if not in C99 mode, so we allow the caller to turn
8370 off the error about not being in C99 mode.
8374 check_for_loop_decls (location_t loc
, bool turn_off_iso_c99_error
)
8376 struct c_binding
*b
;
8377 tree one_decl
= NULL_TREE
;
8380 if (!turn_off_iso_c99_error
)
8382 static bool hint
= true;
8383 /* If we get here, declarations have been used in a for loop without
8384 the C99 for loop scope. This doesn't make much sense, so don't
8386 error_at (loc
, "%<for%> loop initial declarations "
8387 "are only allowed in C99 mode");
8391 "use option -std=c99 or -std=gnu99 to compile your code");
8396 /* C99 subclause 6.8.5 paragraph 3:
8398 [#3] The declaration part of a for statement shall only
8399 declare identifiers for objects having storage class auto or
8402 It isn't clear whether, in this sentence, "identifiers" binds to
8403 "shall only declare" or to "objects" - that is, whether all identifiers
8404 declared must be identifiers for objects, or whether the restriction
8405 only applies to those that are. (A question on this in comp.std.c
8406 in November 2000 received no answer.) We implement the strictest
8407 interpretation, to avoid creating an extension which later causes
8410 for (b
= current_scope
->bindings
; b
; b
= b
->prev
)
8413 tree decl
= b
->decl
;
8418 switch (TREE_CODE (decl
))
8422 location_t decl_loc
= DECL_SOURCE_LOCATION (decl
);
8423 if (TREE_STATIC (decl
))
8425 "declaration of static variable %qD in %<for%> loop "
8426 "initial declaration", decl
);
8427 else if (DECL_EXTERNAL (decl
))
8429 "declaration of %<extern%> variable %qD in %<for%> loop "
8430 "initial declaration", decl
);
8436 "%<struct %E%> declared in %<for%> loop initial "
8441 "%<union %E%> declared in %<for%> loop initial declaration",
8445 error_at (loc
, "%<enum %E%> declared in %<for%> loop "
8446 "initial declaration", id
);
8449 error_at (loc
, "declaration of non-variable "
8450 "%qD in %<for%> loop initial declaration", decl
);
8457 return n_decls
== 1 ? one_decl
: NULL_TREE
;
8460 /* Save and reinitialize the variables
8461 used during compilation of a C function. */
8464 c_push_function_context (void)
8466 struct language_function
*p
;
8467 p
= ggc_alloc_language_function ();
8470 p
->base
.x_stmt_tree
= c_stmt_tree
;
8471 p
->x_break_label
= c_break_label
;
8472 p
->x_cont_label
= c_cont_label
;
8473 p
->x_switch_stack
= c_switch_stack
;
8474 p
->arg_info
= current_function_arg_info
;
8475 p
->returns_value
= current_function_returns_value
;
8476 p
->returns_null
= current_function_returns_null
;
8477 p
->returns_abnormally
= current_function_returns_abnormally
;
8478 p
->warn_about_return_type
= warn_about_return_type
;
8480 push_function_context ();
8483 /* Restore the variables used during compilation of a C function. */
8486 c_pop_function_context (void)
8488 struct language_function
*p
;
8490 pop_function_context ();
8492 cfun
->language
= NULL
;
8494 if (DECL_STRUCT_FUNCTION (current_function_decl
) == 0
8495 && DECL_SAVED_TREE (current_function_decl
) == NULL_TREE
)
8497 /* Stop pointing to the local nodes about to be freed. */
8498 /* But DECL_INITIAL must remain nonzero so we know this
8499 was an actual function definition. */
8500 DECL_INITIAL (current_function_decl
) = error_mark_node
;
8501 DECL_ARGUMENTS (current_function_decl
) = 0;
8504 c_stmt_tree
= p
->base
.x_stmt_tree
;
8505 c_break_label
= p
->x_break_label
;
8506 c_cont_label
= p
->x_cont_label
;
8507 c_switch_stack
= p
->x_switch_stack
;
8508 current_function_arg_info
= p
->arg_info
;
8509 current_function_returns_value
= p
->returns_value
;
8510 current_function_returns_null
= p
->returns_null
;
8511 current_function_returns_abnormally
= p
->returns_abnormally
;
8512 warn_about_return_type
= p
->warn_about_return_type
;
8515 /* The functions below are required for functionality of doing
8516 function at once processing in the C front end. Currently these
8517 functions are not called from anywhere in the C front end, but as
8518 these changes continue, that will change. */
8520 /* Returns the stmt_tree (if any) to which statements are currently
8521 being added. If there is no active statement-tree, NULL is
8525 current_stmt_tree (void)
8527 return &c_stmt_tree
;
8530 /* Return the global value of T as a symbol. */
8533 identifier_global_value (tree t
)
8535 struct c_binding
*b
;
8537 for (b
= I_SYMBOL_BINDING (t
); b
; b
= b
->shadowed
)
8538 if (B_IN_FILE_SCOPE (b
) || B_IN_EXTERNAL_SCOPE (b
))
8544 /* Record a builtin type for C. If NAME is non-NULL, it is the name used;
8545 otherwise the name is found in ridpointers from RID_INDEX. */
8548 record_builtin_type (enum rid rid_index
, const char *name
, tree type
)
8552 id
= ridpointers
[(int) rid_index
];
8554 id
= get_identifier (name
);
8555 decl
= build_decl (UNKNOWN_LOCATION
, TYPE_DECL
, id
, type
);
8557 if (debug_hooks
->type_decl
)
8558 debug_hooks
->type_decl (decl
, false);
8561 /* Build the void_list_node (void_type_node having been created). */
8563 build_void_list_node (void)
8565 tree t
= build_tree_list (NULL_TREE
, void_type_node
);
8569 /* Return a c_parm structure with the given SPECS, ATTRS and DECLARATOR. */
8572 build_c_parm (struct c_declspecs
*specs
, tree attrs
,
8573 struct c_declarator
*declarator
)
8575 struct c_parm
*ret
= XOBNEW (&parser_obstack
, struct c_parm
);
8578 ret
->declarator
= declarator
;
8582 /* Return a declarator with nested attributes. TARGET is the inner
8583 declarator to which these attributes apply. ATTRS are the
8586 struct c_declarator
*
8587 build_attrs_declarator (tree attrs
, struct c_declarator
*target
)
8589 struct c_declarator
*ret
= XOBNEW (&parser_obstack
, struct c_declarator
);
8590 ret
->kind
= cdk_attrs
;
8591 ret
->declarator
= target
;
8592 ret
->u
.attrs
= attrs
;
8596 /* Return a declarator for a function with arguments specified by ARGS
8597 and return type specified by TARGET. */
8599 struct c_declarator
*
8600 build_function_declarator (struct c_arg_info
*args
,
8601 struct c_declarator
*target
)
8603 struct c_declarator
*ret
= XOBNEW (&parser_obstack
, struct c_declarator
);
8604 ret
->kind
= cdk_function
;
8605 ret
->declarator
= target
;
8606 ret
->u
.arg_info
= args
;
8610 /* Return a declarator for the identifier IDENT (which may be
8611 NULL_TREE for an abstract declarator). */
8613 struct c_declarator
*
8614 build_id_declarator (tree ident
)
8616 struct c_declarator
*ret
= XOBNEW (&parser_obstack
, struct c_declarator
);
8618 ret
->declarator
= 0;
8620 /* Default value - may get reset to a more precise location. */
8621 ret
->id_loc
= input_location
;
8625 /* Return something to represent absolute declarators containing a *.
8626 TARGET is the absolute declarator that the * contains.
8627 TYPE_QUALS_ATTRS is a structure for type qualifiers and attributes
8628 to apply to the pointer type. */
8630 struct c_declarator
*
8631 make_pointer_declarator (struct c_declspecs
*type_quals_attrs
,
8632 struct c_declarator
*target
)
8636 struct c_declarator
*itarget
= target
;
8637 struct c_declarator
*ret
= XOBNEW (&parser_obstack
, struct c_declarator
);
8638 if (type_quals_attrs
)
8640 attrs
= type_quals_attrs
->attrs
;
8641 quals
= quals_from_declspecs (type_quals_attrs
);
8642 if (attrs
!= NULL_TREE
)
8643 itarget
= build_attrs_declarator (attrs
, target
);
8645 ret
->kind
= cdk_pointer
;
8646 ret
->declarator
= itarget
;
8647 ret
->u
.pointer_quals
= quals
;
8651 /* Return a pointer to a structure for an empty list of declaration
8654 struct c_declspecs
*
8655 build_null_declspecs (void)
8657 struct c_declspecs
*ret
= XOBNEW (&parser_obstack
, struct c_declspecs
);
8662 ret
->typespec_word
= cts_none
;
8663 ret
->storage_class
= csc_none
;
8664 ret
->expr_const_operands
= true;
8665 ret
->declspecs_seen_p
= false;
8666 ret
->typespec_kind
= ctsk_none
;
8667 ret
->non_sc_seen_p
= false;
8668 ret
->typedef_p
= false;
8669 ret
->explicit_signed_p
= false;
8670 ret
->deprecated_p
= false;
8671 ret
->default_int_p
= false;
8672 ret
->long_p
= false;
8673 ret
->long_long_p
= false;
8674 ret
->short_p
= false;
8675 ret
->signed_p
= false;
8676 ret
->unsigned_p
= false;
8677 ret
->complex_p
= false;
8678 ret
->inline_p
= false;
8679 ret
->thread_p
= false;
8680 ret
->const_p
= false;
8681 ret
->volatile_p
= false;
8682 ret
->restrict_p
= false;
8683 ret
->saturating_p
= false;
8684 ret
->address_space
= ADDR_SPACE_GENERIC
;
8688 /* Add the address space ADDRSPACE to the declaration specifiers
8689 SPECS, returning SPECS. */
8691 struct c_declspecs
*
8692 declspecs_add_addrspace (struct c_declspecs
*specs
, addr_space_t as
)
8694 specs
->non_sc_seen_p
= true;
8695 specs
->declspecs_seen_p
= true;
8697 if (!ADDR_SPACE_GENERIC_P (specs
->address_space
)
8698 && specs
->address_space
!= as
)
8699 error ("incompatible address space qualifiers %qs and %qs",
8700 c_addr_space_name (as
),
8701 c_addr_space_name (specs
->address_space
));
8703 specs
->address_space
= as
;
8707 /* Add the type qualifier QUAL to the declaration specifiers SPECS,
8710 struct c_declspecs
*
8711 declspecs_add_qual (struct c_declspecs
*specs
, tree qual
)
8715 specs
->non_sc_seen_p
= true;
8716 specs
->declspecs_seen_p
= true;
8717 gcc_assert (TREE_CODE (qual
) == IDENTIFIER_NODE
8718 && C_IS_RESERVED_WORD (qual
));
8719 i
= C_RID_CODE (qual
);
8723 dupe
= specs
->const_p
;
8724 specs
->const_p
= true;
8727 dupe
= specs
->volatile_p
;
8728 specs
->volatile_p
= true;
8731 dupe
= specs
->restrict_p
;
8732 specs
->restrict_p
= true;
8737 if (dupe
&& !flag_isoc99
)
8738 pedwarn (input_location
, OPT_pedantic
, "duplicate %qE", qual
);
8742 /* Add the type specifier TYPE to the declaration specifiers SPECS,
8745 struct c_declspecs
*
8746 declspecs_add_type (location_t loc
, struct c_declspecs
*specs
,
8747 struct c_typespec spec
)
8749 tree type
= spec
.spec
;
8750 specs
->non_sc_seen_p
= true;
8751 specs
->declspecs_seen_p
= true;
8752 specs
->typespec_kind
= spec
.kind
;
8753 if (TREE_DEPRECATED (type
))
8754 specs
->deprecated_p
= true;
8756 /* Handle type specifier keywords. */
8757 if (TREE_CODE (type
) == IDENTIFIER_NODE
8758 && C_IS_RESERVED_WORD (type
)
8759 && C_RID_CODE (type
) != RID_CXX_COMPAT_WARN
)
8761 enum rid i
= C_RID_CODE (type
);
8764 error_at (loc
, "two or more data types in declaration specifiers");
8767 if ((int) i
<= (int) RID_LAST_MODIFIER
)
8769 /* "long", "short", "signed", "unsigned", "_Complex" or "_Sat". */
8774 if (specs
->long_long_p
)
8776 error_at (loc
, "%<long long long%> is too long for GCC");
8781 if (specs
->typespec_word
== cts_double
)
8784 ("both %<long long%> and %<double%> in "
8785 "declaration specifiers"));
8788 pedwarn_c90 (loc
, OPT_Wlong_long
,
8789 "ISO C90 does not support %<long long%>");
8790 specs
->long_long_p
= 1;
8795 ("both %<long%> and %<short%> in "
8796 "declaration specifiers"));
8797 else if (specs
->typespec_word
== cts_void
)
8799 ("both %<long%> and %<void%> in "
8800 "declaration specifiers"));
8801 else if (specs
->typespec_word
== cts_int128
)
8803 ("both %<long%> and %<__int128%> in "
8804 "declaration specifiers"));
8805 else if (specs
->typespec_word
== cts_bool
)
8807 ("both %<long%> and %<_Bool%> in "
8808 "declaration specifiers"));
8809 else if (specs
->typespec_word
== cts_char
)
8811 ("both %<long%> and %<char%> in "
8812 "declaration specifiers"));
8813 else if (specs
->typespec_word
== cts_float
)
8815 ("both %<long%> and %<float%> in "
8816 "declaration specifiers"));
8817 else if (specs
->typespec_word
== cts_dfloat32
)
8819 ("both %<long%> and %<_Decimal32%> in "
8820 "declaration specifiers"));
8821 else if (specs
->typespec_word
== cts_dfloat64
)
8823 ("both %<long%> and %<_Decimal64%> in "
8824 "declaration specifiers"));
8825 else if (specs
->typespec_word
== cts_dfloat128
)
8827 ("both %<long%> and %<_Decimal128%> in "
8828 "declaration specifiers"));
8830 specs
->long_p
= true;
8833 dupe
= specs
->short_p
;
8836 ("both %<long%> and %<short%> in "
8837 "declaration specifiers"));
8838 else if (specs
->typespec_word
== cts_void
)
8840 ("both %<short%> and %<void%> in "
8841 "declaration specifiers"));
8842 else if (specs
->typespec_word
== cts_int128
)
8844 ("both %<short%> and %<__int128%> in "
8845 "declaration specifiers"));
8846 else if (specs
->typespec_word
== cts_bool
)
8848 ("both %<short%> and %<_Bool%> in "
8849 "declaration specifiers"));
8850 else if (specs
->typespec_word
== cts_char
)
8852 ("both %<short%> and %<char%> in "
8853 "declaration specifiers"));
8854 else if (specs
->typespec_word
== cts_float
)
8856 ("both %<short%> and %<float%> in "
8857 "declaration specifiers"));
8858 else if (specs
->typespec_word
== cts_double
)
8860 ("both %<short%> and %<double%> in "
8861 "declaration specifiers"));
8862 else if (specs
->typespec_word
== cts_dfloat32
)
8864 ("both %<short%> and %<_Decimal32%> in "
8865 "declaration specifiers"));
8866 else if (specs
->typespec_word
== cts_dfloat64
)
8868 ("both %<short%> and %<_Decimal64%> in "
8869 "declaration specifiers"));
8870 else if (specs
->typespec_word
== cts_dfloat128
)
8872 ("both %<short%> and %<_Decimal128%> in "
8873 "declaration specifiers"));
8875 specs
->short_p
= true;
8878 dupe
= specs
->signed_p
;
8879 if (specs
->unsigned_p
)
8881 ("both %<signed%> and %<unsigned%> in "
8882 "declaration specifiers"));
8883 else if (specs
->typespec_word
== cts_void
)
8885 ("both %<signed%> and %<void%> in "
8886 "declaration specifiers"));
8887 else if (specs
->typespec_word
== cts_bool
)
8889 ("both %<signed%> and %<_Bool%> in "
8890 "declaration specifiers"));
8891 else if (specs
->typespec_word
== cts_float
)
8893 ("both %<signed%> and %<float%> in "
8894 "declaration specifiers"));
8895 else if (specs
->typespec_word
== cts_double
)
8897 ("both %<signed%> and %<double%> in "
8898 "declaration specifiers"));
8899 else if (specs
->typespec_word
== cts_dfloat32
)
8901 ("both %<signed%> and %<_Decimal32%> in "
8902 "declaration specifiers"));
8903 else if (specs
->typespec_word
== cts_dfloat64
)
8905 ("both %<signed%> and %<_Decimal64%> in "
8906 "declaration specifiers"));
8907 else if (specs
->typespec_word
== cts_dfloat128
)
8909 ("both %<signed%> and %<_Decimal128%> in "
8910 "declaration specifiers"));
8912 specs
->signed_p
= true;
8915 dupe
= specs
->unsigned_p
;
8916 if (specs
->signed_p
)
8918 ("both %<signed%> and %<unsigned%> in "
8919 "declaration specifiers"));
8920 else if (specs
->typespec_word
== cts_void
)
8922 ("both %<unsigned%> and %<void%> in "
8923 "declaration specifiers"));
8924 else if (specs
->typespec_word
== cts_bool
)
8926 ("both %<unsigned%> and %<_Bool%> in "
8927 "declaration specifiers"));
8928 else if (specs
->typespec_word
== cts_float
)
8930 ("both %<unsigned%> and %<float%> in "
8931 "declaration specifiers"));
8932 else if (specs
->typespec_word
== cts_double
)
8934 ("both %<unsigned%> and %<double%> in "
8935 "declaration specifiers"));
8936 else if (specs
->typespec_word
== cts_dfloat32
)
8938 ("both %<unsigned%> and %<_Decimal32%> in "
8939 "declaration specifiers"));
8940 else if (specs
->typespec_word
== cts_dfloat64
)
8942 ("both %<unsigned%> and %<_Decimal64%> in "
8943 "declaration specifiers"));
8944 else if (specs
->typespec_word
== cts_dfloat128
)
8946 ("both %<unsigned%> and %<_Decimal128%> in "
8947 "declaration specifiers"));
8949 specs
->unsigned_p
= true;
8952 dupe
= specs
->complex_p
;
8953 if (!flag_isoc99
&& !in_system_header
)
8954 pedwarn (loc
, OPT_pedantic
,
8955 "ISO C90 does not support complex types");
8956 if (specs
->typespec_word
== cts_void
)
8958 ("both %<complex%> and %<void%> in "
8959 "declaration specifiers"));
8960 else if (specs
->typespec_word
== cts_bool
)
8962 ("both %<complex%> and %<_Bool%> in "
8963 "declaration specifiers"));
8964 else if (specs
->typespec_word
== cts_dfloat32
)
8966 ("both %<complex%> and %<_Decimal32%> in "
8967 "declaration specifiers"));
8968 else if (specs
->typespec_word
== cts_dfloat64
)
8970 ("both %<complex%> and %<_Decimal64%> in "
8971 "declaration specifiers"));
8972 else if (specs
->typespec_word
== cts_dfloat128
)
8974 ("both %<complex%> and %<_Decimal128%> in "
8975 "declaration specifiers"));
8976 else if (specs
->typespec_word
== cts_fract
)
8978 ("both %<complex%> and %<_Fract%> in "
8979 "declaration specifiers"));
8980 else if (specs
->typespec_word
== cts_accum
)
8982 ("both %<complex%> and %<_Accum%> in "
8983 "declaration specifiers"));
8984 else if (specs
->saturating_p
)
8986 ("both %<complex%> and %<_Sat%> in "
8987 "declaration specifiers"));
8989 specs
->complex_p
= true;
8992 dupe
= specs
->saturating_p
;
8993 pedwarn (loc
, OPT_pedantic
,
8994 "ISO C does not support saturating types");
8995 if (specs
->typespec_word
== cts_int128
)
8998 ("both %<_Sat%> and %<__int128%> in "
8999 "declaration specifiers"));
9001 else if (specs
->typespec_word
== cts_void
)
9003 ("both %<_Sat%> and %<void%> in "
9004 "declaration specifiers"));
9005 else if (specs
->typespec_word
== cts_bool
)
9007 ("both %<_Sat%> and %<_Bool%> in "
9008 "declaration specifiers"));
9009 else if (specs
->typespec_word
== cts_char
)
9011 ("both %<_Sat%> and %<char%> in "
9012 "declaration specifiers"));
9013 else if (specs
->typespec_word
== cts_int
)
9015 ("both %<_Sat%> and %<int%> in "
9016 "declaration specifiers"));
9017 else if (specs
->typespec_word
== cts_float
)
9019 ("both %<_Sat%> and %<float%> in "
9020 "declaration specifiers"));
9021 else if (specs
->typespec_word
== cts_double
)
9023 ("both %<_Sat%> and %<double%> in "
9024 "declaration specifiers"));
9025 else if (specs
->typespec_word
== cts_dfloat32
)
9027 ("both %<_Sat%> and %<_Decimal32%> in "
9028 "declaration specifiers"));
9029 else if (specs
->typespec_word
== cts_dfloat64
)
9031 ("both %<_Sat%> and %<_Decimal64%> in "
9032 "declaration specifiers"));
9033 else if (specs
->typespec_word
== cts_dfloat128
)
9035 ("both %<_Sat%> and %<_Decimal128%> in "
9036 "declaration specifiers"));
9037 else if (specs
->complex_p
)
9039 ("both %<_Sat%> and %<complex%> in "
9040 "declaration specifiers"));
9042 specs
->saturating_p
= true;
9049 error_at (loc
, "duplicate %qE", type
);
9055 /* "void", "_Bool", "char", "int", "float", "double", "_Decimal32",
9056 "__int128", "_Decimal64", "_Decimal128", "_Fract" or "_Accum". */
9057 if (specs
->typespec_word
!= cts_none
)
9060 "two or more data types in declaration specifiers");
9066 if (int128_integer_type_node
== NULL_TREE
)
9068 error_at (loc
, "%<__int128%> is not supported for this target");
9071 if (!in_system_header
)
9072 pedwarn (loc
, OPT_pedantic
,
9073 "ISO C does not support %<__int128%> type");
9077 ("both %<__int128%> and %<long%> in "
9078 "declaration specifiers"));
9079 else if (specs
->saturating_p
)
9081 ("both %<_Sat%> and %<__int128%> in "
9082 "declaration specifiers"));
9083 else if (specs
->short_p
)
9085 ("both %<__int128%> and %<short%> in "
9086 "declaration specifiers"));
9088 specs
->typespec_word
= cts_int128
;
9093 ("both %<long%> and %<void%> in "
9094 "declaration specifiers"));
9095 else if (specs
->short_p
)
9097 ("both %<short%> and %<void%> in "
9098 "declaration specifiers"));
9099 else if (specs
->signed_p
)
9101 ("both %<signed%> and %<void%> in "
9102 "declaration specifiers"));
9103 else if (specs
->unsigned_p
)
9105 ("both %<unsigned%> and %<void%> in "
9106 "declaration specifiers"));
9107 else if (specs
->complex_p
)
9109 ("both %<complex%> and %<void%> in "
9110 "declaration specifiers"));
9111 else if (specs
->saturating_p
)
9113 ("both %<_Sat%> and %<void%> in "
9114 "declaration specifiers"));
9116 specs
->typespec_word
= cts_void
;
9121 ("both %<long%> and %<_Bool%> in "
9122 "declaration specifiers"));
9123 else if (specs
->short_p
)
9125 ("both %<short%> and %<_Bool%> in "
9126 "declaration specifiers"));
9127 else if (specs
->signed_p
)
9129 ("both %<signed%> and %<_Bool%> in "
9130 "declaration specifiers"));
9131 else if (specs
->unsigned_p
)
9133 ("both %<unsigned%> and %<_Bool%> in "
9134 "declaration specifiers"));
9135 else if (specs
->complex_p
)
9137 ("both %<complex%> and %<_Bool%> in "
9138 "declaration specifiers"));
9139 else if (specs
->saturating_p
)
9141 ("both %<_Sat%> and %<_Bool%> in "
9142 "declaration specifiers"));
9144 specs
->typespec_word
= cts_bool
;
9149 ("both %<long%> and %<char%> in "
9150 "declaration specifiers"));
9151 else if (specs
->short_p
)
9153 ("both %<short%> and %<char%> in "
9154 "declaration specifiers"));
9155 else if (specs
->saturating_p
)
9157 ("both %<_Sat%> and %<char%> in "
9158 "declaration specifiers"));
9160 specs
->typespec_word
= cts_char
;
9163 if (specs
->saturating_p
)
9165 ("both %<_Sat%> and %<int%> in "
9166 "declaration specifiers"));
9168 specs
->typespec_word
= cts_int
;
9173 ("both %<long%> and %<float%> in "
9174 "declaration specifiers"));
9175 else if (specs
->short_p
)
9177 ("both %<short%> and %<float%> in "
9178 "declaration specifiers"));
9179 else if (specs
->signed_p
)
9181 ("both %<signed%> and %<float%> in "
9182 "declaration specifiers"));
9183 else if (specs
->unsigned_p
)
9185 ("both %<unsigned%> and %<float%> in "
9186 "declaration specifiers"));
9187 else if (specs
->saturating_p
)
9189 ("both %<_Sat%> and %<float%> in "
9190 "declaration specifiers"));
9192 specs
->typespec_word
= cts_float
;
9195 if (specs
->long_long_p
)
9197 ("both %<long long%> and %<double%> in "
9198 "declaration specifiers"));
9199 else if (specs
->short_p
)
9201 ("both %<short%> and %<double%> in "
9202 "declaration specifiers"));
9203 else if (specs
->signed_p
)
9205 ("both %<signed%> and %<double%> in "
9206 "declaration specifiers"));
9207 else if (specs
->unsigned_p
)
9209 ("both %<unsigned%> and %<double%> in "
9210 "declaration specifiers"));
9211 else if (specs
->saturating_p
)
9213 ("both %<_Sat%> and %<double%> in "
9214 "declaration specifiers"));
9216 specs
->typespec_word
= cts_double
;
9223 if (i
== RID_DFLOAT32
)
9225 else if (i
== RID_DFLOAT64
)
9228 str
= "_Decimal128";
9229 if (specs
->long_long_p
)
9231 ("both %<long long%> and %<%s%> in "
9232 "declaration specifiers"),
9236 ("both %<long%> and %<%s%> in "
9237 "declaration specifiers"),
9239 else if (specs
->short_p
)
9241 ("both %<short%> and %<%s%> in "
9242 "declaration specifiers"),
9244 else if (specs
->signed_p
)
9246 ("both %<signed%> and %<%s%> in "
9247 "declaration specifiers"),
9249 else if (specs
->unsigned_p
)
9251 ("both %<unsigned%> and %<%s%> in "
9252 "declaration specifiers"),
9254 else if (specs
->complex_p
)
9256 ("both %<complex%> and %<%s%> in "
9257 "declaration specifiers"),
9259 else if (specs
->saturating_p
)
9261 ("both %<_Sat%> and %<%s%> in "
9262 "declaration specifiers"),
9264 else if (i
== RID_DFLOAT32
)
9265 specs
->typespec_word
= cts_dfloat32
;
9266 else if (i
== RID_DFLOAT64
)
9267 specs
->typespec_word
= cts_dfloat64
;
9269 specs
->typespec_word
= cts_dfloat128
;
9271 if (!targetm
.decimal_float_supported_p ())
9273 ("decimal floating point not supported "
9274 "for this target"));
9275 pedwarn (loc
, OPT_pedantic
,
9276 "ISO C does not support decimal floating point");
9286 if (specs
->complex_p
)
9288 ("both %<complex%> and %<%s%> in "
9289 "declaration specifiers"),
9291 else if (i
== RID_FRACT
)
9292 specs
->typespec_word
= cts_fract
;
9294 specs
->typespec_word
= cts_accum
;
9296 if (!targetm
.fixed_point_supported_p ())
9298 "fixed-point types not supported for this target");
9299 pedwarn (loc
, OPT_pedantic
,
9300 "ISO C does not support fixed-point types");
9303 /* ObjC reserved word "id", handled below. */
9309 /* Now we have a typedef (a TYPE_DECL node), an identifier (some
9310 form of ObjC type, cases such as "int" and "long" being handled
9311 above), a TYPE (struct, union, enum and typeof specifiers) or an
9312 ERROR_MARK. In none of these cases may there have previously
9313 been any type specifiers. */
9314 if (specs
->type
|| specs
->typespec_word
!= cts_none
9315 || specs
->long_p
|| specs
->short_p
|| specs
->signed_p
9316 || specs
->unsigned_p
|| specs
->complex_p
)
9317 error_at (loc
, "two or more data types in declaration specifiers");
9318 else if (TREE_CODE (type
) == TYPE_DECL
)
9320 if (TREE_TYPE (type
) == error_mark_node
)
9321 ; /* Allow the type to default to int to avoid cascading errors. */
9324 specs
->type
= TREE_TYPE (type
);
9325 specs
->decl_attr
= DECL_ATTRIBUTES (type
);
9326 specs
->typedef_p
= true;
9327 specs
->explicit_signed_p
= C_TYPEDEF_EXPLICITLY_SIGNED (type
);
9329 /* If this typedef name is defined in a struct, then a C++
9330 lookup would return a different value. */
9332 && I_SYMBOL_BINDING (DECL_NAME (type
))->in_struct
)
9333 warning_at (loc
, OPT_Wc___compat
,
9334 "C++ lookup of %qD would return a field, not a type",
9337 /* If we are parsing a struct, record that a struct field
9339 if (warn_cxx_compat
&& struct_parse_info
!= NULL
)
9340 VEC_safe_push (tree
, heap
, struct_parse_info
->typedefs_seen
, type
);
9343 else if (TREE_CODE (type
) == IDENTIFIER_NODE
)
9345 tree t
= lookup_name (type
);
9346 if (!t
|| TREE_CODE (t
) != TYPE_DECL
)
9347 error_at (loc
, "%qE fails to be a typedef or built in type", type
);
9348 else if (TREE_TYPE (t
) == error_mark_node
)
9351 specs
->type
= TREE_TYPE (t
);
9355 if (TREE_CODE (type
) != ERROR_MARK
&& spec
.kind
== ctsk_typeof
)
9357 specs
->typedef_p
= true;
9361 specs
->expr
= build2 (COMPOUND_EXPR
, TREE_TYPE (spec
.expr
),
9362 specs
->expr
, spec
.expr
);
9364 specs
->expr
= spec
.expr
;
9365 specs
->expr_const_operands
&= spec
.expr_const_operands
;
9374 /* Add the storage class specifier or function specifier SCSPEC to the
9375 declaration specifiers SPECS, returning SPECS. */
9377 struct c_declspecs
*
9378 declspecs_add_scspec (struct c_declspecs
*specs
, tree scspec
)
9381 enum c_storage_class n
= csc_none
;
9383 specs
->declspecs_seen_p
= true;
9384 gcc_assert (TREE_CODE (scspec
) == IDENTIFIER_NODE
9385 && C_IS_RESERVED_WORD (scspec
));
9386 i
= C_RID_CODE (scspec
);
9387 if (specs
->non_sc_seen_p
)
9388 warning (OPT_Wold_style_declaration
,
9389 "%qE is not at beginning of declaration", scspec
);
9393 /* C99 permits duplicate inline. Although of doubtful utility,
9394 it seems simplest to permit it in gnu89 mode as well, as
9395 there is also little utility in maintaining this as a
9396 difference between gnu89 and C99 inline. */
9398 specs
->inline_p
= true;
9401 dupe
= specs
->thread_p
;
9402 if (specs
->storage_class
== csc_auto
)
9403 error ("%<__thread%> used with %<auto%>");
9404 else if (specs
->storage_class
== csc_register
)
9405 error ("%<__thread%> used with %<register%>");
9406 else if (specs
->storage_class
== csc_typedef
)
9407 error ("%<__thread%> used with %<typedef%>");
9409 specs
->thread_p
= true;
9416 /* Diagnose "__thread extern". */
9417 if (specs
->thread_p
)
9418 error ("%<__thread%> before %<extern%>");
9425 /* Diagnose "__thread static". */
9426 if (specs
->thread_p
)
9427 error ("%<__thread%> before %<static%>");
9435 if (n
!= csc_none
&& n
== specs
->storage_class
)
9438 error ("duplicate %qE", scspec
);
9441 if (specs
->storage_class
!= csc_none
&& n
!= specs
->storage_class
)
9443 error ("multiple storage classes in declaration specifiers");
9447 specs
->storage_class
= n
;
9448 if (n
!= csc_extern
&& n
!= csc_static
&& specs
->thread_p
)
9450 error ("%<__thread%> used with %qE", scspec
);
9451 specs
->thread_p
= false;
9458 /* Add the attributes ATTRS to the declaration specifiers SPECS,
9461 struct c_declspecs
*
9462 declspecs_add_attrs (struct c_declspecs
*specs
, tree attrs
)
9464 specs
->attrs
= chainon (attrs
, specs
->attrs
);
9465 specs
->declspecs_seen_p
= true;
9469 /* Combine "long", "short", "signed", "unsigned" and "_Complex" type
9470 specifiers with any other type specifier to determine the resulting
9471 type. This is where ISO C checks on complex types are made, since
9472 "_Complex long" is a prefix of the valid ISO C type "_Complex long
9475 struct c_declspecs
*
9476 finish_declspecs (struct c_declspecs
*specs
)
9478 /* If a type was specified as a whole, we have no modifiers and are
9480 if (specs
->type
!= NULL_TREE
)
9482 gcc_assert (!specs
->long_p
&& !specs
->long_long_p
&& !specs
->short_p
9483 && !specs
->signed_p
&& !specs
->unsigned_p
9484 && !specs
->complex_p
);
9486 /* Set a dummy type. */
9487 if (TREE_CODE (specs
->type
) == ERROR_MARK
)
9488 specs
->type
= integer_type_node
;
9492 /* If none of "void", "_Bool", "char", "int", "float" or "double"
9493 has been specified, treat it as "int" unless "_Complex" is
9494 present and there are no other specifiers. If we just have
9495 "_Complex", it is equivalent to "_Complex double", but e.g.
9496 "_Complex short" is equivalent to "_Complex short int". */
9497 if (specs
->typespec_word
== cts_none
)
9499 if (specs
->saturating_p
)
9501 error ("%<_Sat%> is used without %<_Fract%> or %<_Accum%>");
9502 if (!targetm
.fixed_point_supported_p ())
9503 error ("fixed-point types not supported for this target");
9504 specs
->typespec_word
= cts_fract
;
9506 else if (specs
->long_p
|| specs
->short_p
9507 || specs
->signed_p
|| specs
->unsigned_p
)
9509 specs
->typespec_word
= cts_int
;
9511 else if (specs
->complex_p
)
9513 specs
->typespec_word
= cts_double
;
9514 pedwarn (input_location
, OPT_pedantic
,
9515 "ISO C does not support plain %<complex%> meaning "
9516 "%<double complex%>");
9520 specs
->typespec_word
= cts_int
;
9521 specs
->default_int_p
= true;
9522 /* We don't diagnose this here because grokdeclarator will
9523 give more specific diagnostics according to whether it is
9524 a function definition. */
9528 /* If "signed" was specified, record this to distinguish "int" and
9529 "signed int" in the case of a bit-field with
9530 -funsigned-bitfields. */
9531 specs
->explicit_signed_p
= specs
->signed_p
;
9533 /* Now compute the actual type. */
9534 switch (specs
->typespec_word
)
9537 gcc_assert (!specs
->long_p
&& !specs
->short_p
9538 && !specs
->signed_p
&& !specs
->unsigned_p
9539 && !specs
->complex_p
);
9540 specs
->type
= void_type_node
;
9543 gcc_assert (!specs
->long_p
&& !specs
->short_p
9544 && !specs
->signed_p
&& !specs
->unsigned_p
9545 && !specs
->complex_p
);
9546 specs
->type
= boolean_type_node
;
9549 gcc_assert (!specs
->long_p
&& !specs
->short_p
);
9550 gcc_assert (!(specs
->signed_p
&& specs
->unsigned_p
));
9551 if (specs
->signed_p
)
9552 specs
->type
= signed_char_type_node
;
9553 else if (specs
->unsigned_p
)
9554 specs
->type
= unsigned_char_type_node
;
9556 specs
->type
= char_type_node
;
9557 if (specs
->complex_p
)
9559 pedwarn (input_location
, OPT_pedantic
,
9560 "ISO C does not support complex integer types");
9561 specs
->type
= build_complex_type (specs
->type
);
9565 gcc_assert (!specs
->long_p
&& !specs
->short_p
&& !specs
->long_long_p
);
9566 gcc_assert (!(specs
->signed_p
&& specs
->unsigned_p
));
9567 specs
->type
= (specs
->unsigned_p
9568 ? int128_unsigned_type_node
9569 : int128_integer_type_node
);
9570 if (specs
->complex_p
)
9572 pedwarn (input_location
, OPT_pedantic
,
9573 "ISO C does not support complex integer types");
9574 specs
->type
= build_complex_type (specs
->type
);
9578 gcc_assert (!(specs
->long_p
&& specs
->short_p
));
9579 gcc_assert (!(specs
->signed_p
&& specs
->unsigned_p
));
9580 if (specs
->long_long_p
)
9581 specs
->type
= (specs
->unsigned_p
9582 ? long_long_unsigned_type_node
9583 : long_long_integer_type_node
);
9584 else if (specs
->long_p
)
9585 specs
->type
= (specs
->unsigned_p
9586 ? long_unsigned_type_node
9587 : long_integer_type_node
);
9588 else if (specs
->short_p
)
9589 specs
->type
= (specs
->unsigned_p
9590 ? short_unsigned_type_node
9591 : short_integer_type_node
);
9593 specs
->type
= (specs
->unsigned_p
9594 ? unsigned_type_node
9595 : integer_type_node
);
9596 if (specs
->complex_p
)
9598 pedwarn (input_location
, OPT_pedantic
,
9599 "ISO C does not support complex integer types");
9600 specs
->type
= build_complex_type (specs
->type
);
9604 gcc_assert (!specs
->long_p
&& !specs
->short_p
9605 && !specs
->signed_p
&& !specs
->unsigned_p
);
9606 specs
->type
= (specs
->complex_p
9607 ? complex_float_type_node
9611 gcc_assert (!specs
->long_long_p
&& !specs
->short_p
9612 && !specs
->signed_p
&& !specs
->unsigned_p
);
9615 specs
->type
= (specs
->complex_p
9616 ? complex_long_double_type_node
9617 : long_double_type_node
);
9621 specs
->type
= (specs
->complex_p
9622 ? complex_double_type_node
9623 : double_type_node
);
9629 gcc_assert (!specs
->long_p
&& !specs
->long_long_p
&& !specs
->short_p
9630 && !specs
->signed_p
&& !specs
->unsigned_p
&& !specs
->complex_p
);
9631 if (specs
->typespec_word
== cts_dfloat32
)
9632 specs
->type
= dfloat32_type_node
;
9633 else if (specs
->typespec_word
== cts_dfloat64
)
9634 specs
->type
= dfloat64_type_node
;
9636 specs
->type
= dfloat128_type_node
;
9639 gcc_assert (!specs
->complex_p
);
9640 if (!targetm
.fixed_point_supported_p ())
9641 specs
->type
= integer_type_node
;
9642 else if (specs
->saturating_p
)
9644 if (specs
->long_long_p
)
9645 specs
->type
= specs
->unsigned_p
9646 ? sat_unsigned_long_long_fract_type_node
9647 : sat_long_long_fract_type_node
;
9648 else if (specs
->long_p
)
9649 specs
->type
= specs
->unsigned_p
9650 ? sat_unsigned_long_fract_type_node
9651 : sat_long_fract_type_node
;
9652 else if (specs
->short_p
)
9653 specs
->type
= specs
->unsigned_p
9654 ? sat_unsigned_short_fract_type_node
9655 : sat_short_fract_type_node
;
9657 specs
->type
= specs
->unsigned_p
9658 ? sat_unsigned_fract_type_node
9659 : sat_fract_type_node
;
9663 if (specs
->long_long_p
)
9664 specs
->type
= specs
->unsigned_p
9665 ? unsigned_long_long_fract_type_node
9666 : long_long_fract_type_node
;
9667 else if (specs
->long_p
)
9668 specs
->type
= specs
->unsigned_p
9669 ? unsigned_long_fract_type_node
9670 : long_fract_type_node
;
9671 else if (specs
->short_p
)
9672 specs
->type
= specs
->unsigned_p
9673 ? unsigned_short_fract_type_node
9674 : short_fract_type_node
;
9676 specs
->type
= specs
->unsigned_p
9677 ? unsigned_fract_type_node
9682 gcc_assert (!specs
->complex_p
);
9683 if (!targetm
.fixed_point_supported_p ())
9684 specs
->type
= integer_type_node
;
9685 else if (specs
->saturating_p
)
9687 if (specs
->long_long_p
)
9688 specs
->type
= specs
->unsigned_p
9689 ? sat_unsigned_long_long_accum_type_node
9690 : sat_long_long_accum_type_node
;
9691 else if (specs
->long_p
)
9692 specs
->type
= specs
->unsigned_p
9693 ? sat_unsigned_long_accum_type_node
9694 : sat_long_accum_type_node
;
9695 else if (specs
->short_p
)
9696 specs
->type
= specs
->unsigned_p
9697 ? sat_unsigned_short_accum_type_node
9698 : sat_short_accum_type_node
;
9700 specs
->type
= specs
->unsigned_p
9701 ? sat_unsigned_accum_type_node
9702 : sat_accum_type_node
;
9706 if (specs
->long_long_p
)
9707 specs
->type
= specs
->unsigned_p
9708 ? unsigned_long_long_accum_type_node
9709 : long_long_accum_type_node
;
9710 else if (specs
->long_p
)
9711 specs
->type
= specs
->unsigned_p
9712 ? unsigned_long_accum_type_node
9713 : long_accum_type_node
;
9714 else if (specs
->short_p
)
9715 specs
->type
= specs
->unsigned_p
9716 ? unsigned_short_accum_type_node
9717 : short_accum_type_node
;
9719 specs
->type
= specs
->unsigned_p
9720 ? unsigned_accum_type_node
9731 /* A subroutine of c_write_global_declarations. Perform final processing
9732 on one file scope's declarations (or the external scope's declarations),
9736 c_write_global_declarations_1 (tree globals
)
9741 /* Process the decls in the order they were written. */
9742 for (decl
= globals
; decl
; decl
= DECL_CHAIN (decl
))
9744 /* Check for used but undefined static functions using the C
9745 standard's definition of "used", and set TREE_NO_WARNING so
9746 that check_global_declarations doesn't repeat the check. */
9747 if (TREE_CODE (decl
) == FUNCTION_DECL
9748 && DECL_INITIAL (decl
) == 0
9749 && DECL_EXTERNAL (decl
)
9750 && !TREE_PUBLIC (decl
)
9751 && C_DECL_USED (decl
))
9753 pedwarn (input_location
, 0, "%q+F used but never defined", decl
);
9754 TREE_NO_WARNING (decl
) = 1;
9757 wrapup_global_declaration_1 (decl
);
9763 for (decl
= globals
; decl
; decl
= DECL_CHAIN (decl
))
9764 reconsider
|= wrapup_global_declaration_2 (decl
);
9768 for (decl
= globals
; decl
; decl
= DECL_CHAIN (decl
))
9769 check_global_declaration_1 (decl
);
9772 /* A subroutine of c_write_global_declarations Emit debug information for each
9773 of the declarations in GLOBALS. */
9776 c_write_global_declarations_2 (tree globals
)
9780 for (decl
= globals
; decl
; decl
= DECL_CHAIN (decl
))
9781 debug_hooks
->global_decl (decl
);
9784 /* Callback to collect a source_ref from a DECL. */
9787 collect_source_ref_cb (tree decl
)
9789 if (!DECL_IS_BUILTIN (decl
))
9790 collect_source_ref (LOCATION_FILE (decl_sloc (decl
, false)));
9793 /* Collect all references relevant to SOURCE_FILE. */
9796 collect_all_refs (const char *source_file
)
9801 FOR_EACH_VEC_ELT (tree
, all_translation_units
, i
, t
)
9802 collect_ada_nodes (BLOCK_VARS (DECL_INITIAL (t
)), source_file
);
9805 /* Iterate over all global declarations and call CALLBACK. */
9808 for_each_global_decl (void (*callback
) (tree decl
))
9815 FOR_EACH_VEC_ELT (tree
, all_translation_units
, i
, t
)
9817 decls
= DECL_INITIAL (t
);
9818 for (decl
= BLOCK_VARS (decls
); decl
; decl
= TREE_CHAIN (decl
))
9823 /* Preserve the external declarations scope across a garbage collect. */
9824 static GTY(()) tree ext_block
;
9827 c_write_global_declarations (void)
9832 /* We don't want to do this if generating a PCH. */
9836 /* Do the Objective-C stuff. This is where all the Objective-C
9837 module stuff gets generated (symtab, class/protocol/selector
9839 if (c_dialect_objc ())
9840 objc_write_global_declarations ();
9842 /* Close the external scope. */
9843 ext_block
= pop_scope ();
9845 gcc_assert (!current_scope
);
9847 /* Handle -fdump-ada-spec[-slim]. */
9848 if (dump_enabled_p (TDI_ada
))
9850 /* Build a table of files to generate specs for */
9851 if (get_dump_file_info (TDI_ada
)->flags
& TDF_SLIM
)
9852 collect_source_ref (main_input_filename
);
9854 for_each_global_decl (collect_source_ref_cb
);
9856 dump_ada_specs (collect_all_refs
, NULL
);
9861 tree tmp
= BLOCK_VARS (ext_block
);
9863 FILE * stream
= dump_begin (TDI_tu
, &flags
);
9866 dump_node (tmp
, flags
& ~TDF_SLIM
, stream
);
9867 dump_end (TDI_tu
, stream
);
9871 /* Process all file scopes in this compilation, and the external_scope,
9872 through wrapup_global_declarations and check_global_declarations. */
9873 FOR_EACH_VEC_ELT (tree
, all_translation_units
, i
, t
)
9874 c_write_global_declarations_1 (BLOCK_VARS (DECL_INITIAL (t
)));
9875 c_write_global_declarations_1 (BLOCK_VARS (ext_block
));
9877 /* We're done parsing; proceed to optimize and emit assembly.
9878 FIXME: shouldn't be the front end's responsibility to call this. */
9879 cgraph_finalize_compilation_unit ();
9881 /* After cgraph has had a chance to emit everything that's going to
9882 be emitted, output debug information for globals. */
9885 timevar_push (TV_SYMOUT
);
9886 FOR_EACH_VEC_ELT (tree
, all_translation_units
, i
, t
)
9887 c_write_global_declarations_2 (BLOCK_VARS (DECL_INITIAL (t
)));
9888 c_write_global_declarations_2 (BLOCK_VARS (ext_block
));
9889 timevar_pop (TV_SYMOUT
);
9895 /* Register reserved keyword WORD as qualifier for address space AS. */
9898 c_register_addr_space (const char *word
, addr_space_t as
)
9900 int rid
= RID_FIRST_ADDR_SPACE
+ as
;
9903 /* Address space qualifiers are only supported
9904 in C with GNU extensions enabled. */
9905 if (c_dialect_objc () || flag_no_asm
)
9908 id
= get_identifier (word
);
9909 C_SET_RID_CODE (id
, rid
);
9910 C_IS_RESERVED_WORD (id
) = 1;
9911 ridpointers
[rid
] = id
;
9914 #include "gt-c-decl.h"