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, 2011, 2012
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"
47 #include "c-family/c-common.h"
48 #include "c-family/c-objc.h"
49 #include "c-family/c-pragma.h"
51 #include "langhooks.h"
52 #include "tree-iterator.h"
53 #include "diagnostic-core.h"
57 #include "langhooks-def.h"
58 #include "pointer-set.h"
60 #include "c-family/c-ada-spec.h"
62 /* In grokdeclarator, distinguish syntactic contexts of declarators. */
64 { NORMAL
, /* Ordinary declaration */
65 FUNCDEF
, /* Function definition */
66 PARM
, /* Declaration of parm before function body */
67 FIELD
, /* Declaration inside struct or union */
68 TYPENAME
}; /* Typename (inside cast or sizeof) */
70 /* States indicating how grokdeclarator() should handle declspecs marked
71 with __attribute__((deprecated)). An object declared as
72 __attribute__((deprecated)) suppresses warnings of uses of other
75 enum deprecated_states
{
81 /* Nonzero if we have seen an invalid cross reference
82 to a struct, union, or enum, but not yet printed the message. */
83 tree pending_invalid_xref
;
85 /* File and line to appear in the eventual error message. */
86 location_t pending_invalid_xref_location
;
88 /* The file and line that the prototype came from if this is an
89 old-style definition; used for diagnostics in
90 store_parm_decls_oldstyle. */
92 static location_t current_function_prototype_locus
;
94 /* Whether this prototype was built-in. */
96 static bool current_function_prototype_built_in
;
98 /* The argument type information of this prototype. */
100 static tree current_function_prototype_arg_types
;
102 /* The argument information structure for the function currently being
105 static struct c_arg_info
*current_function_arg_info
;
107 /* The obstack on which parser and related data structures, which are
108 not live beyond their top-level declaration or definition, are
110 struct obstack parser_obstack
;
112 /* The current statement tree. */
114 static GTY(()) struct stmt_tree_s c_stmt_tree
;
116 /* State saving variables. */
120 /* A list of decls to be made automatically visible in each file scope. */
121 static GTY(()) tree visible_builtins
;
123 /* Set to 0 at beginning of a function definition, set to 1 if
124 a return statement that specifies a return value is seen. */
126 int current_function_returns_value
;
128 /* Set to 0 at beginning of a function definition, set to 1 if
129 a return statement with no argument is seen. */
131 int current_function_returns_null
;
133 /* Set to 0 at beginning of a function definition, set to 1 if
134 a call to a noreturn function is seen. */
136 int current_function_returns_abnormally
;
138 /* Set to nonzero by `grokdeclarator' for a function
139 whose return type is defaulted, if warnings for this are desired. */
141 static int warn_about_return_type
;
143 /* Nonzero when the current toplevel function contains a declaration
144 of a nested function which is never defined. */
146 static bool undef_nested_function
;
148 /* Mode used to build pointers (VOIDmode means ptr_mode). */
150 enum machine_mode c_default_pointer_mode
= VOIDmode
;
153 /* Each c_binding structure describes one binding of an identifier to
154 a decl. All the decls in a scope - irrespective of namespace - are
155 chained together by the ->prev field, which (as the name implies)
156 runs in reverse order. All the decls in a given namespace bound to
157 a given identifier are chained by the ->shadowed field, which runs
158 from inner to outer scopes.
160 The ->decl field usually points to a DECL node, but there are two
161 exceptions. In the namespace of type tags, the bound entity is a
162 RECORD_TYPE, UNION_TYPE, or ENUMERAL_TYPE node. If an undeclared
163 identifier is encountered, it is bound to error_mark_node to
164 suppress further errors about that identifier in the current
167 The ->u.type field stores the type of the declaration in this scope;
168 if NULL, the type is the type of the ->decl field. This is only of
169 relevance for objects with external or internal linkage which may
170 be redeclared in inner scopes, forming composite types that only
171 persist for the duration of those scopes. In the external scope,
172 this stores the composite of all the types declared for this
173 object, visible or not. The ->inner_comp field (used only at file
174 scope) stores whether an incomplete array type at file scope was
175 completed at an inner scope to an array size other than 1.
177 The ->u.label field is used for labels. It points to a structure
178 which stores additional information used for warnings.
180 The depth field is copied from the scope structure that holds this
181 decl. It is used to preserve the proper ordering of the ->shadowed
182 field (see bind()) and also for a handful of special-case checks.
183 Finally, the invisible bit is true for a decl which should be
184 ignored for purposes of normal name lookup, and the nested bit is
185 true for a decl that's been bound a second time in an inner scope;
186 in all such cases, the binding in the outer scope will have its
187 invisible bit true. */
189 struct GTY((chain_next ("%h.prev"))) c_binding
{
190 union GTY(()) { /* first so GTY desc can use decl */
191 tree
GTY((tag ("0"))) type
; /* the type in this scope */
192 struct c_label_vars
* GTY((tag ("1"))) label
; /* for warnings */
193 } GTY((desc ("TREE_CODE (%0.decl) == LABEL_DECL"))) u
;
194 tree decl
; /* the decl bound */
195 tree id
; /* the identifier it's bound to */
196 struct c_binding
*prev
; /* the previous decl in this scope */
197 struct c_binding
*shadowed
; /* the innermost decl shadowed by this one */
198 unsigned int depth
: 28; /* depth of this scope */
199 BOOL_BITFIELD invisible
: 1; /* normal lookup should ignore this binding */
200 BOOL_BITFIELD nested
: 1; /* do not set DECL_CONTEXT when popping */
201 BOOL_BITFIELD inner_comp
: 1; /* incomplete array completed in inner scope */
202 BOOL_BITFIELD in_struct
: 1; /* currently defined as struct field */
203 location_t locus
; /* location for nested bindings */
205 #define B_IN_SCOPE(b1, b2) ((b1)->depth == (b2)->depth)
206 #define B_IN_CURRENT_SCOPE(b) ((b)->depth == current_scope->depth)
207 #define B_IN_FILE_SCOPE(b) ((b)->depth == 1 /*file_scope->depth*/)
208 #define B_IN_EXTERNAL_SCOPE(b) ((b)->depth == 0 /*external_scope->depth*/)
210 #define I_SYMBOL_BINDING(node) \
211 (((struct lang_identifier *) IDENTIFIER_NODE_CHECK(node))->symbol_binding)
212 #define I_SYMBOL_DECL(node) \
213 (I_SYMBOL_BINDING(node) ? I_SYMBOL_BINDING(node)->decl : 0)
215 #define I_TAG_BINDING(node) \
216 (((struct lang_identifier *) IDENTIFIER_NODE_CHECK(node))->tag_binding)
217 #define I_TAG_DECL(node) \
218 (I_TAG_BINDING(node) ? I_TAG_BINDING(node)->decl : 0)
220 #define I_LABEL_BINDING(node) \
221 (((struct lang_identifier *) IDENTIFIER_NODE_CHECK(node))->label_binding)
222 #define I_LABEL_DECL(node) \
223 (I_LABEL_BINDING(node) ? I_LABEL_BINDING(node)->decl : 0)
225 /* Each C symbol points to three linked lists of c_binding structures.
226 These describe the values of the identifier in the three different
227 namespaces defined by the language. */
229 struct GTY(()) lang_identifier
{
230 struct c_common_identifier common_id
;
231 struct c_binding
*symbol_binding
; /* vars, funcs, constants, typedefs */
232 struct c_binding
*tag_binding
; /* struct/union/enum tags */
233 struct c_binding
*label_binding
; /* labels */
236 /* Validate c-lang.c's assumptions. */
237 extern char C_SIZEOF_STRUCT_LANG_IDENTIFIER_isnt_accurate
238 [(sizeof(struct lang_identifier
) == C_SIZEOF_STRUCT_LANG_IDENTIFIER
) ? 1 : -1];
240 /* The resulting tree type. */
242 union GTY((desc ("TREE_CODE (&%h.generic) == IDENTIFIER_NODE"),
243 chain_next ("(union lang_tree_node *) c_tree_chain_next (&%h.generic)"))) lang_tree_node
245 union tree_node
GTY ((tag ("0"),
246 desc ("tree_node_structure (&%h)")))
248 struct lang_identifier
GTY ((tag ("1"))) identifier
;
251 /* Track bindings and other things that matter for goto warnings. For
252 efficiency, we do not gather all the decls at the point of
253 definition. Instead, we point into the bindings structure. As
254 scopes are popped, we update these structures and gather the decls
255 that matter at that time. */
257 struct GTY(()) c_spot_bindings
{
258 /* The currently open scope which holds bindings defined when the
259 label was defined or the goto statement was found. */
260 struct c_scope
*scope
;
261 /* The bindings in the scope field which were defined at the point
262 of the label or goto. This lets us look at older or newer
263 bindings in the scope, as appropriate. */
264 struct c_binding
*bindings_in_scope
;
265 /* The number of statement expressions that have started since this
266 label or goto statement was defined. This is zero if we are at
267 the same statement expression level. It is positive if we are in
268 a statement expression started since this spot. It is negative
269 if this spot was in a statement expression and we have left
272 /* Whether we started in a statement expression but are no longer in
273 it. This is set to true if stmt_exprs ever goes negative. */
277 /* This structure is used to keep track of bindings seen when a goto
278 statement is defined. This is only used if we see the goto
279 statement before we see the label. */
281 struct GTY(()) c_goto_bindings
{
282 /* The location of the goto statement. */
284 /* The bindings of the goto statement. */
285 struct c_spot_bindings goto_bindings
;
288 typedef struct c_goto_bindings
*c_goto_bindings_p
;
289 DEF_VEC_P(c_goto_bindings_p
);
290 DEF_VEC_ALLOC_P(c_goto_bindings_p
,gc
);
292 /* The additional information we keep track of for a label binding.
293 These fields are updated as scopes are popped. */
295 struct GTY(()) c_label_vars
{
296 /* The shadowed c_label_vars, when one label shadows another (which
297 can only happen using a __label__ declaration). */
298 struct c_label_vars
*shadowed
;
299 /* The bindings when the label was defined. */
300 struct c_spot_bindings label_bindings
;
301 /* A list of decls that we care about: decls about which we should
302 warn if a goto branches to this label from later in the function.
303 Decls are added to this list as scopes are popped. We only add
304 the decls that matter. */
305 VEC(tree
,gc
) *decls_in_scope
;
306 /* A list of goto statements to this label. This is only used for
307 goto statements seen before the label was defined, so that we can
308 issue appropriate warnings for them. */
309 VEC(c_goto_bindings_p
,gc
) *gotos
;
312 /* Each c_scope structure describes the complete contents of one
313 scope. Four scopes are distinguished specially: the innermost or
314 current scope, the innermost function scope, the file scope (always
315 the second to outermost) and the outermost or external scope.
317 Most declarations are recorded in the current scope.
319 All normal label declarations are recorded in the innermost
320 function scope, as are bindings of undeclared identifiers to
321 error_mark_node. (GCC permits nested functions as an extension,
322 hence the 'innermost' qualifier.) Explicitly declared labels
323 (using the __label__ extension) appear in the current scope.
325 Being in the file scope (current_scope == file_scope) causes
326 special behavior in several places below. Also, under some
327 conditions the Objective-C front end records declarations in the
328 file scope even though that isn't the current scope.
330 All declarations with external linkage are recorded in the external
331 scope, even if they aren't visible there; this models the fact that
332 such declarations are visible to the entire program, and (with a
333 bit of cleverness, see pushdecl) allows diagnosis of some violations
334 of C99 6.2.2p7 and 6.2.7p2:
336 If, within the same translation unit, the same identifier appears
337 with both internal and external linkage, the behavior is
340 All declarations that refer to the same object or function shall
341 have compatible type; otherwise, the behavior is undefined.
343 Initially only the built-in declarations, which describe compiler
344 intrinsic functions plus a subset of the standard library, are in
347 The order of the blocks list matters, and it is frequently appended
348 to. To avoid having to walk all the way to the end of the list on
349 each insertion, or reverse the list later, we maintain a pointer to
350 the last list entry. (FIXME: It should be feasible to use a reversed
353 The bindings list is strictly in reverse order of declarations;
354 pop_scope relies on this. */
357 struct GTY((chain_next ("%h.outer"))) c_scope
{
358 /* The scope containing this one. */
359 struct c_scope
*outer
;
361 /* The next outermost function scope. */
362 struct c_scope
*outer_function
;
364 /* All bindings in this scope. */
365 struct c_binding
*bindings
;
367 /* For each scope (except the global one), a chain of BLOCK nodes
368 for all the scopes that were entered and exited one level down. */
372 /* The depth of this scope. Used to keep the ->shadowed chain of
373 bindings sorted innermost to outermost. */
374 unsigned int depth
: 28;
376 /* True if we are currently filling this scope with parameter
378 BOOL_BITFIELD parm_flag
: 1;
380 /* True if we saw [*] in this scope. Used to give an error messages
381 if these appears in a function definition. */
382 BOOL_BITFIELD had_vla_unspec
: 1;
384 /* True if we already complained about forward parameter decls
385 in this scope. This prevents double warnings on
386 foo (int a; int b; ...) */
387 BOOL_BITFIELD warned_forward_parm_decls
: 1;
389 /* True if this is the outermost block scope of a function body.
390 This scope contains the parameters, the local variables declared
391 in the outermost block, and all the labels (except those in
392 nested functions, or declared at block scope with __label__). */
393 BOOL_BITFIELD function_body
: 1;
395 /* True means make a BLOCK for this scope no matter what. */
396 BOOL_BITFIELD keep
: 1;
398 /* True means that an unsuffixed float constant is _Decimal64. */
399 BOOL_BITFIELD float_const_decimal64
: 1;
401 /* True if this scope has any label bindings. This is used to speed
402 up searching for labels when popping scopes, particularly since
403 labels are normally only found at function scope. */
404 BOOL_BITFIELD has_label_bindings
: 1;
406 /* True if we should issue a warning if a goto statement crosses any
407 of the bindings. We still need to check the list of bindings to
408 find the specific ones we need to warn about. This is true if
409 decl_jump_unsafe would return true for any of the bindings. This
410 is used to avoid looping over all the bindings unnecessarily. */
411 BOOL_BITFIELD has_jump_unsafe_decl
: 1;
414 /* The scope currently in effect. */
416 static GTY(()) struct c_scope
*current_scope
;
418 /* The innermost function scope. Ordinary (not explicitly declared)
419 labels, bindings to error_mark_node, and the lazily-created
420 bindings of __func__ and its friends get this scope. */
422 static GTY(()) struct c_scope
*current_function_scope
;
424 /* The C file scope. This is reset for each input translation unit. */
426 static GTY(()) struct c_scope
*file_scope
;
428 /* The outermost scope. This is used for all declarations with
429 external linkage, and only these, hence the name. */
431 static GTY(()) struct c_scope
*external_scope
;
433 /* A chain of c_scope structures awaiting reuse. */
435 static GTY((deletable
)) struct c_scope
*scope_freelist
;
437 /* A chain of c_binding structures awaiting reuse. */
439 static GTY((deletable
)) struct c_binding
*binding_freelist
;
441 /* Append VAR to LIST in scope SCOPE. */
442 #define SCOPE_LIST_APPEND(scope, list, decl) do { \
443 struct c_scope *s_ = (scope); \
445 if (s_->list##_last) \
446 BLOCK_CHAIN (s_->list##_last) = d_; \
449 s_->list##_last = d_; \
452 /* Concatenate FROM in scope FSCOPE onto TO in scope TSCOPE. */
453 #define SCOPE_LIST_CONCAT(tscope, to, fscope, from) do { \
454 struct c_scope *t_ = (tscope); \
455 struct c_scope *f_ = (fscope); \
457 BLOCK_CHAIN (t_->to##_last) = f_->from; \
460 t_->to##_last = f_->from##_last; \
463 /* A c_inline_static structure stores details of a static identifier
464 referenced in a definition of a function that may be an inline
465 definition if no subsequent declaration of that function uses
466 "extern" or does not use "inline". */
468 struct GTY((chain_next ("%h.next"))) c_inline_static
{
469 /* The location for a diagnostic. */
472 /* The function that may be an inline definition. */
475 /* The object or function referenced. */
478 /* What sort of reference this is. */
479 enum c_inline_static_type type
;
481 /* The next such structure or NULL. */
482 struct c_inline_static
*next
;
485 /* List of static identifiers used or referenced in functions that may
486 be inline definitions. */
487 static GTY(()) struct c_inline_static
*c_inline_statics
;
489 /* True means unconditionally make a BLOCK for the next scope pushed. */
491 static bool keep_next_level_flag
;
493 /* True means the next call to push_scope will be the outermost scope
494 of a function body, so do not push a new scope, merely cease
495 expecting parameter decls. */
497 static bool next_is_function_body
;
499 /* A VEC of pointers to c_binding structures. */
501 typedef struct c_binding
*c_binding_ptr
;
502 DEF_VEC_P(c_binding_ptr
);
503 DEF_VEC_ALLOC_P(c_binding_ptr
,heap
);
505 /* Information that we keep for a struct or union while it is being
508 struct c_struct_parse_info
510 /* If warn_cxx_compat, a list of types defined within this
512 VEC(tree
,heap
) *struct_types
;
513 /* If warn_cxx_compat, a list of field names which have bindings,
514 and which are defined in this struct, but which are not defined
515 in any enclosing struct. This is used to clear the in_struct
516 field of the c_bindings structure. */
517 VEC(c_binding_ptr
,heap
) *fields
;
518 /* If warn_cxx_compat, a list of typedef names used when defining
519 fields in this struct. */
520 VEC(tree
,heap
) *typedefs_seen
;
523 /* Information for the struct or union currently being parsed, or
524 NULL if not parsing a struct or union. */
525 static struct c_struct_parse_info
*struct_parse_info
;
527 /* Forward declarations. */
528 static tree
lookup_name_in_scope (tree
, struct c_scope
*);
529 static tree
c_make_fname_decl (location_t
, tree
, int);
530 static tree
grokdeclarator (const struct c_declarator
*,
531 struct c_declspecs
*,
532 enum decl_context
, bool, tree
*, tree
*, tree
*,
533 bool *, enum deprecated_states
);
534 static tree
grokparms (struct c_arg_info
*, bool);
535 static void layout_array_type (tree
);
537 /* T is a statement. Add it to the statement-tree. This is the
538 C/ObjC version--C++ has a slightly different version of this
544 enum tree_code code
= TREE_CODE (t
);
546 if (CAN_HAVE_LOCATION_P (t
) && code
!= LABEL_EXPR
)
548 if (!EXPR_HAS_LOCATION (t
))
549 SET_EXPR_LOCATION (t
, input_location
);
552 if (code
== LABEL_EXPR
|| code
== CASE_LABEL_EXPR
)
553 STATEMENT_LIST_HAS_LABEL (cur_stmt_list
) = 1;
555 /* Add T to the statement-tree. Non-side-effect statements need to be
556 recorded during statement expressions. */
557 if (!building_stmt_list_p ())
559 append_to_statement_list_force (t
, &cur_stmt_list
);
564 /* Build a pointer type using the default pointer mode. */
567 c_build_pointer_type (tree to_type
)
569 addr_space_t as
= to_type
== error_mark_node
? ADDR_SPACE_GENERIC
570 : TYPE_ADDR_SPACE (to_type
);
571 enum machine_mode pointer_mode
;
573 if (as
!= ADDR_SPACE_GENERIC
|| c_default_pointer_mode
== VOIDmode
)
574 pointer_mode
= targetm
.addr_space
.pointer_mode (as
);
576 pointer_mode
= c_default_pointer_mode
;
577 return build_pointer_type_for_mode (to_type
, pointer_mode
, false);
581 /* Return true if we will want to say something if a goto statement
585 decl_jump_unsafe (tree decl
)
587 if (error_operand_p (decl
))
590 /* Always warn about crossing variably modified types. */
591 if ((TREE_CODE (decl
) == VAR_DECL
|| TREE_CODE (decl
) == TYPE_DECL
)
592 && variably_modified_type_p (TREE_TYPE (decl
), NULL_TREE
))
595 /* Otherwise, only warn if -Wgoto-misses-init and this is an
596 initialized automatic decl. */
597 if (warn_jump_misses_init
598 && TREE_CODE (decl
) == VAR_DECL
599 && !TREE_STATIC (decl
)
600 && DECL_INITIAL (decl
) != NULL_TREE
)
608 c_print_identifier (FILE *file
, tree node
, int indent
)
610 print_node (file
, "symbol", I_SYMBOL_DECL (node
), indent
+ 4);
611 print_node (file
, "tag", I_TAG_DECL (node
), indent
+ 4);
612 print_node (file
, "label", I_LABEL_DECL (node
), indent
+ 4);
613 if (C_IS_RESERVED_WORD (node
) && C_RID_CODE (node
) != RID_CXX_COMPAT_WARN
)
615 tree rid
= ridpointers
[C_RID_CODE (node
)];
616 indent_to (file
, indent
+ 4);
617 fprintf (file
, "rid " HOST_PTR_PRINTF
" \"%s\"",
618 (void *) rid
, IDENTIFIER_POINTER (rid
));
622 /* Establish a binding between NAME, an IDENTIFIER_NODE, and DECL,
623 which may be any of several kinds of DECL or TYPE or error_mark_node,
624 in the scope SCOPE. */
626 bind (tree name
, tree decl
, struct c_scope
*scope
, bool invisible
,
627 bool nested
, location_t locus
)
629 struct c_binding
*b
, **here
;
631 if (binding_freelist
)
633 b
= binding_freelist
;
634 binding_freelist
= b
->prev
;
637 b
= ggc_alloc_c_binding ();
642 b
->depth
= scope
->depth
;
643 b
->invisible
= invisible
;
651 b
->prev
= scope
->bindings
;
654 if (decl_jump_unsafe (decl
))
655 scope
->has_jump_unsafe_decl
= 1;
660 switch (TREE_CODE (decl
))
662 case LABEL_DECL
: here
= &I_LABEL_BINDING (name
); break;
665 case RECORD_TYPE
: here
= &I_TAG_BINDING (name
); break;
671 case ERROR_MARK
: here
= &I_SYMBOL_BINDING (name
); break;
677 /* Locate the appropriate place in the chain of shadowed decls
678 to insert this binding. Normally, scope == current_scope and
679 this does nothing. */
680 while (*here
&& (*here
)->depth
> scope
->depth
)
681 here
= &(*here
)->shadowed
;
687 /* Clear the binding structure B, stick it on the binding_freelist,
688 and return the former value of b->prev. This is used by pop_scope
689 and get_parm_info to iterate destructively over all the bindings
690 from a given scope. */
691 static struct c_binding
*
692 free_binding_and_advance (struct c_binding
*b
)
694 struct c_binding
*prev
= b
->prev
;
696 memset (b
, 0, sizeof (struct c_binding
));
697 b
->prev
= binding_freelist
;
698 binding_freelist
= b
;
703 /* Bind a label. Like bind, but skip fields which aren't used for
704 labels, and add the LABEL_VARS value. */
706 bind_label (tree name
, tree label
, struct c_scope
*scope
,
707 struct c_label_vars
*label_vars
)
711 bind (name
, label
, scope
, /*invisible=*/false, /*nested=*/false,
714 scope
->has_label_bindings
= true;
717 gcc_assert (b
->decl
== label
);
718 label_vars
->shadowed
= b
->u
.label
;
719 b
->u
.label
= label_vars
;
722 /* Hook called at end of compilation to assume 1 elt
723 for a file-scope tentative array defn that wasn't complete before. */
726 c_finish_incomplete_decl (tree decl
)
728 if (TREE_CODE (decl
) == VAR_DECL
)
730 tree type
= TREE_TYPE (decl
);
731 if (type
!= error_mark_node
732 && TREE_CODE (type
) == ARRAY_TYPE
733 && !DECL_EXTERNAL (decl
)
734 && TYPE_DOMAIN (type
) == 0)
736 warning_at (DECL_SOURCE_LOCATION (decl
),
737 0, "array %q+D assumed to have one element", decl
);
739 complete_array_type (&TREE_TYPE (decl
), NULL_TREE
, true);
741 relayout_decl (decl
);
746 /* Record that inline function FUNC contains a reference (location
747 LOC) to static DECL (file-scope or function-local according to
751 record_inline_static (location_t loc
, tree func
, tree decl
,
752 enum c_inline_static_type type
)
754 struct c_inline_static
*csi
= ggc_alloc_c_inline_static ();
756 csi
->function
= func
;
757 csi
->static_decl
= decl
;
759 csi
->next
= c_inline_statics
;
760 c_inline_statics
= csi
;
763 /* Check for references to static declarations in inline functions at
764 the end of the translation unit and diagnose them if the functions
765 are still inline definitions. */
768 check_inline_statics (void)
770 struct c_inline_static
*csi
;
771 for (csi
= c_inline_statics
; csi
; csi
= csi
->next
)
773 if (DECL_EXTERNAL (csi
->function
))
777 pedwarn (csi
->location
, 0,
778 "%qD is static but used in inline function %qD "
779 "which is not static", csi
->static_decl
, csi
->function
);
782 pedwarn (csi
->location
, 0,
783 "%q+D is static but declared in inline function %qD "
784 "which is not static", csi
->static_decl
, csi
->function
);
790 c_inline_statics
= NULL
;
793 /* Fill in a c_spot_bindings structure. If DEFINING is true, set it
794 for the current state, otherwise set it to uninitialized. */
797 set_spot_bindings (struct c_spot_bindings
*p
, bool defining
)
801 p
->scope
= current_scope
;
802 p
->bindings_in_scope
= current_scope
->bindings
;
807 p
->bindings_in_scope
= NULL
;
810 p
->left_stmt_expr
= false;
813 /* Update spot bindings P as we pop out of SCOPE. Return true if we
814 should push decls for a label. */
817 update_spot_bindings (struct c_scope
*scope
, struct c_spot_bindings
*p
)
819 if (p
->scope
!= scope
)
821 /* This label or goto is defined in some other scope, or it is a
822 label which is not yet defined. There is nothing to
827 /* Adjust the spot bindings to refer to the bindings already defined
828 in the enclosing scope. */
829 p
->scope
= scope
->outer
;
830 p
->bindings_in_scope
= p
->scope
->bindings
;
835 /* The Objective-C front-end often needs to determine the current scope. */
838 objc_get_current_scope (void)
840 return current_scope
;
843 /* The following function is used only by Objective-C. It needs to live here
844 because it accesses the innards of c_scope. */
847 objc_mark_locals_volatile (void *enclosing_blk
)
849 struct c_scope
*scope
;
852 for (scope
= current_scope
;
853 scope
&& scope
!= enclosing_blk
;
854 scope
= scope
->outer
)
856 for (b
= scope
->bindings
; b
; b
= b
->prev
)
857 objc_volatilize_decl (b
->decl
);
859 /* Do not climb up past the current function. */
860 if (scope
->function_body
)
865 /* Return true if we are in the global binding level. */
868 global_bindings_p (void)
870 return current_scope
== file_scope
;
874 keep_next_level (void)
876 keep_next_level_flag
= true;
879 /* Set the flag for the FLOAT_CONST_DECIMAL64 pragma being ON. */
882 set_float_const_decimal64 (void)
884 current_scope
->float_const_decimal64
= true;
887 /* Clear the flag for the FLOAT_CONST_DECIMAL64 pragma. */
890 clear_float_const_decimal64 (void)
892 current_scope
->float_const_decimal64
= false;
895 /* Return nonzero if an unsuffixed float constant is _Decimal64. */
898 float_const_decimal64_p (void)
900 return current_scope
->float_const_decimal64
;
903 /* Identify this scope as currently being filled with parameters. */
906 declare_parm_level (void)
908 current_scope
->parm_flag
= true;
914 if (next_is_function_body
)
916 /* This is the transition from the parameters to the top level
917 of the function body. These are the same scope
918 (C99 6.2.1p4,6) so we do not push another scope structure.
919 next_is_function_body is set only by store_parm_decls, which
920 in turn is called when and only when we are about to
921 encounter the opening curly brace for the function body.
923 The outermost block of a function always gets a BLOCK node,
924 because the debugging output routines expect that each
925 function has at least one BLOCK. */
926 current_scope
->parm_flag
= false;
927 current_scope
->function_body
= true;
928 current_scope
->keep
= true;
929 current_scope
->outer_function
= current_function_scope
;
930 current_function_scope
= current_scope
;
932 keep_next_level_flag
= false;
933 next_is_function_body
= false;
935 /* The FLOAT_CONST_DECIMAL64 pragma applies to nested scopes. */
936 if (current_scope
->outer
)
937 current_scope
->float_const_decimal64
938 = current_scope
->outer
->float_const_decimal64
;
940 current_scope
->float_const_decimal64
= false;
944 struct c_scope
*scope
;
947 scope
= scope_freelist
;
948 scope_freelist
= scope
->outer
;
951 scope
= ggc_alloc_cleared_c_scope ();
953 /* The FLOAT_CONST_DECIMAL64 pragma applies to nested scopes. */
955 scope
->float_const_decimal64
= current_scope
->float_const_decimal64
;
957 scope
->float_const_decimal64
= false;
959 scope
->keep
= keep_next_level_flag
;
960 scope
->outer
= current_scope
;
961 scope
->depth
= current_scope
? (current_scope
->depth
+ 1) : 0;
963 /* Check for scope depth overflow. Unlikely (2^28 == 268,435,456) but
965 if (current_scope
&& scope
->depth
== 0)
968 sorry ("GCC supports only %u nested scopes", scope
->depth
);
971 current_scope
= scope
;
972 keep_next_level_flag
= false;
976 /* This is called when we are leaving SCOPE. For each label defined
977 in SCOPE, add any appropriate decls to its decls_in_scope fields.
978 These are the decls whose initialization will be skipped by a goto
979 later in the function. */
982 update_label_decls (struct c_scope
*scope
)
989 if (s
->has_label_bindings
)
993 for (b
= s
->bindings
; b
!= NULL
; b
= b
->prev
)
995 struct c_label_vars
*label_vars
;
996 struct c_binding
*b1
;
999 struct c_goto_bindings
*g
;
1001 if (TREE_CODE (b
->decl
) != LABEL_DECL
)
1003 label_vars
= b
->u
.label
;
1005 b1
= label_vars
->label_bindings
.bindings_in_scope
;
1006 if (label_vars
->label_bindings
.scope
== NULL
)
1009 hjud
= label_vars
->label_bindings
.scope
->has_jump_unsafe_decl
;
1010 if (update_spot_bindings (scope
, &label_vars
->label_bindings
))
1012 /* This label is defined in this scope. */
1015 for (; b1
!= NULL
; b1
= b1
->prev
)
1017 /* A goto from later in the function to this
1018 label will never see the initialization
1019 of B1, if any. Save it to issue a
1020 warning if needed. */
1021 if (decl_jump_unsafe (b1
->decl
))
1022 VEC_safe_push (tree
, gc
,
1023 label_vars
->decls_in_scope
,
1029 /* Update the bindings of any goto statements associated
1031 FOR_EACH_VEC_ELT (c_goto_bindings_p
, label_vars
->gotos
, ix
, g
)
1032 update_spot_bindings (scope
, &g
->goto_bindings
);
1036 /* Don't search beyond the current function. */
1037 if (s
== current_function_scope
)
1044 /* Set the TYPE_CONTEXT of all of TYPE's variants to CONTEXT. */
1047 set_type_context (tree type
, tree context
)
1049 for (type
= TYPE_MAIN_VARIANT (type
); type
;
1050 type
= TYPE_NEXT_VARIANT (type
))
1051 TYPE_CONTEXT (type
) = context
;
1054 /* Exit a scope. Restore the state of the identifier-decl mappings
1055 that were in effect when this scope was entered. Return a BLOCK
1056 node containing all the DECLs in this scope that are of interest
1057 to debug info generation. */
1062 struct c_scope
*scope
= current_scope
;
1063 tree block
, context
, p
;
1064 struct c_binding
*b
;
1066 bool functionbody
= scope
->function_body
;
1067 bool keep
= functionbody
|| scope
->keep
|| scope
->bindings
;
1069 update_label_decls (scope
);
1071 /* If appropriate, create a BLOCK to record the decls for the life
1072 of this function. */
1076 block
= make_node (BLOCK
);
1077 BLOCK_SUBBLOCKS (block
) = scope
->blocks
;
1078 TREE_USED (block
) = 1;
1080 /* In each subblock, record that this is its superior. */
1081 for (p
= scope
->blocks
; p
; p
= BLOCK_CHAIN (p
))
1082 BLOCK_SUPERCONTEXT (p
) = block
;
1084 BLOCK_VARS (block
) = 0;
1087 /* The TYPE_CONTEXTs for all of the tagged types belonging to this
1088 scope must be set so that they point to the appropriate
1089 construct, i.e. either to the current FUNCTION_DECL node, or
1090 else to the BLOCK node we just constructed.
1092 Note that for tagged types whose scope is just the formal
1093 parameter list for some function type specification, we can't
1094 properly set their TYPE_CONTEXTs here, because we don't have a
1095 pointer to the appropriate FUNCTION_TYPE node readily available
1096 to us. For those cases, the TYPE_CONTEXTs of the relevant tagged
1097 type nodes get set in `grokdeclarator' as soon as we have created
1098 the FUNCTION_TYPE node which will represent the "scope" for these
1099 "parameter list local" tagged types. */
1100 if (scope
->function_body
)
1101 context
= current_function_decl
;
1102 else if (scope
== file_scope
)
1104 tree file_decl
= build_translation_unit_decl (NULL_TREE
);
1105 context
= file_decl
;
1110 /* Clear all bindings in this scope. */
1111 for (b
= scope
->bindings
; b
; b
= free_binding_and_advance (b
))
1114 switch (TREE_CODE (p
))
1117 /* Warnings for unused labels, errors for undefined labels. */
1118 if (TREE_USED (p
) && !DECL_INITIAL (p
))
1120 error ("label %q+D used but not defined", p
);
1121 DECL_INITIAL (p
) = error_mark_node
;
1124 warn_for_unused_label (p
);
1126 /* Labels go in BLOCK_VARS. */
1127 DECL_CHAIN (p
) = BLOCK_VARS (block
);
1128 BLOCK_VARS (block
) = p
;
1129 gcc_assert (I_LABEL_BINDING (b
->id
) == b
);
1130 I_LABEL_BINDING (b
->id
) = b
->shadowed
;
1132 /* Also pop back to the shadowed label_vars. */
1133 release_tree_vector (b
->u
.label
->decls_in_scope
);
1134 b
->u
.label
= b
->u
.label
->shadowed
;
1140 set_type_context (p
, context
);
1142 /* Types may not have tag-names, in which case the type
1143 appears in the bindings list with b->id NULL. */
1146 gcc_assert (I_TAG_BINDING (b
->id
) == b
);
1147 I_TAG_BINDING (b
->id
) = b
->shadowed
;
1152 /* Propagate TREE_ADDRESSABLE from nested functions to their
1153 containing functions. */
1154 if (!TREE_ASM_WRITTEN (p
)
1155 && DECL_INITIAL (p
) != 0
1156 && TREE_ADDRESSABLE (p
)
1157 && DECL_ABSTRACT_ORIGIN (p
) != 0
1158 && DECL_ABSTRACT_ORIGIN (p
) != p
)
1159 TREE_ADDRESSABLE (DECL_ABSTRACT_ORIGIN (p
)) = 1;
1160 if (!DECL_EXTERNAL (p
)
1161 && !DECL_INITIAL (p
)
1162 && scope
!= file_scope
1163 && scope
!= external_scope
)
1165 error ("nested function %q+D declared but never defined", p
);
1166 undef_nested_function
= true;
1168 else if (DECL_DECLARED_INLINE_P (p
)
1170 && !DECL_INITIAL (p
))
1172 /* C99 6.7.4p6: "a function with external linkage... declared
1173 with an inline function specifier ... shall also be defined
1174 in the same translation unit." */
1175 if (!flag_gnu89_inline
)
1176 pedwarn (input_location
, 0,
1177 "inline function %q+D declared but never defined", p
);
1178 DECL_EXTERNAL (p
) = 1;
1184 /* Warnings for unused variables. */
1185 if ((!TREE_USED (p
) || !DECL_READ_P (p
))
1186 && !TREE_NO_WARNING (p
)
1187 && !DECL_IN_SYSTEM_HEADER (p
)
1189 && !DECL_ARTIFICIAL (p
)
1190 && scope
!= file_scope
1191 && scope
!= external_scope
)
1194 warning (OPT_Wunused_variable
, "unused variable %q+D", p
);
1195 else if (DECL_CONTEXT (p
) == current_function_decl
)
1196 warning_at (DECL_SOURCE_LOCATION (p
),
1197 OPT_Wunused_but_set_variable
,
1198 "variable %qD set but not used", p
);
1203 error ("type of array %q+D completed incompatibly with"
1204 " implicit initialization", p
);
1211 /* All of these go in BLOCK_VARS, but only if this is the
1212 binding in the home scope. */
1215 DECL_CHAIN (p
) = BLOCK_VARS (block
);
1216 BLOCK_VARS (block
) = p
;
1218 else if (VAR_OR_FUNCTION_DECL_P (p
) && scope
!= file_scope
)
1220 /* For block local externs add a special
1221 DECL_EXTERNAL decl for debug info generation. */
1222 tree extp
= copy_node (p
);
1224 DECL_EXTERNAL (extp
) = 1;
1225 TREE_STATIC (extp
) = 0;
1226 TREE_PUBLIC (extp
) = 1;
1227 DECL_INITIAL (extp
) = NULL_TREE
;
1228 DECL_LANG_SPECIFIC (extp
) = NULL
;
1229 DECL_CONTEXT (extp
) = current_function_decl
;
1230 if (TREE_CODE (p
) == FUNCTION_DECL
)
1232 DECL_RESULT (extp
) = NULL_TREE
;
1233 DECL_SAVED_TREE (extp
) = NULL_TREE
;
1234 DECL_STRUCT_FUNCTION (extp
) = NULL
;
1236 if (b
->locus
!= UNKNOWN_LOCATION
)
1237 DECL_SOURCE_LOCATION (extp
) = b
->locus
;
1238 DECL_CHAIN (extp
) = BLOCK_VARS (block
);
1239 BLOCK_VARS (block
) = extp
;
1241 /* If this is the file scope set DECL_CONTEXT of each decl to
1242 the TRANSLATION_UNIT_DECL. This makes same_translation_unit_p
1244 if (scope
== file_scope
)
1246 DECL_CONTEXT (p
) = context
;
1247 if (TREE_CODE (p
) == TYPE_DECL
1248 && TREE_TYPE (p
) != error_mark_node
)
1249 set_type_context (TREE_TYPE (p
), context
);
1253 /* Parameters go in DECL_ARGUMENTS, not BLOCK_VARS, and have
1254 already been put there by store_parm_decls. Unused-
1255 parameter warnings are handled by function.c.
1256 error_mark_node obviously does not go in BLOCK_VARS and
1257 does not get unused-variable warnings. */
1260 /* It is possible for a decl not to have a name. We get
1261 here with b->id NULL in this case. */
1264 gcc_assert (I_SYMBOL_BINDING (b
->id
) == b
);
1265 I_SYMBOL_BINDING (b
->id
) = b
->shadowed
;
1266 if (b
->shadowed
&& b
->shadowed
->u
.type
)
1267 TREE_TYPE (b
->shadowed
->decl
) = b
->shadowed
->u
.type
;
1277 /* Dispose of the block that we just made inside some higher level. */
1278 if ((scope
->function_body
|| scope
== file_scope
) && context
)
1280 DECL_INITIAL (context
) = block
;
1281 BLOCK_SUPERCONTEXT (block
) = context
;
1283 else if (scope
->outer
)
1286 SCOPE_LIST_APPEND (scope
->outer
, blocks
, block
);
1287 /* If we did not make a block for the scope just exited, any
1288 blocks made for inner scopes must be carried forward so they
1289 will later become subblocks of something else. */
1290 else if (scope
->blocks
)
1291 SCOPE_LIST_CONCAT (scope
->outer
, blocks
, scope
, blocks
);
1294 /* Pop the current scope, and free the structure for reuse. */
1295 current_scope
= scope
->outer
;
1296 if (scope
->function_body
)
1297 current_function_scope
= scope
->outer_function
;
1299 memset (scope
, 0, sizeof (struct c_scope
));
1300 scope
->outer
= scope_freelist
;
1301 scope_freelist
= scope
;
1307 push_file_scope (void)
1315 file_scope
= current_scope
;
1317 start_fname_decls ();
1319 for (decl
= visible_builtins
; decl
; decl
= DECL_CHAIN (decl
))
1320 bind (DECL_NAME (decl
), decl
, file_scope
,
1321 /*invisible=*/false, /*nested=*/true, DECL_SOURCE_LOCATION (decl
));
1325 pop_file_scope (void)
1327 /* In case there were missing closebraces, get us back to the global
1329 while (current_scope
!= file_scope
)
1332 /* __FUNCTION__ is defined at file scope (""). This
1333 call may not be necessary as my tests indicate it
1334 still works without it. */
1335 finish_fname_decls ();
1337 check_inline_statics ();
1339 /* This is the point to write out a PCH if we're doing that.
1340 In that case we do not want to do anything else. */
1343 c_common_write_pch ();
1347 /* Pop off the file scope and close this translation unit. */
1351 maybe_apply_pending_pragma_weaks ();
1354 /* Adjust the bindings for the start of a statement expression. */
1357 c_bindings_start_stmt_expr (struct c_spot_bindings
* switch_bindings
)
1359 struct c_scope
*scope
;
1361 for (scope
= current_scope
; scope
!= NULL
; scope
= scope
->outer
)
1363 struct c_binding
*b
;
1365 if (!scope
->has_label_bindings
)
1368 for (b
= scope
->bindings
; b
!= NULL
; b
= b
->prev
)
1370 struct c_label_vars
*label_vars
;
1372 struct c_goto_bindings
*g
;
1374 if (TREE_CODE (b
->decl
) != LABEL_DECL
)
1376 label_vars
= b
->u
.label
;
1377 ++label_vars
->label_bindings
.stmt_exprs
;
1378 FOR_EACH_VEC_ELT (c_goto_bindings_p
, label_vars
->gotos
, ix
, g
)
1379 ++g
->goto_bindings
.stmt_exprs
;
1383 if (switch_bindings
!= NULL
)
1384 ++switch_bindings
->stmt_exprs
;
1387 /* Adjust the bindings for the end of a statement expression. */
1390 c_bindings_end_stmt_expr (struct c_spot_bindings
*switch_bindings
)
1392 struct c_scope
*scope
;
1394 for (scope
= current_scope
; scope
!= NULL
; scope
= scope
->outer
)
1396 struct c_binding
*b
;
1398 if (!scope
->has_label_bindings
)
1401 for (b
= scope
->bindings
; b
!= NULL
; b
= b
->prev
)
1403 struct c_label_vars
*label_vars
;
1405 struct c_goto_bindings
*g
;
1407 if (TREE_CODE (b
->decl
) != LABEL_DECL
)
1409 label_vars
= b
->u
.label
;
1410 --label_vars
->label_bindings
.stmt_exprs
;
1411 if (label_vars
->label_bindings
.stmt_exprs
< 0)
1413 label_vars
->label_bindings
.left_stmt_expr
= true;
1414 label_vars
->label_bindings
.stmt_exprs
= 0;
1416 FOR_EACH_VEC_ELT (c_goto_bindings_p
, label_vars
->gotos
, ix
, g
)
1418 --g
->goto_bindings
.stmt_exprs
;
1419 if (g
->goto_bindings
.stmt_exprs
< 0)
1421 g
->goto_bindings
.left_stmt_expr
= true;
1422 g
->goto_bindings
.stmt_exprs
= 0;
1428 if (switch_bindings
!= NULL
)
1430 --switch_bindings
->stmt_exprs
;
1431 gcc_assert (switch_bindings
->stmt_exprs
>= 0);
1435 /* Push a definition or a declaration of struct, union or enum tag "name".
1436 "type" should be the type node.
1437 We assume that the tag "name" is not already defined, and has a location
1440 Note that the definition may really be just a forward reference.
1441 In that case, the TYPE_SIZE will be zero. */
1444 pushtag (location_t loc
, tree name
, tree type
)
1446 /* Record the identifier as the type's name if it has none. */
1447 if (name
&& !TYPE_NAME (type
))
1448 TYPE_NAME (type
) = name
;
1449 bind (name
, type
, current_scope
, /*invisible=*/false, /*nested=*/false, loc
);
1451 /* Create a fake NULL-named TYPE_DECL node whose TREE_TYPE will be the
1452 tagged type we just added to the current scope. This fake
1453 NULL-named TYPE_DECL node helps dwarfout.c to know when it needs
1454 to output a representation of a tagged type, and it also gives
1455 us a convenient place to record the "scope start" address for the
1458 TYPE_STUB_DECL (type
) = pushdecl (build_decl (loc
,
1459 TYPE_DECL
, NULL_TREE
, type
));
1461 /* An approximation for now, so we can tell this is a function-scope tag.
1462 This will be updated in pop_scope. */
1463 TYPE_CONTEXT (type
) = DECL_CONTEXT (TYPE_STUB_DECL (type
));
1465 if (warn_cxx_compat
&& name
!= NULL_TREE
)
1467 struct c_binding
*b
= I_SYMBOL_BINDING (name
);
1470 && b
->decl
!= NULL_TREE
1471 && TREE_CODE (b
->decl
) == TYPE_DECL
1472 && (B_IN_CURRENT_SCOPE (b
)
1473 || (current_scope
== file_scope
&& B_IN_EXTERNAL_SCOPE (b
)))
1474 && (TYPE_MAIN_VARIANT (TREE_TYPE (b
->decl
))
1475 != TYPE_MAIN_VARIANT (type
)))
1477 warning_at (loc
, OPT_Wc___compat
,
1478 ("using %qD as both a typedef and a tag is "
1481 if (b
->locus
!= UNKNOWN_LOCATION
)
1482 inform (b
->locus
, "originally defined here");
1487 /* Subroutine of compare_decls. Allow harmless mismatches in return
1488 and argument types provided that the type modes match. This function
1489 return a unified type given a suitable match, and 0 otherwise. */
1492 match_builtin_function_types (tree newtype
, tree oldtype
)
1494 tree newrettype
, oldrettype
;
1495 tree newargs
, oldargs
;
1496 tree trytype
, tryargs
;
1498 /* Accept the return type of the new declaration if same modes. */
1499 oldrettype
= TREE_TYPE (oldtype
);
1500 newrettype
= TREE_TYPE (newtype
);
1502 if (TYPE_MODE (oldrettype
) != TYPE_MODE (newrettype
))
1505 oldargs
= TYPE_ARG_TYPES (oldtype
);
1506 newargs
= TYPE_ARG_TYPES (newtype
);
1509 while (oldargs
|| newargs
)
1513 || !TREE_VALUE (oldargs
)
1514 || !TREE_VALUE (newargs
)
1515 || TYPE_MODE (TREE_VALUE (oldargs
))
1516 != TYPE_MODE (TREE_VALUE (newargs
)))
1519 oldargs
= TREE_CHAIN (oldargs
);
1520 newargs
= TREE_CHAIN (newargs
);
1523 trytype
= build_function_type (newrettype
, tryargs
);
1524 return build_type_attribute_variant (trytype
, TYPE_ATTRIBUTES (oldtype
));
1527 /* Subroutine of diagnose_mismatched_decls. Check for function type
1528 mismatch involving an empty arglist vs a nonempty one and give clearer
1531 diagnose_arglist_conflict (tree newdecl
, tree olddecl
,
1532 tree newtype
, tree oldtype
)
1536 if (TREE_CODE (olddecl
) != FUNCTION_DECL
1537 || !comptypes (TREE_TYPE (oldtype
), TREE_TYPE (newtype
))
1538 || !((!prototype_p (oldtype
) && DECL_INITIAL (olddecl
) == 0)
1539 || (!prototype_p (newtype
) && DECL_INITIAL (newdecl
) == 0)))
1542 t
= TYPE_ARG_TYPES (oldtype
);
1544 t
= TYPE_ARG_TYPES (newtype
);
1545 for (; t
; t
= TREE_CHAIN (t
))
1547 tree type
= TREE_VALUE (t
);
1549 if (TREE_CHAIN (t
) == 0
1550 && TYPE_MAIN_VARIANT (type
) != void_type_node
)
1552 inform (input_location
, "a parameter list with an ellipsis can%'t match "
1553 "an empty parameter name list declaration");
1557 if (c_type_promotes_to (type
) != type
)
1559 inform (input_location
, "an argument type that has a default promotion can%'t match "
1560 "an empty parameter name list declaration");
1566 /* Another subroutine of diagnose_mismatched_decls. OLDDECL is an
1567 old-style function definition, NEWDECL is a prototype declaration.
1568 Diagnose inconsistencies in the argument list. Returns TRUE if
1569 the prototype is compatible, FALSE if not. */
1571 validate_proto_after_old_defn (tree newdecl
, tree newtype
, tree oldtype
)
1573 tree newargs
, oldargs
;
1576 #define END_OF_ARGLIST(t) ((t) == void_type_node)
1578 oldargs
= TYPE_ACTUAL_ARG_TYPES (oldtype
);
1579 newargs
= TYPE_ARG_TYPES (newtype
);
1584 tree oldargtype
= TREE_VALUE (oldargs
);
1585 tree newargtype
= TREE_VALUE (newargs
);
1587 if (oldargtype
== error_mark_node
|| newargtype
== error_mark_node
)
1590 oldargtype
= TYPE_MAIN_VARIANT (oldargtype
);
1591 newargtype
= TYPE_MAIN_VARIANT (newargtype
);
1593 if (END_OF_ARGLIST (oldargtype
) && END_OF_ARGLIST (newargtype
))
1596 /* Reaching the end of just one list means the two decls don't
1597 agree on the number of arguments. */
1598 if (END_OF_ARGLIST (oldargtype
))
1600 error ("prototype for %q+D declares more arguments "
1601 "than previous old-style definition", newdecl
);
1604 else if (END_OF_ARGLIST (newargtype
))
1606 error ("prototype for %q+D declares fewer arguments "
1607 "than previous old-style definition", newdecl
);
1611 /* Type for passing arg must be consistent with that declared
1613 else if (!comptypes (oldargtype
, newargtype
))
1615 error ("prototype for %q+D declares argument %d"
1616 " with incompatible type",
1621 oldargs
= TREE_CHAIN (oldargs
);
1622 newargs
= TREE_CHAIN (newargs
);
1626 /* If we get here, no errors were found, but do issue a warning
1627 for this poor-style construct. */
1628 warning (0, "prototype for %q+D follows non-prototype definition",
1631 #undef END_OF_ARGLIST
1634 /* Subroutine of diagnose_mismatched_decls. Report the location of DECL,
1635 first in a pair of mismatched declarations, using the diagnostic
1638 locate_old_decl (tree decl
)
1640 if (TREE_CODE (decl
) == FUNCTION_DECL
&& DECL_BUILT_IN (decl
))
1642 else if (DECL_INITIAL (decl
))
1643 inform (input_location
, "previous definition of %q+D was here", decl
);
1644 else if (C_DECL_IMPLICIT (decl
))
1645 inform (input_location
, "previous implicit declaration of %q+D was here", decl
);
1647 inform (input_location
, "previous declaration of %q+D was here", decl
);
1650 /* Subroutine of duplicate_decls. Compare NEWDECL to OLDDECL.
1651 Returns true if the caller should proceed to merge the two, false
1652 if OLDDECL should simply be discarded. As a side effect, issues
1653 all necessary diagnostics for invalid or poor-style combinations.
1654 If it returns true, writes the types of NEWDECL and OLDDECL to
1655 *NEWTYPEP and *OLDTYPEP - these may have been adjusted from
1656 TREE_TYPE (NEWDECL, OLDDECL) respectively. */
1659 diagnose_mismatched_decls (tree newdecl
, tree olddecl
,
1660 tree
*newtypep
, tree
*oldtypep
)
1662 tree newtype
, oldtype
;
1663 bool pedwarned
= false;
1664 bool warned
= false;
1667 #define DECL_EXTERN_INLINE(DECL) (DECL_DECLARED_INLINE_P (DECL) \
1668 && DECL_EXTERNAL (DECL))
1670 /* If we have error_mark_node for either decl or type, just discard
1671 the previous decl - we're in an error cascade already. */
1672 if (olddecl
== error_mark_node
|| newdecl
== error_mark_node
)
1674 *oldtypep
= oldtype
= TREE_TYPE (olddecl
);
1675 *newtypep
= newtype
= TREE_TYPE (newdecl
);
1676 if (oldtype
== error_mark_node
|| newtype
== error_mark_node
)
1679 /* Two different categories of symbol altogether. This is an error
1680 unless OLDDECL is a builtin. OLDDECL will be discarded in any case. */
1681 if (TREE_CODE (olddecl
) != TREE_CODE (newdecl
))
1683 if (!(TREE_CODE (olddecl
) == FUNCTION_DECL
1684 && DECL_BUILT_IN (olddecl
)
1685 && !C_DECL_DECLARED_BUILTIN (olddecl
)))
1687 error ("%q+D redeclared as different kind of symbol", newdecl
);
1688 locate_old_decl (olddecl
);
1690 else if (TREE_PUBLIC (newdecl
))
1691 warning (0, "built-in function %q+D declared as non-function",
1694 warning (OPT_Wshadow
, "declaration of %q+D shadows "
1695 "a built-in function", newdecl
);
1699 /* Enumerators have no linkage, so may only be declared once in a
1701 if (TREE_CODE (olddecl
) == CONST_DECL
)
1703 error ("redeclaration of enumerator %q+D", newdecl
);
1704 locate_old_decl (olddecl
);
1708 if (!comptypes (oldtype
, newtype
))
1710 if (TREE_CODE (olddecl
) == FUNCTION_DECL
1711 && DECL_BUILT_IN (olddecl
) && !C_DECL_DECLARED_BUILTIN (olddecl
))
1713 /* Accept harmless mismatch in function types.
1714 This is for the ffs and fprintf builtins. */
1715 tree trytype
= match_builtin_function_types (newtype
, oldtype
);
1717 if (trytype
&& comptypes (newtype
, trytype
))
1718 *oldtypep
= oldtype
= trytype
;
1721 /* If types don't match for a built-in, throw away the
1722 built-in. No point in calling locate_old_decl here, it
1723 won't print anything. */
1724 warning (0, "conflicting types for built-in function %q+D",
1729 else if (TREE_CODE (olddecl
) == FUNCTION_DECL
1730 && DECL_IS_BUILTIN (olddecl
))
1732 /* A conflicting function declaration for a predeclared
1733 function that isn't actually built in. Objective C uses
1734 these. The new declaration silently overrides everything
1735 but the volatility (i.e. noreturn) indication. See also
1736 below. FIXME: Make Objective C use normal builtins. */
1737 TREE_THIS_VOLATILE (newdecl
) |= TREE_THIS_VOLATILE (olddecl
);
1740 /* Permit void foo (...) to match int foo (...) if the latter is
1741 the definition and implicit int was used. See
1742 c-torture/compile/920625-2.c. */
1743 else if (TREE_CODE (newdecl
) == FUNCTION_DECL
&& DECL_INITIAL (newdecl
)
1744 && TYPE_MAIN_VARIANT (TREE_TYPE (oldtype
)) == void_type_node
1745 && TYPE_MAIN_VARIANT (TREE_TYPE (newtype
)) == integer_type_node
1746 && C_FUNCTION_IMPLICIT_INT (newdecl
) && !DECL_INITIAL (olddecl
))
1748 pedwarned
= pedwarn (input_location
, 0,
1749 "conflicting types for %q+D", newdecl
);
1750 /* Make sure we keep void as the return type. */
1751 TREE_TYPE (newdecl
) = *newtypep
= newtype
= oldtype
;
1752 C_FUNCTION_IMPLICIT_INT (newdecl
) = 0;
1754 /* Permit void foo (...) to match an earlier call to foo (...) with
1755 no declared type (thus, implicitly int). */
1756 else if (TREE_CODE (newdecl
) == FUNCTION_DECL
1757 && TYPE_MAIN_VARIANT (TREE_TYPE (newtype
)) == void_type_node
1758 && TYPE_MAIN_VARIANT (TREE_TYPE (oldtype
)) == integer_type_node
1759 && C_DECL_IMPLICIT (olddecl
) && !DECL_INITIAL (olddecl
))
1761 pedwarned
= pedwarn (input_location
, 0,
1762 "conflicting types for %q+D", newdecl
);
1763 /* Make sure we keep void as the return type. */
1764 TREE_TYPE (olddecl
) = *oldtypep
= oldtype
= newtype
;
1768 int new_quals
= TYPE_QUALS (newtype
);
1769 int old_quals
= TYPE_QUALS (oldtype
);
1771 if (new_quals
!= old_quals
)
1773 addr_space_t new_addr
= DECODE_QUAL_ADDR_SPACE (new_quals
);
1774 addr_space_t old_addr
= DECODE_QUAL_ADDR_SPACE (old_quals
);
1775 if (new_addr
!= old_addr
)
1777 if (ADDR_SPACE_GENERIC_P (new_addr
))
1778 error ("conflicting named address spaces (generic vs %s) "
1780 c_addr_space_name (old_addr
), newdecl
);
1781 else if (ADDR_SPACE_GENERIC_P (old_addr
))
1782 error ("conflicting named address spaces (%s vs generic) "
1784 c_addr_space_name (new_addr
), newdecl
);
1786 error ("conflicting named address spaces (%s vs %s) "
1788 c_addr_space_name (new_addr
),
1789 c_addr_space_name (old_addr
),
1793 if (CLEAR_QUAL_ADDR_SPACE (new_quals
)
1794 != CLEAR_QUAL_ADDR_SPACE (old_quals
))
1795 error ("conflicting type qualifiers for %q+D", newdecl
);
1798 error ("conflicting types for %q+D", newdecl
);
1799 diagnose_arglist_conflict (newdecl
, olddecl
, newtype
, oldtype
);
1800 locate_old_decl (olddecl
);
1805 /* Redeclaration of a type is a constraint violation (6.7.2.3p1),
1806 but silently ignore the redeclaration if either is in a system
1807 header. (Conflicting redeclarations were handled above.) This
1808 is allowed for C11 if the types are the same, not just
1810 if (TREE_CODE (newdecl
) == TYPE_DECL
)
1812 bool types_different
= false;
1813 int comptypes_result
;
1816 = comptypes_check_different_types (oldtype
, newtype
, &types_different
);
1818 if (comptypes_result
!= 1 || types_different
)
1820 error ("redefinition of typedef %q+D with different type", newdecl
);
1821 locate_old_decl (olddecl
);
1825 if (DECL_IN_SYSTEM_HEADER (newdecl
)
1826 || DECL_IN_SYSTEM_HEADER (olddecl
)
1827 || TREE_NO_WARNING (newdecl
)
1828 || TREE_NO_WARNING (olddecl
))
1829 return true; /* Allow OLDDECL to continue in use. */
1831 if (variably_modified_type_p (newtype
, NULL
))
1833 error ("redefinition of typedef %q+D with variably modified type",
1835 locate_old_decl (olddecl
);
1837 else if (pedantic
&& !flag_isoc11
)
1839 pedwarn (input_location
, OPT_Wpedantic
,
1840 "redefinition of typedef %q+D", newdecl
);
1841 locate_old_decl (olddecl
);
1847 /* Function declarations can either be 'static' or 'extern' (no
1848 qualifier is equivalent to 'extern' - C99 6.2.2p5) and therefore
1849 can never conflict with each other on account of linkage
1850 (6.2.2p4). Multiple definitions are not allowed (6.9p3,5) but
1851 gnu89 mode permits two definitions if one is 'extern inline' and
1852 one is not. The non- extern-inline definition supersedes the
1853 extern-inline definition. */
1855 else if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
1857 /* If you declare a built-in function name as static, or
1858 define the built-in with an old-style definition (so we
1859 can't validate the argument list) the built-in definition is
1860 overridden, but optionally warn this was a bad choice of name. */
1861 if (DECL_BUILT_IN (olddecl
)
1862 && !C_DECL_DECLARED_BUILTIN (olddecl
)
1863 && (!TREE_PUBLIC (newdecl
)
1864 || (DECL_INITIAL (newdecl
)
1865 && !prototype_p (TREE_TYPE (newdecl
)))))
1867 warning (OPT_Wshadow
, "declaration of %q+D shadows "
1868 "a built-in function", newdecl
);
1869 /* Discard the old built-in function. */
1873 if (DECL_INITIAL (newdecl
))
1875 if (DECL_INITIAL (olddecl
))
1877 /* If both decls are in the same TU and the new declaration
1878 isn't overriding an extern inline reject the new decl.
1879 In c99, no overriding is allowed in the same translation
1881 if ((!DECL_EXTERN_INLINE (olddecl
)
1882 || DECL_EXTERN_INLINE (newdecl
)
1883 || (!flag_gnu89_inline
1884 && (!DECL_DECLARED_INLINE_P (olddecl
)
1885 || !lookup_attribute ("gnu_inline",
1886 DECL_ATTRIBUTES (olddecl
)))
1887 && (!DECL_DECLARED_INLINE_P (newdecl
)
1888 || !lookup_attribute ("gnu_inline",
1889 DECL_ATTRIBUTES (newdecl
))))
1891 && same_translation_unit_p (newdecl
, olddecl
))
1893 error ("redefinition of %q+D", newdecl
);
1894 locate_old_decl (olddecl
);
1899 /* If we have a prototype after an old-style function definition,
1900 the argument types must be checked specially. */
1901 else if (DECL_INITIAL (olddecl
)
1902 && !prototype_p (oldtype
) && prototype_p (newtype
)
1903 && TYPE_ACTUAL_ARG_TYPES (oldtype
)
1904 && !validate_proto_after_old_defn (newdecl
, newtype
, oldtype
))
1906 locate_old_decl (olddecl
);
1909 /* A non-static declaration (even an "extern") followed by a
1910 static declaration is undefined behavior per C99 6.2.2p3-5,7.
1911 The same is true for a static forward declaration at block
1912 scope followed by a non-static declaration/definition at file
1913 scope. Static followed by non-static at the same scope is
1914 not undefined behavior, and is the most convenient way to get
1915 some effects (see e.g. what unwind-dw2-fde-glibc.c does to
1916 the definition of _Unwind_Find_FDE in unwind-dw2-fde.c), but
1917 we do diagnose it if -Wtraditional. */
1918 if (TREE_PUBLIC (olddecl
) && !TREE_PUBLIC (newdecl
))
1920 /* Two exceptions to the rule. If olddecl is an extern
1921 inline, or a predeclared function that isn't actually
1922 built in, newdecl silently overrides olddecl. The latter
1923 occur only in Objective C; see also above. (FIXME: Make
1924 Objective C use normal builtins.) */
1925 if (!DECL_IS_BUILTIN (olddecl
)
1926 && !DECL_EXTERN_INLINE (olddecl
))
1928 error ("static declaration of %q+D follows "
1929 "non-static declaration", newdecl
);
1930 locate_old_decl (olddecl
);
1934 else if (TREE_PUBLIC (newdecl
) && !TREE_PUBLIC (olddecl
))
1936 if (DECL_CONTEXT (olddecl
))
1938 error ("non-static declaration of %q+D follows "
1939 "static declaration", newdecl
);
1940 locate_old_decl (olddecl
);
1943 else if (warn_traditional
)
1945 warned
|= warning (OPT_Wtraditional
,
1946 "non-static declaration of %q+D "
1947 "follows static declaration", newdecl
);
1951 /* Make sure gnu_inline attribute is either not present, or
1952 present on all inline decls. */
1953 if (DECL_DECLARED_INLINE_P (olddecl
)
1954 && DECL_DECLARED_INLINE_P (newdecl
))
1956 bool newa
= lookup_attribute ("gnu_inline",
1957 DECL_ATTRIBUTES (newdecl
)) != NULL
;
1958 bool olda
= lookup_attribute ("gnu_inline",
1959 DECL_ATTRIBUTES (olddecl
)) != NULL
;
1962 error_at (input_location
, "%<gnu_inline%> attribute present on %q+D",
1963 newa
? newdecl
: olddecl
);
1964 error_at (DECL_SOURCE_LOCATION (newa
? olddecl
: newdecl
),
1969 else if (TREE_CODE (newdecl
) == VAR_DECL
)
1971 /* Only variables can be thread-local, and all declarations must
1972 agree on this property. */
1973 if (C_DECL_THREADPRIVATE_P (olddecl
) && !DECL_THREAD_LOCAL_P (newdecl
))
1975 /* Nothing to check. Since OLDDECL is marked threadprivate
1976 and NEWDECL does not have a thread-local attribute, we
1977 will merge the threadprivate attribute into NEWDECL. */
1980 else if (DECL_THREAD_LOCAL_P (newdecl
) != DECL_THREAD_LOCAL_P (olddecl
))
1982 if (DECL_THREAD_LOCAL_P (newdecl
))
1983 error ("thread-local declaration of %q+D follows "
1984 "non-thread-local declaration", newdecl
);
1986 error ("non-thread-local declaration of %q+D follows "
1987 "thread-local declaration", newdecl
);
1989 locate_old_decl (olddecl
);
1993 /* Multiple initialized definitions are not allowed (6.9p3,5). */
1994 if (DECL_INITIAL (newdecl
) && DECL_INITIAL (olddecl
))
1996 error ("redefinition of %q+D", newdecl
);
1997 locate_old_decl (olddecl
);
2001 /* Objects declared at file scope: if the first declaration had
2002 external linkage (even if it was an external reference) the
2003 second must have external linkage as well, or the behavior is
2004 undefined. If the first declaration had internal linkage, then
2005 the second must too, or else be an external reference (in which
2006 case the composite declaration still has internal linkage).
2007 As for function declarations, we warn about the static-then-
2008 extern case only for -Wtraditional. See generally 6.2.2p3-5,7. */
2009 if (DECL_FILE_SCOPE_P (newdecl
)
2010 && TREE_PUBLIC (newdecl
) != TREE_PUBLIC (olddecl
))
2012 if (DECL_EXTERNAL (newdecl
))
2014 if (!DECL_FILE_SCOPE_P (olddecl
))
2016 error ("extern declaration of %q+D follows "
2017 "declaration with no linkage", newdecl
);
2018 locate_old_decl (olddecl
);
2021 else if (warn_traditional
)
2023 warned
|= warning (OPT_Wtraditional
,
2024 "non-static declaration of %q+D "
2025 "follows static declaration", newdecl
);
2030 if (TREE_PUBLIC (newdecl
))
2031 error ("non-static declaration of %q+D follows "
2032 "static declaration", newdecl
);
2034 error ("static declaration of %q+D follows "
2035 "non-static declaration", newdecl
);
2037 locate_old_decl (olddecl
);
2041 /* Two objects with the same name declared at the same block
2042 scope must both be external references (6.7p3). */
2043 else if (!DECL_FILE_SCOPE_P (newdecl
))
2045 if (DECL_EXTERNAL (newdecl
))
2047 /* Extern with initializer at block scope, which will
2048 already have received an error. */
2050 else if (DECL_EXTERNAL (olddecl
))
2052 error ("declaration of %q+D with no linkage follows "
2053 "extern declaration", newdecl
);
2054 locate_old_decl (olddecl
);
2058 error ("redeclaration of %q+D with no linkage", newdecl
);
2059 locate_old_decl (olddecl
);
2065 /* C++ does not permit a decl to appear multiple times at file
2068 && DECL_FILE_SCOPE_P (newdecl
)
2069 && !DECL_EXTERNAL (newdecl
)
2070 && !DECL_EXTERNAL (olddecl
))
2071 warned
|= warning_at (DECL_SOURCE_LOCATION (newdecl
),
2073 ("duplicate declaration of %qD is "
2079 /* All decls must agree on a visibility. */
2080 if (CODE_CONTAINS_STRUCT (TREE_CODE (newdecl
), TS_DECL_WITH_VIS
)
2081 && DECL_VISIBILITY_SPECIFIED (newdecl
) && DECL_VISIBILITY_SPECIFIED (olddecl
)
2082 && DECL_VISIBILITY (newdecl
) != DECL_VISIBILITY (olddecl
))
2084 warned
|= warning (0, "redeclaration of %q+D with different visibility "
2085 "(old visibility preserved)", newdecl
);
2088 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
2090 /* Diagnose inline __attribute__ ((noinline)) which is silly. */
2091 if (DECL_DECLARED_INLINE_P (newdecl
)
2092 && lookup_attribute ("noinline", DECL_ATTRIBUTES (olddecl
)))
2094 warned
|= warning (OPT_Wattributes
,
2095 "inline declaration of %qD follows "
2096 "declaration with attribute noinline", newdecl
);
2098 else if (DECL_DECLARED_INLINE_P (olddecl
)
2099 && lookup_attribute ("noinline", DECL_ATTRIBUTES (newdecl
)))
2101 warned
|= warning (OPT_Wattributes
,
2102 "declaration of %q+D with attribute "
2103 "noinline follows inline declaration ", newdecl
);
2106 else /* PARM_DECL, VAR_DECL */
2108 /* Redeclaration of a parameter is a constraint violation (this is
2109 not explicitly stated, but follows from C99 6.7p3 [no more than
2110 one declaration of the same identifier with no linkage in the
2111 same scope, except type tags] and 6.2.2p6 [parameters have no
2112 linkage]). We must check for a forward parameter declaration,
2113 indicated by TREE_ASM_WRITTEN on the old declaration - this is
2114 an extension, the mandatory diagnostic for which is handled by
2115 mark_forward_parm_decls. */
2117 if (TREE_CODE (newdecl
) == PARM_DECL
2118 && (!TREE_ASM_WRITTEN (olddecl
) || TREE_ASM_WRITTEN (newdecl
)))
2120 error ("redefinition of parameter %q+D", newdecl
);
2121 locate_old_decl (olddecl
);
2126 /* Optional warning for completely redundant decls. */
2127 if (!warned
&& !pedwarned
2128 && warn_redundant_decls
2129 /* Don't warn about a function declaration followed by a
2131 && !(TREE_CODE (newdecl
) == FUNCTION_DECL
2132 && DECL_INITIAL (newdecl
) && !DECL_INITIAL (olddecl
))
2133 /* Don't warn about redundant redeclarations of builtins. */
2134 && !(TREE_CODE (newdecl
) == FUNCTION_DECL
2135 && !DECL_BUILT_IN (newdecl
)
2136 && DECL_BUILT_IN (olddecl
)
2137 && !C_DECL_DECLARED_BUILTIN (olddecl
))
2138 /* Don't warn about an extern followed by a definition. */
2139 && !(DECL_EXTERNAL (olddecl
) && !DECL_EXTERNAL (newdecl
))
2140 /* Don't warn about forward parameter decls. */
2141 && !(TREE_CODE (newdecl
) == PARM_DECL
2142 && TREE_ASM_WRITTEN (olddecl
) && !TREE_ASM_WRITTEN (newdecl
))
2143 /* Don't warn about a variable definition following a declaration. */
2144 && !(TREE_CODE (newdecl
) == VAR_DECL
2145 && DECL_INITIAL (newdecl
) && !DECL_INITIAL (olddecl
)))
2147 warned
= warning (OPT_Wredundant_decls
, "redundant redeclaration of %q+D",
2151 /* Report location of previous decl/defn. */
2152 if (warned
|| pedwarned
)
2153 locate_old_decl (olddecl
);
2155 #undef DECL_EXTERN_INLINE
2160 /* Subroutine of duplicate_decls. NEWDECL has been found to be
2161 consistent with OLDDECL, but carries new information. Merge the
2162 new information into OLDDECL. This function issues no
2166 merge_decls (tree newdecl
, tree olddecl
, tree newtype
, tree oldtype
)
2168 bool new_is_definition
= (TREE_CODE (newdecl
) == FUNCTION_DECL
2169 && DECL_INITIAL (newdecl
) != 0);
2170 bool new_is_prototype
= (TREE_CODE (newdecl
) == FUNCTION_DECL
2171 && prototype_p (TREE_TYPE (newdecl
)));
2172 bool old_is_prototype
= (TREE_CODE (olddecl
) == FUNCTION_DECL
2173 && prototype_p (TREE_TYPE (olddecl
)));
2175 /* For real parm decl following a forward decl, rechain the old decl
2176 in its new location and clear TREE_ASM_WRITTEN (it's not a
2177 forward decl anymore). */
2178 if (TREE_CODE (newdecl
) == PARM_DECL
2179 && TREE_ASM_WRITTEN (olddecl
) && !TREE_ASM_WRITTEN (newdecl
))
2181 struct c_binding
*b
, **here
;
2183 for (here
= ¤t_scope
->bindings
; *here
; here
= &(*here
)->prev
)
2184 if ((*here
)->decl
== olddecl
)
2191 b
->prev
= current_scope
->bindings
;
2192 current_scope
->bindings
= b
;
2194 TREE_ASM_WRITTEN (olddecl
) = 0;
2197 DECL_ATTRIBUTES (newdecl
)
2198 = targetm
.merge_decl_attributes (olddecl
, newdecl
);
2200 /* Merge the data types specified in the two decls. */
2202 = TREE_TYPE (olddecl
)
2203 = composite_type (newtype
, oldtype
);
2205 /* Lay the type out, unless already done. */
2206 if (!comptypes (oldtype
, TREE_TYPE (newdecl
)))
2208 if (TREE_TYPE (newdecl
) != error_mark_node
)
2209 layout_type (TREE_TYPE (newdecl
));
2210 if (TREE_CODE (newdecl
) != FUNCTION_DECL
2211 && TREE_CODE (newdecl
) != TYPE_DECL
2212 && TREE_CODE (newdecl
) != CONST_DECL
)
2213 layout_decl (newdecl
, 0);
2217 /* Since the type is OLDDECL's, make OLDDECL's size go with. */
2218 DECL_SIZE (newdecl
) = DECL_SIZE (olddecl
);
2219 DECL_SIZE_UNIT (newdecl
) = DECL_SIZE_UNIT (olddecl
);
2220 DECL_MODE (newdecl
) = DECL_MODE (olddecl
);
2221 if (DECL_ALIGN (olddecl
) > DECL_ALIGN (newdecl
))
2223 DECL_ALIGN (newdecl
) = DECL_ALIGN (olddecl
);
2224 DECL_USER_ALIGN (newdecl
) |= DECL_USER_ALIGN (olddecl
);
2228 /* Keep the old rtl since we can safely use it. */
2229 if (HAS_RTL_P (olddecl
))
2230 COPY_DECL_RTL (olddecl
, newdecl
);
2232 /* Merge the type qualifiers. */
2233 if (TREE_READONLY (newdecl
))
2234 TREE_READONLY (olddecl
) = 1;
2236 if (TREE_THIS_VOLATILE (newdecl
))
2237 TREE_THIS_VOLATILE (olddecl
) = 1;
2239 /* Merge deprecatedness. */
2240 if (TREE_DEPRECATED (newdecl
))
2241 TREE_DEPRECATED (olddecl
) = 1;
2243 /* If a decl is in a system header and the other isn't, keep the one on the
2244 system header. Otherwise, keep source location of definition rather than
2245 declaration and of prototype rather than non-prototype unless that
2246 prototype is built-in. */
2247 if (CODE_CONTAINS_STRUCT (TREE_CODE (olddecl
), TS_DECL_WITH_VIS
)
2248 && DECL_IN_SYSTEM_HEADER (olddecl
)
2249 && !DECL_IN_SYSTEM_HEADER (newdecl
) )
2250 DECL_SOURCE_LOCATION (newdecl
) = DECL_SOURCE_LOCATION (olddecl
);
2251 else if (CODE_CONTAINS_STRUCT (TREE_CODE (olddecl
), TS_DECL_WITH_VIS
)
2252 && DECL_IN_SYSTEM_HEADER (newdecl
)
2253 && !DECL_IN_SYSTEM_HEADER (olddecl
))
2254 DECL_SOURCE_LOCATION (olddecl
) = DECL_SOURCE_LOCATION (newdecl
);
2255 else if ((DECL_INITIAL (newdecl
) == 0 && DECL_INITIAL (olddecl
) != 0)
2256 || (old_is_prototype
&& !new_is_prototype
2257 && !C_DECL_BUILTIN_PROTOTYPE (olddecl
)))
2258 DECL_SOURCE_LOCATION (newdecl
) = DECL_SOURCE_LOCATION (olddecl
);
2260 /* Merge the initialization information. */
2261 if (DECL_INITIAL (newdecl
) == 0)
2262 DECL_INITIAL (newdecl
) = DECL_INITIAL (olddecl
);
2264 /* Merge the threadprivate attribute. */
2265 if (TREE_CODE (olddecl
) == VAR_DECL
&& C_DECL_THREADPRIVATE_P (olddecl
))
2267 DECL_TLS_MODEL (newdecl
) = DECL_TLS_MODEL (olddecl
);
2268 C_DECL_THREADPRIVATE_P (newdecl
) = 1;
2271 if (CODE_CONTAINS_STRUCT (TREE_CODE (olddecl
), TS_DECL_WITH_VIS
))
2273 /* Merge the section attribute.
2274 We want to issue an error if the sections conflict but that
2275 must be done later in decl_attributes since we are called
2276 before attributes are assigned. */
2277 if (DECL_SECTION_NAME (newdecl
) == NULL_TREE
)
2278 DECL_SECTION_NAME (newdecl
) = DECL_SECTION_NAME (olddecl
);
2280 /* Copy the assembler name.
2281 Currently, it can only be defined in the prototype. */
2282 COPY_DECL_ASSEMBLER_NAME (olddecl
, newdecl
);
2284 /* Use visibility of whichever declaration had it specified */
2285 if (DECL_VISIBILITY_SPECIFIED (olddecl
))
2287 DECL_VISIBILITY (newdecl
) = DECL_VISIBILITY (olddecl
);
2288 DECL_VISIBILITY_SPECIFIED (newdecl
) = 1;
2291 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
2293 DECL_STATIC_CONSTRUCTOR(newdecl
) |= DECL_STATIC_CONSTRUCTOR(olddecl
);
2294 DECL_STATIC_DESTRUCTOR (newdecl
) |= DECL_STATIC_DESTRUCTOR (olddecl
);
2295 DECL_NO_LIMIT_STACK (newdecl
) |= DECL_NO_LIMIT_STACK (olddecl
);
2296 DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (newdecl
)
2297 |= DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (olddecl
);
2298 TREE_THIS_VOLATILE (newdecl
) |= TREE_THIS_VOLATILE (olddecl
);
2299 DECL_IS_MALLOC (newdecl
) |= DECL_IS_MALLOC (olddecl
);
2300 DECL_IS_OPERATOR_NEW (newdecl
) |= DECL_IS_OPERATOR_NEW (olddecl
);
2301 TREE_READONLY (newdecl
) |= TREE_READONLY (olddecl
);
2302 DECL_PURE_P (newdecl
) |= DECL_PURE_P (olddecl
);
2303 DECL_IS_NOVOPS (newdecl
) |= DECL_IS_NOVOPS (olddecl
);
2306 /* Merge the storage class information. */
2307 merge_weak (newdecl
, olddecl
);
2309 /* For functions, static overrides non-static. */
2310 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
2312 TREE_PUBLIC (newdecl
) &= TREE_PUBLIC (olddecl
);
2313 /* This is since we don't automatically
2314 copy the attributes of NEWDECL into OLDDECL. */
2315 TREE_PUBLIC (olddecl
) = TREE_PUBLIC (newdecl
);
2316 /* If this clears `static', clear it in the identifier too. */
2317 if (!TREE_PUBLIC (olddecl
))
2318 TREE_PUBLIC (DECL_NAME (olddecl
)) = 0;
2322 /* In c99, 'extern' declaration before (or after) 'inline' means this
2323 function is not DECL_EXTERNAL, unless 'gnu_inline' attribute
2325 if (TREE_CODE (newdecl
) == FUNCTION_DECL
2326 && !flag_gnu89_inline
2327 && (DECL_DECLARED_INLINE_P (newdecl
)
2328 || DECL_DECLARED_INLINE_P (olddecl
))
2329 && (!DECL_DECLARED_INLINE_P (newdecl
)
2330 || !DECL_DECLARED_INLINE_P (olddecl
)
2331 || !DECL_EXTERNAL (olddecl
))
2332 && DECL_EXTERNAL (newdecl
)
2333 && !lookup_attribute ("gnu_inline", DECL_ATTRIBUTES (newdecl
))
2334 && !current_function_decl
)
2335 DECL_EXTERNAL (newdecl
) = 0;
2337 if (DECL_EXTERNAL (newdecl
))
2339 TREE_STATIC (newdecl
) = TREE_STATIC (olddecl
);
2340 DECL_EXTERNAL (newdecl
) = DECL_EXTERNAL (olddecl
);
2342 /* An extern decl does not override previous storage class. */
2343 TREE_PUBLIC (newdecl
) = TREE_PUBLIC (olddecl
);
2344 if (!DECL_EXTERNAL (newdecl
))
2346 DECL_CONTEXT (newdecl
) = DECL_CONTEXT (olddecl
);
2347 DECL_COMMON (newdecl
) = DECL_COMMON (olddecl
);
2352 TREE_STATIC (olddecl
) = TREE_STATIC (newdecl
);
2353 TREE_PUBLIC (olddecl
) = TREE_PUBLIC (newdecl
);
2356 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
2358 /* If we're redefining a function previously defined as extern
2359 inline, make sure we emit debug info for the inline before we
2360 throw it away, in case it was inlined into a function that
2361 hasn't been written out yet. */
2362 if (new_is_definition
&& DECL_INITIAL (olddecl
))
2363 /* The new defn must not be inline. */
2364 DECL_UNINLINABLE (newdecl
) = 1;
2367 /* If either decl says `inline', this fn is inline, unless
2368 its definition was passed already. */
2369 if (DECL_DECLARED_INLINE_P (newdecl
)
2370 || DECL_DECLARED_INLINE_P (olddecl
))
2371 DECL_DECLARED_INLINE_P (newdecl
) = 1;
2373 DECL_UNINLINABLE (newdecl
) = DECL_UNINLINABLE (olddecl
)
2374 = (DECL_UNINLINABLE (newdecl
) || DECL_UNINLINABLE (olddecl
));
2376 DECL_DISREGARD_INLINE_LIMITS (newdecl
)
2377 = DECL_DISREGARD_INLINE_LIMITS (olddecl
)
2378 = (DECL_DISREGARD_INLINE_LIMITS (newdecl
)
2379 || DECL_DISREGARD_INLINE_LIMITS (olddecl
));
2382 if (DECL_BUILT_IN (olddecl
))
2384 /* If redeclaring a builtin function, it stays built in.
2385 But it gets tagged as having been declared. */
2386 DECL_BUILT_IN_CLASS (newdecl
) = DECL_BUILT_IN_CLASS (olddecl
);
2387 DECL_FUNCTION_CODE (newdecl
) = DECL_FUNCTION_CODE (olddecl
);
2388 C_DECL_DECLARED_BUILTIN (newdecl
) = 1;
2389 if (new_is_prototype
)
2391 C_DECL_BUILTIN_PROTOTYPE (newdecl
) = 0;
2392 if (DECL_BUILT_IN_CLASS (newdecl
) == BUILT_IN_NORMAL
)
2394 enum built_in_function fncode
= DECL_FUNCTION_CODE (newdecl
);
2397 /* If a compatible prototype of these builtin functions
2398 is seen, assume the runtime implements it with the
2399 expected semantics. */
2400 case BUILT_IN_STPCPY
:
2401 if (builtin_decl_explicit_p (fncode
))
2402 set_builtin_decl_implicit_p (fncode
, true);
2410 C_DECL_BUILTIN_PROTOTYPE (newdecl
)
2411 = C_DECL_BUILTIN_PROTOTYPE (olddecl
);
2414 /* Preserve function specific target and optimization options */
2415 if (DECL_FUNCTION_SPECIFIC_TARGET (olddecl
)
2416 && !DECL_FUNCTION_SPECIFIC_TARGET (newdecl
))
2417 DECL_FUNCTION_SPECIFIC_TARGET (newdecl
)
2418 = DECL_FUNCTION_SPECIFIC_TARGET (olddecl
);
2420 if (DECL_FUNCTION_SPECIFIC_OPTIMIZATION (olddecl
)
2421 && !DECL_FUNCTION_SPECIFIC_OPTIMIZATION (newdecl
))
2422 DECL_FUNCTION_SPECIFIC_OPTIMIZATION (newdecl
)
2423 = DECL_FUNCTION_SPECIFIC_OPTIMIZATION (olddecl
);
2425 /* Also preserve various other info from the definition. */
2426 if (!new_is_definition
)
2429 DECL_RESULT (newdecl
) = DECL_RESULT (olddecl
);
2430 DECL_INITIAL (newdecl
) = DECL_INITIAL (olddecl
);
2431 DECL_STRUCT_FUNCTION (newdecl
) = DECL_STRUCT_FUNCTION (olddecl
);
2432 DECL_SAVED_TREE (newdecl
) = DECL_SAVED_TREE (olddecl
);
2433 DECL_ARGUMENTS (newdecl
) = copy_list (DECL_ARGUMENTS (olddecl
));
2434 for (t
= DECL_ARGUMENTS (newdecl
); t
; t
= DECL_CHAIN (t
))
2435 DECL_CONTEXT (t
) = newdecl
;
2437 /* See if we've got a function to instantiate from. */
2438 if (DECL_SAVED_TREE (olddecl
))
2439 DECL_ABSTRACT_ORIGIN (newdecl
)
2440 = DECL_ABSTRACT_ORIGIN (olddecl
);
2444 /* Merge the USED information. */
2445 if (TREE_USED (olddecl
))
2446 TREE_USED (newdecl
) = 1;
2447 else if (TREE_USED (newdecl
))
2448 TREE_USED (olddecl
) = 1;
2449 if (TREE_CODE (olddecl
) == VAR_DECL
|| TREE_CODE (olddecl
) == PARM_DECL
)
2450 DECL_READ_P (newdecl
) |= DECL_READ_P (olddecl
);
2451 if (DECL_PRESERVE_P (olddecl
))
2452 DECL_PRESERVE_P (newdecl
) = 1;
2453 else if (DECL_PRESERVE_P (newdecl
))
2454 DECL_PRESERVE_P (olddecl
) = 1;
2456 /* Copy most of the decl-specific fields of NEWDECL into OLDDECL.
2457 But preserve OLDDECL's DECL_UID, DECL_CONTEXT and
2458 DECL_ARGUMENTS (if appropriate). */
2460 unsigned olddecl_uid
= DECL_UID (olddecl
);
2461 tree olddecl_context
= DECL_CONTEXT (olddecl
);
2462 tree olddecl_arguments
= NULL
;
2463 if (TREE_CODE (olddecl
) == FUNCTION_DECL
)
2464 olddecl_arguments
= DECL_ARGUMENTS (olddecl
);
2466 memcpy ((char *) olddecl
+ sizeof (struct tree_common
),
2467 (char *) newdecl
+ sizeof (struct tree_common
),
2468 sizeof (struct tree_decl_common
) - sizeof (struct tree_common
));
2469 DECL_USER_ALIGN (olddecl
) = DECL_USER_ALIGN (newdecl
);
2470 switch (TREE_CODE (olddecl
))
2480 memcpy ((char *) olddecl
+ sizeof (struct tree_decl_common
),
2481 (char *) newdecl
+ sizeof (struct tree_decl_common
),
2482 tree_code_size (TREE_CODE (olddecl
)) - sizeof (struct tree_decl_common
));
2487 memcpy ((char *) olddecl
+ sizeof (struct tree_decl_common
),
2488 (char *) newdecl
+ sizeof (struct tree_decl_common
),
2489 sizeof (struct tree_decl_non_common
) - sizeof (struct tree_decl_common
));
2491 DECL_UID (olddecl
) = olddecl_uid
;
2492 DECL_CONTEXT (olddecl
) = olddecl_context
;
2493 if (TREE_CODE (olddecl
) == FUNCTION_DECL
)
2494 DECL_ARGUMENTS (olddecl
) = olddecl_arguments
;
2497 /* If OLDDECL had its DECL_RTL instantiated, re-invoke make_decl_rtl
2498 so that encode_section_info has a chance to look at the new decl
2499 flags and attributes. */
2500 if (DECL_RTL_SET_P (olddecl
)
2501 && (TREE_CODE (olddecl
) == FUNCTION_DECL
2502 || (TREE_CODE (olddecl
) == VAR_DECL
2503 && TREE_STATIC (olddecl
))))
2504 make_decl_rtl (olddecl
);
2507 /* Handle when a new declaration NEWDECL has the same name as an old
2508 one OLDDECL in the same binding contour. Prints an error message
2511 If safely possible, alter OLDDECL to look like NEWDECL, and return
2512 true. Otherwise, return false. */
2515 duplicate_decls (tree newdecl
, tree olddecl
)
2517 tree newtype
= NULL
, oldtype
= NULL
;
2519 if (!diagnose_mismatched_decls (newdecl
, olddecl
, &newtype
, &oldtype
))
2521 /* Avoid `unused variable' and other warnings for OLDDECL. */
2522 TREE_NO_WARNING (olddecl
) = 1;
2526 merge_decls (newdecl
, olddecl
, newtype
, oldtype
);
2531 /* Check whether decl-node NEW_DECL shadows an existing declaration. */
2533 warn_if_shadowing (tree new_decl
)
2535 struct c_binding
*b
;
2537 /* Shadow warnings wanted? */
2539 /* No shadow warnings for internally generated vars. */
2540 || DECL_IS_BUILTIN (new_decl
)
2541 /* No shadow warnings for vars made for inlining. */
2542 || DECL_FROM_INLINE (new_decl
))
2545 /* Is anything being shadowed? Invisible decls do not count. */
2546 for (b
= I_SYMBOL_BINDING (DECL_NAME (new_decl
)); b
; b
= b
->shadowed
)
2547 if (b
->decl
&& b
->decl
!= new_decl
&& !b
->invisible
2548 && (b
->decl
== error_mark_node
2549 || diagnostic_report_warnings_p (global_dc
,
2550 DECL_SOURCE_LOCATION (b
->decl
))))
2552 tree old_decl
= b
->decl
;
2554 if (old_decl
== error_mark_node
)
2556 warning (OPT_Wshadow
, "declaration of %q+D shadows previous "
2557 "non-variable", new_decl
);
2560 else if (TREE_CODE (old_decl
) == PARM_DECL
)
2561 warning (OPT_Wshadow
, "declaration of %q+D shadows a parameter",
2563 else if (DECL_FILE_SCOPE_P (old_decl
))
2564 warning (OPT_Wshadow
, "declaration of %q+D shadows a global "
2565 "declaration", new_decl
);
2566 else if (TREE_CODE (old_decl
) == FUNCTION_DECL
2567 && DECL_BUILT_IN (old_decl
))
2569 warning (OPT_Wshadow
, "declaration of %q+D shadows "
2570 "a built-in function", new_decl
);
2574 warning (OPT_Wshadow
, "declaration of %q+D shadows a previous local",
2577 warning_at (DECL_SOURCE_LOCATION (old_decl
), OPT_Wshadow
,
2578 "shadowed declaration is here");
2584 /* Record a decl-node X as belonging to the current lexical scope.
2585 Check for errors (such as an incompatible declaration for the same
2586 name already seen in the same scope).
2588 Returns either X or an old decl for the same name.
2589 If an old decl is returned, it may have been smashed
2590 to agree with what X says. */
2595 tree name
= DECL_NAME (x
);
2596 struct c_scope
*scope
= current_scope
;
2597 struct c_binding
*b
;
2598 bool nested
= false;
2599 location_t locus
= DECL_SOURCE_LOCATION (x
);
2601 /* Must set DECL_CONTEXT for everything not at file scope or
2602 DECL_FILE_SCOPE_P won't work. Local externs don't count
2603 unless they have initializers (which generate code). */
2604 if (current_function_decl
2605 && ((TREE_CODE (x
) != FUNCTION_DECL
&& TREE_CODE (x
) != VAR_DECL
)
2606 || DECL_INITIAL (x
) || !DECL_EXTERNAL (x
)))
2607 DECL_CONTEXT (x
) = current_function_decl
;
2609 /* Anonymous decls are just inserted in the scope. */
2612 bind (name
, x
, scope
, /*invisible=*/false, /*nested=*/false,
2617 /* First, see if there is another declaration with the same name in
2618 the current scope. If there is, duplicate_decls may do all the
2619 work for us. If duplicate_decls returns false, that indicates
2620 two incompatible decls in the same scope; we are to silently
2621 replace the old one (duplicate_decls has issued all appropriate
2622 diagnostics). In particular, we should not consider possible
2623 duplicates in the external scope, or shadowing. */
2624 b
= I_SYMBOL_BINDING (name
);
2625 if (b
&& B_IN_SCOPE (b
, scope
))
2627 struct c_binding
*b_ext
, *b_use
;
2628 tree type
= TREE_TYPE (x
);
2629 tree visdecl
= b
->decl
;
2630 tree vistype
= TREE_TYPE (visdecl
);
2631 if (TREE_CODE (TREE_TYPE (x
)) == ARRAY_TYPE
2632 && COMPLETE_TYPE_P (TREE_TYPE (x
)))
2633 b
->inner_comp
= false;
2636 /* If this is an external linkage declaration, we should check
2637 for compatibility with the type in the external scope before
2638 setting the type at this scope based on the visible
2639 information only. */
2640 if (TREE_PUBLIC (x
) && TREE_PUBLIC (visdecl
))
2642 while (b_ext
&& !B_IN_EXTERNAL_SCOPE (b_ext
))
2643 b_ext
= b_ext
->shadowed
;
2648 TREE_TYPE (b_use
->decl
) = b_use
->u
.type
;
2651 if (duplicate_decls (x
, b_use
->decl
))
2655 /* Save the updated type in the external scope and
2656 restore the proper type for this scope. */
2658 if (comptypes (vistype
, type
))
2659 thistype
= composite_type (vistype
, type
);
2661 thistype
= TREE_TYPE (b_use
->decl
);
2662 b_use
->u
.type
= TREE_TYPE (b_use
->decl
);
2663 if (TREE_CODE (b_use
->decl
) == FUNCTION_DECL
2664 && DECL_BUILT_IN (b_use
->decl
))
2666 = build_type_attribute_variant (thistype
,
2669 TREE_TYPE (b_use
->decl
) = thistype
;
2674 goto skip_external_and_shadow_checks
;
2677 /* All declarations with external linkage, and all external
2678 references, go in the external scope, no matter what scope is
2679 current. However, the binding in that scope is ignored for
2680 purposes of normal name lookup. A separate binding structure is
2681 created in the requested scope; this governs the normal
2682 visibility of the symbol.
2684 The binding in the externals scope is used exclusively for
2685 detecting duplicate declarations of the same object, no matter
2686 what scope they are in; this is what we do here. (C99 6.2.7p2:
2687 All declarations that refer to the same object or function shall
2688 have compatible type; otherwise, the behavior is undefined.) */
2689 if (DECL_EXTERNAL (x
) || scope
== file_scope
)
2691 tree type
= TREE_TYPE (x
);
2694 bool type_saved
= false;
2695 if (b
&& !B_IN_EXTERNAL_SCOPE (b
)
2696 && (TREE_CODE (b
->decl
) == FUNCTION_DECL
2697 || TREE_CODE (b
->decl
) == VAR_DECL
)
2698 && DECL_FILE_SCOPE_P (b
->decl
))
2701 vistype
= TREE_TYPE (visdecl
);
2703 if (scope
!= file_scope
2704 && !DECL_IN_SYSTEM_HEADER (x
))
2705 warning (OPT_Wnested_externs
, "nested extern declaration of %qD", x
);
2707 while (b
&& !B_IN_EXTERNAL_SCOPE (b
))
2709 /* If this decl might be modified, save its type. This is
2710 done here rather than when the decl is first bound
2711 because the type may change after first binding, through
2712 being completed or through attributes being added. If we
2713 encounter multiple such decls, only the first should have
2714 its type saved; the others will already have had their
2715 proper types saved and the types will not have changed as
2716 their scopes will not have been re-entered. */
2717 if (DECL_P (b
->decl
) && DECL_FILE_SCOPE_P (b
->decl
) && !type_saved
)
2719 b
->u
.type
= TREE_TYPE (b
->decl
);
2722 if (B_IN_FILE_SCOPE (b
)
2723 && TREE_CODE (b
->decl
) == VAR_DECL
2724 && TREE_STATIC (b
->decl
)
2725 && TREE_CODE (TREE_TYPE (b
->decl
)) == ARRAY_TYPE
2726 && !TYPE_DOMAIN (TREE_TYPE (b
->decl
))
2727 && TREE_CODE (type
) == ARRAY_TYPE
2728 && TYPE_DOMAIN (type
)
2729 && TYPE_MAX_VALUE (TYPE_DOMAIN (type
))
2730 && !integer_zerop (TYPE_MAX_VALUE (TYPE_DOMAIN (type
))))
2732 /* Array type completed in inner scope, which should be
2733 diagnosed if the completion does not have size 1 and
2734 it does not get completed in the file scope. */
2735 b
->inner_comp
= true;
2740 /* If a matching external declaration has been found, set its
2741 type to the composite of all the types of that declaration.
2742 After the consistency checks, it will be reset to the
2743 composite of the visible types only. */
2744 if (b
&& (TREE_PUBLIC (x
) || same_translation_unit_p (x
, b
->decl
))
2746 TREE_TYPE (b
->decl
) = b
->u
.type
;
2748 /* The point of the same_translation_unit_p check here is,
2749 we want to detect a duplicate decl for a construct like
2750 foo() { extern bar(); } ... static bar(); but not if
2751 they are in different translation units. In any case,
2752 the static does not go in the externals scope. */
2754 && (TREE_PUBLIC (x
) || same_translation_unit_p (x
, b
->decl
))
2755 && duplicate_decls (x
, b
->decl
))
2760 if (comptypes (vistype
, type
))
2761 thistype
= composite_type (vistype
, type
);
2763 thistype
= TREE_TYPE (b
->decl
);
2767 b
->u
.type
= TREE_TYPE (b
->decl
);
2768 if (TREE_CODE (b
->decl
) == FUNCTION_DECL
&& DECL_BUILT_IN (b
->decl
))
2770 = build_type_attribute_variant (thistype
,
2771 TYPE_ATTRIBUTES (b
->u
.type
));
2772 TREE_TYPE (b
->decl
) = thistype
;
2773 bind (name
, b
->decl
, scope
, /*invisible=*/false, /*nested=*/true,
2777 else if (TREE_PUBLIC (x
))
2779 if (visdecl
&& !b
&& duplicate_decls (x
, visdecl
))
2781 /* An external declaration at block scope referring to a
2782 visible entity with internal linkage. The composite
2783 type will already be correct for this scope, so we
2784 just need to fall through to make the declaration in
2791 bind (name
, x
, external_scope
, /*invisible=*/true,
2792 /*nested=*/false, locus
);
2798 if (TREE_CODE (x
) != PARM_DECL
)
2799 warn_if_shadowing (x
);
2801 skip_external_and_shadow_checks
:
2802 if (TREE_CODE (x
) == TYPE_DECL
)
2804 /* So this is a typedef, set its underlying type. */
2805 set_underlying_type (x
);
2807 /* If X is a typedef defined in the current function, record it
2808 for the purpose of implementing the -Wunused-local-typedefs
2810 record_locally_defined_typedef (x
);
2813 bind (name
, x
, scope
, /*invisible=*/false, nested
, locus
);
2815 /* If x's type is incomplete because it's based on a
2816 structure or union which has not yet been fully declared,
2817 attach it to that structure or union type, so we can go
2818 back and complete the variable declaration later, if the
2819 structure or union gets fully declared.
2821 If the input is erroneous, we can have error_mark in the type
2822 slot (e.g. "f(void a, ...)") - that doesn't count as an
2824 if (TREE_TYPE (x
) != error_mark_node
2825 && !COMPLETE_TYPE_P (TREE_TYPE (x
)))
2827 tree element
= TREE_TYPE (x
);
2829 while (TREE_CODE (element
) == ARRAY_TYPE
)
2830 element
= TREE_TYPE (element
);
2831 element
= TYPE_MAIN_VARIANT (element
);
2833 if ((TREE_CODE (element
) == RECORD_TYPE
2834 || TREE_CODE (element
) == UNION_TYPE
)
2835 && (TREE_CODE (x
) != TYPE_DECL
2836 || TREE_CODE (TREE_TYPE (x
)) == ARRAY_TYPE
)
2837 && !COMPLETE_TYPE_P (element
))
2838 C_TYPE_INCOMPLETE_VARS (element
)
2839 = tree_cons (NULL_TREE
, x
, C_TYPE_INCOMPLETE_VARS (element
));
2844 /* Record X as belonging to file scope.
2845 This is used only internally by the Objective-C front end,
2846 and is limited to its needs. duplicate_decls is not called;
2847 if there is any preexisting decl for this identifier, it is an ICE. */
2850 pushdecl_top_level (tree x
)
2853 bool nested
= false;
2854 gcc_assert (TREE_CODE (x
) == VAR_DECL
|| TREE_CODE (x
) == CONST_DECL
);
2856 name
= DECL_NAME (x
);
2858 gcc_assert (TREE_CODE (x
) == CONST_DECL
|| !I_SYMBOL_BINDING (name
));
2860 if (TREE_PUBLIC (x
))
2862 bind (name
, x
, external_scope
, /*invisible=*/true, /*nested=*/false,
2867 bind (name
, x
, file_scope
, /*invisible=*/false, nested
, UNKNOWN_LOCATION
);
2873 implicit_decl_warning (tree id
, tree olddecl
)
2875 if (warn_implicit_function_declaration
)
2880 warned
= pedwarn (input_location
, OPT_Wimplicit_function_declaration
,
2881 "implicit declaration of function %qE", id
);
2883 warned
= warning (OPT_Wimplicit_function_declaration
,
2884 G_("implicit declaration of function %qE"), id
);
2885 if (olddecl
&& warned
)
2886 locate_old_decl (olddecl
);
2890 /* Generate an implicit declaration for identifier FUNCTIONID at LOC as a
2891 function of type int (). */
2894 implicitly_declare (location_t loc
, tree functionid
)
2896 struct c_binding
*b
;
2900 for (b
= I_SYMBOL_BINDING (functionid
); b
; b
= b
->shadowed
)
2902 if (B_IN_SCOPE (b
, external_scope
))
2911 if (decl
== error_mark_node
)
2914 /* FIXME: Objective-C has weird not-really-builtin functions
2915 which are supposed to be visible automatically. They wind up
2916 in the external scope because they're pushed before the file
2917 scope gets created. Catch this here and rebind them into the
2919 if (!DECL_BUILT_IN (decl
) && DECL_IS_BUILTIN (decl
))
2921 bind (functionid
, decl
, file_scope
,
2922 /*invisible=*/false, /*nested=*/true,
2923 DECL_SOURCE_LOCATION (decl
));
2928 tree newtype
= default_function_type
;
2930 TREE_TYPE (decl
) = b
->u
.type
;
2931 /* Implicit declaration of a function already declared
2932 (somehow) in a different scope, or as a built-in.
2933 If this is the first time this has happened, warn;
2934 then recycle the old declaration but with the new type. */
2935 if (!C_DECL_IMPLICIT (decl
))
2937 implicit_decl_warning (functionid
, decl
);
2938 C_DECL_IMPLICIT (decl
) = 1;
2940 if (DECL_BUILT_IN (decl
))
2942 newtype
= build_type_attribute_variant (newtype
,
2944 (TREE_TYPE (decl
)));
2945 if (!comptypes (newtype
, TREE_TYPE (decl
)))
2947 warning_at (loc
, 0, "incompatible implicit declaration of "
2948 "built-in function %qD", decl
);
2949 newtype
= TREE_TYPE (decl
);
2954 if (!comptypes (newtype
, TREE_TYPE (decl
)))
2956 error_at (loc
, "incompatible implicit declaration of function %qD", decl
);
2957 locate_old_decl (decl
);
2960 b
->u
.type
= TREE_TYPE (decl
);
2961 TREE_TYPE (decl
) = newtype
;
2962 bind (functionid
, decl
, current_scope
,
2963 /*invisible=*/false, /*nested=*/true,
2964 DECL_SOURCE_LOCATION (decl
));
2969 /* Not seen before. */
2970 decl
= build_decl (loc
, FUNCTION_DECL
, functionid
, default_function_type
);
2971 DECL_EXTERNAL (decl
) = 1;
2972 TREE_PUBLIC (decl
) = 1;
2973 C_DECL_IMPLICIT (decl
) = 1;
2974 implicit_decl_warning (functionid
, 0);
2975 asmspec_tree
= maybe_apply_renaming_pragma (decl
, /*asmname=*/NULL
);
2977 set_user_assembler_name (decl
, TREE_STRING_POINTER (asmspec_tree
));
2979 /* C89 says implicit declarations are in the innermost block.
2980 So we record the decl in the standard fashion. */
2981 decl
= pushdecl (decl
);
2983 /* No need to call objc_check_decl here - it's a function type. */
2984 rest_of_decl_compilation (decl
, 0, 0);
2986 /* Write a record describing this implicit function declaration
2987 to the prototypes file (if requested). */
2988 gen_aux_info_record (decl
, 0, 1, 0);
2990 /* Possibly apply some default attributes to this implicit declaration. */
2991 decl_attributes (&decl
, NULL_TREE
, 0);
2996 /* Issue an error message for a reference to an undeclared variable
2997 ID, including a reference to a builtin outside of function-call
2998 context. Establish a binding of the identifier to error_mark_node
2999 in an appropriate scope, which will suppress further errors for the
3000 same identifier. The error message should be given location LOC. */
3002 undeclared_variable (location_t loc
, tree id
)
3004 static bool already
= false;
3005 struct c_scope
*scope
;
3007 if (current_function_decl
== 0)
3009 error_at (loc
, "%qE undeclared here (not in a function)", id
);
3010 scope
= current_scope
;
3014 if (!objc_diagnose_private_ivar (id
))
3015 error_at (loc
, "%qE undeclared (first use in this function)", id
);
3018 inform (loc
, "each undeclared identifier is reported only"
3019 " once for each function it appears in");
3023 /* If we are parsing old-style parameter decls, current_function_decl
3024 will be nonnull but current_function_scope will be null. */
3025 scope
= current_function_scope
? current_function_scope
: current_scope
;
3027 bind (id
, error_mark_node
, scope
, /*invisible=*/false, /*nested=*/false,
3031 /* Subroutine of lookup_label, declare_label, define_label: construct a
3032 LABEL_DECL with all the proper frills. Also create a struct
3033 c_label_vars initialized for the current scope. */
3036 make_label (location_t location
, tree name
, bool defining
,
3037 struct c_label_vars
**p_label_vars
)
3039 tree label
= build_decl (location
, LABEL_DECL
, name
, void_type_node
);
3040 struct c_label_vars
*label_vars
;
3042 DECL_CONTEXT (label
) = current_function_decl
;
3043 DECL_MODE (label
) = VOIDmode
;
3045 label_vars
= ggc_alloc_c_label_vars ();
3046 label_vars
->shadowed
= NULL
;
3047 set_spot_bindings (&label_vars
->label_bindings
, defining
);
3048 label_vars
->decls_in_scope
= make_tree_vector ();
3049 label_vars
->gotos
= VEC_alloc (c_goto_bindings_p
, gc
, 0);
3050 *p_label_vars
= label_vars
;
3055 /* Get the LABEL_DECL corresponding to identifier NAME as a label.
3056 Create one if none exists so far for the current function.
3057 This is called when a label is used in a goto expression or
3058 has its address taken. */
3061 lookup_label (tree name
)
3064 struct c_label_vars
*label_vars
;
3066 if (current_function_scope
== 0)
3068 error ("label %qE referenced outside of any function", name
);
3072 /* Use a label already defined or ref'd with this name, but not if
3073 it is inherited from a containing function and wasn't declared
3075 label
= I_LABEL_DECL (name
);
3076 if (label
&& (DECL_CONTEXT (label
) == current_function_decl
3077 || C_DECLARED_LABEL_FLAG (label
)))
3079 /* If the label has only been declared, update its apparent
3080 location to point here, for better diagnostics if it
3081 turns out not to have been defined. */
3082 if (DECL_INITIAL (label
) == NULL_TREE
)
3083 DECL_SOURCE_LOCATION (label
) = input_location
;
3087 /* No label binding for that identifier; make one. */
3088 label
= make_label (input_location
, name
, false, &label_vars
);
3090 /* Ordinary labels go in the current function scope. */
3091 bind_label (name
, label
, current_function_scope
, label_vars
);
3096 /* Issue a warning about DECL for a goto statement at GOTO_LOC going
3100 warn_about_goto (location_t goto_loc
, tree label
, tree decl
)
3102 if (variably_modified_type_p (TREE_TYPE (decl
), NULL_TREE
))
3104 "jump into scope of identifier with variably modified type");
3106 warning_at (goto_loc
, OPT_Wjump_misses_init
,
3107 "jump skips variable initialization");
3108 inform (DECL_SOURCE_LOCATION (label
), "label %qD defined here", label
);
3109 inform (DECL_SOURCE_LOCATION (decl
), "%qD declared here", decl
);
3112 /* Look up a label because of a goto statement. This is like
3113 lookup_label, but also issues any appropriate warnings. */
3116 lookup_label_for_goto (location_t loc
, tree name
)
3119 struct c_label_vars
*label_vars
;
3123 label
= lookup_label (name
);
3124 if (label
== NULL_TREE
)
3127 /* If we are jumping to a different function, we can't issue any
3129 if (DECL_CONTEXT (label
) != current_function_decl
)
3131 gcc_assert (C_DECLARED_LABEL_FLAG (label
));
3135 label_vars
= I_LABEL_BINDING (name
)->u
.label
;
3137 /* If the label has not yet been defined, then push this goto on a
3138 list for possible later warnings. */
3139 if (label_vars
->label_bindings
.scope
== NULL
)
3141 struct c_goto_bindings
*g
;
3143 g
= ggc_alloc_c_goto_bindings ();
3145 set_spot_bindings (&g
->goto_bindings
, true);
3146 VEC_safe_push (c_goto_bindings_p
, gc
, label_vars
->gotos
, g
);
3150 /* If there are any decls in label_vars->decls_in_scope, then this
3151 goto has missed the declaration of the decl. This happens for a
3157 Issue a warning or error. */
3158 FOR_EACH_VEC_ELT (tree
, label_vars
->decls_in_scope
, ix
, decl
)
3159 warn_about_goto (loc
, label
, decl
);
3161 if (label_vars
->label_bindings
.left_stmt_expr
)
3163 error_at (loc
, "jump into statement expression");
3164 inform (DECL_SOURCE_LOCATION (label
), "label %qD defined here", label
);
3170 /* Make a label named NAME in the current function, shadowing silently
3171 any that may be inherited from containing functions or containing
3172 scopes. This is called for __label__ declarations. */
3175 declare_label (tree name
)
3177 struct c_binding
*b
= I_LABEL_BINDING (name
);
3179 struct c_label_vars
*label_vars
;
3181 /* Check to make sure that the label hasn't already been declared
3183 if (b
&& B_IN_CURRENT_SCOPE (b
))
3185 error ("duplicate label declaration %qE", name
);
3186 locate_old_decl (b
->decl
);
3188 /* Just use the previous declaration. */
3192 label
= make_label (input_location
, name
, false, &label_vars
);
3193 C_DECLARED_LABEL_FLAG (label
) = 1;
3195 /* Declared labels go in the current scope. */
3196 bind_label (name
, label
, current_scope
, label_vars
);
3201 /* When we define a label, issue any appropriate warnings if there are
3202 any gotos earlier in the function which jump to this label. */
3205 check_earlier_gotos (tree label
, struct c_label_vars
* label_vars
)
3208 struct c_goto_bindings
*g
;
3210 FOR_EACH_VEC_ELT (c_goto_bindings_p
, label_vars
->gotos
, ix
, g
)
3212 struct c_binding
*b
;
3213 struct c_scope
*scope
;
3215 /* We have a goto to this label. The goto is going forward. In
3216 g->scope, the goto is going to skip any binding which was
3217 defined after g->bindings_in_scope. */
3218 if (g
->goto_bindings
.scope
->has_jump_unsafe_decl
)
3220 for (b
= g
->goto_bindings
.scope
->bindings
;
3221 b
!= g
->goto_bindings
.bindings_in_scope
;
3224 if (decl_jump_unsafe (b
->decl
))
3225 warn_about_goto (g
->loc
, label
, b
->decl
);
3229 /* We also need to warn about decls defined in any scopes
3230 between the scope of the label and the scope of the goto. */
3231 for (scope
= label_vars
->label_bindings
.scope
;
3232 scope
!= g
->goto_bindings
.scope
;
3233 scope
= scope
->outer
)
3235 gcc_assert (scope
!= NULL
);
3236 if (scope
->has_jump_unsafe_decl
)
3238 if (scope
== label_vars
->label_bindings
.scope
)
3239 b
= label_vars
->label_bindings
.bindings_in_scope
;
3241 b
= scope
->bindings
;
3242 for (; b
!= NULL
; b
= b
->prev
)
3244 if (decl_jump_unsafe (b
->decl
))
3245 warn_about_goto (g
->loc
, label
, b
->decl
);
3250 if (g
->goto_bindings
.stmt_exprs
> 0)
3252 error_at (g
->loc
, "jump into statement expression");
3253 inform (DECL_SOURCE_LOCATION (label
), "label %qD defined here",
3258 /* Now that the label is defined, we will issue warnings about
3259 subsequent gotos to this label when we see them. */
3260 VEC_truncate (c_goto_bindings_p
, label_vars
->gotos
, 0);
3261 label_vars
->gotos
= NULL
;
3264 /* Define a label, specifying the location in the source file.
3265 Return the LABEL_DECL node for the label, if the definition is valid.
3266 Otherwise return 0. */
3269 define_label (location_t location
, tree name
)
3271 /* Find any preexisting label with this name. It is an error
3272 if that label has already been defined in this function, or
3273 if there is a containing function with a declared label with
3275 tree label
= I_LABEL_DECL (name
);
3278 && ((DECL_CONTEXT (label
) == current_function_decl
3279 && DECL_INITIAL (label
) != 0)
3280 || (DECL_CONTEXT (label
) != current_function_decl
3281 && C_DECLARED_LABEL_FLAG (label
))))
3283 error_at (location
, "duplicate label %qD", label
);
3284 locate_old_decl (label
);
3287 else if (label
&& DECL_CONTEXT (label
) == current_function_decl
)
3289 struct c_label_vars
*label_vars
= I_LABEL_BINDING (name
)->u
.label
;
3291 /* The label has been used or declared already in this function,
3292 but not defined. Update its location to point to this
3294 DECL_SOURCE_LOCATION (label
) = location
;
3295 set_spot_bindings (&label_vars
->label_bindings
, true);
3297 /* Issue warnings as required about any goto statements from
3298 earlier in the function. */
3299 check_earlier_gotos (label
, label_vars
);
3303 struct c_label_vars
*label_vars
;
3305 /* No label binding for that identifier; make one. */
3306 label
= make_label (location
, name
, true, &label_vars
);
3308 /* Ordinary labels go in the current function scope. */
3309 bind_label (name
, label
, current_function_scope
, label_vars
);
3312 if (!in_system_header
&& lookup_name (name
))
3313 warning_at (location
, OPT_Wtraditional
,
3314 "traditional C lacks a separate namespace "
3315 "for labels, identifier %qE conflicts", name
);
3317 /* Mark label as having been defined. */
3318 DECL_INITIAL (label
) = error_mark_node
;
3322 /* Get the bindings for a new switch statement. This is used to issue
3323 warnings as appropriate for jumps from the switch to case or
3326 struct c_spot_bindings
*
3327 c_get_switch_bindings (void)
3329 struct c_spot_bindings
*switch_bindings
;
3331 switch_bindings
= XNEW (struct c_spot_bindings
);
3332 set_spot_bindings (switch_bindings
, true);
3333 return switch_bindings
;
3337 c_release_switch_bindings (struct c_spot_bindings
*bindings
)
3339 gcc_assert (bindings
->stmt_exprs
== 0 && !bindings
->left_stmt_expr
);
3343 /* This is called at the point of a case or default label to issue
3344 warnings about decls as needed. It returns true if it found an
3345 error, not just a warning. */
3348 c_check_switch_jump_warnings (struct c_spot_bindings
*switch_bindings
,
3349 location_t switch_loc
, location_t case_loc
)
3352 struct c_scope
*scope
;
3355 for (scope
= current_scope
;
3356 scope
!= switch_bindings
->scope
;
3357 scope
= scope
->outer
)
3359 struct c_binding
*b
;
3361 gcc_assert (scope
!= NULL
);
3363 if (!scope
->has_jump_unsafe_decl
)
3366 for (b
= scope
->bindings
; b
!= NULL
; b
= b
->prev
)
3368 if (decl_jump_unsafe (b
->decl
))
3370 if (variably_modified_type_p (TREE_TYPE (b
->decl
), NULL_TREE
))
3374 ("switch jumps into scope of identifier with "
3375 "variably modified type"));
3378 warning_at (case_loc
, OPT_Wjump_misses_init
,
3379 "switch jumps over variable initialization");
3380 inform (switch_loc
, "switch starts here");
3381 inform (DECL_SOURCE_LOCATION (b
->decl
), "%qD declared here",
3387 if (switch_bindings
->stmt_exprs
> 0)
3390 error_at (case_loc
, "switch jumps into statement expression");
3391 inform (switch_loc
, "switch starts here");
3397 /* Given NAME, an IDENTIFIER_NODE,
3398 return the structure (or union or enum) definition for that name.
3399 If THISLEVEL_ONLY is nonzero, searches only the current_scope.
3400 CODE says which kind of type the caller wants;
3401 it is RECORD_TYPE or UNION_TYPE or ENUMERAL_TYPE.
3402 If PLOC is not NULL and this returns non-null, it sets *PLOC to the
3403 location where the tag was defined.
3404 If the wrong kind of type is found, an error is reported. */
3407 lookup_tag (enum tree_code code
, tree name
, int thislevel_only
,
3410 struct c_binding
*b
= I_TAG_BINDING (name
);
3416 /* We only care about whether it's in this level if
3417 thislevel_only was set or it might be a type clash. */
3418 if (thislevel_only
|| TREE_CODE (b
->decl
) != code
)
3420 /* For our purposes, a tag in the external scope is the same as
3421 a tag in the file scope. (Primarily relevant to Objective-C
3422 and its builtin structure tags, which get pushed before the
3423 file scope is created.) */
3424 if (B_IN_CURRENT_SCOPE (b
)
3425 || (current_scope
== file_scope
&& B_IN_EXTERNAL_SCOPE (b
)))
3429 if (thislevel_only
&& !thislevel
)
3432 if (TREE_CODE (b
->decl
) != code
)
3434 /* Definition isn't the kind we were looking for. */
3435 pending_invalid_xref
= name
;
3436 pending_invalid_xref_location
= input_location
;
3438 /* If in the same binding level as a declaration as a tag
3439 of a different type, this must not be allowed to
3440 shadow that tag, so give the error immediately.
3441 (For example, "struct foo; union foo;" is invalid.) */
3443 pending_xref_error ();
3452 /* Print an error message now
3453 for a recent invalid struct, union or enum cross reference.
3454 We don't print them immediately because they are not invalid
3455 when used in the `struct foo;' construct for shadowing. */
3458 pending_xref_error (void)
3460 if (pending_invalid_xref
!= 0)
3461 error_at (pending_invalid_xref_location
, "%qE defined as wrong kind of tag",
3462 pending_invalid_xref
);
3463 pending_invalid_xref
= 0;
3467 /* Look up NAME in the current scope and its superiors
3468 in the namespace of variables, functions and typedefs.
3469 Return a ..._DECL node of some kind representing its definition,
3470 or return 0 if it is undefined. */
3473 lookup_name (tree name
)
3475 struct c_binding
*b
= I_SYMBOL_BINDING (name
);
3476 if (b
&& !b
->invisible
)
3478 maybe_record_typedef_use (b
->decl
);
3484 /* Similar to `lookup_name' but look only at the indicated scope. */
3487 lookup_name_in_scope (tree name
, struct c_scope
*scope
)
3489 struct c_binding
*b
;
3491 for (b
= I_SYMBOL_BINDING (name
); b
; b
= b
->shadowed
)
3492 if (B_IN_SCOPE (b
, scope
))
3497 /* Create the predefined scalar types of C,
3498 and some nodes representing standard constants (0, 1, (void *) 0).
3499 Initialize the global scope.
3500 Make definitions for built-in primitive functions. */
3503 c_init_decl_processing (void)
3505 location_t save_loc
= input_location
;
3507 /* Initialize reserved words for parser. */
3510 current_function_decl
= 0;
3512 gcc_obstack_init (&parser_obstack
);
3514 /* Make the externals scope. */
3516 external_scope
= current_scope
;
3518 /* Declarations from c_common_nodes_and_builtins must not be associated
3519 with this input file, lest we get differences between using and not
3520 using preprocessed headers. */
3521 input_location
= BUILTINS_LOCATION
;
3523 c_common_nodes_and_builtins ();
3525 /* In C, comparisons and TRUTH_* expressions have type int. */
3526 truthvalue_type_node
= integer_type_node
;
3527 truthvalue_true_node
= integer_one_node
;
3528 truthvalue_false_node
= integer_zero_node
;
3530 /* Even in C99, which has a real boolean type. */
3531 pushdecl (build_decl (UNKNOWN_LOCATION
, TYPE_DECL
, get_identifier ("_Bool"),
3532 boolean_type_node
));
3534 input_location
= save_loc
;
3536 pedantic_lvalues
= true;
3538 make_fname_decl
= c_make_fname_decl
;
3539 start_fname_decls ();
3542 /* Create the VAR_DECL at LOC for __FUNCTION__ etc. ID is the name to
3543 give the decl, NAME is the initialization string and TYPE_DEP
3544 indicates whether NAME depended on the type of the function. As we
3545 don't yet implement delayed emission of static data, we mark the
3546 decl as emitted so it is not placed in the output. Anything using
3547 it must therefore pull out the STRING_CST initializer directly.
3551 c_make_fname_decl (location_t loc
, tree id
, int type_dep
)
3553 const char *name
= fname_as_string (type_dep
);
3554 tree decl
, type
, init
;
3555 size_t length
= strlen (name
);
3557 type
= build_array_type (char_type_node
,
3558 build_index_type (size_int (length
)));
3559 type
= c_build_qualified_type (type
, TYPE_QUAL_CONST
);
3561 decl
= build_decl (loc
, VAR_DECL
, id
, type
);
3563 TREE_STATIC (decl
) = 1;
3564 TREE_READONLY (decl
) = 1;
3565 DECL_ARTIFICIAL (decl
) = 1;
3567 init
= build_string (length
+ 1, name
);
3568 free (CONST_CAST (char *, name
));
3569 TREE_TYPE (init
) = type
;
3570 DECL_INITIAL (decl
) = init
;
3572 TREE_USED (decl
) = 1;
3574 if (current_function_decl
3575 /* For invalid programs like this:
3578 const char* p = __FUNCTION__;
3580 the __FUNCTION__ is believed to appear in K&R style function
3581 parameter declarator. In that case we still don't have
3583 && (!seen_error () || current_function_scope
))
3585 DECL_CONTEXT (decl
) = current_function_decl
;
3586 bind (id
, decl
, current_function_scope
,
3587 /*invisible=*/false, /*nested=*/false, UNKNOWN_LOCATION
);
3590 finish_decl (decl
, loc
, init
, NULL_TREE
, NULL_TREE
);
3596 c_builtin_function (tree decl
)
3598 tree type
= TREE_TYPE (decl
);
3599 tree id
= DECL_NAME (decl
);
3601 const char *name
= IDENTIFIER_POINTER (id
);
3602 C_DECL_BUILTIN_PROTOTYPE (decl
) = prototype_p (type
);
3604 /* Should never be called on a symbol with a preexisting meaning. */
3605 gcc_assert (!I_SYMBOL_BINDING (id
));
3607 bind (id
, decl
, external_scope
, /*invisible=*/true, /*nested=*/false,
3610 /* Builtins in the implementation namespace are made visible without
3611 needing to be explicitly declared. See push_file_scope. */
3612 if (name
[0] == '_' && (name
[1] == '_' || ISUPPER (name
[1])))
3614 DECL_CHAIN (decl
) = visible_builtins
;
3615 visible_builtins
= decl
;
3622 c_builtin_function_ext_scope (tree decl
)
3624 tree type
= TREE_TYPE (decl
);
3625 tree id
= DECL_NAME (decl
);
3627 const char *name
= IDENTIFIER_POINTER (id
);
3628 C_DECL_BUILTIN_PROTOTYPE (decl
) = prototype_p (type
);
3630 /* Should never be called on a symbol with a preexisting meaning. */
3631 gcc_assert (!I_SYMBOL_BINDING (id
));
3633 bind (id
, decl
, external_scope
, /*invisible=*/false, /*nested=*/false,
3636 /* Builtins in the implementation namespace are made visible without
3637 needing to be explicitly declared. See push_file_scope. */
3638 if (name
[0] == '_' && (name
[1] == '_' || ISUPPER (name
[1])))
3640 DECL_CHAIN (decl
) = visible_builtins
;
3641 visible_builtins
= decl
;
3647 /* Called when a declaration is seen that contains no names to declare.
3648 If its type is a reference to a structure, union or enum inherited
3649 from a containing scope, shadow that tag name for the current scope
3650 with a forward reference.
3651 If its type defines a new named structure or union
3652 or defines an enum, it is valid but we need not do anything here.
3653 Otherwise, it is an error. */
3656 shadow_tag (const struct c_declspecs
*declspecs
)
3658 shadow_tag_warned (declspecs
, 0);
3661 /* WARNED is 1 if we have done a pedwarn, 2 if we have done a warning,
3664 shadow_tag_warned (const struct c_declspecs
*declspecs
, int warned
)
3666 bool found_tag
= false;
3668 if (declspecs
->type
&& !declspecs
->default_int_p
&& !declspecs
->typedef_p
)
3670 tree value
= declspecs
->type
;
3671 enum tree_code code
= TREE_CODE (value
);
3673 if (code
== RECORD_TYPE
|| code
== UNION_TYPE
|| code
== ENUMERAL_TYPE
)
3674 /* Used to test also that TYPE_SIZE (value) != 0.
3675 That caused warning for `struct foo;' at top level in the file. */
3677 tree name
= TYPE_NAME (value
);
3682 if (declspecs
->restrict_p
)
3684 error ("invalid use of %<restrict%>");
3690 if (warned
!= 1 && code
!= ENUMERAL_TYPE
)
3691 /* Empty unnamed enum OK */
3693 pedwarn (input_location
, 0,
3694 "unnamed struct/union that defines no instances");
3698 else if (declspecs
->typespec_kind
!= ctsk_tagdef
3699 && declspecs
->typespec_kind
!= ctsk_tagfirstref
3700 && declspecs
->storage_class
!= csc_none
)
3703 pedwarn (input_location
, 0,
3704 "empty declaration with storage class specifier "
3705 "does not redeclare tag");
3707 pending_xref_error ();
3709 else if (declspecs
->typespec_kind
!= ctsk_tagdef
3710 && declspecs
->typespec_kind
!= ctsk_tagfirstref
3711 && (declspecs
->const_p
3712 || declspecs
->volatile_p
3713 || declspecs
->restrict_p
3714 || declspecs
->address_space
))
3717 pedwarn (input_location
, 0,
3718 "empty declaration with type qualifier "
3719 "does not redeclare tag");
3721 pending_xref_error ();
3723 else if (declspecs
->typespec_kind
!= ctsk_tagdef
3724 && declspecs
->typespec_kind
!= ctsk_tagfirstref
3725 && declspecs
->alignas_p
)
3728 pedwarn (input_location
, 0,
3729 "empty declaration with %<_Alignas%> "
3730 "does not redeclare tag");
3732 pending_xref_error ();
3736 pending_invalid_xref
= 0;
3737 t
= lookup_tag (code
, name
, 1, NULL
);
3741 t
= make_node (code
);
3742 pushtag (input_location
, name
, t
);
3748 if (warned
!= 1 && !in_system_header
)
3750 pedwarn (input_location
, 0,
3751 "useless type name in empty declaration");
3756 else if (warned
!= 1 && !in_system_header
&& declspecs
->typedef_p
)
3758 pedwarn (input_location
, 0, "useless type name in empty declaration");
3762 pending_invalid_xref
= 0;
3764 if (declspecs
->inline_p
)
3766 error ("%<inline%> in empty declaration");
3770 if (declspecs
->noreturn_p
)
3772 error ("%<_Noreturn%> in empty declaration");
3776 if (current_scope
== file_scope
&& declspecs
->storage_class
== csc_auto
)
3778 error ("%<auto%> in file-scope empty declaration");
3782 if (current_scope
== file_scope
&& declspecs
->storage_class
== csc_register
)
3784 error ("%<register%> in file-scope empty declaration");
3788 if (!warned
&& !in_system_header
&& declspecs
->storage_class
!= csc_none
)
3790 warning (0, "useless storage class specifier in empty declaration");
3794 if (!warned
&& !in_system_header
&& declspecs
->thread_p
)
3796 warning (0, "useless %<__thread%> in empty declaration");
3800 if (!warned
&& !in_system_header
&& (declspecs
->const_p
3801 || declspecs
->volatile_p
3802 || declspecs
->restrict_p
3803 || declspecs
->address_space
))
3805 warning (0, "useless type qualifier in empty declaration");
3809 if (!warned
&& !in_system_header
&& declspecs
->alignas_p
)
3811 warning (0, "useless %<_Alignas%> in empty declaration");
3818 pedwarn (input_location
, 0, "empty declaration");
3823 /* Return the qualifiers from SPECS as a bitwise OR of TYPE_QUAL_*
3824 bits. SPECS represents declaration specifiers that the grammar
3825 only permits to contain type qualifiers and attributes. */
3828 quals_from_declspecs (const struct c_declspecs
*specs
)
3830 int quals
= ((specs
->const_p
? TYPE_QUAL_CONST
: 0)
3831 | (specs
->volatile_p
? TYPE_QUAL_VOLATILE
: 0)
3832 | (specs
->restrict_p
? TYPE_QUAL_RESTRICT
: 0)
3833 | (ENCODE_QUAL_ADDR_SPACE (specs
->address_space
)));
3834 gcc_assert (!specs
->type
3835 && !specs
->decl_attr
3836 && specs
->typespec_word
== cts_none
3837 && specs
->storage_class
== csc_none
3838 && !specs
->typedef_p
3839 && !specs
->explicit_signed_p
3840 && !specs
->deprecated_p
3842 && !specs
->long_long_p
3845 && !specs
->unsigned_p
3846 && !specs
->complex_p
3848 && !specs
->noreturn_p
3849 && !specs
->thread_p
);
3853 /* Construct an array declarator. LOC is the location of the
3854 beginning of the array (usually the opening brace). EXPR is the
3855 expression inside [], or NULL_TREE. QUALS are the type qualifiers
3856 inside the [] (to be applied to the pointer to which a parameter
3857 array is converted). STATIC_P is true if "static" is inside the
3858 [], false otherwise. VLA_UNSPEC_P is true if the array is [*], a
3859 VLA of unspecified length which is nevertheless a complete type,
3860 false otherwise. The field for the contained declarator is left to
3861 be filled in by set_array_declarator_inner. */
3863 struct c_declarator
*
3864 build_array_declarator (location_t loc
,
3865 tree expr
, struct c_declspecs
*quals
, bool static_p
,
3868 struct c_declarator
*declarator
= XOBNEW (&parser_obstack
,
3869 struct c_declarator
);
3870 declarator
->id_loc
= loc
;
3871 declarator
->kind
= cdk_array
;
3872 declarator
->declarator
= 0;
3873 declarator
->u
.array
.dimen
= expr
;
3876 declarator
->u
.array
.attrs
= quals
->attrs
;
3877 declarator
->u
.array
.quals
= quals_from_declspecs (quals
);
3881 declarator
->u
.array
.attrs
= NULL_TREE
;
3882 declarator
->u
.array
.quals
= 0;
3884 declarator
->u
.array
.static_p
= static_p
;
3885 declarator
->u
.array
.vla_unspec_p
= vla_unspec_p
;
3888 if (static_p
|| quals
!= NULL
)
3889 pedwarn (loc
, OPT_Wpedantic
,
3890 "ISO C90 does not support %<static%> or type "
3891 "qualifiers in parameter array declarators");
3893 pedwarn (loc
, OPT_Wpedantic
,
3894 "ISO C90 does not support %<[*]%> array declarators");
3898 if (!current_scope
->parm_flag
)
3901 error_at (loc
, "%<[*]%> not allowed in other than "
3902 "function prototype scope");
3903 declarator
->u
.array
.vla_unspec_p
= false;
3906 current_scope
->had_vla_unspec
= true;
3911 /* Set the contained declarator of an array declarator. DECL is the
3912 declarator, as constructed by build_array_declarator; INNER is what
3913 appears on the left of the []. */
3915 struct c_declarator
*
3916 set_array_declarator_inner (struct c_declarator
*decl
,
3917 struct c_declarator
*inner
)
3919 decl
->declarator
= inner
;
3923 /* INIT is a constructor that forms DECL's initializer. If the final
3924 element initializes a flexible array field, add the size of that
3925 initializer to DECL's size. */
3928 add_flexible_array_elts_to_size (tree decl
, tree init
)
3932 if (VEC_empty (constructor_elt
, CONSTRUCTOR_ELTS (init
)))
3935 elt
= VEC_last (constructor_elt
, CONSTRUCTOR_ELTS (init
)).value
;
3936 type
= TREE_TYPE (elt
);
3937 if (TREE_CODE (type
) == ARRAY_TYPE
3938 && TYPE_SIZE (type
) == NULL_TREE
3939 && TYPE_DOMAIN (type
) != NULL_TREE
3940 && TYPE_MAX_VALUE (TYPE_DOMAIN (type
)) == NULL_TREE
)
3942 complete_array_type (&type
, elt
, false);
3944 = size_binop (PLUS_EXPR
, DECL_SIZE (decl
), TYPE_SIZE (type
));
3945 DECL_SIZE_UNIT (decl
)
3946 = size_binop (PLUS_EXPR
, DECL_SIZE_UNIT (decl
), TYPE_SIZE_UNIT (type
));
3950 /* Decode a "typename", such as "int **", returning a ..._TYPE node.
3951 Set *EXPR, if EXPR not NULL, to any expression to be evaluated
3952 before the type name, and set *EXPR_CONST_OPERANDS, if
3953 EXPR_CONST_OPERANDS not NULL, to indicate whether the type name may
3954 appear in a constant expression. */
3957 groktypename (struct c_type_name
*type_name
, tree
*expr
,
3958 bool *expr_const_operands
)
3961 tree attrs
= type_name
->specs
->attrs
;
3963 type_name
->specs
->attrs
= NULL_TREE
;
3965 type
= grokdeclarator (type_name
->declarator
, type_name
->specs
, TYPENAME
,
3966 false, NULL
, &attrs
, expr
, expr_const_operands
,
3969 /* Apply attributes. */
3970 decl_attributes (&type
, attrs
, 0);
3975 /* Decode a declarator in an ordinary declaration or data definition.
3976 This is called as soon as the type information and variable name
3977 have been parsed, before parsing the initializer if any.
3978 Here we create the ..._DECL node, fill in its type,
3979 and put it on the list of decls for the current context.
3980 The ..._DECL node is returned as the value.
3982 Exception: for arrays where the length is not specified,
3983 the type is left null, to be filled in by `finish_decl'.
3985 Function definitions do not come here; they go to start_function
3986 instead. However, external and forward declarations of functions
3987 do go through here. Structure field declarations are done by
3988 grokfield and not through here. */
3991 start_decl (struct c_declarator
*declarator
, struct c_declspecs
*declspecs
,
3992 bool initialized
, tree attributes
)
3996 tree expr
= NULL_TREE
;
3997 enum deprecated_states deprecated_state
= DEPRECATED_NORMAL
;
3999 /* An object declared as __attribute__((deprecated)) suppresses
4000 warnings of uses of other deprecated items. */
4001 if (lookup_attribute ("deprecated", attributes
))
4002 deprecated_state
= DEPRECATED_SUPPRESS
;
4004 decl
= grokdeclarator (declarator
, declspecs
,
4005 NORMAL
, initialized
, NULL
, &attributes
, &expr
, NULL
,
4011 add_stmt (fold_convert (void_type_node
, expr
));
4013 if (TREE_CODE (decl
) != FUNCTION_DECL
&& MAIN_NAME_P (DECL_NAME (decl
)))
4014 warning (OPT_Wmain
, "%q+D is usually a function", decl
);
4017 /* Is it valid for this decl to have an initializer at all?
4018 If not, set INITIALIZED to zero, which will indirectly
4019 tell 'finish_decl' to ignore the initializer once it is parsed. */
4020 switch (TREE_CODE (decl
))
4023 error ("typedef %qD is initialized (use __typeof__ instead)", decl
);
4028 error ("function %qD is initialized like a variable", decl
);
4033 /* DECL_INITIAL in a PARM_DECL is really DECL_ARG_TYPE. */
4034 error ("parameter %qD is initialized", decl
);
4039 /* Don't allow initializations for incomplete types except for
4040 arrays which might be completed by the initialization. */
4042 /* This can happen if the array size is an undefined macro.
4043 We already gave a warning, so we don't need another one. */
4044 if (TREE_TYPE (decl
) == error_mark_node
)
4046 else if (COMPLETE_TYPE_P (TREE_TYPE (decl
)))
4048 /* A complete type is ok if size is fixed. */
4050 if (TREE_CODE (TYPE_SIZE (TREE_TYPE (decl
))) != INTEGER_CST
4051 || C_DECL_VARIABLE_SIZE (decl
))
4053 error ("variable-sized object may not be initialized");
4057 else if (TREE_CODE (TREE_TYPE (decl
)) != ARRAY_TYPE
)
4059 error ("variable %qD has initializer but incomplete type", decl
);
4062 else if (C_DECL_VARIABLE_SIZE (decl
))
4064 /* Although C99 is unclear about whether incomplete arrays
4065 of VLAs themselves count as VLAs, it does not make
4066 sense to permit them to be initialized given that
4067 ordinary VLAs may not be initialized. */
4068 error ("variable-sized object may not be initialized");
4075 if (current_scope
== file_scope
)
4076 TREE_STATIC (decl
) = 1;
4078 /* Tell 'pushdecl' this is an initialized decl
4079 even though we don't yet have the initializer expression.
4080 Also tell 'finish_decl' it may store the real initializer. */
4081 DECL_INITIAL (decl
) = error_mark_node
;
4084 /* If this is a function declaration, write a record describing it to the
4085 prototypes file (if requested). */
4087 if (TREE_CODE (decl
) == FUNCTION_DECL
)
4088 gen_aux_info_record (decl
, 0, 0, prototype_p (TREE_TYPE (decl
)));
4090 /* ANSI specifies that a tentative definition which is not merged with
4091 a non-tentative definition behaves exactly like a definition with an
4092 initializer equal to zero. (Section 3.7.2)
4094 -fno-common gives strict ANSI behavior, though this tends to break
4095 a large body of code that grew up without this rule.
4097 Thread-local variables are never common, since there's no entrenched
4098 body of code to break, and it allows more efficient variable references
4099 in the presence of dynamic linking. */
4101 if (TREE_CODE (decl
) == VAR_DECL
4103 && TREE_PUBLIC (decl
)
4104 && !DECL_THREAD_LOCAL_P (decl
)
4106 DECL_COMMON (decl
) = 1;
4108 /* Set attributes here so if duplicate decl, will have proper attributes. */
4109 decl_attributes (&decl
, attributes
, 0);
4111 /* Handle gnu_inline attribute. */
4112 if (declspecs
->inline_p
4113 && !flag_gnu89_inline
4114 && TREE_CODE (decl
) == FUNCTION_DECL
4115 && (lookup_attribute ("gnu_inline", DECL_ATTRIBUTES (decl
))
4116 || current_function_decl
))
4118 if (declspecs
->storage_class
== csc_auto
&& current_scope
!= file_scope
)
4120 else if (declspecs
->storage_class
!= csc_static
)
4121 DECL_EXTERNAL (decl
) = !DECL_EXTERNAL (decl
);
4124 if (TREE_CODE (decl
) == FUNCTION_DECL
4125 && targetm
.calls
.promote_prototypes (TREE_TYPE (decl
)))
4127 struct c_declarator
*ce
= declarator
;
4129 if (ce
->kind
== cdk_pointer
)
4130 ce
= declarator
->declarator
;
4131 if (ce
->kind
== cdk_function
)
4133 tree args
= ce
->u
.arg_info
->parms
;
4134 for (; args
; args
= DECL_CHAIN (args
))
4136 tree type
= TREE_TYPE (args
);
4137 if (type
&& INTEGRAL_TYPE_P (type
)
4138 && TYPE_PRECISION (type
) < TYPE_PRECISION (integer_type_node
))
4139 DECL_ARG_TYPE (args
) = integer_type_node
;
4144 if (TREE_CODE (decl
) == FUNCTION_DECL
4145 && DECL_DECLARED_INLINE_P (decl
)
4146 && DECL_UNINLINABLE (decl
)
4147 && lookup_attribute ("noinline", DECL_ATTRIBUTES (decl
)))
4148 warning (OPT_Wattributes
, "inline function %q+D given attribute noinline",
4151 /* C99 6.7.4p3: An inline definition of a function with external
4152 linkage shall not contain a definition of a modifiable object
4153 with static storage duration... */
4154 if (TREE_CODE (decl
) == VAR_DECL
4155 && current_scope
!= file_scope
4156 && TREE_STATIC (decl
)
4157 && !TREE_READONLY (decl
)
4158 && DECL_DECLARED_INLINE_P (current_function_decl
)
4159 && DECL_EXTERNAL (current_function_decl
))
4160 record_inline_static (input_location
, current_function_decl
,
4161 decl
, csi_modifiable
);
4163 if (c_dialect_objc ()
4164 && (TREE_CODE (decl
) == VAR_DECL
4165 || TREE_CODE (decl
) == FUNCTION_DECL
))
4166 objc_check_global_decl (decl
);
4168 /* Add this decl to the current scope.
4169 TEM may equal DECL or it may be a previous decl of the same name. */
4170 tem
= pushdecl (decl
);
4172 if (initialized
&& DECL_EXTERNAL (tem
))
4174 DECL_EXTERNAL (tem
) = 0;
4175 TREE_STATIC (tem
) = 1;
4181 /* Subroutine of finish_decl. TYPE is the type of an uninitialized object
4182 DECL or the non-array element type if DECL is an uninitialized array.
4183 If that type has a const member, diagnose this. */
4186 diagnose_uninitialized_cst_member (tree decl
, tree type
)
4189 for (field
= TYPE_FIELDS (type
); field
; field
= TREE_CHAIN (field
))
4192 if (TREE_CODE (field
) != FIELD_DECL
)
4194 field_type
= strip_array_types (TREE_TYPE (field
));
4196 if (TYPE_QUALS (field_type
) & TYPE_QUAL_CONST
)
4198 warning_at (DECL_SOURCE_LOCATION (decl
), OPT_Wc___compat
,
4199 "uninitialized const member in %qT is invalid in C++",
4200 strip_array_types (TREE_TYPE (decl
)));
4201 inform (DECL_SOURCE_LOCATION (field
), "%qD should be initialized", field
);
4204 if (TREE_CODE (field_type
) == RECORD_TYPE
4205 || TREE_CODE (field_type
) == UNION_TYPE
)
4206 diagnose_uninitialized_cst_member (decl
, field_type
);
4210 /* Finish processing of a declaration;
4211 install its initial value.
4212 If ORIGTYPE is not NULL_TREE, it is the original type of INIT.
4213 If the length of an array type is not known before,
4214 it must be determined now, from the initial value, or it is an error.
4216 INIT_LOC is the location of the initial value. */
4219 finish_decl (tree decl
, location_t init_loc
, tree init
,
4220 tree origtype
, tree asmspec_tree
)
4223 bool was_incomplete
= (DECL_SIZE (decl
) == 0);
4224 const char *asmspec
= 0;
4226 /* If a name was specified, get the string. */
4227 if ((TREE_CODE (decl
) == FUNCTION_DECL
|| TREE_CODE (decl
) == VAR_DECL
)
4228 && DECL_FILE_SCOPE_P (decl
))
4229 asmspec_tree
= maybe_apply_renaming_pragma (decl
, asmspec_tree
);
4231 asmspec
= TREE_STRING_POINTER (asmspec_tree
);
4233 if (TREE_CODE (decl
) == VAR_DECL
4234 && TREE_STATIC (decl
)
4235 && global_bindings_p ())
4236 /* So decl is a global variable. Record the types it uses
4237 so that we can decide later to emit debug info for them. */
4238 record_types_used_by_current_var_decl (decl
);
4240 /* If `start_decl' didn't like having an initialization, ignore it now. */
4241 if (init
!= 0 && DECL_INITIAL (decl
) == 0)
4244 /* Don't crash if parm is initialized. */
4245 if (TREE_CODE (decl
) == PARM_DECL
)
4249 store_init_value (init_loc
, decl
, init
, origtype
);
4251 if (c_dialect_objc () && (TREE_CODE (decl
) == VAR_DECL
4252 || TREE_CODE (decl
) == FUNCTION_DECL
4253 || TREE_CODE (decl
) == FIELD_DECL
))
4254 objc_check_decl (decl
);
4256 type
= TREE_TYPE (decl
);
4258 /* Deduce size of array from initialization, if not already known. */
4259 if (TREE_CODE (type
) == ARRAY_TYPE
4260 && TYPE_DOMAIN (type
) == 0
4261 && TREE_CODE (decl
) != TYPE_DECL
)
4264 = (TREE_STATIC (decl
)
4265 /* Even if pedantic, an external linkage array
4266 may have incomplete type at first. */
4267 ? pedantic
&& !TREE_PUBLIC (decl
)
4268 : !DECL_EXTERNAL (decl
));
4270 = complete_array_type (&TREE_TYPE (decl
), DECL_INITIAL (decl
),
4273 /* Get the completed type made by complete_array_type. */
4274 type
= TREE_TYPE (decl
);
4279 error ("initializer fails to determine size of %q+D", decl
);
4284 error ("array size missing in %q+D", decl
);
4285 /* If a `static' var's size isn't known,
4286 make it extern as well as static, so it does not get
4288 If it is not `static', then do not mark extern;
4289 finish_incomplete_decl will give it a default size
4290 and it will get allocated. */
4291 else if (!pedantic
&& TREE_STATIC (decl
) && !TREE_PUBLIC (decl
))
4292 DECL_EXTERNAL (decl
) = 1;
4296 error ("zero or negative size array %q+D", decl
);
4300 /* For global variables, update the copy of the type that
4301 exists in the binding. */
4302 if (TREE_PUBLIC (decl
))
4304 struct c_binding
*b_ext
= I_SYMBOL_BINDING (DECL_NAME (decl
));
4305 while (b_ext
&& !B_IN_EXTERNAL_SCOPE (b_ext
))
4306 b_ext
= b_ext
->shadowed
;
4309 if (b_ext
->u
.type
&& comptypes (b_ext
->u
.type
, type
))
4310 b_ext
->u
.type
= composite_type (b_ext
->u
.type
, type
);
4312 b_ext
->u
.type
= type
;
4321 if (DECL_INITIAL (decl
))
4322 TREE_TYPE (DECL_INITIAL (decl
)) = type
;
4324 relayout_decl (decl
);
4327 if (TREE_CODE (decl
) == VAR_DECL
)
4329 if (init
&& TREE_CODE (init
) == CONSTRUCTOR
)
4330 add_flexible_array_elts_to_size (decl
, init
);
4332 if (DECL_SIZE (decl
) == 0 && TREE_TYPE (decl
) != error_mark_node
4333 && COMPLETE_TYPE_P (TREE_TYPE (decl
)))
4334 layout_decl (decl
, 0);
4336 if (DECL_SIZE (decl
) == 0
4337 /* Don't give an error if we already gave one earlier. */
4338 && TREE_TYPE (decl
) != error_mark_node
4339 && (TREE_STATIC (decl
)
4340 /* A static variable with an incomplete type
4341 is an error if it is initialized.
4342 Also if it is not file scope.
4343 Otherwise, let it through, but if it is not `extern'
4344 then it may cause an error message later. */
4345 ? (DECL_INITIAL (decl
) != 0
4346 || !DECL_FILE_SCOPE_P (decl
))
4347 /* An automatic variable with an incomplete type
4349 : !DECL_EXTERNAL (decl
)))
4351 error ("storage size of %q+D isn%'t known", decl
);
4352 TREE_TYPE (decl
) = error_mark_node
;
4355 if ((DECL_EXTERNAL (decl
) || TREE_STATIC (decl
))
4356 && DECL_SIZE (decl
) != 0)
4358 if (TREE_CODE (DECL_SIZE (decl
)) == INTEGER_CST
)
4359 constant_expression_warning (DECL_SIZE (decl
));
4362 error ("storage size of %q+D isn%'t constant", decl
);
4363 TREE_TYPE (decl
) = error_mark_node
;
4367 if (TREE_USED (type
))
4369 TREE_USED (decl
) = 1;
4370 DECL_READ_P (decl
) = 1;
4374 /* If this is a function and an assembler name is specified, reset DECL_RTL
4375 so we can give it its new name. Also, update builtin_decl if it
4376 was a normal built-in. */
4377 if (TREE_CODE (decl
) == FUNCTION_DECL
&& asmspec
)
4379 if (DECL_BUILT_IN_CLASS (decl
) == BUILT_IN_NORMAL
)
4380 set_builtin_user_assembler_name (decl
, asmspec
);
4381 set_user_assembler_name (decl
, asmspec
);
4384 /* If #pragma weak was used, mark the decl weak now. */
4385 maybe_apply_pragma_weak (decl
);
4387 /* Output the assembler code and/or RTL code for variables and functions,
4388 unless the type is an undefined structure or union.
4389 If not, it will get done when the type is completed. */
4391 if (TREE_CODE (decl
) == VAR_DECL
|| TREE_CODE (decl
) == FUNCTION_DECL
)
4393 /* Determine the ELF visibility. */
4394 if (TREE_PUBLIC (decl
))
4395 c_determine_visibility (decl
);
4397 /* This is a no-op in c-lang.c or something real in objc-act.c. */
4398 if (c_dialect_objc ())
4399 objc_check_decl (decl
);
4403 /* If this is not a static variable, issue a warning.
4404 It doesn't make any sense to give an ASMSPEC for an
4405 ordinary, non-register local variable. Historically,
4406 GCC has accepted -- but ignored -- the ASMSPEC in
4408 if (!DECL_FILE_SCOPE_P (decl
)
4409 && TREE_CODE (decl
) == VAR_DECL
4410 && !C_DECL_REGISTER (decl
)
4411 && !TREE_STATIC (decl
))
4412 warning (0, "ignoring asm-specifier for non-static local "
4413 "variable %q+D", decl
);
4415 set_user_assembler_name (decl
, asmspec
);
4418 if (DECL_FILE_SCOPE_P (decl
))
4420 if (DECL_INITIAL (decl
) == NULL_TREE
4421 || DECL_INITIAL (decl
) == error_mark_node
)
4422 /* Don't output anything
4423 when a tentative file-scope definition is seen.
4424 But at end of compilation, do output code for them. */
4425 DECL_DEFER_OUTPUT (decl
) = 1;
4426 if (asmspec
&& C_DECL_REGISTER (decl
))
4427 DECL_HARD_REGISTER (decl
) = 1;
4428 rest_of_decl_compilation (decl
, true, 0);
4432 /* In conjunction with an ASMSPEC, the `register'
4433 keyword indicates that we should place the variable
4434 in a particular register. */
4435 if (asmspec
&& C_DECL_REGISTER (decl
))
4437 DECL_HARD_REGISTER (decl
) = 1;
4438 /* This cannot be done for a structure with volatile
4439 fields, on which DECL_REGISTER will have been
4441 if (!DECL_REGISTER (decl
))
4442 error ("cannot put object with volatile field into register");
4445 if (TREE_CODE (decl
) != FUNCTION_DECL
)
4447 /* If we're building a variable sized type, and we might be
4448 reachable other than via the top of the current binding
4449 level, then create a new BIND_EXPR so that we deallocate
4450 the object at the right time. */
4451 /* Note that DECL_SIZE can be null due to errors. */
4452 if (DECL_SIZE (decl
)
4453 && !TREE_CONSTANT (DECL_SIZE (decl
))
4454 && STATEMENT_LIST_HAS_LABEL (cur_stmt_list
))
4457 bind
= build3 (BIND_EXPR
, void_type_node
, NULL
, NULL
, NULL
);
4458 TREE_SIDE_EFFECTS (bind
) = 1;
4460 BIND_EXPR_BODY (bind
) = push_stmt_list ();
4462 add_stmt (build_stmt (DECL_SOURCE_LOCATION (decl
),
4468 if (!DECL_FILE_SCOPE_P (decl
))
4470 /* Recompute the RTL of a local array now
4471 if it used to be an incomplete type. */
4473 && !TREE_STATIC (decl
) && !DECL_EXTERNAL (decl
))
4475 /* If we used it already as memory, it must stay in memory. */
4476 TREE_ADDRESSABLE (decl
) = TREE_USED (decl
);
4477 /* If it's still incomplete now, no init will save it. */
4478 if (DECL_SIZE (decl
) == 0)
4479 DECL_INITIAL (decl
) = 0;
4484 if (TREE_CODE (decl
) == TYPE_DECL
)
4486 if (!DECL_FILE_SCOPE_P (decl
)
4487 && variably_modified_type_p (TREE_TYPE (decl
), NULL_TREE
))
4488 add_stmt (build_stmt (DECL_SOURCE_LOCATION (decl
), DECL_EXPR
, decl
));
4490 rest_of_decl_compilation (decl
, DECL_FILE_SCOPE_P (decl
), 0);
4493 /* Install a cleanup (aka destructor) if one was given. */
4494 if (TREE_CODE (decl
) == VAR_DECL
&& !TREE_STATIC (decl
))
4496 tree attr
= lookup_attribute ("cleanup", DECL_ATTRIBUTES (decl
));
4499 tree cleanup_id
= TREE_VALUE (TREE_VALUE (attr
));
4500 tree cleanup_decl
= lookup_name (cleanup_id
);
4504 /* Build "cleanup(&decl)" for the destructor. */
4505 cleanup
= build_unary_op (input_location
, ADDR_EXPR
, decl
, 0);
4506 vec
= VEC_alloc (tree
, gc
, 1);
4507 VEC_quick_push (tree
, vec
, cleanup
);
4508 cleanup
= build_function_call_vec (DECL_SOURCE_LOCATION (decl
),
4509 cleanup_decl
, vec
, NULL
);
4510 VEC_free (tree
, gc
, vec
);
4512 /* Don't warn about decl unused; the cleanup uses it. */
4513 TREE_USED (decl
) = 1;
4514 TREE_USED (cleanup_decl
) = 1;
4515 DECL_READ_P (decl
) = 1;
4517 push_cleanup (decl
, cleanup
, false);
4522 && TREE_CODE (decl
) == VAR_DECL
4523 && !DECL_EXTERNAL (decl
)
4524 && DECL_INITIAL (decl
) == NULL_TREE
)
4526 type
= strip_array_types (type
);
4527 if (TREE_READONLY (decl
))
4528 warning_at (DECL_SOURCE_LOCATION (decl
), OPT_Wc___compat
,
4529 "uninitialized const %qD is invalid in C++", decl
);
4530 else if ((TREE_CODE (type
) == RECORD_TYPE
4531 || TREE_CODE (type
) == UNION_TYPE
)
4532 && C_TYPE_FIELDS_READONLY (type
))
4533 diagnose_uninitialized_cst_member (decl
, type
);
4536 invoke_plugin_callbacks (PLUGIN_FINISH_DECL
, decl
);
4539 /* Given a parsed parameter declaration, decode it into a PARM_DECL.
4540 EXPR is NULL or a pointer to an expression that needs to be
4541 evaluated for the side effects of array size expressions in the
4545 grokparm (const struct c_parm
*parm
, tree
*expr
)
4547 tree attrs
= parm
->attrs
;
4548 tree decl
= grokdeclarator (parm
->declarator
, parm
->specs
, PARM
, false,
4549 NULL
, &attrs
, expr
, NULL
, DEPRECATED_NORMAL
);
4551 decl_attributes (&decl
, attrs
, 0);
4556 /* Given a parsed parameter declaration, decode it into a PARM_DECL
4557 and push that on the current scope. EXPR is a pointer to an
4558 expression that needs to be evaluated for the side effects of array
4559 size expressions in the parameters. */
4562 push_parm_decl (const struct c_parm
*parm
, tree
*expr
)
4564 tree attrs
= parm
->attrs
;
4567 decl
= grokdeclarator (parm
->declarator
, parm
->specs
, PARM
, false, NULL
,
4568 &attrs
, expr
, NULL
, DEPRECATED_NORMAL
);
4569 decl_attributes (&decl
, attrs
, 0);
4571 decl
= pushdecl (decl
);
4573 finish_decl (decl
, input_location
, NULL_TREE
, NULL_TREE
, NULL_TREE
);
4576 /* Mark all the parameter declarations to date as forward decls.
4577 Also diagnose use of this extension. */
4580 mark_forward_parm_decls (void)
4582 struct c_binding
*b
;
4584 if (pedantic
&& !current_scope
->warned_forward_parm_decls
)
4586 pedwarn (input_location
, OPT_Wpedantic
,
4587 "ISO C forbids forward parameter declarations");
4588 current_scope
->warned_forward_parm_decls
= true;
4591 for (b
= current_scope
->bindings
; b
; b
= b
->prev
)
4592 if (TREE_CODE (b
->decl
) == PARM_DECL
)
4593 TREE_ASM_WRITTEN (b
->decl
) = 1;
4596 /* Build a COMPOUND_LITERAL_EXPR. TYPE is the type given in the compound
4597 literal, which may be an incomplete array type completed by the
4598 initializer; INIT is a CONSTRUCTOR at LOC that initializes the compound
4599 literal. NON_CONST is true if the initializers contain something
4600 that cannot occur in a constant expression. */
4603 build_compound_literal (location_t loc
, tree type
, tree init
, bool non_const
)
4605 /* We do not use start_decl here because we have a type, not a declarator;
4606 and do not use finish_decl because the decl should be stored inside
4607 the COMPOUND_LITERAL_EXPR rather than added elsewhere as a DECL_EXPR. */
4612 if (type
== error_mark_node
4613 || init
== error_mark_node
)
4614 return error_mark_node
;
4616 decl
= build_decl (loc
, VAR_DECL
, NULL_TREE
, type
);
4617 DECL_EXTERNAL (decl
) = 0;
4618 TREE_PUBLIC (decl
) = 0;
4619 TREE_STATIC (decl
) = (current_scope
== file_scope
);
4620 DECL_CONTEXT (decl
) = current_function_decl
;
4621 TREE_USED (decl
) = 1;
4622 DECL_READ_P (decl
) = 1;
4623 TREE_TYPE (decl
) = type
;
4624 TREE_READONLY (decl
) = (TYPE_READONLY (type
)
4625 || (TREE_CODE (type
) == ARRAY_TYPE
4626 && TYPE_READONLY (TREE_TYPE (type
))));
4627 store_init_value (loc
, decl
, init
, NULL_TREE
);
4629 if (TREE_CODE (type
) == ARRAY_TYPE
&& !COMPLETE_TYPE_P (type
))
4631 int failure
= complete_array_type (&TREE_TYPE (decl
),
4632 DECL_INITIAL (decl
), true);
4633 gcc_assert (!failure
);
4635 type
= TREE_TYPE (decl
);
4636 TREE_TYPE (DECL_INITIAL (decl
)) = type
;
4639 if (type
== error_mark_node
|| !COMPLETE_TYPE_P (type
))
4641 c_incomplete_type_error (NULL_TREE
, type
);
4642 return error_mark_node
;
4645 stmt
= build_stmt (DECL_SOURCE_LOCATION (decl
), DECL_EXPR
, decl
);
4646 complit
= build1 (COMPOUND_LITERAL_EXPR
, type
, stmt
);
4647 TREE_SIDE_EFFECTS (complit
) = 1;
4649 layout_decl (decl
, 0);
4651 if (TREE_STATIC (decl
))
4653 /* This decl needs a name for the assembler output. */
4654 set_compound_literal_name (decl
);
4655 DECL_DEFER_OUTPUT (decl
) = 1;
4656 DECL_COMDAT (decl
) = 1;
4657 DECL_ARTIFICIAL (decl
) = 1;
4658 DECL_IGNORED_P (decl
) = 1;
4660 rest_of_decl_compilation (decl
, 1, 0);
4665 complit
= build2 (C_MAYBE_CONST_EXPR
, type
, NULL
, complit
);
4666 C_MAYBE_CONST_EXPR_NON_CONST (complit
) = 1;
4672 /* Check the type of a compound literal. Here we just check that it
4673 is valid for C++. */
4676 check_compound_literal_type (location_t loc
, struct c_type_name
*type_name
)
4679 && (type_name
->specs
->typespec_kind
== ctsk_tagdef
4680 || type_name
->specs
->typespec_kind
== ctsk_tagfirstref
))
4681 warning_at (loc
, OPT_Wc___compat
,
4682 "defining a type in a compound literal is invalid in C++");
4685 /* Determine whether TYPE is a structure with a flexible array member,
4686 or a union containing such a structure (possibly recursively). */
4689 flexible_array_type_p (tree type
)
4692 switch (TREE_CODE (type
))
4695 x
= TYPE_FIELDS (type
);
4698 while (DECL_CHAIN (x
) != NULL_TREE
)
4700 if (TREE_CODE (TREE_TYPE (x
)) == ARRAY_TYPE
4701 && TYPE_SIZE (TREE_TYPE (x
)) == NULL_TREE
4702 && TYPE_DOMAIN (TREE_TYPE (x
)) != NULL_TREE
4703 && TYPE_MAX_VALUE (TYPE_DOMAIN (TREE_TYPE (x
))) == NULL_TREE
)
4707 for (x
= TYPE_FIELDS (type
); x
!= NULL_TREE
; x
= DECL_CHAIN (x
))
4709 if (flexible_array_type_p (TREE_TYPE (x
)))
4718 /* Performs sanity checks on the TYPE and WIDTH of the bit-field NAME,
4719 replacing with appropriate values if they are invalid. */
4721 check_bitfield_type_and_width (tree
*type
, tree
*width
, tree orig_name
)
4724 unsigned int max_width
;
4725 unsigned HOST_WIDE_INT w
;
4726 const char *name
= (orig_name
4727 ? identifier_to_locale (IDENTIFIER_POINTER (orig_name
))
4728 : _("<anonymous>"));
4730 /* Detect and ignore out of range field width and process valid
4732 if (!INTEGRAL_TYPE_P (TREE_TYPE (*width
)))
4734 error ("bit-field %qs width not an integer constant", name
);
4735 *width
= integer_one_node
;
4739 if (TREE_CODE (*width
) != INTEGER_CST
)
4741 *width
= c_fully_fold (*width
, false, NULL
);
4742 if (TREE_CODE (*width
) == INTEGER_CST
)
4743 pedwarn (input_location
, OPT_Wpedantic
,
4744 "bit-field %qs width not an integer constant expression",
4747 if (TREE_CODE (*width
) != INTEGER_CST
)
4749 error ("bit-field %qs width not an integer constant", name
);
4750 *width
= integer_one_node
;
4752 constant_expression_warning (*width
);
4753 if (tree_int_cst_sgn (*width
) < 0)
4755 error ("negative width in bit-field %qs", name
);
4756 *width
= integer_one_node
;
4758 else if (integer_zerop (*width
) && orig_name
)
4760 error ("zero width for bit-field %qs", name
);
4761 *width
= integer_one_node
;
4765 /* Detect invalid bit-field type. */
4766 if (TREE_CODE (*type
) != INTEGER_TYPE
4767 && TREE_CODE (*type
) != BOOLEAN_TYPE
4768 && TREE_CODE (*type
) != ENUMERAL_TYPE
)
4770 error ("bit-field %qs has invalid type", name
);
4771 *type
= unsigned_type_node
;
4774 type_mv
= TYPE_MAIN_VARIANT (*type
);
4775 if (!in_system_header
4776 && type_mv
!= integer_type_node
4777 && type_mv
!= unsigned_type_node
4778 && type_mv
!= boolean_type_node
)
4779 pedwarn (input_location
, OPT_Wpedantic
,
4780 "type of bit-field %qs is a GCC extension", name
);
4782 max_width
= TYPE_PRECISION (*type
);
4784 if (0 < compare_tree_int (*width
, max_width
))
4786 error ("width of %qs exceeds its type", name
);
4788 *width
= build_int_cst (integer_type_node
, w
);
4791 w
= tree_low_cst (*width
, 1);
4793 if (TREE_CODE (*type
) == ENUMERAL_TYPE
)
4795 struct lang_type
*lt
= TYPE_LANG_SPECIFIC (*type
);
4797 || w
< tree_int_cst_min_precision (lt
->enum_min
, TYPE_UNSIGNED (*type
))
4798 || w
< tree_int_cst_min_precision (lt
->enum_max
, TYPE_UNSIGNED (*type
)))
4799 warning (0, "%qs is narrower than values of its type", name
);
4805 /* Print warning about variable length array if necessary. */
4808 warn_variable_length_array (tree name
, tree size
)
4810 int const_size
= TREE_CONSTANT (size
);
4812 if (!flag_isoc99
&& pedantic
&& warn_vla
!= 0)
4817 pedwarn (input_location
, OPT_Wvla
,
4818 "ISO C90 forbids array %qE whose size "
4819 "can%'t be evaluated",
4822 pedwarn (input_location
, OPT_Wvla
, "ISO C90 forbids array whose size "
4823 "can%'t be evaluated");
4828 pedwarn (input_location
, OPT_Wvla
,
4829 "ISO C90 forbids variable length array %qE",
4832 pedwarn (input_location
, OPT_Wvla
, "ISO C90 forbids variable length array");
4835 else if (warn_vla
> 0)
4841 "the size of array %qE can"
4842 "%'t be evaluated", name
);
4845 "the size of array can %'t be evaluated");
4851 "variable length array %qE is used",
4855 "variable length array is used");
4860 /* Given declspecs and a declarator,
4861 determine the name and type of the object declared
4862 and construct a ..._DECL node for it.
4863 (In one case we can return a ..._TYPE node instead.
4864 For invalid input we sometimes return 0.)
4866 DECLSPECS is a c_declspecs structure for the declaration specifiers.
4868 DECL_CONTEXT says which syntactic context this declaration is in:
4869 NORMAL for most contexts. Make a VAR_DECL or FUNCTION_DECL or TYPE_DECL.
4870 FUNCDEF for a function definition. Like NORMAL but a few different
4871 error messages in each case. Return value may be zero meaning
4872 this definition is too screwy to try to parse.
4873 PARM for a parameter declaration (either within a function prototype
4874 or before a function body). Make a PARM_DECL, or return void_type_node.
4875 TYPENAME if for a typename (in a cast or sizeof).
4876 Don't make a DECL node; just return the ..._TYPE node.
4877 FIELD for a struct or union field; make a FIELD_DECL.
4878 INITIALIZED is true if the decl has an initializer.
4879 WIDTH is non-NULL for bit-fields, and is a pointer to an INTEGER_CST node
4880 representing the width of the bit-field.
4881 DECL_ATTRS points to the list of attributes that should be added to this
4882 decl. Any nested attributes that belong on the decl itself will be
4884 If EXPR is not NULL, any expressions that need to be evaluated as
4885 part of evaluating variably modified types will be stored in *EXPR.
4886 If EXPR_CONST_OPERANDS is not NULL, *EXPR_CONST_OPERANDS will be
4887 set to indicate whether operands in *EXPR can be used in constant
4889 DEPRECATED_STATE is a deprecated_states value indicating whether
4890 deprecation warnings should be suppressed.
4892 In the TYPENAME case, DECLARATOR is really an absolute declarator.
4893 It may also be so in the PARM case, for a prototype where the
4894 argument type is specified but not the name.
4896 This function is where the complicated C meanings of `static'
4897 and `extern' are interpreted. */
4900 grokdeclarator (const struct c_declarator
*declarator
,
4901 struct c_declspecs
*declspecs
,
4902 enum decl_context decl_context
, bool initialized
, tree
*width
,
4903 tree
*decl_attrs
, tree
*expr
, bool *expr_const_operands
,
4904 enum deprecated_states deprecated_state
)
4906 tree type
= declspecs
->type
;
4907 bool threadp
= declspecs
->thread_p
;
4908 enum c_storage_class storage_class
= declspecs
->storage_class
;
4912 int type_quals
= TYPE_UNQUALIFIED
;
4913 tree name
= NULL_TREE
;
4914 bool funcdef_flag
= false;
4915 bool funcdef_syntax
= false;
4916 bool size_varies
= false;
4917 tree decl_attr
= declspecs
->decl_attr
;
4918 int array_ptr_quals
= TYPE_UNQUALIFIED
;
4919 tree array_ptr_attrs
= NULL_TREE
;
4920 int array_parm_static
= 0;
4921 bool array_parm_vla_unspec_p
= false;
4922 tree returned_attrs
= NULL_TREE
;
4923 bool bitfield
= width
!= NULL
;
4925 struct c_arg_info
*arg_info
= 0;
4926 addr_space_t as1
, as2
, address_space
;
4927 location_t loc
= UNKNOWN_LOCATION
;
4930 bool expr_const_operands_dummy
;
4931 enum c_declarator_kind first_non_attr_kind
;
4932 unsigned int alignas_align
= 0;
4934 if (TREE_CODE (type
) == ERROR_MARK
)
4935 return error_mark_node
;
4938 if (expr_const_operands
== NULL
)
4939 expr_const_operands
= &expr_const_operands_dummy
;
4941 *expr
= declspecs
->expr
;
4942 *expr_const_operands
= declspecs
->expr_const_operands
;
4944 if (decl_context
== FUNCDEF
)
4945 funcdef_flag
= true, decl_context
= NORMAL
;
4947 /* Look inside a declarator for the name being declared
4948 and get it as an IDENTIFIER_NODE, for an error message. */
4950 const struct c_declarator
*decl
= declarator
;
4952 first_non_attr_kind
= cdk_attrs
;
4962 funcdef_syntax
= (decl
->kind
== cdk_function
);
4963 decl
= decl
->declarator
;
4964 if (first_non_attr_kind
== cdk_attrs
)
4965 first_non_attr_kind
= decl
->kind
;
4969 decl
= decl
->declarator
;
4976 if (first_non_attr_kind
== cdk_attrs
)
4977 first_non_attr_kind
= decl
->kind
;
4986 gcc_assert (decl_context
== PARM
4987 || decl_context
== TYPENAME
4988 || (decl_context
== FIELD
4989 && declarator
->kind
== cdk_id
));
4990 gcc_assert (!initialized
);
4994 /* A function definition's declarator must have the form of
4995 a function declarator. */
4997 if (funcdef_flag
&& !funcdef_syntax
)
5000 /* If this looks like a function definition, make it one,
5001 even if it occurs where parms are expected.
5002 Then store_parm_decls will reject it and not use it as a parm. */
5003 if (decl_context
== NORMAL
&& !funcdef_flag
&& current_scope
->parm_flag
)
5004 decl_context
= PARM
;
5006 if (declspecs
->deprecated_p
&& deprecated_state
!= DEPRECATED_SUPPRESS
)
5007 warn_deprecated_use (declspecs
->type
, declspecs
->decl_attr
);
5009 if ((decl_context
== NORMAL
|| decl_context
== FIELD
)
5010 && current_scope
== file_scope
5011 && variably_modified_type_p (type
, NULL_TREE
))
5014 error_at (loc
, "variably modified %qE at file scope", name
);
5016 error_at (loc
, "variably modified field at file scope");
5017 type
= integer_type_node
;
5020 size_varies
= C_TYPE_VARIABLE_SIZE (type
) != 0;
5022 /* Diagnose defaulting to "int". */
5024 if (declspecs
->default_int_p
&& !in_system_header
)
5026 /* Issue a warning if this is an ISO C 99 program or if
5027 -Wreturn-type and this is a function, or if -Wimplicit;
5028 prefer the former warning since it is more explicit. */
5029 if ((warn_implicit_int
|| warn_return_type
|| flag_isoc99
)
5031 warn_about_return_type
= 1;
5035 pedwarn_c99 (loc
, flag_isoc99
? 0 : OPT_Wimplicit_int
,
5036 "type defaults to %<int%> in declaration of %qE",
5039 pedwarn_c99 (input_location
, flag_isoc99
? 0 : OPT_Wimplicit_int
,
5040 "type defaults to %<int%> in type name");
5044 /* Adjust the type if a bit-field is being declared,
5045 -funsigned-bitfields applied and the type is not explicitly
5047 if (bitfield
&& !flag_signed_bitfields
&& !declspecs
->explicit_signed_p
5048 && TREE_CODE (type
) == INTEGER_TYPE
)
5049 type
= unsigned_type_for (type
);
5051 /* Figure out the type qualifiers for the declaration. There are
5052 two ways a declaration can become qualified. One is something
5053 like `const int i' where the `const' is explicit. Another is
5054 something like `typedef const int CI; CI i' where the type of the
5055 declaration contains the `const'. A third possibility is that
5056 there is a type qualifier on the element type of a typedefed
5057 array type, in which case we should extract that qualifier so
5058 that c_apply_type_quals_to_decl receives the full list of
5059 qualifiers to work with (C90 is not entirely clear about whether
5060 duplicate qualifiers should be diagnosed in this case, but it
5061 seems most appropriate to do so). */
5062 element_type
= strip_array_types (type
);
5063 constp
= declspecs
->const_p
+ TYPE_READONLY (element_type
);
5064 restrictp
= declspecs
->restrict_p
+ TYPE_RESTRICT (element_type
);
5065 volatilep
= declspecs
->volatile_p
+ TYPE_VOLATILE (element_type
);
5066 as1
= declspecs
->address_space
;
5067 as2
= TYPE_ADDR_SPACE (element_type
);
5068 address_space
= ADDR_SPACE_GENERIC_P (as1
)? as2
: as1
;
5070 if (pedantic
&& !flag_isoc99
)
5073 pedwarn (loc
, OPT_Wpedantic
, "duplicate %<const%>");
5075 pedwarn (loc
, OPT_Wpedantic
, "duplicate %<restrict%>");
5077 pedwarn (loc
, OPT_Wpedantic
, "duplicate %<volatile%>");
5080 if (!ADDR_SPACE_GENERIC_P (as1
) && !ADDR_SPACE_GENERIC_P (as2
) && as1
!= as2
)
5081 error_at (loc
, "conflicting named address spaces (%s vs %s)",
5082 c_addr_space_name (as1
), c_addr_space_name (as2
));
5084 if ((TREE_CODE (type
) == ARRAY_TYPE
5085 || first_non_attr_kind
== cdk_array
)
5086 && TYPE_QUALS (element_type
))
5087 type
= TYPE_MAIN_VARIANT (type
);
5088 type_quals
= ((constp
? TYPE_QUAL_CONST
: 0)
5089 | (restrictp
? TYPE_QUAL_RESTRICT
: 0)
5090 | (volatilep
? TYPE_QUAL_VOLATILE
: 0)
5091 | ENCODE_QUAL_ADDR_SPACE (address_space
));
5093 /* Warn about storage classes that are invalid for certain
5094 kinds of declarations (parameters, typenames, etc.). */
5098 || storage_class
== csc_auto
5099 || storage_class
== csc_register
5100 || storage_class
== csc_typedef
))
5102 if (storage_class
== csc_auto
)
5104 (current_scope
== file_scope
) ? 0 : OPT_Wpedantic
,
5105 "function definition declared %<auto%>");
5106 if (storage_class
== csc_register
)
5107 error_at (loc
, "function definition declared %<register%>");
5108 if (storage_class
== csc_typedef
)
5109 error_at (loc
, "function definition declared %<typedef%>");
5111 error_at (loc
, "function definition declared %<__thread%>");
5113 if (storage_class
== csc_auto
5114 || storage_class
== csc_register
5115 || storage_class
== csc_typedef
)
5116 storage_class
= csc_none
;
5118 else if (decl_context
!= NORMAL
&& (storage_class
!= csc_none
|| threadp
))
5120 if (decl_context
== PARM
&& storage_class
== csc_register
)
5124 switch (decl_context
)
5128 error_at (loc
, "storage class specified for structure "
5131 error_at (loc
, "storage class specified for structure field");
5135 error_at (loc
, "storage class specified for parameter %qE",
5138 error_at (loc
, "storage class specified for unnamed parameter");
5141 error_at (loc
, "storage class specified for typename");
5144 storage_class
= csc_none
;
5148 else if (storage_class
== csc_extern
5152 /* 'extern' with initialization is invalid if not at file scope. */
5153 if (current_scope
== file_scope
)
5155 /* It is fine to have 'extern const' when compiling at C
5156 and C++ intersection. */
5157 if (!(warn_cxx_compat
&& constp
))
5158 warning_at (loc
, 0, "%qE initialized and declared %<extern%>",
5162 error_at (loc
, "%qE has both %<extern%> and initializer", name
);
5164 else if (current_scope
== file_scope
)
5166 if (storage_class
== csc_auto
)
5167 error_at (loc
, "file-scope declaration of %qE specifies %<auto%>",
5169 if (pedantic
&& storage_class
== csc_register
)
5170 pedwarn (input_location
, OPT_Wpedantic
,
5171 "file-scope declaration of %qE specifies %<register%>", name
);
5175 if (storage_class
== csc_extern
&& funcdef_flag
)
5176 error_at (loc
, "nested function %qE declared %<extern%>", name
);
5177 else if (threadp
&& storage_class
== csc_none
)
5179 error_at (loc
, "function-scope %qE implicitly auto and declared "
5186 /* Now figure out the structure of the declarator proper.
5187 Descend through it, creating more complex types, until we reach
5188 the declared identifier (or NULL_TREE, in an absolute declarator).
5189 At each stage we maintain an unqualified version of the type
5190 together with any qualifiers that should be applied to it with
5191 c_build_qualified_type; this way, array types including
5192 multidimensional array types are first built up in unqualified
5193 form and then the qualified form is created with
5194 TYPE_MAIN_VARIANT pointing to the unqualified form. */
5196 while (declarator
&& declarator
->kind
!= cdk_id
)
5198 if (type
== error_mark_node
)
5200 declarator
= declarator
->declarator
;
5204 /* Each level of DECLARATOR is either a cdk_array (for ...[..]),
5205 a cdk_pointer (for *...),
5206 a cdk_function (for ...(...)),
5207 a cdk_attrs (for nested attributes),
5208 or a cdk_id (for the name being declared
5209 or the place in an absolute declarator
5210 where the name was omitted).
5211 For the last case, we have just exited the loop.
5213 At this point, TYPE is the type of elements of an array,
5214 or for a function to return, or for a pointer to point to.
5215 After this sequence of ifs, TYPE is the type of the
5216 array or function or pointer, and DECLARATOR has had its
5217 outermost layer removed. */
5219 if (array_ptr_quals
!= TYPE_UNQUALIFIED
5220 || array_ptr_attrs
!= NULL_TREE
5221 || array_parm_static
)
5223 /* Only the innermost declarator (making a parameter be of
5224 array type which is converted to pointer type)
5225 may have static or type qualifiers. */
5226 error_at (loc
, "static or type qualifiers in non-parameter array declarator");
5227 array_ptr_quals
= TYPE_UNQUALIFIED
;
5228 array_ptr_attrs
= NULL_TREE
;
5229 array_parm_static
= 0;
5232 switch (declarator
->kind
)
5236 /* A declarator with embedded attributes. */
5237 tree attrs
= declarator
->u
.attrs
;
5238 const struct c_declarator
*inner_decl
;
5240 declarator
= declarator
->declarator
;
5241 inner_decl
= declarator
;
5242 while (inner_decl
->kind
== cdk_attrs
)
5243 inner_decl
= inner_decl
->declarator
;
5244 if (inner_decl
->kind
== cdk_id
)
5245 attr_flags
|= (int) ATTR_FLAG_DECL_NEXT
;
5246 else if (inner_decl
->kind
== cdk_function
)
5247 attr_flags
|= (int) ATTR_FLAG_FUNCTION_NEXT
;
5248 else if (inner_decl
->kind
== cdk_array
)
5249 attr_flags
|= (int) ATTR_FLAG_ARRAY_NEXT
;
5250 returned_attrs
= decl_attributes (&type
,
5251 chainon (returned_attrs
, attrs
),
5257 tree itype
= NULL_TREE
;
5258 tree size
= declarator
->u
.array
.dimen
;
5259 /* The index is a signed object `sizetype' bits wide. */
5260 tree index_type
= c_common_signed_type (sizetype
);
5262 array_ptr_quals
= declarator
->u
.array
.quals
;
5263 array_ptr_attrs
= declarator
->u
.array
.attrs
;
5264 array_parm_static
= declarator
->u
.array
.static_p
;
5265 array_parm_vla_unspec_p
= declarator
->u
.array
.vla_unspec_p
;
5267 declarator
= declarator
->declarator
;
5269 /* Check for some types that there cannot be arrays of. */
5271 if (VOID_TYPE_P (type
))
5274 error_at (loc
, "declaration of %qE as array of voids", name
);
5276 error_at (loc
, "declaration of type name as array of voids");
5277 type
= error_mark_node
;
5280 if (TREE_CODE (type
) == FUNCTION_TYPE
)
5283 error_at (loc
, "declaration of %qE as array of functions",
5286 error_at (loc
, "declaration of type name as array of "
5288 type
= error_mark_node
;
5291 if (pedantic
&& !in_system_header
&& flexible_array_type_p (type
))
5292 pedwarn (loc
, OPT_Wpedantic
,
5293 "invalid use of structure with flexible array member");
5295 if (size
== error_mark_node
)
5296 type
= error_mark_node
;
5298 if (type
== error_mark_node
)
5301 /* If size was specified, set ITYPE to a range-type for
5302 that size. Otherwise, ITYPE remains null. finish_decl
5303 may figure it out from an initial value. */
5307 bool size_maybe_const
= true;
5308 bool size_int_const
= (TREE_CODE (size
) == INTEGER_CST
5309 && !TREE_OVERFLOW (size
));
5310 bool this_size_varies
= false;
5312 /* Strip NON_LVALUE_EXPRs since we aren't using as an
5314 STRIP_TYPE_NOPS (size
);
5316 if (!INTEGRAL_TYPE_P (TREE_TYPE (size
)))
5319 error_at (loc
, "size of array %qE has non-integer type",
5323 "size of unnamed array has non-integer type");
5324 size
= integer_one_node
;
5327 size
= c_fully_fold (size
, false, &size_maybe_const
);
5329 if (pedantic
&& size_maybe_const
&& integer_zerop (size
))
5332 pedwarn (loc
, OPT_Wpedantic
,
5333 "ISO C forbids zero-size array %qE", name
);
5335 pedwarn (loc
, OPT_Wpedantic
,
5336 "ISO C forbids zero-size array");
5339 if (TREE_CODE (size
) == INTEGER_CST
&& size_maybe_const
)
5341 constant_expression_warning (size
);
5342 if (tree_int_cst_sgn (size
) < 0)
5345 error_at (loc
, "size of array %qE is negative", name
);
5347 error_at (loc
, "size of unnamed array is negative");
5348 size
= integer_one_node
;
5350 /* Handle a size folded to an integer constant but
5351 not an integer constant expression. */
5352 if (!size_int_const
)
5354 /* If this is a file scope declaration of an
5355 ordinary identifier, this is invalid code;
5356 diagnosing it here and not subsequently
5357 treating the type as variable-length avoids
5358 more confusing diagnostics later. */
5359 if ((decl_context
== NORMAL
|| decl_context
== FIELD
)
5360 && current_scope
== file_scope
)
5361 pedwarn (input_location
, 0,
5362 "variably modified %qE at file scope",
5365 this_size_varies
= size_varies
= true;
5366 warn_variable_length_array (name
, size
);
5369 else if ((decl_context
== NORMAL
|| decl_context
== FIELD
)
5370 && current_scope
== file_scope
)
5372 error_at (loc
, "variably modified %qE at file scope", name
);
5373 size
= integer_one_node
;
5377 /* Make sure the array size remains visibly
5378 nonconstant even if it is (eg) a const variable
5379 with known value. */
5380 this_size_varies
= size_varies
= true;
5381 warn_variable_length_array (name
, size
);
5384 if (integer_zerop (size
) && !this_size_varies
)
5386 /* A zero-length array cannot be represented with
5387 an unsigned index type, which is what we'll
5388 get with build_index_type. Create an
5389 open-ended range instead. */
5390 itype
= build_range_type (sizetype
, size
, NULL_TREE
);
5394 /* Arrange for the SAVE_EXPR on the inside of the
5395 MINUS_EXPR, which allows the -1 to get folded
5396 with the +1 that happens when building TYPE_SIZE. */
5398 size
= save_expr (size
);
5399 if (this_size_varies
&& TREE_CODE (size
) == INTEGER_CST
)
5400 size
= build2 (COMPOUND_EXPR
, TREE_TYPE (size
),
5401 integer_zero_node
, size
);
5403 /* Compute the maximum valid index, that is, size
5404 - 1. Do the calculation in index_type, so that
5405 if it is a variable the computations will be
5406 done in the proper mode. */
5407 itype
= fold_build2_loc (loc
, MINUS_EXPR
, index_type
,
5408 convert (index_type
, size
),
5409 convert (index_type
,
5412 /* The above overflows when size does not fit
5414 ??? While a size of INT_MAX+1 technically shouldn't
5415 cause an overflow (because we subtract 1), handling
5416 this case seems like an unnecessary complication. */
5417 if (TREE_CODE (size
) == INTEGER_CST
5418 && !int_fits_type_p (size
, index_type
))
5421 error_at (loc
, "size of array %qE is too large",
5424 error_at (loc
, "size of unnamed array is too large");
5425 type
= error_mark_node
;
5429 itype
= build_index_type (itype
);
5431 if (this_size_varies
)
5434 *expr
= build2 (COMPOUND_EXPR
, TREE_TYPE (size
),
5438 *expr_const_operands
&= size_maybe_const
;
5441 else if (decl_context
== FIELD
)
5443 bool flexible_array_member
= false;
5444 if (array_parm_vla_unspec_p
)
5445 /* Field names can in fact have function prototype
5446 scope so [*] is disallowed here through making
5447 the field variably modified, not through being
5448 something other than a declaration with function
5453 const struct c_declarator
*t
= declarator
;
5454 while (t
->kind
== cdk_attrs
)
5456 flexible_array_member
= (t
->kind
== cdk_id
);
5458 if (flexible_array_member
5459 && pedantic
&& !flag_isoc99
&& !in_system_header
)
5460 pedwarn (loc
, OPT_Wpedantic
,
5461 "ISO C90 does not support flexible array members");
5463 /* ISO C99 Flexible array members are effectively
5464 identical to GCC's zero-length array extension. */
5465 if (flexible_array_member
|| array_parm_vla_unspec_p
)
5466 itype
= build_range_type (sizetype
, size_zero_node
,
5469 else if (decl_context
== PARM
)
5471 if (array_parm_vla_unspec_p
)
5473 itype
= build_range_type (sizetype
, size_zero_node
, NULL_TREE
);
5477 else if (decl_context
== TYPENAME
)
5479 if (array_parm_vla_unspec_p
)
5482 warning (0, "%<[*]%> not in a declaration");
5483 /* We use this to avoid messing up with incomplete
5484 array types of the same type, that would
5485 otherwise be modified below. */
5486 itype
= build_range_type (sizetype
, size_zero_node
,
5492 /* Complain about arrays of incomplete types. */
5493 if (!COMPLETE_TYPE_P (type
))
5495 error_at (loc
, "array type has incomplete element type");
5496 type
= error_mark_node
;
5499 /* When itype is NULL, a shared incomplete array type is
5500 returned for all array of a given type. Elsewhere we
5501 make sure we don't complete that type before copying
5502 it, but here we want to make sure we don't ever
5503 modify the shared type, so we gcc_assert (itype)
5506 addr_space_t as
= DECODE_QUAL_ADDR_SPACE (type_quals
);
5507 if (!ADDR_SPACE_GENERIC_P (as
) && as
!= TYPE_ADDR_SPACE (type
))
5508 type
= build_qualified_type (type
,
5509 ENCODE_QUAL_ADDR_SPACE (as
));
5511 type
= build_array_type (type
, itype
);
5514 if (type
!= error_mark_node
)
5518 /* It is ok to modify type here even if itype is
5519 NULL: if size_varies, we're in a
5520 multi-dimensional array and the inner type has
5521 variable size, so the enclosing shared array type
5523 if (size
&& TREE_CODE (size
) == INTEGER_CST
)
5525 = build_distinct_type_copy (TYPE_MAIN_VARIANT (type
));
5526 C_TYPE_VARIABLE_SIZE (type
) = 1;
5529 /* The GCC extension for zero-length arrays differs from
5530 ISO flexible array members in that sizeof yields
5532 if (size
&& integer_zerop (size
))
5535 type
= build_distinct_type_copy (TYPE_MAIN_VARIANT (type
));
5536 TYPE_SIZE (type
) = bitsize_zero_node
;
5537 TYPE_SIZE_UNIT (type
) = size_zero_node
;
5538 SET_TYPE_STRUCTURAL_EQUALITY (type
);
5540 if (array_parm_vla_unspec_p
)
5543 /* The type is complete. C99 6.7.5.2p4 */
5544 type
= build_distinct_type_copy (TYPE_MAIN_VARIANT (type
));
5545 TYPE_SIZE (type
) = bitsize_zero_node
;
5546 TYPE_SIZE_UNIT (type
) = size_zero_node
;
5547 SET_TYPE_STRUCTURAL_EQUALITY (type
);
5551 if (decl_context
!= PARM
5552 && (array_ptr_quals
!= TYPE_UNQUALIFIED
5553 || array_ptr_attrs
!= NULL_TREE
5554 || array_parm_static
))
5556 error_at (loc
, "static or type qualifiers in non-parameter array declarator");
5557 array_ptr_quals
= TYPE_UNQUALIFIED
;
5558 array_ptr_attrs
= NULL_TREE
;
5559 array_parm_static
= 0;
5565 /* Say it's a definition only for the declarator closest
5566 to the identifier, apart possibly from some
5568 bool really_funcdef
= false;
5572 const struct c_declarator
*t
= declarator
->declarator
;
5573 while (t
->kind
== cdk_attrs
)
5575 really_funcdef
= (t
->kind
== cdk_id
);
5578 /* Declaring a function type. Make sure we have a valid
5579 type for the function to return. */
5580 if (type
== error_mark_node
)
5583 size_varies
= false;
5585 /* Warn about some types functions can't return. */
5586 if (TREE_CODE (type
) == FUNCTION_TYPE
)
5589 error_at (loc
, "%qE declared as function returning a "
5592 error_at (loc
, "type name declared as function "
5593 "returning a function");
5594 type
= integer_type_node
;
5596 if (TREE_CODE (type
) == ARRAY_TYPE
)
5599 error_at (loc
, "%qE declared as function returning an array",
5602 error_at (loc
, "type name declared as function returning "
5604 type
= integer_type_node
;
5606 errmsg
= targetm
.invalid_return_type (type
);
5610 type
= integer_type_node
;
5613 /* Construct the function type and go to the next
5614 inner layer of declarator. */
5615 arg_info
= declarator
->u
.arg_info
;
5616 arg_types
= grokparms (arg_info
, really_funcdef
);
5618 /* Type qualifiers before the return type of the function
5619 qualify the return type, not the function type. */
5622 /* Type qualifiers on a function return type are
5623 normally permitted by the standard but have no
5624 effect, so give a warning at -Wreturn-type.
5625 Qualifiers on a void return type are banned on
5626 function definitions in ISO C; GCC used to used
5627 them for noreturn functions. */
5628 if (VOID_TYPE_P (type
) && really_funcdef
)
5630 "function definition has qualified void return type");
5632 warning_at (loc
, OPT_Wignored_qualifiers
,
5633 "type qualifiers ignored on function return type");
5635 type
= c_build_qualified_type (type
, type_quals
);
5637 type_quals
= TYPE_UNQUALIFIED
;
5639 type
= build_function_type (type
, arg_types
);
5640 declarator
= declarator
->declarator
;
5642 /* Set the TYPE_CONTEXTs for each tagged type which is local to
5643 the formal parameter list of this FUNCTION_TYPE to point to
5644 the FUNCTION_TYPE node itself. */
5649 FOR_EACH_VEC_ELT_REVERSE (c_arg_tag
, arg_info
->tags
, ix
, tag
)
5650 TYPE_CONTEXT (tag
->type
) = type
;
5656 /* Merge any constancy or volatility into the target type
5659 if (pedantic
&& TREE_CODE (type
) == FUNCTION_TYPE
5661 pedwarn (loc
, OPT_Wpedantic
,
5662 "ISO C forbids qualified function types");
5664 type
= c_build_qualified_type (type
, type_quals
);
5665 size_varies
= false;
5667 /* When the pointed-to type involves components of variable size,
5668 care must be taken to ensure that the size evaluation code is
5669 emitted early enough to dominate all the possible later uses
5670 and late enough for the variables on which it depends to have
5673 This is expected to happen automatically when the pointed-to
5674 type has a name/declaration of it's own, but special attention
5675 is required if the type is anonymous.
5677 We handle the NORMAL and FIELD contexts here by attaching an
5678 artificial TYPE_DECL to such pointed-to type. This forces the
5679 sizes evaluation at a safe point and ensures it is not deferred
5680 until e.g. within a deeper conditional context.
5682 We expect nothing to be needed here for PARM or TYPENAME.
5683 Pushing a TYPE_DECL at this point for TYPENAME would actually
5684 be incorrect, as we might be in the middle of an expression
5685 with side effects on the pointed-to type size "arguments" prior
5686 to the pointer declaration point and the fake TYPE_DECL in the
5687 enclosing context would force the size evaluation prior to the
5690 if (!TYPE_NAME (type
)
5691 && (decl_context
== NORMAL
|| decl_context
== FIELD
)
5692 && variably_modified_type_p (type
, NULL_TREE
))
5694 tree decl
= build_decl (loc
, TYPE_DECL
, NULL_TREE
, type
);
5695 DECL_ARTIFICIAL (decl
) = 1;
5697 finish_decl (decl
, loc
, NULL_TREE
, NULL_TREE
, NULL_TREE
);
5698 TYPE_NAME (type
) = decl
;
5701 type
= c_build_pointer_type (type
);
5703 /* Process type qualifiers (such as const or volatile)
5704 that were given inside the `*'. */
5705 type_quals
= declarator
->u
.pointer_quals
;
5707 declarator
= declarator
->declarator
;
5714 *decl_attrs
= chainon (returned_attrs
, *decl_attrs
);
5716 /* Now TYPE has the actual type, apart from any qualifiers in
5719 /* Warn about address space used for things other than static memory or
5721 address_space
= DECODE_QUAL_ADDR_SPACE (type_quals
);
5722 if (!ADDR_SPACE_GENERIC_P (address_space
))
5724 if (decl_context
== NORMAL
)
5726 switch (storage_class
)
5729 error ("%qs combined with %<auto%> qualifier for %qE",
5730 c_addr_space_name (address_space
), name
);
5733 error ("%qs combined with %<register%> qualifier for %qE",
5734 c_addr_space_name (address_space
), name
);
5737 if (current_function_scope
)
5739 error ("%qs specified for auto variable %qE",
5740 c_addr_space_name (address_space
), name
);
5752 else if (decl_context
== PARM
&& TREE_CODE (type
) != ARRAY_TYPE
)
5755 error ("%qs specified for parameter %qE",
5756 c_addr_space_name (address_space
), name
);
5758 error ("%qs specified for unnamed parameter",
5759 c_addr_space_name (address_space
));
5761 else if (decl_context
== FIELD
)
5764 error ("%qs specified for structure field %qE",
5765 c_addr_space_name (address_space
), name
);
5767 error ("%qs specified for structure field",
5768 c_addr_space_name (address_space
));
5772 /* Check the type and width of a bit-field. */
5774 check_bitfield_type_and_width (&type
, width
, name
);
5776 /* Reject invalid uses of _Alignas. */
5777 if (declspecs
->alignas_p
)
5779 if (storage_class
== csc_typedef
)
5780 error_at (loc
, "alignment specified for typedef %qE", name
);
5781 else if (storage_class
== csc_register
)
5782 error_at (loc
, "alignment specified for %<register%> object %qE",
5784 else if (decl_context
== PARM
)
5787 error_at (loc
, "alignment specified for parameter %qE", name
);
5789 error_at (loc
, "alignment specified for unnamed parameter");
5794 error_at (loc
, "alignment specified for bit-field %qE", name
);
5796 error_at (loc
, "alignment specified for unnamed bit-field");
5798 else if (TREE_CODE (type
) == FUNCTION_TYPE
)
5799 error_at (loc
, "alignment specified for function %qE", name
);
5800 else if (declspecs
->align_log
!= -1)
5802 alignas_align
= 1U << declspecs
->align_log
;
5803 if (alignas_align
< TYPE_ALIGN_UNIT (type
))
5806 error_at (loc
, "%<_Alignas%> specifiers cannot reduce "
5807 "alignment of %qE", name
);
5809 error_at (loc
, "%<_Alignas%> specifiers cannot reduce "
5810 "alignment of unnamed field");
5816 /* Did array size calculations overflow or does the array cover more
5817 than half of the address-space? */
5818 if (TREE_CODE (type
) == ARRAY_TYPE
5819 && COMPLETE_TYPE_P (type
)
5820 && TREE_CODE (TYPE_SIZE_UNIT (type
)) == INTEGER_CST
5821 && ! valid_constant_size_p (TYPE_SIZE_UNIT (type
)))
5824 error_at (loc
, "size of array %qE is too large", name
);
5826 error_at (loc
, "size of unnamed array is too large");
5827 /* If we proceed with the array type as it is, we'll eventually
5828 crash in tree_low_cst(). */
5829 type
= error_mark_node
;
5832 /* If this is declaring a typedef name, return a TYPE_DECL. */
5834 if (storage_class
== csc_typedef
)
5837 if (pedantic
&& TREE_CODE (type
) == FUNCTION_TYPE
5839 pedwarn (loc
, OPT_Wpedantic
,
5840 "ISO C forbids qualified function types");
5842 type
= c_build_qualified_type (type
, type_quals
);
5843 decl
= build_decl (declarator
->id_loc
,
5844 TYPE_DECL
, declarator
->u
.id
, type
);
5845 if (declspecs
->explicit_signed_p
)
5846 C_TYPEDEF_EXPLICITLY_SIGNED (decl
) = 1;
5847 if (declspecs
->inline_p
)
5848 pedwarn (loc
, 0,"typedef %q+D declared %<inline%>", decl
);
5849 if (declspecs
->noreturn_p
)
5850 pedwarn (loc
, 0,"typedef %q+D declared %<_Noreturn%>", decl
);
5852 if (warn_cxx_compat
&& declarator
->u
.id
!= NULL_TREE
)
5854 struct c_binding
*b
= I_TAG_BINDING (declarator
->u
.id
);
5857 && b
->decl
!= NULL_TREE
5858 && (B_IN_CURRENT_SCOPE (b
)
5859 || (current_scope
== file_scope
&& B_IN_EXTERNAL_SCOPE (b
)))
5860 && TYPE_MAIN_VARIANT (b
->decl
) != TYPE_MAIN_VARIANT (type
))
5862 warning_at (declarator
->id_loc
, OPT_Wc___compat
,
5863 ("using %qD as both a typedef and a tag is "
5866 if (b
->locus
!= UNKNOWN_LOCATION
)
5867 inform (b
->locus
, "originally defined here");
5874 /* If this is a type name (such as, in a cast or sizeof),
5875 compute the type and return it now. */
5877 if (decl_context
== TYPENAME
)
5879 /* Note that the grammar rejects storage classes in typenames
5881 gcc_assert (storage_class
== csc_none
&& !threadp
5882 && !declspecs
->inline_p
&& !declspecs
->noreturn_p
);
5883 if (pedantic
&& TREE_CODE (type
) == FUNCTION_TYPE
5885 pedwarn (loc
, OPT_Wpedantic
,
5886 "ISO C forbids const or volatile function types");
5888 type
= c_build_qualified_type (type
, type_quals
);
5892 if (pedantic
&& decl_context
== FIELD
5893 && variably_modified_type_p (type
, NULL_TREE
))
5896 pedwarn (loc
, OPT_Wpedantic
, "a member of a structure or union cannot "
5897 "have a variably modified type");
5900 /* Aside from typedefs and type names (handle above),
5901 `void' at top level (not within pointer)
5902 is allowed only in public variables.
5903 We don't complain about parms either, but that is because
5904 a better error message can be made later. */
5906 if (VOID_TYPE_P (type
) && decl_context
!= PARM
5907 && !((decl_context
!= FIELD
&& TREE_CODE (type
) != FUNCTION_TYPE
)
5908 && (storage_class
== csc_extern
5909 || (current_scope
== file_scope
5910 && !(storage_class
== csc_static
5911 || storage_class
== csc_register
)))))
5913 error_at (loc
, "variable or field %qE declared void", name
);
5914 type
= integer_type_node
;
5917 /* Now create the decl, which may be a VAR_DECL, a PARM_DECL
5918 or a FUNCTION_DECL, depending on DECL_CONTEXT and TYPE. */
5923 if (decl_context
== PARM
)
5927 /* A parameter declared as an array of T is really a pointer to T.
5928 One declared as a function is really a pointer to a function. */
5930 if (TREE_CODE (type
) == ARRAY_TYPE
)
5932 /* Transfer const-ness of array into that of type pointed to. */
5933 type
= TREE_TYPE (type
);
5935 type
= c_build_qualified_type (type
, type_quals
);
5936 type
= c_build_pointer_type (type
);
5937 type_quals
= array_ptr_quals
;
5939 type
= c_build_qualified_type (type
, type_quals
);
5941 /* We don't yet implement attributes in this context. */
5942 if (array_ptr_attrs
!= NULL_TREE
)
5943 warning_at (loc
, OPT_Wattributes
,
5944 "attributes in parameter array declarator ignored");
5946 size_varies
= false;
5948 else if (TREE_CODE (type
) == FUNCTION_TYPE
)
5951 pedwarn (loc
, OPT_Wpedantic
,
5952 "ISO C forbids qualified function types");
5954 type
= c_build_qualified_type (type
, type_quals
);
5955 type
= c_build_pointer_type (type
);
5956 type_quals
= TYPE_UNQUALIFIED
;
5958 else if (type_quals
)
5959 type
= c_build_qualified_type (type
, type_quals
);
5961 decl
= build_decl (declarator
->id_loc
,
5962 PARM_DECL
, declarator
->u
.id
, type
);
5964 C_DECL_VARIABLE_SIZE (decl
) = 1;
5966 /* Compute the type actually passed in the parmlist,
5967 for the case where there is no prototype.
5968 (For example, shorts and chars are passed as ints.)
5969 When there is a prototype, this is overridden later. */
5971 if (type
== error_mark_node
)
5972 promoted_type
= type
;
5974 promoted_type
= c_type_promotes_to (type
);
5976 DECL_ARG_TYPE (decl
) = promoted_type
;
5977 if (declspecs
->inline_p
)
5978 pedwarn (loc
, 0, "parameter %q+D declared %<inline%>", decl
);
5979 if (declspecs
->noreturn_p
)
5980 pedwarn (loc
, 0, "parameter %q+D declared %<_Noreturn%>", decl
);
5982 else if (decl_context
== FIELD
)
5984 /* Note that the grammar rejects storage classes in typenames
5986 gcc_assert (storage_class
== csc_none
&& !threadp
5987 && !declspecs
->inline_p
&& !declspecs
->noreturn_p
);
5989 /* Structure field. It may not be a function. */
5991 if (TREE_CODE (type
) == FUNCTION_TYPE
)
5993 error_at (loc
, "field %qE declared as a function", name
);
5994 type
= build_pointer_type (type
);
5996 else if (TREE_CODE (type
) != ERROR_MARK
5997 && !COMPLETE_OR_UNBOUND_ARRAY_TYPE_P (type
))
6000 error_at (loc
, "field %qE has incomplete type", name
);
6002 error_at (loc
, "unnamed field has incomplete type");
6003 type
= error_mark_node
;
6005 type
= c_build_qualified_type (type
, type_quals
);
6006 decl
= build_decl (declarator
->id_loc
,
6007 FIELD_DECL
, declarator
->u
.id
, type
);
6008 DECL_NONADDRESSABLE_P (decl
) = bitfield
;
6009 if (bitfield
&& !declarator
->u
.id
)
6010 TREE_NO_WARNING (decl
) = 1;
6013 C_DECL_VARIABLE_SIZE (decl
) = 1;
6015 else if (TREE_CODE (type
) == FUNCTION_TYPE
)
6017 if (storage_class
== csc_register
|| threadp
)
6019 error_at (loc
, "invalid storage class for function %qE", name
);
6021 else if (current_scope
!= file_scope
)
6023 /* Function declaration not at file scope. Storage
6024 classes other than `extern' are not allowed, C99
6025 6.7.1p5, and `extern' makes no difference. However,
6026 GCC allows 'auto', perhaps with 'inline', to support
6027 nested functions. */
6028 if (storage_class
== csc_auto
)
6029 pedwarn (loc
, OPT_Wpedantic
,
6030 "invalid storage class for function %qE", name
);
6031 else if (storage_class
== csc_static
)
6033 error_at (loc
, "invalid storage class for function %qE", name
);
6035 storage_class
= declspecs
->storage_class
= csc_none
;
6041 decl
= build_decl (declarator
->id_loc
,
6042 FUNCTION_DECL
, declarator
->u
.id
, type
);
6043 decl
= build_decl_attribute_variant (decl
, decl_attr
);
6045 if (pedantic
&& type_quals
&& !DECL_IN_SYSTEM_HEADER (decl
))
6046 pedwarn (loc
, OPT_Wpedantic
,
6047 "ISO C forbids qualified function types");
6049 /* Every function declaration is an external reference
6050 (DECL_EXTERNAL) except for those which are not at file
6051 scope and are explicitly declared "auto". This is
6052 forbidden by standard C (C99 6.7.1p5) and is interpreted by
6053 GCC to signify a forward declaration of a nested function. */
6054 if (storage_class
== csc_auto
&& current_scope
!= file_scope
)
6055 DECL_EXTERNAL (decl
) = 0;
6056 /* In C99, a function which is declared 'inline' with 'extern'
6057 is not an external reference (which is confusing). It
6058 means that the later definition of the function must be output
6059 in this file, C99 6.7.4p6. In GNU C89, a function declared
6060 'extern inline' is an external reference. */
6061 else if (declspecs
->inline_p
&& storage_class
!= csc_static
)
6062 DECL_EXTERNAL (decl
) = ((storage_class
== csc_extern
)
6063 == flag_gnu89_inline
);
6065 DECL_EXTERNAL (decl
) = !initialized
;
6067 /* Record absence of global scope for `static' or `auto'. */
6069 = !(storage_class
== csc_static
|| storage_class
== csc_auto
);
6071 /* For a function definition, record the argument information
6072 block where store_parm_decls will look for it. */
6074 current_function_arg_info
= arg_info
;
6076 if (declspecs
->default_int_p
)
6077 C_FUNCTION_IMPLICIT_INT (decl
) = 1;
6079 /* Record presence of `inline' and `_Noreturn', if it is
6081 if (flag_hosted
&& MAIN_NAME_P (declarator
->u
.id
))
6083 if (declspecs
->inline_p
)
6084 pedwarn (loc
, 0, "cannot inline function %<main%>");
6085 if (declspecs
->noreturn_p
)
6086 pedwarn (loc
, 0, "%<main%> declared %<_Noreturn%>");
6090 if (declspecs
->inline_p
)
6091 /* Record that the function is declared `inline'. */
6092 DECL_DECLARED_INLINE_P (decl
) = 1;
6093 if (declspecs
->noreturn_p
)
6098 pedwarn (loc
, OPT_Wpedantic
,
6099 "ISO C99 does not support %<_Noreturn%>");
6101 pedwarn (loc
, OPT_Wpedantic
,
6102 "ISO C90 does not support %<_Noreturn%>");
6104 TREE_THIS_VOLATILE (decl
) = 1;
6110 /* It's a variable. */
6111 /* An uninitialized decl with `extern' is a reference. */
6112 int extern_ref
= !initialized
&& storage_class
== csc_extern
;
6114 type
= c_build_qualified_type (type
, type_quals
);
6116 /* C99 6.2.2p7: It is invalid (compile-time undefined
6117 behavior) to create an 'extern' declaration for a
6118 variable if there is a global declaration that is
6119 'static' and the global declaration is not visible.
6120 (If the static declaration _is_ currently visible,
6121 the 'extern' declaration is taken to refer to that decl.) */
6122 if (extern_ref
&& current_scope
!= file_scope
)
6124 tree global_decl
= identifier_global_value (declarator
->u
.id
);
6125 tree visible_decl
= lookup_name (declarator
->u
.id
);
6128 && global_decl
!= visible_decl
6129 && TREE_CODE (global_decl
) == VAR_DECL
6130 && !TREE_PUBLIC (global_decl
))
6131 error_at (loc
, "variable previously declared %<static%> "
6132 "redeclared %<extern%>");
6135 decl
= build_decl (declarator
->id_loc
,
6136 VAR_DECL
, declarator
->u
.id
, type
);
6138 C_DECL_VARIABLE_SIZE (decl
) = 1;
6140 if (declspecs
->inline_p
)
6141 pedwarn (loc
, 0, "variable %q+D declared %<inline%>", decl
);
6142 if (declspecs
->noreturn_p
)
6143 pedwarn (loc
, 0, "variable %q+D declared %<_Noreturn%>", decl
);
6145 /* At file scope, an initialized extern declaration may follow
6146 a static declaration. In that case, DECL_EXTERNAL will be
6147 reset later in start_decl. */
6148 DECL_EXTERNAL (decl
) = (storage_class
== csc_extern
);
6150 /* At file scope, the presence of a `static' or `register' storage
6151 class specifier, or the absence of all storage class specifiers
6152 makes this declaration a definition (perhaps tentative). Also,
6153 the absence of `static' makes it public. */
6154 if (current_scope
== file_scope
)
6156 TREE_PUBLIC (decl
) = storage_class
!= csc_static
;
6157 TREE_STATIC (decl
) = !extern_ref
;
6159 /* Not at file scope, only `static' makes a static definition. */
6162 TREE_STATIC (decl
) = (storage_class
== csc_static
);
6163 TREE_PUBLIC (decl
) = extern_ref
;
6167 DECL_TLS_MODEL (decl
) = decl_default_tls_model (decl
);
6170 if ((storage_class
== csc_extern
6171 || (storage_class
== csc_none
6172 && TREE_CODE (type
) == FUNCTION_TYPE
6174 && variably_modified_type_p (type
, NULL_TREE
))
6177 if (TREE_CODE (type
) == FUNCTION_TYPE
)
6178 error_at (loc
, "non-nested function with variably modified type");
6180 error_at (loc
, "object with variably modified type must have "
6184 /* Record `register' declaration for warnings on &
6185 and in case doing stupid register allocation. */
6187 if (storage_class
== csc_register
)
6189 C_DECL_REGISTER (decl
) = 1;
6190 DECL_REGISTER (decl
) = 1;
6193 /* Record constancy and volatility. */
6194 c_apply_type_quals_to_decl (type_quals
, decl
);
6196 /* Apply _Alignas specifiers. */
6199 DECL_ALIGN (decl
) = alignas_align
* BITS_PER_UNIT
;
6200 DECL_USER_ALIGN (decl
) = 1;
6203 /* If a type has volatile components, it should be stored in memory.
6204 Otherwise, the fact that those components are volatile
6205 will be ignored, and would even crash the compiler.
6206 Of course, this only makes sense on VAR,PARM, and RESULT decl's. */
6207 if (C_TYPE_FIELDS_VOLATILE (TREE_TYPE (decl
))
6208 && (TREE_CODE (decl
) == VAR_DECL
|| TREE_CODE (decl
) == PARM_DECL
6209 || TREE_CODE (decl
) == RESULT_DECL
))
6211 /* It is not an error for a structure with volatile fields to
6212 be declared register, but reset DECL_REGISTER since it
6213 cannot actually go in a register. */
6214 int was_reg
= C_DECL_REGISTER (decl
);
6215 C_DECL_REGISTER (decl
) = 0;
6216 DECL_REGISTER (decl
) = 0;
6217 c_mark_addressable (decl
);
6218 C_DECL_REGISTER (decl
) = was_reg
;
6221 /* This is the earliest point at which we might know the assembler
6222 name of a variable. Thus, if it's known before this, die horribly. */
6223 gcc_assert (!DECL_ASSEMBLER_NAME_SET_P (decl
));
6226 && TREE_CODE (decl
) == VAR_DECL
6227 && TREE_PUBLIC (decl
)
6228 && TREE_STATIC (decl
)
6229 && (TREE_CODE (TREE_TYPE (decl
)) == RECORD_TYPE
6230 || TREE_CODE (TREE_TYPE (decl
)) == UNION_TYPE
6231 || TREE_CODE (TREE_TYPE (decl
)) == ENUMERAL_TYPE
)
6232 && TYPE_NAME (TREE_TYPE (decl
)) == NULL_TREE
)
6233 warning_at (DECL_SOURCE_LOCATION (decl
), OPT_Wc___compat
,
6234 ("non-local variable %qD with anonymous type is "
6235 "questionable in C++"),
6242 /* Decode the parameter-list info for a function type or function definition.
6243 The argument is the value returned by `get_parm_info' (or made in c-parse.c
6244 if there is an identifier list instead of a parameter decl list).
6245 These two functions are separate because when a function returns
6246 or receives functions then each is called multiple times but the order
6247 of calls is different. The last call to `grokparms' is always the one
6248 that contains the formal parameter names of a function definition.
6250 Return a list of arg types to use in the FUNCTION_TYPE for this function.
6252 FUNCDEF_FLAG is true for a function definition, false for
6253 a mere declaration. A nonempty identifier-list gets an error message
6254 when FUNCDEF_FLAG is false. */
6257 grokparms (struct c_arg_info
*arg_info
, bool funcdef_flag
)
6259 tree arg_types
= arg_info
->types
;
6261 if (funcdef_flag
&& arg_info
->had_vla_unspec
)
6263 /* A function definition isn't function prototype scope C99 6.2.1p4. */
6265 error ("%<[*]%> not allowed in other than function prototype scope");
6268 if (arg_types
== 0 && !funcdef_flag
&& !in_system_header
)
6269 warning (OPT_Wstrict_prototypes
,
6270 "function declaration isn%'t a prototype");
6272 if (arg_types
== error_mark_node
)
6273 return 0; /* don't set TYPE_ARG_TYPES in this case */
6275 else if (arg_types
&& TREE_CODE (TREE_VALUE (arg_types
)) == IDENTIFIER_NODE
)
6279 pedwarn (input_location
, 0, "parameter names (without types) in function declaration");
6280 arg_info
->parms
= NULL_TREE
;
6283 arg_info
->parms
= arg_info
->types
;
6285 arg_info
->types
= 0;
6290 tree parm
, type
, typelt
;
6291 unsigned int parmno
;
6294 /* If there is a parameter of incomplete type in a definition,
6295 this is an error. In a declaration this is valid, and a
6296 struct or union type may be completed later, before any calls
6297 or definition of the function. In the case where the tag was
6298 first declared within the parameter list, a warning has
6299 already been given. If a parameter has void type, then
6300 however the function cannot be defined or called, so
6303 for (parm
= arg_info
->parms
, typelt
= arg_types
, parmno
= 1;
6305 parm
= DECL_CHAIN (parm
), typelt
= TREE_CHAIN (typelt
), parmno
++)
6307 type
= TREE_VALUE (typelt
);
6308 if (type
== error_mark_node
)
6311 if (!COMPLETE_TYPE_P (type
))
6315 if (DECL_NAME (parm
))
6316 error_at (input_location
,
6317 "parameter %u (%q+D) has incomplete type",
6320 error_at (DECL_SOURCE_LOCATION (parm
),
6321 "parameter %u has incomplete type",
6324 TREE_VALUE (typelt
) = error_mark_node
;
6325 TREE_TYPE (parm
) = error_mark_node
;
6326 arg_types
= NULL_TREE
;
6328 else if (VOID_TYPE_P (type
))
6330 if (DECL_NAME (parm
))
6331 warning_at (input_location
, 0,
6332 "parameter %u (%q+D) has void type",
6335 warning_at (DECL_SOURCE_LOCATION (parm
), 0,
6336 "parameter %u has void type",
6341 errmsg
= targetm
.invalid_parameter_type (type
);
6345 TREE_VALUE (typelt
) = error_mark_node
;
6346 TREE_TYPE (parm
) = error_mark_node
;
6347 arg_types
= NULL_TREE
;
6350 if (DECL_NAME (parm
) && TREE_USED (parm
))
6351 warn_if_shadowing (parm
);
6357 /* Allocate and initialize a c_arg_info structure from the parser's
6361 build_arg_info (void)
6363 struct c_arg_info
*ret
= XOBNEW (&parser_obstack
, struct c_arg_info
);
6364 ret
->parms
= NULL_TREE
;
6366 ret
->types
= NULL_TREE
;
6367 ret
->others
= NULL_TREE
;
6368 ret
->pending_sizes
= NULL
;
6369 ret
->had_vla_unspec
= 0;
6373 /* Take apart the current scope and return a c_arg_info structure with
6374 info on a parameter list just parsed.
6376 This structure is later fed to 'grokparms' and 'store_parm_decls'.
6378 ELLIPSIS being true means the argument list ended in '...' so don't
6379 append a sentinel (void_list_node) to the end of the type-list.
6381 EXPR is NULL or an expression that needs to be evaluated for the
6382 side effects of array size expressions in the parameters. */
6385 get_parm_info (bool ellipsis
, tree expr
)
6387 struct c_binding
*b
= current_scope
->bindings
;
6388 struct c_arg_info
*arg_info
= build_arg_info ();
6391 VEC(c_arg_tag
,gc
) *tags
= NULL
;
6395 static bool explained_incomplete_types
= false;
6396 bool gave_void_only_once_err
= false;
6398 arg_info
->had_vla_unspec
= current_scope
->had_vla_unspec
;
6400 /* The bindings in this scope must not get put into a block.
6401 We will take care of deleting the binding nodes. */
6402 current_scope
->bindings
= 0;
6404 /* This function is only called if there was *something* on the
6408 /* A parameter list consisting solely of 'void' indicates that the
6409 function takes no arguments. But if the 'void' is qualified
6410 (by 'const' or 'volatile'), or has a storage class specifier
6411 ('register'), then the behavior is undefined; issue an error.
6412 Typedefs for 'void' are OK (see DR#157). */
6413 if (b
->prev
== 0 /* one binding */
6414 && TREE_CODE (b
->decl
) == PARM_DECL
/* which is a parameter */
6415 && !DECL_NAME (b
->decl
) /* anonymous */
6416 && VOID_TYPE_P (TREE_TYPE (b
->decl
))) /* of void type */
6418 if (TREE_THIS_VOLATILE (b
->decl
)
6419 || TREE_READONLY (b
->decl
)
6420 || C_DECL_REGISTER (b
->decl
))
6421 error ("%<void%> as only parameter may not be qualified");
6423 /* There cannot be an ellipsis. */
6425 error ("%<void%> must be the only parameter");
6427 arg_info
->types
= void_list_node
;
6432 types
= void_list_node
;
6434 /* Break up the bindings list into parms, tags, types, and others;
6435 apply sanity checks; purge the name-to-decl bindings. */
6438 tree decl
= b
->decl
;
6439 tree type
= TREE_TYPE (decl
);
6441 const char *keyword
;
6443 switch (TREE_CODE (decl
))
6448 gcc_assert (I_SYMBOL_BINDING (b
->id
) == b
);
6449 I_SYMBOL_BINDING (b
->id
) = b
->shadowed
;
6452 /* Check for forward decls that never got their actual decl. */
6453 if (TREE_ASM_WRITTEN (decl
))
6454 error ("parameter %q+D has just a forward declaration", decl
);
6455 /* Check for (..., void, ...) and issue an error. */
6456 else if (VOID_TYPE_P (type
) && !DECL_NAME (decl
))
6458 if (!gave_void_only_once_err
)
6460 error ("%<void%> must be the only parameter");
6461 gave_void_only_once_err
= true;
6466 /* Valid parameter, add it to the list. */
6467 DECL_CHAIN (decl
) = parms
;
6470 /* Since there is a prototype, args are passed in their
6471 declared types. The back end may override this later. */
6472 DECL_ARG_TYPE (decl
) = type
;
6473 types
= tree_cons (0, type
, types
);
6477 case ENUMERAL_TYPE
: keyword
= "enum"; goto tag
;
6478 case UNION_TYPE
: keyword
= "union"; goto tag
;
6479 case RECORD_TYPE
: keyword
= "struct"; goto tag
;
6481 /* Types may not have tag-names, in which case the type
6482 appears in the bindings list with b->id NULL. */
6485 gcc_assert (I_TAG_BINDING (b
->id
) == b
);
6486 I_TAG_BINDING (b
->id
) = b
->shadowed
;
6489 /* Warn about any struct, union or enum tags defined in a
6490 parameter list. The scope of such types is limited to
6491 the parameter list, which is rarely if ever desirable
6492 (it's impossible to call such a function with type-
6493 correct arguments). An anonymous union parm type is
6494 meaningful as a GNU extension, so don't warn for that. */
6495 if (TREE_CODE (decl
) != UNION_TYPE
|| b
->id
!= 0)
6498 /* The %s will be one of 'struct', 'union', or 'enum'. */
6499 warning (0, "%<%s %E%> declared inside parameter list",
6502 /* The %s will be one of 'struct', 'union', or 'enum'. */
6503 warning (0, "anonymous %s declared inside parameter list",
6506 if (!explained_incomplete_types
)
6508 warning (0, "its scope is only this definition or declaration,"
6509 " which is probably not what you want");
6510 explained_incomplete_types
= true;
6516 VEC_safe_push (c_arg_tag
, gc
, tags
, tag
);
6522 /* CONST_DECLs appear here when we have an embedded enum,
6523 and TYPE_DECLs appear here when we have an embedded struct
6524 or union. No warnings for this - we already warned about the
6525 type itself. FUNCTION_DECLs appear when there is an implicit
6526 function declaration in the parameter list. */
6528 /* When we reinsert this decl in the function body, we need
6529 to reconstruct whether it was marked as nested. */
6530 gcc_assert (TREE_CODE (decl
) == FUNCTION_DECL
6533 DECL_CHAIN (decl
) = others
;
6538 /* error_mark_node appears here when we have an undeclared
6539 variable. Just throw it away. */
6542 gcc_assert (I_SYMBOL_BINDING (b
->id
) == b
);
6543 I_SYMBOL_BINDING (b
->id
) = b
->shadowed
;
6547 /* Other things that might be encountered. */
6554 b
= free_binding_and_advance (b
);
6557 arg_info
->parms
= parms
;
6558 arg_info
->tags
= tags
;
6559 arg_info
->types
= types
;
6560 arg_info
->others
= others
;
6561 arg_info
->pending_sizes
= expr
;
6565 /* Get the struct, enum or union (CODE says which) with tag NAME.
6566 Define the tag as a forward-reference with location LOC if it is
6567 not defined. Return a c_typespec structure for the type
6571 parser_xref_tag (location_t loc
, enum tree_code code
, tree name
)
6573 struct c_typespec ret
;
6577 ret
.expr
= NULL_TREE
;
6578 ret
.expr_const_operands
= true;
6580 /* If a cross reference is requested, look up the type
6581 already defined for this tag and return it. */
6583 ref
= lookup_tag (code
, name
, 0, &refloc
);
6584 /* If this is the right type of tag, return what we found.
6585 (This reference will be shadowed by shadow_tag later if appropriate.)
6586 If this is the wrong type of tag, do not return it. If it was the
6587 wrong type in the same scope, we will have had an error
6588 message already; if in a different scope and declaring
6589 a name, pending_xref_error will give an error message; but if in a
6590 different scope and not declaring a name, this tag should
6591 shadow the previous declaration of a different type of tag, and
6592 this would not work properly if we return the reference found.
6593 (For example, with "struct foo" in an outer scope, "union foo;"
6594 must shadow that tag with a new one of union type.) */
6595 ret
.kind
= (ref
? ctsk_tagref
: ctsk_tagfirstref
);
6596 if (ref
&& TREE_CODE (ref
) == code
)
6598 if (C_TYPE_DEFINED_IN_STRUCT (ref
)
6599 && loc
!= UNKNOWN_LOCATION
6605 warning_at (loc
, OPT_Wc___compat
,
6606 ("enum type defined in struct or union "
6607 "is not visible in C++"));
6608 inform (refloc
, "enum type defined here");
6611 warning_at (loc
, OPT_Wc___compat
,
6612 ("struct defined in struct or union "
6613 "is not visible in C++"));
6614 inform (refloc
, "struct defined here");
6617 warning_at (loc
, OPT_Wc___compat
,
6618 ("union defined in struct or union "
6619 "is not visible in C++"));
6620 inform (refloc
, "union defined here");
6631 /* If no such tag is yet defined, create a forward-reference node
6632 and record it as the "definition".
6633 When a real declaration of this type is found,
6634 the forward-reference will be altered into a real type. */
6636 ref
= make_node (code
);
6637 if (code
== ENUMERAL_TYPE
)
6639 /* Give the type a default layout like unsigned int
6640 to avoid crashing if it does not get defined. */
6641 SET_TYPE_MODE (ref
, TYPE_MODE (unsigned_type_node
));
6642 TYPE_ALIGN (ref
) = TYPE_ALIGN (unsigned_type_node
);
6643 TYPE_USER_ALIGN (ref
) = 0;
6644 TYPE_UNSIGNED (ref
) = 1;
6645 TYPE_PRECISION (ref
) = TYPE_PRECISION (unsigned_type_node
);
6646 TYPE_MIN_VALUE (ref
) = TYPE_MIN_VALUE (unsigned_type_node
);
6647 TYPE_MAX_VALUE (ref
) = TYPE_MAX_VALUE (unsigned_type_node
);
6650 pushtag (loc
, name
, ref
);
6656 /* Get the struct, enum or union (CODE says which) with tag NAME.
6657 Define the tag as a forward-reference if it is not defined.
6658 Return a tree for the type. */
6661 xref_tag (enum tree_code code
, tree name
)
6663 return parser_xref_tag (input_location
, code
, name
).spec
;
6666 /* Make sure that the tag NAME is defined *in the current scope*
6667 at least as a forward reference.
6668 LOC is the location of the struct's definition.
6669 CODE says which kind of tag NAME ought to be.
6671 This stores the current value of the file static STRUCT_PARSE_INFO
6672 in *ENCLOSING_STRUCT_PARSE_INFO, and points STRUCT_PARSE_INFO at a
6673 new c_struct_parse_info structure. The old value of
6674 STRUCT_PARSE_INFO is restored in finish_struct. */
6677 start_struct (location_t loc
, enum tree_code code
, tree name
,
6678 struct c_struct_parse_info
**enclosing_struct_parse_info
)
6680 /* If there is already a tag defined at this scope
6681 (as a forward reference), just return it. */
6683 tree ref
= NULL_TREE
;
6684 location_t refloc
= UNKNOWN_LOCATION
;
6686 if (name
!= NULL_TREE
)
6687 ref
= lookup_tag (code
, name
, 1, &refloc
);
6688 if (ref
&& TREE_CODE (ref
) == code
)
6690 if (TYPE_SIZE (ref
))
6692 if (code
== UNION_TYPE
)
6693 error_at (loc
, "redefinition of %<union %E%>", name
);
6695 error_at (loc
, "redefinition of %<struct %E%>", name
);
6696 if (refloc
!= UNKNOWN_LOCATION
)
6697 inform (refloc
, "originally defined here");
6698 /* Don't create structures using a name already in use. */
6701 else if (C_TYPE_BEING_DEFINED (ref
))
6703 if (code
== UNION_TYPE
)
6704 error_at (loc
, "nested redefinition of %<union %E%>", name
);
6706 error_at (loc
, "nested redefinition of %<struct %E%>", name
);
6707 /* Don't bother to report "originally defined here" for a
6708 nested redefinition; the original definition should be
6710 /* Don't create structures that contain themselves. */
6715 /* Otherwise create a forward-reference just so the tag is in scope. */
6717 if (ref
== NULL_TREE
|| TREE_CODE (ref
) != code
)
6719 ref
= make_node (code
);
6720 pushtag (loc
, name
, ref
);
6723 C_TYPE_BEING_DEFINED (ref
) = 1;
6724 TYPE_PACKED (ref
) = flag_pack_struct
;
6726 *enclosing_struct_parse_info
= struct_parse_info
;
6727 struct_parse_info
= XNEW (struct c_struct_parse_info
);
6728 struct_parse_info
->struct_types
= VEC_alloc (tree
, heap
, 0);
6729 struct_parse_info
->fields
= VEC_alloc (c_binding_ptr
, heap
, 0);
6730 struct_parse_info
->typedefs_seen
= VEC_alloc (tree
, heap
, 0);
6732 /* FIXME: This will issue a warning for a use of a type defined
6733 within a statement expr used within sizeof, et. al. This is not
6734 terribly serious as C++ doesn't permit statement exprs within
6736 if (warn_cxx_compat
&& (in_sizeof
|| in_typeof
|| in_alignof
))
6737 warning_at (loc
, OPT_Wc___compat
,
6738 "defining type in %qs expression is invalid in C++",
6741 : (in_typeof
? "typeof" : "alignof")));
6746 /* Process the specs, declarator and width (NULL if omitted)
6747 of a structure component, returning a FIELD_DECL node.
6748 WIDTH is non-NULL for bit-fields only, and is an INTEGER_CST node.
6749 DECL_ATTRS is as for grokdeclarator.
6751 LOC is the location of the structure component.
6753 This is done during the parsing of the struct declaration.
6754 The FIELD_DECL nodes are chained together and the lot of them
6755 are ultimately passed to `build_struct' to make the RECORD_TYPE node. */
6758 grokfield (location_t loc
,
6759 struct c_declarator
*declarator
, struct c_declspecs
*declspecs
,
6760 tree width
, tree
*decl_attrs
)
6764 if (declarator
->kind
== cdk_id
&& declarator
->u
.id
== NULL_TREE
6765 && width
== NULL_TREE
)
6767 /* This is an unnamed decl.
6769 If we have something of the form "union { list } ;" then this
6770 is the anonymous union extension. Similarly for struct.
6772 If this is something of the form "struct foo;", then
6773 If MS or Plan 9 extensions are enabled, this is handled as
6774 an anonymous struct.
6775 Otherwise this is a forward declaration of a structure tag.
6777 If this is something of the form "foo;" and foo is a TYPE_DECL, then
6778 If foo names a structure or union without a tag, then this
6779 is an anonymous struct (this is permitted by C11).
6780 If MS or Plan 9 extensions are enabled and foo names a
6781 structure, then again this is an anonymous struct.
6782 Otherwise this is an error.
6784 Oh what a horrid tangled web we weave. I wonder if MS consciously
6785 took this from Plan 9 or if it was an accident of implementation
6786 that took root before someone noticed the bug... */
6788 tree type
= declspecs
->type
;
6789 bool type_ok
= (TREE_CODE (type
) == RECORD_TYPE
6790 || TREE_CODE (type
) == UNION_TYPE
);
6794 && (flag_ms_extensions
6795 || flag_plan9_extensions
6796 || !declspecs
->typedef_p
))
6798 if (flag_ms_extensions
|| flag_plan9_extensions
)
6800 else if (TYPE_NAME (type
) == NULL
)
6807 pedwarn (loc
, 0, "declaration does not declare anything");
6813 pedwarn (loc
, OPT_Wpedantic
,
6814 "ISO C99 doesn%'t support unnamed structs/unions");
6816 pedwarn (loc
, OPT_Wpedantic
,
6817 "ISO C90 doesn%'t support unnamed structs/unions");
6821 value
= grokdeclarator (declarator
, declspecs
, FIELD
, false,
6822 width
? &width
: NULL
, decl_attrs
, NULL
, NULL
,
6825 finish_decl (value
, loc
, NULL_TREE
, NULL_TREE
, NULL_TREE
);
6826 DECL_INITIAL (value
) = width
;
6828 if (warn_cxx_compat
&& DECL_NAME (value
) != NULL_TREE
)
6830 /* If we currently have a binding for this field, set the
6831 in_struct field in the binding, so that we warn about lookups
6833 struct c_binding
*b
= I_SYMBOL_BINDING (DECL_NAME (value
));
6836 /* If the in_struct field is not yet set, push it on a list
6837 to be cleared when this struct is finished. */
6840 VEC_safe_push (c_binding_ptr
, heap
,
6841 struct_parse_info
->fields
, b
);
6850 /* Subroutine of detect_field_duplicates: return whether X and Y,
6851 which are both fields in the same struct, have duplicate field
6855 is_duplicate_field (tree x
, tree y
)
6857 if (DECL_NAME (x
) != NULL_TREE
&& DECL_NAME (x
) == DECL_NAME (y
))
6860 /* When using -fplan9-extensions, an anonymous field whose name is a
6861 typedef can duplicate a field name. */
6862 if (flag_plan9_extensions
6863 && (DECL_NAME (x
) == NULL_TREE
|| DECL_NAME (y
) == NULL_TREE
))
6865 tree xt
, xn
, yt
, yn
;
6868 if (DECL_NAME (x
) != NULL_TREE
)
6870 else if ((TREE_CODE (xt
) == RECORD_TYPE
|| TREE_CODE (xt
) == UNION_TYPE
)
6871 && TYPE_NAME (xt
) != NULL_TREE
6872 && TREE_CODE (TYPE_NAME (xt
)) == TYPE_DECL
)
6873 xn
= DECL_NAME (TYPE_NAME (xt
));
6878 if (DECL_NAME (y
) != NULL_TREE
)
6880 else if ((TREE_CODE (yt
) == RECORD_TYPE
|| TREE_CODE (yt
) == UNION_TYPE
)
6881 && TYPE_NAME (yt
) != NULL_TREE
6882 && TREE_CODE (TYPE_NAME (yt
)) == TYPE_DECL
)
6883 yn
= DECL_NAME (TYPE_NAME (yt
));
6887 if (xn
!= NULL_TREE
&& xn
== yn
)
6894 /* Subroutine of detect_field_duplicates: add the fields of FIELDLIST
6895 to HTAB, giving errors for any duplicates. */
6898 detect_field_duplicates_hash (tree fieldlist
, htab_t htab
)
6903 for (x
= fieldlist
; x
; x
= DECL_CHAIN (x
))
6904 if ((y
= DECL_NAME (x
)) != 0)
6906 slot
= htab_find_slot (htab
, y
, INSERT
);
6909 error ("duplicate member %q+D", x
);
6910 DECL_NAME (x
) = NULL_TREE
;
6914 else if (TREE_CODE (TREE_TYPE (x
)) == RECORD_TYPE
6915 || TREE_CODE (TREE_TYPE (x
)) == UNION_TYPE
)
6917 detect_field_duplicates_hash (TYPE_FIELDS (TREE_TYPE (x
)), htab
);
6919 /* When using -fplan9-extensions, an anonymous field whose
6920 name is a typedef can duplicate a field name. */
6921 if (flag_plan9_extensions
6922 && TYPE_NAME (TREE_TYPE (x
)) != NULL_TREE
6923 && TREE_CODE (TYPE_NAME (TREE_TYPE (x
))) == TYPE_DECL
)
6925 tree xn
= DECL_NAME (TYPE_NAME (TREE_TYPE (x
)));
6926 slot
= htab_find_slot (htab
, xn
, INSERT
);
6928 error ("duplicate member %q+D", TYPE_NAME (TREE_TYPE (x
)));
6934 /* Generate an error for any duplicate field names in FIELDLIST. Munge
6935 the list such that this does not present a problem later. */
6938 detect_field_duplicates (tree fieldlist
)
6943 /* If the struct is the list of instance variables of an Objective-C
6944 class, then we need to check all the instance variables of
6945 superclasses when checking for duplicates (since you can't have
6946 an instance variable in a subclass with the same name as an
6947 instance variable in a superclass). We pass on this job to the
6948 Objective-C compiler. objc_detect_field_duplicates() will return
6949 false if we are not checking the list of instance variables and
6950 the C frontend should proceed with the standard field duplicate
6951 checks. If we are checking the list of instance variables, the
6952 ObjC frontend will do the check, emit the errors if needed, and
6953 then return true. */
6954 if (c_dialect_objc ())
6955 if (objc_detect_field_duplicates (false))
6958 /* First, see if there are more than "a few" fields.
6959 This is trivially true if there are zero or one fields. */
6960 if (!fieldlist
|| !DECL_CHAIN (fieldlist
))
6965 if (DECL_NAME (x
) == NULL_TREE
6966 && (TREE_CODE (TREE_TYPE (x
)) == RECORD_TYPE
6967 || TREE_CODE (TREE_TYPE (x
)) == UNION_TYPE
))
6970 } while (timeout
> 0 && x
);
6972 /* If there were "few" fields and no anonymous structures or unions,
6973 avoid the overhead of allocating a hash table. Instead just do
6974 the nested traversal thing. */
6977 for (x
= DECL_CHAIN (fieldlist
); x
; x
= DECL_CHAIN (x
))
6978 /* When using -fplan9-extensions, we can have duplicates
6979 between typedef names and fields. */
6981 || (flag_plan9_extensions
6982 && DECL_NAME (x
) == NULL_TREE
6983 && (TREE_CODE (TREE_TYPE (x
)) == RECORD_TYPE
6984 || TREE_CODE (TREE_TYPE (x
)) == UNION_TYPE
)
6985 && TYPE_NAME (TREE_TYPE (x
)) != NULL_TREE
6986 && TREE_CODE (TYPE_NAME (TREE_TYPE (x
))) == TYPE_DECL
))
6988 for (y
= fieldlist
; y
!= x
; y
= TREE_CHAIN (y
))
6989 if (is_duplicate_field (y
, x
))
6991 error ("duplicate member %q+D", x
);
6992 DECL_NAME (x
) = NULL_TREE
;
6998 htab_t htab
= htab_create (37, htab_hash_pointer
, htab_eq_pointer
, NULL
);
7000 detect_field_duplicates_hash (fieldlist
, htab
);
7005 /* Finish up struct info used by -Wc++-compat. */
7008 warn_cxx_compat_finish_struct (tree fieldlist
)
7012 struct c_binding
*b
;
7014 /* Set the C_TYPE_DEFINED_IN_STRUCT flag for each type defined in
7015 the current struct. We do this now at the end of the struct
7016 because the flag is used to issue visibility warnings, and we
7017 only want to issue those warnings if the type is referenced
7018 outside of the struct declaration. */
7019 FOR_EACH_VEC_ELT (tree
, struct_parse_info
->struct_types
, ix
, x
)
7020 C_TYPE_DEFINED_IN_STRUCT (x
) = 1;
7022 /* The TYPEDEFS_SEEN field of STRUCT_PARSE_INFO is a list of
7023 typedefs used when declaring fields in this struct. If the name
7024 of any of the fields is also a typedef name then the struct would
7025 not parse in C++, because the C++ lookup rules say that the
7026 typedef name would be looked up in the context of the struct, and
7027 would thus be the field rather than the typedef. */
7028 if (!VEC_empty (tree
, struct_parse_info
->typedefs_seen
)
7029 && fieldlist
!= NULL_TREE
)
7031 /* Use a pointer_set using the name of the typedef. We can use
7032 a pointer_set because identifiers are interned. */
7033 struct pointer_set_t
*tset
= pointer_set_create ();
7035 FOR_EACH_VEC_ELT (tree
, struct_parse_info
->typedefs_seen
, ix
, x
)
7036 pointer_set_insert (tset
, DECL_NAME (x
));
7038 for (x
= fieldlist
; x
!= NULL_TREE
; x
= DECL_CHAIN (x
))
7040 if (DECL_NAME (x
) != NULL_TREE
7041 && pointer_set_contains (tset
, DECL_NAME (x
)))
7043 warning_at (DECL_SOURCE_LOCATION (x
), OPT_Wc___compat
,
7044 ("using %qD as both field and typedef name is "
7047 /* FIXME: It would be nice to report the location where
7048 the typedef name is used. */
7052 pointer_set_destroy (tset
);
7055 /* For each field which has a binding and which was not defined in
7056 an enclosing struct, clear the in_struct field. */
7057 FOR_EACH_VEC_ELT (c_binding_ptr
, struct_parse_info
->fields
, ix
, b
)
7061 /* Fill in the fields of a RECORD_TYPE or UNION_TYPE node, T.
7062 LOC is the location of the RECORD_TYPE or UNION_TYPE's definition.
7063 FIELDLIST is a chain of FIELD_DECL nodes for the fields.
7064 ATTRIBUTES are attributes to be applied to the structure.
7066 ENCLOSING_STRUCT_PARSE_INFO is the value of STRUCT_PARSE_INFO when
7067 the struct was started. */
7070 finish_struct (location_t loc
, tree t
, tree fieldlist
, tree attributes
,
7071 struct c_struct_parse_info
*enclosing_struct_parse_info
)
7074 bool toplevel
= file_scope
== current_scope
;
7075 int saw_named_field
;
7077 /* If this type was previously laid out as a forward reference,
7078 make sure we lay it out again. */
7082 decl_attributes (&t
, attributes
, (int) ATTR_FLAG_TYPE_IN_PLACE
);
7086 for (x
= fieldlist
; x
; x
= DECL_CHAIN (x
))
7088 if (DECL_NAME (x
) != 0)
7091 && (TREE_CODE (TREE_TYPE (x
)) == RECORD_TYPE
7092 || TREE_CODE (TREE_TYPE (x
)) == UNION_TYPE
))
7098 if (TREE_CODE (t
) == UNION_TYPE
)
7101 pedwarn (loc
, OPT_Wpedantic
, "union has no named members");
7103 pedwarn (loc
, OPT_Wpedantic
, "union has no members");
7108 pedwarn (loc
, OPT_Wpedantic
, "struct has no named members");
7110 pedwarn (loc
, OPT_Wpedantic
, "struct has no members");
7115 /* Install struct as DECL_CONTEXT of each field decl.
7116 Also process specified field sizes, found in the DECL_INITIAL,
7117 storing 0 there after the type has been changed to precision equal
7118 to its width, rather than the precision of the specified standard
7119 type. (Correct layout requires the original type to have been preserved
7122 saw_named_field
= 0;
7123 for (x
= fieldlist
; x
; x
= DECL_CHAIN (x
))
7125 if (TREE_TYPE (x
) == error_mark_node
)
7128 DECL_CONTEXT (x
) = t
;
7130 /* If any field is const, the structure type is pseudo-const. */
7131 if (TREE_READONLY (x
))
7132 C_TYPE_FIELDS_READONLY (t
) = 1;
7135 /* A field that is pseudo-const makes the structure likewise. */
7136 tree t1
= strip_array_types (TREE_TYPE (x
));
7137 if ((TREE_CODE (t1
) == RECORD_TYPE
|| TREE_CODE (t1
) == UNION_TYPE
)
7138 && C_TYPE_FIELDS_READONLY (t1
))
7139 C_TYPE_FIELDS_READONLY (t
) = 1;
7142 /* Any field that is volatile means variables of this type must be
7143 treated in some ways as volatile. */
7144 if (TREE_THIS_VOLATILE (x
))
7145 C_TYPE_FIELDS_VOLATILE (t
) = 1;
7147 /* Any field of nominal variable size implies structure is too. */
7148 if (C_DECL_VARIABLE_SIZE (x
))
7149 C_TYPE_VARIABLE_SIZE (t
) = 1;
7151 if (DECL_INITIAL (x
))
7153 unsigned HOST_WIDE_INT width
= tree_low_cst (DECL_INITIAL (x
), 1);
7154 DECL_SIZE (x
) = bitsize_int (width
);
7155 DECL_BIT_FIELD (x
) = 1;
7156 SET_DECL_C_BIT_FIELD (x
);
7160 && (DECL_BIT_FIELD (x
)
7161 || TYPE_ALIGN (TREE_TYPE (x
)) > BITS_PER_UNIT
))
7162 DECL_PACKED (x
) = 1;
7164 /* Detect flexible array member in an invalid context. */
7165 if (TREE_CODE (TREE_TYPE (x
)) == ARRAY_TYPE
7166 && TYPE_SIZE (TREE_TYPE (x
)) == NULL_TREE
7167 && TYPE_DOMAIN (TREE_TYPE (x
)) != NULL_TREE
7168 && TYPE_MAX_VALUE (TYPE_DOMAIN (TREE_TYPE (x
))) == NULL_TREE
)
7170 if (TREE_CODE (t
) == UNION_TYPE
)
7172 error_at (DECL_SOURCE_LOCATION (x
),
7173 "flexible array member in union");
7174 TREE_TYPE (x
) = error_mark_node
;
7176 else if (DECL_CHAIN (x
) != NULL_TREE
)
7178 error_at (DECL_SOURCE_LOCATION (x
),
7179 "flexible array member not at end of struct");
7180 TREE_TYPE (x
) = error_mark_node
;
7182 else if (!saw_named_field
)
7184 error_at (DECL_SOURCE_LOCATION (x
),
7185 "flexible array member in otherwise empty struct");
7186 TREE_TYPE (x
) = error_mark_node
;
7190 if (pedantic
&& TREE_CODE (t
) == RECORD_TYPE
7191 && flexible_array_type_p (TREE_TYPE (x
)))
7192 pedwarn (DECL_SOURCE_LOCATION (x
), OPT_Wpedantic
,
7193 "invalid use of structure with flexible array member");
7196 || TREE_CODE (TREE_TYPE (x
)) == RECORD_TYPE
7197 || TREE_CODE (TREE_TYPE (x
)) == UNION_TYPE
)
7198 saw_named_field
= 1;
7201 detect_field_duplicates (fieldlist
);
7203 /* Now we have the nearly final fieldlist. Record it,
7204 then lay out the structure or union (including the fields). */
7206 TYPE_FIELDS (t
) = fieldlist
;
7210 /* Give bit-fields their proper types. */
7212 tree
*fieldlistp
= &fieldlist
;
7214 if (TREE_CODE (*fieldlistp
) == FIELD_DECL
&& DECL_INITIAL (*fieldlistp
)
7215 && TREE_TYPE (*fieldlistp
) != error_mark_node
)
7217 unsigned HOST_WIDE_INT width
7218 = tree_low_cst (DECL_INITIAL (*fieldlistp
), 1);
7219 tree type
= TREE_TYPE (*fieldlistp
);
7220 if (width
!= TYPE_PRECISION (type
))
7222 TREE_TYPE (*fieldlistp
)
7223 = c_build_bitfield_integer_type (width
, TYPE_UNSIGNED (type
));
7224 DECL_MODE (*fieldlistp
) = TYPE_MODE (TREE_TYPE (*fieldlistp
));
7226 DECL_INITIAL (*fieldlistp
) = 0;
7229 fieldlistp
= &DECL_CHAIN (*fieldlistp
);
7232 /* Now we have the truly final field list.
7233 Store it in this type and in the variants. */
7235 TYPE_FIELDS (t
) = fieldlist
;
7237 /* If there are lots of fields, sort so we can look through them fast.
7238 We arbitrarily consider 16 or more elts to be "a lot". */
7243 for (x
= fieldlist
; x
; x
= DECL_CHAIN (x
))
7245 if (len
> 15 || DECL_NAME (x
) == NULL
)
7253 struct lang_type
*space
;
7254 struct sorted_fields_type
*space2
;
7256 len
+= list_length (x
);
7258 /* Use the same allocation policy here that make_node uses, to
7259 ensure that this lives as long as the rest of the struct decl.
7260 All decls in an inline function need to be saved. */
7262 space
= ggc_alloc_cleared_lang_type (sizeof (struct lang_type
));
7263 space2
= ggc_alloc_sorted_fields_type
7264 (sizeof (struct sorted_fields_type
) + len
* sizeof (tree
));
7268 field_array
= &space2
->elts
[0];
7269 for (x
= fieldlist
; x
; x
= DECL_CHAIN (x
))
7271 field_array
[len
++] = x
;
7273 /* If there is anonymous struct or union, break out of the loop. */
7274 if (DECL_NAME (x
) == NULL
)
7277 /* Found no anonymous struct/union. Add the TYPE_LANG_SPECIFIC. */
7280 TYPE_LANG_SPECIFIC (t
) = space
;
7281 TYPE_LANG_SPECIFIC (t
)->s
->len
= len
;
7282 field_array
= TYPE_LANG_SPECIFIC (t
)->s
->elts
;
7283 qsort (field_array
, len
, sizeof (tree
), field_decl_cmp
);
7288 for (x
= TYPE_MAIN_VARIANT (t
); x
; x
= TYPE_NEXT_VARIANT (x
))
7290 TYPE_FIELDS (x
) = TYPE_FIELDS (t
);
7291 TYPE_LANG_SPECIFIC (x
) = TYPE_LANG_SPECIFIC (t
);
7292 C_TYPE_FIELDS_READONLY (x
) = C_TYPE_FIELDS_READONLY (t
);
7293 C_TYPE_FIELDS_VOLATILE (x
) = C_TYPE_FIELDS_VOLATILE (t
);
7294 C_TYPE_VARIABLE_SIZE (x
) = C_TYPE_VARIABLE_SIZE (t
);
7297 /* If this was supposed to be a transparent union, but we can't
7298 make it one, warn and turn off the flag. */
7299 if (TREE_CODE (t
) == UNION_TYPE
7300 && TYPE_TRANSPARENT_AGGR (t
)
7301 && (!TYPE_FIELDS (t
) || TYPE_MODE (t
) != DECL_MODE (TYPE_FIELDS (t
))))
7303 TYPE_TRANSPARENT_AGGR (t
) = 0;
7304 warning_at (loc
, 0, "union cannot be made transparent");
7307 /* If this structure or union completes the type of any previous
7308 variable declaration, lay it out and output its rtl. */
7309 for (x
= C_TYPE_INCOMPLETE_VARS (TYPE_MAIN_VARIANT (t
));
7313 tree decl
= TREE_VALUE (x
);
7314 if (TREE_CODE (TREE_TYPE (decl
)) == ARRAY_TYPE
)
7315 layout_array_type (TREE_TYPE (decl
));
7316 if (TREE_CODE (decl
) != TYPE_DECL
)
7318 layout_decl (decl
, 0);
7319 if (c_dialect_objc ())
7320 objc_check_decl (decl
);
7321 rest_of_decl_compilation (decl
, toplevel
, 0);
7324 C_TYPE_INCOMPLETE_VARS (TYPE_MAIN_VARIANT (t
)) = 0;
7326 /* Update type location to the one of the definition, instead of e.g.
7327 a forward declaration. */
7328 if (TYPE_STUB_DECL (t
))
7329 DECL_SOURCE_LOCATION (TYPE_STUB_DECL (t
)) = loc
;
7331 /* Finish debugging output for this type. */
7332 rest_of_type_compilation (t
, toplevel
);
7334 /* If we're inside a function proper, i.e. not file-scope and not still
7335 parsing parameters, then arrange for the size of a variable sized type
7337 if (building_stmt_list_p () && variably_modified_type_p (t
, NULL_TREE
))
7338 add_stmt (build_stmt (loc
,
7339 DECL_EXPR
, build_decl (loc
, TYPE_DECL
, NULL
, t
)));
7341 if (warn_cxx_compat
)
7342 warn_cxx_compat_finish_struct (fieldlist
);
7344 VEC_free (tree
, heap
, struct_parse_info
->struct_types
);
7345 VEC_free (c_binding_ptr
, heap
, struct_parse_info
->fields
);
7346 VEC_free (tree
, heap
, struct_parse_info
->typedefs_seen
);
7347 XDELETE (struct_parse_info
);
7349 struct_parse_info
= enclosing_struct_parse_info
;
7351 /* If this struct is defined inside a struct, add it to
7354 && struct_parse_info
!= NULL
7355 && !in_sizeof
&& !in_typeof
&& !in_alignof
)
7356 VEC_safe_push (tree
, heap
, struct_parse_info
->struct_types
, t
);
7361 /* Lay out the type T, and its element type, and so on. */
7364 layout_array_type (tree t
)
7366 if (TREE_CODE (TREE_TYPE (t
)) == ARRAY_TYPE
)
7367 layout_array_type (TREE_TYPE (t
));
7371 /* Begin compiling the definition of an enumeration type.
7372 NAME is its name (or null if anonymous).
7373 LOC is the enum's location.
7374 Returns the type object, as yet incomplete.
7375 Also records info about it so that build_enumerator
7376 may be used to declare the individual values as they are read. */
7379 start_enum (location_t loc
, struct c_enum_contents
*the_enum
, tree name
)
7381 tree enumtype
= NULL_TREE
;
7382 location_t enumloc
= UNKNOWN_LOCATION
;
7384 /* If this is the real definition for a previous forward reference,
7385 fill in the contents in the same object that used to be the
7386 forward reference. */
7388 if (name
!= NULL_TREE
)
7389 enumtype
= lookup_tag (ENUMERAL_TYPE
, name
, 1, &enumloc
);
7391 if (enumtype
== 0 || TREE_CODE (enumtype
) != ENUMERAL_TYPE
)
7393 enumtype
= make_node (ENUMERAL_TYPE
);
7394 pushtag (loc
, name
, enumtype
);
7397 if (C_TYPE_BEING_DEFINED (enumtype
))
7398 error_at (loc
, "nested redefinition of %<enum %E%>", name
);
7400 C_TYPE_BEING_DEFINED (enumtype
) = 1;
7402 if (TYPE_VALUES (enumtype
) != 0)
7404 /* This enum is a named one that has been declared already. */
7405 error_at (loc
, "redeclaration of %<enum %E%>", name
);
7406 if (enumloc
!= UNKNOWN_LOCATION
)
7407 inform (enumloc
, "originally defined here");
7409 /* Completely replace its old definition.
7410 The old enumerators remain defined, however. */
7411 TYPE_VALUES (enumtype
) = 0;
7414 the_enum
->enum_next_value
= integer_zero_node
;
7415 the_enum
->enum_overflow
= 0;
7417 if (flag_short_enums
)
7418 TYPE_PACKED (enumtype
) = 1;
7420 /* FIXME: This will issue a warning for a use of a type defined
7421 within sizeof in a statement expr. This is not terribly serious
7422 as C++ doesn't permit statement exprs within sizeof anyhow. */
7423 if (warn_cxx_compat
&& (in_sizeof
|| in_typeof
|| in_alignof
))
7424 warning_at (loc
, OPT_Wc___compat
,
7425 "defining type in %qs expression is invalid in C++",
7428 : (in_typeof
? "typeof" : "alignof")));
7433 /* After processing and defining all the values of an enumeration type,
7434 install their decls in the enumeration type and finish it off.
7435 ENUMTYPE is the type object, VALUES a list of decl-value pairs,
7436 and ATTRIBUTES are the specified attributes.
7437 Returns ENUMTYPE. */
7440 finish_enum (tree enumtype
, tree values
, tree attributes
)
7443 tree minnode
= 0, maxnode
= 0;
7444 int precision
, unsign
;
7445 bool toplevel
= (file_scope
== current_scope
);
7446 struct lang_type
*lt
;
7448 decl_attributes (&enumtype
, attributes
, (int) ATTR_FLAG_TYPE_IN_PLACE
);
7450 /* Calculate the maximum value of any enumerator in this type. */
7452 if (values
== error_mark_node
)
7453 minnode
= maxnode
= integer_zero_node
;
7456 minnode
= maxnode
= TREE_VALUE (values
);
7457 for (pair
= TREE_CHAIN (values
); pair
; pair
= TREE_CHAIN (pair
))
7459 tree value
= TREE_VALUE (pair
);
7460 if (tree_int_cst_lt (maxnode
, value
))
7462 if (tree_int_cst_lt (value
, minnode
))
7467 /* Construct the final type of this enumeration. It is the same
7468 as one of the integral types - the narrowest one that fits, except
7469 that normally we only go as narrow as int - and signed iff any of
7470 the values are negative. */
7471 unsign
= (tree_int_cst_sgn (minnode
) >= 0);
7472 precision
= MAX (tree_int_cst_min_precision (minnode
, unsign
),
7473 tree_int_cst_min_precision (maxnode
, unsign
));
7475 if (TYPE_PACKED (enumtype
) || precision
> TYPE_PRECISION (integer_type_node
))
7477 tem
= c_common_type_for_size (precision
, unsign
);
7480 warning (0, "enumeration values exceed range of largest integer");
7481 tem
= long_long_integer_type_node
;
7485 tem
= unsign
? unsigned_type_node
: integer_type_node
;
7487 TYPE_MIN_VALUE (enumtype
) = TYPE_MIN_VALUE (tem
);
7488 TYPE_MAX_VALUE (enumtype
) = TYPE_MAX_VALUE (tem
);
7489 TYPE_UNSIGNED (enumtype
) = TYPE_UNSIGNED (tem
);
7490 TYPE_SIZE (enumtype
) = 0;
7492 /* If the precision of the type was specific with an attribute and it
7493 was too small, give an error. Otherwise, use it. */
7494 if (TYPE_PRECISION (enumtype
))
7496 if (precision
> TYPE_PRECISION (enumtype
))
7497 error ("specified mode too small for enumeral values");
7500 TYPE_PRECISION (enumtype
) = TYPE_PRECISION (tem
);
7502 layout_type (enumtype
);
7504 if (values
!= error_mark_node
)
7506 /* Change the type of the enumerators to be the enum type. We
7507 need to do this irrespective of the size of the enum, for
7508 proper type checking. Replace the DECL_INITIALs of the
7509 enumerators, and the value slots of the list, with copies
7510 that have the enum type; they cannot be modified in place
7511 because they may be shared (e.g. integer_zero_node) Finally,
7512 change the purpose slots to point to the names of the decls. */
7513 for (pair
= values
; pair
; pair
= TREE_CHAIN (pair
))
7515 tree enu
= TREE_PURPOSE (pair
);
7516 tree ini
= DECL_INITIAL (enu
);
7518 TREE_TYPE (enu
) = enumtype
;
7520 /* The ISO C Standard mandates enumerators to have type int,
7521 even though the underlying type of an enum type is
7522 unspecified. However, GCC allows enumerators of any
7523 integer type as an extensions. build_enumerator()
7524 converts any enumerators that fit in an int to type int,
7525 to avoid promotions to unsigned types when comparing
7526 integers with enumerators that fit in the int range.
7527 When -pedantic is given, build_enumerator() would have
7528 already warned about those that don't fit. Here we
7529 convert the rest to the enumerator type. */
7530 if (TREE_TYPE (ini
) != integer_type_node
)
7531 ini
= convert (enumtype
, ini
);
7533 DECL_INITIAL (enu
) = ini
;
7534 TREE_PURPOSE (pair
) = DECL_NAME (enu
);
7535 TREE_VALUE (pair
) = ini
;
7538 TYPE_VALUES (enumtype
) = values
;
7541 /* Record the min/max values so that we can warn about bit-field
7542 enumerations that are too small for the values. */
7543 lt
= ggc_alloc_cleared_lang_type (sizeof (struct lang_type
));
7544 lt
->enum_min
= minnode
;
7545 lt
->enum_max
= maxnode
;
7546 TYPE_LANG_SPECIFIC (enumtype
) = lt
;
7548 /* Fix up all variant types of this enum type. */
7549 for (tem
= TYPE_MAIN_VARIANT (enumtype
); tem
; tem
= TYPE_NEXT_VARIANT (tem
))
7551 if (tem
== enumtype
)
7553 TYPE_VALUES (tem
) = TYPE_VALUES (enumtype
);
7554 TYPE_MIN_VALUE (tem
) = TYPE_MIN_VALUE (enumtype
);
7555 TYPE_MAX_VALUE (tem
) = TYPE_MAX_VALUE (enumtype
);
7556 TYPE_SIZE (tem
) = TYPE_SIZE (enumtype
);
7557 TYPE_SIZE_UNIT (tem
) = TYPE_SIZE_UNIT (enumtype
);
7558 SET_TYPE_MODE (tem
, TYPE_MODE (enumtype
));
7559 TYPE_PRECISION (tem
) = TYPE_PRECISION (enumtype
);
7560 TYPE_ALIGN (tem
) = TYPE_ALIGN (enumtype
);
7561 TYPE_USER_ALIGN (tem
) = TYPE_USER_ALIGN (enumtype
);
7562 TYPE_UNSIGNED (tem
) = TYPE_UNSIGNED (enumtype
);
7563 TYPE_LANG_SPECIFIC (tem
) = TYPE_LANG_SPECIFIC (enumtype
);
7566 /* Finish debugging output for this type. */
7567 rest_of_type_compilation (enumtype
, toplevel
);
7569 /* If this enum is defined inside a struct, add it to
7572 && struct_parse_info
!= NULL
7573 && !in_sizeof
&& !in_typeof
&& !in_alignof
)
7574 VEC_safe_push (tree
, heap
, struct_parse_info
->struct_types
, enumtype
);
7579 /* Build and install a CONST_DECL for one value of the
7580 current enumeration type (one that was begun with start_enum).
7581 DECL_LOC is the location of the enumerator.
7582 LOC is the location of the '=' operator if any, DECL_LOC otherwise.
7583 Return a tree-list containing the CONST_DECL and its value.
7584 Assignment of sequential values by default is handled here. */
7587 build_enumerator (location_t decl_loc
, location_t loc
,
7588 struct c_enum_contents
*the_enum
, tree name
, tree value
)
7592 /* Validate and default VALUE. */
7596 /* Don't issue more errors for error_mark_node (i.e. an
7597 undeclared identifier) - just ignore the value expression. */
7598 if (value
== error_mark_node
)
7600 else if (!INTEGRAL_TYPE_P (TREE_TYPE (value
)))
7602 error_at (loc
, "enumerator value for %qE is not an integer constant",
7608 if (TREE_CODE (value
) != INTEGER_CST
)
7610 value
= c_fully_fold (value
, false, NULL
);
7611 if (TREE_CODE (value
) == INTEGER_CST
)
7612 pedwarn (loc
, OPT_Wpedantic
,
7613 "enumerator value for %qE is not an integer "
7614 "constant expression", name
);
7616 if (TREE_CODE (value
) != INTEGER_CST
)
7618 error ("enumerator value for %qE is not an integer constant",
7624 value
= default_conversion (value
);
7625 constant_expression_warning (value
);
7630 /* Default based on previous value. */
7631 /* It should no longer be possible to have NON_LVALUE_EXPR
7635 value
= the_enum
->enum_next_value
;
7636 if (the_enum
->enum_overflow
)
7637 error_at (loc
, "overflow in enumeration values");
7639 /* Even though the underlying type of an enum is unspecified, the
7640 type of enumeration constants is explicitly defined as int
7641 (6.4.4.3/2 in the C99 Standard). GCC allows any integer type as
7643 else if (!int_fits_type_p (value
, integer_type_node
))
7644 pedwarn (loc
, OPT_Wpedantic
,
7645 "ISO C restricts enumerator values to range of %<int%>");
7647 /* The ISO C Standard mandates enumerators to have type int, even
7648 though the underlying type of an enum type is unspecified.
7649 However, GCC allows enumerators of any integer type as an
7650 extensions. Here we convert any enumerators that fit in an int
7651 to type int, to avoid promotions to unsigned types when comparing
7652 integers with enumerators that fit in the int range. When
7653 -pedantic is given, we would have already warned about those that
7654 don't fit. We have to do this here rather than in finish_enum
7655 because this value may be used to define more enumerators. */
7656 if (int_fits_type_p (value
, integer_type_node
))
7657 value
= convert (integer_type_node
, value
);
7659 /* Set basis for default for next value. */
7660 the_enum
->enum_next_value
7661 = build_binary_op (EXPR_LOC_OR_HERE (value
),
7662 PLUS_EXPR
, value
, integer_one_node
, 0);
7663 the_enum
->enum_overflow
= tree_int_cst_lt (the_enum
->enum_next_value
, value
);
7665 /* Now create a declaration for the enum value name. */
7667 type
= TREE_TYPE (value
);
7668 type
= c_common_type_for_size (MAX (TYPE_PRECISION (type
),
7669 TYPE_PRECISION (integer_type_node
)),
7670 (TYPE_PRECISION (type
)
7671 >= TYPE_PRECISION (integer_type_node
)
7672 && TYPE_UNSIGNED (type
)));
7674 decl
= build_decl (decl_loc
, CONST_DECL
, name
, type
);
7675 DECL_INITIAL (decl
) = convert (type
, value
);
7678 return tree_cons (decl
, value
, NULL_TREE
);
7682 /* Create the FUNCTION_DECL for a function definition.
7683 DECLSPECS, DECLARATOR and ATTRIBUTES are the parts of
7684 the declaration; they describe the function's name and the type it returns,
7685 but twisted together in a fashion that parallels the syntax of C.
7687 This function creates a binding context for the function body
7688 as well as setting up the FUNCTION_DECL in current_function_decl.
7690 Returns 1 on success. If the DECLARATOR is not suitable for a function
7691 (it defines a datum instead), we return 0, which tells
7692 yyparse to report a parse error. */
7695 start_function (struct c_declspecs
*declspecs
, struct c_declarator
*declarator
,
7698 tree decl1
, old_decl
;
7699 tree restype
, resdecl
;
7702 current_function_returns_value
= 0; /* Assume, until we see it does. */
7703 current_function_returns_null
= 0;
7704 current_function_returns_abnormally
= 0;
7705 warn_about_return_type
= 0;
7706 c_switch_stack
= NULL
;
7708 /* Indicate no valid break/continue context by setting these variables
7709 to some non-null, non-label value. We'll notice and emit the proper
7710 error message in c_finish_bc_stmt. */
7711 c_break_label
= c_cont_label
= size_zero_node
;
7713 decl1
= grokdeclarator (declarator
, declspecs
, FUNCDEF
, true, NULL
,
7714 &attributes
, NULL
, NULL
, DEPRECATED_NORMAL
);
7716 /* If the declarator is not suitable for a function definition,
7717 cause a syntax error. */
7719 || TREE_CODE (decl1
) != FUNCTION_DECL
)
7722 loc
= DECL_SOURCE_LOCATION (decl1
);
7724 decl_attributes (&decl1
, attributes
, 0);
7726 if (DECL_DECLARED_INLINE_P (decl1
)
7727 && DECL_UNINLINABLE (decl1
)
7728 && lookup_attribute ("noinline", DECL_ATTRIBUTES (decl1
)))
7729 warning_at (loc
, OPT_Wattributes
,
7730 "inline function %qD given attribute noinline",
7733 /* Handle gnu_inline attribute. */
7734 if (declspecs
->inline_p
7735 && !flag_gnu89_inline
7736 && TREE_CODE (decl1
) == FUNCTION_DECL
7737 && (lookup_attribute ("gnu_inline", DECL_ATTRIBUTES (decl1
))
7738 || current_function_decl
))
7740 if (declspecs
->storage_class
!= csc_static
)
7741 DECL_EXTERNAL (decl1
) = !DECL_EXTERNAL (decl1
);
7744 announce_function (decl1
);
7746 if (!COMPLETE_OR_VOID_TYPE_P (TREE_TYPE (TREE_TYPE (decl1
))))
7748 error_at (loc
, "return type is an incomplete type");
7749 /* Make it return void instead. */
7751 = build_function_type (void_type_node
,
7752 TYPE_ARG_TYPES (TREE_TYPE (decl1
)));
7755 if (warn_about_return_type
)
7756 pedwarn_c99 (loc
, flag_isoc99
? 0
7757 : (warn_return_type
? OPT_Wreturn_type
: OPT_Wimplicit_int
),
7758 "return type defaults to %<int%>");
7760 /* Make the init_value nonzero so pushdecl knows this is not tentative.
7761 error_mark_node is replaced below (in pop_scope) with the BLOCK. */
7762 DECL_INITIAL (decl1
) = error_mark_node
;
7764 /* A nested function is not global. */
7765 if (current_function_decl
!= 0)
7766 TREE_PUBLIC (decl1
) = 0;
7768 /* If this definition isn't a prototype and we had a prototype declaration
7769 before, copy the arg type info from that prototype. */
7770 old_decl
= lookup_name_in_scope (DECL_NAME (decl1
), current_scope
);
7771 if (old_decl
&& TREE_CODE (old_decl
) != FUNCTION_DECL
)
7773 current_function_prototype_locus
= UNKNOWN_LOCATION
;
7774 current_function_prototype_built_in
= false;
7775 current_function_prototype_arg_types
= NULL_TREE
;
7776 if (!prototype_p (TREE_TYPE (decl1
)))
7778 if (old_decl
!= 0 && TREE_CODE (TREE_TYPE (old_decl
)) == FUNCTION_TYPE
7779 && comptypes (TREE_TYPE (TREE_TYPE (decl1
)),
7780 TREE_TYPE (TREE_TYPE (old_decl
))))
7782 TREE_TYPE (decl1
) = composite_type (TREE_TYPE (old_decl
),
7784 current_function_prototype_locus
= DECL_SOURCE_LOCATION (old_decl
);
7785 current_function_prototype_built_in
7786 = C_DECL_BUILTIN_PROTOTYPE (old_decl
);
7787 current_function_prototype_arg_types
7788 = TYPE_ARG_TYPES (TREE_TYPE (decl1
));
7790 if (TREE_PUBLIC (decl1
))
7792 /* If there is an external prototype declaration of this
7793 function, record its location but do not copy information
7794 to this decl. This may be an invisible declaration
7795 (built-in or in a scope which has finished) or simply
7796 have more refined argument types than any declaration
7798 struct c_binding
*b
;
7799 for (b
= I_SYMBOL_BINDING (DECL_NAME (decl1
)); b
; b
= b
->shadowed
)
7800 if (B_IN_SCOPE (b
, external_scope
))
7804 tree ext_decl
, ext_type
;
7806 ext_type
= b
->u
.type
? b
->u
.type
: TREE_TYPE (ext_decl
);
7807 if (TREE_CODE (ext_type
) == FUNCTION_TYPE
7808 && comptypes (TREE_TYPE (TREE_TYPE (decl1
)),
7809 TREE_TYPE (ext_type
)))
7811 current_function_prototype_locus
7812 = DECL_SOURCE_LOCATION (ext_decl
);
7813 current_function_prototype_built_in
7814 = C_DECL_BUILTIN_PROTOTYPE (ext_decl
);
7815 current_function_prototype_arg_types
7816 = TYPE_ARG_TYPES (ext_type
);
7822 /* Optionally warn of old-fashioned def with no previous prototype. */
7823 if (warn_strict_prototypes
7824 && old_decl
!= error_mark_node
7825 && !prototype_p (TREE_TYPE (decl1
))
7826 && C_DECL_ISNT_PROTOTYPE (old_decl
))
7827 warning_at (loc
, OPT_Wstrict_prototypes
,
7828 "function declaration isn%'t a prototype");
7829 /* Optionally warn of any global def with no previous prototype. */
7830 else if (warn_missing_prototypes
7831 && old_decl
!= error_mark_node
7832 && TREE_PUBLIC (decl1
)
7833 && !MAIN_NAME_P (DECL_NAME (decl1
))
7834 && C_DECL_ISNT_PROTOTYPE (old_decl
))
7835 warning_at (loc
, OPT_Wmissing_prototypes
,
7836 "no previous prototype for %qD", decl1
);
7837 /* Optionally warn of any def with no previous prototype
7838 if the function has already been used. */
7839 else if (warn_missing_prototypes
7841 && old_decl
!= error_mark_node
7842 && TREE_USED (old_decl
)
7843 && !prototype_p (TREE_TYPE (old_decl
)))
7844 warning_at (loc
, OPT_Wmissing_prototypes
,
7845 "%qD was used with no prototype before its definition", decl1
);
7846 /* Optionally warn of any global def with no previous declaration. */
7847 else if (warn_missing_declarations
7848 && TREE_PUBLIC (decl1
)
7850 && !MAIN_NAME_P (DECL_NAME (decl1
)))
7851 warning_at (loc
, OPT_Wmissing_declarations
,
7852 "no previous declaration for %qD",
7854 /* Optionally warn of any def with no previous declaration
7855 if the function has already been used. */
7856 else if (warn_missing_declarations
7858 && old_decl
!= error_mark_node
7859 && TREE_USED (old_decl
)
7860 && C_DECL_IMPLICIT (old_decl
))
7861 warning_at (loc
, OPT_Wmissing_declarations
,
7862 "%qD was used with no declaration before its definition", decl1
);
7864 /* This function exists in static storage.
7865 (This does not mean `static' in the C sense!) */
7866 TREE_STATIC (decl1
) = 1;
7868 /* This is the earliest point at which we might know the assembler
7869 name of the function. Thus, if it's set before this, die horribly. */
7870 gcc_assert (!DECL_ASSEMBLER_NAME_SET_P (decl1
));
7872 /* If #pragma weak was used, mark the decl weak now. */
7873 if (current_scope
== file_scope
)
7874 maybe_apply_pragma_weak (decl1
);
7876 /* Warn for unlikely, improbable, or stupid declarations of `main'. */
7877 if (warn_main
&& MAIN_NAME_P (DECL_NAME (decl1
)))
7879 if (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (decl1
)))
7880 != integer_type_node
)
7881 pedwarn (loc
, OPT_Wmain
, "return type of %qD is not %<int%>", decl1
);
7883 check_main_parameter_types (decl1
);
7885 if (!TREE_PUBLIC (decl1
))
7886 pedwarn (loc
, OPT_Wmain
,
7887 "%qD is normally a non-static function", decl1
);
7890 /* Record the decl so that the function name is defined.
7891 If we already have a decl for this name, and it is a FUNCTION_DECL,
7892 use the old decl. */
7894 current_function_decl
= pushdecl (decl1
);
7897 declare_parm_level ();
7899 restype
= TREE_TYPE (TREE_TYPE (current_function_decl
));
7900 resdecl
= build_decl (loc
, RESULT_DECL
, NULL_TREE
, restype
);
7901 DECL_ARTIFICIAL (resdecl
) = 1;
7902 DECL_IGNORED_P (resdecl
) = 1;
7903 DECL_RESULT (current_function_decl
) = resdecl
;
7905 start_fname_decls ();
7910 /* Subroutine of store_parm_decls which handles new-style function
7911 definitions (prototype format). The parms already have decls, so we
7912 need only record them as in effect and complain if any redundant
7913 old-style parm decls were written. */
7915 store_parm_decls_newstyle (tree fndecl
, const struct c_arg_info
*arg_info
)
7921 if (current_scope
->bindings
)
7923 error_at (DECL_SOURCE_LOCATION (fndecl
),
7924 "old-style parameter declarations in prototyped "
7925 "function definition");
7927 /* Get rid of the old-style declarations. */
7931 /* Don't issue this warning for nested functions, and don't issue this
7932 warning if we got here because ARG_INFO_TYPES was error_mark_node
7933 (this happens when a function definition has just an ellipsis in
7934 its parameter list). */
7935 else if (!in_system_header
&& !current_function_scope
7936 && arg_info
->types
!= error_mark_node
)
7937 warning_at (DECL_SOURCE_LOCATION (fndecl
), OPT_Wtraditional
,
7938 "traditional C rejects ISO C style function definitions");
7940 /* Now make all the parameter declarations visible in the function body.
7941 We can bypass most of the grunt work of pushdecl. */
7942 for (decl
= arg_info
->parms
; decl
; decl
= DECL_CHAIN (decl
))
7944 DECL_CONTEXT (decl
) = current_function_decl
;
7945 if (DECL_NAME (decl
))
7947 bind (DECL_NAME (decl
), decl
, current_scope
,
7948 /*invisible=*/false, /*nested=*/false,
7950 if (!TREE_USED (decl
))
7951 warn_if_shadowing (decl
);
7954 error_at (DECL_SOURCE_LOCATION (decl
), "parameter name omitted");
7957 /* Record the parameter list in the function declaration. */
7958 DECL_ARGUMENTS (fndecl
) = arg_info
->parms
;
7960 /* Now make all the ancillary declarations visible, likewise. */
7961 for (decl
= arg_info
->others
; decl
; decl
= DECL_CHAIN (decl
))
7963 DECL_CONTEXT (decl
) = current_function_decl
;
7964 if (DECL_NAME (decl
))
7965 bind (DECL_NAME (decl
), decl
, current_scope
,
7966 /*invisible=*/false,
7967 /*nested=*/(TREE_CODE (decl
) == FUNCTION_DECL
),
7971 /* And all the tag declarations. */
7972 FOR_EACH_VEC_ELT_REVERSE (c_arg_tag
, arg_info
->tags
, ix
, tag
)
7974 bind (tag
->id
, tag
->type
, current_scope
,
7975 /*invisible=*/false, /*nested=*/false, UNKNOWN_LOCATION
);
7978 /* Subroutine of store_parm_decls which handles old-style function
7979 definitions (separate parameter list and declarations). */
7982 store_parm_decls_oldstyle (tree fndecl
, const struct c_arg_info
*arg_info
)
7984 struct c_binding
*b
;
7985 tree parm
, decl
, last
;
7986 tree parmids
= arg_info
->parms
;
7987 struct pointer_set_t
*seen_args
= pointer_set_create ();
7989 if (!in_system_header
)
7990 warning_at (DECL_SOURCE_LOCATION (fndecl
),
7991 OPT_Wold_style_definition
, "old-style function definition");
7993 /* Match each formal parameter name with its declaration. Save each
7994 decl in the appropriate TREE_PURPOSE slot of the parmids chain. */
7995 for (parm
= parmids
; parm
; parm
= TREE_CHAIN (parm
))
7997 if (TREE_VALUE (parm
) == 0)
7999 error_at (DECL_SOURCE_LOCATION (fndecl
),
8000 "parameter name missing from parameter list");
8001 TREE_PURPOSE (parm
) = 0;
8005 b
= I_SYMBOL_BINDING (TREE_VALUE (parm
));
8006 if (b
&& B_IN_CURRENT_SCOPE (b
))
8009 /* Skip erroneous parameters. */
8010 if (decl
== error_mark_node
)
8012 /* If we got something other than a PARM_DECL it is an error. */
8013 if (TREE_CODE (decl
) != PARM_DECL
)
8014 error_at (DECL_SOURCE_LOCATION (decl
),
8015 "%qD declared as a non-parameter", decl
);
8016 /* If the declaration is already marked, we have a duplicate
8017 name. Complain and ignore the duplicate. */
8018 else if (pointer_set_contains (seen_args
, decl
))
8020 error_at (DECL_SOURCE_LOCATION (decl
),
8021 "multiple parameters named %qD", decl
);
8022 TREE_PURPOSE (parm
) = 0;
8025 /* If the declaration says "void", complain and turn it into
8027 else if (VOID_TYPE_P (TREE_TYPE (decl
)))
8029 error_at (DECL_SOURCE_LOCATION (decl
),
8030 "parameter %qD declared with void type", decl
);
8031 TREE_TYPE (decl
) = integer_type_node
;
8032 DECL_ARG_TYPE (decl
) = integer_type_node
;
8033 layout_decl (decl
, 0);
8035 warn_if_shadowing (decl
);
8037 /* If no declaration found, default to int. */
8040 /* FIXME diagnostics: This should be the location of the argument,
8041 not the FNDECL. E.g., for an old-style declaration
8043 int f10(v) { blah; }
8045 We should use the location of the V, not the F10.
8046 Unfortunately, the V is an IDENTIFIER_NODE which has no
8047 location. In the future we need locations for c_arg_info
8050 See gcc.dg/Wshadow-3.c for an example of this problem. */
8051 decl
= build_decl (DECL_SOURCE_LOCATION (fndecl
),
8052 PARM_DECL
, TREE_VALUE (parm
), integer_type_node
);
8053 DECL_ARG_TYPE (decl
) = TREE_TYPE (decl
);
8055 warn_if_shadowing (decl
);
8058 pedwarn (DECL_SOURCE_LOCATION (decl
),
8059 0, "type of %qD defaults to %<int%>", decl
);
8061 warning_at (DECL_SOURCE_LOCATION (decl
),
8062 OPT_Wmissing_parameter_type
,
8063 "type of %qD defaults to %<int%>", decl
);
8066 TREE_PURPOSE (parm
) = decl
;
8067 pointer_set_insert (seen_args
, decl
);
8070 /* Now examine the parms chain for incomplete declarations
8071 and declarations with no corresponding names. */
8073 for (b
= current_scope
->bindings
; b
; b
= b
->prev
)
8076 if (TREE_CODE (parm
) != PARM_DECL
)
8079 if (TREE_TYPE (parm
) != error_mark_node
8080 && !COMPLETE_TYPE_P (TREE_TYPE (parm
)))
8082 error_at (DECL_SOURCE_LOCATION (parm
),
8083 "parameter %qD has incomplete type", parm
);
8084 TREE_TYPE (parm
) = error_mark_node
;
8087 if (!pointer_set_contains (seen_args
, parm
))
8089 error_at (DECL_SOURCE_LOCATION (parm
),
8090 "declaration for parameter %qD but no such parameter",
8093 /* Pretend the parameter was not missing.
8094 This gets us to a standard state and minimizes
8095 further error messages. */
8096 parmids
= chainon (parmids
, tree_cons (parm
, 0, 0));
8100 /* Chain the declarations together in the order of the list of
8101 names. Store that chain in the function decl, replacing the
8102 list of names. Update the current scope to match. */
8103 DECL_ARGUMENTS (fndecl
) = 0;
8105 for (parm
= parmids
; parm
; parm
= TREE_CHAIN (parm
))
8106 if (TREE_PURPOSE (parm
))
8108 if (parm
&& TREE_PURPOSE (parm
))
8110 last
= TREE_PURPOSE (parm
);
8111 DECL_ARGUMENTS (fndecl
) = last
;
8113 for (parm
= TREE_CHAIN (parm
); parm
; parm
= TREE_CHAIN (parm
))
8114 if (TREE_PURPOSE (parm
))
8116 DECL_CHAIN (last
) = TREE_PURPOSE (parm
);
8117 last
= TREE_PURPOSE (parm
);
8119 DECL_CHAIN (last
) = 0;
8122 pointer_set_destroy (seen_args
);
8124 /* If there was a previous prototype,
8125 set the DECL_ARG_TYPE of each argument according to
8126 the type previously specified, and report any mismatches. */
8128 if (current_function_prototype_arg_types
)
8131 for (parm
= DECL_ARGUMENTS (fndecl
),
8132 type
= current_function_prototype_arg_types
;
8133 parm
|| (type
&& TREE_VALUE (type
) != error_mark_node
8134 && (TYPE_MAIN_VARIANT (TREE_VALUE (type
)) != void_type_node
));
8135 parm
= DECL_CHAIN (parm
), type
= TREE_CHAIN (type
))
8137 if (parm
== 0 || type
== 0
8138 || TYPE_MAIN_VARIANT (TREE_VALUE (type
)) == void_type_node
)
8140 if (current_function_prototype_built_in
)
8141 warning_at (DECL_SOURCE_LOCATION (fndecl
),
8142 0, "number of arguments doesn%'t match "
8143 "built-in prototype");
8146 /* FIXME diagnostics: This should be the location of
8147 FNDECL, but there is bug when a prototype is
8148 declared inside function context, but defined
8149 outside of it (e.g., gcc.dg/pr15698-2.c). In
8150 which case FNDECL gets the location of the
8151 prototype, not the definition. */
8152 error_at (input_location
,
8153 "number of arguments doesn%'t match prototype");
8155 error_at (current_function_prototype_locus
,
8156 "prototype declaration");
8160 /* Type for passing arg must be consistent with that
8161 declared for the arg. ISO C says we take the unqualified
8162 type for parameters declared with qualified type. */
8163 if (TREE_TYPE (parm
) != error_mark_node
8164 && TREE_TYPE (type
) != error_mark_node
8165 && !comptypes (TYPE_MAIN_VARIANT (DECL_ARG_TYPE (parm
)),
8166 TYPE_MAIN_VARIANT (TREE_VALUE (type
))))
8168 if (TYPE_MAIN_VARIANT (TREE_TYPE (parm
))
8169 == TYPE_MAIN_VARIANT (TREE_VALUE (type
)))
8171 /* Adjust argument to match prototype. E.g. a previous
8172 `int foo(float);' prototype causes
8173 `int foo(x) float x; {...}' to be treated like
8174 `int foo(float x) {...}'. This is particularly
8175 useful for argument types like uid_t. */
8176 DECL_ARG_TYPE (parm
) = TREE_TYPE (parm
);
8178 if (targetm
.calls
.promote_prototypes (TREE_TYPE (current_function_decl
))
8179 && INTEGRAL_TYPE_P (TREE_TYPE (parm
))
8180 && TYPE_PRECISION (TREE_TYPE (parm
))
8181 < TYPE_PRECISION (integer_type_node
))
8182 DECL_ARG_TYPE (parm
) = integer_type_node
;
8184 /* ??? Is it possible to get here with a
8185 built-in prototype or will it always have
8186 been diagnosed as conflicting with an
8187 old-style definition and discarded? */
8188 if (current_function_prototype_built_in
)
8189 warning_at (DECL_SOURCE_LOCATION (parm
),
8190 OPT_Wpedantic
, "promoted argument %qD "
8191 "doesn%'t match built-in prototype", parm
);
8194 pedwarn (DECL_SOURCE_LOCATION (parm
),
8195 OPT_Wpedantic
, "promoted argument %qD "
8196 "doesn%'t match prototype", parm
);
8197 pedwarn (current_function_prototype_locus
, OPT_Wpedantic
,
8198 "prototype declaration");
8203 if (current_function_prototype_built_in
)
8204 warning_at (DECL_SOURCE_LOCATION (parm
),
8205 0, "argument %qD doesn%'t match "
8206 "built-in prototype", parm
);
8209 error_at (DECL_SOURCE_LOCATION (parm
),
8210 "argument %qD doesn%'t match prototype", parm
);
8211 error_at (current_function_prototype_locus
,
8212 "prototype declaration");
8217 TYPE_ACTUAL_ARG_TYPES (TREE_TYPE (fndecl
)) = 0;
8220 /* Otherwise, create a prototype that would match. */
8224 tree actual
= 0, last
= 0, type
;
8226 for (parm
= DECL_ARGUMENTS (fndecl
); parm
; parm
= DECL_CHAIN (parm
))
8228 type
= tree_cons (NULL_TREE
, DECL_ARG_TYPE (parm
), NULL_TREE
);
8230 TREE_CHAIN (last
) = type
;
8235 type
= tree_cons (NULL_TREE
, void_type_node
, NULL_TREE
);
8237 TREE_CHAIN (last
) = type
;
8241 /* We are going to assign a new value for the TYPE_ACTUAL_ARG_TYPES
8242 of the type of this function, but we need to avoid having this
8243 affect the types of other similarly-typed functions, so we must
8244 first force the generation of an identical (but separate) type
8245 node for the relevant function type. The new node we create
8246 will be a variant of the main variant of the original function
8249 TREE_TYPE (fndecl
) = build_variant_type_copy (TREE_TYPE (fndecl
));
8251 TYPE_ACTUAL_ARG_TYPES (TREE_TYPE (fndecl
)) = actual
;
8255 /* Store parameter declarations passed in ARG_INFO into the current
8256 function declaration. */
8259 store_parm_decls_from (struct c_arg_info
*arg_info
)
8261 current_function_arg_info
= arg_info
;
8262 store_parm_decls ();
8265 /* Store the parameter declarations into the current function declaration.
8266 This is called after parsing the parameter declarations, before
8267 digesting the body of the function.
8269 For an old-style definition, construct a prototype out of the old-style
8270 parameter declarations and inject it into the function's type. */
8273 store_parm_decls (void)
8275 tree fndecl
= current_function_decl
;
8278 /* The argument information block for FNDECL. */
8279 struct c_arg_info
*arg_info
= current_function_arg_info
;
8280 current_function_arg_info
= 0;
8282 /* True if this definition is written with a prototype. Note:
8283 despite C99 6.7.5.3p14, we can *not* treat an empty argument
8284 list in a function definition as equivalent to (void) -- an
8285 empty argument list specifies the function has no parameters,
8286 but only (void) sets up a prototype for future calls. */
8287 proto
= arg_info
->types
!= 0;
8290 store_parm_decls_newstyle (fndecl
, arg_info
);
8292 store_parm_decls_oldstyle (fndecl
, arg_info
);
8294 /* The next call to push_scope will be a function body. */
8296 next_is_function_body
= true;
8298 /* Write a record describing this function definition to the prototypes
8299 file (if requested). */
8301 gen_aux_info_record (fndecl
, 1, 0, proto
);
8303 /* Initialize the RTL code for the function. */
8304 allocate_struct_function (fndecl
, false);
8306 if (warn_unused_local_typedefs
)
8307 cfun
->language
= ggc_alloc_cleared_language_function ();
8309 /* Begin the statement tree for this function. */
8310 DECL_SAVED_TREE (fndecl
) = push_stmt_list ();
8312 /* ??? Insert the contents of the pending sizes list into the function
8313 to be evaluated. The only reason left to have this is
8314 void foo(int n, int array[n++])
8315 because we throw away the array type in favor of a pointer type, and
8316 thus won't naturally see the SAVE_EXPR containing the increment. All
8317 other pending sizes would be handled by gimplify_parameters. */
8318 if (arg_info
->pending_sizes
)
8319 add_stmt (arg_info
->pending_sizes
);
8323 /* Finish up a function declaration and compile that function
8324 all the way to assembler language output. Then free the storage
8325 for the function definition.
8327 This is called after parsing the body of the function definition. */
8330 finish_function (void)
8332 tree fndecl
= current_function_decl
;
8334 if (c_dialect_objc ())
8335 objc_finish_function ();
8337 if (TREE_CODE (fndecl
) == FUNCTION_DECL
8338 && targetm
.calls
.promote_prototypes (TREE_TYPE (fndecl
)))
8340 tree args
= DECL_ARGUMENTS (fndecl
);
8341 for (; args
; args
= DECL_CHAIN (args
))
8343 tree type
= TREE_TYPE (args
);
8344 if (INTEGRAL_TYPE_P (type
)
8345 && TYPE_PRECISION (type
) < TYPE_PRECISION (integer_type_node
))
8346 DECL_ARG_TYPE (args
) = integer_type_node
;
8350 if (DECL_INITIAL (fndecl
) && DECL_INITIAL (fndecl
) != error_mark_node
)
8351 BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl
)) = fndecl
;
8353 /* Must mark the RESULT_DECL as being in this function. */
8355 if (DECL_RESULT (fndecl
) && DECL_RESULT (fndecl
) != error_mark_node
)
8356 DECL_CONTEXT (DECL_RESULT (fndecl
)) = fndecl
;
8358 if (MAIN_NAME_P (DECL_NAME (fndecl
)) && flag_hosted
8359 && TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (fndecl
)))
8360 == integer_type_node
&& flag_isoc99
)
8362 /* Hack. We don't want the middle-end to warn that this return
8363 is unreachable, so we mark its location as special. Using
8364 UNKNOWN_LOCATION has the problem that it gets clobbered in
8365 annotate_one_with_locus. A cleaner solution might be to
8366 ensure ! should_carry_locus_p (stmt), but that needs a flag.
8368 c_finish_return (BUILTINS_LOCATION
, integer_zero_node
, NULL_TREE
);
8371 /* Tie off the statement tree for this function. */
8372 DECL_SAVED_TREE (fndecl
) = pop_stmt_list (DECL_SAVED_TREE (fndecl
));
8374 finish_fname_decls ();
8376 /* Complain if there's just no return statement. */
8377 if (warn_return_type
8378 && TREE_CODE (TREE_TYPE (TREE_TYPE (fndecl
))) != VOID_TYPE
8379 && !current_function_returns_value
&& !current_function_returns_null
8380 /* Don't complain if we are no-return. */
8381 && !current_function_returns_abnormally
8382 /* Don't complain if we are declared noreturn. */
8383 && !TREE_THIS_VOLATILE (fndecl
)
8384 /* Don't warn for main(). */
8385 && !MAIN_NAME_P (DECL_NAME (fndecl
))
8386 /* Or if they didn't actually specify a return type. */
8387 && !C_FUNCTION_IMPLICIT_INT (fndecl
)
8388 /* Normally, with -Wreturn-type, flow will complain, but we might
8389 optimize out static functions. */
8390 && !TREE_PUBLIC (fndecl
))
8392 warning (OPT_Wreturn_type
,
8393 "no return statement in function returning non-void");
8394 TREE_NO_WARNING (fndecl
) = 1;
8397 /* Complain about parameters that are only set, but never otherwise used. */
8398 if (warn_unused_but_set_parameter
)
8402 for (decl
= DECL_ARGUMENTS (fndecl
);
8404 decl
= DECL_CHAIN (decl
))
8405 if (TREE_USED (decl
)
8406 && TREE_CODE (decl
) == PARM_DECL
8407 && !DECL_READ_P (decl
)
8409 && !DECL_ARTIFICIAL (decl
)
8410 && !TREE_NO_WARNING (decl
))
8411 warning_at (DECL_SOURCE_LOCATION (decl
),
8412 OPT_Wunused_but_set_parameter
,
8413 "parameter %qD set but not used", decl
);
8416 /* Complain about locally defined typedefs that are not used in this
8418 maybe_warn_unused_local_typedefs ();
8420 /* Store the end of the function, so that we get good line number
8421 info for the epilogue. */
8422 cfun
->function_end_locus
= input_location
;
8424 /* Finalize the ELF visibility for the function. */
8425 c_determine_visibility (fndecl
);
8427 /* For GNU C extern inline functions disregard inline limits. */
8428 if (DECL_EXTERNAL (fndecl
)
8429 && DECL_DECLARED_INLINE_P (fndecl
))
8430 DECL_DISREGARD_INLINE_LIMITS (fndecl
) = 1;
8432 /* Genericize before inlining. Delay genericizing nested functions
8433 until their parent function is genericized. Since finalizing
8434 requires GENERIC, delay that as well. */
8436 if (DECL_INITIAL (fndecl
) && DECL_INITIAL (fndecl
) != error_mark_node
8437 && !undef_nested_function
)
8439 if (!decl_function_context (fndecl
))
8441 invoke_plugin_callbacks (PLUGIN_PRE_GENERICIZE
, fndecl
);
8442 c_genericize (fndecl
);
8444 /* ??? Objc emits functions after finalizing the compilation unit.
8445 This should be cleaned up later and this conditional removed. */
8446 if (cgraph_global_info_ready
)
8448 cgraph_add_new_function (fndecl
, false);
8451 cgraph_finalize_function (fndecl
, false);
8455 /* Register this function with cgraph just far enough to get it
8456 added to our parent's nested function list. Handy, since the
8457 C front end doesn't have such a list. */
8458 (void) cgraph_get_create_node (fndecl
);
8462 if (!decl_function_context (fndecl
))
8463 undef_nested_function
= false;
8465 if (cfun
->language
!= NULL
)
8467 ggc_free (cfun
->language
);
8468 cfun
->language
= NULL
;
8471 /* We're leaving the context of this function, so zap cfun.
8472 It's still in DECL_STRUCT_FUNCTION, and we'll restore it in
8473 tree_rest_of_compilation. */
8475 current_function_decl
= NULL
;
8478 /* Check the declarations given in a for-loop for satisfying the C99
8479 constraints. If exactly one such decl is found, return it. LOC is
8480 the location of the opening parenthesis of the for loop. The last
8481 parameter allows you to control the "for loop initial declarations
8482 are only allowed in C99 mode". Normally, you should pass
8483 flag_isoc99 as that parameter. But in some cases (Objective-C
8484 foreach loop, for example) we want to run the checks in this
8485 function even if not in C99 mode, so we allow the caller to turn
8486 off the error about not being in C99 mode.
8490 check_for_loop_decls (location_t loc
, bool turn_off_iso_c99_error
)
8492 struct c_binding
*b
;
8493 tree one_decl
= NULL_TREE
;
8496 if (!turn_off_iso_c99_error
)
8498 static bool hint
= true;
8499 /* If we get here, declarations have been used in a for loop without
8500 the C99 for loop scope. This doesn't make much sense, so don't
8502 error_at (loc
, "%<for%> loop initial declarations "
8503 "are only allowed in C99 mode");
8507 "use option -std=c99 or -std=gnu99 to compile your code");
8512 /* C99 subclause 6.8.5 paragraph 3:
8514 [#3] The declaration part of a for statement shall only
8515 declare identifiers for objects having storage class auto or
8518 It isn't clear whether, in this sentence, "identifiers" binds to
8519 "shall only declare" or to "objects" - that is, whether all identifiers
8520 declared must be identifiers for objects, or whether the restriction
8521 only applies to those that are. (A question on this in comp.std.c
8522 in November 2000 received no answer.) We implement the strictest
8523 interpretation, to avoid creating an extension which later causes
8526 for (b
= current_scope
->bindings
; b
; b
= b
->prev
)
8529 tree decl
= b
->decl
;
8534 switch (TREE_CODE (decl
))
8538 location_t decl_loc
= DECL_SOURCE_LOCATION (decl
);
8539 if (TREE_STATIC (decl
))
8541 "declaration of static variable %qD in %<for%> loop "
8542 "initial declaration", decl
);
8543 else if (DECL_EXTERNAL (decl
))
8545 "declaration of %<extern%> variable %qD in %<for%> loop "
8546 "initial declaration", decl
);
8552 "%<struct %E%> declared in %<for%> loop initial "
8557 "%<union %E%> declared in %<for%> loop initial declaration",
8561 error_at (loc
, "%<enum %E%> declared in %<for%> loop "
8562 "initial declaration", id
);
8565 error_at (loc
, "declaration of non-variable "
8566 "%qD in %<for%> loop initial declaration", decl
);
8573 return n_decls
== 1 ? one_decl
: NULL_TREE
;
8576 /* Save and reinitialize the variables
8577 used during compilation of a C function. */
8580 c_push_function_context (void)
8582 struct language_function
*p
= cfun
->language
;
8583 /* cfun->language might have been already allocated by the use of
8584 -Wunused-local-typedefs. In that case, just re-use it. */
8586 cfun
->language
= p
= ggc_alloc_cleared_language_function ();
8588 p
->base
.x_stmt_tree
= c_stmt_tree
;
8589 c_stmt_tree
.x_cur_stmt_list
8590 = VEC_copy (tree
, gc
, c_stmt_tree
.x_cur_stmt_list
);
8591 p
->x_break_label
= c_break_label
;
8592 p
->x_cont_label
= c_cont_label
;
8593 p
->x_switch_stack
= c_switch_stack
;
8594 p
->arg_info
= current_function_arg_info
;
8595 p
->returns_value
= current_function_returns_value
;
8596 p
->returns_null
= current_function_returns_null
;
8597 p
->returns_abnormally
= current_function_returns_abnormally
;
8598 p
->warn_about_return_type
= warn_about_return_type
;
8600 push_function_context ();
8603 /* Restore the variables used during compilation of a C function. */
8606 c_pop_function_context (void)
8608 struct language_function
*p
;
8610 pop_function_context ();
8613 /* When -Wunused-local-typedefs is in effect, cfun->languages is
8614 used to store data throughout the life time of the current cfun,
8615 So don't deallocate it. */
8616 if (!warn_unused_local_typedefs
)
8617 cfun
->language
= NULL
;
8619 if (DECL_STRUCT_FUNCTION (current_function_decl
) == 0
8620 && DECL_SAVED_TREE (current_function_decl
) == NULL_TREE
)
8622 /* Stop pointing to the local nodes about to be freed. */
8623 /* But DECL_INITIAL must remain nonzero so we know this
8624 was an actual function definition. */
8625 DECL_INITIAL (current_function_decl
) = error_mark_node
;
8626 DECL_ARGUMENTS (current_function_decl
) = 0;
8629 c_stmt_tree
= p
->base
.x_stmt_tree
;
8630 p
->base
.x_stmt_tree
.x_cur_stmt_list
= NULL
;
8631 c_break_label
= p
->x_break_label
;
8632 c_cont_label
= p
->x_cont_label
;
8633 c_switch_stack
= p
->x_switch_stack
;
8634 current_function_arg_info
= p
->arg_info
;
8635 current_function_returns_value
= p
->returns_value
;
8636 current_function_returns_null
= p
->returns_null
;
8637 current_function_returns_abnormally
= p
->returns_abnormally
;
8638 warn_about_return_type
= p
->warn_about_return_type
;
8641 /* The functions below are required for functionality of doing
8642 function at once processing in the C front end. Currently these
8643 functions are not called from anywhere in the C front end, but as
8644 these changes continue, that will change. */
8646 /* Returns the stmt_tree (if any) to which statements are currently
8647 being added. If there is no active statement-tree, NULL is
8651 current_stmt_tree (void)
8653 return &c_stmt_tree
;
8656 /* Return the global value of T as a symbol. */
8659 identifier_global_value (tree t
)
8661 struct c_binding
*b
;
8663 for (b
= I_SYMBOL_BINDING (t
); b
; b
= b
->shadowed
)
8664 if (B_IN_FILE_SCOPE (b
) || B_IN_EXTERNAL_SCOPE (b
))
8670 /* In C, the only C-linkage public declaration is at file scope. */
8673 c_linkage_bindings (tree name
)
8675 return identifier_global_value (name
);
8678 /* Record a builtin type for C. If NAME is non-NULL, it is the name used;
8679 otherwise the name is found in ridpointers from RID_INDEX. */
8682 record_builtin_type (enum rid rid_index
, const char *name
, tree type
)
8686 id
= ridpointers
[(int) rid_index
];
8688 id
= get_identifier (name
);
8689 decl
= build_decl (UNKNOWN_LOCATION
, TYPE_DECL
, id
, type
);
8691 if (debug_hooks
->type_decl
)
8692 debug_hooks
->type_decl (decl
, false);
8695 /* Build the void_list_node (void_type_node having been created). */
8697 build_void_list_node (void)
8699 tree t
= build_tree_list (NULL_TREE
, void_type_node
);
8703 /* Return a c_parm structure with the given SPECS, ATTRS and DECLARATOR. */
8706 build_c_parm (struct c_declspecs
*specs
, tree attrs
,
8707 struct c_declarator
*declarator
)
8709 struct c_parm
*ret
= XOBNEW (&parser_obstack
, struct c_parm
);
8712 ret
->declarator
= declarator
;
8716 /* Return a declarator with nested attributes. TARGET is the inner
8717 declarator to which these attributes apply. ATTRS are the
8720 struct c_declarator
*
8721 build_attrs_declarator (tree attrs
, struct c_declarator
*target
)
8723 struct c_declarator
*ret
= XOBNEW (&parser_obstack
, struct c_declarator
);
8724 ret
->kind
= cdk_attrs
;
8725 ret
->declarator
= target
;
8726 ret
->u
.attrs
= attrs
;
8730 /* Return a declarator for a function with arguments specified by ARGS
8731 and return type specified by TARGET. */
8733 struct c_declarator
*
8734 build_function_declarator (struct c_arg_info
*args
,
8735 struct c_declarator
*target
)
8737 struct c_declarator
*ret
= XOBNEW (&parser_obstack
, struct c_declarator
);
8738 ret
->kind
= cdk_function
;
8739 ret
->declarator
= target
;
8740 ret
->u
.arg_info
= args
;
8744 /* Return a declarator for the identifier IDENT (which may be
8745 NULL_TREE for an abstract declarator). */
8747 struct c_declarator
*
8748 build_id_declarator (tree ident
)
8750 struct c_declarator
*ret
= XOBNEW (&parser_obstack
, struct c_declarator
);
8752 ret
->declarator
= 0;
8754 /* Default value - may get reset to a more precise location. */
8755 ret
->id_loc
= input_location
;
8759 /* Return something to represent absolute declarators containing a *.
8760 TARGET is the absolute declarator that the * contains.
8761 TYPE_QUALS_ATTRS is a structure for type qualifiers and attributes
8762 to apply to the pointer type. */
8764 struct c_declarator
*
8765 make_pointer_declarator (struct c_declspecs
*type_quals_attrs
,
8766 struct c_declarator
*target
)
8770 struct c_declarator
*itarget
= target
;
8771 struct c_declarator
*ret
= XOBNEW (&parser_obstack
, struct c_declarator
);
8772 if (type_quals_attrs
)
8774 attrs
= type_quals_attrs
->attrs
;
8775 quals
= quals_from_declspecs (type_quals_attrs
);
8776 if (attrs
!= NULL_TREE
)
8777 itarget
= build_attrs_declarator (attrs
, target
);
8779 ret
->kind
= cdk_pointer
;
8780 ret
->declarator
= itarget
;
8781 ret
->u
.pointer_quals
= quals
;
8785 /* Return a pointer to a structure for an empty list of declaration
8788 struct c_declspecs
*
8789 build_null_declspecs (void)
8791 struct c_declspecs
*ret
= XOBNEW (&parser_obstack
, struct c_declspecs
);
8792 memset (&ret
->locations
, 0, cdw_number_of_elements
);
8797 ret
->align_log
= -1;
8798 ret
->typespec_word
= cts_none
;
8799 ret
->storage_class
= csc_none
;
8800 ret
->expr_const_operands
= true;
8801 ret
->declspecs_seen_p
= false;
8802 ret
->typespec_kind
= ctsk_none
;
8803 ret
->non_sc_seen_p
= false;
8804 ret
->typedef_p
= false;
8805 ret
->explicit_signed_p
= false;
8806 ret
->deprecated_p
= false;
8807 ret
->default_int_p
= false;
8808 ret
->long_p
= false;
8809 ret
->long_long_p
= false;
8810 ret
->short_p
= false;
8811 ret
->signed_p
= false;
8812 ret
->unsigned_p
= false;
8813 ret
->complex_p
= false;
8814 ret
->inline_p
= false;
8815 ret
->noreturn_p
= false;
8816 ret
->thread_p
= false;
8817 ret
->const_p
= false;
8818 ret
->volatile_p
= false;
8819 ret
->restrict_p
= false;
8820 ret
->saturating_p
= false;
8821 ret
->alignas_p
= false;
8822 ret
->address_space
= ADDR_SPACE_GENERIC
;
8826 /* Add the address space ADDRSPACE to the declaration specifiers
8827 SPECS, returning SPECS. */
8829 struct c_declspecs
*
8830 declspecs_add_addrspace (source_location location
,
8831 struct c_declspecs
*specs
, addr_space_t as
)
8833 specs
->non_sc_seen_p
= true;
8834 specs
->declspecs_seen_p
= true;
8836 if (!ADDR_SPACE_GENERIC_P (specs
->address_space
)
8837 && specs
->address_space
!= as
)
8838 error ("incompatible address space qualifiers %qs and %qs",
8839 c_addr_space_name (as
),
8840 c_addr_space_name (specs
->address_space
));
8843 specs
->address_space
= as
;
8844 specs
->locations
[cdw_address_space
] = location
;
8849 /* Add the type qualifier QUAL to the declaration specifiers SPECS,
8852 struct c_declspecs
*
8853 declspecs_add_qual (source_location loc
,
8854 struct c_declspecs
*specs
, tree qual
)
8858 specs
->non_sc_seen_p
= true;
8859 specs
->declspecs_seen_p
= true;
8860 gcc_assert (TREE_CODE (qual
) == IDENTIFIER_NODE
8861 && C_IS_RESERVED_WORD (qual
));
8862 i
= C_RID_CODE (qual
);
8866 dupe
= specs
->const_p
;
8867 specs
->const_p
= true;
8868 specs
->locations
[cdw_const
] = loc
;
8871 dupe
= specs
->volatile_p
;
8872 specs
->volatile_p
= true;
8873 specs
->locations
[cdw_volatile
] = loc
;
8876 dupe
= specs
->restrict_p
;
8877 specs
->restrict_p
= true;
8878 specs
->locations
[cdw_restrict
] = loc
;
8883 if (dupe
&& !flag_isoc99
)
8884 pedwarn (loc
, OPT_Wpedantic
, "duplicate %qE", qual
);
8888 /* Add the type specifier TYPE to the declaration specifiers SPECS,
8891 struct c_declspecs
*
8892 declspecs_add_type (location_t loc
, struct c_declspecs
*specs
,
8893 struct c_typespec spec
)
8895 tree type
= spec
.spec
;
8896 specs
->non_sc_seen_p
= true;
8897 specs
->declspecs_seen_p
= true;
8898 specs
->typespec_kind
= spec
.kind
;
8899 if (TREE_DEPRECATED (type
))
8900 specs
->deprecated_p
= true;
8902 /* Handle type specifier keywords. */
8903 if (TREE_CODE (type
) == IDENTIFIER_NODE
8904 && C_IS_RESERVED_WORD (type
)
8905 && C_RID_CODE (type
) != RID_CXX_COMPAT_WARN
)
8907 enum rid i
= C_RID_CODE (type
);
8910 error_at (loc
, "two or more data types in declaration specifiers");
8913 if ((int) i
<= (int) RID_LAST_MODIFIER
)
8915 /* "long", "short", "signed", "unsigned", "_Complex" or "_Sat". */
8920 if (specs
->long_long_p
)
8922 error_at (loc
, "%<long long long%> is too long for GCC");
8927 if (specs
->typespec_word
== cts_double
)
8930 ("both %<long long%> and %<double%> in "
8931 "declaration specifiers"));
8934 pedwarn_c90 (loc
, OPT_Wlong_long
,
8935 "ISO C90 does not support %<long long%>");
8936 specs
->long_long_p
= 1;
8937 specs
->locations
[cdw_long_long
] = loc
;
8942 ("both %<long%> and %<short%> in "
8943 "declaration specifiers"));
8944 else if (specs
->typespec_word
== cts_void
)
8946 ("both %<long%> and %<void%> in "
8947 "declaration specifiers"));
8948 else if (specs
->typespec_word
== cts_int128
)
8950 ("both %<long%> and %<__int128%> in "
8951 "declaration specifiers"));
8952 else if (specs
->typespec_word
== cts_bool
)
8954 ("both %<long%> and %<_Bool%> in "
8955 "declaration specifiers"));
8956 else if (specs
->typespec_word
== cts_char
)
8958 ("both %<long%> and %<char%> in "
8959 "declaration specifiers"));
8960 else if (specs
->typespec_word
== cts_float
)
8962 ("both %<long%> and %<float%> in "
8963 "declaration specifiers"));
8964 else if (specs
->typespec_word
== cts_dfloat32
)
8966 ("both %<long%> and %<_Decimal32%> in "
8967 "declaration specifiers"));
8968 else if (specs
->typespec_word
== cts_dfloat64
)
8970 ("both %<long%> and %<_Decimal64%> in "
8971 "declaration specifiers"));
8972 else if (specs
->typespec_word
== cts_dfloat128
)
8974 ("both %<long%> and %<_Decimal128%> in "
8975 "declaration specifiers"));
8978 specs
->long_p
= true;
8979 specs
->locations
[cdw_long
] = loc
;
8983 dupe
= specs
->short_p
;
8986 ("both %<long%> and %<short%> in "
8987 "declaration specifiers"));
8988 else if (specs
->typespec_word
== cts_void
)
8990 ("both %<short%> and %<void%> in "
8991 "declaration specifiers"));
8992 else if (specs
->typespec_word
== cts_int128
)
8994 ("both %<short%> and %<__int128%> in "
8995 "declaration specifiers"));
8996 else if (specs
->typespec_word
== cts_bool
)
8998 ("both %<short%> and %<_Bool%> in "
8999 "declaration specifiers"));
9000 else if (specs
->typespec_word
== cts_char
)
9002 ("both %<short%> and %<char%> in "
9003 "declaration specifiers"));
9004 else if (specs
->typespec_word
== cts_float
)
9006 ("both %<short%> and %<float%> in "
9007 "declaration specifiers"));
9008 else if (specs
->typespec_word
== cts_double
)
9010 ("both %<short%> and %<double%> in "
9011 "declaration specifiers"));
9012 else if (specs
->typespec_word
== cts_dfloat32
)
9014 ("both %<short%> and %<_Decimal32%> in "
9015 "declaration specifiers"));
9016 else if (specs
->typespec_word
== cts_dfloat64
)
9018 ("both %<short%> and %<_Decimal64%> in "
9019 "declaration specifiers"));
9020 else if (specs
->typespec_word
== cts_dfloat128
)
9022 ("both %<short%> and %<_Decimal128%> in "
9023 "declaration specifiers"));
9026 specs
->short_p
= true;
9027 specs
->locations
[cdw_short
] = loc
;
9031 dupe
= specs
->signed_p
;
9032 if (specs
->unsigned_p
)
9034 ("both %<signed%> and %<unsigned%> in "
9035 "declaration specifiers"));
9036 else if (specs
->typespec_word
== cts_void
)
9038 ("both %<signed%> and %<void%> in "
9039 "declaration specifiers"));
9040 else if (specs
->typespec_word
== cts_bool
)
9042 ("both %<signed%> and %<_Bool%> in "
9043 "declaration specifiers"));
9044 else if (specs
->typespec_word
== cts_float
)
9046 ("both %<signed%> and %<float%> in "
9047 "declaration specifiers"));
9048 else if (specs
->typespec_word
== cts_double
)
9050 ("both %<signed%> and %<double%> in "
9051 "declaration specifiers"));
9052 else if (specs
->typespec_word
== cts_dfloat32
)
9054 ("both %<signed%> and %<_Decimal32%> in "
9055 "declaration specifiers"));
9056 else if (specs
->typespec_word
== cts_dfloat64
)
9058 ("both %<signed%> and %<_Decimal64%> in "
9059 "declaration specifiers"));
9060 else if (specs
->typespec_word
== cts_dfloat128
)
9062 ("both %<signed%> and %<_Decimal128%> in "
9063 "declaration specifiers"));
9066 specs
->signed_p
= true;
9067 specs
->locations
[cdw_signed
] = loc
;
9071 dupe
= specs
->unsigned_p
;
9072 if (specs
->signed_p
)
9074 ("both %<signed%> and %<unsigned%> in "
9075 "declaration specifiers"));
9076 else if (specs
->typespec_word
== cts_void
)
9078 ("both %<unsigned%> and %<void%> in "
9079 "declaration specifiers"));
9080 else if (specs
->typespec_word
== cts_bool
)
9082 ("both %<unsigned%> and %<_Bool%> in "
9083 "declaration specifiers"));
9084 else if (specs
->typespec_word
== cts_float
)
9086 ("both %<unsigned%> and %<float%> in "
9087 "declaration specifiers"));
9088 else if (specs
->typespec_word
== cts_double
)
9090 ("both %<unsigned%> and %<double%> in "
9091 "declaration specifiers"));
9092 else if (specs
->typespec_word
== cts_dfloat32
)
9094 ("both %<unsigned%> and %<_Decimal32%> in "
9095 "declaration specifiers"));
9096 else if (specs
->typespec_word
== cts_dfloat64
)
9098 ("both %<unsigned%> and %<_Decimal64%> in "
9099 "declaration specifiers"));
9100 else if (specs
->typespec_word
== cts_dfloat128
)
9102 ("both %<unsigned%> and %<_Decimal128%> in "
9103 "declaration specifiers"));
9106 specs
->unsigned_p
= true;
9107 specs
->locations
[cdw_unsigned
] = loc
;
9111 dupe
= specs
->complex_p
;
9112 if (!flag_isoc99
&& !in_system_header_at (loc
))
9113 pedwarn (loc
, OPT_Wpedantic
,
9114 "ISO C90 does not support complex types");
9115 if (specs
->typespec_word
== cts_void
)
9117 ("both %<complex%> and %<void%> in "
9118 "declaration specifiers"));
9119 else if (specs
->typespec_word
== cts_bool
)
9121 ("both %<complex%> and %<_Bool%> in "
9122 "declaration specifiers"));
9123 else if (specs
->typespec_word
== cts_dfloat32
)
9125 ("both %<complex%> and %<_Decimal32%> in "
9126 "declaration specifiers"));
9127 else if (specs
->typespec_word
== cts_dfloat64
)
9129 ("both %<complex%> and %<_Decimal64%> in "
9130 "declaration specifiers"));
9131 else if (specs
->typespec_word
== cts_dfloat128
)
9133 ("both %<complex%> and %<_Decimal128%> in "
9134 "declaration specifiers"));
9135 else if (specs
->typespec_word
== cts_fract
)
9137 ("both %<complex%> and %<_Fract%> in "
9138 "declaration specifiers"));
9139 else if (specs
->typespec_word
== cts_accum
)
9141 ("both %<complex%> and %<_Accum%> in "
9142 "declaration specifiers"));
9143 else if (specs
->saturating_p
)
9145 ("both %<complex%> and %<_Sat%> in "
9146 "declaration specifiers"));
9149 specs
->complex_p
= true;
9150 specs
->locations
[cdw_complex
] = loc
;
9154 dupe
= specs
->saturating_p
;
9155 pedwarn (loc
, OPT_Wpedantic
,
9156 "ISO C does not support saturating types");
9157 if (specs
->typespec_word
== cts_int128
)
9160 ("both %<_Sat%> and %<__int128%> in "
9161 "declaration specifiers"));
9163 else if (specs
->typespec_word
== cts_void
)
9165 ("both %<_Sat%> and %<void%> in "
9166 "declaration specifiers"));
9167 else if (specs
->typespec_word
== cts_bool
)
9169 ("both %<_Sat%> and %<_Bool%> in "
9170 "declaration specifiers"));
9171 else if (specs
->typespec_word
== cts_char
)
9173 ("both %<_Sat%> and %<char%> in "
9174 "declaration specifiers"));
9175 else if (specs
->typespec_word
== cts_int
)
9177 ("both %<_Sat%> and %<int%> in "
9178 "declaration specifiers"));
9179 else if (specs
->typespec_word
== cts_float
)
9181 ("both %<_Sat%> and %<float%> in "
9182 "declaration specifiers"));
9183 else if (specs
->typespec_word
== cts_double
)
9185 ("both %<_Sat%> and %<double%> in "
9186 "declaration specifiers"));
9187 else if (specs
->typespec_word
== cts_dfloat32
)
9189 ("both %<_Sat%> and %<_Decimal32%> in "
9190 "declaration specifiers"));
9191 else if (specs
->typespec_word
== cts_dfloat64
)
9193 ("both %<_Sat%> and %<_Decimal64%> in "
9194 "declaration specifiers"));
9195 else if (specs
->typespec_word
== cts_dfloat128
)
9197 ("both %<_Sat%> and %<_Decimal128%> in "
9198 "declaration specifiers"));
9199 else if (specs
->complex_p
)
9201 ("both %<_Sat%> and %<complex%> in "
9202 "declaration specifiers"));
9205 specs
->saturating_p
= true;
9206 specs
->locations
[cdw_saturating
] = loc
;
9214 error_at (loc
, "duplicate %qE", type
);
9220 /* "void", "_Bool", "char", "int", "float", "double", "_Decimal32",
9221 "__int128", "_Decimal64", "_Decimal128", "_Fract" or "_Accum". */
9222 if (specs
->typespec_word
!= cts_none
)
9225 "two or more data types in declaration specifiers");
9231 if (int128_integer_type_node
== NULL_TREE
)
9233 error_at (loc
, "%<__int128%> is not supported for this target");
9236 if (!in_system_header
)
9237 pedwarn (loc
, OPT_Wpedantic
,
9238 "ISO C does not support %<__int128%> type");
9242 ("both %<__int128%> and %<long%> in "
9243 "declaration specifiers"));
9244 else if (specs
->saturating_p
)
9246 ("both %<_Sat%> and %<__int128%> in "
9247 "declaration specifiers"));
9248 else if (specs
->short_p
)
9250 ("both %<__int128%> and %<short%> in "
9251 "declaration specifiers"));
9254 specs
->typespec_word
= cts_int128
;
9255 specs
->locations
[cdw_typespec
] = loc
;
9261 ("both %<long%> and %<void%> in "
9262 "declaration specifiers"));
9263 else if (specs
->short_p
)
9265 ("both %<short%> and %<void%> in "
9266 "declaration specifiers"));
9267 else if (specs
->signed_p
)
9269 ("both %<signed%> and %<void%> in "
9270 "declaration specifiers"));
9271 else if (specs
->unsigned_p
)
9273 ("both %<unsigned%> and %<void%> in "
9274 "declaration specifiers"));
9275 else if (specs
->complex_p
)
9277 ("both %<complex%> and %<void%> in "
9278 "declaration specifiers"));
9279 else if (specs
->saturating_p
)
9281 ("both %<_Sat%> and %<void%> in "
9282 "declaration specifiers"));
9285 specs
->typespec_word
= cts_void
;
9286 specs
->locations
[cdw_typespec
] = loc
;
9292 ("both %<long%> and %<_Bool%> in "
9293 "declaration specifiers"));
9294 else if (specs
->short_p
)
9296 ("both %<short%> and %<_Bool%> in "
9297 "declaration specifiers"));
9298 else if (specs
->signed_p
)
9300 ("both %<signed%> and %<_Bool%> in "
9301 "declaration specifiers"));
9302 else if (specs
->unsigned_p
)
9304 ("both %<unsigned%> and %<_Bool%> in "
9305 "declaration specifiers"));
9306 else if (specs
->complex_p
)
9308 ("both %<complex%> and %<_Bool%> in "
9309 "declaration specifiers"));
9310 else if (specs
->saturating_p
)
9312 ("both %<_Sat%> and %<_Bool%> in "
9313 "declaration specifiers"));
9316 specs
->typespec_word
= cts_bool
;
9317 specs
->locations
[cdw_typespec
] = loc
;
9323 ("both %<long%> and %<char%> in "
9324 "declaration specifiers"));
9325 else if (specs
->short_p
)
9327 ("both %<short%> and %<char%> in "
9328 "declaration specifiers"));
9329 else if (specs
->saturating_p
)
9331 ("both %<_Sat%> and %<char%> in "
9332 "declaration specifiers"));
9335 specs
->typespec_word
= cts_char
;
9336 specs
->locations
[cdw_typespec
] = loc
;
9340 if (specs
->saturating_p
)
9342 ("both %<_Sat%> and %<int%> in "
9343 "declaration specifiers"));
9346 specs
->typespec_word
= cts_int
;
9347 specs
->locations
[cdw_typespec
] = loc
;
9353 ("both %<long%> and %<float%> in "
9354 "declaration specifiers"));
9355 else if (specs
->short_p
)
9357 ("both %<short%> and %<float%> in "
9358 "declaration specifiers"));
9359 else if (specs
->signed_p
)
9361 ("both %<signed%> and %<float%> in "
9362 "declaration specifiers"));
9363 else if (specs
->unsigned_p
)
9365 ("both %<unsigned%> and %<float%> in "
9366 "declaration specifiers"));
9367 else if (specs
->saturating_p
)
9369 ("both %<_Sat%> and %<float%> in "
9370 "declaration specifiers"));
9373 specs
->typespec_word
= cts_float
;
9374 specs
->locations
[cdw_typespec
] = loc
;
9378 if (specs
->long_long_p
)
9380 ("both %<long long%> and %<double%> in "
9381 "declaration specifiers"));
9382 else if (specs
->short_p
)
9384 ("both %<short%> and %<double%> in "
9385 "declaration specifiers"));
9386 else if (specs
->signed_p
)
9388 ("both %<signed%> and %<double%> in "
9389 "declaration specifiers"));
9390 else if (specs
->unsigned_p
)
9392 ("both %<unsigned%> and %<double%> in "
9393 "declaration specifiers"));
9394 else if (specs
->saturating_p
)
9396 ("both %<_Sat%> and %<double%> in "
9397 "declaration specifiers"));
9400 specs
->typespec_word
= cts_double
;
9401 specs
->locations
[cdw_typespec
] = loc
;
9409 if (i
== RID_DFLOAT32
)
9411 else if (i
== RID_DFLOAT64
)
9414 str
= "_Decimal128";
9415 if (specs
->long_long_p
)
9417 ("both %<long long%> and %<%s%> in "
9418 "declaration specifiers"),
9422 ("both %<long%> and %<%s%> in "
9423 "declaration specifiers"),
9425 else if (specs
->short_p
)
9427 ("both %<short%> and %<%s%> in "
9428 "declaration specifiers"),
9430 else if (specs
->signed_p
)
9432 ("both %<signed%> and %<%s%> in "
9433 "declaration specifiers"),
9435 else if (specs
->unsigned_p
)
9437 ("both %<unsigned%> and %<%s%> in "
9438 "declaration specifiers"),
9440 else if (specs
->complex_p
)
9442 ("both %<complex%> and %<%s%> in "
9443 "declaration specifiers"),
9445 else if (specs
->saturating_p
)
9447 ("both %<_Sat%> and %<%s%> in "
9448 "declaration specifiers"),
9450 else if (i
== RID_DFLOAT32
)
9451 specs
->typespec_word
= cts_dfloat32
;
9452 else if (i
== RID_DFLOAT64
)
9453 specs
->typespec_word
= cts_dfloat64
;
9455 specs
->typespec_word
= cts_dfloat128
;
9456 specs
->locations
[cdw_typespec
] = loc
;
9458 if (!targetm
.decimal_float_supported_p ())
9460 ("decimal floating point not supported "
9461 "for this target"));
9462 pedwarn (loc
, OPT_Wpedantic
,
9463 "ISO C does not support decimal floating point");
9473 if (specs
->complex_p
)
9475 ("both %<complex%> and %<%s%> in "
9476 "declaration specifiers"),
9478 else if (i
== RID_FRACT
)
9479 specs
->typespec_word
= cts_fract
;
9481 specs
->typespec_word
= cts_accum
;
9482 specs
->locations
[cdw_typespec
] = loc
;
9484 if (!targetm
.fixed_point_supported_p ())
9486 "fixed-point types not supported for this target");
9487 pedwarn (loc
, OPT_Wpedantic
,
9488 "ISO C does not support fixed-point types");
9491 /* ObjC reserved word "id", handled below. */
9497 /* Now we have a typedef (a TYPE_DECL node), an identifier (some
9498 form of ObjC type, cases such as "int" and "long" being handled
9499 above), a TYPE (struct, union, enum and typeof specifiers) or an
9500 ERROR_MARK. In none of these cases may there have previously
9501 been any type specifiers. */
9502 if (specs
->type
|| specs
->typespec_word
!= cts_none
9503 || specs
->long_p
|| specs
->short_p
|| specs
->signed_p
9504 || specs
->unsigned_p
|| specs
->complex_p
)
9505 error_at (loc
, "two or more data types in declaration specifiers");
9506 else if (TREE_CODE (type
) == TYPE_DECL
)
9508 if (TREE_TYPE (type
) == error_mark_node
)
9509 ; /* Allow the type to default to int to avoid cascading errors. */
9512 specs
->type
= TREE_TYPE (type
);
9513 specs
->decl_attr
= DECL_ATTRIBUTES (type
);
9514 specs
->typedef_p
= true;
9515 specs
->explicit_signed_p
= C_TYPEDEF_EXPLICITLY_SIGNED (type
);
9516 specs
->locations
[cdw_typedef
] = loc
;
9518 /* If this typedef name is defined in a struct, then a C++
9519 lookup would return a different value. */
9521 && I_SYMBOL_BINDING (DECL_NAME (type
))->in_struct
)
9522 warning_at (loc
, OPT_Wc___compat
,
9523 "C++ lookup of %qD would return a field, not a type",
9526 /* If we are parsing a struct, record that a struct field
9528 if (warn_cxx_compat
&& struct_parse_info
!= NULL
)
9529 VEC_safe_push (tree
, heap
, struct_parse_info
->typedefs_seen
, type
);
9532 else if (TREE_CODE (type
) == IDENTIFIER_NODE
)
9534 tree t
= lookup_name (type
);
9535 if (!t
|| TREE_CODE (t
) != TYPE_DECL
)
9536 error_at (loc
, "%qE fails to be a typedef or built in type", type
);
9537 else if (TREE_TYPE (t
) == error_mark_node
)
9541 specs
->type
= TREE_TYPE (t
);
9542 specs
->locations
[cdw_typespec
] = loc
;
9547 if (TREE_CODE (type
) != ERROR_MARK
&& spec
.kind
== ctsk_typeof
)
9549 specs
->typedef_p
= true;
9550 specs
->locations
[cdw_typedef
] = loc
;
9554 specs
->expr
= build2 (COMPOUND_EXPR
, TREE_TYPE (spec
.expr
),
9555 specs
->expr
, spec
.expr
);
9557 specs
->expr
= spec
.expr
;
9558 specs
->expr_const_operands
&= spec
.expr_const_operands
;
9567 /* Add the storage class specifier or function specifier SCSPEC to the
9568 declaration specifiers SPECS, returning SPECS. */
9570 struct c_declspecs
*
9571 declspecs_add_scspec (source_location loc
,
9572 struct c_declspecs
*specs
,
9576 enum c_storage_class n
= csc_none
;
9578 specs
->declspecs_seen_p
= true;
9579 gcc_assert (TREE_CODE (scspec
) == IDENTIFIER_NODE
9580 && C_IS_RESERVED_WORD (scspec
));
9581 i
= C_RID_CODE (scspec
);
9582 if (specs
->non_sc_seen_p
)
9583 warning (OPT_Wold_style_declaration
,
9584 "%qE is not at beginning of declaration", scspec
);
9588 /* C99 permits duplicate inline. Although of doubtful utility,
9589 it seems simplest to permit it in gnu89 mode as well, as
9590 there is also little utility in maintaining this as a
9591 difference between gnu89 and C99 inline. */
9593 specs
->inline_p
= true;
9594 specs
->locations
[cdw_inline
] = loc
;
9597 /* Duplicate _Noreturn is permitted. */
9599 specs
->noreturn_p
= true;
9600 specs
->locations
[cdw_noreturn
] = loc
;
9603 dupe
= specs
->thread_p
;
9604 if (specs
->storage_class
== csc_auto
)
9605 error ("%<__thread%> used with %<auto%>");
9606 else if (specs
->storage_class
== csc_register
)
9607 error ("%<__thread%> used with %<register%>");
9608 else if (specs
->storage_class
== csc_typedef
)
9609 error ("%<__thread%> used with %<typedef%>");
9612 specs
->thread_p
= true;
9613 specs
->locations
[cdw_thread
] = loc
;
9621 /* Diagnose "__thread extern". */
9622 if (specs
->thread_p
)
9623 error ("%<__thread%> before %<extern%>");
9630 /* Diagnose "__thread static". */
9631 if (specs
->thread_p
)
9632 error ("%<__thread%> before %<static%>");
9640 if (n
!= csc_none
&& n
== specs
->storage_class
)
9643 error ("duplicate %qE", scspec
);
9646 if (specs
->storage_class
!= csc_none
&& n
!= specs
->storage_class
)
9648 error ("multiple storage classes in declaration specifiers");
9652 specs
->storage_class
= n
;
9653 specs
->locations
[cdw_storage_class
] = loc
;
9654 if (n
!= csc_extern
&& n
!= csc_static
&& specs
->thread_p
)
9656 error ("%<__thread%> used with %qE", scspec
);
9657 specs
->thread_p
= false;
9664 /* Add the attributes ATTRS to the declaration specifiers SPECS,
9667 struct c_declspecs
*
9668 declspecs_add_attrs (source_location loc
, struct c_declspecs
*specs
, tree attrs
)
9670 specs
->attrs
= chainon (attrs
, specs
->attrs
);
9671 specs
->locations
[cdw_attributes
] = loc
;
9672 specs
->declspecs_seen_p
= true;
9676 /* Add an _Alignas specifier (expression ALIGN, or type whose
9677 alignment is ALIGN) to the declaration specifiers SPECS, returning
9679 struct c_declspecs
*
9680 declspecs_add_alignas (source_location loc
,
9681 struct c_declspecs
*specs
, tree align
)
9684 specs
->alignas_p
= true;
9685 specs
->locations
[cdw_alignas
] = loc
;
9686 if (align
== error_mark_node
)
9688 align_log
= check_user_alignment (align
, true);
9689 if (align_log
> specs
->align_log
)
9690 specs
->align_log
= align_log
;
9694 /* Combine "long", "short", "signed", "unsigned" and "_Complex" type
9695 specifiers with any other type specifier to determine the resulting
9696 type. This is where ISO C checks on complex types are made, since
9697 "_Complex long" is a prefix of the valid ISO C type "_Complex long
9700 struct c_declspecs
*
9701 finish_declspecs (struct c_declspecs
*specs
)
9703 /* If a type was specified as a whole, we have no modifiers and are
9705 if (specs
->type
!= NULL_TREE
)
9707 gcc_assert (!specs
->long_p
&& !specs
->long_long_p
&& !specs
->short_p
9708 && !specs
->signed_p
&& !specs
->unsigned_p
9709 && !specs
->complex_p
);
9711 /* Set a dummy type. */
9712 if (TREE_CODE (specs
->type
) == ERROR_MARK
)
9713 specs
->type
= integer_type_node
;
9717 /* If none of "void", "_Bool", "char", "int", "float" or "double"
9718 has been specified, treat it as "int" unless "_Complex" is
9719 present and there are no other specifiers. If we just have
9720 "_Complex", it is equivalent to "_Complex double", but e.g.
9721 "_Complex short" is equivalent to "_Complex short int". */
9722 if (specs
->typespec_word
== cts_none
)
9724 if (specs
->saturating_p
)
9726 error_at (specs
->locations
[cdw_saturating
],
9727 "%<_Sat%> is used without %<_Fract%> or %<_Accum%>");
9728 if (!targetm
.fixed_point_supported_p ())
9729 error_at (specs
->locations
[cdw_saturating
],
9730 "fixed-point types not supported for this target");
9731 specs
->typespec_word
= cts_fract
;
9733 else if (specs
->long_p
|| specs
->short_p
9734 || specs
->signed_p
|| specs
->unsigned_p
)
9736 specs
->typespec_word
= cts_int
;
9738 else if (specs
->complex_p
)
9740 specs
->typespec_word
= cts_double
;
9741 pedwarn (specs
->locations
[cdw_complex
], OPT_Wpedantic
,
9742 "ISO C does not support plain %<complex%> meaning "
9743 "%<double complex%>");
9747 specs
->typespec_word
= cts_int
;
9748 specs
->default_int_p
= true;
9749 /* We don't diagnose this here because grokdeclarator will
9750 give more specific diagnostics according to whether it is
9751 a function definition. */
9755 /* If "signed" was specified, record this to distinguish "int" and
9756 "signed int" in the case of a bit-field with
9757 -funsigned-bitfields. */
9758 specs
->explicit_signed_p
= specs
->signed_p
;
9760 /* Now compute the actual type. */
9761 switch (specs
->typespec_word
)
9764 gcc_assert (!specs
->long_p
&& !specs
->short_p
9765 && !specs
->signed_p
&& !specs
->unsigned_p
9766 && !specs
->complex_p
);
9767 specs
->type
= void_type_node
;
9770 gcc_assert (!specs
->long_p
&& !specs
->short_p
9771 && !specs
->signed_p
&& !specs
->unsigned_p
9772 && !specs
->complex_p
);
9773 specs
->type
= boolean_type_node
;
9776 gcc_assert (!specs
->long_p
&& !specs
->short_p
);
9777 gcc_assert (!(specs
->signed_p
&& specs
->unsigned_p
));
9778 if (specs
->signed_p
)
9779 specs
->type
= signed_char_type_node
;
9780 else if (specs
->unsigned_p
)
9781 specs
->type
= unsigned_char_type_node
;
9783 specs
->type
= char_type_node
;
9784 if (specs
->complex_p
)
9786 pedwarn (specs
->locations
[cdw_complex
], OPT_Wpedantic
,
9787 "ISO C does not support complex integer types");
9788 specs
->type
= build_complex_type (specs
->type
);
9792 gcc_assert (!specs
->long_p
&& !specs
->short_p
&& !specs
->long_long_p
);
9793 gcc_assert (!(specs
->signed_p
&& specs
->unsigned_p
));
9794 specs
->type
= (specs
->unsigned_p
9795 ? int128_unsigned_type_node
9796 : int128_integer_type_node
);
9797 if (specs
->complex_p
)
9799 pedwarn (specs
->locations
[cdw_complex
], OPT_Wpedantic
,
9800 "ISO C does not support complex integer types");
9801 specs
->type
= build_complex_type (specs
->type
);
9805 gcc_assert (!(specs
->long_p
&& specs
->short_p
));
9806 gcc_assert (!(specs
->signed_p
&& specs
->unsigned_p
));
9807 if (specs
->long_long_p
)
9808 specs
->type
= (specs
->unsigned_p
9809 ? long_long_unsigned_type_node
9810 : long_long_integer_type_node
);
9811 else if (specs
->long_p
)
9812 specs
->type
= (specs
->unsigned_p
9813 ? long_unsigned_type_node
9814 : long_integer_type_node
);
9815 else if (specs
->short_p
)
9816 specs
->type
= (specs
->unsigned_p
9817 ? short_unsigned_type_node
9818 : short_integer_type_node
);
9820 specs
->type
= (specs
->unsigned_p
9821 ? unsigned_type_node
9822 : integer_type_node
);
9823 if (specs
->complex_p
)
9825 pedwarn (specs
->locations
[cdw_complex
], OPT_Wpedantic
,
9826 "ISO C does not support complex integer types");
9827 specs
->type
= build_complex_type (specs
->type
);
9831 gcc_assert (!specs
->long_p
&& !specs
->short_p
9832 && !specs
->signed_p
&& !specs
->unsigned_p
);
9833 specs
->type
= (specs
->complex_p
9834 ? complex_float_type_node
9838 gcc_assert (!specs
->long_long_p
&& !specs
->short_p
9839 && !specs
->signed_p
&& !specs
->unsigned_p
);
9842 specs
->type
= (specs
->complex_p
9843 ? complex_long_double_type_node
9844 : long_double_type_node
);
9848 specs
->type
= (specs
->complex_p
9849 ? complex_double_type_node
9850 : double_type_node
);
9856 gcc_assert (!specs
->long_p
&& !specs
->long_long_p
&& !specs
->short_p
9857 && !specs
->signed_p
&& !specs
->unsigned_p
&& !specs
->complex_p
);
9858 if (specs
->typespec_word
== cts_dfloat32
)
9859 specs
->type
= dfloat32_type_node
;
9860 else if (specs
->typespec_word
== cts_dfloat64
)
9861 specs
->type
= dfloat64_type_node
;
9863 specs
->type
= dfloat128_type_node
;
9866 gcc_assert (!specs
->complex_p
);
9867 if (!targetm
.fixed_point_supported_p ())
9868 specs
->type
= integer_type_node
;
9869 else if (specs
->saturating_p
)
9871 if (specs
->long_long_p
)
9872 specs
->type
= specs
->unsigned_p
9873 ? sat_unsigned_long_long_fract_type_node
9874 : sat_long_long_fract_type_node
;
9875 else if (specs
->long_p
)
9876 specs
->type
= specs
->unsigned_p
9877 ? sat_unsigned_long_fract_type_node
9878 : sat_long_fract_type_node
;
9879 else if (specs
->short_p
)
9880 specs
->type
= specs
->unsigned_p
9881 ? sat_unsigned_short_fract_type_node
9882 : sat_short_fract_type_node
;
9884 specs
->type
= specs
->unsigned_p
9885 ? sat_unsigned_fract_type_node
9886 : sat_fract_type_node
;
9890 if (specs
->long_long_p
)
9891 specs
->type
= specs
->unsigned_p
9892 ? unsigned_long_long_fract_type_node
9893 : long_long_fract_type_node
;
9894 else if (specs
->long_p
)
9895 specs
->type
= specs
->unsigned_p
9896 ? unsigned_long_fract_type_node
9897 : long_fract_type_node
;
9898 else if (specs
->short_p
)
9899 specs
->type
= specs
->unsigned_p
9900 ? unsigned_short_fract_type_node
9901 : short_fract_type_node
;
9903 specs
->type
= specs
->unsigned_p
9904 ? unsigned_fract_type_node
9909 gcc_assert (!specs
->complex_p
);
9910 if (!targetm
.fixed_point_supported_p ())
9911 specs
->type
= integer_type_node
;
9912 else if (specs
->saturating_p
)
9914 if (specs
->long_long_p
)
9915 specs
->type
= specs
->unsigned_p
9916 ? sat_unsigned_long_long_accum_type_node
9917 : sat_long_long_accum_type_node
;
9918 else if (specs
->long_p
)
9919 specs
->type
= specs
->unsigned_p
9920 ? sat_unsigned_long_accum_type_node
9921 : sat_long_accum_type_node
;
9922 else if (specs
->short_p
)
9923 specs
->type
= specs
->unsigned_p
9924 ? sat_unsigned_short_accum_type_node
9925 : sat_short_accum_type_node
;
9927 specs
->type
= specs
->unsigned_p
9928 ? sat_unsigned_accum_type_node
9929 : sat_accum_type_node
;
9933 if (specs
->long_long_p
)
9934 specs
->type
= specs
->unsigned_p
9935 ? unsigned_long_long_accum_type_node
9936 : long_long_accum_type_node
;
9937 else if (specs
->long_p
)
9938 specs
->type
= specs
->unsigned_p
9939 ? unsigned_long_accum_type_node
9940 : long_accum_type_node
;
9941 else if (specs
->short_p
)
9942 specs
->type
= specs
->unsigned_p
9943 ? unsigned_short_accum_type_node
9944 : short_accum_type_node
;
9946 specs
->type
= specs
->unsigned_p
9947 ? unsigned_accum_type_node
9958 /* A subroutine of c_write_global_declarations. Perform final processing
9959 on one file scope's declarations (or the external scope's declarations),
9963 c_write_global_declarations_1 (tree globals
)
9968 /* Process the decls in the order they were written. */
9969 for (decl
= globals
; decl
; decl
= DECL_CHAIN (decl
))
9971 /* Check for used but undefined static functions using the C
9972 standard's definition of "used", and set TREE_NO_WARNING so
9973 that check_global_declarations doesn't repeat the check. */
9974 if (TREE_CODE (decl
) == FUNCTION_DECL
9975 && DECL_INITIAL (decl
) == 0
9976 && DECL_EXTERNAL (decl
)
9977 && !TREE_PUBLIC (decl
)
9978 && C_DECL_USED (decl
))
9980 pedwarn (input_location
, 0, "%q+F used but never defined", decl
);
9981 TREE_NO_WARNING (decl
) = 1;
9984 wrapup_global_declaration_1 (decl
);
9990 for (decl
= globals
; decl
; decl
= DECL_CHAIN (decl
))
9991 reconsider
|= wrapup_global_declaration_2 (decl
);
9995 for (decl
= globals
; decl
; decl
= DECL_CHAIN (decl
))
9996 check_global_declaration_1 (decl
);
9999 /* A subroutine of c_write_global_declarations Emit debug information for each
10000 of the declarations in GLOBALS. */
10003 c_write_global_declarations_2 (tree globals
)
10007 for (decl
= globals
; decl
; decl
= DECL_CHAIN (decl
))
10008 debug_hooks
->global_decl (decl
);
10011 /* Callback to collect a source_ref from a DECL. */
10014 collect_source_ref_cb (tree decl
)
10016 if (!DECL_IS_BUILTIN (decl
))
10017 collect_source_ref (LOCATION_FILE (decl_sloc (decl
, false)));
10020 /* Preserve the external declarations scope across a garbage collect. */
10021 static GTY(()) tree ext_block
;
10023 /* Collect all references relevant to SOURCE_FILE. */
10026 collect_all_refs (const char *source_file
)
10031 FOR_EACH_VEC_ELT (tree
, all_translation_units
, i
, t
)
10032 collect_ada_nodes (BLOCK_VARS (DECL_INITIAL (t
)), source_file
);
10034 collect_ada_nodes (BLOCK_VARS (ext_block
), source_file
);
10037 /* Iterate over all global declarations and call CALLBACK. */
10040 for_each_global_decl (void (*callback
) (tree decl
))
10047 FOR_EACH_VEC_ELT (tree
, all_translation_units
, i
, t
)
10049 decls
= DECL_INITIAL (t
);
10050 for (decl
= BLOCK_VARS (decls
); decl
; decl
= TREE_CHAIN (decl
))
10054 for (decl
= BLOCK_VARS (ext_block
); decl
; decl
= TREE_CHAIN (decl
))
10059 c_write_global_declarations (void)
10064 /* We don't want to do this if generating a PCH. */
10068 timevar_start (TV_PHASE_DEFERRED
);
10070 /* Do the Objective-C stuff. This is where all the Objective-C
10071 module stuff gets generated (symtab, class/protocol/selector
10073 if (c_dialect_objc ())
10074 objc_write_global_declarations ();
10076 /* Close the external scope. */
10077 ext_block
= pop_scope ();
10078 external_scope
= 0;
10079 gcc_assert (!current_scope
);
10081 /* Handle -fdump-ada-spec[-slim]. */
10082 if (dump_initialized_p (TDI_ada
))
10084 /* Build a table of files to generate specs for */
10085 if (get_dump_file_info (TDI_ada
)->pflags
& TDF_SLIM
)
10086 collect_source_ref (main_input_filename
);
10088 for_each_global_decl (collect_source_ref_cb
);
10090 dump_ada_specs (collect_all_refs
, NULL
);
10095 tree tmp
= BLOCK_VARS (ext_block
);
10097 FILE * stream
= dump_begin (TDI_tu
, &flags
);
10100 dump_node (tmp
, flags
& ~TDF_SLIM
, stream
);
10101 dump_end (TDI_tu
, stream
);
10105 /* Process all file scopes in this compilation, and the external_scope,
10106 through wrapup_global_declarations and check_global_declarations. */
10107 FOR_EACH_VEC_ELT (tree
, all_translation_units
, i
, t
)
10108 c_write_global_declarations_1 (BLOCK_VARS (DECL_INITIAL (t
)));
10109 c_write_global_declarations_1 (BLOCK_VARS (ext_block
));
10111 timevar_stop (TV_PHASE_DEFERRED
);
10112 timevar_start (TV_PHASE_OPT_GEN
);
10114 /* We're done parsing; proceed to optimize and emit assembly.
10115 FIXME: shouldn't be the front end's responsibility to call this. */
10116 finalize_compilation_unit ();
10118 timevar_stop (TV_PHASE_OPT_GEN
);
10119 timevar_start (TV_PHASE_DBGINFO
);
10121 /* After cgraph has had a chance to emit everything that's going to
10122 be emitted, output debug information for globals. */
10123 if (!seen_error ())
10125 timevar_push (TV_SYMOUT
);
10126 FOR_EACH_VEC_ELT (tree
, all_translation_units
, i
, t
)
10127 c_write_global_declarations_2 (BLOCK_VARS (DECL_INITIAL (t
)));
10128 c_write_global_declarations_2 (BLOCK_VARS (ext_block
));
10129 timevar_pop (TV_SYMOUT
);
10133 timevar_stop (TV_PHASE_DBGINFO
);
10136 /* Register reserved keyword WORD as qualifier for address space AS. */
10139 c_register_addr_space (const char *word
, addr_space_t as
)
10141 int rid
= RID_FIRST_ADDR_SPACE
+ as
;
10144 /* Address space qualifiers are only supported
10145 in C with GNU extensions enabled. */
10146 if (c_dialect_objc () || flag_no_asm
)
10149 id
= get_identifier (word
);
10150 C_SET_RID_CODE (id
, rid
);
10151 C_IS_RESERVED_WORD (id
) = 1;
10152 ridpointers
[rid
] = id
;
10155 #include "gt-c-c-decl.h"