1 /* Process declarations and variables for C compiler.
2 Copyright (C) 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
3 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
4 Free Software Foundation, Inc.
6 This file is part of GCC.
8 GCC is free software; you can redistribute it and/or modify it under
9 the terms of the GNU General Public License as published by the Free
10 Software Foundation; either version 3, or (at your option) any later
13 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
14 WARRANTY; without even the implied warranty of MERCHANTABILITY or
15 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING3. If not see
20 <http://www.gnu.org/licenses/>. */
22 /* Process declarations and symbol lookup for C front end.
23 Also constructs types; the standard scalar types at initialization,
24 and structure, union, array and enum types when they are declared. */
26 /* ??? not all decl nodes are given the most useful possible
27 line numbers. For example, the CONST_DECLs for enum values. */
31 #include "coretypes.h"
36 #include "tree-inline.h"
48 #include "c-family/c-common.h"
49 #include "c-family/c-objc.h"
50 #include "c-family/c-pragma.h"
52 #include "langhooks.h"
53 #include "tree-mudflap.h"
54 #include "tree-iterator.h"
55 #include "diagnostic-core.h"
56 #include "tree-dump.h"
59 #include "langhooks-def.h"
60 #include "pointer-set.h"
62 #include "c-family/c-ada-spec.h"
64 /* In grokdeclarator, distinguish syntactic contexts of declarators. */
66 { NORMAL
, /* Ordinary declaration */
67 FUNCDEF
, /* Function definition */
68 PARM
, /* Declaration of parm before function body */
69 FIELD
, /* Declaration inside struct or union */
70 TYPENAME
}; /* Typename (inside cast or sizeof) */
72 /* States indicating how grokdeclarator() should handle declspecs marked
73 with __attribute__((deprecated)). An object declared as
74 __attribute__((deprecated)) suppresses warnings of uses of other
77 enum deprecated_states
{
83 /* Nonzero if we have seen an invalid cross reference
84 to a struct, union, or enum, but not yet printed the message. */
85 tree pending_invalid_xref
;
87 /* File and line to appear in the eventual error message. */
88 location_t pending_invalid_xref_location
;
90 /* The file and line that the prototype came from if this is an
91 old-style definition; used for diagnostics in
92 store_parm_decls_oldstyle. */
94 static location_t current_function_prototype_locus
;
96 /* Whether this prototype was built-in. */
98 static bool current_function_prototype_built_in
;
100 /* The argument type information of this prototype. */
102 static tree current_function_prototype_arg_types
;
104 /* The argument information structure for the function currently being
107 static struct c_arg_info
*current_function_arg_info
;
109 /* The obstack on which parser and related data structures, which are
110 not live beyond their top-level declaration or definition, are
112 struct obstack parser_obstack
;
114 /* The current statement tree. */
116 static GTY(()) struct stmt_tree_s c_stmt_tree
;
118 /* State saving variables. */
122 /* A list of decls to be made automatically visible in each file scope. */
123 static GTY(()) tree visible_builtins
;
125 /* Set to 0 at beginning of a function definition, set to 1 if
126 a return statement that specifies a return value is seen. */
128 int current_function_returns_value
;
130 /* Set to 0 at beginning of a function definition, set to 1 if
131 a return statement with no argument is seen. */
133 int current_function_returns_null
;
135 /* Set to 0 at beginning of a function definition, set to 1 if
136 a call to a noreturn function is seen. */
138 int current_function_returns_abnormally
;
140 /* Set to nonzero by `grokdeclarator' for a function
141 whose return type is defaulted, if warnings for this are desired. */
143 static int warn_about_return_type
;
145 /* Nonzero when the current toplevel function contains a declaration
146 of a nested function which is never defined. */
148 static bool undef_nested_function
;
150 /* True means global_bindings_p should return false even if the scope stack
151 says we are in file scope. */
152 bool c_override_global_bindings_to_false
;
155 /* Each c_binding structure describes one binding of an identifier to
156 a decl. All the decls in a scope - irrespective of namespace - are
157 chained together by the ->prev field, which (as the name implies)
158 runs in reverse order. All the decls in a given namespace bound to
159 a given identifier are chained by the ->shadowed field, which runs
160 from inner to outer scopes.
162 The ->decl field usually points to a DECL node, but there are two
163 exceptions. In the namespace of type tags, the bound entity is a
164 RECORD_TYPE, UNION_TYPE, or ENUMERAL_TYPE node. If an undeclared
165 identifier is encountered, it is bound to error_mark_node to
166 suppress further errors about that identifier in the current
169 The ->u.type field stores the type of the declaration in this scope;
170 if NULL, the type is the type of the ->decl field. This is only of
171 relevance for objects with external or internal linkage which may
172 be redeclared in inner scopes, forming composite types that only
173 persist for the duration of those scopes. In the external scope,
174 this stores the composite of all the types declared for this
175 object, visible or not. The ->inner_comp field (used only at file
176 scope) stores whether an incomplete array type at file scope was
177 completed at an inner scope to an array size other than 1.
179 The ->u.label field is used for labels. It points to a structure
180 which stores additional information used for warnings.
182 The depth field is copied from the scope structure that holds this
183 decl. It is used to preserve the proper ordering of the ->shadowed
184 field (see bind()) and also for a handful of special-case checks.
185 Finally, the invisible bit is true for a decl which should be
186 ignored for purposes of normal name lookup, and the nested bit is
187 true for a decl that's been bound a second time in an inner scope;
188 in all such cases, the binding in the outer scope will have its
189 invisible bit true. */
191 struct GTY((chain_next ("%h.prev"))) c_binding
{
192 union GTY(()) { /* first so GTY desc can use decl */
193 tree
GTY((tag ("0"))) type
; /* the type in this scope */
194 struct c_label_vars
* GTY((tag ("1"))) label
; /* for warnings */
195 } GTY((desc ("TREE_CODE (%0.decl) == LABEL_DECL"))) u
;
196 tree decl
; /* the decl bound */
197 tree id
; /* the identifier it's bound to */
198 struct c_binding
*prev
; /* the previous decl in this scope */
199 struct c_binding
*shadowed
; /* the innermost decl shadowed by this one */
200 unsigned int depth
: 28; /* depth of this scope */
201 BOOL_BITFIELD invisible
: 1; /* normal lookup should ignore this binding */
202 BOOL_BITFIELD nested
: 1; /* do not set DECL_CONTEXT when popping */
203 BOOL_BITFIELD inner_comp
: 1; /* incomplete array completed in inner scope */
204 BOOL_BITFIELD in_struct
: 1; /* currently defined as struct field */
205 location_t locus
; /* location for nested bindings */
207 #define B_IN_SCOPE(b1, b2) ((b1)->depth == (b2)->depth)
208 #define B_IN_CURRENT_SCOPE(b) ((b)->depth == current_scope->depth)
209 #define B_IN_FILE_SCOPE(b) ((b)->depth == 1 /*file_scope->depth*/)
210 #define B_IN_EXTERNAL_SCOPE(b) ((b)->depth == 0 /*external_scope->depth*/)
212 #define I_SYMBOL_BINDING(node) \
213 (((struct lang_identifier *) IDENTIFIER_NODE_CHECK(node))->symbol_binding)
214 #define I_SYMBOL_DECL(node) \
215 (I_SYMBOL_BINDING(node) ? I_SYMBOL_BINDING(node)->decl : 0)
217 #define I_TAG_BINDING(node) \
218 (((struct lang_identifier *) IDENTIFIER_NODE_CHECK(node))->tag_binding)
219 #define I_TAG_DECL(node) \
220 (I_TAG_BINDING(node) ? I_TAG_BINDING(node)->decl : 0)
222 #define I_LABEL_BINDING(node) \
223 (((struct lang_identifier *) IDENTIFIER_NODE_CHECK(node))->label_binding)
224 #define I_LABEL_DECL(node) \
225 (I_LABEL_BINDING(node) ? I_LABEL_BINDING(node)->decl : 0)
227 /* Each C symbol points to three linked lists of c_binding structures.
228 These describe the values of the identifier in the three different
229 namespaces defined by the language. */
231 struct GTY(()) lang_identifier
{
232 struct c_common_identifier common_id
;
233 struct c_binding
*symbol_binding
; /* vars, funcs, constants, typedefs */
234 struct c_binding
*tag_binding
; /* struct/union/enum tags */
235 struct c_binding
*label_binding
; /* labels */
238 /* Validate c-lang.c's assumptions. */
239 extern char C_SIZEOF_STRUCT_LANG_IDENTIFIER_isnt_accurate
240 [(sizeof(struct lang_identifier
) == C_SIZEOF_STRUCT_LANG_IDENTIFIER
) ? 1 : -1];
242 /* The resulting tree type. */
244 union GTY((desc ("TREE_CODE (&%h.generic) == IDENTIFIER_NODE"),
245 chain_next ("TREE_CODE (&%h.generic) == INTEGER_TYPE ? (union lang_tree_node *) TYPE_NEXT_VARIANT (&%h.generic) : ((union lang_tree_node *) TREE_CHAIN (&%h.generic))"))) lang_tree_node
247 union tree_node
GTY ((tag ("0"),
248 desc ("tree_node_structure (&%h)")))
250 struct lang_identifier
GTY ((tag ("1"))) identifier
;
253 /* Track bindings and other things that matter for goto warnings. For
254 efficiency, we do not gather all the decls at the point of
255 definition. Instead, we point into the bindings structure. As
256 scopes are popped, we update these structures and gather the decls
257 that matter at that time. */
259 struct GTY(()) c_spot_bindings
{
260 /* The currently open scope which holds bindings defined when the
261 label was defined or the goto statement was found. */
262 struct c_scope
*scope
;
263 /* The bindings in the scope field which were defined at the point
264 of the label or goto. This lets us look at older or newer
265 bindings in the scope, as appropriate. */
266 struct c_binding
*bindings_in_scope
;
267 /* The number of statement expressions that have started since this
268 label or goto statement was defined. This is zero if we are at
269 the same statement expression level. It is positive if we are in
270 a statement expression started since this spot. It is negative
271 if this spot was in a statement expression and we have left
274 /* Whether we started in a statement expression but are no longer in
275 it. This is set to true if stmt_exprs ever goes negative. */
279 /* This structure is used to keep track of bindings seen when a goto
280 statement is defined. This is only used if we see the goto
281 statement before we see the label. */
283 struct GTY(()) c_goto_bindings
{
284 /* The location of the goto statement. */
286 /* The bindings of the goto statement. */
287 struct c_spot_bindings goto_bindings
;
290 typedef struct c_goto_bindings
*c_goto_bindings_p
;
291 DEF_VEC_P(c_goto_bindings_p
);
292 DEF_VEC_ALLOC_P(c_goto_bindings_p
,gc
);
294 /* The additional information we keep track of for a label binding.
295 These fields are updated as scopes are popped. */
297 struct GTY(()) c_label_vars
{
298 /* The shadowed c_label_vars, when one label shadows another (which
299 can only happen using a __label__ declaration). */
300 struct c_label_vars
*shadowed
;
301 /* The bindings when the label was defined. */
302 struct c_spot_bindings label_bindings
;
303 /* A list of decls that we care about: decls about which we should
304 warn if a goto branches to this label from later in the function.
305 Decls are added to this list as scopes are popped. We only add
306 the decls that matter. */
307 VEC(tree
,gc
) *decls_in_scope
;
308 /* A list of goto statements to this label. This is only used for
309 goto statements seen before the label was defined, so that we can
310 issue appropriate warnings for them. */
311 VEC(c_goto_bindings_p
,gc
) *gotos
;
314 /* Each c_scope structure describes the complete contents of one
315 scope. Four scopes are distinguished specially: the innermost or
316 current scope, the innermost function scope, the file scope (always
317 the second to outermost) and the outermost or external scope.
319 Most declarations are recorded in the current scope.
321 All normal label declarations are recorded in the innermost
322 function scope, as are bindings of undeclared identifiers to
323 error_mark_node. (GCC permits nested functions as an extension,
324 hence the 'innermost' qualifier.) Explicitly declared labels
325 (using the __label__ extension) appear in the current scope.
327 Being in the file scope (current_scope == file_scope) causes
328 special behavior in several places below. Also, under some
329 conditions the Objective-C front end records declarations in the
330 file scope even though that isn't the current scope.
332 All declarations with external linkage are recorded in the external
333 scope, even if they aren't visible there; this models the fact that
334 such declarations are visible to the entire program, and (with a
335 bit of cleverness, see pushdecl) allows diagnosis of some violations
336 of C99 6.2.2p7 and 6.2.7p2:
338 If, within the same translation unit, the same identifier appears
339 with both internal and external linkage, the behavior is
342 All declarations that refer to the same object or function shall
343 have compatible type; otherwise, the behavior is undefined.
345 Initially only the built-in declarations, which describe compiler
346 intrinsic functions plus a subset of the standard library, are in
349 The order of the blocks list matters, and it is frequently appended
350 to. To avoid having to walk all the way to the end of the list on
351 each insertion, or reverse the list later, we maintain a pointer to
352 the last list entry. (FIXME: It should be feasible to use a reversed
355 The bindings list is strictly in reverse order of declarations;
356 pop_scope relies on this. */
359 struct GTY((chain_next ("%h.outer"))) c_scope
{
360 /* The scope containing this one. */
361 struct c_scope
*outer
;
363 /* The next outermost function scope. */
364 struct c_scope
*outer_function
;
366 /* All bindings in this scope. */
367 struct c_binding
*bindings
;
369 /* For each scope (except the global one), a chain of BLOCK nodes
370 for all the scopes that were entered and exited one level down. */
374 /* The depth of this scope. Used to keep the ->shadowed chain of
375 bindings sorted innermost to outermost. */
376 unsigned int depth
: 28;
378 /* True if we are currently filling this scope with parameter
380 BOOL_BITFIELD parm_flag
: 1;
382 /* True if we saw [*] in this scope. Used to give an error messages
383 if these appears in a function definition. */
384 BOOL_BITFIELD had_vla_unspec
: 1;
386 /* True if we already complained about forward parameter decls
387 in this scope. This prevents double warnings on
388 foo (int a; int b; ...) */
389 BOOL_BITFIELD warned_forward_parm_decls
: 1;
391 /* True if this is the outermost block scope of a function body.
392 This scope contains the parameters, the local variables declared
393 in the outermost block, and all the labels (except those in
394 nested functions, or declared at block scope with __label__). */
395 BOOL_BITFIELD function_body
: 1;
397 /* True means make a BLOCK for this scope no matter what. */
398 BOOL_BITFIELD keep
: 1;
400 /* True means that an unsuffixed float constant is _Decimal64. */
401 BOOL_BITFIELD float_const_decimal64
: 1;
403 /* True if this scope has any label bindings. This is used to speed
404 up searching for labels when popping scopes, particularly since
405 labels are normally only found at function scope. */
406 BOOL_BITFIELD has_label_bindings
: 1;
409 /* The scope currently in effect. */
411 static GTY(()) struct c_scope
*current_scope
;
413 /* The innermost function scope. Ordinary (not explicitly declared)
414 labels, bindings to error_mark_node, and the lazily-created
415 bindings of __func__ and its friends get this scope. */
417 static GTY(()) struct c_scope
*current_function_scope
;
419 /* The C file scope. This is reset for each input translation unit. */
421 static GTY(()) struct c_scope
*file_scope
;
423 /* The outermost scope. This is used for all declarations with
424 external linkage, and only these, hence the name. */
426 static GTY(()) struct c_scope
*external_scope
;
428 /* A chain of c_scope structures awaiting reuse. */
430 static GTY((deletable
)) struct c_scope
*scope_freelist
;
432 /* A chain of c_binding structures awaiting reuse. */
434 static GTY((deletable
)) struct c_binding
*binding_freelist
;
436 /* Append VAR to LIST in scope SCOPE. */
437 #define SCOPE_LIST_APPEND(scope, list, decl) do { \
438 struct c_scope *s_ = (scope); \
440 if (s_->list##_last) \
441 BLOCK_CHAIN (s_->list##_last) = d_; \
444 s_->list##_last = d_; \
447 /* Concatenate FROM in scope FSCOPE onto TO in scope TSCOPE. */
448 #define SCOPE_LIST_CONCAT(tscope, to, fscope, from) do { \
449 struct c_scope *t_ = (tscope); \
450 struct c_scope *f_ = (fscope); \
452 BLOCK_CHAIN (t_->to##_last) = f_->from; \
455 t_->to##_last = f_->from##_last; \
458 /* A c_inline_static structure stores details of a static identifier
459 referenced in a definition of a function that may be an inline
460 definition if no subsequent declaration of that function uses
461 "extern" or does not use "inline". */
463 struct GTY((chain_next ("%h.next"))) c_inline_static
{
464 /* The location for a diagnostic. */
467 /* The function that may be an inline definition. */
470 /* The object or function referenced. */
473 /* What sort of reference this is. */
474 enum c_inline_static_type type
;
476 /* The next such structure or NULL. */
477 struct c_inline_static
*next
;
480 /* List of static identifiers used or referenced in functions that may
481 be inline definitions. */
482 static GTY(()) struct c_inline_static
*c_inline_statics
;
484 /* True means unconditionally make a BLOCK for the next scope pushed. */
486 static bool keep_next_level_flag
;
488 /* True means the next call to push_scope will be the outermost scope
489 of a function body, so do not push a new scope, merely cease
490 expecting parameter decls. */
492 static bool next_is_function_body
;
494 /* A VEC of pointers to c_binding structures. */
496 typedef struct c_binding
*c_binding_ptr
;
497 DEF_VEC_P(c_binding_ptr
);
498 DEF_VEC_ALLOC_P(c_binding_ptr
,heap
);
500 /* Information that we keep for a struct or union while it is being
503 struct c_struct_parse_info
505 /* If warn_cxx_compat, a list of types defined within this
507 VEC(tree
,heap
) *struct_types
;
508 /* If warn_cxx_compat, a list of field names which have bindings,
509 and which are defined in this struct, but which are not defined
510 in any enclosing struct. This is used to clear the in_struct
511 field of the c_bindings structure. */
512 VEC(c_binding_ptr
,heap
) *fields
;
513 /* If warn_cxx_compat, a list of typedef names used when defining
514 fields in this struct. */
515 VEC(tree
,heap
) *typedefs_seen
;
518 /* Information for the struct or union currently being parsed, or
519 NULL if not parsing a struct or union. */
520 static struct c_struct_parse_info
*struct_parse_info
;
522 /* Forward declarations. */
523 static tree
lookup_name_in_scope (tree
, struct c_scope
*);
524 static tree
c_make_fname_decl (location_t
, tree
, int);
525 static tree
grokdeclarator (const struct c_declarator
*,
526 struct c_declspecs
*,
527 enum decl_context
, bool, tree
*, tree
*, tree
*,
528 bool *, enum deprecated_states
);
529 static tree
grokparms (struct c_arg_info
*, bool);
530 static void layout_array_type (tree
);
532 /* T is a statement. Add it to the statement-tree. This is the
533 C/ObjC version--C++ has a slightly different version of this
539 enum tree_code code
= TREE_CODE (t
);
541 if (CAN_HAVE_LOCATION_P (t
) && code
!= LABEL_EXPR
)
543 if (!EXPR_HAS_LOCATION (t
))
544 SET_EXPR_LOCATION (t
, input_location
);
547 if (code
== LABEL_EXPR
|| code
== CASE_LABEL_EXPR
)
548 STATEMENT_LIST_HAS_LABEL (cur_stmt_list
) = 1;
550 /* Add T to the statement-tree. Non-side-effect statements need to be
551 recorded during statement expressions. */
552 append_to_statement_list_force (t
, &cur_stmt_list
);
559 c_print_identifier (FILE *file
, tree node
, int indent
)
561 print_node (file
, "symbol", I_SYMBOL_DECL (node
), indent
+ 4);
562 print_node (file
, "tag", I_TAG_DECL (node
), indent
+ 4);
563 print_node (file
, "label", I_LABEL_DECL (node
), indent
+ 4);
564 if (C_IS_RESERVED_WORD (node
) && C_RID_CODE (node
) != RID_CXX_COMPAT_WARN
)
566 tree rid
= ridpointers
[C_RID_CODE (node
)];
567 indent_to (file
, indent
+ 4);
568 fprintf (file
, "rid " HOST_PTR_PRINTF
" \"%s\"",
569 (void *) rid
, IDENTIFIER_POINTER (rid
));
573 /* Establish a binding between NAME, an IDENTIFIER_NODE, and DECL,
574 which may be any of several kinds of DECL or TYPE or error_mark_node,
575 in the scope SCOPE. */
577 bind (tree name
, tree decl
, struct c_scope
*scope
, bool invisible
,
578 bool nested
, location_t locus
)
580 struct c_binding
*b
, **here
;
582 if (binding_freelist
)
584 b
= binding_freelist
;
585 binding_freelist
= b
->prev
;
588 b
= ggc_alloc_c_binding ();
593 b
->depth
= scope
->depth
;
594 b
->invisible
= invisible
;
602 b
->prev
= scope
->bindings
;
608 switch (TREE_CODE (decl
))
610 case LABEL_DECL
: here
= &I_LABEL_BINDING (name
); break;
613 case RECORD_TYPE
: here
= &I_TAG_BINDING (name
); break;
619 case ERROR_MARK
: here
= &I_SYMBOL_BINDING (name
); break;
625 /* Locate the appropriate place in the chain of shadowed decls
626 to insert this binding. Normally, scope == current_scope and
627 this does nothing. */
628 while (*here
&& (*here
)->depth
> scope
->depth
)
629 here
= &(*here
)->shadowed
;
635 /* Clear the binding structure B, stick it on the binding_freelist,
636 and return the former value of b->prev. This is used by pop_scope
637 and get_parm_info to iterate destructively over all the bindings
638 from a given scope. */
639 static struct c_binding
*
640 free_binding_and_advance (struct c_binding
*b
)
642 struct c_binding
*prev
= b
->prev
;
644 memset (b
, 0, sizeof (struct c_binding
));
645 b
->prev
= binding_freelist
;
646 binding_freelist
= b
;
651 /* Bind a label. Like bind, but skip fields which aren't used for
652 labels, and add the LABEL_VARS value. */
654 bind_label (tree name
, tree label
, struct c_scope
*scope
,
655 struct c_label_vars
*label_vars
)
659 bind (name
, label
, scope
, /*invisible=*/false, /*nested=*/false,
662 scope
->has_label_bindings
= true;
665 gcc_assert (b
->decl
== label
);
666 label_vars
->shadowed
= b
->u
.label
;
667 b
->u
.label
= label_vars
;
670 /* Hook called at end of compilation to assume 1 elt
671 for a file-scope tentative array defn that wasn't complete before. */
674 c_finish_incomplete_decl (tree decl
)
676 if (TREE_CODE (decl
) == VAR_DECL
)
678 tree type
= TREE_TYPE (decl
);
679 if (type
!= error_mark_node
680 && TREE_CODE (type
) == ARRAY_TYPE
681 && !DECL_EXTERNAL (decl
)
682 && TYPE_DOMAIN (type
) == 0)
684 warning_at (DECL_SOURCE_LOCATION (decl
),
685 0, "array %q+D assumed to have one element", decl
);
687 complete_array_type (&TREE_TYPE (decl
), NULL_TREE
, true);
689 layout_decl (decl
, 0);
694 /* Record that inline function FUNC contains a reference (location
695 LOC) to static DECL (file-scope or function-local according to
699 record_inline_static (location_t loc
, tree func
, tree decl
,
700 enum c_inline_static_type type
)
702 struct c_inline_static
*csi
= ggc_alloc_c_inline_static ();
704 csi
->function
= func
;
705 csi
->static_decl
= decl
;
707 csi
->next
= c_inline_statics
;
708 c_inline_statics
= csi
;
711 /* Check for references to static declarations in inline functions at
712 the end of the translation unit and diagnose them if the functions
713 are still inline definitions. */
716 check_inline_statics (void)
718 struct c_inline_static
*csi
;
719 for (csi
= c_inline_statics
; csi
; csi
= csi
->next
)
721 if (DECL_EXTERNAL (csi
->function
))
725 pedwarn (csi
->location
, 0,
726 "%qD is static but used in inline function %qD "
727 "which is not static", csi
->static_decl
, csi
->function
);
730 pedwarn (csi
->location
, 0,
731 "%q+D is static but declared in inline function %qD "
732 "which is not static", csi
->static_decl
, csi
->function
);
738 c_inline_statics
= NULL
;
741 /* Fill in a c_spot_bindings structure. If DEFINING is true, set it
742 for the current state, otherwise set it to uninitialized. */
745 set_spot_bindings (struct c_spot_bindings
*p
, bool defining
)
749 p
->scope
= current_scope
;
750 p
->bindings_in_scope
= current_scope
->bindings
;
755 p
->bindings_in_scope
= NULL
;
758 p
->left_stmt_expr
= false;
761 /* Return true if we will want to say something if a goto statement
765 decl_jump_unsafe (tree decl
)
767 if (decl
== error_mark_node
|| TREE_TYPE (decl
) == error_mark_node
)
770 /* Always warn about crossing variably modified types. */
771 if ((TREE_CODE (decl
) == VAR_DECL
|| TREE_CODE (decl
) == TYPE_DECL
)
772 && variably_modified_type_p (TREE_TYPE (decl
), NULL_TREE
))
775 /* Otherwise, only warn if -Wgoto-misses-init and this is an
776 initialized automatic decl. */
777 if (warn_jump_misses_init
778 && TREE_CODE (decl
) == VAR_DECL
779 && !TREE_STATIC (decl
)
780 && DECL_INITIAL (decl
) != NULL_TREE
)
786 /* Update spot bindings P as we pop out of SCOPE. Return true if we
787 should push decls for a label. */
790 update_spot_bindings (struct c_scope
*scope
, struct c_spot_bindings
*p
)
792 if (p
->scope
!= scope
)
794 /* This label or goto is defined in some other scope, or it is a
795 label which is not yet defined. There is nothing to
800 /* Adjust the spot bindings to refer to the bindings already defined
801 in the enclosing scope. */
802 p
->scope
= scope
->outer
;
803 p
->bindings_in_scope
= p
->scope
->bindings
;
808 /* The Objective-C front-end often needs to determine the current scope. */
811 objc_get_current_scope (void)
813 return current_scope
;
816 /* The following function is used only by Objective-C. It needs to live here
817 because it accesses the innards of c_scope. */
820 objc_mark_locals_volatile (void *enclosing_blk
)
822 struct c_scope
*scope
;
825 for (scope
= current_scope
;
826 scope
&& scope
!= enclosing_blk
;
827 scope
= scope
->outer
)
829 for (b
= scope
->bindings
; b
; b
= b
->prev
)
830 objc_volatilize_decl (b
->decl
);
832 /* Do not climb up past the current function. */
833 if (scope
->function_body
)
838 /* Nonzero if we are currently in file scope. */
841 global_bindings_p (void)
843 return (current_scope
== file_scope
&& !c_override_global_bindings_to_false
849 keep_next_level (void)
851 keep_next_level_flag
= true;
854 /* Set the flag for the FLOAT_CONST_DECIMAL64 pragma being ON. */
857 set_float_const_decimal64 (void)
859 current_scope
->float_const_decimal64
= true;
862 /* Clear the flag for the FLOAT_CONST_DECIMAL64 pragma. */
865 clear_float_const_decimal64 (void)
867 current_scope
->float_const_decimal64
= false;
870 /* Return nonzero if an unsuffixed float constant is _Decimal64. */
873 float_const_decimal64_p (void)
875 return current_scope
->float_const_decimal64
;
878 /* Identify this scope as currently being filled with parameters. */
881 declare_parm_level (void)
883 current_scope
->parm_flag
= true;
889 if (next_is_function_body
)
891 /* This is the transition from the parameters to the top level
892 of the function body. These are the same scope
893 (C99 6.2.1p4,6) so we do not push another scope structure.
894 next_is_function_body is set only by store_parm_decls, which
895 in turn is called when and only when we are about to
896 encounter the opening curly brace for the function body.
898 The outermost block of a function always gets a BLOCK node,
899 because the debugging output routines expect that each
900 function has at least one BLOCK. */
901 current_scope
->parm_flag
= false;
902 current_scope
->function_body
= true;
903 current_scope
->keep
= true;
904 current_scope
->outer_function
= current_function_scope
;
905 current_function_scope
= current_scope
;
907 keep_next_level_flag
= false;
908 next_is_function_body
= false;
910 /* The FLOAT_CONST_DECIMAL64 pragma applies to nested scopes. */
911 if (current_scope
->outer
)
912 current_scope
->float_const_decimal64
913 = current_scope
->outer
->float_const_decimal64
;
915 current_scope
->float_const_decimal64
= false;
919 struct c_scope
*scope
;
922 scope
= scope_freelist
;
923 scope_freelist
= scope
->outer
;
926 scope
= ggc_alloc_cleared_c_scope ();
928 /* The FLOAT_CONST_DECIMAL64 pragma applies to nested scopes. */
930 scope
->float_const_decimal64
= current_scope
->float_const_decimal64
;
932 scope
->float_const_decimal64
= false;
934 scope
->keep
= keep_next_level_flag
;
935 scope
->outer
= current_scope
;
936 scope
->depth
= current_scope
? (current_scope
->depth
+ 1) : 0;
938 /* Check for scope depth overflow. Unlikely (2^28 == 268,435,456) but
940 if (current_scope
&& scope
->depth
== 0)
943 sorry ("GCC supports only %u nested scopes", scope
->depth
);
946 current_scope
= scope
;
947 keep_next_level_flag
= false;
951 /* This is called when we are leaving SCOPE. For each label defined
952 in SCOPE, add any appropriate decls to its decls_in_scope fields.
953 These are the decls whose initialization will be skipped by a goto
954 later in the function. */
957 update_label_decls (struct c_scope
*scope
)
964 if (s
->has_label_bindings
)
968 for (b
= s
->bindings
; b
!= NULL
; b
= b
->prev
)
970 struct c_label_vars
*label_vars
;
971 struct c_binding
*b1
;
973 struct c_goto_bindings
*g
;
975 if (TREE_CODE (b
->decl
) != LABEL_DECL
)
977 label_vars
= b
->u
.label
;
979 b1
= label_vars
->label_bindings
.bindings_in_scope
;
980 if (update_spot_bindings (scope
, &label_vars
->label_bindings
))
982 /* This label is defined in this scope. */
983 for (; b1
!= NULL
; b1
= b1
->prev
)
985 /* A goto from later in the function to this
986 label will never see the initialization of
987 B1, if any. Save it to issue a warning if
989 if (decl_jump_unsafe (b1
->decl
))
990 VEC_safe_push (tree
, gc
, label_vars
->decls_in_scope
,
995 /* Update the bindings of any goto statements associated
997 FOR_EACH_VEC_ELT (c_goto_bindings_p
, label_vars
->gotos
, ix
, g
)
998 update_spot_bindings (scope
, &g
->goto_bindings
);
1002 /* Don't search beyond the current function. */
1003 if (s
== current_function_scope
)
1010 /* Set the TYPE_CONTEXT of all of TYPE's variants to CONTEXT. */
1013 set_type_context (tree type
, tree context
)
1015 for (type
= TYPE_MAIN_VARIANT (type
); type
;
1016 type
= TYPE_NEXT_VARIANT (type
))
1017 TYPE_CONTEXT (type
) = context
;
1020 /* Exit a scope. Restore the state of the identifier-decl mappings
1021 that were in effect when this scope was entered. Return a BLOCK
1022 node containing all the DECLs in this scope that are of interest
1023 to debug info generation. */
1028 struct c_scope
*scope
= current_scope
;
1029 tree block
, context
, p
;
1030 struct c_binding
*b
;
1032 bool functionbody
= scope
->function_body
;
1033 bool keep
= functionbody
|| scope
->keep
|| scope
->bindings
;
1035 update_label_decls (scope
);
1037 /* If appropriate, create a BLOCK to record the decls for the life
1038 of this function. */
1042 block
= make_node (BLOCK
);
1043 BLOCK_SUBBLOCKS (block
) = scope
->blocks
;
1044 TREE_USED (block
) = 1;
1046 /* In each subblock, record that this is its superior. */
1047 for (p
= scope
->blocks
; p
; p
= BLOCK_CHAIN (p
))
1048 BLOCK_SUPERCONTEXT (p
) = block
;
1050 BLOCK_VARS (block
) = 0;
1053 /* The TYPE_CONTEXTs for all of the tagged types belonging to this
1054 scope must be set so that they point to the appropriate
1055 construct, i.e. either to the current FUNCTION_DECL node, or
1056 else to the BLOCK node we just constructed.
1058 Note that for tagged types whose scope is just the formal
1059 parameter list for some function type specification, we can't
1060 properly set their TYPE_CONTEXTs here, because we don't have a
1061 pointer to the appropriate FUNCTION_TYPE node readily available
1062 to us. For those cases, the TYPE_CONTEXTs of the relevant tagged
1063 type nodes get set in `grokdeclarator' as soon as we have created
1064 the FUNCTION_TYPE node which will represent the "scope" for these
1065 "parameter list local" tagged types. */
1066 if (scope
->function_body
)
1067 context
= current_function_decl
;
1068 else if (scope
== file_scope
)
1070 tree file_decl
= build_translation_unit_decl (NULL_TREE
);
1071 context
= file_decl
;
1076 /* Clear all bindings in this scope. */
1077 for (b
= scope
->bindings
; b
; b
= free_binding_and_advance (b
))
1080 switch (TREE_CODE (p
))
1083 /* Warnings for unused labels, errors for undefined labels. */
1084 if (TREE_USED (p
) && !DECL_INITIAL (p
))
1086 error ("label %q+D used but not defined", p
);
1087 DECL_INITIAL (p
) = error_mark_node
;
1090 warn_for_unused_label (p
);
1092 /* Labels go in BLOCK_VARS. */
1093 DECL_CHAIN (p
) = BLOCK_VARS (block
);
1094 BLOCK_VARS (block
) = p
;
1095 gcc_assert (I_LABEL_BINDING (b
->id
) == b
);
1096 I_LABEL_BINDING (b
->id
) = b
->shadowed
;
1098 /* Also pop back to the shadowed label_vars. */
1099 release_tree_vector (b
->u
.label
->decls_in_scope
);
1100 b
->u
.label
= b
->u
.label
->shadowed
;
1106 set_type_context (p
, context
);
1108 /* Types may not have tag-names, in which case the type
1109 appears in the bindings list with b->id NULL. */
1112 gcc_assert (I_TAG_BINDING (b
->id
) == b
);
1113 I_TAG_BINDING (b
->id
) = b
->shadowed
;
1118 /* Propagate TREE_ADDRESSABLE from nested functions to their
1119 containing functions. */
1120 if (!TREE_ASM_WRITTEN (p
)
1121 && DECL_INITIAL (p
) != 0
1122 && TREE_ADDRESSABLE (p
)
1123 && DECL_ABSTRACT_ORIGIN (p
) != 0
1124 && DECL_ABSTRACT_ORIGIN (p
) != p
)
1125 TREE_ADDRESSABLE (DECL_ABSTRACT_ORIGIN (p
)) = 1;
1126 if (!DECL_EXTERNAL (p
)
1127 && !DECL_INITIAL (p
)
1128 && scope
!= file_scope
1129 && scope
!= external_scope
)
1131 error ("nested function %q+D declared but never defined", p
);
1132 undef_nested_function
= true;
1134 else if (DECL_DECLARED_INLINE_P (p
)
1136 && !DECL_INITIAL (p
))
1138 /* C99 6.7.4p6: "a function with external linkage... declared
1139 with an inline function specifier ... shall also be defined
1140 in the same translation unit." */
1141 if (!flag_gnu89_inline
)
1142 pedwarn (input_location
, 0,
1143 "inline function %q+D declared but never defined", p
);
1144 DECL_EXTERNAL (p
) = 1;
1150 /* Warnings for unused variables. */
1151 if ((!TREE_USED (p
) || !DECL_READ_P (p
))
1152 && !TREE_NO_WARNING (p
)
1153 && !DECL_IN_SYSTEM_HEADER (p
)
1155 && !DECL_ARTIFICIAL (p
)
1156 && scope
!= file_scope
1157 && scope
!= external_scope
)
1160 warning (OPT_Wunused_variable
, "unused variable %q+D", p
);
1161 else if (DECL_CONTEXT (p
) == current_function_decl
)
1162 warning_at (DECL_SOURCE_LOCATION (p
),
1163 OPT_Wunused_but_set_variable
,
1164 "variable %qD set but not used", p
);
1169 error ("type of array %q+D completed incompatibly with"
1170 " implicit initialization", p
);
1177 /* All of these go in BLOCK_VARS, but only if this is the
1178 binding in the home scope. */
1181 DECL_CHAIN (p
) = BLOCK_VARS (block
);
1182 BLOCK_VARS (block
) = p
;
1184 else if (VAR_OR_FUNCTION_DECL_P (p
))
1186 /* For block local externs add a special
1187 DECL_EXTERNAL decl for debug info generation. */
1188 tree extp
= copy_node (p
);
1190 DECL_EXTERNAL (extp
) = 1;
1191 TREE_STATIC (extp
) = 0;
1192 TREE_PUBLIC (extp
) = 1;
1193 DECL_INITIAL (extp
) = NULL_TREE
;
1194 DECL_LANG_SPECIFIC (extp
) = NULL
;
1195 DECL_CONTEXT (extp
) = current_function_decl
;
1196 if (TREE_CODE (p
) == FUNCTION_DECL
)
1198 DECL_RESULT (extp
) = NULL_TREE
;
1199 DECL_SAVED_TREE (extp
) = NULL_TREE
;
1200 DECL_STRUCT_FUNCTION (extp
) = NULL
;
1202 if (b
->locus
!= UNKNOWN_LOCATION
)
1203 DECL_SOURCE_LOCATION (extp
) = b
->locus
;
1204 DECL_CHAIN (extp
) = BLOCK_VARS (block
);
1205 BLOCK_VARS (block
) = extp
;
1207 /* If this is the file scope set DECL_CONTEXT of each decl to
1208 the TRANSLATION_UNIT_DECL. This makes same_translation_unit_p
1210 if (scope
== file_scope
)
1212 DECL_CONTEXT (p
) = context
;
1213 if (TREE_CODE (p
) == TYPE_DECL
1214 && TREE_TYPE (p
) != error_mark_node
)
1215 set_type_context (TREE_TYPE (p
), context
);
1219 /* Parameters go in DECL_ARGUMENTS, not BLOCK_VARS, and have
1220 already been put there by store_parm_decls. Unused-
1221 parameter warnings are handled by function.c.
1222 error_mark_node obviously does not go in BLOCK_VARS and
1223 does not get unused-variable warnings. */
1226 /* It is possible for a decl not to have a name. We get
1227 here with b->id NULL in this case. */
1230 gcc_assert (I_SYMBOL_BINDING (b
->id
) == b
);
1231 I_SYMBOL_BINDING (b
->id
) = b
->shadowed
;
1232 if (b
->shadowed
&& b
->shadowed
->u
.type
)
1233 TREE_TYPE (b
->shadowed
->decl
) = b
->shadowed
->u
.type
;
1243 /* Dispose of the block that we just made inside some higher level. */
1244 if ((scope
->function_body
|| scope
== file_scope
) && context
)
1246 DECL_INITIAL (context
) = block
;
1247 BLOCK_SUPERCONTEXT (block
) = context
;
1249 else if (scope
->outer
)
1252 SCOPE_LIST_APPEND (scope
->outer
, blocks
, block
);
1253 /* If we did not make a block for the scope just exited, any
1254 blocks made for inner scopes must be carried forward so they
1255 will later become subblocks of something else. */
1256 else if (scope
->blocks
)
1257 SCOPE_LIST_CONCAT (scope
->outer
, blocks
, scope
, blocks
);
1260 /* Pop the current scope, and free the structure for reuse. */
1261 current_scope
= scope
->outer
;
1262 if (scope
->function_body
)
1263 current_function_scope
= scope
->outer_function
;
1265 memset (scope
, 0, sizeof (struct c_scope
));
1266 scope
->outer
= scope_freelist
;
1267 scope_freelist
= scope
;
1273 push_file_scope (void)
1281 file_scope
= current_scope
;
1283 start_fname_decls ();
1285 for (decl
= visible_builtins
; decl
; decl
= DECL_CHAIN (decl
))
1286 bind (DECL_NAME (decl
), decl
, file_scope
,
1287 /*invisible=*/false, /*nested=*/true, DECL_SOURCE_LOCATION (decl
));
1291 pop_file_scope (void)
1293 /* In case there were missing closebraces, get us back to the global
1295 while (current_scope
!= file_scope
)
1298 /* __FUNCTION__ is defined at file scope (""). This
1299 call may not be necessary as my tests indicate it
1300 still works without it. */
1301 finish_fname_decls ();
1303 check_inline_statics ();
1305 /* This is the point to write out a PCH if we're doing that.
1306 In that case we do not want to do anything else. */
1309 c_common_write_pch ();
1313 /* Pop off the file scope and close this translation unit. */
1317 maybe_apply_pending_pragma_weaks ();
1320 /* Adjust the bindings for the start of a statement expression. */
1323 c_bindings_start_stmt_expr (struct c_spot_bindings
* switch_bindings
)
1325 struct c_scope
*scope
;
1327 for (scope
= current_scope
; scope
!= NULL
; scope
= scope
->outer
)
1329 struct c_binding
*b
;
1331 if (!scope
->has_label_bindings
)
1334 for (b
= scope
->bindings
; b
!= NULL
; b
= b
->prev
)
1336 struct c_label_vars
*label_vars
;
1338 struct c_goto_bindings
*g
;
1340 if (TREE_CODE (b
->decl
) != LABEL_DECL
)
1342 label_vars
= b
->u
.label
;
1343 ++label_vars
->label_bindings
.stmt_exprs
;
1344 FOR_EACH_VEC_ELT (c_goto_bindings_p
, label_vars
->gotos
, ix
, g
)
1345 ++g
->goto_bindings
.stmt_exprs
;
1349 if (switch_bindings
!= NULL
)
1350 ++switch_bindings
->stmt_exprs
;
1353 /* Adjust the bindings for the end of a statement expression. */
1356 c_bindings_end_stmt_expr (struct c_spot_bindings
*switch_bindings
)
1358 struct c_scope
*scope
;
1360 for (scope
= current_scope
; scope
!= NULL
; scope
= scope
->outer
)
1362 struct c_binding
*b
;
1364 if (!scope
->has_label_bindings
)
1367 for (b
= scope
->bindings
; b
!= NULL
; b
= b
->prev
)
1369 struct c_label_vars
*label_vars
;
1371 struct c_goto_bindings
*g
;
1373 if (TREE_CODE (b
->decl
) != LABEL_DECL
)
1375 label_vars
= b
->u
.label
;
1376 --label_vars
->label_bindings
.stmt_exprs
;
1377 if (label_vars
->label_bindings
.stmt_exprs
< 0)
1379 label_vars
->label_bindings
.left_stmt_expr
= true;
1380 label_vars
->label_bindings
.stmt_exprs
= 0;
1382 FOR_EACH_VEC_ELT (c_goto_bindings_p
, label_vars
->gotos
, ix
, g
)
1384 --g
->goto_bindings
.stmt_exprs
;
1385 if (g
->goto_bindings
.stmt_exprs
< 0)
1387 g
->goto_bindings
.left_stmt_expr
= true;
1388 g
->goto_bindings
.stmt_exprs
= 0;
1394 if (switch_bindings
!= NULL
)
1396 --switch_bindings
->stmt_exprs
;
1397 gcc_assert (switch_bindings
->stmt_exprs
>= 0);
1401 /* Push a definition or a declaration of struct, union or enum tag "name".
1402 "type" should be the type node.
1403 We assume that the tag "name" is not already defined, and has a location
1406 Note that the definition may really be just a forward reference.
1407 In that case, the TYPE_SIZE will be zero. */
1410 pushtag (location_t loc
, tree name
, tree type
)
1412 /* Record the identifier as the type's name if it has none. */
1413 if (name
&& !TYPE_NAME (type
))
1414 TYPE_NAME (type
) = name
;
1415 bind (name
, type
, current_scope
, /*invisible=*/false, /*nested=*/false, loc
);
1417 /* Create a fake NULL-named TYPE_DECL node whose TREE_TYPE will be the
1418 tagged type we just added to the current scope. This fake
1419 NULL-named TYPE_DECL node helps dwarfout.c to know when it needs
1420 to output a representation of a tagged type, and it also gives
1421 us a convenient place to record the "scope start" address for the
1424 TYPE_STUB_DECL (type
) = pushdecl (build_decl (loc
,
1425 TYPE_DECL
, NULL_TREE
, type
));
1427 /* An approximation for now, so we can tell this is a function-scope tag.
1428 This will be updated in pop_scope. */
1429 TYPE_CONTEXT (type
) = DECL_CONTEXT (TYPE_STUB_DECL (type
));
1431 if (warn_cxx_compat
&& name
!= NULL_TREE
)
1433 struct c_binding
*b
= I_SYMBOL_BINDING (name
);
1436 && b
->decl
!= NULL_TREE
1437 && TREE_CODE (b
->decl
) == TYPE_DECL
1438 && (B_IN_CURRENT_SCOPE (b
)
1439 || (current_scope
== file_scope
&& B_IN_EXTERNAL_SCOPE (b
)))
1440 && (TYPE_MAIN_VARIANT (TREE_TYPE (b
->decl
))
1441 != TYPE_MAIN_VARIANT (type
)))
1443 warning_at (loc
, OPT_Wc___compat
,
1444 ("using %qD as both a typedef and a tag is "
1447 if (b
->locus
!= UNKNOWN_LOCATION
)
1448 inform (b
->locus
, "originally defined here");
1453 /* Subroutine of compare_decls. Allow harmless mismatches in return
1454 and argument types provided that the type modes match. This function
1455 return a unified type given a suitable match, and 0 otherwise. */
1458 match_builtin_function_types (tree newtype
, tree oldtype
)
1460 tree newrettype
, oldrettype
;
1461 tree newargs
, oldargs
;
1462 tree trytype
, tryargs
;
1464 /* Accept the return type of the new declaration if same modes. */
1465 oldrettype
= TREE_TYPE (oldtype
);
1466 newrettype
= TREE_TYPE (newtype
);
1468 if (TYPE_MODE (oldrettype
) != TYPE_MODE (newrettype
))
1471 oldargs
= TYPE_ARG_TYPES (oldtype
);
1472 newargs
= TYPE_ARG_TYPES (newtype
);
1475 while (oldargs
|| newargs
)
1479 || !TREE_VALUE (oldargs
)
1480 || !TREE_VALUE (newargs
)
1481 || TYPE_MODE (TREE_VALUE (oldargs
))
1482 != TYPE_MODE (TREE_VALUE (newargs
)))
1485 oldargs
= TREE_CHAIN (oldargs
);
1486 newargs
= TREE_CHAIN (newargs
);
1489 trytype
= build_function_type (newrettype
, tryargs
);
1490 return build_type_attribute_variant (trytype
, TYPE_ATTRIBUTES (oldtype
));
1493 /* Subroutine of diagnose_mismatched_decls. Check for function type
1494 mismatch involving an empty arglist vs a nonempty one and give clearer
1497 diagnose_arglist_conflict (tree newdecl
, tree olddecl
,
1498 tree newtype
, tree oldtype
)
1502 if (TREE_CODE (olddecl
) != FUNCTION_DECL
1503 || !comptypes (TREE_TYPE (oldtype
), TREE_TYPE (newtype
))
1504 || !((TYPE_ARG_TYPES (oldtype
) == 0 && DECL_INITIAL (olddecl
) == 0)
1506 (TYPE_ARG_TYPES (newtype
) == 0 && DECL_INITIAL (newdecl
) == 0)))
1509 t
= TYPE_ARG_TYPES (oldtype
);
1511 t
= TYPE_ARG_TYPES (newtype
);
1512 for (; t
; t
= TREE_CHAIN (t
))
1514 tree type
= TREE_VALUE (t
);
1516 if (TREE_CHAIN (t
) == 0
1517 && TYPE_MAIN_VARIANT (type
) != void_type_node
)
1519 inform (input_location
, "a parameter list with an ellipsis can%'t match "
1520 "an empty parameter name list declaration");
1524 if (c_type_promotes_to (type
) != type
)
1526 inform (input_location
, "an argument type that has a default promotion can%'t match "
1527 "an empty parameter name list declaration");
1533 /* Another subroutine of diagnose_mismatched_decls. OLDDECL is an
1534 old-style function definition, NEWDECL is a prototype declaration.
1535 Diagnose inconsistencies in the argument list. Returns TRUE if
1536 the prototype is compatible, FALSE if not. */
1538 validate_proto_after_old_defn (tree newdecl
, tree newtype
, tree oldtype
)
1540 tree newargs
, oldargs
;
1543 #define END_OF_ARGLIST(t) ((t) == void_type_node)
1545 oldargs
= TYPE_ACTUAL_ARG_TYPES (oldtype
);
1546 newargs
= TYPE_ARG_TYPES (newtype
);
1551 tree oldargtype
= TREE_VALUE (oldargs
);
1552 tree newargtype
= TREE_VALUE (newargs
);
1554 if (oldargtype
== error_mark_node
|| newargtype
== error_mark_node
)
1557 oldargtype
= TYPE_MAIN_VARIANT (oldargtype
);
1558 newargtype
= TYPE_MAIN_VARIANT (newargtype
);
1560 if (END_OF_ARGLIST (oldargtype
) && END_OF_ARGLIST (newargtype
))
1563 /* Reaching the end of just one list means the two decls don't
1564 agree on the number of arguments. */
1565 if (END_OF_ARGLIST (oldargtype
))
1567 error ("prototype for %q+D declares more arguments "
1568 "than previous old-style definition", newdecl
);
1571 else if (END_OF_ARGLIST (newargtype
))
1573 error ("prototype for %q+D declares fewer arguments "
1574 "than previous old-style definition", newdecl
);
1578 /* Type for passing arg must be consistent with that declared
1580 else if (!comptypes (oldargtype
, newargtype
))
1582 error ("prototype for %q+D declares argument %d"
1583 " with incompatible type",
1588 oldargs
= TREE_CHAIN (oldargs
);
1589 newargs
= TREE_CHAIN (newargs
);
1593 /* If we get here, no errors were found, but do issue a warning
1594 for this poor-style construct. */
1595 warning (0, "prototype for %q+D follows non-prototype definition",
1598 #undef END_OF_ARGLIST
1601 /* Subroutine of diagnose_mismatched_decls. Report the location of DECL,
1602 first in a pair of mismatched declarations, using the diagnostic
1605 locate_old_decl (tree decl
)
1607 if (TREE_CODE (decl
) == FUNCTION_DECL
&& DECL_BUILT_IN (decl
))
1609 else if (DECL_INITIAL (decl
))
1610 inform (input_location
, "previous definition of %q+D was here", decl
);
1611 else if (C_DECL_IMPLICIT (decl
))
1612 inform (input_location
, "previous implicit declaration of %q+D was here", decl
);
1614 inform (input_location
, "previous declaration of %q+D was here", decl
);
1617 /* Subroutine of duplicate_decls. Compare NEWDECL to OLDDECL.
1618 Returns true if the caller should proceed to merge the two, false
1619 if OLDDECL should simply be discarded. As a side effect, issues
1620 all necessary diagnostics for invalid or poor-style combinations.
1621 If it returns true, writes the types of NEWDECL and OLDDECL to
1622 *NEWTYPEP and *OLDTYPEP - these may have been adjusted from
1623 TREE_TYPE (NEWDECL, OLDDECL) respectively. */
1626 diagnose_mismatched_decls (tree newdecl
, tree olddecl
,
1627 tree
*newtypep
, tree
*oldtypep
)
1629 tree newtype
, oldtype
;
1630 bool pedwarned
= false;
1631 bool warned
= false;
1634 #define DECL_EXTERN_INLINE(DECL) (DECL_DECLARED_INLINE_P (DECL) \
1635 && DECL_EXTERNAL (DECL))
1637 /* If we have error_mark_node for either decl or type, just discard
1638 the previous decl - we're in an error cascade already. */
1639 if (olddecl
== error_mark_node
|| newdecl
== error_mark_node
)
1641 *oldtypep
= oldtype
= TREE_TYPE (olddecl
);
1642 *newtypep
= newtype
= TREE_TYPE (newdecl
);
1643 if (oldtype
== error_mark_node
|| newtype
== error_mark_node
)
1646 /* Two different categories of symbol altogether. This is an error
1647 unless OLDDECL is a builtin. OLDDECL will be discarded in any case. */
1648 if (TREE_CODE (olddecl
) != TREE_CODE (newdecl
))
1650 if (!(TREE_CODE (olddecl
) == FUNCTION_DECL
1651 && DECL_BUILT_IN (olddecl
)
1652 && !C_DECL_DECLARED_BUILTIN (olddecl
)))
1654 error ("%q+D redeclared as different kind of symbol", newdecl
);
1655 locate_old_decl (olddecl
);
1657 else if (TREE_PUBLIC (newdecl
))
1658 warning (0, "built-in function %q+D declared as non-function",
1661 warning (OPT_Wshadow
, "declaration of %q+D shadows "
1662 "a built-in function", newdecl
);
1666 /* Enumerators have no linkage, so may only be declared once in a
1668 if (TREE_CODE (olddecl
) == CONST_DECL
)
1670 error ("redeclaration of enumerator %q+D", newdecl
);
1671 locate_old_decl (olddecl
);
1675 if (!comptypes (oldtype
, newtype
))
1677 if (TREE_CODE (olddecl
) == FUNCTION_DECL
1678 && DECL_BUILT_IN (olddecl
) && !C_DECL_DECLARED_BUILTIN (olddecl
))
1680 /* Accept harmless mismatch in function types.
1681 This is for the ffs and fprintf builtins. */
1682 tree trytype
= match_builtin_function_types (newtype
, oldtype
);
1684 if (trytype
&& comptypes (newtype
, trytype
))
1685 *oldtypep
= oldtype
= trytype
;
1688 /* If types don't match for a built-in, throw away the
1689 built-in. No point in calling locate_old_decl here, it
1690 won't print anything. */
1691 warning (0, "conflicting types for built-in function %q+D",
1696 else if (TREE_CODE (olddecl
) == FUNCTION_DECL
1697 && DECL_IS_BUILTIN (olddecl
))
1699 /* A conflicting function declaration for a predeclared
1700 function that isn't actually built in. Objective C uses
1701 these. The new declaration silently overrides everything
1702 but the volatility (i.e. noreturn) indication. See also
1703 below. FIXME: Make Objective C use normal builtins. */
1704 TREE_THIS_VOLATILE (newdecl
) |= TREE_THIS_VOLATILE (olddecl
);
1707 /* Permit void foo (...) to match int foo (...) if the latter is
1708 the definition and implicit int was used. See
1709 c-torture/compile/920625-2.c. */
1710 else if (TREE_CODE (newdecl
) == FUNCTION_DECL
&& DECL_INITIAL (newdecl
)
1711 && TYPE_MAIN_VARIANT (TREE_TYPE (oldtype
)) == void_type_node
1712 && TYPE_MAIN_VARIANT (TREE_TYPE (newtype
)) == integer_type_node
1713 && C_FUNCTION_IMPLICIT_INT (newdecl
) && !DECL_INITIAL (olddecl
))
1715 pedwarned
= pedwarn (input_location
, 0,
1716 "conflicting types for %q+D", newdecl
);
1717 /* Make sure we keep void as the return type. */
1718 TREE_TYPE (newdecl
) = *newtypep
= newtype
= oldtype
;
1719 C_FUNCTION_IMPLICIT_INT (newdecl
) = 0;
1721 /* Permit void foo (...) to match an earlier call to foo (...) with
1722 no declared type (thus, implicitly int). */
1723 else if (TREE_CODE (newdecl
) == FUNCTION_DECL
1724 && TYPE_MAIN_VARIANT (TREE_TYPE (newtype
)) == void_type_node
1725 && TYPE_MAIN_VARIANT (TREE_TYPE (oldtype
)) == integer_type_node
1726 && C_DECL_IMPLICIT (olddecl
) && !DECL_INITIAL (olddecl
))
1728 pedwarned
= pedwarn (input_location
, 0,
1729 "conflicting types for %q+D", newdecl
);
1730 /* Make sure we keep void as the return type. */
1731 TREE_TYPE (olddecl
) = *oldtypep
= oldtype
= newtype
;
1735 int new_quals
= TYPE_QUALS (newtype
);
1736 int old_quals
= TYPE_QUALS (oldtype
);
1738 if (new_quals
!= old_quals
)
1740 addr_space_t new_addr
= DECODE_QUAL_ADDR_SPACE (new_quals
);
1741 addr_space_t old_addr
= DECODE_QUAL_ADDR_SPACE (old_quals
);
1742 if (new_addr
!= old_addr
)
1744 if (ADDR_SPACE_GENERIC_P (new_addr
))
1745 error ("conflicting named address spaces (generic vs %s) "
1747 c_addr_space_name (old_addr
), newdecl
);
1748 else if (ADDR_SPACE_GENERIC_P (old_addr
))
1749 error ("conflicting named address spaces (%s vs generic) "
1751 c_addr_space_name (new_addr
), newdecl
);
1753 error ("conflicting named address spaces (%s vs %s) "
1755 c_addr_space_name (new_addr
),
1756 c_addr_space_name (old_addr
),
1760 if (CLEAR_QUAL_ADDR_SPACE (new_quals
)
1761 != CLEAR_QUAL_ADDR_SPACE (old_quals
))
1762 error ("conflicting type qualifiers for %q+D", newdecl
);
1765 error ("conflicting types for %q+D", newdecl
);
1766 diagnose_arglist_conflict (newdecl
, olddecl
, newtype
, oldtype
);
1767 locate_old_decl (olddecl
);
1772 /* Redeclaration of a type is a constraint violation (6.7.2.3p1),
1773 but silently ignore the redeclaration if either is in a system
1774 header. (Conflicting redeclarations were handled above.) This
1775 is allowed for C1X if the types are the same, not just
1777 if (TREE_CODE (newdecl
) == TYPE_DECL
)
1779 bool types_different
= false;
1780 int comptypes_result
;
1783 = comptypes_check_different_types (oldtype
, newtype
, &types_different
);
1785 if (comptypes_result
!= 1 || types_different
)
1787 error ("redefinition of typedef %q+D with different type", newdecl
);
1788 locate_old_decl (olddecl
);
1792 if (DECL_IN_SYSTEM_HEADER (newdecl
)
1793 || DECL_IN_SYSTEM_HEADER (olddecl
)
1794 || TREE_NO_WARNING (newdecl
)
1795 || TREE_NO_WARNING (olddecl
))
1796 return true; /* Allow OLDDECL to continue in use. */
1798 if (pedantic
&& !flag_isoc1x
)
1800 pedwarn (input_location
, OPT_pedantic
,
1801 "redefinition of typedef %q+D", newdecl
);
1802 locate_old_decl (olddecl
);
1804 else if (variably_modified_type_p (newtype
, NULL
))
1806 /* Whether there is a constraint violation for the types not
1807 being the same cannot be determined at compile time; a
1808 warning that there may be one at runtime is considered
1809 appropriate (WG14 reflector message 11743, 8 May 2009). */
1810 warning (0, "redefinition of typedef %q+D may be a constraint "
1811 "violation at runtime", newdecl
);
1812 locate_old_decl (olddecl
);
1818 /* Function declarations can either be 'static' or 'extern' (no
1819 qualifier is equivalent to 'extern' - C99 6.2.2p5) and therefore
1820 can never conflict with each other on account of linkage
1821 (6.2.2p4). Multiple definitions are not allowed (6.9p3,5) but
1822 gnu89 mode permits two definitions if one is 'extern inline' and
1823 one is not. The non- extern-inline definition supersedes the
1824 extern-inline definition. */
1826 else if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
1828 /* If you declare a built-in function name as static, or
1829 define the built-in with an old-style definition (so we
1830 can't validate the argument list) the built-in definition is
1831 overridden, but optionally warn this was a bad choice of name. */
1832 if (DECL_BUILT_IN (olddecl
)
1833 && !C_DECL_DECLARED_BUILTIN (olddecl
)
1834 && (!TREE_PUBLIC (newdecl
)
1835 || (DECL_INITIAL (newdecl
)
1836 && !TYPE_ARG_TYPES (TREE_TYPE (newdecl
)))))
1838 warning (OPT_Wshadow
, "declaration of %q+D shadows "
1839 "a built-in function", newdecl
);
1840 /* Discard the old built-in function. */
1844 if (DECL_INITIAL (newdecl
))
1846 if (DECL_INITIAL (olddecl
))
1848 /* If both decls are in the same TU and the new declaration
1849 isn't overriding an extern inline reject the new decl.
1850 In c99, no overriding is allowed in the same translation
1852 if ((!DECL_EXTERN_INLINE (olddecl
)
1853 || DECL_EXTERN_INLINE (newdecl
)
1854 || (!flag_gnu89_inline
1855 && (!DECL_DECLARED_INLINE_P (olddecl
)
1856 || !lookup_attribute ("gnu_inline",
1857 DECL_ATTRIBUTES (olddecl
)))
1858 && (!DECL_DECLARED_INLINE_P (newdecl
)
1859 || !lookup_attribute ("gnu_inline",
1860 DECL_ATTRIBUTES (newdecl
))))
1862 && same_translation_unit_p (newdecl
, olddecl
))
1864 error ("redefinition of %q+D", newdecl
);
1865 locate_old_decl (olddecl
);
1870 /* If we have a prototype after an old-style function definition,
1871 the argument types must be checked specially. */
1872 else if (DECL_INITIAL (olddecl
)
1873 && !TYPE_ARG_TYPES (oldtype
) && TYPE_ARG_TYPES (newtype
)
1874 && TYPE_ACTUAL_ARG_TYPES (oldtype
)
1875 && !validate_proto_after_old_defn (newdecl
, newtype
, oldtype
))
1877 locate_old_decl (olddecl
);
1880 /* A non-static declaration (even an "extern") followed by a
1881 static declaration is undefined behavior per C99 6.2.2p3-5,7.
1882 The same is true for a static forward declaration at block
1883 scope followed by a non-static declaration/definition at file
1884 scope. Static followed by non-static at the same scope is
1885 not undefined behavior, and is the most convenient way to get
1886 some effects (see e.g. what unwind-dw2-fde-glibc.c does to
1887 the definition of _Unwind_Find_FDE in unwind-dw2-fde.c), but
1888 we do diagnose it if -Wtraditional. */
1889 if (TREE_PUBLIC (olddecl
) && !TREE_PUBLIC (newdecl
))
1891 /* Two exceptions to the rule. If olddecl is an extern
1892 inline, or a predeclared function that isn't actually
1893 built in, newdecl silently overrides olddecl. The latter
1894 occur only in Objective C; see also above. (FIXME: Make
1895 Objective C use normal builtins.) */
1896 if (!DECL_IS_BUILTIN (olddecl
)
1897 && !DECL_EXTERN_INLINE (olddecl
))
1899 error ("static declaration of %q+D follows "
1900 "non-static declaration", newdecl
);
1901 locate_old_decl (olddecl
);
1905 else if (TREE_PUBLIC (newdecl
) && !TREE_PUBLIC (olddecl
))
1907 if (DECL_CONTEXT (olddecl
))
1909 error ("non-static declaration of %q+D follows "
1910 "static declaration", newdecl
);
1911 locate_old_decl (olddecl
);
1914 else if (warn_traditional
)
1916 warned
|= warning (OPT_Wtraditional
,
1917 "non-static declaration of %q+D "
1918 "follows static declaration", newdecl
);
1922 /* Make sure gnu_inline attribute is either not present, or
1923 present on all inline decls. */
1924 if (DECL_DECLARED_INLINE_P (olddecl
)
1925 && DECL_DECLARED_INLINE_P (newdecl
))
1927 bool newa
= lookup_attribute ("gnu_inline",
1928 DECL_ATTRIBUTES (newdecl
)) != NULL
;
1929 bool olda
= lookup_attribute ("gnu_inline",
1930 DECL_ATTRIBUTES (olddecl
)) != NULL
;
1933 error_at (input_location
, "%<gnu_inline%> attribute present on %q+D",
1934 newa
? newdecl
: olddecl
);
1935 error_at (DECL_SOURCE_LOCATION (newa
? olddecl
: newdecl
),
1940 else if (TREE_CODE (newdecl
) == VAR_DECL
)
1942 /* Only variables can be thread-local, and all declarations must
1943 agree on this property. */
1944 if (C_DECL_THREADPRIVATE_P (olddecl
) && !DECL_THREAD_LOCAL_P (newdecl
))
1946 /* Nothing to check. Since OLDDECL is marked threadprivate
1947 and NEWDECL does not have a thread-local attribute, we
1948 will merge the threadprivate attribute into NEWDECL. */
1951 else if (DECL_THREAD_LOCAL_P (newdecl
) != DECL_THREAD_LOCAL_P (olddecl
))
1953 if (DECL_THREAD_LOCAL_P (newdecl
))
1954 error ("thread-local declaration of %q+D follows "
1955 "non-thread-local declaration", newdecl
);
1957 error ("non-thread-local declaration of %q+D follows "
1958 "thread-local declaration", newdecl
);
1960 locate_old_decl (olddecl
);
1964 /* Multiple initialized definitions are not allowed (6.9p3,5). */
1965 if (DECL_INITIAL (newdecl
) && DECL_INITIAL (olddecl
))
1967 error ("redefinition of %q+D", newdecl
);
1968 locate_old_decl (olddecl
);
1972 /* Objects declared at file scope: if the first declaration had
1973 external linkage (even if it was an external reference) the
1974 second must have external linkage as well, or the behavior is
1975 undefined. If the first declaration had internal linkage, then
1976 the second must too, or else be an external reference (in which
1977 case the composite declaration still has internal linkage).
1978 As for function declarations, we warn about the static-then-
1979 extern case only for -Wtraditional. See generally 6.2.2p3-5,7. */
1980 if (DECL_FILE_SCOPE_P (newdecl
)
1981 && TREE_PUBLIC (newdecl
) != TREE_PUBLIC (olddecl
))
1983 if (DECL_EXTERNAL (newdecl
))
1985 if (!DECL_FILE_SCOPE_P (olddecl
))
1987 error ("extern declaration of %q+D follows "
1988 "declaration with no linkage", newdecl
);
1989 locate_old_decl (olddecl
);
1992 else if (warn_traditional
)
1994 warned
|= warning (OPT_Wtraditional
,
1995 "non-static declaration of %q+D "
1996 "follows static declaration", newdecl
);
2001 if (TREE_PUBLIC (newdecl
))
2002 error ("non-static declaration of %q+D follows "
2003 "static declaration", newdecl
);
2005 error ("static declaration of %q+D follows "
2006 "non-static declaration", newdecl
);
2008 locate_old_decl (olddecl
);
2012 /* Two objects with the same name declared at the same block
2013 scope must both be external references (6.7p3). */
2014 else if (!DECL_FILE_SCOPE_P (newdecl
))
2016 if (DECL_EXTERNAL (newdecl
))
2018 /* Extern with initializer at block scope, which will
2019 already have received an error. */
2021 else if (DECL_EXTERNAL (olddecl
))
2023 error ("declaration of %q+D with no linkage follows "
2024 "extern declaration", newdecl
);
2025 locate_old_decl (olddecl
);
2029 error ("redeclaration of %q+D with no linkage", newdecl
);
2030 locate_old_decl (olddecl
);
2036 /* C++ does not permit a decl to appear multiple times at file
2039 && DECL_FILE_SCOPE_P (newdecl
)
2040 && !DECL_EXTERNAL (newdecl
)
2041 && !DECL_EXTERNAL (olddecl
))
2042 warned
|= warning_at (DECL_SOURCE_LOCATION (newdecl
),
2044 ("duplicate declaration of %qD is "
2050 /* All decls must agree on a visibility. */
2051 if (CODE_CONTAINS_STRUCT (TREE_CODE (newdecl
), TS_DECL_WITH_VIS
)
2052 && DECL_VISIBILITY_SPECIFIED (newdecl
) && DECL_VISIBILITY_SPECIFIED (olddecl
)
2053 && DECL_VISIBILITY (newdecl
) != DECL_VISIBILITY (olddecl
))
2055 warned
|= warning (0, "redeclaration of %q+D with different visibility "
2056 "(old visibility preserved)", newdecl
);
2059 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
2061 /* Diagnose inline __attribute__ ((noinline)) which is silly. */
2062 if (DECL_DECLARED_INLINE_P (newdecl
)
2063 && lookup_attribute ("noinline", DECL_ATTRIBUTES (olddecl
)))
2065 warned
|= warning (OPT_Wattributes
,
2066 "inline declaration of %qD follows "
2067 "declaration with attribute noinline", newdecl
);
2069 else if (DECL_DECLARED_INLINE_P (olddecl
)
2070 && lookup_attribute ("noinline", DECL_ATTRIBUTES (newdecl
)))
2072 warned
|= warning (OPT_Wattributes
,
2073 "declaration of %q+D with attribute "
2074 "noinline follows inline declaration ", newdecl
);
2077 else /* PARM_DECL, VAR_DECL */
2079 /* Redeclaration of a parameter is a constraint violation (this is
2080 not explicitly stated, but follows from C99 6.7p3 [no more than
2081 one declaration of the same identifier with no linkage in the
2082 same scope, except type tags] and 6.2.2p6 [parameters have no
2083 linkage]). We must check for a forward parameter declaration,
2084 indicated by TREE_ASM_WRITTEN on the old declaration - this is
2085 an extension, the mandatory diagnostic for which is handled by
2086 mark_forward_parm_decls. */
2088 if (TREE_CODE (newdecl
) == PARM_DECL
2089 && (!TREE_ASM_WRITTEN (olddecl
) || TREE_ASM_WRITTEN (newdecl
)))
2091 error ("redefinition of parameter %q+D", newdecl
);
2092 locate_old_decl (olddecl
);
2097 /* Optional warning for completely redundant decls. */
2098 if (!warned
&& !pedwarned
2099 && warn_redundant_decls
2100 /* Don't warn about a function declaration followed by a
2102 && !(TREE_CODE (newdecl
) == FUNCTION_DECL
2103 && DECL_INITIAL (newdecl
) && !DECL_INITIAL (olddecl
))
2104 /* Don't warn about redundant redeclarations of builtins. */
2105 && !(TREE_CODE (newdecl
) == FUNCTION_DECL
2106 && !DECL_BUILT_IN (newdecl
)
2107 && DECL_BUILT_IN (olddecl
)
2108 && !C_DECL_DECLARED_BUILTIN (olddecl
))
2109 /* Don't warn about an extern followed by a definition. */
2110 && !(DECL_EXTERNAL (olddecl
) && !DECL_EXTERNAL (newdecl
))
2111 /* Don't warn about forward parameter decls. */
2112 && !(TREE_CODE (newdecl
) == PARM_DECL
2113 && TREE_ASM_WRITTEN (olddecl
) && !TREE_ASM_WRITTEN (newdecl
))
2114 /* Don't warn about a variable definition following a declaration. */
2115 && !(TREE_CODE (newdecl
) == VAR_DECL
2116 && DECL_INITIAL (newdecl
) && !DECL_INITIAL (olddecl
)))
2118 warned
= warning (OPT_Wredundant_decls
, "redundant redeclaration of %q+D",
2122 /* Report location of previous decl/defn. */
2123 if (warned
|| pedwarned
)
2124 locate_old_decl (olddecl
);
2126 #undef DECL_EXTERN_INLINE
2131 /* Subroutine of duplicate_decls. NEWDECL has been found to be
2132 consistent with OLDDECL, but carries new information. Merge the
2133 new information into OLDDECL. This function issues no
2137 merge_decls (tree newdecl
, tree olddecl
, tree newtype
, tree oldtype
)
2139 bool new_is_definition
= (TREE_CODE (newdecl
) == FUNCTION_DECL
2140 && DECL_INITIAL (newdecl
) != 0);
2141 bool new_is_prototype
= (TREE_CODE (newdecl
) == FUNCTION_DECL
2142 && TYPE_ARG_TYPES (TREE_TYPE (newdecl
)) != 0);
2143 bool old_is_prototype
= (TREE_CODE (olddecl
) == FUNCTION_DECL
2144 && TYPE_ARG_TYPES (TREE_TYPE (olddecl
)) != 0);
2145 bool extern_changed
= false;
2147 /* For real parm decl following a forward decl, rechain the old decl
2148 in its new location and clear TREE_ASM_WRITTEN (it's not a
2149 forward decl anymore). */
2150 if (TREE_CODE (newdecl
) == PARM_DECL
2151 && TREE_ASM_WRITTEN (olddecl
) && !TREE_ASM_WRITTEN (newdecl
))
2153 struct c_binding
*b
, **here
;
2155 for (here
= ¤t_scope
->bindings
; *here
; here
= &(*here
)->prev
)
2156 if ((*here
)->decl
== olddecl
)
2163 b
->prev
= current_scope
->bindings
;
2164 current_scope
->bindings
= b
;
2166 TREE_ASM_WRITTEN (olddecl
) = 0;
2169 DECL_ATTRIBUTES (newdecl
)
2170 = targetm
.merge_decl_attributes (olddecl
, newdecl
);
2172 /* Merge the data types specified in the two decls. */
2174 = TREE_TYPE (olddecl
)
2175 = composite_type (newtype
, oldtype
);
2177 /* Lay the type out, unless already done. */
2178 if (!comptypes (oldtype
, TREE_TYPE (newdecl
)))
2180 if (TREE_TYPE (newdecl
) != error_mark_node
)
2181 layout_type (TREE_TYPE (newdecl
));
2182 if (TREE_CODE (newdecl
) != FUNCTION_DECL
2183 && TREE_CODE (newdecl
) != TYPE_DECL
2184 && TREE_CODE (newdecl
) != CONST_DECL
)
2185 layout_decl (newdecl
, 0);
2189 /* Since the type is OLDDECL's, make OLDDECL's size go with. */
2190 DECL_SIZE (newdecl
) = DECL_SIZE (olddecl
);
2191 DECL_SIZE_UNIT (newdecl
) = DECL_SIZE_UNIT (olddecl
);
2192 DECL_MODE (newdecl
) = DECL_MODE (olddecl
);
2193 if (DECL_ALIGN (olddecl
) > DECL_ALIGN (newdecl
))
2195 DECL_ALIGN (newdecl
) = DECL_ALIGN (olddecl
);
2196 DECL_USER_ALIGN (newdecl
) |= DECL_USER_ALIGN (olddecl
);
2200 /* Keep the old rtl since we can safely use it. */
2201 if (HAS_RTL_P (olddecl
))
2202 COPY_DECL_RTL (olddecl
, newdecl
);
2204 /* Merge the type qualifiers. */
2205 if (TREE_READONLY (newdecl
))
2206 TREE_READONLY (olddecl
) = 1;
2208 if (TREE_THIS_VOLATILE (newdecl
))
2209 TREE_THIS_VOLATILE (olddecl
) = 1;
2211 /* Merge deprecatedness. */
2212 if (TREE_DEPRECATED (newdecl
))
2213 TREE_DEPRECATED (olddecl
) = 1;
2215 /* If a decl is in a system header and the other isn't, keep the one on the
2216 system header. Otherwise, keep source location of definition rather than
2217 declaration and of prototype rather than non-prototype unless that
2218 prototype is built-in. */
2219 if (CODE_CONTAINS_STRUCT (TREE_CODE (olddecl
), TS_DECL_WITH_VIS
)
2220 && DECL_IN_SYSTEM_HEADER (olddecl
)
2221 && !DECL_IN_SYSTEM_HEADER (newdecl
) )
2222 DECL_SOURCE_LOCATION (newdecl
) = DECL_SOURCE_LOCATION (olddecl
);
2223 else if (CODE_CONTAINS_STRUCT (TREE_CODE (olddecl
), TS_DECL_WITH_VIS
)
2224 && DECL_IN_SYSTEM_HEADER (newdecl
)
2225 && !DECL_IN_SYSTEM_HEADER (olddecl
))
2226 DECL_SOURCE_LOCATION (olddecl
) = DECL_SOURCE_LOCATION (newdecl
);
2227 else if ((DECL_INITIAL (newdecl
) == 0 && DECL_INITIAL (olddecl
) != 0)
2228 || (old_is_prototype
&& !new_is_prototype
2229 && !C_DECL_BUILTIN_PROTOTYPE (olddecl
)))
2230 DECL_SOURCE_LOCATION (newdecl
) = DECL_SOURCE_LOCATION (olddecl
);
2232 /* Merge the initialization information. */
2233 if (DECL_INITIAL (newdecl
) == 0)
2234 DECL_INITIAL (newdecl
) = DECL_INITIAL (olddecl
);
2236 /* Merge the threadprivate attribute. */
2237 if (TREE_CODE (olddecl
) == VAR_DECL
&& C_DECL_THREADPRIVATE_P (olddecl
))
2239 DECL_TLS_MODEL (newdecl
) = DECL_TLS_MODEL (olddecl
);
2240 C_DECL_THREADPRIVATE_P (newdecl
) = 1;
2243 if (CODE_CONTAINS_STRUCT (TREE_CODE (olddecl
), TS_DECL_WITH_VIS
))
2245 /* Merge the section attribute.
2246 We want to issue an error if the sections conflict but that
2247 must be done later in decl_attributes since we are called
2248 before attributes are assigned. */
2249 if (DECL_SECTION_NAME (newdecl
) == NULL_TREE
)
2250 DECL_SECTION_NAME (newdecl
) = DECL_SECTION_NAME (olddecl
);
2252 /* Copy the assembler name.
2253 Currently, it can only be defined in the prototype. */
2254 COPY_DECL_ASSEMBLER_NAME (olddecl
, newdecl
);
2256 /* Use visibility of whichever declaration had it specified */
2257 if (DECL_VISIBILITY_SPECIFIED (olddecl
))
2259 DECL_VISIBILITY (newdecl
) = DECL_VISIBILITY (olddecl
);
2260 DECL_VISIBILITY_SPECIFIED (newdecl
) = 1;
2263 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
2265 DECL_STATIC_CONSTRUCTOR(newdecl
) |= DECL_STATIC_CONSTRUCTOR(olddecl
);
2266 DECL_STATIC_DESTRUCTOR (newdecl
) |= DECL_STATIC_DESTRUCTOR (olddecl
);
2267 DECL_NO_LIMIT_STACK (newdecl
) |= DECL_NO_LIMIT_STACK (olddecl
);
2268 DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (newdecl
)
2269 |= DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (olddecl
);
2270 TREE_THIS_VOLATILE (newdecl
) |= TREE_THIS_VOLATILE (olddecl
);
2271 DECL_IS_MALLOC (newdecl
) |= DECL_IS_MALLOC (olddecl
);
2272 DECL_IS_OPERATOR_NEW (newdecl
) |= DECL_IS_OPERATOR_NEW (olddecl
);
2273 TREE_READONLY (newdecl
) |= TREE_READONLY (olddecl
);
2274 DECL_PURE_P (newdecl
) |= DECL_PURE_P (olddecl
);
2275 DECL_IS_NOVOPS (newdecl
) |= DECL_IS_NOVOPS (olddecl
);
2278 /* Merge the storage class information. */
2279 merge_weak (newdecl
, olddecl
);
2281 /* For functions, static overrides non-static. */
2282 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
2284 TREE_PUBLIC (newdecl
) &= TREE_PUBLIC (olddecl
);
2285 /* This is since we don't automatically
2286 copy the attributes of NEWDECL into OLDDECL. */
2287 TREE_PUBLIC (olddecl
) = TREE_PUBLIC (newdecl
);
2288 /* If this clears `static', clear it in the identifier too. */
2289 if (!TREE_PUBLIC (olddecl
))
2290 TREE_PUBLIC (DECL_NAME (olddecl
)) = 0;
2294 /* In c99, 'extern' declaration before (or after) 'inline' means this
2295 function is not DECL_EXTERNAL, unless 'gnu_inline' attribute
2297 if (TREE_CODE (newdecl
) == FUNCTION_DECL
2298 && !flag_gnu89_inline
2299 && (DECL_DECLARED_INLINE_P (newdecl
)
2300 || DECL_DECLARED_INLINE_P (olddecl
))
2301 && (!DECL_DECLARED_INLINE_P (newdecl
)
2302 || !DECL_DECLARED_INLINE_P (olddecl
)
2303 || !DECL_EXTERNAL (olddecl
))
2304 && DECL_EXTERNAL (newdecl
)
2305 && !lookup_attribute ("gnu_inline", DECL_ATTRIBUTES (newdecl
))
2306 && !current_function_decl
)
2307 DECL_EXTERNAL (newdecl
) = 0;
2309 if (DECL_EXTERNAL (newdecl
))
2311 TREE_STATIC (newdecl
) = TREE_STATIC (olddecl
);
2312 DECL_EXTERNAL (newdecl
) = DECL_EXTERNAL (olddecl
);
2314 /* An extern decl does not override previous storage class. */
2315 TREE_PUBLIC (newdecl
) = TREE_PUBLIC (olddecl
);
2316 if (!DECL_EXTERNAL (newdecl
))
2318 DECL_CONTEXT (newdecl
) = DECL_CONTEXT (olddecl
);
2319 DECL_COMMON (newdecl
) = DECL_COMMON (olddecl
);
2324 TREE_STATIC (olddecl
) = TREE_STATIC (newdecl
);
2325 TREE_PUBLIC (olddecl
) = TREE_PUBLIC (newdecl
);
2328 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
2330 /* If we're redefining a function previously defined as extern
2331 inline, make sure we emit debug info for the inline before we
2332 throw it away, in case it was inlined into a function that
2333 hasn't been written out yet. */
2334 if (new_is_definition
&& DECL_INITIAL (olddecl
))
2335 /* The new defn must not be inline. */
2336 DECL_UNINLINABLE (newdecl
) = 1;
2339 /* If either decl says `inline', this fn is inline, unless
2340 its definition was passed already. */
2341 if (DECL_DECLARED_INLINE_P (newdecl
)
2342 || DECL_DECLARED_INLINE_P (olddecl
))
2343 DECL_DECLARED_INLINE_P (newdecl
) = 1;
2345 DECL_UNINLINABLE (newdecl
) = DECL_UNINLINABLE (olddecl
)
2346 = (DECL_UNINLINABLE (newdecl
) || DECL_UNINLINABLE (olddecl
));
2348 DECL_DISREGARD_INLINE_LIMITS (newdecl
)
2349 = DECL_DISREGARD_INLINE_LIMITS (olddecl
)
2350 = (DECL_DISREGARD_INLINE_LIMITS (newdecl
)
2351 || DECL_DISREGARD_INLINE_LIMITS (olddecl
));
2354 if (DECL_BUILT_IN (olddecl
))
2356 /* If redeclaring a builtin function, it stays built in.
2357 But it gets tagged as having been declared. */
2358 DECL_BUILT_IN_CLASS (newdecl
) = DECL_BUILT_IN_CLASS (olddecl
);
2359 DECL_FUNCTION_CODE (newdecl
) = DECL_FUNCTION_CODE (olddecl
);
2360 C_DECL_DECLARED_BUILTIN (newdecl
) = 1;
2361 if (new_is_prototype
)
2362 C_DECL_BUILTIN_PROTOTYPE (newdecl
) = 0;
2364 C_DECL_BUILTIN_PROTOTYPE (newdecl
)
2365 = C_DECL_BUILTIN_PROTOTYPE (olddecl
);
2368 /* Preserve function specific target and optimization options */
2369 if (DECL_FUNCTION_SPECIFIC_TARGET (olddecl
)
2370 && !DECL_FUNCTION_SPECIFIC_TARGET (newdecl
))
2371 DECL_FUNCTION_SPECIFIC_TARGET (newdecl
)
2372 = DECL_FUNCTION_SPECIFIC_TARGET (olddecl
);
2374 if (DECL_FUNCTION_SPECIFIC_OPTIMIZATION (olddecl
)
2375 && !DECL_FUNCTION_SPECIFIC_OPTIMIZATION (newdecl
))
2376 DECL_FUNCTION_SPECIFIC_OPTIMIZATION (newdecl
)
2377 = DECL_FUNCTION_SPECIFIC_OPTIMIZATION (olddecl
);
2379 /* Also preserve various other info from the definition. */
2380 if (!new_is_definition
)
2383 DECL_RESULT (newdecl
) = DECL_RESULT (olddecl
);
2384 DECL_INITIAL (newdecl
) = DECL_INITIAL (olddecl
);
2385 DECL_STRUCT_FUNCTION (newdecl
) = DECL_STRUCT_FUNCTION (olddecl
);
2386 DECL_SAVED_TREE (newdecl
) = DECL_SAVED_TREE (olddecl
);
2387 DECL_ARGUMENTS (newdecl
) = copy_list (DECL_ARGUMENTS (olddecl
));
2388 for (t
= DECL_ARGUMENTS (newdecl
); t
; t
= DECL_CHAIN (t
))
2389 DECL_CONTEXT (t
) = newdecl
;
2391 /* See if we've got a function to instantiate from. */
2392 if (DECL_SAVED_TREE (olddecl
))
2393 DECL_ABSTRACT_ORIGIN (newdecl
)
2394 = DECL_ABSTRACT_ORIGIN (olddecl
);
2398 extern_changed
= DECL_EXTERNAL (olddecl
) && !DECL_EXTERNAL (newdecl
);
2400 /* Merge the USED information. */
2401 if (TREE_USED (olddecl
))
2402 TREE_USED (newdecl
) = 1;
2403 else if (TREE_USED (newdecl
))
2404 TREE_USED (olddecl
) = 1;
2405 if (TREE_CODE (olddecl
) == VAR_DECL
|| TREE_CODE (olddecl
) == PARM_DECL
)
2406 DECL_READ_P (newdecl
) |= DECL_READ_P (olddecl
);
2407 if (DECL_PRESERVE_P (olddecl
))
2408 DECL_PRESERVE_P (newdecl
) = 1;
2409 else if (DECL_PRESERVE_P (newdecl
))
2410 DECL_PRESERVE_P (olddecl
) = 1;
2412 /* Copy most of the decl-specific fields of NEWDECL into OLDDECL.
2413 But preserve OLDDECL's DECL_UID, DECL_CONTEXT and
2414 DECL_ARGUMENTS (if appropriate). */
2416 unsigned olddecl_uid
= DECL_UID (olddecl
);
2417 tree olddecl_context
= DECL_CONTEXT (olddecl
);
2418 tree olddecl_arguments
= NULL
;
2419 if (TREE_CODE (olddecl
) == FUNCTION_DECL
)
2420 olddecl_arguments
= DECL_ARGUMENTS (olddecl
);
2422 memcpy ((char *) olddecl
+ sizeof (struct tree_common
),
2423 (char *) newdecl
+ sizeof (struct tree_common
),
2424 sizeof (struct tree_decl_common
) - sizeof (struct tree_common
));
2425 switch (TREE_CODE (olddecl
))
2435 memcpy ((char *) olddecl
+ sizeof (struct tree_decl_common
),
2436 (char *) newdecl
+ sizeof (struct tree_decl_common
),
2437 tree_code_size (TREE_CODE (olddecl
)) - sizeof (struct tree_decl_common
));
2442 memcpy ((char *) olddecl
+ sizeof (struct tree_decl_common
),
2443 (char *) newdecl
+ sizeof (struct tree_decl_common
),
2444 sizeof (struct tree_decl_non_common
) - sizeof (struct tree_decl_common
));
2446 DECL_UID (olddecl
) = olddecl_uid
;
2447 DECL_CONTEXT (olddecl
) = olddecl_context
;
2448 if (TREE_CODE (olddecl
) == FUNCTION_DECL
)
2449 DECL_ARGUMENTS (olddecl
) = olddecl_arguments
;
2452 /* If OLDDECL had its DECL_RTL instantiated, re-invoke make_decl_rtl
2453 so that encode_section_info has a chance to look at the new decl
2454 flags and attributes. */
2455 if (DECL_RTL_SET_P (olddecl
)
2456 && (TREE_CODE (olddecl
) == FUNCTION_DECL
2457 || (TREE_CODE (olddecl
) == VAR_DECL
2458 && TREE_STATIC (olddecl
))))
2459 make_decl_rtl (olddecl
);
2461 /* If we changed a function from DECL_EXTERNAL to !DECL_EXTERNAL,
2462 and the definition is coming from the old version, cgraph needs
2463 to be called again. */
2464 if (extern_changed
&& !new_is_definition
2465 && TREE_CODE (olddecl
) == FUNCTION_DECL
&& DECL_INITIAL (olddecl
))
2466 cgraph_mark_if_needed (olddecl
);
2469 /* Handle when a new declaration NEWDECL has the same name as an old
2470 one OLDDECL in the same binding contour. Prints an error message
2473 If safely possible, alter OLDDECL to look like NEWDECL, and return
2474 true. Otherwise, return false. */
2477 duplicate_decls (tree newdecl
, tree olddecl
)
2479 tree newtype
= NULL
, oldtype
= NULL
;
2481 if (!diagnose_mismatched_decls (newdecl
, olddecl
, &newtype
, &oldtype
))
2483 /* Avoid `unused variable' and other warnings for OLDDECL. */
2484 TREE_NO_WARNING (olddecl
) = 1;
2488 merge_decls (newdecl
, olddecl
, newtype
, oldtype
);
2493 /* Check whether decl-node NEW_DECL shadows an existing declaration. */
2495 warn_if_shadowing (tree new_decl
)
2497 struct c_binding
*b
;
2499 /* Shadow warnings wanted? */
2501 /* No shadow warnings for internally generated vars. */
2502 || DECL_IS_BUILTIN (new_decl
)
2503 /* No shadow warnings for vars made for inlining. */
2504 || DECL_FROM_INLINE (new_decl
))
2507 /* Is anything being shadowed? Invisible decls do not count. */
2508 for (b
= I_SYMBOL_BINDING (DECL_NAME (new_decl
)); b
; b
= b
->shadowed
)
2509 if (b
->decl
&& b
->decl
!= new_decl
&& !b
->invisible
)
2511 tree old_decl
= b
->decl
;
2513 if (old_decl
== error_mark_node
)
2515 warning (OPT_Wshadow
, "declaration of %q+D shadows previous "
2516 "non-variable", new_decl
);
2519 else if (TREE_CODE (old_decl
) == PARM_DECL
)
2520 warning (OPT_Wshadow
, "declaration of %q+D shadows a parameter",
2522 else if (DECL_FILE_SCOPE_P (old_decl
))
2523 warning (OPT_Wshadow
, "declaration of %q+D shadows a global "
2524 "declaration", new_decl
);
2525 else if (TREE_CODE (old_decl
) == FUNCTION_DECL
2526 && DECL_BUILT_IN (old_decl
))
2528 warning (OPT_Wshadow
, "declaration of %q+D shadows "
2529 "a built-in function", new_decl
);
2533 warning (OPT_Wshadow
, "declaration of %q+D shadows a previous local",
2536 warning_at (DECL_SOURCE_LOCATION (old_decl
), OPT_Wshadow
,
2537 "shadowed declaration is here");
2543 /* Record a decl-node X as belonging to the current lexical scope.
2544 Check for errors (such as an incompatible declaration for the same
2545 name already seen in the same scope).
2547 Returns either X or an old decl for the same name.
2548 If an old decl is returned, it may have been smashed
2549 to agree with what X says. */
2554 tree name
= DECL_NAME (x
);
2555 struct c_scope
*scope
= current_scope
;
2556 struct c_binding
*b
;
2557 bool nested
= false;
2558 location_t locus
= DECL_SOURCE_LOCATION (x
);
2560 /* Must set DECL_CONTEXT for everything not at file scope or
2561 DECL_FILE_SCOPE_P won't work. Local externs don't count
2562 unless they have initializers (which generate code). */
2563 if (current_function_decl
2564 && ((TREE_CODE (x
) != FUNCTION_DECL
&& TREE_CODE (x
) != VAR_DECL
)
2565 || DECL_INITIAL (x
) || !DECL_EXTERNAL (x
)))
2566 DECL_CONTEXT (x
) = current_function_decl
;
2568 /* Anonymous decls are just inserted in the scope. */
2571 bind (name
, x
, scope
, /*invisible=*/false, /*nested=*/false,
2576 /* First, see if there is another declaration with the same name in
2577 the current scope. If there is, duplicate_decls may do all the
2578 work for us. If duplicate_decls returns false, that indicates
2579 two incompatible decls in the same scope; we are to silently
2580 replace the old one (duplicate_decls has issued all appropriate
2581 diagnostics). In particular, we should not consider possible
2582 duplicates in the external scope, or shadowing. */
2583 b
= I_SYMBOL_BINDING (name
);
2584 if (b
&& B_IN_SCOPE (b
, scope
))
2586 struct c_binding
*b_ext
, *b_use
;
2587 tree type
= TREE_TYPE (x
);
2588 tree visdecl
= b
->decl
;
2589 tree vistype
= TREE_TYPE (visdecl
);
2590 if (TREE_CODE (TREE_TYPE (x
)) == ARRAY_TYPE
2591 && COMPLETE_TYPE_P (TREE_TYPE (x
)))
2592 b
->inner_comp
= false;
2595 /* If this is an external linkage declaration, we should check
2596 for compatibility with the type in the external scope before
2597 setting the type at this scope based on the visible
2598 information only. */
2599 if (TREE_PUBLIC (x
) && TREE_PUBLIC (visdecl
))
2601 while (b_ext
&& !B_IN_EXTERNAL_SCOPE (b_ext
))
2602 b_ext
= b_ext
->shadowed
;
2607 TREE_TYPE (b_use
->decl
) = b_use
->u
.type
;
2610 if (duplicate_decls (x
, b_use
->decl
))
2614 /* Save the updated type in the external scope and
2615 restore the proper type for this scope. */
2617 if (comptypes (vistype
, type
))
2618 thistype
= composite_type (vistype
, type
);
2620 thistype
= TREE_TYPE (b_use
->decl
);
2621 b_use
->u
.type
= TREE_TYPE (b_use
->decl
);
2622 if (TREE_CODE (b_use
->decl
) == FUNCTION_DECL
2623 && DECL_BUILT_IN (b_use
->decl
))
2625 = build_type_attribute_variant (thistype
,
2628 TREE_TYPE (b_use
->decl
) = thistype
;
2633 goto skip_external_and_shadow_checks
;
2636 /* All declarations with external linkage, and all external
2637 references, go in the external scope, no matter what scope is
2638 current. However, the binding in that scope is ignored for
2639 purposes of normal name lookup. A separate binding structure is
2640 created in the requested scope; this governs the normal
2641 visibility of the symbol.
2643 The binding in the externals scope is used exclusively for
2644 detecting duplicate declarations of the same object, no matter
2645 what scope they are in; this is what we do here. (C99 6.2.7p2:
2646 All declarations that refer to the same object or function shall
2647 have compatible type; otherwise, the behavior is undefined.) */
2648 if (DECL_EXTERNAL (x
) || scope
== file_scope
)
2650 tree type
= TREE_TYPE (x
);
2653 bool type_saved
= false;
2654 if (b
&& !B_IN_EXTERNAL_SCOPE (b
)
2655 && (TREE_CODE (b
->decl
) == FUNCTION_DECL
2656 || TREE_CODE (b
->decl
) == VAR_DECL
)
2657 && DECL_FILE_SCOPE_P (b
->decl
))
2660 vistype
= TREE_TYPE (visdecl
);
2662 if (scope
!= file_scope
2663 && !DECL_IN_SYSTEM_HEADER (x
))
2664 warning (OPT_Wnested_externs
, "nested extern declaration of %qD", x
);
2666 while (b
&& !B_IN_EXTERNAL_SCOPE (b
))
2668 /* If this decl might be modified, save its type. This is
2669 done here rather than when the decl is first bound
2670 because the type may change after first binding, through
2671 being completed or through attributes being added. If we
2672 encounter multiple such decls, only the first should have
2673 its type saved; the others will already have had their
2674 proper types saved and the types will not have changed as
2675 their scopes will not have been re-entered. */
2676 if (DECL_P (b
->decl
) && DECL_FILE_SCOPE_P (b
->decl
) && !type_saved
)
2678 b
->u
.type
= TREE_TYPE (b
->decl
);
2681 if (B_IN_FILE_SCOPE (b
)
2682 && TREE_CODE (b
->decl
) == VAR_DECL
2683 && TREE_STATIC (b
->decl
)
2684 && TREE_CODE (TREE_TYPE (b
->decl
)) == ARRAY_TYPE
2685 && !TYPE_DOMAIN (TREE_TYPE (b
->decl
))
2686 && TREE_CODE (type
) == ARRAY_TYPE
2687 && TYPE_DOMAIN (type
)
2688 && TYPE_MAX_VALUE (TYPE_DOMAIN (type
))
2689 && !integer_zerop (TYPE_MAX_VALUE (TYPE_DOMAIN (type
))))
2691 /* Array type completed in inner scope, which should be
2692 diagnosed if the completion does not have size 1 and
2693 it does not get completed in the file scope. */
2694 b
->inner_comp
= true;
2699 /* If a matching external declaration has been found, set its
2700 type to the composite of all the types of that declaration.
2701 After the consistency checks, it will be reset to the
2702 composite of the visible types only. */
2703 if (b
&& (TREE_PUBLIC (x
) || same_translation_unit_p (x
, b
->decl
))
2705 TREE_TYPE (b
->decl
) = b
->u
.type
;
2707 /* The point of the same_translation_unit_p check here is,
2708 we want to detect a duplicate decl for a construct like
2709 foo() { extern bar(); } ... static bar(); but not if
2710 they are in different translation units. In any case,
2711 the static does not go in the externals scope. */
2713 && (TREE_PUBLIC (x
) || same_translation_unit_p (x
, b
->decl
))
2714 && duplicate_decls (x
, b
->decl
))
2719 if (comptypes (vistype
, type
))
2720 thistype
= composite_type (vistype
, type
);
2722 thistype
= TREE_TYPE (b
->decl
);
2726 b
->u
.type
= TREE_TYPE (b
->decl
);
2727 if (TREE_CODE (b
->decl
) == FUNCTION_DECL
&& DECL_BUILT_IN (b
->decl
))
2729 = build_type_attribute_variant (thistype
,
2730 TYPE_ATTRIBUTES (b
->u
.type
));
2731 TREE_TYPE (b
->decl
) = thistype
;
2732 bind (name
, b
->decl
, scope
, /*invisible=*/false, /*nested=*/true,
2736 else if (TREE_PUBLIC (x
))
2738 if (visdecl
&& !b
&& duplicate_decls (x
, visdecl
))
2740 /* An external declaration at block scope referring to a
2741 visible entity with internal linkage. The composite
2742 type will already be correct for this scope, so we
2743 just need to fall through to make the declaration in
2750 bind (name
, x
, external_scope
, /*invisible=*/true,
2751 /*nested=*/false, locus
);
2757 if (TREE_CODE (x
) != PARM_DECL
)
2758 warn_if_shadowing (x
);
2760 skip_external_and_shadow_checks
:
2761 if (TREE_CODE (x
) == TYPE_DECL
)
2762 set_underlying_type (x
);
2764 bind (name
, x
, scope
, /*invisible=*/false, nested
, locus
);
2766 /* If x's type is incomplete because it's based on a
2767 structure or union which has not yet been fully declared,
2768 attach it to that structure or union type, so we can go
2769 back and complete the variable declaration later, if the
2770 structure or union gets fully declared.
2772 If the input is erroneous, we can have error_mark in the type
2773 slot (e.g. "f(void a, ...)") - that doesn't count as an
2775 if (TREE_TYPE (x
) != error_mark_node
2776 && !COMPLETE_TYPE_P (TREE_TYPE (x
)))
2778 tree element
= TREE_TYPE (x
);
2780 while (TREE_CODE (element
) == ARRAY_TYPE
)
2781 element
= TREE_TYPE (element
);
2782 element
= TYPE_MAIN_VARIANT (element
);
2784 if ((TREE_CODE (element
) == RECORD_TYPE
2785 || TREE_CODE (element
) == UNION_TYPE
)
2786 && (TREE_CODE (x
) != TYPE_DECL
2787 || TREE_CODE (TREE_TYPE (x
)) == ARRAY_TYPE
)
2788 && !COMPLETE_TYPE_P (element
))
2789 C_TYPE_INCOMPLETE_VARS (element
)
2790 = tree_cons (NULL_TREE
, x
, C_TYPE_INCOMPLETE_VARS (element
));
2795 /* Record X as belonging to file scope.
2796 This is used only internally by the Objective-C front end,
2797 and is limited to its needs. duplicate_decls is not called;
2798 if there is any preexisting decl for this identifier, it is an ICE. */
2801 pushdecl_top_level (tree x
)
2804 bool nested
= false;
2805 gcc_assert (TREE_CODE (x
) == VAR_DECL
|| TREE_CODE (x
) == CONST_DECL
);
2807 name
= DECL_NAME (x
);
2809 gcc_assert (TREE_CODE (x
) == CONST_DECL
|| !I_SYMBOL_BINDING (name
));
2811 if (TREE_PUBLIC (x
))
2813 bind (name
, x
, external_scope
, /*invisible=*/true, /*nested=*/false,
2818 bind (name
, x
, file_scope
, /*invisible=*/false, nested
, UNKNOWN_LOCATION
);
2824 implicit_decl_warning (tree id
, tree olddecl
)
2826 if (warn_implicit_function_declaration
)
2831 warned
= pedwarn (input_location
, OPT_Wimplicit_function_declaration
,
2832 "implicit declaration of function %qE", id
);
2834 warned
= warning (OPT_Wimplicit_function_declaration
,
2835 G_("implicit declaration of function %qE"), id
);
2836 if (olddecl
&& warned
)
2837 locate_old_decl (olddecl
);
2841 /* Generate an implicit declaration for identifier FUNCTIONID at LOC as a
2842 function of type int (). */
2845 implicitly_declare (location_t loc
, tree functionid
)
2847 struct c_binding
*b
;
2851 for (b
= I_SYMBOL_BINDING (functionid
); b
; b
= b
->shadowed
)
2853 if (B_IN_SCOPE (b
, external_scope
))
2862 if (decl
== error_mark_node
)
2865 /* FIXME: Objective-C has weird not-really-builtin functions
2866 which are supposed to be visible automatically. They wind up
2867 in the external scope because they're pushed before the file
2868 scope gets created. Catch this here and rebind them into the
2870 if (!DECL_BUILT_IN (decl
) && DECL_IS_BUILTIN (decl
))
2872 bind (functionid
, decl
, file_scope
,
2873 /*invisible=*/false, /*nested=*/true,
2874 DECL_SOURCE_LOCATION (decl
));
2879 tree newtype
= default_function_type
;
2881 TREE_TYPE (decl
) = b
->u
.type
;
2882 /* Implicit declaration of a function already declared
2883 (somehow) in a different scope, or as a built-in.
2884 If this is the first time this has happened, warn;
2885 then recycle the old declaration but with the new type. */
2886 if (!C_DECL_IMPLICIT (decl
))
2888 implicit_decl_warning (functionid
, decl
);
2889 C_DECL_IMPLICIT (decl
) = 1;
2891 if (DECL_BUILT_IN (decl
))
2893 newtype
= build_type_attribute_variant (newtype
,
2895 (TREE_TYPE (decl
)));
2896 if (!comptypes (newtype
, TREE_TYPE (decl
)))
2898 warning_at (loc
, 0, "incompatible implicit declaration of "
2899 "built-in function %qD", decl
);
2900 newtype
= TREE_TYPE (decl
);
2905 if (!comptypes (newtype
, TREE_TYPE (decl
)))
2907 error_at (loc
, "incompatible implicit declaration of function %qD", decl
);
2908 locate_old_decl (decl
);
2911 b
->u
.type
= TREE_TYPE (decl
);
2912 TREE_TYPE (decl
) = newtype
;
2913 bind (functionid
, decl
, current_scope
,
2914 /*invisible=*/false, /*nested=*/true,
2915 DECL_SOURCE_LOCATION (decl
));
2920 /* Not seen before. */
2921 decl
= build_decl (loc
, FUNCTION_DECL
, functionid
, default_function_type
);
2922 DECL_EXTERNAL (decl
) = 1;
2923 TREE_PUBLIC (decl
) = 1;
2924 C_DECL_IMPLICIT (decl
) = 1;
2925 implicit_decl_warning (functionid
, 0);
2926 asmspec_tree
= maybe_apply_renaming_pragma (decl
, /*asmname=*/NULL
);
2928 set_user_assembler_name (decl
, TREE_STRING_POINTER (asmspec_tree
));
2930 /* C89 says implicit declarations are in the innermost block.
2931 So we record the decl in the standard fashion. */
2932 decl
= pushdecl (decl
);
2934 /* No need to call objc_check_decl here - it's a function type. */
2935 rest_of_decl_compilation (decl
, 0, 0);
2937 /* Write a record describing this implicit function declaration
2938 to the prototypes file (if requested). */
2939 gen_aux_info_record (decl
, 0, 1, 0);
2941 /* Possibly apply some default attributes to this implicit declaration. */
2942 decl_attributes (&decl
, NULL_TREE
, 0);
2947 /* Issue an error message for a reference to an undeclared variable
2948 ID, including a reference to a builtin outside of function-call
2949 context. Establish a binding of the identifier to error_mark_node
2950 in an appropriate scope, which will suppress further errors for the
2951 same identifier. The error message should be given location LOC. */
2953 undeclared_variable (location_t loc
, tree id
)
2955 static bool already
= false;
2956 struct c_scope
*scope
;
2958 if (current_function_decl
== 0)
2960 error_at (loc
, "%qE undeclared here (not in a function)", id
);
2961 scope
= current_scope
;
2965 if (!objc_diagnose_private_ivar (id
))
2966 error_at (loc
, "%qE undeclared (first use in this function)", id
);
2969 inform (loc
, "each undeclared identifier is reported only"
2970 " once for each function it appears in");
2974 /* If we are parsing old-style parameter decls, current_function_decl
2975 will be nonnull but current_function_scope will be null. */
2976 scope
= current_function_scope
? current_function_scope
: current_scope
;
2978 bind (id
, error_mark_node
, scope
, /*invisible=*/false, /*nested=*/false,
2982 /* Subroutine of lookup_label, declare_label, define_label: construct a
2983 LABEL_DECL with all the proper frills. Also create a struct
2984 c_label_vars initialized for the current scope. */
2987 make_label (location_t location
, tree name
, bool defining
,
2988 struct c_label_vars
**p_label_vars
)
2990 tree label
= build_decl (location
, LABEL_DECL
, name
, void_type_node
);
2991 struct c_label_vars
*label_vars
;
2993 DECL_CONTEXT (label
) = current_function_decl
;
2994 DECL_MODE (label
) = VOIDmode
;
2996 label_vars
= ggc_alloc_c_label_vars ();
2997 label_vars
->shadowed
= NULL
;
2998 set_spot_bindings (&label_vars
->label_bindings
, defining
);
2999 label_vars
->decls_in_scope
= make_tree_vector ();
3000 label_vars
->gotos
= VEC_alloc (c_goto_bindings_p
, gc
, 0);
3001 *p_label_vars
= label_vars
;
3006 /* Get the LABEL_DECL corresponding to identifier NAME as a label.
3007 Create one if none exists so far for the current function.
3008 This is called when a label is used in a goto expression or
3009 has its address taken. */
3012 lookup_label (tree name
)
3015 struct c_label_vars
*label_vars
;
3017 if (current_function_scope
== 0)
3019 error ("label %qE referenced outside of any function", name
);
3023 /* Use a label already defined or ref'd with this name, but not if
3024 it is inherited from a containing function and wasn't declared
3026 label
= I_LABEL_DECL (name
);
3027 if (label
&& (DECL_CONTEXT (label
) == current_function_decl
3028 || C_DECLARED_LABEL_FLAG (label
)))
3030 /* If the label has only been declared, update its apparent
3031 location to point here, for better diagnostics if it
3032 turns out not to have been defined. */
3033 if (DECL_INITIAL (label
) == NULL_TREE
)
3034 DECL_SOURCE_LOCATION (label
) = input_location
;
3038 /* No label binding for that identifier; make one. */
3039 label
= make_label (input_location
, name
, false, &label_vars
);
3041 /* Ordinary labels go in the current function scope. */
3042 bind_label (name
, label
, current_function_scope
, label_vars
);
3047 /* Issue a warning about DECL for a goto statement at GOTO_LOC going
3051 warn_about_goto (location_t goto_loc
, tree label
, tree decl
)
3053 if (variably_modified_type_p (TREE_TYPE (decl
), NULL_TREE
))
3055 "jump into scope of identifier with variably modified type");
3057 warning_at (goto_loc
, OPT_Wjump_misses_init
,
3058 "jump skips variable initialization");
3059 inform (DECL_SOURCE_LOCATION (label
), "label %qD defined here", label
);
3060 inform (DECL_SOURCE_LOCATION (decl
), "%qD declared here", decl
);
3063 /* Look up a label because of a goto statement. This is like
3064 lookup_label, but also issues any appropriate warnings. */
3067 lookup_label_for_goto (location_t loc
, tree name
)
3070 struct c_label_vars
*label_vars
;
3074 label
= lookup_label (name
);
3075 if (label
== NULL_TREE
)
3078 /* If we are jumping to a different function, we can't issue any
3080 if (DECL_CONTEXT (label
) != current_function_decl
)
3082 gcc_assert (C_DECLARED_LABEL_FLAG (label
));
3086 label_vars
= I_LABEL_BINDING (name
)->u
.label
;
3088 /* If the label has not yet been defined, then push this goto on a
3089 list for possible later warnings. */
3090 if (label_vars
->label_bindings
.scope
== NULL
)
3092 struct c_goto_bindings
*g
;
3094 g
= ggc_alloc_c_goto_bindings ();
3096 set_spot_bindings (&g
->goto_bindings
, true);
3097 VEC_safe_push (c_goto_bindings_p
, gc
, label_vars
->gotos
, g
);
3101 /* If there are any decls in label_vars->decls_in_scope, then this
3102 goto has missed the declaration of the decl. This happens for a
3108 Issue a warning or error. */
3109 FOR_EACH_VEC_ELT (tree
, label_vars
->decls_in_scope
, ix
, decl
)
3110 warn_about_goto (loc
, label
, decl
);
3112 if (label_vars
->label_bindings
.left_stmt_expr
)
3114 error_at (loc
, "jump into statement expression");
3115 inform (DECL_SOURCE_LOCATION (label
), "label %qD defined here", label
);
3121 /* Make a label named NAME in the current function, shadowing silently
3122 any that may be inherited from containing functions or containing
3123 scopes. This is called for __label__ declarations. */
3126 declare_label (tree name
)
3128 struct c_binding
*b
= I_LABEL_BINDING (name
);
3130 struct c_label_vars
*label_vars
;
3132 /* Check to make sure that the label hasn't already been declared
3134 if (b
&& B_IN_CURRENT_SCOPE (b
))
3136 error ("duplicate label declaration %qE", name
);
3137 locate_old_decl (b
->decl
);
3139 /* Just use the previous declaration. */
3143 label
= make_label (input_location
, name
, false, &label_vars
);
3144 C_DECLARED_LABEL_FLAG (label
) = 1;
3146 /* Declared labels go in the current scope. */
3147 bind_label (name
, label
, current_scope
, label_vars
);
3152 /* When we define a label, issue any appropriate warnings if there are
3153 any gotos earlier in the function which jump to this label. */
3156 check_earlier_gotos (tree label
, struct c_label_vars
* label_vars
)
3159 struct c_goto_bindings
*g
;
3161 FOR_EACH_VEC_ELT (c_goto_bindings_p
, label_vars
->gotos
, ix
, g
)
3163 struct c_binding
*b
;
3164 struct c_scope
*scope
;
3166 /* We have a goto to this label. The goto is going forward. In
3167 g->scope, the goto is going to skip any binding which was
3168 defined after g->bindings_in_scope. */
3169 for (b
= g
->goto_bindings
.scope
->bindings
;
3170 b
!= g
->goto_bindings
.bindings_in_scope
;
3173 if (decl_jump_unsafe (b
->decl
))
3174 warn_about_goto (g
->loc
, label
, b
->decl
);
3177 /* We also need to warn about decls defined in any scopes
3178 between the scope of the label and the scope of the goto. */
3179 for (scope
= label_vars
->label_bindings
.scope
;
3180 scope
!= g
->goto_bindings
.scope
;
3181 scope
= scope
->outer
)
3183 gcc_assert (scope
!= NULL
);
3184 if (scope
== label_vars
->label_bindings
.scope
)
3185 b
= label_vars
->label_bindings
.bindings_in_scope
;
3187 b
= scope
->bindings
;
3188 for (; b
!= NULL
; b
= b
->prev
)
3190 if (decl_jump_unsafe (b
->decl
))
3191 warn_about_goto (g
->loc
, label
, b
->decl
);
3195 if (g
->goto_bindings
.stmt_exprs
> 0)
3197 error_at (g
->loc
, "jump into statement expression");
3198 inform (DECL_SOURCE_LOCATION (label
), "label %qD defined here",
3203 /* Now that the label is defined, we will issue warnings about
3204 subsequent gotos to this label when we see them. */
3205 VEC_truncate (c_goto_bindings_p
, label_vars
->gotos
, 0);
3206 label_vars
->gotos
= NULL
;
3209 /* Define a label, specifying the location in the source file.
3210 Return the LABEL_DECL node for the label, if the definition is valid.
3211 Otherwise return 0. */
3214 define_label (location_t location
, tree name
)
3216 /* Find any preexisting label with this name. It is an error
3217 if that label has already been defined in this function, or
3218 if there is a containing function with a declared label with
3220 tree label
= I_LABEL_DECL (name
);
3223 && ((DECL_CONTEXT (label
) == current_function_decl
3224 && DECL_INITIAL (label
) != 0)
3225 || (DECL_CONTEXT (label
) != current_function_decl
3226 && C_DECLARED_LABEL_FLAG (label
))))
3228 error_at (location
, "duplicate label %qD", label
);
3229 locate_old_decl (label
);
3232 else if (label
&& DECL_CONTEXT (label
) == current_function_decl
)
3234 struct c_label_vars
*label_vars
= I_LABEL_BINDING (name
)->u
.label
;
3236 /* The label has been used or declared already in this function,
3237 but not defined. Update its location to point to this
3239 DECL_SOURCE_LOCATION (label
) = location
;
3240 set_spot_bindings (&label_vars
->label_bindings
, true);
3242 /* Issue warnings as required about any goto statements from
3243 earlier in the function. */
3244 check_earlier_gotos (label
, label_vars
);
3248 struct c_label_vars
*label_vars
;
3250 /* No label binding for that identifier; make one. */
3251 label
= make_label (location
, name
, true, &label_vars
);
3253 /* Ordinary labels go in the current function scope. */
3254 bind_label (name
, label
, current_function_scope
, label_vars
);
3257 if (!in_system_header
&& lookup_name (name
))
3258 warning_at (location
, OPT_Wtraditional
,
3259 "traditional C lacks a separate namespace "
3260 "for labels, identifier %qE conflicts", name
);
3262 /* Mark label as having been defined. */
3263 DECL_INITIAL (label
) = error_mark_node
;
3267 /* Get the bindings for a new switch statement. This is used to issue
3268 warnings as appropriate for jumps from the switch to case or
3271 struct c_spot_bindings
*
3272 c_get_switch_bindings (void)
3274 struct c_spot_bindings
*switch_bindings
;
3276 switch_bindings
= XNEW (struct c_spot_bindings
);
3277 set_spot_bindings (switch_bindings
, true);
3278 return switch_bindings
;
3282 c_release_switch_bindings (struct c_spot_bindings
*bindings
)
3284 gcc_assert (bindings
->stmt_exprs
== 0 && !bindings
->left_stmt_expr
);
3288 /* This is called at the point of a case or default label to issue
3289 warnings about decls as needed. It returns true if it found an
3290 error, not just a warning. */
3293 c_check_switch_jump_warnings (struct c_spot_bindings
*switch_bindings
,
3294 location_t switch_loc
, location_t case_loc
)
3297 struct c_scope
*scope
;
3300 for (scope
= current_scope
;
3301 scope
!= switch_bindings
->scope
;
3302 scope
= scope
->outer
)
3304 struct c_binding
*b
;
3306 gcc_assert (scope
!= NULL
);
3307 for (b
= scope
->bindings
; b
!= NULL
; b
= b
->prev
)
3309 if (decl_jump_unsafe (b
->decl
))
3311 if (variably_modified_type_p (TREE_TYPE (b
->decl
), NULL_TREE
))
3315 ("switch jumps into scope of identifier with "
3316 "variably modified type"));
3319 warning_at (case_loc
, OPT_Wjump_misses_init
,
3320 "switch jumps over variable initialization");
3321 inform (switch_loc
, "switch starts here");
3322 inform (DECL_SOURCE_LOCATION (b
->decl
), "%qD declared here",
3328 if (switch_bindings
->stmt_exprs
> 0)
3331 error_at (case_loc
, "switch jumps into statement expression");
3332 inform (switch_loc
, "switch starts here");
3338 /* Given NAME, an IDENTIFIER_NODE,
3339 return the structure (or union or enum) definition for that name.
3340 If THISLEVEL_ONLY is nonzero, searches only the current_scope.
3341 CODE says which kind of type the caller wants;
3342 it is RECORD_TYPE or UNION_TYPE or ENUMERAL_TYPE.
3343 If PLOC is not NULL and this returns non-null, it sets *PLOC to the
3344 location where the tag was defined.
3345 If the wrong kind of type is found, an error is reported. */
3348 lookup_tag (enum tree_code code
, tree name
, int thislevel_only
,
3351 struct c_binding
*b
= I_TAG_BINDING (name
);
3357 /* We only care about whether it's in this level if
3358 thislevel_only was set or it might be a type clash. */
3359 if (thislevel_only
|| TREE_CODE (b
->decl
) != code
)
3361 /* For our purposes, a tag in the external scope is the same as
3362 a tag in the file scope. (Primarily relevant to Objective-C
3363 and its builtin structure tags, which get pushed before the
3364 file scope is created.) */
3365 if (B_IN_CURRENT_SCOPE (b
)
3366 || (current_scope
== file_scope
&& B_IN_EXTERNAL_SCOPE (b
)))
3370 if (thislevel_only
&& !thislevel
)
3373 if (TREE_CODE (b
->decl
) != code
)
3375 /* Definition isn't the kind we were looking for. */
3376 pending_invalid_xref
= name
;
3377 pending_invalid_xref_location
= input_location
;
3379 /* If in the same binding level as a declaration as a tag
3380 of a different type, this must not be allowed to
3381 shadow that tag, so give the error immediately.
3382 (For example, "struct foo; union foo;" is invalid.) */
3384 pending_xref_error ();
3393 /* Print an error message now
3394 for a recent invalid struct, union or enum cross reference.
3395 We don't print them immediately because they are not invalid
3396 when used in the `struct foo;' construct for shadowing. */
3399 pending_xref_error (void)
3401 if (pending_invalid_xref
!= 0)
3402 error_at (pending_invalid_xref_location
, "%qE defined as wrong kind of tag",
3403 pending_invalid_xref
);
3404 pending_invalid_xref
= 0;
3408 /* Look up NAME in the current scope and its superiors
3409 in the namespace of variables, functions and typedefs.
3410 Return a ..._DECL node of some kind representing its definition,
3411 or return 0 if it is undefined. */
3414 lookup_name (tree name
)
3416 struct c_binding
*b
= I_SYMBOL_BINDING (name
);
3417 if (b
&& !b
->invisible
)
3422 /* Similar to `lookup_name' but look only at the indicated scope. */
3425 lookup_name_in_scope (tree name
, struct c_scope
*scope
)
3427 struct c_binding
*b
;
3429 for (b
= I_SYMBOL_BINDING (name
); b
; b
= b
->shadowed
)
3430 if (B_IN_SCOPE (b
, scope
))
3435 /* Create the predefined scalar types of C,
3436 and some nodes representing standard constants (0, 1, (void *) 0).
3437 Initialize the global scope.
3438 Make definitions for built-in primitive functions. */
3441 c_init_decl_processing (void)
3443 location_t save_loc
= input_location
;
3445 /* Initialize reserved words for parser. */
3448 current_function_decl
= 0;
3450 gcc_obstack_init (&parser_obstack
);
3452 /* Make the externals scope. */
3454 external_scope
= current_scope
;
3456 /* Declarations from c_common_nodes_and_builtins must not be associated
3457 with this input file, lest we get differences between using and not
3458 using preprocessed headers. */
3459 input_location
= BUILTINS_LOCATION
;
3461 build_common_tree_nodes (flag_signed_char
);
3463 c_common_nodes_and_builtins ();
3465 /* In C, comparisons and TRUTH_* expressions have type int. */
3466 truthvalue_type_node
= integer_type_node
;
3467 truthvalue_true_node
= integer_one_node
;
3468 truthvalue_false_node
= integer_zero_node
;
3470 /* Even in C99, which has a real boolean type. */
3471 pushdecl (build_decl (UNKNOWN_LOCATION
, TYPE_DECL
, get_identifier ("_Bool"),
3472 boolean_type_node
));
3474 input_location
= save_loc
;
3476 pedantic_lvalues
= true;
3478 make_fname_decl
= c_make_fname_decl
;
3479 start_fname_decls ();
3482 /* Create the VAR_DECL at LOC for __FUNCTION__ etc. ID is the name to
3483 give the decl, NAME is the initialization string and TYPE_DEP
3484 indicates whether NAME depended on the type of the function. As we
3485 don't yet implement delayed emission of static data, we mark the
3486 decl as emitted so it is not placed in the output. Anything using
3487 it must therefore pull out the STRING_CST initializer directly.
3491 c_make_fname_decl (location_t loc
, tree id
, int type_dep
)
3493 const char *name
= fname_as_string (type_dep
);
3494 tree decl
, type
, init
;
3495 size_t length
= strlen (name
);
3497 type
= build_array_type (char_type_node
,
3498 build_index_type (size_int (length
)));
3499 type
= c_build_qualified_type (type
, TYPE_QUAL_CONST
);
3501 decl
= build_decl (loc
, VAR_DECL
, id
, type
);
3503 TREE_STATIC (decl
) = 1;
3504 TREE_READONLY (decl
) = 1;
3505 DECL_ARTIFICIAL (decl
) = 1;
3507 init
= build_string (length
+ 1, name
);
3508 free (CONST_CAST (char *, name
));
3509 TREE_TYPE (init
) = type
;
3510 DECL_INITIAL (decl
) = init
;
3512 TREE_USED (decl
) = 1;
3514 if (current_function_decl
3515 /* For invalid programs like this:
3518 const char* p = __FUNCTION__;
3520 the __FUNCTION__ is believed to appear in K&R style function
3521 parameter declarator. In that case we still don't have
3523 && (!seen_error () || current_function_scope
))
3525 DECL_CONTEXT (decl
) = current_function_decl
;
3526 bind (id
, decl
, current_function_scope
,
3527 /*invisible=*/false, /*nested=*/false, UNKNOWN_LOCATION
);
3530 finish_decl (decl
, loc
, init
, NULL_TREE
, NULL_TREE
);
3536 c_builtin_function (tree decl
)
3538 tree type
= TREE_TYPE (decl
);
3539 tree id
= DECL_NAME (decl
);
3541 const char *name
= IDENTIFIER_POINTER (id
);
3542 C_DECL_BUILTIN_PROTOTYPE (decl
) = (TYPE_ARG_TYPES (type
) != 0);
3544 /* Should never be called on a symbol with a preexisting meaning. */
3545 gcc_assert (!I_SYMBOL_BINDING (id
));
3547 bind (id
, decl
, external_scope
, /*invisible=*/true, /*nested=*/false,
3550 /* Builtins in the implementation namespace are made visible without
3551 needing to be explicitly declared. See push_file_scope. */
3552 if (name
[0] == '_' && (name
[1] == '_' || ISUPPER (name
[1])))
3554 DECL_CHAIN (decl
) = visible_builtins
;
3555 visible_builtins
= decl
;
3562 c_builtin_function_ext_scope (tree decl
)
3564 tree type
= TREE_TYPE (decl
);
3565 tree id
= DECL_NAME (decl
);
3567 const char *name
= IDENTIFIER_POINTER (id
);
3568 C_DECL_BUILTIN_PROTOTYPE (decl
) = (TYPE_ARG_TYPES (type
) != 0);
3570 /* Should never be called on a symbol with a preexisting meaning. */
3571 gcc_assert (!I_SYMBOL_BINDING (id
));
3573 bind (id
, decl
, external_scope
, /*invisible=*/false, /*nested=*/false,
3576 /* Builtins in the implementation namespace are made visible without
3577 needing to be explicitly declared. See push_file_scope. */
3578 if (name
[0] == '_' && (name
[1] == '_' || ISUPPER (name
[1])))
3580 DECL_CHAIN (decl
) = visible_builtins
;
3581 visible_builtins
= decl
;
3587 /* Called when a declaration is seen that contains no names to declare.
3588 If its type is a reference to a structure, union or enum inherited
3589 from a containing scope, shadow that tag name for the current scope
3590 with a forward reference.
3591 If its type defines a new named structure or union
3592 or defines an enum, it is valid but we need not do anything here.
3593 Otherwise, it is an error. */
3596 shadow_tag (const struct c_declspecs
*declspecs
)
3598 shadow_tag_warned (declspecs
, 0);
3601 /* WARNED is 1 if we have done a pedwarn, 2 if we have done a warning,
3604 shadow_tag_warned (const struct c_declspecs
*declspecs
, int warned
)
3606 bool found_tag
= false;
3608 if (declspecs
->type
&& !declspecs
->default_int_p
&& !declspecs
->typedef_p
)
3610 tree value
= declspecs
->type
;
3611 enum tree_code code
= TREE_CODE (value
);
3613 if (code
== RECORD_TYPE
|| code
== UNION_TYPE
|| code
== ENUMERAL_TYPE
)
3614 /* Used to test also that TYPE_SIZE (value) != 0.
3615 That caused warning for `struct foo;' at top level in the file. */
3617 tree name
= TYPE_NAME (value
);
3622 if (declspecs
->restrict_p
)
3624 error ("invalid use of %<restrict%>");
3630 if (warned
!= 1 && code
!= ENUMERAL_TYPE
)
3631 /* Empty unnamed enum OK */
3633 pedwarn (input_location
, 0,
3634 "unnamed struct/union that defines no instances");
3638 else if (declspecs
->typespec_kind
!= ctsk_tagdef
3639 && declspecs
->typespec_kind
!= ctsk_tagfirstref
3640 && declspecs
->storage_class
!= csc_none
)
3643 pedwarn (input_location
, 0,
3644 "empty declaration with storage class specifier "
3645 "does not redeclare tag");
3647 pending_xref_error ();
3649 else if (declspecs
->typespec_kind
!= ctsk_tagdef
3650 && declspecs
->typespec_kind
!= ctsk_tagfirstref
3651 && (declspecs
->const_p
3652 || declspecs
->volatile_p
3653 || declspecs
->restrict_p
3654 || declspecs
->address_space
))
3657 pedwarn (input_location
, 0,
3658 "empty declaration with type qualifier "
3659 "does not redeclare tag");
3661 pending_xref_error ();
3665 pending_invalid_xref
= 0;
3666 t
= lookup_tag (code
, name
, 1, NULL
);
3670 t
= make_node (code
);
3671 pushtag (input_location
, name
, t
);
3677 if (warned
!= 1 && !in_system_header
)
3679 pedwarn (input_location
, 0,
3680 "useless type name in empty declaration");
3685 else if (warned
!= 1 && !in_system_header
&& declspecs
->typedef_p
)
3687 pedwarn (input_location
, 0, "useless type name in empty declaration");
3691 pending_invalid_xref
= 0;
3693 if (declspecs
->inline_p
)
3695 error ("%<inline%> in empty declaration");
3699 if (current_scope
== file_scope
&& declspecs
->storage_class
== csc_auto
)
3701 error ("%<auto%> in file-scope empty declaration");
3705 if (current_scope
== file_scope
&& declspecs
->storage_class
== csc_register
)
3707 error ("%<register%> in file-scope empty declaration");
3711 if (!warned
&& !in_system_header
&& declspecs
->storage_class
!= csc_none
)
3713 warning (0, "useless storage class specifier in empty declaration");
3717 if (!warned
&& !in_system_header
&& declspecs
->thread_p
)
3719 warning (0, "useless %<__thread%> in empty declaration");
3723 if (!warned
&& !in_system_header
&& (declspecs
->const_p
3724 || declspecs
->volatile_p
3725 || declspecs
->restrict_p
3726 || declspecs
->address_space
))
3728 warning (0, "useless type qualifier in empty declaration");
3735 pedwarn (input_location
, 0, "empty declaration");
3740 /* Return the qualifiers from SPECS as a bitwise OR of TYPE_QUAL_*
3741 bits. SPECS represents declaration specifiers that the grammar
3742 only permits to contain type qualifiers and attributes. */
3745 quals_from_declspecs (const struct c_declspecs
*specs
)
3747 int quals
= ((specs
->const_p
? TYPE_QUAL_CONST
: 0)
3748 | (specs
->volatile_p
? TYPE_QUAL_VOLATILE
: 0)
3749 | (specs
->restrict_p
? TYPE_QUAL_RESTRICT
: 0)
3750 | (ENCODE_QUAL_ADDR_SPACE (specs
->address_space
)));
3751 gcc_assert (!specs
->type
3752 && !specs
->decl_attr
3753 && specs
->typespec_word
== cts_none
3754 && specs
->storage_class
== csc_none
3755 && !specs
->typedef_p
3756 && !specs
->explicit_signed_p
3757 && !specs
->deprecated_p
3759 && !specs
->long_long_p
3762 && !specs
->unsigned_p
3763 && !specs
->complex_p
3765 && !specs
->thread_p
);
3769 /* Construct an array declarator. LOC is the location of the
3770 beginning of the array (usually the opening brace). EXPR is the
3771 expression inside [], or NULL_TREE. QUALS are the type qualifiers
3772 inside the [] (to be applied to the pointer to which a parameter
3773 array is converted). STATIC_P is true if "static" is inside the
3774 [], false otherwise. VLA_UNSPEC_P is true if the array is [*], a
3775 VLA of unspecified length which is nevertheless a complete type,
3776 false otherwise. The field for the contained declarator is left to
3777 be filled in by set_array_declarator_inner. */
3779 struct c_declarator
*
3780 build_array_declarator (location_t loc
,
3781 tree expr
, struct c_declspecs
*quals
, bool static_p
,
3784 struct c_declarator
*declarator
= XOBNEW (&parser_obstack
,
3785 struct c_declarator
);
3786 declarator
->id_loc
= loc
;
3787 declarator
->kind
= cdk_array
;
3788 declarator
->declarator
= 0;
3789 declarator
->u
.array
.dimen
= expr
;
3792 declarator
->u
.array
.attrs
= quals
->attrs
;
3793 declarator
->u
.array
.quals
= quals_from_declspecs (quals
);
3797 declarator
->u
.array
.attrs
= NULL_TREE
;
3798 declarator
->u
.array
.quals
= 0;
3800 declarator
->u
.array
.static_p
= static_p
;
3801 declarator
->u
.array
.vla_unspec_p
= vla_unspec_p
;
3804 if (static_p
|| quals
!= NULL
)
3805 pedwarn (loc
, OPT_pedantic
,
3806 "ISO C90 does not support %<static%> or type "
3807 "qualifiers in parameter array declarators");
3809 pedwarn (loc
, OPT_pedantic
,
3810 "ISO C90 does not support %<[*]%> array declarators");
3814 if (!current_scope
->parm_flag
)
3817 error_at (loc
, "%<[*]%> not allowed in other than "
3818 "function prototype scope");
3819 declarator
->u
.array
.vla_unspec_p
= false;
3822 current_scope
->had_vla_unspec
= true;
3827 /* Set the contained declarator of an array declarator. DECL is the
3828 declarator, as constructed by build_array_declarator; INNER is what
3829 appears on the left of the []. */
3831 struct c_declarator
*
3832 set_array_declarator_inner (struct c_declarator
*decl
,
3833 struct c_declarator
*inner
)
3835 decl
->declarator
= inner
;
3839 /* INIT is a constructor that forms DECL's initializer. If the final
3840 element initializes a flexible array field, add the size of that
3841 initializer to DECL's size. */
3844 add_flexible_array_elts_to_size (tree decl
, tree init
)
3848 if (VEC_empty (constructor_elt
, CONSTRUCTOR_ELTS (init
)))
3851 elt
= VEC_last (constructor_elt
, CONSTRUCTOR_ELTS (init
))->value
;
3852 type
= TREE_TYPE (elt
);
3853 if (TREE_CODE (type
) == ARRAY_TYPE
3854 && TYPE_SIZE (type
) == NULL_TREE
3855 && TYPE_DOMAIN (type
) != NULL_TREE
3856 && TYPE_MAX_VALUE (TYPE_DOMAIN (type
)) == NULL_TREE
)
3858 complete_array_type (&type
, elt
, false);
3860 = size_binop (PLUS_EXPR
, DECL_SIZE (decl
), TYPE_SIZE (type
));
3861 DECL_SIZE_UNIT (decl
)
3862 = size_binop (PLUS_EXPR
, DECL_SIZE_UNIT (decl
), TYPE_SIZE_UNIT (type
));
3866 /* Decode a "typename", such as "int **", returning a ..._TYPE node.
3867 Set *EXPR, if EXPR not NULL, to any expression to be evaluated
3868 before the type name, and set *EXPR_CONST_OPERANDS, if
3869 EXPR_CONST_OPERANDS not NULL, to indicate whether the type name may
3870 appear in a constant expression. */
3873 groktypename (struct c_type_name
*type_name
, tree
*expr
,
3874 bool *expr_const_operands
)
3877 tree attrs
= type_name
->specs
->attrs
;
3879 type_name
->specs
->attrs
= NULL_TREE
;
3881 type
= grokdeclarator (type_name
->declarator
, type_name
->specs
, TYPENAME
,
3882 false, NULL
, &attrs
, expr
, expr_const_operands
,
3885 /* Apply attributes. */
3886 decl_attributes (&type
, attrs
, 0);
3891 /* Decode a declarator in an ordinary declaration or data definition.
3892 This is called as soon as the type information and variable name
3893 have been parsed, before parsing the initializer if any.
3894 Here we create the ..._DECL node, fill in its type,
3895 and put it on the list of decls for the current context.
3896 The ..._DECL node is returned as the value.
3898 Exception: for arrays where the length is not specified,
3899 the type is left null, to be filled in by `finish_decl'.
3901 Function definitions do not come here; they go to start_function
3902 instead. However, external and forward declarations of functions
3903 do go through here. Structure field declarations are done by
3904 grokfield and not through here. */
3907 start_decl (struct c_declarator
*declarator
, struct c_declspecs
*declspecs
,
3908 bool initialized
, tree attributes
)
3912 tree expr
= NULL_TREE
;
3913 enum deprecated_states deprecated_state
= DEPRECATED_NORMAL
;
3915 /* An object declared as __attribute__((deprecated)) suppresses
3916 warnings of uses of other deprecated items. */
3917 if (lookup_attribute ("deprecated", attributes
))
3918 deprecated_state
= DEPRECATED_SUPPRESS
;
3920 decl
= grokdeclarator (declarator
, declspecs
,
3921 NORMAL
, initialized
, NULL
, &attributes
, &expr
, NULL
,
3929 if (TREE_CODE (decl
) != FUNCTION_DECL
&& MAIN_NAME_P (DECL_NAME (decl
)))
3930 warning (OPT_Wmain
, "%q+D is usually a function", decl
);
3933 /* Is it valid for this decl to have an initializer at all?
3934 If not, set INITIALIZED to zero, which will indirectly
3935 tell 'finish_decl' to ignore the initializer once it is parsed. */
3936 switch (TREE_CODE (decl
))
3939 error ("typedef %qD is initialized (use __typeof__ instead)", decl
);
3944 error ("function %qD is initialized like a variable", decl
);
3949 /* DECL_INITIAL in a PARM_DECL is really DECL_ARG_TYPE. */
3950 error ("parameter %qD is initialized", decl
);
3955 /* Don't allow initializations for incomplete types except for
3956 arrays which might be completed by the initialization. */
3958 /* This can happen if the array size is an undefined macro.
3959 We already gave a warning, so we don't need another one. */
3960 if (TREE_TYPE (decl
) == error_mark_node
)
3962 else if (COMPLETE_TYPE_P (TREE_TYPE (decl
)))
3964 /* A complete type is ok if size is fixed. */
3966 if (TREE_CODE (TYPE_SIZE (TREE_TYPE (decl
))) != INTEGER_CST
3967 || C_DECL_VARIABLE_SIZE (decl
))
3969 error ("variable-sized object may not be initialized");
3973 else if (TREE_CODE (TREE_TYPE (decl
)) != ARRAY_TYPE
)
3975 error ("variable %qD has initializer but incomplete type", decl
);
3978 else if (C_DECL_VARIABLE_SIZE (decl
))
3980 /* Although C99 is unclear about whether incomplete arrays
3981 of VLAs themselves count as VLAs, it does not make
3982 sense to permit them to be initialized given that
3983 ordinary VLAs may not be initialized. */
3984 error ("variable-sized object may not be initialized");
3991 if (current_scope
== file_scope
)
3992 TREE_STATIC (decl
) = 1;
3994 /* Tell 'pushdecl' this is an initialized decl
3995 even though we don't yet have the initializer expression.
3996 Also tell 'finish_decl' it may store the real initializer. */
3997 DECL_INITIAL (decl
) = error_mark_node
;
4000 /* If this is a function declaration, write a record describing it to the
4001 prototypes file (if requested). */
4003 if (TREE_CODE (decl
) == FUNCTION_DECL
)
4004 gen_aux_info_record (decl
, 0, 0, TYPE_ARG_TYPES (TREE_TYPE (decl
)) != 0);
4006 /* ANSI specifies that a tentative definition which is not merged with
4007 a non-tentative definition behaves exactly like a definition with an
4008 initializer equal to zero. (Section 3.7.2)
4010 -fno-common gives strict ANSI behavior, though this tends to break
4011 a large body of code that grew up without this rule.
4013 Thread-local variables are never common, since there's no entrenched
4014 body of code to break, and it allows more efficient variable references
4015 in the presence of dynamic linking. */
4017 if (TREE_CODE (decl
) == VAR_DECL
4019 && TREE_PUBLIC (decl
)
4020 && !DECL_THREAD_LOCAL_P (decl
)
4022 DECL_COMMON (decl
) = 1;
4024 /* Set attributes here so if duplicate decl, will have proper attributes. */
4025 decl_attributes (&decl
, attributes
, 0);
4027 /* Handle gnu_inline attribute. */
4028 if (declspecs
->inline_p
4029 && !flag_gnu89_inline
4030 && TREE_CODE (decl
) == FUNCTION_DECL
4031 && (lookup_attribute ("gnu_inline", DECL_ATTRIBUTES (decl
))
4032 || current_function_decl
))
4034 if (declspecs
->storage_class
== csc_auto
&& current_scope
!= file_scope
)
4036 else if (declspecs
->storage_class
!= csc_static
)
4037 DECL_EXTERNAL (decl
) = !DECL_EXTERNAL (decl
);
4040 if (TREE_CODE (decl
) == FUNCTION_DECL
4041 && targetm
.calls
.promote_prototypes (TREE_TYPE (decl
)))
4043 struct c_declarator
*ce
= declarator
;
4045 if (ce
->kind
== cdk_pointer
)
4046 ce
= declarator
->declarator
;
4047 if (ce
->kind
== cdk_function
)
4049 tree args
= ce
->u
.arg_info
->parms
;
4050 for (; args
; args
= DECL_CHAIN (args
))
4052 tree type
= TREE_TYPE (args
);
4053 if (type
&& INTEGRAL_TYPE_P (type
)
4054 && TYPE_PRECISION (type
) < TYPE_PRECISION (integer_type_node
))
4055 DECL_ARG_TYPE (args
) = integer_type_node
;
4060 if (TREE_CODE (decl
) == FUNCTION_DECL
4061 && DECL_DECLARED_INLINE_P (decl
)
4062 && DECL_UNINLINABLE (decl
)
4063 && lookup_attribute ("noinline", DECL_ATTRIBUTES (decl
)))
4064 warning (OPT_Wattributes
, "inline function %q+D given attribute noinline",
4067 /* C99 6.7.4p3: An inline definition of a function with external
4068 linkage shall not contain a definition of a modifiable object
4069 with static storage duration... */
4070 if (TREE_CODE (decl
) == VAR_DECL
4071 && current_scope
!= file_scope
4072 && TREE_STATIC (decl
)
4073 && !TREE_READONLY (decl
)
4074 && DECL_DECLARED_INLINE_P (current_function_decl
)
4075 && DECL_EXTERNAL (current_function_decl
))
4076 record_inline_static (input_location
, current_function_decl
,
4077 decl
, csi_modifiable
);
4079 if (c_dialect_objc ()
4080 && (TREE_CODE (decl
) == VAR_DECL
4081 || TREE_CODE (decl
) == FUNCTION_DECL
))
4082 objc_check_global_decl (decl
);
4084 /* Add this decl to the current scope.
4085 TEM may equal DECL or it may be a previous decl of the same name. */
4086 tem
= pushdecl (decl
);
4088 if (initialized
&& DECL_EXTERNAL (tem
))
4090 DECL_EXTERNAL (tem
) = 0;
4091 TREE_STATIC (tem
) = 1;
4097 /* Subroutine of finish_decl. TYPE is the type of an uninitialized object
4098 DECL or the non-array element type if DECL is an uninitialized array.
4099 If that type has a const member, diagnose this. */
4102 diagnose_uninitialized_cst_member (tree decl
, tree type
)
4105 for (field
= TYPE_FIELDS (type
); field
; field
= TREE_CHAIN (field
))
4108 if (TREE_CODE (field
) != FIELD_DECL
)
4110 field_type
= strip_array_types (TREE_TYPE (field
));
4112 if (TYPE_QUALS (field_type
) & TYPE_QUAL_CONST
)
4114 warning_at (DECL_SOURCE_LOCATION (decl
), OPT_Wc___compat
,
4115 "uninitialized const member in %qT is invalid in C++",
4116 strip_array_types (TREE_TYPE (decl
)));
4117 inform (DECL_SOURCE_LOCATION (field
), "%qD should be initialized", field
);
4120 if (TREE_CODE (field_type
) == RECORD_TYPE
4121 || TREE_CODE (field_type
) == UNION_TYPE
)
4122 diagnose_uninitialized_cst_member (decl
, field_type
);
4126 /* Finish processing of a declaration;
4127 install its initial value.
4128 If ORIGTYPE is not NULL_TREE, it is the original type of INIT.
4129 If the length of an array type is not known before,
4130 it must be determined now, from the initial value, or it is an error.
4132 INIT_LOC is the location of the initial value. */
4135 finish_decl (tree decl
, location_t init_loc
, tree init
,
4136 tree origtype
, tree asmspec_tree
)
4139 bool was_incomplete
= (DECL_SIZE (decl
) == 0);
4140 const char *asmspec
= 0;
4142 /* If a name was specified, get the string. */
4143 if ((TREE_CODE (decl
) == FUNCTION_DECL
|| TREE_CODE (decl
) == VAR_DECL
)
4144 && DECL_FILE_SCOPE_P (decl
))
4145 asmspec_tree
= maybe_apply_renaming_pragma (decl
, asmspec_tree
);
4147 asmspec
= TREE_STRING_POINTER (asmspec_tree
);
4149 if (TREE_CODE (decl
) == VAR_DECL
4150 && TREE_STATIC (decl
)
4151 && global_bindings_p ())
4152 /* So decl is a global variable. Record the types it uses
4153 so that we can decide later to emit debug info for them. */
4154 record_types_used_by_current_var_decl (decl
);
4156 /* If `start_decl' didn't like having an initialization, ignore it now. */
4157 if (init
!= 0 && DECL_INITIAL (decl
) == 0)
4160 /* Don't crash if parm is initialized. */
4161 if (TREE_CODE (decl
) == PARM_DECL
)
4165 store_init_value (init_loc
, decl
, init
, origtype
);
4167 if (c_dialect_objc () && (TREE_CODE (decl
) == VAR_DECL
4168 || TREE_CODE (decl
) == FUNCTION_DECL
4169 || TREE_CODE (decl
) == FIELD_DECL
))
4170 objc_check_decl (decl
);
4172 type
= TREE_TYPE (decl
);
4174 /* Deduce size of array from initialization, if not already known. */
4175 if (TREE_CODE (type
) == ARRAY_TYPE
4176 && TYPE_DOMAIN (type
) == 0
4177 && TREE_CODE (decl
) != TYPE_DECL
)
4180 = (TREE_STATIC (decl
)
4181 /* Even if pedantic, an external linkage array
4182 may have incomplete type at first. */
4183 ? pedantic
&& !TREE_PUBLIC (decl
)
4184 : !DECL_EXTERNAL (decl
));
4186 = complete_array_type (&TREE_TYPE (decl
), DECL_INITIAL (decl
),
4189 /* Get the completed type made by complete_array_type. */
4190 type
= TREE_TYPE (decl
);
4195 error ("initializer fails to determine size of %q+D", decl
);
4200 error ("array size missing in %q+D", decl
);
4201 /* If a `static' var's size isn't known,
4202 make it extern as well as static, so it does not get
4204 If it is not `static', then do not mark extern;
4205 finish_incomplete_decl will give it a default size
4206 and it will get allocated. */
4207 else if (!pedantic
&& TREE_STATIC (decl
) && !TREE_PUBLIC (decl
))
4208 DECL_EXTERNAL (decl
) = 1;
4212 error ("zero or negative size array %q+D", decl
);
4216 /* For global variables, update the copy of the type that
4217 exists in the binding. */
4218 if (TREE_PUBLIC (decl
))
4220 struct c_binding
*b_ext
= I_SYMBOL_BINDING (DECL_NAME (decl
));
4221 while (b_ext
&& !B_IN_EXTERNAL_SCOPE (b_ext
))
4222 b_ext
= b_ext
->shadowed
;
4226 b_ext
->u
.type
= composite_type (b_ext
->u
.type
, type
);
4228 b_ext
->u
.type
= type
;
4237 if (DECL_INITIAL (decl
))
4238 TREE_TYPE (DECL_INITIAL (decl
)) = type
;
4240 layout_decl (decl
, 0);
4243 if (TREE_CODE (decl
) == VAR_DECL
)
4245 if (init
&& TREE_CODE (init
) == CONSTRUCTOR
)
4246 add_flexible_array_elts_to_size (decl
, init
);
4248 if (DECL_SIZE (decl
) == 0 && TREE_TYPE (decl
) != error_mark_node
4249 && COMPLETE_TYPE_P (TREE_TYPE (decl
)))
4250 layout_decl (decl
, 0);
4252 if (DECL_SIZE (decl
) == 0
4253 /* Don't give an error if we already gave one earlier. */
4254 && TREE_TYPE (decl
) != error_mark_node
4255 && (TREE_STATIC (decl
)
4256 /* A static variable with an incomplete type
4257 is an error if it is initialized.
4258 Also if it is not file scope.
4259 Otherwise, let it through, but if it is not `extern'
4260 then it may cause an error message later. */
4261 ? (DECL_INITIAL (decl
) != 0
4262 || !DECL_FILE_SCOPE_P (decl
))
4263 /* An automatic variable with an incomplete type
4265 : !DECL_EXTERNAL (decl
)))
4267 error ("storage size of %q+D isn%'t known", decl
);
4268 TREE_TYPE (decl
) = error_mark_node
;
4271 if ((DECL_EXTERNAL (decl
) || TREE_STATIC (decl
))
4272 && DECL_SIZE (decl
) != 0)
4274 if (TREE_CODE (DECL_SIZE (decl
)) == INTEGER_CST
)
4275 constant_expression_warning (DECL_SIZE (decl
));
4278 error ("storage size of %q+D isn%'t constant", decl
);
4279 TREE_TYPE (decl
) = error_mark_node
;
4283 if (TREE_USED (type
))
4285 TREE_USED (decl
) = 1;
4286 DECL_READ_P (decl
) = 1;
4290 /* If this is a function and an assembler name is specified, reset DECL_RTL
4291 so we can give it its new name. Also, update built_in_decls if it
4292 was a normal built-in. */
4293 if (TREE_CODE (decl
) == FUNCTION_DECL
&& asmspec
)
4295 if (DECL_BUILT_IN_CLASS (decl
) == BUILT_IN_NORMAL
)
4296 set_builtin_user_assembler_name (decl
, asmspec
);
4297 set_user_assembler_name (decl
, asmspec
);
4300 /* If #pragma weak was used, mark the decl weak now. */
4301 maybe_apply_pragma_weak (decl
);
4303 /* Output the assembler code and/or RTL code for variables and functions,
4304 unless the type is an undefined structure or union.
4305 If not, it will get done when the type is completed. */
4307 if (TREE_CODE (decl
) == VAR_DECL
|| TREE_CODE (decl
) == FUNCTION_DECL
)
4309 /* Determine the ELF visibility. */
4310 if (TREE_PUBLIC (decl
))
4311 c_determine_visibility (decl
);
4313 /* This is a no-op in c-lang.c or something real in objc-act.c. */
4314 if (c_dialect_objc ())
4315 objc_check_decl (decl
);
4319 /* If this is not a static variable, issue a warning.
4320 It doesn't make any sense to give an ASMSPEC for an
4321 ordinary, non-register local variable. Historically,
4322 GCC has accepted -- but ignored -- the ASMSPEC in
4324 if (!DECL_FILE_SCOPE_P (decl
)
4325 && TREE_CODE (decl
) == VAR_DECL
4326 && !C_DECL_REGISTER (decl
)
4327 && !TREE_STATIC (decl
))
4328 warning (0, "ignoring asm-specifier for non-static local "
4329 "variable %q+D", decl
);
4331 set_user_assembler_name (decl
, asmspec
);
4334 if (DECL_FILE_SCOPE_P (decl
))
4336 if (DECL_INITIAL (decl
) == NULL_TREE
4337 || DECL_INITIAL (decl
) == error_mark_node
)
4338 /* Don't output anything
4339 when a tentative file-scope definition is seen.
4340 But at end of compilation, do output code for them. */
4341 DECL_DEFER_OUTPUT (decl
) = 1;
4342 rest_of_decl_compilation (decl
, true, 0);
4346 /* In conjunction with an ASMSPEC, the `register'
4347 keyword indicates that we should place the variable
4348 in a particular register. */
4349 if (asmspec
&& C_DECL_REGISTER (decl
))
4351 DECL_HARD_REGISTER (decl
) = 1;
4352 /* This cannot be done for a structure with volatile
4353 fields, on which DECL_REGISTER will have been
4355 if (!DECL_REGISTER (decl
))
4356 error ("cannot put object with volatile field into register");
4359 if (TREE_CODE (decl
) != FUNCTION_DECL
)
4361 /* If we're building a variable sized type, and we might be
4362 reachable other than via the top of the current binding
4363 level, then create a new BIND_EXPR so that we deallocate
4364 the object at the right time. */
4365 /* Note that DECL_SIZE can be null due to errors. */
4366 if (DECL_SIZE (decl
)
4367 && !TREE_CONSTANT (DECL_SIZE (decl
))
4368 && STATEMENT_LIST_HAS_LABEL (cur_stmt_list
))
4371 bind
= build3 (BIND_EXPR
, void_type_node
, NULL
, NULL
, NULL
);
4372 TREE_SIDE_EFFECTS (bind
) = 1;
4374 BIND_EXPR_BODY (bind
) = push_stmt_list ();
4376 add_stmt (build_stmt (DECL_SOURCE_LOCATION (decl
),
4382 if (!DECL_FILE_SCOPE_P (decl
))
4384 /* Recompute the RTL of a local array now
4385 if it used to be an incomplete type. */
4387 && !TREE_STATIC (decl
) && !DECL_EXTERNAL (decl
))
4389 /* If we used it already as memory, it must stay in memory. */
4390 TREE_ADDRESSABLE (decl
) = TREE_USED (decl
);
4391 /* If it's still incomplete now, no init will save it. */
4392 if (DECL_SIZE (decl
) == 0)
4393 DECL_INITIAL (decl
) = 0;
4398 if (TREE_CODE (decl
) == TYPE_DECL
)
4400 if (!DECL_FILE_SCOPE_P (decl
)
4401 && variably_modified_type_p (TREE_TYPE (decl
), NULL_TREE
))
4402 add_stmt (build_stmt (DECL_SOURCE_LOCATION (decl
), DECL_EXPR
, decl
));
4404 rest_of_decl_compilation (decl
, DECL_FILE_SCOPE_P (decl
), 0);
4407 /* At the end of a declaration, throw away any variable type sizes
4408 of types defined inside that declaration. There is no use
4409 computing them in the following function definition. */
4410 if (current_scope
== file_scope
)
4411 get_pending_sizes ();
4413 /* Install a cleanup (aka destructor) if one was given. */
4414 if (TREE_CODE (decl
) == VAR_DECL
&& !TREE_STATIC (decl
))
4416 tree attr
= lookup_attribute ("cleanup", DECL_ATTRIBUTES (decl
));
4419 tree cleanup_id
= TREE_VALUE (TREE_VALUE (attr
));
4420 tree cleanup_decl
= lookup_name (cleanup_id
);
4424 /* Build "cleanup(&decl)" for the destructor. */
4425 cleanup
= build_unary_op (input_location
, ADDR_EXPR
, decl
, 0);
4426 vec
= VEC_alloc (tree
, gc
, 1);
4427 VEC_quick_push (tree
, vec
, cleanup
);
4428 cleanup
= build_function_call_vec (DECL_SOURCE_LOCATION (decl
),
4429 cleanup_decl
, vec
, NULL
);
4430 VEC_free (tree
, gc
, vec
);
4432 /* Don't warn about decl unused; the cleanup uses it. */
4433 TREE_USED (decl
) = 1;
4434 TREE_USED (cleanup_decl
) = 1;
4435 DECL_READ_P (decl
) = 1;
4437 push_cleanup (decl
, cleanup
, false);
4442 && TREE_CODE (decl
) == VAR_DECL
4443 && !DECL_EXTERNAL (decl
)
4444 && DECL_INITIAL (decl
) == NULL_TREE
)
4446 type
= strip_array_types (type
);
4447 if (TREE_READONLY (decl
))
4448 warning_at (DECL_SOURCE_LOCATION (decl
), OPT_Wc___compat
,
4449 "uninitialized const %qD is invalid in C++", decl
);
4450 else if ((TREE_CODE (type
) == RECORD_TYPE
4451 || TREE_CODE (type
) == UNION_TYPE
)
4452 && C_TYPE_FIELDS_READONLY (type
))
4453 diagnose_uninitialized_cst_member (decl
, type
);
4457 /* Given a parsed parameter declaration, decode it into a PARM_DECL. */
4460 grokparm (const struct c_parm
*parm
)
4462 tree attrs
= parm
->attrs
;
4463 tree decl
= grokdeclarator (parm
->declarator
, parm
->specs
, PARM
, false,
4464 NULL
, &attrs
, NULL
, NULL
, DEPRECATED_NORMAL
);
4466 decl_attributes (&decl
, attrs
, 0);
4471 /* Given a parsed parameter declaration, decode it into a PARM_DECL
4472 and push that on the current scope. */
4475 push_parm_decl (const struct c_parm
*parm
)
4477 tree attrs
= parm
->attrs
;
4480 decl
= grokdeclarator (parm
->declarator
, parm
->specs
, PARM
, false, NULL
,
4481 &attrs
, NULL
, NULL
, DEPRECATED_NORMAL
);
4482 decl_attributes (&decl
, attrs
, 0);
4484 decl
= pushdecl (decl
);
4486 finish_decl (decl
, input_location
, NULL_TREE
, NULL_TREE
, NULL_TREE
);
4489 /* Mark all the parameter declarations to date as forward decls.
4490 Also diagnose use of this extension. */
4493 mark_forward_parm_decls (void)
4495 struct c_binding
*b
;
4497 if (pedantic
&& !current_scope
->warned_forward_parm_decls
)
4499 pedwarn (input_location
, OPT_pedantic
,
4500 "ISO C forbids forward parameter declarations");
4501 current_scope
->warned_forward_parm_decls
= true;
4504 for (b
= current_scope
->bindings
; b
; b
= b
->prev
)
4505 if (TREE_CODE (b
->decl
) == PARM_DECL
)
4506 TREE_ASM_WRITTEN (b
->decl
) = 1;
4509 /* Build a COMPOUND_LITERAL_EXPR. TYPE is the type given in the compound
4510 literal, which may be an incomplete array type completed by the
4511 initializer; INIT is a CONSTRUCTOR at LOC that initializes the compound
4512 literal. NON_CONST is true if the initializers contain something
4513 that cannot occur in a constant expression. */
4516 build_compound_literal (location_t loc
, tree type
, tree init
, bool non_const
)
4518 /* We do not use start_decl here because we have a type, not a declarator;
4519 and do not use finish_decl because the decl should be stored inside
4520 the COMPOUND_LITERAL_EXPR rather than added elsewhere as a DECL_EXPR. */
4525 if (type
== error_mark_node
4526 || init
== error_mark_node
)
4527 return error_mark_node
;
4529 decl
= build_decl (loc
, VAR_DECL
, NULL_TREE
, type
);
4530 DECL_EXTERNAL (decl
) = 0;
4531 TREE_PUBLIC (decl
) = 0;
4532 TREE_STATIC (decl
) = (current_scope
== file_scope
);
4533 DECL_CONTEXT (decl
) = current_function_decl
;
4534 TREE_USED (decl
) = 1;
4535 DECL_READ_P (decl
) = 1;
4536 TREE_TYPE (decl
) = type
;
4537 TREE_READONLY (decl
) = TYPE_READONLY (type
);
4538 store_init_value (loc
, decl
, init
, NULL_TREE
);
4540 if (TREE_CODE (type
) == ARRAY_TYPE
&& !COMPLETE_TYPE_P (type
))
4542 int failure
= complete_array_type (&TREE_TYPE (decl
),
4543 DECL_INITIAL (decl
), true);
4544 gcc_assert (!failure
);
4546 type
= TREE_TYPE (decl
);
4547 TREE_TYPE (DECL_INITIAL (decl
)) = type
;
4550 if (type
== error_mark_node
|| !COMPLETE_TYPE_P (type
))
4551 return error_mark_node
;
4553 stmt
= build_stmt (DECL_SOURCE_LOCATION (decl
), DECL_EXPR
, decl
);
4554 complit
= build1 (COMPOUND_LITERAL_EXPR
, type
, stmt
);
4555 TREE_SIDE_EFFECTS (complit
) = 1;
4557 layout_decl (decl
, 0);
4559 if (TREE_STATIC (decl
))
4561 /* This decl needs a name for the assembler output. */
4562 set_compound_literal_name (decl
);
4563 DECL_DEFER_OUTPUT (decl
) = 1;
4564 DECL_COMDAT (decl
) = 1;
4565 DECL_ARTIFICIAL (decl
) = 1;
4566 DECL_IGNORED_P (decl
) = 1;
4568 rest_of_decl_compilation (decl
, 1, 0);
4573 complit
= build2 (C_MAYBE_CONST_EXPR
, type
, NULL
, complit
);
4574 C_MAYBE_CONST_EXPR_NON_CONST (complit
) = 1;
4580 /* Check the type of a compound literal. Here we just check that it
4581 is valid for C++. */
4584 check_compound_literal_type (location_t loc
, struct c_type_name
*type_name
)
4587 && (type_name
->specs
->typespec_kind
== ctsk_tagdef
4588 || type_name
->specs
->typespec_kind
== ctsk_tagfirstref
))
4589 warning_at (loc
, OPT_Wc___compat
,
4590 "defining a type in a compound literal is invalid in C++");
4593 /* Determine whether TYPE is a structure with a flexible array member,
4594 or a union containing such a structure (possibly recursively). */
4597 flexible_array_type_p (tree type
)
4600 switch (TREE_CODE (type
))
4603 x
= TYPE_FIELDS (type
);
4606 while (DECL_CHAIN (x
) != NULL_TREE
)
4608 if (TREE_CODE (TREE_TYPE (x
)) == ARRAY_TYPE
4609 && TYPE_SIZE (TREE_TYPE (x
)) == NULL_TREE
4610 && TYPE_DOMAIN (TREE_TYPE (x
)) != NULL_TREE
4611 && TYPE_MAX_VALUE (TYPE_DOMAIN (TREE_TYPE (x
))) == NULL_TREE
)
4615 for (x
= TYPE_FIELDS (type
); x
!= NULL_TREE
; x
= DECL_CHAIN (x
))
4617 if (flexible_array_type_p (TREE_TYPE (x
)))
4626 /* Performs sanity checks on the TYPE and WIDTH of the bit-field NAME,
4627 replacing with appropriate values if they are invalid. */
4629 check_bitfield_type_and_width (tree
*type
, tree
*width
, tree orig_name
)
4632 unsigned int max_width
;
4633 unsigned HOST_WIDE_INT w
;
4634 const char *name
= (orig_name
4635 ? identifier_to_locale (IDENTIFIER_POINTER (orig_name
))
4636 : _("<anonymous>"));
4638 /* Detect and ignore out of range field width and process valid
4640 if (!INTEGRAL_TYPE_P (TREE_TYPE (*width
)))
4642 error ("bit-field %qs width not an integer constant", name
);
4643 *width
= integer_one_node
;
4647 if (TREE_CODE (*width
) != INTEGER_CST
)
4649 *width
= c_fully_fold (*width
, false, NULL
);
4650 if (TREE_CODE (*width
) == INTEGER_CST
)
4651 pedwarn (input_location
, OPT_pedantic
,
4652 "bit-field %qs width not an integer constant expression",
4655 if (TREE_CODE (*width
) != INTEGER_CST
)
4657 error ("bit-field %qs width not an integer constant", name
);
4658 *width
= integer_one_node
;
4660 constant_expression_warning (*width
);
4661 if (tree_int_cst_sgn (*width
) < 0)
4663 error ("negative width in bit-field %qs", name
);
4664 *width
= integer_one_node
;
4666 else if (integer_zerop (*width
) && orig_name
)
4668 error ("zero width for bit-field %qs", name
);
4669 *width
= integer_one_node
;
4673 /* Detect invalid bit-field type. */
4674 if (TREE_CODE (*type
) != INTEGER_TYPE
4675 && TREE_CODE (*type
) != BOOLEAN_TYPE
4676 && TREE_CODE (*type
) != ENUMERAL_TYPE
)
4678 error ("bit-field %qs has invalid type", name
);
4679 *type
= unsigned_type_node
;
4682 type_mv
= TYPE_MAIN_VARIANT (*type
);
4683 if (!in_system_header
4684 && type_mv
!= integer_type_node
4685 && type_mv
!= unsigned_type_node
4686 && type_mv
!= boolean_type_node
)
4687 pedwarn (input_location
, OPT_pedantic
,
4688 "type of bit-field %qs is a GCC extension", name
);
4690 max_width
= TYPE_PRECISION (*type
);
4692 if (0 < compare_tree_int (*width
, max_width
))
4694 error ("width of %qs exceeds its type", name
);
4696 *width
= build_int_cst (NULL_TREE
, w
);
4699 w
= tree_low_cst (*width
, 1);
4701 if (TREE_CODE (*type
) == ENUMERAL_TYPE
)
4703 struct lang_type
*lt
= TYPE_LANG_SPECIFIC (*type
);
4705 || w
< tree_int_cst_min_precision (lt
->enum_min
, TYPE_UNSIGNED (*type
))
4706 || w
< tree_int_cst_min_precision (lt
->enum_max
, TYPE_UNSIGNED (*type
)))
4707 warning (0, "%qs is narrower than values of its type", name
);
4713 /* Print warning about variable length array if necessary. */
4716 warn_variable_length_array (tree name
, tree size
)
4718 int const_size
= TREE_CONSTANT (size
);
4720 if (!flag_isoc99
&& pedantic
&& warn_vla
!= 0)
4725 pedwarn (input_location
, OPT_Wvla
,
4726 "ISO C90 forbids array %qE whose size "
4727 "can%'t be evaluated",
4730 pedwarn (input_location
, OPT_Wvla
, "ISO C90 forbids array whose size "
4731 "can%'t be evaluated");
4736 pedwarn (input_location
, OPT_Wvla
,
4737 "ISO C90 forbids variable length array %qE",
4740 pedwarn (input_location
, OPT_Wvla
, "ISO C90 forbids variable length array");
4743 else if (warn_vla
> 0)
4749 "the size of array %qE can"
4750 "%'t be evaluated", name
);
4753 "the size of array can %'t be evaluated");
4759 "variable length array %qE is used",
4763 "variable length array is used");
4768 /* Given a size SIZE that may not be a constant, return a SAVE_EXPR to
4769 serve as the actual size-expression for a type or decl. This is
4770 like variable_size in stor-layout.c, but we make global_bindings_p
4771 return negative to avoid calls to that function from outside the
4772 front end resulting in errors at file scope, then call this version
4773 instead from front-end code. */
4776 c_variable_size (tree size
)
4780 if (TREE_CONSTANT (size
))
4783 size
= save_expr (size
);
4785 save
= skip_simple_arithmetic (size
);
4787 if (cfun
&& cfun
->dont_save_pending_sizes_p
)
4790 if (!global_bindings_p ())
4791 put_pending_size (save
);
4796 /* Given declspecs and a declarator,
4797 determine the name and type of the object declared
4798 and construct a ..._DECL node for it.
4799 (In one case we can return a ..._TYPE node instead.
4800 For invalid input we sometimes return 0.)
4802 DECLSPECS is a c_declspecs structure for the declaration specifiers.
4804 DECL_CONTEXT says which syntactic context this declaration is in:
4805 NORMAL for most contexts. Make a VAR_DECL or FUNCTION_DECL or TYPE_DECL.
4806 FUNCDEF for a function definition. Like NORMAL but a few different
4807 error messages in each case. Return value may be zero meaning
4808 this definition is too screwy to try to parse.
4809 PARM for a parameter declaration (either within a function prototype
4810 or before a function body). Make a PARM_DECL, or return void_type_node.
4811 TYPENAME if for a typename (in a cast or sizeof).
4812 Don't make a DECL node; just return the ..._TYPE node.
4813 FIELD for a struct or union field; make a FIELD_DECL.
4814 INITIALIZED is true if the decl has an initializer.
4815 WIDTH is non-NULL for bit-fields, and is a pointer to an INTEGER_CST node
4816 representing the width of the bit-field.
4817 DECL_ATTRS points to the list of attributes that should be added to this
4818 decl. Any nested attributes that belong on the decl itself will be
4820 If EXPR is not NULL, any expressions that need to be evaluated as
4821 part of evaluating variably modified types will be stored in *EXPR.
4822 If EXPR_CONST_OPERANDS is not NULL, *EXPR_CONST_OPERANDS will be
4823 set to indicate whether operands in *EXPR can be used in constant
4825 DEPRECATED_STATE is a deprecated_states value indicating whether
4826 deprecation warnings should be suppressed.
4828 In the TYPENAME case, DECLARATOR is really an absolute declarator.
4829 It may also be so in the PARM case, for a prototype where the
4830 argument type is specified but not the name.
4832 This function is where the complicated C meanings of `static'
4833 and `extern' are interpreted. */
4836 grokdeclarator (const struct c_declarator
*declarator
,
4837 struct c_declspecs
*declspecs
,
4838 enum decl_context decl_context
, bool initialized
, tree
*width
,
4839 tree
*decl_attrs
, tree
*expr
, bool *expr_const_operands
,
4840 enum deprecated_states deprecated_state
)
4842 tree type
= declspecs
->type
;
4843 bool threadp
= declspecs
->thread_p
;
4844 enum c_storage_class storage_class
= declspecs
->storage_class
;
4848 int type_quals
= TYPE_UNQUALIFIED
;
4849 tree name
= NULL_TREE
;
4850 bool funcdef_flag
= false;
4851 bool funcdef_syntax
= false;
4852 bool size_varies
= false;
4853 tree decl_attr
= declspecs
->decl_attr
;
4854 int array_ptr_quals
= TYPE_UNQUALIFIED
;
4855 tree array_ptr_attrs
= NULL_TREE
;
4856 int array_parm_static
= 0;
4857 bool array_parm_vla_unspec_p
= false;
4858 tree returned_attrs
= NULL_TREE
;
4859 bool bitfield
= width
!= NULL
;
4861 struct c_arg_info
*arg_info
= 0;
4862 addr_space_t as1
, as2
, address_space
;
4863 location_t loc
= UNKNOWN_LOCATION
;
4866 bool expr_const_operands_dummy
;
4868 if (TREE_CODE (type
) == ERROR_MARK
)
4869 return error_mark_node
;
4872 if (expr_const_operands
== NULL
)
4873 expr_const_operands
= &expr_const_operands_dummy
;
4875 *expr
= declspecs
->expr
;
4876 *expr_const_operands
= declspecs
->expr_const_operands
;
4878 if (decl_context
== FUNCDEF
)
4879 funcdef_flag
= true, decl_context
= NORMAL
;
4881 /* Look inside a declarator for the name being declared
4882 and get it as an IDENTIFIER_NODE, for an error message. */
4884 const struct c_declarator
*decl
= declarator
;
4895 funcdef_syntax
= (decl
->kind
== cdk_function
);
4896 decl
= decl
->declarator
;
4900 decl
= decl
->declarator
;
4915 gcc_assert (decl_context
== PARM
4916 || decl_context
== TYPENAME
4917 || (decl_context
== FIELD
4918 && declarator
->kind
== cdk_id
));
4919 gcc_assert (!initialized
);
4923 /* A function definition's declarator must have the form of
4924 a function declarator. */
4926 if (funcdef_flag
&& !funcdef_syntax
)
4929 /* If this looks like a function definition, make it one,
4930 even if it occurs where parms are expected.
4931 Then store_parm_decls will reject it and not use it as a parm. */
4932 if (decl_context
== NORMAL
&& !funcdef_flag
&& current_scope
->parm_flag
)
4933 decl_context
= PARM
;
4935 if (declspecs
->deprecated_p
&& deprecated_state
!= DEPRECATED_SUPPRESS
)
4936 warn_deprecated_use (declspecs
->type
, declspecs
->decl_attr
);
4938 if ((decl_context
== NORMAL
|| decl_context
== FIELD
)
4939 && current_scope
== file_scope
4940 && variably_modified_type_p (type
, NULL_TREE
))
4943 error_at (loc
, "variably modified %qE at file scope", name
);
4945 error_at (loc
, "variably modified field at file scope");
4946 type
= integer_type_node
;
4949 size_varies
= C_TYPE_VARIABLE_SIZE (type
) != 0;
4951 /* Diagnose defaulting to "int". */
4953 if (declspecs
->default_int_p
&& !in_system_header
)
4955 /* Issue a warning if this is an ISO C 99 program or if
4956 -Wreturn-type and this is a function, or if -Wimplicit;
4957 prefer the former warning since it is more explicit. */
4958 if ((warn_implicit_int
|| warn_return_type
|| flag_isoc99
)
4960 warn_about_return_type
= 1;
4964 pedwarn_c99 (loc
, flag_isoc99
? 0 : OPT_Wimplicit_int
,
4965 "type defaults to %<int%> in declaration of %qE",
4968 pedwarn_c99 (input_location
, flag_isoc99
? 0 : OPT_Wimplicit_int
,
4969 "type defaults to %<int%> in type name");
4973 /* Adjust the type if a bit-field is being declared,
4974 -funsigned-bitfields applied and the type is not explicitly
4976 if (bitfield
&& !flag_signed_bitfields
&& !declspecs
->explicit_signed_p
4977 && TREE_CODE (type
) == INTEGER_TYPE
)
4978 type
= unsigned_type_for (type
);
4980 /* Figure out the type qualifiers for the declaration. There are
4981 two ways a declaration can become qualified. One is something
4982 like `const int i' where the `const' is explicit. Another is
4983 something like `typedef const int CI; CI i' where the type of the
4984 declaration contains the `const'. A third possibility is that
4985 there is a type qualifier on the element type of a typedefed
4986 array type, in which case we should extract that qualifier so
4987 that c_apply_type_quals_to_decl receives the full list of
4988 qualifiers to work with (C90 is not entirely clear about whether
4989 duplicate qualifiers should be diagnosed in this case, but it
4990 seems most appropriate to do so). */
4991 element_type
= strip_array_types (type
);
4992 constp
= declspecs
->const_p
+ TYPE_READONLY (element_type
);
4993 restrictp
= declspecs
->restrict_p
+ TYPE_RESTRICT (element_type
);
4994 volatilep
= declspecs
->volatile_p
+ TYPE_VOLATILE (element_type
);
4995 as1
= declspecs
->address_space
;
4996 as2
= TYPE_ADDR_SPACE (element_type
);
4997 address_space
= ADDR_SPACE_GENERIC_P (as1
)? as2
: as1
;
4999 if (pedantic
&& !flag_isoc99
)
5002 pedwarn (loc
, OPT_pedantic
, "duplicate %<const%>");
5004 pedwarn (loc
, OPT_pedantic
, "duplicate %<restrict%>");
5006 pedwarn (loc
, OPT_pedantic
, "duplicate %<volatile%>");
5009 if (!ADDR_SPACE_GENERIC_P (as1
) && !ADDR_SPACE_GENERIC_P (as2
) && as1
!= as2
)
5010 error_at (loc
, "conflicting named address spaces (%s vs %s)",
5011 c_addr_space_name (as1
), c_addr_space_name (as2
));
5013 if (!flag_gen_aux_info
&& (TYPE_QUALS (element_type
)))
5014 type
= TYPE_MAIN_VARIANT (type
);
5015 type_quals
= ((constp
? TYPE_QUAL_CONST
: 0)
5016 | (restrictp
? TYPE_QUAL_RESTRICT
: 0)
5017 | (volatilep
? TYPE_QUAL_VOLATILE
: 0)
5018 | ENCODE_QUAL_ADDR_SPACE (address_space
));
5020 /* Warn about storage classes that are invalid for certain
5021 kinds of declarations (parameters, typenames, etc.). */
5025 || storage_class
== csc_auto
5026 || storage_class
== csc_register
5027 || storage_class
== csc_typedef
))
5029 if (storage_class
== csc_auto
)
5031 (current_scope
== file_scope
) ? 0 : OPT_pedantic
,
5032 "function definition declared %<auto%>");
5033 if (storage_class
== csc_register
)
5034 error_at (loc
, "function definition declared %<register%>");
5035 if (storage_class
== csc_typedef
)
5036 error_at (loc
, "function definition declared %<typedef%>");
5038 error_at (loc
, "function definition declared %<__thread%>");
5040 if (storage_class
== csc_auto
5041 || storage_class
== csc_register
5042 || storage_class
== csc_typedef
)
5043 storage_class
= csc_none
;
5045 else if (decl_context
!= NORMAL
&& (storage_class
!= csc_none
|| threadp
))
5047 if (decl_context
== PARM
&& storage_class
== csc_register
)
5051 switch (decl_context
)
5055 error_at (loc
, "storage class specified for structure "
5058 error_at (loc
, "storage class specified for structure field");
5062 error_at (loc
, "storage class specified for parameter %qE",
5065 error_at (loc
, "storage class specified for unnamed parameter");
5068 error_at (loc
, "storage class specified for typename");
5071 storage_class
= csc_none
;
5075 else if (storage_class
== csc_extern
5079 /* 'extern' with initialization is invalid if not at file scope. */
5080 if (current_scope
== file_scope
)
5082 /* It is fine to have 'extern const' when compiling at C
5083 and C++ intersection. */
5084 if (!(warn_cxx_compat
&& constp
))
5085 warning_at (loc
, 0, "%qE initialized and declared %<extern%>",
5089 error_at (loc
, "%qE has both %<extern%> and initializer", name
);
5091 else if (current_scope
== file_scope
)
5093 if (storage_class
== csc_auto
)
5094 error_at (loc
, "file-scope declaration of %qE specifies %<auto%>",
5096 if (pedantic
&& storage_class
== csc_register
)
5097 pedwarn (input_location
, OPT_pedantic
,
5098 "file-scope declaration of %qE specifies %<register%>", name
);
5102 if (storage_class
== csc_extern
&& funcdef_flag
)
5103 error_at (loc
, "nested function %qE declared %<extern%>", name
);
5104 else if (threadp
&& storage_class
== csc_none
)
5106 error_at (loc
, "function-scope %qE implicitly auto and declared "
5113 /* Now figure out the structure of the declarator proper.
5114 Descend through it, creating more complex types, until we reach
5115 the declared identifier (or NULL_TREE, in an absolute declarator).
5116 At each stage we maintain an unqualified version of the type
5117 together with any qualifiers that should be applied to it with
5118 c_build_qualified_type; this way, array types including
5119 multidimensional array types are first built up in unqualified
5120 form and then the qualified form is created with
5121 TYPE_MAIN_VARIANT pointing to the unqualified form. */
5123 while (declarator
&& declarator
->kind
!= cdk_id
)
5125 if (type
== error_mark_node
)
5127 declarator
= declarator
->declarator
;
5131 /* Each level of DECLARATOR is either a cdk_array (for ...[..]),
5132 a cdk_pointer (for *...),
5133 a cdk_function (for ...(...)),
5134 a cdk_attrs (for nested attributes),
5135 or a cdk_id (for the name being declared
5136 or the place in an absolute declarator
5137 where the name was omitted).
5138 For the last case, we have just exited the loop.
5140 At this point, TYPE is the type of elements of an array,
5141 or for a function to return, or for a pointer to point to.
5142 After this sequence of ifs, TYPE is the type of the
5143 array or function or pointer, and DECLARATOR has had its
5144 outermost layer removed. */
5146 if (array_ptr_quals
!= TYPE_UNQUALIFIED
5147 || array_ptr_attrs
!= NULL_TREE
5148 || array_parm_static
)
5150 /* Only the innermost declarator (making a parameter be of
5151 array type which is converted to pointer type)
5152 may have static or type qualifiers. */
5153 error_at (loc
, "static or type qualifiers in non-parameter array declarator");
5154 array_ptr_quals
= TYPE_UNQUALIFIED
;
5155 array_ptr_attrs
= NULL_TREE
;
5156 array_parm_static
= 0;
5159 switch (declarator
->kind
)
5163 /* A declarator with embedded attributes. */
5164 tree attrs
= declarator
->u
.attrs
;
5165 const struct c_declarator
*inner_decl
;
5167 declarator
= declarator
->declarator
;
5168 inner_decl
= declarator
;
5169 while (inner_decl
->kind
== cdk_attrs
)
5170 inner_decl
= inner_decl
->declarator
;
5171 if (inner_decl
->kind
== cdk_id
)
5172 attr_flags
|= (int) ATTR_FLAG_DECL_NEXT
;
5173 else if (inner_decl
->kind
== cdk_function
)
5174 attr_flags
|= (int) ATTR_FLAG_FUNCTION_NEXT
;
5175 else if (inner_decl
->kind
== cdk_array
)
5176 attr_flags
|= (int) ATTR_FLAG_ARRAY_NEXT
;
5177 returned_attrs
= decl_attributes (&type
,
5178 chainon (returned_attrs
, attrs
),
5184 tree itype
= NULL_TREE
;
5185 tree size
= declarator
->u
.array
.dimen
;
5186 /* The index is a signed object `sizetype' bits wide. */
5187 tree index_type
= c_common_signed_type (sizetype
);
5189 array_ptr_quals
= declarator
->u
.array
.quals
;
5190 array_ptr_attrs
= declarator
->u
.array
.attrs
;
5191 array_parm_static
= declarator
->u
.array
.static_p
;
5192 array_parm_vla_unspec_p
= declarator
->u
.array
.vla_unspec_p
;
5194 declarator
= declarator
->declarator
;
5196 /* Check for some types that there cannot be arrays of. */
5198 if (VOID_TYPE_P (type
))
5201 error_at (loc
, "declaration of %qE as array of voids", name
);
5203 error_at (loc
, "declaration of type name as array of voids");
5204 type
= error_mark_node
;
5207 if (TREE_CODE (type
) == FUNCTION_TYPE
)
5210 error_at (loc
, "declaration of %qE as array of functions",
5213 error_at (loc
, "declaration of type name as array of "
5215 type
= error_mark_node
;
5218 if (pedantic
&& !in_system_header
&& flexible_array_type_p (type
))
5219 pedwarn (loc
, OPT_pedantic
,
5220 "invalid use of structure with flexible array member");
5222 if (size
== error_mark_node
)
5223 type
= error_mark_node
;
5225 if (type
== error_mark_node
)
5228 /* If size was specified, set ITYPE to a range-type for
5229 that size. Otherwise, ITYPE remains null. finish_decl
5230 may figure it out from an initial value. */
5234 bool size_maybe_const
= true;
5235 bool size_int_const
= (TREE_CODE (size
) == INTEGER_CST
5236 && !TREE_OVERFLOW (size
));
5237 bool this_size_varies
= false;
5239 /* Strip NON_LVALUE_EXPRs since we aren't using as an
5241 STRIP_TYPE_NOPS (size
);
5243 if (!INTEGRAL_TYPE_P (TREE_TYPE (size
)))
5246 error_at (loc
, "size of array %qE has non-integer type",
5250 "size of unnamed array has non-integer type");
5251 size
= integer_one_node
;
5254 size
= c_fully_fold (size
, false, &size_maybe_const
);
5256 if (pedantic
&& size_maybe_const
&& integer_zerop (size
))
5259 pedwarn (loc
, OPT_pedantic
,
5260 "ISO C forbids zero-size array %qE", name
);
5262 pedwarn (loc
, OPT_pedantic
,
5263 "ISO C forbids zero-size array");
5266 if (TREE_CODE (size
) == INTEGER_CST
&& size_maybe_const
)
5268 constant_expression_warning (size
);
5269 if (tree_int_cst_sgn (size
) < 0)
5272 error_at (loc
, "size of array %qE is negative", name
);
5274 error_at (loc
, "size of unnamed array is negative");
5275 size
= integer_one_node
;
5277 /* Handle a size folded to an integer constant but
5278 not an integer constant expression. */
5279 if (!size_int_const
)
5281 /* If this is a file scope declaration of an
5282 ordinary identifier, this is invalid code;
5283 diagnosing it here and not subsequently
5284 treating the type as variable-length avoids
5285 more confusing diagnostics later. */
5286 if ((decl_context
== NORMAL
|| decl_context
== FIELD
)
5287 && current_scope
== file_scope
)
5288 pedwarn (input_location
, 0,
5289 "variably modified %qE at file scope",
5292 this_size_varies
= size_varies
= true;
5293 warn_variable_length_array (name
, size
);
5296 else if ((decl_context
== NORMAL
|| decl_context
== FIELD
)
5297 && current_scope
== file_scope
)
5299 error_at (loc
, "variably modified %qE at file scope", name
);
5300 size
= integer_one_node
;
5304 /* Make sure the array size remains visibly
5305 nonconstant even if it is (eg) a const variable
5306 with known value. */
5307 this_size_varies
= size_varies
= true;
5308 warn_variable_length_array (name
, size
);
5311 if (integer_zerop (size
) && !this_size_varies
)
5313 /* A zero-length array cannot be represented with
5314 an unsigned index type, which is what we'll
5315 get with build_index_type. Create an
5316 open-ended range instead. */
5317 itype
= build_range_type (sizetype
, size
, NULL_TREE
);
5321 /* Arrange for the SAVE_EXPR on the inside of the
5322 MINUS_EXPR, which allows the -1 to get folded
5323 with the +1 that happens when building TYPE_SIZE. */
5325 size
= c_variable_size (size
);
5326 if (this_size_varies
&& TREE_CODE (size
) == INTEGER_CST
)
5327 size
= build2 (COMPOUND_EXPR
, TREE_TYPE (size
),
5328 integer_zero_node
, size
);
5330 /* Compute the maximum valid index, that is, size
5331 - 1. Do the calculation in index_type, so that
5332 if it is a variable the computations will be
5333 done in the proper mode. */
5334 itype
= fold_build2_loc (loc
, MINUS_EXPR
, index_type
,
5335 convert (index_type
, size
),
5336 convert (index_type
,
5339 /* If that overflowed, the array is too big. ???
5340 While a size of INT_MAX+1 technically shouldn't
5341 cause an overflow (because we subtract 1), the
5342 overflow is recorded during the conversion to
5343 index_type, before the subtraction. Handling
5344 this case seems like an unnecessary
5346 if (TREE_CODE (itype
) == INTEGER_CST
5347 && TREE_OVERFLOW (itype
))
5350 error_at (loc
, "size of array %qE is too large",
5353 error_at (loc
, "size of unnamed array is too large");
5354 type
= error_mark_node
;
5358 itype
= build_index_type (itype
);
5360 if (this_size_varies
)
5363 *expr
= build2 (COMPOUND_EXPR
, TREE_TYPE (size
),
5367 *expr_const_operands
&= size_maybe_const
;
5370 else if (decl_context
== FIELD
)
5372 bool flexible_array_member
= false;
5373 if (array_parm_vla_unspec_p
)
5374 /* Field names can in fact have function prototype
5375 scope so [*] is disallowed here through making
5376 the field variably modified, not through being
5377 something other than a declaration with function
5382 const struct c_declarator
*t
= declarator
;
5383 while (t
->kind
== cdk_attrs
)
5385 flexible_array_member
= (t
->kind
== cdk_id
);
5387 if (flexible_array_member
5388 && pedantic
&& !flag_isoc99
&& !in_system_header
)
5389 pedwarn (loc
, OPT_pedantic
,
5390 "ISO C90 does not support flexible array members");
5392 /* ISO C99 Flexible array members are effectively
5393 identical to GCC's zero-length array extension. */
5394 if (flexible_array_member
|| array_parm_vla_unspec_p
)
5395 itype
= build_range_type (sizetype
, size_zero_node
,
5398 else if (decl_context
== PARM
)
5400 if (array_parm_vla_unspec_p
)
5402 itype
= build_range_type (sizetype
, size_zero_node
, NULL_TREE
);
5406 else if (decl_context
== TYPENAME
)
5408 if (array_parm_vla_unspec_p
)
5411 warning (0, "%<[*]%> not in a declaration");
5412 /* We use this to avoid messing up with incomplete
5413 array types of the same type, that would
5414 otherwise be modified below. */
5415 itype
= build_range_type (sizetype
, size_zero_node
,
5421 /* Complain about arrays of incomplete types. */
5422 if (!COMPLETE_TYPE_P (type
))
5424 error_at (loc
, "array type has incomplete element type");
5425 type
= error_mark_node
;
5428 /* When itype is NULL, a shared incomplete array type is
5429 returned for all array of a given type. Elsewhere we
5430 make sure we don't complete that type before copying
5431 it, but here we want to make sure we don't ever
5432 modify the shared type, so we gcc_assert (itype)
5435 addr_space_t as
= DECODE_QUAL_ADDR_SPACE (type_quals
);
5436 if (!ADDR_SPACE_GENERIC_P (as
) && as
!= TYPE_ADDR_SPACE (type
))
5437 type
= build_qualified_type (type
,
5438 ENCODE_QUAL_ADDR_SPACE (as
));
5440 type
= build_array_type (type
, itype
);
5443 if (type
!= error_mark_node
)
5447 /* It is ok to modify type here even if itype is
5448 NULL: if size_varies, we're in a
5449 multi-dimensional array and the inner type has
5450 variable size, so the enclosing shared array type
5452 if (size
&& TREE_CODE (size
) == INTEGER_CST
)
5454 = build_distinct_type_copy (TYPE_MAIN_VARIANT (type
));
5455 C_TYPE_VARIABLE_SIZE (type
) = 1;
5458 /* The GCC extension for zero-length arrays differs from
5459 ISO flexible array members in that sizeof yields
5461 if (size
&& integer_zerop (size
))
5464 type
= build_distinct_type_copy (TYPE_MAIN_VARIANT (type
));
5465 TYPE_SIZE (type
) = bitsize_zero_node
;
5466 TYPE_SIZE_UNIT (type
) = size_zero_node
;
5467 SET_TYPE_STRUCTURAL_EQUALITY (type
);
5469 if (array_parm_vla_unspec_p
)
5472 /* The type is complete. C99 6.7.5.2p4 */
5473 type
= build_distinct_type_copy (TYPE_MAIN_VARIANT (type
));
5474 TYPE_SIZE (type
) = bitsize_zero_node
;
5475 TYPE_SIZE_UNIT (type
) = size_zero_node
;
5476 SET_TYPE_STRUCTURAL_EQUALITY (type
);
5480 if (decl_context
!= PARM
5481 && (array_ptr_quals
!= TYPE_UNQUALIFIED
5482 || array_ptr_attrs
!= NULL_TREE
5483 || array_parm_static
))
5485 error_at (loc
, "static or type qualifiers in non-parameter array declarator");
5486 array_ptr_quals
= TYPE_UNQUALIFIED
;
5487 array_ptr_attrs
= NULL_TREE
;
5488 array_parm_static
= 0;
5494 /* Say it's a definition only for the declarator closest
5495 to the identifier, apart possibly from some
5497 bool really_funcdef
= false;
5501 const struct c_declarator
*t
= declarator
->declarator
;
5502 while (t
->kind
== cdk_attrs
)
5504 really_funcdef
= (t
->kind
== cdk_id
);
5507 /* Declaring a function type. Make sure we have a valid
5508 type for the function to return. */
5509 if (type
== error_mark_node
)
5512 size_varies
= false;
5514 /* Warn about some types functions can't return. */
5515 if (TREE_CODE (type
) == FUNCTION_TYPE
)
5518 error_at (loc
, "%qE declared as function returning a "
5521 error_at (loc
, "type name declared as function "
5522 "returning a function");
5523 type
= integer_type_node
;
5525 if (TREE_CODE (type
) == ARRAY_TYPE
)
5528 error_at (loc
, "%qE declared as function returning an array",
5531 error_at (loc
, "type name declared as function returning "
5533 type
= integer_type_node
;
5535 errmsg
= targetm
.invalid_return_type (type
);
5539 type
= integer_type_node
;
5542 /* Construct the function type and go to the next
5543 inner layer of declarator. */
5544 arg_info
= declarator
->u
.arg_info
;
5545 arg_types
= grokparms (arg_info
, really_funcdef
);
5547 put_pending_sizes (arg_info
->pending_sizes
);
5549 /* Type qualifiers before the return type of the function
5550 qualify the return type, not the function type. */
5553 /* Type qualifiers on a function return type are
5554 normally permitted by the standard but have no
5555 effect, so give a warning at -Wreturn-type.
5556 Qualifiers on a void return type are banned on
5557 function definitions in ISO C; GCC used to used
5558 them for noreturn functions. */
5559 if (VOID_TYPE_P (type
) && really_funcdef
)
5561 "function definition has qualified void return type");
5563 warning_at (loc
, OPT_Wignored_qualifiers
,
5564 "type qualifiers ignored on function return type");
5566 type
= c_build_qualified_type (type
, type_quals
);
5568 type_quals
= TYPE_UNQUALIFIED
;
5570 type
= build_function_type (type
, arg_types
);
5571 declarator
= declarator
->declarator
;
5573 /* Set the TYPE_CONTEXTs for each tagged type which is local to
5574 the formal parameter list of this FUNCTION_TYPE to point to
5575 the FUNCTION_TYPE node itself. */
5580 FOR_EACH_VEC_ELT_REVERSE (c_arg_tag
, arg_info
->tags
, ix
, tag
)
5581 TYPE_CONTEXT (tag
->type
) = type
;
5587 /* Merge any constancy or volatility into the target type
5590 if (pedantic
&& TREE_CODE (type
) == FUNCTION_TYPE
5592 pedwarn (loc
, OPT_pedantic
,
5593 "ISO C forbids qualified function types");
5595 type
= c_build_qualified_type (type
, type_quals
);
5596 size_varies
= false;
5598 /* When the pointed-to type involves components of variable size,
5599 care must be taken to ensure that the size evaluation code is
5600 emitted early enough to dominate all the possible later uses
5601 and late enough for the variables on which it depends to have
5604 This is expected to happen automatically when the pointed-to
5605 type has a name/declaration of it's own, but special attention
5606 is required if the type is anonymous.
5608 We handle the NORMAL and FIELD contexts here by attaching an
5609 artificial TYPE_DECL to such pointed-to type. This forces the
5610 sizes evaluation at a safe point and ensures it is not deferred
5611 until e.g. within a deeper conditional context.
5613 We expect nothing to be needed here for PARM or TYPENAME.
5614 Pushing a TYPE_DECL at this point for TYPENAME would actually
5615 be incorrect, as we might be in the middle of an expression
5616 with side effects on the pointed-to type size "arguments" prior
5617 to the pointer declaration point and the fake TYPE_DECL in the
5618 enclosing context would force the size evaluation prior to the
5621 if (!TYPE_NAME (type
)
5622 && (decl_context
== NORMAL
|| decl_context
== FIELD
)
5623 && variably_modified_type_p (type
, NULL_TREE
))
5625 tree decl
= build_decl (loc
, TYPE_DECL
, NULL_TREE
, type
);
5626 DECL_ARTIFICIAL (decl
) = 1;
5628 finish_decl (decl
, loc
, NULL_TREE
, NULL_TREE
, NULL_TREE
);
5629 TYPE_NAME (type
) = decl
;
5632 type
= build_pointer_type (type
);
5634 /* Process type qualifiers (such as const or volatile)
5635 that were given inside the `*'. */
5636 type_quals
= declarator
->u
.pointer_quals
;
5638 declarator
= declarator
->declarator
;
5645 *decl_attrs
= chainon (returned_attrs
, *decl_attrs
);
5647 /* Now TYPE has the actual type, apart from any qualifiers in
5650 /* Warn about address space used for things other than static memory or
5652 address_space
= DECODE_QUAL_ADDR_SPACE (type_quals
);
5653 if (!ADDR_SPACE_GENERIC_P (address_space
))
5655 if (decl_context
== NORMAL
)
5657 switch (storage_class
)
5660 error ("%qs combined with %<auto%> qualifier for %qE",
5661 c_addr_space_name (address_space
), name
);
5664 error ("%qs combined with %<register%> qualifier for %qE",
5665 c_addr_space_name (address_space
), name
);
5668 if (current_function_scope
)
5670 error ("%qs specified for auto variable %qE",
5671 c_addr_space_name (address_space
), name
);
5683 else if (decl_context
== PARM
&& TREE_CODE (type
) != ARRAY_TYPE
)
5686 error ("%qs specified for parameter %qE",
5687 c_addr_space_name (address_space
), name
);
5689 error ("%qs specified for unnamed parameter",
5690 c_addr_space_name (address_space
));
5692 else if (decl_context
== FIELD
)
5695 error ("%qs specified for structure field %qE",
5696 c_addr_space_name (address_space
), name
);
5698 error ("%qs specified for structure field",
5699 c_addr_space_name (address_space
));
5703 /* Check the type and width of a bit-field. */
5705 check_bitfield_type_and_width (&type
, width
, name
);
5707 /* Did array size calculations overflow? */
5709 if (TREE_CODE (type
) == ARRAY_TYPE
5710 && COMPLETE_TYPE_P (type
)
5711 && TREE_CODE (TYPE_SIZE_UNIT (type
)) == INTEGER_CST
5712 && TREE_OVERFLOW (TYPE_SIZE_UNIT (type
)))
5715 error_at (loc
, "size of array %qE is too large", name
);
5717 error_at (loc
, "size of unnamed array is too large");
5718 /* If we proceed with the array type as it is, we'll eventually
5719 crash in tree_low_cst(). */
5720 type
= error_mark_node
;
5723 /* If this is declaring a typedef name, return a TYPE_DECL. */
5725 if (storage_class
== csc_typedef
)
5728 if (pedantic
&& TREE_CODE (type
) == FUNCTION_TYPE
5730 pedwarn (loc
, OPT_pedantic
,
5731 "ISO C forbids qualified function types");
5733 type
= c_build_qualified_type (type
, type_quals
);
5734 decl
= build_decl (declarator
->id_loc
,
5735 TYPE_DECL
, declarator
->u
.id
, type
);
5736 if (declspecs
->explicit_signed_p
)
5737 C_TYPEDEF_EXPLICITLY_SIGNED (decl
) = 1;
5738 if (declspecs
->inline_p
)
5739 pedwarn (loc
, 0,"typedef %q+D declared %<inline%>", decl
);
5741 if (warn_cxx_compat
&& declarator
->u
.id
!= NULL_TREE
)
5743 struct c_binding
*b
= I_TAG_BINDING (declarator
->u
.id
);
5746 && b
->decl
!= NULL_TREE
5747 && (B_IN_CURRENT_SCOPE (b
)
5748 || (current_scope
== file_scope
&& B_IN_EXTERNAL_SCOPE (b
)))
5749 && TYPE_MAIN_VARIANT (b
->decl
) != TYPE_MAIN_VARIANT (type
))
5751 warning_at (declarator
->id_loc
, OPT_Wc___compat
,
5752 ("using %qD as both a typedef and a tag is "
5755 if (b
->locus
!= UNKNOWN_LOCATION
)
5756 inform (b
->locus
, "originally defined here");
5763 /* If this is a type name (such as, in a cast or sizeof),
5764 compute the type and return it now. */
5766 if (decl_context
== TYPENAME
)
5768 /* Note that the grammar rejects storage classes in typenames
5770 gcc_assert (storage_class
== csc_none
&& !threadp
5771 && !declspecs
->inline_p
);
5772 if (pedantic
&& TREE_CODE (type
) == FUNCTION_TYPE
5774 pedwarn (loc
, OPT_pedantic
,
5775 "ISO C forbids const or volatile function types");
5777 type
= c_build_qualified_type (type
, type_quals
);
5781 if (pedantic
&& decl_context
== FIELD
5782 && variably_modified_type_p (type
, NULL_TREE
))
5785 pedwarn (loc
, OPT_pedantic
, "a member of a structure or union cannot "
5786 "have a variably modified type");
5789 /* Aside from typedefs and type names (handle above),
5790 `void' at top level (not within pointer)
5791 is allowed only in public variables.
5792 We don't complain about parms either, but that is because
5793 a better error message can be made later. */
5795 if (VOID_TYPE_P (type
) && decl_context
!= PARM
5796 && !((decl_context
!= FIELD
&& TREE_CODE (type
) != FUNCTION_TYPE
)
5797 && (storage_class
== csc_extern
5798 || (current_scope
== file_scope
5799 && !(storage_class
== csc_static
5800 || storage_class
== csc_register
)))))
5802 error_at (loc
, "variable or field %qE declared void", name
);
5803 type
= integer_type_node
;
5806 /* Now create the decl, which may be a VAR_DECL, a PARM_DECL
5807 or a FUNCTION_DECL, depending on DECL_CONTEXT and TYPE. */
5812 if (decl_context
== PARM
)
5816 /* A parameter declared as an array of T is really a pointer to T.
5817 One declared as a function is really a pointer to a function. */
5819 if (TREE_CODE (type
) == ARRAY_TYPE
)
5821 /* Transfer const-ness of array into that of type pointed to. */
5822 type
= TREE_TYPE (type
);
5824 type
= c_build_qualified_type (type
, type_quals
);
5825 type
= build_pointer_type (type
);
5826 type_quals
= array_ptr_quals
;
5828 type
= c_build_qualified_type (type
, type_quals
);
5830 /* We don't yet implement attributes in this context. */
5831 if (array_ptr_attrs
!= NULL_TREE
)
5832 warning_at (loc
, OPT_Wattributes
,
5833 "attributes in parameter array declarator ignored");
5835 size_varies
= false;
5837 else if (TREE_CODE (type
) == FUNCTION_TYPE
)
5840 pedwarn (loc
, OPT_pedantic
,
5841 "ISO C forbids qualified function types");
5843 type
= c_build_qualified_type (type
, type_quals
);
5844 type
= build_pointer_type (type
);
5845 type_quals
= TYPE_UNQUALIFIED
;
5847 else if (type_quals
)
5848 type
= c_build_qualified_type (type
, type_quals
);
5850 decl
= build_decl (declarator
->id_loc
,
5851 PARM_DECL
, declarator
->u
.id
, type
);
5853 C_DECL_VARIABLE_SIZE (decl
) = 1;
5855 /* Compute the type actually passed in the parmlist,
5856 for the case where there is no prototype.
5857 (For example, shorts and chars are passed as ints.)
5858 When there is a prototype, this is overridden later. */
5860 if (type
== error_mark_node
)
5861 promoted_type
= type
;
5863 promoted_type
= c_type_promotes_to (type
);
5865 DECL_ARG_TYPE (decl
) = promoted_type
;
5866 if (declspecs
->inline_p
)
5867 pedwarn (loc
, 0, "parameter %q+D declared %<inline%>", decl
);
5869 else if (decl_context
== FIELD
)
5871 /* Note that the grammar rejects storage classes in typenames
5873 gcc_assert (storage_class
== csc_none
&& !threadp
5874 && !declspecs
->inline_p
);
5876 /* Structure field. It may not be a function. */
5878 if (TREE_CODE (type
) == FUNCTION_TYPE
)
5880 error_at (loc
, "field %qE declared as a function", name
);
5881 type
= build_pointer_type (type
);
5883 else if (TREE_CODE (type
) != ERROR_MARK
5884 && !COMPLETE_OR_UNBOUND_ARRAY_TYPE_P (type
))
5887 error_at (loc
, "field %qE has incomplete type", name
);
5889 error_at (loc
, "unnamed field has incomplete type");
5890 type
= error_mark_node
;
5892 type
= c_build_qualified_type (type
, type_quals
);
5893 decl
= build_decl (declarator
->id_loc
,
5894 FIELD_DECL
, declarator
->u
.id
, type
);
5895 DECL_NONADDRESSABLE_P (decl
) = bitfield
;
5896 if (bitfield
&& !declarator
->u
.id
)
5897 TREE_NO_WARNING (decl
) = 1;
5900 C_DECL_VARIABLE_SIZE (decl
) = 1;
5902 else if (TREE_CODE (type
) == FUNCTION_TYPE
)
5904 if (storage_class
== csc_register
|| threadp
)
5906 error_at (loc
, "invalid storage class for function %qE", name
);
5908 else if (current_scope
!= file_scope
)
5910 /* Function declaration not at file scope. Storage
5911 classes other than `extern' are not allowed, C99
5912 6.7.1p5, and `extern' makes no difference. However,
5913 GCC allows 'auto', perhaps with 'inline', to support
5914 nested functions. */
5915 if (storage_class
== csc_auto
)
5916 pedwarn (loc
, OPT_pedantic
,
5917 "invalid storage class for function %qE", name
);
5918 else if (storage_class
== csc_static
)
5920 error_at (loc
, "invalid storage class for function %qE", name
);
5922 storage_class
= declspecs
->storage_class
= csc_none
;
5928 decl
= build_decl (declarator
->id_loc
,
5929 FUNCTION_DECL
, declarator
->u
.id
, type
);
5930 decl
= build_decl_attribute_variant (decl
, decl_attr
);
5932 if (pedantic
&& type_quals
&& !DECL_IN_SYSTEM_HEADER (decl
))
5933 pedwarn (loc
, OPT_pedantic
,
5934 "ISO C forbids qualified function types");
5936 /* Every function declaration is an external reference
5937 (DECL_EXTERNAL) except for those which are not at file
5938 scope and are explicitly declared "auto". This is
5939 forbidden by standard C (C99 6.7.1p5) and is interpreted by
5940 GCC to signify a forward declaration of a nested function. */
5941 if (storage_class
== csc_auto
&& current_scope
!= file_scope
)
5942 DECL_EXTERNAL (decl
) = 0;
5943 /* In C99, a function which is declared 'inline' with 'extern'
5944 is not an external reference (which is confusing). It
5945 means that the later definition of the function must be output
5946 in this file, C99 6.7.4p6. In GNU C89, a function declared
5947 'extern inline' is an external reference. */
5948 else if (declspecs
->inline_p
&& storage_class
!= csc_static
)
5949 DECL_EXTERNAL (decl
) = ((storage_class
== csc_extern
)
5950 == flag_gnu89_inline
);
5952 DECL_EXTERNAL (decl
) = !initialized
;
5954 /* Record absence of global scope for `static' or `auto'. */
5956 = !(storage_class
== csc_static
|| storage_class
== csc_auto
);
5958 /* For a function definition, record the argument information
5959 block where store_parm_decls will look for it. */
5961 current_function_arg_info
= arg_info
;
5963 if (declspecs
->default_int_p
)
5964 C_FUNCTION_IMPLICIT_INT (decl
) = 1;
5966 /* Record presence of `inline', if it is reasonable. */
5967 if (flag_hosted
&& MAIN_NAME_P (declarator
->u
.id
))
5969 if (declspecs
->inline_p
)
5970 pedwarn (loc
, 0, "cannot inline function %<main%>");
5972 else if (declspecs
->inline_p
)
5973 /* Record that the function is declared `inline'. */
5974 DECL_DECLARED_INLINE_P (decl
) = 1;
5978 /* It's a variable. */
5979 /* An uninitialized decl with `extern' is a reference. */
5980 int extern_ref
= !initialized
&& storage_class
== csc_extern
;
5982 type
= c_build_qualified_type (type
, type_quals
);
5984 /* C99 6.2.2p7: It is invalid (compile-time undefined
5985 behavior) to create an 'extern' declaration for a
5986 variable if there is a global declaration that is
5987 'static' and the global declaration is not visible.
5988 (If the static declaration _is_ currently visible,
5989 the 'extern' declaration is taken to refer to that decl.) */
5990 if (extern_ref
&& current_scope
!= file_scope
)
5992 tree global_decl
= identifier_global_value (declarator
->u
.id
);
5993 tree visible_decl
= lookup_name (declarator
->u
.id
);
5996 && global_decl
!= visible_decl
5997 && TREE_CODE (global_decl
) == VAR_DECL
5998 && !TREE_PUBLIC (global_decl
))
5999 error_at (loc
, "variable previously declared %<static%> "
6000 "redeclared %<extern%>");
6003 decl
= build_decl (declarator
->id_loc
,
6004 VAR_DECL
, declarator
->u
.id
, type
);
6006 C_DECL_VARIABLE_SIZE (decl
) = 1;
6008 if (declspecs
->inline_p
)
6009 pedwarn (loc
, 0, "variable %q+D declared %<inline%>", decl
);
6011 /* At file scope, an initialized extern declaration may follow
6012 a static declaration. In that case, DECL_EXTERNAL will be
6013 reset later in start_decl. */
6014 DECL_EXTERNAL (decl
) = (storage_class
== csc_extern
);
6016 /* At file scope, the presence of a `static' or `register' storage
6017 class specifier, or the absence of all storage class specifiers
6018 makes this declaration a definition (perhaps tentative). Also,
6019 the absence of `static' makes it public. */
6020 if (current_scope
== file_scope
)
6022 TREE_PUBLIC (decl
) = storage_class
!= csc_static
;
6023 TREE_STATIC (decl
) = !extern_ref
;
6025 /* Not at file scope, only `static' makes a static definition. */
6028 TREE_STATIC (decl
) = (storage_class
== csc_static
);
6029 TREE_PUBLIC (decl
) = extern_ref
;
6033 DECL_TLS_MODEL (decl
) = decl_default_tls_model (decl
);
6036 if ((storage_class
== csc_extern
6037 || (storage_class
== csc_none
6038 && TREE_CODE (type
) == FUNCTION_TYPE
6040 && variably_modified_type_p (type
, NULL_TREE
))
6043 if (TREE_CODE (type
) == FUNCTION_TYPE
)
6044 error_at (loc
, "non-nested function with variably modified type");
6046 error_at (loc
, "object with variably modified type must have "
6050 /* Record `register' declaration for warnings on &
6051 and in case doing stupid register allocation. */
6053 if (storage_class
== csc_register
)
6055 C_DECL_REGISTER (decl
) = 1;
6056 DECL_REGISTER (decl
) = 1;
6059 /* Record constancy and volatility. */
6060 c_apply_type_quals_to_decl (type_quals
, decl
);
6062 /* If a type has volatile components, it should be stored in memory.
6063 Otherwise, the fact that those components are volatile
6064 will be ignored, and would even crash the compiler.
6065 Of course, this only makes sense on VAR,PARM, and RESULT decl's. */
6066 if (C_TYPE_FIELDS_VOLATILE (TREE_TYPE (decl
))
6067 && (TREE_CODE (decl
) == VAR_DECL
|| TREE_CODE (decl
) == PARM_DECL
6068 || TREE_CODE (decl
) == RESULT_DECL
))
6070 /* It is not an error for a structure with volatile fields to
6071 be declared register, but reset DECL_REGISTER since it
6072 cannot actually go in a register. */
6073 int was_reg
= C_DECL_REGISTER (decl
);
6074 C_DECL_REGISTER (decl
) = 0;
6075 DECL_REGISTER (decl
) = 0;
6076 c_mark_addressable (decl
);
6077 C_DECL_REGISTER (decl
) = was_reg
;
6080 /* This is the earliest point at which we might know the assembler
6081 name of a variable. Thus, if it's known before this, die horribly. */
6082 gcc_assert (!DECL_ASSEMBLER_NAME_SET_P (decl
));
6085 && TREE_CODE (decl
) == VAR_DECL
6086 && TREE_PUBLIC (decl
)
6087 && TREE_STATIC (decl
)
6088 && (TREE_CODE (TREE_TYPE (decl
)) == RECORD_TYPE
6089 || TREE_CODE (TREE_TYPE (decl
)) == UNION_TYPE
6090 || TREE_CODE (TREE_TYPE (decl
)) == ENUMERAL_TYPE
)
6091 && TYPE_NAME (TREE_TYPE (decl
)) == NULL_TREE
)
6092 warning_at (DECL_SOURCE_LOCATION (decl
), OPT_Wc___compat
,
6093 ("non-local variable %qD with anonymous type is "
6094 "questionable in C++"),
6101 /* Decode the parameter-list info for a function type or function definition.
6102 The argument is the value returned by `get_parm_info' (or made in c-parse.c
6103 if there is an identifier list instead of a parameter decl list).
6104 These two functions are separate because when a function returns
6105 or receives functions then each is called multiple times but the order
6106 of calls is different. The last call to `grokparms' is always the one
6107 that contains the formal parameter names of a function definition.
6109 Return a list of arg types to use in the FUNCTION_TYPE for this function.
6111 FUNCDEF_FLAG is true for a function definition, false for
6112 a mere declaration. A nonempty identifier-list gets an error message
6113 when FUNCDEF_FLAG is false. */
6116 grokparms (struct c_arg_info
*arg_info
, bool funcdef_flag
)
6118 tree arg_types
= arg_info
->types
;
6120 if (funcdef_flag
&& arg_info
->had_vla_unspec
)
6122 /* A function definition isn't function prototype scope C99 6.2.1p4. */
6124 error ("%<[*]%> not allowed in other than function prototype scope");
6127 if (arg_types
== 0 && !funcdef_flag
&& !in_system_header
)
6128 warning (OPT_Wstrict_prototypes
,
6129 "function declaration isn%'t a prototype");
6131 if (arg_types
== error_mark_node
)
6132 return 0; /* don't set TYPE_ARG_TYPES in this case */
6134 else if (arg_types
&& TREE_CODE (TREE_VALUE (arg_types
)) == IDENTIFIER_NODE
)
6138 pedwarn (input_location
, 0, "parameter names (without types) in function declaration");
6139 arg_info
->parms
= NULL_TREE
;
6142 arg_info
->parms
= arg_info
->types
;
6144 arg_info
->types
= 0;
6149 tree parm
, type
, typelt
;
6150 unsigned int parmno
;
6153 /* If there is a parameter of incomplete type in a definition,
6154 this is an error. In a declaration this is valid, and a
6155 struct or union type may be completed later, before any calls
6156 or definition of the function. In the case where the tag was
6157 first declared within the parameter list, a warning has
6158 already been given. If a parameter has void type, then
6159 however the function cannot be defined or called, so
6162 for (parm
= arg_info
->parms
, typelt
= arg_types
, parmno
= 1;
6164 parm
= DECL_CHAIN (parm
), typelt
= TREE_CHAIN (typelt
), parmno
++)
6166 type
= TREE_VALUE (typelt
);
6167 if (type
== error_mark_node
)
6170 if (!COMPLETE_TYPE_P (type
))
6174 if (DECL_NAME (parm
))
6175 error_at (input_location
,
6176 "parameter %u (%q+D) has incomplete type",
6179 error_at (DECL_SOURCE_LOCATION (parm
),
6180 "parameter %u has incomplete type",
6183 TREE_VALUE (typelt
) = error_mark_node
;
6184 TREE_TYPE (parm
) = error_mark_node
;
6185 arg_types
= NULL_TREE
;
6187 else if (VOID_TYPE_P (type
))
6189 if (DECL_NAME (parm
))
6190 warning_at (input_location
, 0,
6191 "parameter %u (%q+D) has void type",
6194 warning_at (DECL_SOURCE_LOCATION (parm
), 0,
6195 "parameter %u has void type",
6200 errmsg
= targetm
.invalid_parameter_type (type
);
6204 TREE_VALUE (typelt
) = error_mark_node
;
6205 TREE_TYPE (parm
) = error_mark_node
;
6206 arg_types
= NULL_TREE
;
6209 if (DECL_NAME (parm
) && TREE_USED (parm
))
6210 warn_if_shadowing (parm
);
6216 /* Allocate and initialize a c_arg_info structure from the parser's
6220 build_arg_info (void)
6222 struct c_arg_info
*ret
= XOBNEW (&parser_obstack
, struct c_arg_info
);
6223 ret
->parms
= NULL_TREE
;
6225 ret
->types
= NULL_TREE
;
6226 ret
->others
= NULL_TREE
;
6227 ret
->pending_sizes
= NULL
;
6228 ret
->had_vla_unspec
= 0;
6232 /* Take apart the current scope and return a c_arg_info structure with
6233 info on a parameter list just parsed.
6235 This structure is later fed to 'grokparms' and 'store_parm_decls'.
6237 ELLIPSIS being true means the argument list ended in '...' so don't
6238 append a sentinel (void_list_node) to the end of the type-list. */
6241 get_parm_info (bool ellipsis
)
6243 struct c_binding
*b
= current_scope
->bindings
;
6244 struct c_arg_info
*arg_info
= build_arg_info ();
6247 VEC(c_arg_tag
,gc
) *tags
= NULL
;
6251 static bool explained_incomplete_types
= false;
6252 bool gave_void_only_once_err
= false;
6254 arg_info
->had_vla_unspec
= current_scope
->had_vla_unspec
;
6256 /* The bindings in this scope must not get put into a block.
6257 We will take care of deleting the binding nodes. */
6258 current_scope
->bindings
= 0;
6260 /* This function is only called if there was *something* on the
6264 /* A parameter list consisting solely of 'void' indicates that the
6265 function takes no arguments. But if the 'void' is qualified
6266 (by 'const' or 'volatile'), or has a storage class specifier
6267 ('register'), then the behavior is undefined; issue an error.
6268 Typedefs for 'void' are OK (see DR#157). */
6269 if (b
->prev
== 0 /* one binding */
6270 && TREE_CODE (b
->decl
) == PARM_DECL
/* which is a parameter */
6271 && !DECL_NAME (b
->decl
) /* anonymous */
6272 && VOID_TYPE_P (TREE_TYPE (b
->decl
))) /* of void type */
6274 if (TREE_THIS_VOLATILE (b
->decl
)
6275 || TREE_READONLY (b
->decl
)
6276 || C_DECL_REGISTER (b
->decl
))
6277 error ("%<void%> as only parameter may not be qualified");
6279 /* There cannot be an ellipsis. */
6281 error ("%<void%> must be the only parameter");
6283 arg_info
->types
= void_list_node
;
6288 types
= void_list_node
;
6290 /* Break up the bindings list into parms, tags, types, and others;
6291 apply sanity checks; purge the name-to-decl bindings. */
6294 tree decl
= b
->decl
;
6295 tree type
= TREE_TYPE (decl
);
6297 const char *keyword
;
6299 switch (TREE_CODE (decl
))
6304 gcc_assert (I_SYMBOL_BINDING (b
->id
) == b
);
6305 I_SYMBOL_BINDING (b
->id
) = b
->shadowed
;
6308 /* Check for forward decls that never got their actual decl. */
6309 if (TREE_ASM_WRITTEN (decl
))
6310 error ("parameter %q+D has just a forward declaration", decl
);
6311 /* Check for (..., void, ...) and issue an error. */
6312 else if (VOID_TYPE_P (type
) && !DECL_NAME (decl
))
6314 if (!gave_void_only_once_err
)
6316 error ("%<void%> must be the only parameter");
6317 gave_void_only_once_err
= true;
6322 /* Valid parameter, add it to the list. */
6323 DECL_CHAIN (decl
) = parms
;
6326 /* Since there is a prototype, args are passed in their
6327 declared types. The back end may override this later. */
6328 DECL_ARG_TYPE (decl
) = type
;
6329 types
= tree_cons (0, type
, types
);
6333 case ENUMERAL_TYPE
: keyword
= "enum"; goto tag
;
6334 case UNION_TYPE
: keyword
= "union"; goto tag
;
6335 case RECORD_TYPE
: keyword
= "struct"; goto tag
;
6337 /* Types may not have tag-names, in which case the type
6338 appears in the bindings list with b->id NULL. */
6341 gcc_assert (I_TAG_BINDING (b
->id
) == b
);
6342 I_TAG_BINDING (b
->id
) = b
->shadowed
;
6345 /* Warn about any struct, union or enum tags defined in a
6346 parameter list. The scope of such types is limited to
6347 the parameter list, which is rarely if ever desirable
6348 (it's impossible to call such a function with type-
6349 correct arguments). An anonymous union parm type is
6350 meaningful as a GNU extension, so don't warn for that. */
6351 if (TREE_CODE (decl
) != UNION_TYPE
|| b
->id
!= 0)
6354 /* The %s will be one of 'struct', 'union', or 'enum'. */
6355 warning (0, "%<%s %E%> declared inside parameter list",
6358 /* The %s will be one of 'struct', 'union', or 'enum'. */
6359 warning (0, "anonymous %s declared inside parameter list",
6362 if (!explained_incomplete_types
)
6364 warning (0, "its scope is only this definition or declaration,"
6365 " which is probably not what you want");
6366 explained_incomplete_types
= true;
6370 tag
= VEC_safe_push (c_arg_tag
, gc
, tags
, NULL
);
6378 /* CONST_DECLs appear here when we have an embedded enum,
6379 and TYPE_DECLs appear here when we have an embedded struct
6380 or union. No warnings for this - we already warned about the
6381 type itself. FUNCTION_DECLs appear when there is an implicit
6382 function declaration in the parameter list. */
6384 /* When we reinsert this decl in the function body, we need
6385 to reconstruct whether it was marked as nested. */
6386 gcc_assert (TREE_CODE (decl
) == FUNCTION_DECL
6389 DECL_CHAIN (decl
) = others
;
6394 /* error_mark_node appears here when we have an undeclared
6395 variable. Just throw it away. */
6398 gcc_assert (I_SYMBOL_BINDING (b
->id
) == b
);
6399 I_SYMBOL_BINDING (b
->id
) = b
->shadowed
;
6403 /* Other things that might be encountered. */
6410 b
= free_binding_and_advance (b
);
6413 arg_info
->parms
= parms
;
6414 arg_info
->tags
= tags
;
6415 arg_info
->types
= types
;
6416 arg_info
->others
= others
;
6417 arg_info
->pending_sizes
= get_pending_sizes ();
6421 /* Get the struct, enum or union (CODE says which) with tag NAME.
6422 Define the tag as a forward-reference with location LOC if it is
6423 not defined. Return a c_typespec structure for the type
6427 parser_xref_tag (location_t loc
, enum tree_code code
, tree name
)
6429 struct c_typespec ret
;
6433 ret
.expr
= NULL_TREE
;
6434 ret
.expr_const_operands
= true;
6436 /* If a cross reference is requested, look up the type
6437 already defined for this tag and return it. */
6439 ref
= lookup_tag (code
, name
, 0, &refloc
);
6440 /* If this is the right type of tag, return what we found.
6441 (This reference will be shadowed by shadow_tag later if appropriate.)
6442 If this is the wrong type of tag, do not return it. If it was the
6443 wrong type in the same scope, we will have had an error
6444 message already; if in a different scope and declaring
6445 a name, pending_xref_error will give an error message; but if in a
6446 different scope and not declaring a name, this tag should
6447 shadow the previous declaration of a different type of tag, and
6448 this would not work properly if we return the reference found.
6449 (For example, with "struct foo" in an outer scope, "union foo;"
6450 must shadow that tag with a new one of union type.) */
6451 ret
.kind
= (ref
? ctsk_tagref
: ctsk_tagfirstref
);
6452 if (ref
&& TREE_CODE (ref
) == code
)
6454 if (C_TYPE_DEFINED_IN_STRUCT (ref
)
6455 && loc
!= UNKNOWN_LOCATION
6461 warning_at (loc
, OPT_Wc___compat
,
6462 ("enum type defined in struct or union "
6463 "is not visible in C++"));
6464 inform (refloc
, "enum type defined here");
6467 warning_at (loc
, OPT_Wc___compat
,
6468 ("struct defined in struct or union "
6469 "is not visible in C++"));
6470 inform (refloc
, "struct defined here");
6473 warning_at (loc
, OPT_Wc___compat
,
6474 ("union defined in struct or union "
6475 "is not visible in C++"));
6476 inform (refloc
, "union defined here");
6487 /* If no such tag is yet defined, create a forward-reference node
6488 and record it as the "definition".
6489 When a real declaration of this type is found,
6490 the forward-reference will be altered into a real type. */
6492 ref
= make_node (code
);
6493 if (code
== ENUMERAL_TYPE
)
6495 /* Give the type a default layout like unsigned int
6496 to avoid crashing if it does not get defined. */
6497 SET_TYPE_MODE (ref
, TYPE_MODE (unsigned_type_node
));
6498 TYPE_ALIGN (ref
) = TYPE_ALIGN (unsigned_type_node
);
6499 TYPE_USER_ALIGN (ref
) = 0;
6500 TYPE_UNSIGNED (ref
) = 1;
6501 TYPE_PRECISION (ref
) = TYPE_PRECISION (unsigned_type_node
);
6502 TYPE_MIN_VALUE (ref
) = TYPE_MIN_VALUE (unsigned_type_node
);
6503 TYPE_MAX_VALUE (ref
) = TYPE_MAX_VALUE (unsigned_type_node
);
6506 pushtag (loc
, name
, ref
);
6512 /* Get the struct, enum or union (CODE says which) with tag NAME.
6513 Define the tag as a forward-reference if it is not defined.
6514 Return a tree for the type. */
6517 xref_tag (enum tree_code code
, tree name
)
6519 return parser_xref_tag (input_location
, code
, name
).spec
;
6522 /* Make sure that the tag NAME is defined *in the current scope*
6523 at least as a forward reference.
6524 LOC is the location of the struct's definition.
6525 CODE says which kind of tag NAME ought to be.
6527 This stores the current value of the file static STRUCT_PARSE_INFO
6528 in *ENCLOSING_STRUCT_PARSE_INFO, and points STRUCT_PARSE_INFO at a
6529 new c_struct_parse_info structure. The old value of
6530 STRUCT_PARSE_INFO is restored in finish_struct. */
6533 start_struct (location_t loc
, enum tree_code code
, tree name
,
6534 struct c_struct_parse_info
**enclosing_struct_parse_info
)
6536 /* If there is already a tag defined at this scope
6537 (as a forward reference), just return it. */
6539 tree ref
= NULL_TREE
;
6540 location_t refloc
= UNKNOWN_LOCATION
;
6542 if (name
!= NULL_TREE
)
6543 ref
= lookup_tag (code
, name
, 1, &refloc
);
6544 if (ref
&& TREE_CODE (ref
) == code
)
6546 if (TYPE_SIZE (ref
))
6548 if (code
== UNION_TYPE
)
6549 error_at (loc
, "redefinition of %<union %E%>", name
);
6551 error_at (loc
, "redefinition of %<struct %E%>", name
);
6552 if (refloc
!= UNKNOWN_LOCATION
)
6553 inform (refloc
, "originally defined here");
6554 /* Don't create structures using a name already in use. */
6557 else if (C_TYPE_BEING_DEFINED (ref
))
6559 if (code
== UNION_TYPE
)
6560 error_at (loc
, "nested redefinition of %<union %E%>", name
);
6562 error_at (loc
, "nested redefinition of %<struct %E%>", name
);
6563 /* Don't bother to report "originally defined here" for a
6564 nested redefinition; the original definition should be
6566 /* Don't create structures that contain themselves. */
6571 /* Otherwise create a forward-reference just so the tag is in scope. */
6573 if (ref
== NULL_TREE
|| TREE_CODE (ref
) != code
)
6575 ref
= make_node (code
);
6576 pushtag (loc
, name
, ref
);
6579 C_TYPE_BEING_DEFINED (ref
) = 1;
6580 TYPE_PACKED (ref
) = flag_pack_struct
;
6582 *enclosing_struct_parse_info
= struct_parse_info
;
6583 struct_parse_info
= XNEW (struct c_struct_parse_info
);
6584 struct_parse_info
->struct_types
= VEC_alloc (tree
, heap
, 0);
6585 struct_parse_info
->fields
= VEC_alloc (c_binding_ptr
, heap
, 0);
6586 struct_parse_info
->typedefs_seen
= VEC_alloc (tree
, heap
, 0);
6588 /* FIXME: This will issue a warning for a use of a type defined
6589 within a statement expr used within sizeof, et. al. This is not
6590 terribly serious as C++ doesn't permit statement exprs within
6592 if (warn_cxx_compat
&& (in_sizeof
|| in_typeof
|| in_alignof
))
6593 warning_at (loc
, OPT_Wc___compat
,
6594 "defining type in %qs expression is invalid in C++",
6597 : (in_typeof
? "typeof" : "alignof")));
6602 /* Process the specs, declarator and width (NULL if omitted)
6603 of a structure component, returning a FIELD_DECL node.
6604 WIDTH is non-NULL for bit-fields only, and is an INTEGER_CST node.
6605 DECL_ATTRS is as for grokdeclarator.
6607 LOC is the location of the structure component.
6609 This is done during the parsing of the struct declaration.
6610 The FIELD_DECL nodes are chained together and the lot of them
6611 are ultimately passed to `build_struct' to make the RECORD_TYPE node. */
6614 grokfield (location_t loc
,
6615 struct c_declarator
*declarator
, struct c_declspecs
*declspecs
,
6616 tree width
, tree
*decl_attrs
)
6620 if (declarator
->kind
== cdk_id
&& declarator
->u
.id
== NULL_TREE
6621 && width
== NULL_TREE
)
6623 /* This is an unnamed decl.
6625 If we have something of the form "union { list } ;" then this
6626 is the anonymous union extension. Similarly for struct.
6628 If this is something of the form "struct foo;", then
6629 If MS or Plan 9 extensions are enabled, this is handled as
6630 an anonymous struct.
6631 Otherwise this is a forward declaration of a structure tag.
6633 If this is something of the form "foo;" and foo is a TYPE_DECL, then
6634 If foo names a structure or union without a tag, then this
6635 is an anonymous struct (this is permitted by C1X).
6636 If MS or Plan 9 extensions are enabled and foo names a
6637 structure, then again this is an anonymous struct.
6638 Otherwise this is an error.
6640 Oh what a horrid tangled web we weave. I wonder if MS consciously
6641 took this from Plan 9 or if it was an accident of implementation
6642 that took root before someone noticed the bug... */
6644 tree type
= declspecs
->type
;
6645 bool type_ok
= (TREE_CODE (type
) == RECORD_TYPE
6646 || TREE_CODE (type
) == UNION_TYPE
);
6651 if (flag_ms_extensions
|| flag_plan9_extensions
)
6653 else if (TYPE_NAME (TYPE_MAIN_VARIANT (type
)) == NULL
)
6660 pedwarn (loc
, 0, "declaration does not declare anything");
6666 pedwarn (loc
, OPT_pedantic
,
6667 "ISO C99 doesn%'t support unnamed structs/unions");
6669 pedwarn (loc
, OPT_pedantic
,
6670 "ISO C90 doesn%'t support unnamed structs/unions");
6674 value
= grokdeclarator (declarator
, declspecs
, FIELD
, false,
6675 width
? &width
: NULL
, decl_attrs
, NULL
, NULL
,
6678 finish_decl (value
, loc
, NULL_TREE
, NULL_TREE
, NULL_TREE
);
6679 DECL_INITIAL (value
) = width
;
6681 if (warn_cxx_compat
&& DECL_NAME (value
) != NULL_TREE
)
6683 /* If we currently have a binding for this field, set the
6684 in_struct field in the binding, so that we warn about lookups
6686 struct c_binding
*b
= I_SYMBOL_BINDING (DECL_NAME (value
));
6689 /* If the in_struct field is not yet set, push it on a list
6690 to be cleared when this struct is finished. */
6693 VEC_safe_push (c_binding_ptr
, heap
,
6694 struct_parse_info
->fields
, b
);
6703 /* Subroutine of detect_field_duplicates: return whether X and Y,
6704 which are both fields in the same struct, have duplicate field
6708 is_duplicate_field (tree x
, tree y
)
6710 if (DECL_NAME (x
) != NULL_TREE
&& DECL_NAME (x
) == DECL_NAME (y
))
6713 /* When using -fplan9-extensions, an anonymous field whose name is a
6714 typedef can duplicate a field name. */
6715 if (flag_plan9_extensions
6716 && (DECL_NAME (x
) == NULL_TREE
|| DECL_NAME (y
) == NULL_TREE
))
6718 tree xt
, xn
, yt
, yn
;
6721 if (DECL_NAME (x
) != NULL_TREE
)
6723 else if ((TREE_CODE (xt
) == RECORD_TYPE
|| TREE_CODE (xt
) == UNION_TYPE
)
6724 && TYPE_NAME (xt
) != NULL_TREE
6725 && TREE_CODE (TYPE_NAME (xt
)) == TYPE_DECL
)
6726 xn
= DECL_NAME (TYPE_NAME (xt
));
6731 if (DECL_NAME (y
) != NULL_TREE
)
6733 else if ((TREE_CODE (yt
) == RECORD_TYPE
|| TREE_CODE (yt
) == UNION_TYPE
)
6734 && TYPE_NAME (yt
) != NULL_TREE
6735 && TREE_CODE (TYPE_NAME (yt
)) == TYPE_DECL
)
6736 yn
= DECL_NAME (TYPE_NAME (yt
));
6740 if (xn
!= NULL_TREE
&& xn
== yn
)
6747 /* Subroutine of detect_field_duplicates: add the fields of FIELDLIST
6748 to HTAB, giving errors for any duplicates. */
6751 detect_field_duplicates_hash (tree fieldlist
, htab_t htab
)
6756 for (x
= fieldlist
; x
; x
= DECL_CHAIN (x
))
6757 if ((y
= DECL_NAME (x
)) != 0)
6759 slot
= htab_find_slot (htab
, y
, INSERT
);
6762 error ("duplicate member %q+D", x
);
6763 DECL_NAME (x
) = NULL_TREE
;
6767 else if (TREE_CODE (TREE_TYPE (x
)) == RECORD_TYPE
6768 || TREE_CODE (TREE_TYPE (x
)) == UNION_TYPE
)
6770 detect_field_duplicates_hash (TYPE_FIELDS (TREE_TYPE (x
)), htab
);
6772 /* When using -fplan9-extensions, an anonymous field whose
6773 name is a typedef can duplicate a field name. */
6774 if (flag_plan9_extensions
6775 && TYPE_NAME (TREE_TYPE (x
)) != NULL_TREE
6776 && TREE_CODE (TYPE_NAME (TREE_TYPE (x
))) == TYPE_DECL
)
6778 tree xn
= DECL_NAME (TYPE_NAME (TREE_TYPE (x
)));
6779 slot
= htab_find_slot (htab
, xn
, INSERT
);
6781 error ("duplicate member %q+D", TYPE_NAME (TREE_TYPE (x
)));
6787 /* Generate an error for any duplicate field names in FIELDLIST. Munge
6788 the list such that this does not present a problem later. */
6791 detect_field_duplicates (tree fieldlist
)
6796 /* If the struct is the list of instance variables of an Objective-C
6797 class, then we need to add all the instance variables of
6798 superclasses before checking for duplicates (since you can't have
6799 an instance variable in a subclass with the same name as an
6800 instance variable in a superclass). objc_get_interface_ivars()
6801 leaves fieldlist unchanged if we are not in this case, so in that
6802 case nothing changes compared to C.
6804 if (c_dialect_objc ())
6805 fieldlist
= objc_get_interface_ivars (fieldlist
);
6807 /* First, see if there are more than "a few" fields.
6808 This is trivially true if there are zero or one fields. */
6811 x
= DECL_CHAIN (fieldlist
);
6816 if (DECL_NAME (x
) == NULL_TREE
6817 && (TREE_CODE (TREE_TYPE (x
)) == RECORD_TYPE
6818 || TREE_CODE (TREE_TYPE (x
)) == UNION_TYPE
))
6821 } while (timeout
> 0 && x
);
6823 /* If there were "few" fields and no anonymous structures or unions,
6824 avoid the overhead of allocating a hash table. Instead just do
6825 the nested traversal thing. */
6828 for (x
= DECL_CHAIN (fieldlist
); x
; x
= DECL_CHAIN (x
))
6829 /* When using -fplan9-extensions, we can have duplicates
6830 between typedef names and fields. */
6832 || (flag_plan9_extensions
6833 && DECL_NAME (x
) == NULL_TREE
6834 && (TREE_CODE (TREE_TYPE (x
)) == RECORD_TYPE
6835 || TREE_CODE (TREE_TYPE (x
)) == UNION_TYPE
)
6836 && TYPE_NAME (TREE_TYPE (x
)) != NULL_TREE
6837 && TREE_CODE (TYPE_NAME (TREE_TYPE (x
))) == TYPE_DECL
))
6839 for (y
= fieldlist
; y
!= x
; y
= TREE_CHAIN (y
))
6840 if (is_duplicate_field (y
, x
))
6842 error ("duplicate member %q+D", x
);
6843 DECL_NAME (x
) = NULL_TREE
;
6849 htab_t htab
= htab_create (37, htab_hash_pointer
, htab_eq_pointer
, NULL
);
6851 detect_field_duplicates_hash (fieldlist
, htab
);
6856 /* Finish up struct info used by -Wc++-compat. */
6859 warn_cxx_compat_finish_struct (tree fieldlist
)
6863 struct c_binding
*b
;
6865 /* Set the C_TYPE_DEFINED_IN_STRUCT flag for each type defined in
6866 the current struct. We do this now at the end of the struct
6867 because the flag is used to issue visibility warnings, and we
6868 only want to issue those warnings if the type is referenced
6869 outside of the struct declaration. */
6870 FOR_EACH_VEC_ELT (tree
, struct_parse_info
->struct_types
, ix
, x
)
6871 C_TYPE_DEFINED_IN_STRUCT (x
) = 1;
6873 /* The TYPEDEFS_SEEN field of STRUCT_PARSE_INFO is a list of
6874 typedefs used when declaring fields in this struct. If the name
6875 of any of the fields is also a typedef name then the struct would
6876 not parse in C++, because the C++ lookup rules say that the
6877 typedef name would be looked up in the context of the struct, and
6878 would thus be the field rather than the typedef. */
6879 if (!VEC_empty (tree
, struct_parse_info
->typedefs_seen
)
6880 && fieldlist
!= NULL_TREE
)
6882 /* Use a pointer_set using the name of the typedef. We can use
6883 a pointer_set because identifiers are interned. */
6884 struct pointer_set_t
*tset
= pointer_set_create ();
6886 FOR_EACH_VEC_ELT (tree
, struct_parse_info
->typedefs_seen
, ix
, x
)
6887 pointer_set_insert (tset
, DECL_NAME (x
));
6889 for (x
= fieldlist
; x
!= NULL_TREE
; x
= DECL_CHAIN (x
))
6891 if (DECL_NAME (x
) != NULL_TREE
6892 && pointer_set_contains (tset
, DECL_NAME (x
)))
6894 warning_at (DECL_SOURCE_LOCATION (x
), OPT_Wc___compat
,
6895 ("using %qD as both field and typedef name is "
6898 /* FIXME: It would be nice to report the location where
6899 the typedef name is used. */
6903 pointer_set_destroy (tset
);
6906 /* For each field which has a binding and which was not defined in
6907 an enclosing struct, clear the in_struct field. */
6908 FOR_EACH_VEC_ELT (c_binding_ptr
, struct_parse_info
->fields
, ix
, b
)
6912 /* Fill in the fields of a RECORD_TYPE or UNION_TYPE node, T.
6913 LOC is the location of the RECORD_TYPE or UNION_TYPE's definition.
6914 FIELDLIST is a chain of FIELD_DECL nodes for the fields.
6915 ATTRIBUTES are attributes to be applied to the structure.
6917 ENCLOSING_STRUCT_PARSE_INFO is the value of STRUCT_PARSE_INFO when
6918 the struct was started. */
6921 finish_struct (location_t loc
, tree t
, tree fieldlist
, tree attributes
,
6922 struct c_struct_parse_info
*enclosing_struct_parse_info
)
6925 bool toplevel
= file_scope
== current_scope
;
6926 int saw_named_field
;
6928 /* If this type was previously laid out as a forward reference,
6929 make sure we lay it out again. */
6933 decl_attributes (&t
, attributes
, (int) ATTR_FLAG_TYPE_IN_PLACE
);
6937 for (x
= fieldlist
; x
; x
= DECL_CHAIN (x
))
6939 if (DECL_NAME (x
) != 0)
6942 && (TREE_CODE (TREE_TYPE (x
)) == RECORD_TYPE
6943 || TREE_CODE (TREE_TYPE (x
)) == UNION_TYPE
))
6949 if (TREE_CODE (t
) == UNION_TYPE
)
6952 pedwarn (loc
, OPT_pedantic
, "union has no named members");
6954 pedwarn (loc
, OPT_pedantic
, "union has no members");
6959 pedwarn (loc
, OPT_pedantic
, "struct has no named members");
6961 pedwarn (loc
, OPT_pedantic
, "struct has no members");
6966 /* Install struct as DECL_CONTEXT of each field decl.
6967 Also process specified field sizes, found in the DECL_INITIAL,
6968 storing 0 there after the type has been changed to precision equal
6969 to its width, rather than the precision of the specified standard
6970 type. (Correct layout requires the original type to have been preserved
6973 saw_named_field
= 0;
6974 for (x
= fieldlist
; x
; x
= DECL_CHAIN (x
))
6976 if (TREE_TYPE (x
) == error_mark_node
)
6979 DECL_CONTEXT (x
) = t
;
6981 /* If any field is const, the structure type is pseudo-const. */
6982 if (TREE_READONLY (x
))
6983 C_TYPE_FIELDS_READONLY (t
) = 1;
6986 /* A field that is pseudo-const makes the structure likewise. */
6987 tree t1
= strip_array_types (TREE_TYPE (x
));
6988 if ((TREE_CODE (t1
) == RECORD_TYPE
|| TREE_CODE (t1
) == UNION_TYPE
)
6989 && C_TYPE_FIELDS_READONLY (t1
))
6990 C_TYPE_FIELDS_READONLY (t
) = 1;
6993 /* Any field that is volatile means variables of this type must be
6994 treated in some ways as volatile. */
6995 if (TREE_THIS_VOLATILE (x
))
6996 C_TYPE_FIELDS_VOLATILE (t
) = 1;
6998 /* Any field of nominal variable size implies structure is too. */
6999 if (C_DECL_VARIABLE_SIZE (x
))
7000 C_TYPE_VARIABLE_SIZE (t
) = 1;
7002 if (DECL_INITIAL (x
))
7004 unsigned HOST_WIDE_INT width
= tree_low_cst (DECL_INITIAL (x
), 1);
7005 DECL_SIZE (x
) = bitsize_int (width
);
7006 DECL_BIT_FIELD (x
) = 1;
7007 SET_DECL_C_BIT_FIELD (x
);
7011 && (DECL_BIT_FIELD (x
)
7012 || TYPE_ALIGN (TREE_TYPE (x
)) > BITS_PER_UNIT
))
7013 DECL_PACKED (x
) = 1;
7015 /* Detect flexible array member in an invalid context. */
7016 if (TREE_CODE (TREE_TYPE (x
)) == ARRAY_TYPE
7017 && TYPE_SIZE (TREE_TYPE (x
)) == NULL_TREE
7018 && TYPE_DOMAIN (TREE_TYPE (x
)) != NULL_TREE
7019 && TYPE_MAX_VALUE (TYPE_DOMAIN (TREE_TYPE (x
))) == NULL_TREE
)
7021 if (TREE_CODE (t
) == UNION_TYPE
)
7023 error_at (DECL_SOURCE_LOCATION (x
),
7024 "flexible array member in union");
7025 TREE_TYPE (x
) = error_mark_node
;
7027 else if (DECL_CHAIN (x
) != NULL_TREE
)
7029 error_at (DECL_SOURCE_LOCATION (x
),
7030 "flexible array member not at end of struct");
7031 TREE_TYPE (x
) = error_mark_node
;
7033 else if (!saw_named_field
)
7035 error_at (DECL_SOURCE_LOCATION (x
),
7036 "flexible array member in otherwise empty struct");
7037 TREE_TYPE (x
) = error_mark_node
;
7041 if (pedantic
&& TREE_CODE (t
) == RECORD_TYPE
7042 && flexible_array_type_p (TREE_TYPE (x
)))
7043 pedwarn (DECL_SOURCE_LOCATION (x
), OPT_pedantic
,
7044 "invalid use of structure with flexible array member");
7047 || TREE_CODE (TREE_TYPE (x
)) == RECORD_TYPE
7048 || TREE_CODE (TREE_TYPE (x
)) == UNION_TYPE
)
7049 saw_named_field
= 1;
7052 detect_field_duplicates (fieldlist
);
7054 /* Now we have the nearly final fieldlist. Record it,
7055 then lay out the structure or union (including the fields). */
7057 TYPE_FIELDS (t
) = fieldlist
;
7061 /* Give bit-fields their proper types. */
7063 tree
*fieldlistp
= &fieldlist
;
7065 if (TREE_CODE (*fieldlistp
) == FIELD_DECL
&& DECL_INITIAL (*fieldlistp
)
7066 && TREE_TYPE (*fieldlistp
) != error_mark_node
)
7068 unsigned HOST_WIDE_INT width
7069 = tree_low_cst (DECL_INITIAL (*fieldlistp
), 1);
7070 tree type
= TREE_TYPE (*fieldlistp
);
7071 if (width
!= TYPE_PRECISION (type
))
7073 TREE_TYPE (*fieldlistp
)
7074 = c_build_bitfield_integer_type (width
, TYPE_UNSIGNED (type
));
7075 DECL_MODE (*fieldlistp
) = TYPE_MODE (TREE_TYPE (*fieldlistp
));
7077 DECL_INITIAL (*fieldlistp
) = 0;
7080 fieldlistp
= &DECL_CHAIN (*fieldlistp
);
7083 /* Now we have the truly final field list.
7084 Store it in this type and in the variants. */
7086 TYPE_FIELDS (t
) = fieldlist
;
7088 /* If there are lots of fields, sort so we can look through them fast.
7089 We arbitrarily consider 16 or more elts to be "a lot". */
7094 for (x
= fieldlist
; x
; x
= DECL_CHAIN (x
))
7096 if (len
> 15 || DECL_NAME (x
) == NULL
)
7104 struct lang_type
*space
;
7105 struct sorted_fields_type
*space2
;
7107 len
+= list_length (x
);
7109 /* Use the same allocation policy here that make_node uses, to
7110 ensure that this lives as long as the rest of the struct decl.
7111 All decls in an inline function need to be saved. */
7113 space
= ggc_alloc_cleared_lang_type (sizeof (struct lang_type
));
7114 space2
= ggc_alloc_sorted_fields_type
7115 (sizeof (struct sorted_fields_type
) + len
* sizeof (tree
));
7119 field_array
= &space2
->elts
[0];
7120 for (x
= fieldlist
; x
; x
= DECL_CHAIN (x
))
7122 field_array
[len
++] = x
;
7124 /* If there is anonymous struct or union, break out of the loop. */
7125 if (DECL_NAME (x
) == NULL
)
7128 /* Found no anonymous struct/union. Add the TYPE_LANG_SPECIFIC. */
7131 TYPE_LANG_SPECIFIC (t
) = space
;
7132 TYPE_LANG_SPECIFIC (t
)->s
->len
= len
;
7133 field_array
= TYPE_LANG_SPECIFIC (t
)->s
->elts
;
7134 qsort (field_array
, len
, sizeof (tree
), field_decl_cmp
);
7139 for (x
= TYPE_MAIN_VARIANT (t
); x
; x
= TYPE_NEXT_VARIANT (x
))
7141 TYPE_FIELDS (x
) = TYPE_FIELDS (t
);
7142 TYPE_LANG_SPECIFIC (x
) = TYPE_LANG_SPECIFIC (t
);
7143 C_TYPE_FIELDS_READONLY (x
) = C_TYPE_FIELDS_READONLY (t
);
7144 C_TYPE_FIELDS_VOLATILE (x
) = C_TYPE_FIELDS_VOLATILE (t
);
7145 C_TYPE_VARIABLE_SIZE (x
) = C_TYPE_VARIABLE_SIZE (t
);
7148 /* If this was supposed to be a transparent union, but we can't
7149 make it one, warn and turn off the flag. */
7150 if (TREE_CODE (t
) == UNION_TYPE
7151 && TYPE_TRANSPARENT_AGGR (t
)
7152 && (!TYPE_FIELDS (t
) || TYPE_MODE (t
) != DECL_MODE (TYPE_FIELDS (t
))))
7154 TYPE_TRANSPARENT_AGGR (t
) = 0;
7155 warning_at (loc
, 0, "union cannot be made transparent");
7158 /* If this structure or union completes the type of any previous
7159 variable declaration, lay it out and output its rtl. */
7160 for (x
= C_TYPE_INCOMPLETE_VARS (TYPE_MAIN_VARIANT (t
));
7164 tree decl
= TREE_VALUE (x
);
7165 if (TREE_CODE (TREE_TYPE (decl
)) == ARRAY_TYPE
)
7166 layout_array_type (TREE_TYPE (decl
));
7167 if (TREE_CODE (decl
) != TYPE_DECL
)
7169 layout_decl (decl
, 0);
7170 if (c_dialect_objc ())
7171 objc_check_decl (decl
);
7172 rest_of_decl_compilation (decl
, toplevel
, 0);
7177 C_TYPE_INCOMPLETE_VARS (TYPE_MAIN_VARIANT (t
)) = 0;
7179 /* Update type location to the one of the definition, instead of e.g.
7180 a forward declaration. */
7181 if (TYPE_STUB_DECL (t
))
7182 DECL_SOURCE_LOCATION (TYPE_STUB_DECL (t
)) = loc
;
7184 /* Finish debugging output for this type. */
7185 rest_of_type_compilation (t
, toplevel
);
7187 /* If we're inside a function proper, i.e. not file-scope and not still
7188 parsing parameters, then arrange for the size of a variable sized type
7190 if (cur_stmt_list
&& variably_modified_type_p (t
, NULL_TREE
))
7191 add_stmt (build_stmt (loc
,
7192 DECL_EXPR
, build_decl (loc
, TYPE_DECL
, NULL
, t
)));
7194 if (warn_cxx_compat
)
7195 warn_cxx_compat_finish_struct (fieldlist
);
7197 VEC_free (tree
, heap
, struct_parse_info
->struct_types
);
7198 VEC_free (c_binding_ptr
, heap
, struct_parse_info
->fields
);
7199 VEC_free (tree
, heap
, struct_parse_info
->typedefs_seen
);
7200 XDELETE (struct_parse_info
);
7202 struct_parse_info
= enclosing_struct_parse_info
;
7204 /* If this struct is defined inside a struct, add it to
7207 && struct_parse_info
!= NULL
7208 && !in_sizeof
&& !in_typeof
&& !in_alignof
)
7209 VEC_safe_push (tree
, heap
, struct_parse_info
->struct_types
, t
);
7214 /* Lay out the type T, and its element type, and so on. */
7217 layout_array_type (tree t
)
7219 if (TREE_CODE (TREE_TYPE (t
)) == ARRAY_TYPE
)
7220 layout_array_type (TREE_TYPE (t
));
7224 /* Begin compiling the definition of an enumeration type.
7225 NAME is its name (or null if anonymous).
7226 LOC is the enum's location.
7227 Returns the type object, as yet incomplete.
7228 Also records info about it so that build_enumerator
7229 may be used to declare the individual values as they are read. */
7232 start_enum (location_t loc
, struct c_enum_contents
*the_enum
, tree name
)
7234 tree enumtype
= NULL_TREE
;
7235 location_t enumloc
= UNKNOWN_LOCATION
;
7237 /* If this is the real definition for a previous forward reference,
7238 fill in the contents in the same object that used to be the
7239 forward reference. */
7241 if (name
!= NULL_TREE
)
7242 enumtype
= lookup_tag (ENUMERAL_TYPE
, name
, 1, &enumloc
);
7244 if (enumtype
== 0 || TREE_CODE (enumtype
) != ENUMERAL_TYPE
)
7246 enumtype
= make_node (ENUMERAL_TYPE
);
7247 pushtag (loc
, name
, enumtype
);
7250 if (C_TYPE_BEING_DEFINED (enumtype
))
7251 error_at (loc
, "nested redefinition of %<enum %E%>", name
);
7253 C_TYPE_BEING_DEFINED (enumtype
) = 1;
7255 if (TYPE_VALUES (enumtype
) != 0)
7257 /* This enum is a named one that has been declared already. */
7258 error_at (loc
, "redeclaration of %<enum %E%>", name
);
7259 if (enumloc
!= UNKNOWN_LOCATION
)
7260 inform (enumloc
, "originally defined here");
7262 /* Completely replace its old definition.
7263 The old enumerators remain defined, however. */
7264 TYPE_VALUES (enumtype
) = 0;
7267 the_enum
->enum_next_value
= integer_zero_node
;
7268 the_enum
->enum_overflow
= 0;
7270 if (flag_short_enums
)
7271 TYPE_PACKED (enumtype
) = 1;
7273 /* FIXME: This will issue a warning for a use of a type defined
7274 within sizeof in a statement expr. This is not terribly serious
7275 as C++ doesn't permit statement exprs within sizeof anyhow. */
7276 if (warn_cxx_compat
&& (in_sizeof
|| in_typeof
|| in_alignof
))
7277 warning_at (loc
, OPT_Wc___compat
,
7278 "defining type in %qs expression is invalid in C++",
7281 : (in_typeof
? "typeof" : "alignof")));
7286 /* After processing and defining all the values of an enumeration type,
7287 install their decls in the enumeration type and finish it off.
7288 ENUMTYPE is the type object, VALUES a list of decl-value pairs,
7289 and ATTRIBUTES are the specified attributes.
7290 Returns ENUMTYPE. */
7293 finish_enum (tree enumtype
, tree values
, tree attributes
)
7296 tree minnode
= 0, maxnode
= 0;
7297 int precision
, unsign
;
7298 bool toplevel
= (file_scope
== current_scope
);
7299 struct lang_type
*lt
;
7301 decl_attributes (&enumtype
, attributes
, (int) ATTR_FLAG_TYPE_IN_PLACE
);
7303 /* Calculate the maximum value of any enumerator in this type. */
7305 if (values
== error_mark_node
)
7306 minnode
= maxnode
= integer_zero_node
;
7309 minnode
= maxnode
= TREE_VALUE (values
);
7310 for (pair
= TREE_CHAIN (values
); pair
; pair
= TREE_CHAIN (pair
))
7312 tree value
= TREE_VALUE (pair
);
7313 if (tree_int_cst_lt (maxnode
, value
))
7315 if (tree_int_cst_lt (value
, minnode
))
7320 /* Construct the final type of this enumeration. It is the same
7321 as one of the integral types - the narrowest one that fits, except
7322 that normally we only go as narrow as int - and signed iff any of
7323 the values are negative. */
7324 unsign
= (tree_int_cst_sgn (minnode
) >= 0);
7325 precision
= MAX (tree_int_cst_min_precision (minnode
, unsign
),
7326 tree_int_cst_min_precision (maxnode
, unsign
));
7328 if (TYPE_PACKED (enumtype
) || precision
> TYPE_PRECISION (integer_type_node
))
7330 tem
= c_common_type_for_size (precision
, unsign
);
7333 warning (0, "enumeration values exceed range of largest integer");
7334 tem
= long_long_integer_type_node
;
7338 tem
= unsign
? unsigned_type_node
: integer_type_node
;
7340 TYPE_MIN_VALUE (enumtype
) = TYPE_MIN_VALUE (tem
);
7341 TYPE_MAX_VALUE (enumtype
) = TYPE_MAX_VALUE (tem
);
7342 TYPE_UNSIGNED (enumtype
) = TYPE_UNSIGNED (tem
);
7343 TYPE_SIZE (enumtype
) = 0;
7345 /* If the precision of the type was specific with an attribute and it
7346 was too small, give an error. Otherwise, use it. */
7347 if (TYPE_PRECISION (enumtype
))
7349 if (precision
> TYPE_PRECISION (enumtype
))
7350 error ("specified mode too small for enumeral values");
7353 TYPE_PRECISION (enumtype
) = TYPE_PRECISION (tem
);
7355 layout_type (enumtype
);
7357 if (values
!= error_mark_node
)
7359 /* Change the type of the enumerators to be the enum type. We
7360 need to do this irrespective of the size of the enum, for
7361 proper type checking. Replace the DECL_INITIALs of the
7362 enumerators, and the value slots of the list, with copies
7363 that have the enum type; they cannot be modified in place
7364 because they may be shared (e.g. integer_zero_node) Finally,
7365 change the purpose slots to point to the names of the decls. */
7366 for (pair
= values
; pair
; pair
= TREE_CHAIN (pair
))
7368 tree enu
= TREE_PURPOSE (pair
);
7369 tree ini
= DECL_INITIAL (enu
);
7371 TREE_TYPE (enu
) = enumtype
;
7373 /* The ISO C Standard mandates enumerators to have type int,
7374 even though the underlying type of an enum type is
7375 unspecified. However, GCC allows enumerators of any
7376 integer type as an extensions. build_enumerator()
7377 converts any enumerators that fit in an int to type int,
7378 to avoid promotions to unsigned types when comparing
7379 integers with enumerators that fit in the int range.
7380 When -pedantic is given, build_enumerator() would have
7381 already warned about those that don't fit. Here we
7382 convert the rest to the enumerator type. */
7383 if (TREE_TYPE (ini
) != integer_type_node
)
7384 ini
= convert (enumtype
, ini
);
7386 DECL_INITIAL (enu
) = ini
;
7387 TREE_PURPOSE (pair
) = DECL_NAME (enu
);
7388 TREE_VALUE (pair
) = ini
;
7391 TYPE_VALUES (enumtype
) = values
;
7394 /* Record the min/max values so that we can warn about bit-field
7395 enumerations that are too small for the values. */
7396 lt
= ggc_alloc_cleared_lang_type (sizeof (struct lang_type
));
7397 lt
->enum_min
= minnode
;
7398 lt
->enum_max
= maxnode
;
7399 TYPE_LANG_SPECIFIC (enumtype
) = lt
;
7401 /* Fix up all variant types of this enum type. */
7402 for (tem
= TYPE_MAIN_VARIANT (enumtype
); tem
; tem
= TYPE_NEXT_VARIANT (tem
))
7404 if (tem
== enumtype
)
7406 TYPE_VALUES (tem
) = TYPE_VALUES (enumtype
);
7407 TYPE_MIN_VALUE (tem
) = TYPE_MIN_VALUE (enumtype
);
7408 TYPE_MAX_VALUE (tem
) = TYPE_MAX_VALUE (enumtype
);
7409 TYPE_SIZE (tem
) = TYPE_SIZE (enumtype
);
7410 TYPE_SIZE_UNIT (tem
) = TYPE_SIZE_UNIT (enumtype
);
7411 SET_TYPE_MODE (tem
, TYPE_MODE (enumtype
));
7412 TYPE_PRECISION (tem
) = TYPE_PRECISION (enumtype
);
7413 TYPE_ALIGN (tem
) = TYPE_ALIGN (enumtype
);
7414 TYPE_USER_ALIGN (tem
) = TYPE_USER_ALIGN (enumtype
);
7415 TYPE_UNSIGNED (tem
) = TYPE_UNSIGNED (enumtype
);
7416 TYPE_LANG_SPECIFIC (tem
) = TYPE_LANG_SPECIFIC (enumtype
);
7419 /* Finish debugging output for this type. */
7420 rest_of_type_compilation (enumtype
, toplevel
);
7422 /* If this enum is defined inside a struct, add it to
7425 && struct_parse_info
!= NULL
7426 && !in_sizeof
&& !in_typeof
&& !in_alignof
)
7427 VEC_safe_push (tree
, heap
, struct_parse_info
->struct_types
, enumtype
);
7432 /* Build and install a CONST_DECL for one value of the
7433 current enumeration type (one that was begun with start_enum).
7434 DECL_LOC is the location of the enumerator.
7435 LOC is the location of the '=' operator if any, DECL_LOC otherwise.
7436 Return a tree-list containing the CONST_DECL and its value.
7437 Assignment of sequential values by default is handled here. */
7440 build_enumerator (location_t decl_loc
, location_t loc
,
7441 struct c_enum_contents
*the_enum
, tree name
, tree value
)
7445 /* Validate and default VALUE. */
7449 /* Don't issue more errors for error_mark_node (i.e. an
7450 undeclared identifier) - just ignore the value expression. */
7451 if (value
== error_mark_node
)
7453 else if (!INTEGRAL_TYPE_P (TREE_TYPE (value
)))
7455 error_at (loc
, "enumerator value for %qE is not an integer constant",
7461 if (TREE_CODE (value
) != INTEGER_CST
)
7463 value
= c_fully_fold (value
, false, NULL
);
7464 if (TREE_CODE (value
) == INTEGER_CST
)
7465 pedwarn (loc
, OPT_pedantic
,
7466 "enumerator value for %qE is not an integer "
7467 "constant expression", name
);
7469 if (TREE_CODE (value
) != INTEGER_CST
)
7471 error ("enumerator value for %qE is not an integer constant",
7477 value
= default_conversion (value
);
7478 constant_expression_warning (value
);
7483 /* Default based on previous value. */
7484 /* It should no longer be possible to have NON_LVALUE_EXPR
7488 value
= the_enum
->enum_next_value
;
7489 if (the_enum
->enum_overflow
)
7490 error_at (loc
, "overflow in enumeration values");
7492 /* Even though the underlying type of an enum is unspecified, the
7493 type of enumeration constants is explicitly defined as int
7494 (6.4.4.3/2 in the C99 Standard). GCC allows any integer type as
7496 else if (!int_fits_type_p (value
, integer_type_node
))
7497 pedwarn (loc
, OPT_pedantic
,
7498 "ISO C restricts enumerator values to range of %<int%>");
7500 /* The ISO C Standard mandates enumerators to have type int, even
7501 though the underlying type of an enum type is unspecified.
7502 However, GCC allows enumerators of any integer type as an
7503 extensions. Here we convert any enumerators that fit in an int
7504 to type int, to avoid promotions to unsigned types when comparing
7505 integers with enumerators that fit in the int range. When
7506 -pedantic is given, we would have already warned about those that
7507 don't fit. We have to do this here rather than in finish_enum
7508 because this value may be used to define more enumerators. */
7509 if (int_fits_type_p (value
, integer_type_node
))
7510 value
= convert (integer_type_node
, value
);
7512 /* Set basis for default for next value. */
7513 the_enum
->enum_next_value
7514 = build_binary_op (EXPR_LOC_OR_HERE (value
),
7515 PLUS_EXPR
, value
, integer_one_node
, 0);
7516 the_enum
->enum_overflow
= tree_int_cst_lt (the_enum
->enum_next_value
, value
);
7518 /* Now create a declaration for the enum value name. */
7520 type
= TREE_TYPE (value
);
7521 type
= c_common_type_for_size (MAX (TYPE_PRECISION (type
),
7522 TYPE_PRECISION (integer_type_node
)),
7523 (TYPE_PRECISION (type
)
7524 >= TYPE_PRECISION (integer_type_node
)
7525 && TYPE_UNSIGNED (type
)));
7527 decl
= build_decl (decl_loc
, CONST_DECL
, name
, type
);
7528 DECL_INITIAL (decl
) = convert (type
, value
);
7531 return tree_cons (decl
, value
, NULL_TREE
);
7535 /* Create the FUNCTION_DECL for a function definition.
7536 DECLSPECS, DECLARATOR and ATTRIBUTES are the parts of
7537 the declaration; they describe the function's name and the type it returns,
7538 but twisted together in a fashion that parallels the syntax of C.
7540 This function creates a binding context for the function body
7541 as well as setting up the FUNCTION_DECL in current_function_decl.
7543 Returns 1 on success. If the DECLARATOR is not suitable for a function
7544 (it defines a datum instead), we return 0, which tells
7545 yyparse to report a parse error. */
7548 start_function (struct c_declspecs
*declspecs
, struct c_declarator
*declarator
,
7551 tree decl1
, old_decl
;
7552 tree restype
, resdecl
;
7555 current_function_returns_value
= 0; /* Assume, until we see it does. */
7556 current_function_returns_null
= 0;
7557 current_function_returns_abnormally
= 0;
7558 warn_about_return_type
= 0;
7559 c_switch_stack
= NULL
;
7561 /* Indicate no valid break/continue context by setting these variables
7562 to some non-null, non-label value. We'll notice and emit the proper
7563 error message in c_finish_bc_stmt. */
7564 c_break_label
= c_cont_label
= size_zero_node
;
7566 decl1
= grokdeclarator (declarator
, declspecs
, FUNCDEF
, true, NULL
,
7567 &attributes
, NULL
, NULL
, DEPRECATED_NORMAL
);
7569 /* If the declarator is not suitable for a function definition,
7570 cause a syntax error. */
7574 loc
= DECL_SOURCE_LOCATION (decl1
);
7576 decl_attributes (&decl1
, attributes
, 0);
7578 if (DECL_DECLARED_INLINE_P (decl1
)
7579 && DECL_UNINLINABLE (decl1
)
7580 && lookup_attribute ("noinline", DECL_ATTRIBUTES (decl1
)))
7581 warning_at (loc
, OPT_Wattributes
,
7582 "inline function %qD given attribute noinline",
7585 /* Handle gnu_inline attribute. */
7586 if (declspecs
->inline_p
7587 && !flag_gnu89_inline
7588 && TREE_CODE (decl1
) == FUNCTION_DECL
7589 && (lookup_attribute ("gnu_inline", DECL_ATTRIBUTES (decl1
))
7590 || current_function_decl
))
7592 if (declspecs
->storage_class
!= csc_static
)
7593 DECL_EXTERNAL (decl1
) = !DECL_EXTERNAL (decl1
);
7596 announce_function (decl1
);
7598 if (!COMPLETE_OR_VOID_TYPE_P (TREE_TYPE (TREE_TYPE (decl1
))))
7600 error_at (loc
, "return type is an incomplete type");
7601 /* Make it return void instead. */
7603 = build_function_type (void_type_node
,
7604 TYPE_ARG_TYPES (TREE_TYPE (decl1
)));
7607 if (warn_about_return_type
)
7608 pedwarn_c99 (loc
, flag_isoc99
? 0
7609 : (warn_return_type
? OPT_Wreturn_type
: OPT_Wimplicit_int
),
7610 "return type defaults to %<int%>");
7612 /* Make the init_value nonzero so pushdecl knows this is not tentative.
7613 error_mark_node is replaced below (in pop_scope) with the BLOCK. */
7614 DECL_INITIAL (decl1
) = error_mark_node
;
7616 /* A nested function is not global. */
7617 if (current_function_decl
!= 0)
7618 TREE_PUBLIC (decl1
) = 0;
7620 /* If this definition isn't a prototype and we had a prototype declaration
7621 before, copy the arg type info from that prototype. */
7622 old_decl
= lookup_name_in_scope (DECL_NAME (decl1
), current_scope
);
7623 if (old_decl
&& TREE_CODE (old_decl
) != FUNCTION_DECL
)
7625 current_function_prototype_locus
= UNKNOWN_LOCATION
;
7626 current_function_prototype_built_in
= false;
7627 current_function_prototype_arg_types
= NULL_TREE
;
7628 if (TYPE_ARG_TYPES (TREE_TYPE (decl1
)) == 0)
7630 if (old_decl
!= 0 && TREE_CODE (TREE_TYPE (old_decl
)) == FUNCTION_TYPE
7631 && comptypes (TREE_TYPE (TREE_TYPE (decl1
)),
7632 TREE_TYPE (TREE_TYPE (old_decl
))))
7634 TREE_TYPE (decl1
) = composite_type (TREE_TYPE (old_decl
),
7636 current_function_prototype_locus
= DECL_SOURCE_LOCATION (old_decl
);
7637 current_function_prototype_built_in
7638 = C_DECL_BUILTIN_PROTOTYPE (old_decl
);
7639 current_function_prototype_arg_types
7640 = TYPE_ARG_TYPES (TREE_TYPE (decl1
));
7642 if (TREE_PUBLIC (decl1
))
7644 /* If there is an external prototype declaration of this
7645 function, record its location but do not copy information
7646 to this decl. This may be an invisible declaration
7647 (built-in or in a scope which has finished) or simply
7648 have more refined argument types than any declaration
7650 struct c_binding
*b
;
7651 for (b
= I_SYMBOL_BINDING (DECL_NAME (decl1
)); b
; b
= b
->shadowed
)
7652 if (B_IN_SCOPE (b
, external_scope
))
7656 tree ext_decl
, ext_type
;
7658 ext_type
= b
->u
.type
? b
->u
.type
: TREE_TYPE (ext_decl
);
7659 if (TREE_CODE (ext_type
) == FUNCTION_TYPE
7660 && comptypes (TREE_TYPE (TREE_TYPE (decl1
)),
7661 TREE_TYPE (ext_type
)))
7663 current_function_prototype_locus
7664 = DECL_SOURCE_LOCATION (ext_decl
);
7665 current_function_prototype_built_in
7666 = C_DECL_BUILTIN_PROTOTYPE (ext_decl
);
7667 current_function_prototype_arg_types
7668 = TYPE_ARG_TYPES (ext_type
);
7674 /* Optionally warn of old-fashioned def with no previous prototype. */
7675 if (warn_strict_prototypes
7676 && old_decl
!= error_mark_node
7677 && TYPE_ARG_TYPES (TREE_TYPE (decl1
)) == 0
7678 && C_DECL_ISNT_PROTOTYPE (old_decl
))
7679 warning_at (loc
, OPT_Wstrict_prototypes
,
7680 "function declaration isn%'t a prototype");
7681 /* Optionally warn of any global def with no previous prototype. */
7682 else if (warn_missing_prototypes
7683 && old_decl
!= error_mark_node
7684 && TREE_PUBLIC (decl1
)
7685 && !MAIN_NAME_P (DECL_NAME (decl1
))
7686 && C_DECL_ISNT_PROTOTYPE (old_decl
))
7687 warning_at (loc
, OPT_Wmissing_prototypes
,
7688 "no previous prototype for %qD", decl1
);
7689 /* Optionally warn of any def with no previous prototype
7690 if the function has already been used. */
7691 else if (warn_missing_prototypes
7693 && old_decl
!= error_mark_node
7694 && TREE_USED (old_decl
)
7695 && TYPE_ARG_TYPES (TREE_TYPE (old_decl
)) == 0)
7696 warning_at (loc
, OPT_Wmissing_prototypes
,
7697 "%qD was used with no prototype before its definition", decl1
);
7698 /* Optionally warn of any global def with no previous declaration. */
7699 else if (warn_missing_declarations
7700 && TREE_PUBLIC (decl1
)
7702 && !MAIN_NAME_P (DECL_NAME (decl1
)))
7703 warning_at (loc
, OPT_Wmissing_declarations
,
7704 "no previous declaration for %qD",
7706 /* Optionally warn of any def with no previous declaration
7707 if the function has already been used. */
7708 else if (warn_missing_declarations
7710 && old_decl
!= error_mark_node
7711 && TREE_USED (old_decl
)
7712 && C_DECL_IMPLICIT (old_decl
))
7713 warning_at (loc
, OPT_Wmissing_declarations
,
7714 "%qD was used with no declaration before its definition", decl1
);
7716 /* This function exists in static storage.
7717 (This does not mean `static' in the C sense!) */
7718 TREE_STATIC (decl1
) = 1;
7720 /* This is the earliest point at which we might know the assembler
7721 name of the function. Thus, if it's set before this, die horribly. */
7722 gcc_assert (!DECL_ASSEMBLER_NAME_SET_P (decl1
));
7724 /* If #pragma weak was used, mark the decl weak now. */
7725 if (current_scope
== file_scope
)
7726 maybe_apply_pragma_weak (decl1
);
7728 /* Warn for unlikely, improbable, or stupid declarations of `main'. */
7729 if (warn_main
&& MAIN_NAME_P (DECL_NAME (decl1
)))
7731 if (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (decl1
)))
7732 != integer_type_node
)
7733 pedwarn (loc
, OPT_Wmain
, "return type of %qD is not %<int%>", decl1
);
7735 check_main_parameter_types (decl1
);
7737 if (!TREE_PUBLIC (decl1
))
7738 pedwarn (loc
, OPT_Wmain
,
7739 "%qD is normally a non-static function", decl1
);
7742 /* Record the decl so that the function name is defined.
7743 If we already have a decl for this name, and it is a FUNCTION_DECL,
7744 use the old decl. */
7746 current_function_decl
= pushdecl (decl1
);
7749 declare_parm_level ();
7751 restype
= TREE_TYPE (TREE_TYPE (current_function_decl
));
7752 resdecl
= build_decl (loc
, RESULT_DECL
, NULL_TREE
, restype
);
7753 DECL_ARTIFICIAL (resdecl
) = 1;
7754 DECL_IGNORED_P (resdecl
) = 1;
7755 DECL_RESULT (current_function_decl
) = resdecl
;
7757 start_fname_decls ();
7762 /* Subroutine of store_parm_decls which handles new-style function
7763 definitions (prototype format). The parms already have decls, so we
7764 need only record them as in effect and complain if any redundant
7765 old-style parm decls were written. */
7767 store_parm_decls_newstyle (tree fndecl
, const struct c_arg_info
*arg_info
)
7773 if (current_scope
->bindings
)
7775 error_at (DECL_SOURCE_LOCATION (fndecl
),
7776 "old-style parameter declarations in prototyped "
7777 "function definition");
7779 /* Get rid of the old-style declarations. */
7783 /* Don't issue this warning for nested functions, and don't issue this
7784 warning if we got here because ARG_INFO_TYPES was error_mark_node
7785 (this happens when a function definition has just an ellipsis in
7786 its parameter list). */
7787 else if (!in_system_header
&& !current_function_scope
7788 && arg_info
->types
!= error_mark_node
)
7789 warning_at (DECL_SOURCE_LOCATION (fndecl
), OPT_Wtraditional
,
7790 "traditional C rejects ISO C style function definitions");
7792 /* Now make all the parameter declarations visible in the function body.
7793 We can bypass most of the grunt work of pushdecl. */
7794 for (decl
= arg_info
->parms
; decl
; decl
= DECL_CHAIN (decl
))
7796 DECL_CONTEXT (decl
) = current_function_decl
;
7797 if (DECL_NAME (decl
))
7799 bind (DECL_NAME (decl
), decl
, current_scope
,
7800 /*invisible=*/false, /*nested=*/false,
7802 if (!TREE_USED (decl
))
7803 warn_if_shadowing (decl
);
7806 error_at (DECL_SOURCE_LOCATION (decl
), "parameter name omitted");
7809 /* Record the parameter list in the function declaration. */
7810 DECL_ARGUMENTS (fndecl
) = arg_info
->parms
;
7812 /* Now make all the ancillary declarations visible, likewise. */
7813 for (decl
= arg_info
->others
; decl
; decl
= DECL_CHAIN (decl
))
7815 DECL_CONTEXT (decl
) = current_function_decl
;
7816 if (DECL_NAME (decl
))
7817 bind (DECL_NAME (decl
), decl
, current_scope
,
7818 /*invisible=*/false,
7819 /*nested=*/(TREE_CODE (decl
) == FUNCTION_DECL
),
7823 /* And all the tag declarations. */
7824 FOR_EACH_VEC_ELT_REVERSE (c_arg_tag
, arg_info
->tags
, ix
, tag
)
7826 bind (tag
->id
, tag
->type
, current_scope
,
7827 /*invisible=*/false, /*nested=*/false, UNKNOWN_LOCATION
);
7830 /* Subroutine of store_parm_decls which handles old-style function
7831 definitions (separate parameter list and declarations). */
7834 store_parm_decls_oldstyle (tree fndecl
, const struct c_arg_info
*arg_info
)
7836 struct c_binding
*b
;
7837 tree parm
, decl
, last
;
7838 tree parmids
= arg_info
->parms
;
7839 struct pointer_set_t
*seen_args
= pointer_set_create ();
7841 if (!in_system_header
)
7842 warning_at (DECL_SOURCE_LOCATION (fndecl
),
7843 OPT_Wold_style_definition
, "old-style function definition");
7845 /* Match each formal parameter name with its declaration. Save each
7846 decl in the appropriate TREE_PURPOSE slot of the parmids chain. */
7847 for (parm
= parmids
; parm
; parm
= TREE_CHAIN (parm
))
7849 if (TREE_VALUE (parm
) == 0)
7851 error_at (DECL_SOURCE_LOCATION (fndecl
),
7852 "parameter name missing from parameter list");
7853 TREE_PURPOSE (parm
) = 0;
7857 b
= I_SYMBOL_BINDING (TREE_VALUE (parm
));
7858 if (b
&& B_IN_CURRENT_SCOPE (b
))
7861 /* Skip erroneous parameters. */
7862 if (decl
== error_mark_node
)
7864 /* If we got something other than a PARM_DECL it is an error. */
7865 if (TREE_CODE (decl
) != PARM_DECL
)
7866 error_at (DECL_SOURCE_LOCATION (decl
),
7867 "%qD declared as a non-parameter", decl
);
7868 /* If the declaration is already marked, we have a duplicate
7869 name. Complain and ignore the duplicate. */
7870 else if (pointer_set_contains (seen_args
, decl
))
7872 error_at (DECL_SOURCE_LOCATION (decl
),
7873 "multiple parameters named %qD", decl
);
7874 TREE_PURPOSE (parm
) = 0;
7877 /* If the declaration says "void", complain and turn it into
7879 else if (VOID_TYPE_P (TREE_TYPE (decl
)))
7881 error_at (DECL_SOURCE_LOCATION (decl
),
7882 "parameter %qD declared with void type", decl
);
7883 TREE_TYPE (decl
) = integer_type_node
;
7884 DECL_ARG_TYPE (decl
) = integer_type_node
;
7885 layout_decl (decl
, 0);
7887 warn_if_shadowing (decl
);
7889 /* If no declaration found, default to int. */
7892 /* FIXME diagnostics: This should be the location of the argument,
7893 not the FNDECL. E.g., for an old-style declaration
7895 int f10(v) { blah; }
7897 We should use the location of the V, not the F10.
7898 Unfortunately, the V is an IDENTIFIER_NODE which has no
7899 location. In the future we need locations for c_arg_info
7902 See gcc.dg/Wshadow-3.c for an example of this problem. */
7903 decl
= build_decl (DECL_SOURCE_LOCATION (fndecl
),
7904 PARM_DECL
, TREE_VALUE (parm
), integer_type_node
);
7905 DECL_ARG_TYPE (decl
) = TREE_TYPE (decl
);
7907 warn_if_shadowing (decl
);
7910 pedwarn (DECL_SOURCE_LOCATION (decl
),
7911 0, "type of %qD defaults to %<int%>", decl
);
7913 warning_at (DECL_SOURCE_LOCATION (decl
),
7914 OPT_Wmissing_parameter_type
,
7915 "type of %qD defaults to %<int%>", decl
);
7918 TREE_PURPOSE (parm
) = decl
;
7919 pointer_set_insert (seen_args
, decl
);
7922 /* Now examine the parms chain for incomplete declarations
7923 and declarations with no corresponding names. */
7925 for (b
= current_scope
->bindings
; b
; b
= b
->prev
)
7928 if (TREE_CODE (parm
) != PARM_DECL
)
7931 if (TREE_TYPE (parm
) != error_mark_node
7932 && !COMPLETE_TYPE_P (TREE_TYPE (parm
)))
7934 error_at (DECL_SOURCE_LOCATION (parm
),
7935 "parameter %qD has incomplete type", parm
);
7936 TREE_TYPE (parm
) = error_mark_node
;
7939 if (!pointer_set_contains (seen_args
, parm
))
7941 error_at (DECL_SOURCE_LOCATION (parm
),
7942 "declaration for parameter %qD but no such parameter",
7945 /* Pretend the parameter was not missing.
7946 This gets us to a standard state and minimizes
7947 further error messages. */
7948 parmids
= chainon (parmids
, tree_cons (parm
, 0, 0));
7952 /* Chain the declarations together in the order of the list of
7953 names. Store that chain in the function decl, replacing the
7954 list of names. Update the current scope to match. */
7955 DECL_ARGUMENTS (fndecl
) = 0;
7957 for (parm
= parmids
; parm
; parm
= TREE_CHAIN (parm
))
7958 if (TREE_PURPOSE (parm
))
7960 if (parm
&& TREE_PURPOSE (parm
))
7962 last
= TREE_PURPOSE (parm
);
7963 DECL_ARGUMENTS (fndecl
) = last
;
7965 for (parm
= TREE_CHAIN (parm
); parm
; parm
= TREE_CHAIN (parm
))
7966 if (TREE_PURPOSE (parm
))
7968 DECL_CHAIN (last
) = TREE_PURPOSE (parm
);
7969 last
= TREE_PURPOSE (parm
);
7971 DECL_CHAIN (last
) = 0;
7974 pointer_set_destroy (seen_args
);
7976 /* If there was a previous prototype,
7977 set the DECL_ARG_TYPE of each argument according to
7978 the type previously specified, and report any mismatches. */
7980 if (current_function_prototype_arg_types
)
7983 for (parm
= DECL_ARGUMENTS (fndecl
),
7984 type
= current_function_prototype_arg_types
;
7985 parm
|| (type
&& TREE_VALUE (type
) != error_mark_node
7986 && (TYPE_MAIN_VARIANT (TREE_VALUE (type
)) != void_type_node
));
7987 parm
= DECL_CHAIN (parm
), type
= TREE_CHAIN (type
))
7989 if (parm
== 0 || type
== 0
7990 || TYPE_MAIN_VARIANT (TREE_VALUE (type
)) == void_type_node
)
7992 if (current_function_prototype_built_in
)
7993 warning_at (DECL_SOURCE_LOCATION (fndecl
),
7994 0, "number of arguments doesn%'t match "
7995 "built-in prototype");
7998 /* FIXME diagnostics: This should be the location of
7999 FNDECL, but there is bug when a prototype is
8000 declared inside function context, but defined
8001 outside of it (e.g., gcc.dg/pr15698-2.c). In
8002 which case FNDECL gets the location of the
8003 prototype, not the definition. */
8004 error_at (input_location
,
8005 "number of arguments doesn%'t match prototype");
8007 error_at (current_function_prototype_locus
,
8008 "prototype declaration");
8012 /* Type for passing arg must be consistent with that
8013 declared for the arg. ISO C says we take the unqualified
8014 type for parameters declared with qualified type. */
8015 if (TREE_TYPE (parm
) != error_mark_node
8016 && TREE_TYPE (type
) != error_mark_node
8017 && !comptypes (TYPE_MAIN_VARIANT (DECL_ARG_TYPE (parm
)),
8018 TYPE_MAIN_VARIANT (TREE_VALUE (type
))))
8020 if (TYPE_MAIN_VARIANT (TREE_TYPE (parm
))
8021 == TYPE_MAIN_VARIANT (TREE_VALUE (type
)))
8023 /* Adjust argument to match prototype. E.g. a previous
8024 `int foo(float);' prototype causes
8025 `int foo(x) float x; {...}' to be treated like
8026 `int foo(float x) {...}'. This is particularly
8027 useful for argument types like uid_t. */
8028 DECL_ARG_TYPE (parm
) = TREE_TYPE (parm
);
8030 if (targetm
.calls
.promote_prototypes (TREE_TYPE (current_function_decl
))
8031 && INTEGRAL_TYPE_P (TREE_TYPE (parm
))
8032 && TYPE_PRECISION (TREE_TYPE (parm
))
8033 < TYPE_PRECISION (integer_type_node
))
8034 DECL_ARG_TYPE (parm
) = integer_type_node
;
8036 /* ??? Is it possible to get here with a
8037 built-in prototype or will it always have
8038 been diagnosed as conflicting with an
8039 old-style definition and discarded? */
8040 if (current_function_prototype_built_in
)
8041 warning_at (DECL_SOURCE_LOCATION (parm
),
8042 OPT_pedantic
, "promoted argument %qD "
8043 "doesn%'t match built-in prototype", parm
);
8046 pedwarn (DECL_SOURCE_LOCATION (parm
),
8047 OPT_pedantic
, "promoted argument %qD "
8048 "doesn%'t match prototype", parm
);
8049 pedwarn (current_function_prototype_locus
, OPT_pedantic
,
8050 "prototype declaration");
8055 if (current_function_prototype_built_in
)
8056 warning_at (DECL_SOURCE_LOCATION (parm
),
8057 0, "argument %qD doesn%'t match "
8058 "built-in prototype", parm
);
8061 error_at (DECL_SOURCE_LOCATION (parm
),
8062 "argument %qD doesn%'t match prototype", parm
);
8063 error_at (current_function_prototype_locus
,
8064 "prototype declaration");
8069 TYPE_ACTUAL_ARG_TYPES (TREE_TYPE (fndecl
)) = 0;
8072 /* Otherwise, create a prototype that would match. */
8076 tree actual
= 0, last
= 0, type
;
8078 for (parm
= DECL_ARGUMENTS (fndecl
); parm
; parm
= DECL_CHAIN (parm
))
8080 type
= tree_cons (NULL_TREE
, DECL_ARG_TYPE (parm
), NULL_TREE
);
8082 TREE_CHAIN (last
) = type
;
8087 type
= tree_cons (NULL_TREE
, void_type_node
, NULL_TREE
);
8089 TREE_CHAIN (last
) = type
;
8093 /* We are going to assign a new value for the TYPE_ACTUAL_ARG_TYPES
8094 of the type of this function, but we need to avoid having this
8095 affect the types of other similarly-typed functions, so we must
8096 first force the generation of an identical (but separate) type
8097 node for the relevant function type. The new node we create
8098 will be a variant of the main variant of the original function
8101 TREE_TYPE (fndecl
) = build_variant_type_copy (TREE_TYPE (fndecl
));
8103 TYPE_ACTUAL_ARG_TYPES (TREE_TYPE (fndecl
)) = actual
;
8107 /* Store parameter declarations passed in ARG_INFO into the current
8108 function declaration. */
8111 store_parm_decls_from (struct c_arg_info
*arg_info
)
8113 current_function_arg_info
= arg_info
;
8114 store_parm_decls ();
8117 /* Store the parameter declarations into the current function declaration.
8118 This is called after parsing the parameter declarations, before
8119 digesting the body of the function.
8121 For an old-style definition, construct a prototype out of the old-style
8122 parameter declarations and inject it into the function's type. */
8125 store_parm_decls (void)
8127 tree fndecl
= current_function_decl
;
8130 /* The argument information block for FNDECL. */
8131 struct c_arg_info
*arg_info
= current_function_arg_info
;
8132 current_function_arg_info
= 0;
8134 /* True if this definition is written with a prototype. Note:
8135 despite C99 6.7.5.3p14, we can *not* treat an empty argument
8136 list in a function definition as equivalent to (void) -- an
8137 empty argument list specifies the function has no parameters,
8138 but only (void) sets up a prototype for future calls. */
8139 proto
= arg_info
->types
!= 0;
8142 store_parm_decls_newstyle (fndecl
, arg_info
);
8144 store_parm_decls_oldstyle (fndecl
, arg_info
);
8146 /* The next call to push_scope will be a function body. */
8148 next_is_function_body
= true;
8150 /* Write a record describing this function definition to the prototypes
8151 file (if requested). */
8153 gen_aux_info_record (fndecl
, 1, 0, proto
);
8155 /* Initialize the RTL code for the function. */
8156 allocate_struct_function (fndecl
, false);
8158 /* Begin the statement tree for this function. */
8159 DECL_SAVED_TREE (fndecl
) = push_stmt_list ();
8161 /* ??? Insert the contents of the pending sizes list into the function
8162 to be evaluated. The only reason left to have this is
8163 void foo(int n, int array[n++])
8164 because we throw away the array type in favor of a pointer type, and
8165 thus won't naturally see the SAVE_EXPR containing the increment. All
8166 other pending sizes would be handled by gimplify_parameters. */
8168 VEC(tree
,gc
) *pending_sizes
= get_pending_sizes ();
8172 FOR_EACH_VEC_ELT (tree
, pending_sizes
, i
, t
)
8176 /* Even though we're inside a function body, we still don't want to
8177 call expand_expr to calculate the size of a variable-sized array.
8178 We haven't necessarily assigned RTL to all variables yet, so it's
8179 not safe to try to expand expressions involving them. */
8180 cfun
->dont_save_pending_sizes_p
= 1;
8184 /* Finish up a function declaration and compile that function
8185 all the way to assembler language output. Then free the storage
8186 for the function definition.
8188 This is called after parsing the body of the function definition. */
8191 finish_function (void)
8193 tree fndecl
= current_function_decl
;
8195 if (c_dialect_objc ())
8196 objc_finish_function ();
8198 if (TREE_CODE (fndecl
) == FUNCTION_DECL
8199 && targetm
.calls
.promote_prototypes (TREE_TYPE (fndecl
)))
8201 tree args
= DECL_ARGUMENTS (fndecl
);
8202 for (; args
; args
= DECL_CHAIN (args
))
8204 tree type
= TREE_TYPE (args
);
8205 if (INTEGRAL_TYPE_P (type
)
8206 && TYPE_PRECISION (type
) < TYPE_PRECISION (integer_type_node
))
8207 DECL_ARG_TYPE (args
) = integer_type_node
;
8211 if (DECL_INITIAL (fndecl
) && DECL_INITIAL (fndecl
) != error_mark_node
)
8212 BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl
)) = fndecl
;
8214 /* Must mark the RESULT_DECL as being in this function. */
8216 if (DECL_RESULT (fndecl
) && DECL_RESULT (fndecl
) != error_mark_node
)
8217 DECL_CONTEXT (DECL_RESULT (fndecl
)) = fndecl
;
8219 if (MAIN_NAME_P (DECL_NAME (fndecl
)) && flag_hosted
8220 && TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (fndecl
)))
8221 == integer_type_node
&& flag_isoc99
)
8223 /* Hack. We don't want the middle-end to warn that this return
8224 is unreachable, so we mark its location as special. Using
8225 UNKNOWN_LOCATION has the problem that it gets clobbered in
8226 annotate_one_with_locus. A cleaner solution might be to
8227 ensure ! should_carry_locus_p (stmt), but that needs a flag.
8229 c_finish_return (BUILTINS_LOCATION
, integer_zero_node
, NULL_TREE
);
8232 /* Tie off the statement tree for this function. */
8233 DECL_SAVED_TREE (fndecl
) = pop_stmt_list (DECL_SAVED_TREE (fndecl
));
8235 finish_fname_decls ();
8237 /* Complain if there's just no return statement. */
8238 if (warn_return_type
8239 && TREE_CODE (TREE_TYPE (TREE_TYPE (fndecl
))) != VOID_TYPE
8240 && !current_function_returns_value
&& !current_function_returns_null
8241 /* Don't complain if we are no-return. */
8242 && !current_function_returns_abnormally
8243 /* Don't complain if we are declared noreturn. */
8244 && !TREE_THIS_VOLATILE (fndecl
)
8245 /* Don't warn for main(). */
8246 && !MAIN_NAME_P (DECL_NAME (fndecl
))
8247 /* Or if they didn't actually specify a return type. */
8248 && !C_FUNCTION_IMPLICIT_INT (fndecl
)
8249 /* Normally, with -Wreturn-type, flow will complain, but we might
8250 optimize out static functions. */
8251 && !TREE_PUBLIC (fndecl
))
8253 warning (OPT_Wreturn_type
,
8254 "no return statement in function returning non-void");
8255 TREE_NO_WARNING (fndecl
) = 1;
8258 /* Complain about parameters that are only set, but never otherwise used. */
8259 if (warn_unused_but_set_parameter
)
8263 for (decl
= DECL_ARGUMENTS (fndecl
);
8265 decl
= DECL_CHAIN (decl
))
8266 if (TREE_USED (decl
)
8267 && TREE_CODE (decl
) == PARM_DECL
8268 && !DECL_READ_P (decl
)
8270 && !DECL_ARTIFICIAL (decl
)
8271 && !TREE_NO_WARNING (decl
))
8272 warning_at (DECL_SOURCE_LOCATION (decl
),
8273 OPT_Wunused_but_set_parameter
,
8274 "parameter %qD set but not used", decl
);
8277 /* Store the end of the function, so that we get good line number
8278 info for the epilogue. */
8279 cfun
->function_end_locus
= input_location
;
8281 /* Finalize the ELF visibility for the function. */
8282 c_determine_visibility (fndecl
);
8284 /* For GNU C extern inline functions disregard inline limits. */
8285 if (DECL_EXTERNAL (fndecl
)
8286 && DECL_DECLARED_INLINE_P (fndecl
))
8287 DECL_DISREGARD_INLINE_LIMITS (fndecl
) = 1;
8289 /* Genericize before inlining. Delay genericizing nested functions
8290 until their parent function is genericized. Since finalizing
8291 requires GENERIC, delay that as well. */
8293 if (DECL_INITIAL (fndecl
) && DECL_INITIAL (fndecl
) != error_mark_node
8294 && !undef_nested_function
)
8296 if (!decl_function_context (fndecl
))
8298 invoke_plugin_callbacks (PLUGIN_PRE_GENERICIZE
, fndecl
);
8299 c_genericize (fndecl
);
8301 /* ??? Objc emits functions after finalizing the compilation unit.
8302 This should be cleaned up later and this conditional removed. */
8303 if (cgraph_global_info_ready
)
8305 cgraph_add_new_function (fndecl
, false);
8308 cgraph_finalize_function (fndecl
, false);
8312 /* Register this function with cgraph just far enough to get it
8313 added to our parent's nested function list. Handy, since the
8314 C front end doesn't have such a list. */
8315 (void) cgraph_node (fndecl
);
8319 if (!decl_function_context (fndecl
))
8320 undef_nested_function
= false;
8322 /* We're leaving the context of this function, so zap cfun.
8323 It's still in DECL_STRUCT_FUNCTION, and we'll restore it in
8324 tree_rest_of_compilation. */
8326 current_function_decl
= NULL
;
8329 /* Check the declarations given in a for-loop for satisfying the C99
8330 constraints. If exactly one such decl is found, return it. LOC is
8331 the location of the opening parenthesis of the for loop. The last
8332 parameter allows you to control the "for loop initial declarations
8333 are only allowed in C99 mode". Normally, you should pass
8334 flag_isoc99 as that parameter. But in some cases (Objective-C
8335 foreach loop, for example) we want to run the checks in this
8336 function even if not in C99 mode, so we allow the caller to turn
8337 off the error about not being in C99 mode.
8341 check_for_loop_decls (location_t loc
, bool turn_off_iso_c99_error
)
8343 struct c_binding
*b
;
8344 tree one_decl
= NULL_TREE
;
8347 if (!turn_off_iso_c99_error
)
8349 static bool hint
= true;
8350 /* If we get here, declarations have been used in a for loop without
8351 the C99 for loop scope. This doesn't make much sense, so don't
8353 error_at (loc
, "%<for%> loop initial declarations "
8354 "are only allowed in C99 mode");
8358 "use option -std=c99 or -std=gnu99 to compile your code");
8363 /* C99 subclause 6.8.5 paragraph 3:
8365 [#3] The declaration part of a for statement shall only
8366 declare identifiers for objects having storage class auto or
8369 It isn't clear whether, in this sentence, "identifiers" binds to
8370 "shall only declare" or to "objects" - that is, whether all identifiers
8371 declared must be identifiers for objects, or whether the restriction
8372 only applies to those that are. (A question on this in comp.std.c
8373 in November 2000 received no answer.) We implement the strictest
8374 interpretation, to avoid creating an extension which later causes
8377 for (b
= current_scope
->bindings
; b
; b
= b
->prev
)
8380 tree decl
= b
->decl
;
8385 switch (TREE_CODE (decl
))
8389 location_t decl_loc
= DECL_SOURCE_LOCATION (decl
);
8390 if (TREE_STATIC (decl
))
8392 "declaration of static variable %qD in %<for%> loop "
8393 "initial declaration", decl
);
8394 else if (DECL_EXTERNAL (decl
))
8396 "declaration of %<extern%> variable %qD in %<for%> loop "
8397 "initial declaration", decl
);
8403 "%<struct %E%> declared in %<for%> loop initial "
8408 "%<union %E%> declared in %<for%> loop initial declaration",
8412 error_at (loc
, "%<enum %E%> declared in %<for%> loop "
8413 "initial declaration", id
);
8416 error_at (loc
, "declaration of non-variable "
8417 "%qD in %<for%> loop initial declaration", decl
);
8424 return n_decls
== 1 ? one_decl
: NULL_TREE
;
8427 /* Save and reinitialize the variables
8428 used during compilation of a C function. */
8431 c_push_function_context (void)
8433 struct language_function
*p
;
8434 p
= ggc_alloc_language_function ();
8437 p
->base
.x_stmt_tree
= c_stmt_tree
;
8438 p
->x_break_label
= c_break_label
;
8439 p
->x_cont_label
= c_cont_label
;
8440 p
->x_switch_stack
= c_switch_stack
;
8441 p
->arg_info
= current_function_arg_info
;
8442 p
->returns_value
= current_function_returns_value
;
8443 p
->returns_null
= current_function_returns_null
;
8444 p
->returns_abnormally
= current_function_returns_abnormally
;
8445 p
->warn_about_return_type
= warn_about_return_type
;
8447 push_function_context ();
8450 /* Restore the variables used during compilation of a C function. */
8453 c_pop_function_context (void)
8455 struct language_function
*p
;
8457 pop_function_context ();
8459 cfun
->language
= NULL
;
8461 if (DECL_STRUCT_FUNCTION (current_function_decl
) == 0
8462 && DECL_SAVED_TREE (current_function_decl
) == NULL_TREE
)
8464 /* Stop pointing to the local nodes about to be freed. */
8465 /* But DECL_INITIAL must remain nonzero so we know this
8466 was an actual function definition. */
8467 DECL_INITIAL (current_function_decl
) = error_mark_node
;
8468 DECL_ARGUMENTS (current_function_decl
) = 0;
8471 c_stmt_tree
= p
->base
.x_stmt_tree
;
8472 c_break_label
= p
->x_break_label
;
8473 c_cont_label
= p
->x_cont_label
;
8474 c_switch_stack
= p
->x_switch_stack
;
8475 current_function_arg_info
= p
->arg_info
;
8476 current_function_returns_value
= p
->returns_value
;
8477 current_function_returns_null
= p
->returns_null
;
8478 current_function_returns_abnormally
= p
->returns_abnormally
;
8479 warn_about_return_type
= p
->warn_about_return_type
;
8482 /* The functions below are required for functionality of doing
8483 function at once processing in the C front end. Currently these
8484 functions are not called from anywhere in the C front end, but as
8485 these changes continue, that will change. */
8487 /* Returns the stmt_tree (if any) to which statements are currently
8488 being added. If there is no active statement-tree, NULL is
8492 current_stmt_tree (void)
8494 return &c_stmt_tree
;
8497 /* Return the global value of T as a symbol. */
8500 identifier_global_value (tree t
)
8502 struct c_binding
*b
;
8504 for (b
= I_SYMBOL_BINDING (t
); b
; b
= b
->shadowed
)
8505 if (B_IN_FILE_SCOPE (b
) || B_IN_EXTERNAL_SCOPE (b
))
8511 /* Record a builtin type for C. If NAME is non-NULL, it is the name used;
8512 otherwise the name is found in ridpointers from RID_INDEX. */
8515 record_builtin_type (enum rid rid_index
, const char *name
, tree type
)
8519 id
= ridpointers
[(int) rid_index
];
8521 id
= get_identifier (name
);
8522 decl
= build_decl (UNKNOWN_LOCATION
, TYPE_DECL
, id
, type
);
8524 if (debug_hooks
->type_decl
)
8525 debug_hooks
->type_decl (decl
, false);
8528 /* Build the void_list_node (void_type_node having been created). */
8530 build_void_list_node (void)
8532 tree t
= build_tree_list (NULL_TREE
, void_type_node
);
8536 /* Return a c_parm structure with the given SPECS, ATTRS and DECLARATOR. */
8539 build_c_parm (struct c_declspecs
*specs
, tree attrs
,
8540 struct c_declarator
*declarator
)
8542 struct c_parm
*ret
= XOBNEW (&parser_obstack
, struct c_parm
);
8545 ret
->declarator
= declarator
;
8549 /* Return a declarator with nested attributes. TARGET is the inner
8550 declarator to which these attributes apply. ATTRS are the
8553 struct c_declarator
*
8554 build_attrs_declarator (tree attrs
, struct c_declarator
*target
)
8556 struct c_declarator
*ret
= XOBNEW (&parser_obstack
, struct c_declarator
);
8557 ret
->kind
= cdk_attrs
;
8558 ret
->declarator
= target
;
8559 ret
->u
.attrs
= attrs
;
8563 /* Return a declarator for a function with arguments specified by ARGS
8564 and return type specified by TARGET. */
8566 struct c_declarator
*
8567 build_function_declarator (struct c_arg_info
*args
,
8568 struct c_declarator
*target
)
8570 struct c_declarator
*ret
= XOBNEW (&parser_obstack
, struct c_declarator
);
8571 ret
->kind
= cdk_function
;
8572 ret
->declarator
= target
;
8573 ret
->u
.arg_info
= args
;
8577 /* Return a declarator for the identifier IDENT (which may be
8578 NULL_TREE for an abstract declarator). */
8580 struct c_declarator
*
8581 build_id_declarator (tree ident
)
8583 struct c_declarator
*ret
= XOBNEW (&parser_obstack
, struct c_declarator
);
8585 ret
->declarator
= 0;
8587 /* Default value - may get reset to a more precise location. */
8588 ret
->id_loc
= input_location
;
8592 /* Return something to represent absolute declarators containing a *.
8593 TARGET is the absolute declarator that the * contains.
8594 TYPE_QUALS_ATTRS is a structure for type qualifiers and attributes
8595 to apply to the pointer type. */
8597 struct c_declarator
*
8598 make_pointer_declarator (struct c_declspecs
*type_quals_attrs
,
8599 struct c_declarator
*target
)
8603 struct c_declarator
*itarget
= target
;
8604 struct c_declarator
*ret
= XOBNEW (&parser_obstack
, struct c_declarator
);
8605 if (type_quals_attrs
)
8607 attrs
= type_quals_attrs
->attrs
;
8608 quals
= quals_from_declspecs (type_quals_attrs
);
8609 if (attrs
!= NULL_TREE
)
8610 itarget
= build_attrs_declarator (attrs
, target
);
8612 ret
->kind
= cdk_pointer
;
8613 ret
->declarator
= itarget
;
8614 ret
->u
.pointer_quals
= quals
;
8618 /* Return a pointer to a structure for an empty list of declaration
8621 struct c_declspecs
*
8622 build_null_declspecs (void)
8624 struct c_declspecs
*ret
= XOBNEW (&parser_obstack
, struct c_declspecs
);
8629 ret
->typespec_word
= cts_none
;
8630 ret
->storage_class
= csc_none
;
8631 ret
->expr_const_operands
= true;
8632 ret
->declspecs_seen_p
= false;
8633 ret
->typespec_kind
= ctsk_none
;
8634 ret
->non_sc_seen_p
= false;
8635 ret
->typedef_p
= false;
8636 ret
->explicit_signed_p
= false;
8637 ret
->deprecated_p
= false;
8638 ret
->default_int_p
= false;
8639 ret
->long_p
= false;
8640 ret
->long_long_p
= false;
8641 ret
->short_p
= false;
8642 ret
->signed_p
= false;
8643 ret
->unsigned_p
= false;
8644 ret
->complex_p
= false;
8645 ret
->inline_p
= false;
8646 ret
->thread_p
= false;
8647 ret
->const_p
= false;
8648 ret
->volatile_p
= false;
8649 ret
->restrict_p
= false;
8650 ret
->saturating_p
= false;
8651 ret
->address_space
= ADDR_SPACE_GENERIC
;
8655 /* Add the address space ADDRSPACE to the declaration specifiers
8656 SPECS, returning SPECS. */
8658 struct c_declspecs
*
8659 declspecs_add_addrspace (struct c_declspecs
*specs
, addr_space_t as
)
8661 specs
->non_sc_seen_p
= true;
8662 specs
->declspecs_seen_p
= true;
8664 if (!ADDR_SPACE_GENERIC_P (specs
->address_space
)
8665 && specs
->address_space
!= as
)
8666 error ("incompatible address space qualifiers %qs and %qs",
8667 c_addr_space_name (as
),
8668 c_addr_space_name (specs
->address_space
));
8670 specs
->address_space
= as
;
8674 /* Add the type qualifier QUAL to the declaration specifiers SPECS,
8677 struct c_declspecs
*
8678 declspecs_add_qual (struct c_declspecs
*specs
, tree qual
)
8682 specs
->non_sc_seen_p
= true;
8683 specs
->declspecs_seen_p
= true;
8684 gcc_assert (TREE_CODE (qual
) == IDENTIFIER_NODE
8685 && C_IS_RESERVED_WORD (qual
));
8686 i
= C_RID_CODE (qual
);
8690 dupe
= specs
->const_p
;
8691 specs
->const_p
= true;
8694 dupe
= specs
->volatile_p
;
8695 specs
->volatile_p
= true;
8698 dupe
= specs
->restrict_p
;
8699 specs
->restrict_p
= true;
8704 if (dupe
&& !flag_isoc99
)
8705 pedwarn (input_location
, OPT_pedantic
, "duplicate %qE", qual
);
8709 /* Add the type specifier TYPE to the declaration specifiers SPECS,
8712 struct c_declspecs
*
8713 declspecs_add_type (location_t loc
, struct c_declspecs
*specs
,
8714 struct c_typespec spec
)
8716 tree type
= spec
.spec
;
8717 specs
->non_sc_seen_p
= true;
8718 specs
->declspecs_seen_p
= true;
8719 specs
->typespec_kind
= spec
.kind
;
8720 if (TREE_DEPRECATED (type
))
8721 specs
->deprecated_p
= true;
8723 /* Handle type specifier keywords. */
8724 if (TREE_CODE (type
) == IDENTIFIER_NODE
8725 && C_IS_RESERVED_WORD (type
)
8726 && C_RID_CODE (type
) != RID_CXX_COMPAT_WARN
)
8728 enum rid i
= C_RID_CODE (type
);
8731 error_at (loc
, "two or more data types in declaration specifiers");
8734 if ((int) i
<= (int) RID_LAST_MODIFIER
)
8736 /* "long", "short", "signed", "unsigned", "_Complex" or "_Sat". */
8741 if (specs
->long_long_p
)
8743 error_at (loc
, "%<long long long%> is too long for GCC");
8748 if (specs
->typespec_word
== cts_double
)
8751 ("both %<long long%> and %<double%> in "
8752 "declaration specifiers"));
8755 pedwarn_c90 (loc
, OPT_Wlong_long
,
8756 "ISO C90 does not support %<long long%>");
8757 specs
->long_long_p
= 1;
8762 ("both %<long%> and %<short%> in "
8763 "declaration specifiers"));
8764 else if (specs
->typespec_word
== cts_void
)
8766 ("both %<long%> and %<void%> in "
8767 "declaration specifiers"));
8768 else if (specs
->typespec_word
== cts_int128
)
8770 ("both %<long%> and %<__int128%> in "
8771 "declaration specifiers"));
8772 else if (specs
->typespec_word
== cts_bool
)
8774 ("both %<long%> and %<_Bool%> in "
8775 "declaration specifiers"));
8776 else if (specs
->typespec_word
== cts_char
)
8778 ("both %<long%> and %<char%> in "
8779 "declaration specifiers"));
8780 else if (specs
->typespec_word
== cts_float
)
8782 ("both %<long%> and %<float%> in "
8783 "declaration specifiers"));
8784 else if (specs
->typespec_word
== cts_dfloat32
)
8786 ("both %<long%> and %<_Decimal32%> in "
8787 "declaration specifiers"));
8788 else if (specs
->typespec_word
== cts_dfloat64
)
8790 ("both %<long%> and %<_Decimal64%> in "
8791 "declaration specifiers"));
8792 else if (specs
->typespec_word
== cts_dfloat128
)
8794 ("both %<long%> and %<_Decimal128%> in "
8795 "declaration specifiers"));
8797 specs
->long_p
= true;
8800 dupe
= specs
->short_p
;
8803 ("both %<long%> and %<short%> in "
8804 "declaration specifiers"));
8805 else if (specs
->typespec_word
== cts_void
)
8807 ("both %<short%> and %<void%> in "
8808 "declaration specifiers"));
8809 else if (specs
->typespec_word
== cts_int128
)
8811 ("both %<short%> and %<__int128%> in "
8812 "declaration specifiers"));
8813 else if (specs
->typespec_word
== cts_bool
)
8815 ("both %<short%> and %<_Bool%> in "
8816 "declaration specifiers"));
8817 else if (specs
->typespec_word
== cts_char
)
8819 ("both %<short%> and %<char%> in "
8820 "declaration specifiers"));
8821 else if (specs
->typespec_word
== cts_float
)
8823 ("both %<short%> and %<float%> in "
8824 "declaration specifiers"));
8825 else if (specs
->typespec_word
== cts_double
)
8827 ("both %<short%> and %<double%> in "
8828 "declaration specifiers"));
8829 else if (specs
->typespec_word
== cts_dfloat32
)
8831 ("both %<short%> and %<_Decimal32%> in "
8832 "declaration specifiers"));
8833 else if (specs
->typespec_word
== cts_dfloat64
)
8835 ("both %<short%> and %<_Decimal64%> in "
8836 "declaration specifiers"));
8837 else if (specs
->typespec_word
== cts_dfloat128
)
8839 ("both %<short%> and %<_Decimal128%> in "
8840 "declaration specifiers"));
8842 specs
->short_p
= true;
8845 dupe
= specs
->signed_p
;
8846 if (specs
->unsigned_p
)
8848 ("both %<signed%> and %<unsigned%> in "
8849 "declaration specifiers"));
8850 else if (specs
->typespec_word
== cts_void
)
8852 ("both %<signed%> and %<void%> in "
8853 "declaration specifiers"));
8854 else if (specs
->typespec_word
== cts_bool
)
8856 ("both %<signed%> and %<_Bool%> in "
8857 "declaration specifiers"));
8858 else if (specs
->typespec_word
== cts_float
)
8860 ("both %<signed%> and %<float%> in "
8861 "declaration specifiers"));
8862 else if (specs
->typespec_word
== cts_double
)
8864 ("both %<signed%> and %<double%> in "
8865 "declaration specifiers"));
8866 else if (specs
->typespec_word
== cts_dfloat32
)
8868 ("both %<signed%> and %<_Decimal32%> in "
8869 "declaration specifiers"));
8870 else if (specs
->typespec_word
== cts_dfloat64
)
8872 ("both %<signed%> and %<_Decimal64%> in "
8873 "declaration specifiers"));
8874 else if (specs
->typespec_word
== cts_dfloat128
)
8876 ("both %<signed%> and %<_Decimal128%> in "
8877 "declaration specifiers"));
8879 specs
->signed_p
= true;
8882 dupe
= specs
->unsigned_p
;
8883 if (specs
->signed_p
)
8885 ("both %<signed%> and %<unsigned%> in "
8886 "declaration specifiers"));
8887 else if (specs
->typespec_word
== cts_void
)
8889 ("both %<unsigned%> and %<void%> in "
8890 "declaration specifiers"));
8891 else if (specs
->typespec_word
== cts_bool
)
8893 ("both %<unsigned%> and %<_Bool%> in "
8894 "declaration specifiers"));
8895 else if (specs
->typespec_word
== cts_float
)
8897 ("both %<unsigned%> and %<float%> in "
8898 "declaration specifiers"));
8899 else if (specs
->typespec_word
== cts_double
)
8901 ("both %<unsigned%> and %<double%> in "
8902 "declaration specifiers"));
8903 else if (specs
->typespec_word
== cts_dfloat32
)
8905 ("both %<unsigned%> and %<_Decimal32%> in "
8906 "declaration specifiers"));
8907 else if (specs
->typespec_word
== cts_dfloat64
)
8909 ("both %<unsigned%> and %<_Decimal64%> in "
8910 "declaration specifiers"));
8911 else if (specs
->typespec_word
== cts_dfloat128
)
8913 ("both %<unsigned%> and %<_Decimal128%> in "
8914 "declaration specifiers"));
8916 specs
->unsigned_p
= true;
8919 dupe
= specs
->complex_p
;
8920 if (!flag_isoc99
&& !in_system_header
)
8921 pedwarn (loc
, OPT_pedantic
,
8922 "ISO C90 does not support complex types");
8923 if (specs
->typespec_word
== cts_void
)
8925 ("both %<complex%> and %<void%> in "
8926 "declaration specifiers"));
8927 else if (specs
->typespec_word
== cts_bool
)
8929 ("both %<complex%> and %<_Bool%> in "
8930 "declaration specifiers"));
8931 else if (specs
->typespec_word
== cts_dfloat32
)
8933 ("both %<complex%> and %<_Decimal32%> in "
8934 "declaration specifiers"));
8935 else if (specs
->typespec_word
== cts_dfloat64
)
8937 ("both %<complex%> and %<_Decimal64%> in "
8938 "declaration specifiers"));
8939 else if (specs
->typespec_word
== cts_dfloat128
)
8941 ("both %<complex%> and %<_Decimal128%> in "
8942 "declaration specifiers"));
8943 else if (specs
->typespec_word
== cts_fract
)
8945 ("both %<complex%> and %<_Fract%> in "
8946 "declaration specifiers"));
8947 else if (specs
->typespec_word
== cts_accum
)
8949 ("both %<complex%> and %<_Accum%> in "
8950 "declaration specifiers"));
8951 else if (specs
->saturating_p
)
8953 ("both %<complex%> and %<_Sat%> in "
8954 "declaration specifiers"));
8956 specs
->complex_p
= true;
8959 dupe
= specs
->saturating_p
;
8960 pedwarn (loc
, OPT_pedantic
,
8961 "ISO C does not support saturating types");
8962 if (specs
->typespec_word
== cts_int128
)
8965 ("both %<_Sat%> and %<__int128%> in "
8966 "declaration specifiers"));
8968 else if (specs
->typespec_word
== cts_void
)
8970 ("both %<_Sat%> and %<void%> in "
8971 "declaration specifiers"));
8972 else if (specs
->typespec_word
== cts_bool
)
8974 ("both %<_Sat%> and %<_Bool%> in "
8975 "declaration specifiers"));
8976 else if (specs
->typespec_word
== cts_char
)
8978 ("both %<_Sat%> and %<char%> in "
8979 "declaration specifiers"));
8980 else if (specs
->typespec_word
== cts_int
)
8982 ("both %<_Sat%> and %<int%> in "
8983 "declaration specifiers"));
8984 else if (specs
->typespec_word
== cts_float
)
8986 ("both %<_Sat%> and %<float%> in "
8987 "declaration specifiers"));
8988 else if (specs
->typespec_word
== cts_double
)
8990 ("both %<_Sat%> and %<double%> in "
8991 "declaration specifiers"));
8992 else if (specs
->typespec_word
== cts_dfloat32
)
8994 ("both %<_Sat%> and %<_Decimal32%> in "
8995 "declaration specifiers"));
8996 else if (specs
->typespec_word
== cts_dfloat64
)
8998 ("both %<_Sat%> and %<_Decimal64%> in "
8999 "declaration specifiers"));
9000 else if (specs
->typespec_word
== cts_dfloat128
)
9002 ("both %<_Sat%> and %<_Decimal128%> in "
9003 "declaration specifiers"));
9004 else if (specs
->complex_p
)
9006 ("both %<_Sat%> and %<complex%> in "
9007 "declaration specifiers"));
9009 specs
->saturating_p
= true;
9016 error_at (loc
, "duplicate %qE", type
);
9022 /* "void", "_Bool", "char", "int", "float", "double", "_Decimal32",
9023 "__int128", "_Decimal64", "_Decimal128", "_Fract" or "_Accum". */
9024 if (specs
->typespec_word
!= cts_none
)
9027 "two or more data types in declaration specifiers");
9033 if (int128_integer_type_node
== NULL_TREE
)
9035 error_at (loc
, "%<__int128%> is not supported for this target");
9038 if (!in_system_header
)
9039 pedwarn (loc
, OPT_pedantic
,
9040 "ISO C does not support %<__int128%> type");
9044 ("both %<__int128%> and %<long%> in "
9045 "declaration specifiers"));
9046 else if (specs
->saturating_p
)
9048 ("both %<_Sat%> and %<__int128%> in "
9049 "declaration specifiers"));
9050 else if (specs
->short_p
)
9052 ("both %<__int128%> and %<short%> in "
9053 "declaration specifiers"));
9055 specs
->typespec_word
= cts_int128
;
9060 ("both %<long%> and %<void%> in "
9061 "declaration specifiers"));
9062 else if (specs
->short_p
)
9064 ("both %<short%> and %<void%> in "
9065 "declaration specifiers"));
9066 else if (specs
->signed_p
)
9068 ("both %<signed%> and %<void%> in "
9069 "declaration specifiers"));
9070 else if (specs
->unsigned_p
)
9072 ("both %<unsigned%> and %<void%> in "
9073 "declaration specifiers"));
9074 else if (specs
->complex_p
)
9076 ("both %<complex%> and %<void%> in "
9077 "declaration specifiers"));
9078 else if (specs
->saturating_p
)
9080 ("both %<_Sat%> and %<void%> in "
9081 "declaration specifiers"));
9083 specs
->typespec_word
= cts_void
;
9088 ("both %<long%> and %<_Bool%> in "
9089 "declaration specifiers"));
9090 else if (specs
->short_p
)
9092 ("both %<short%> and %<_Bool%> in "
9093 "declaration specifiers"));
9094 else if (specs
->signed_p
)
9096 ("both %<signed%> and %<_Bool%> in "
9097 "declaration specifiers"));
9098 else if (specs
->unsigned_p
)
9100 ("both %<unsigned%> and %<_Bool%> in "
9101 "declaration specifiers"));
9102 else if (specs
->complex_p
)
9104 ("both %<complex%> and %<_Bool%> in "
9105 "declaration specifiers"));
9106 else if (specs
->saturating_p
)
9108 ("both %<_Sat%> and %<_Bool%> in "
9109 "declaration specifiers"));
9111 specs
->typespec_word
= cts_bool
;
9116 ("both %<long%> and %<char%> in "
9117 "declaration specifiers"));
9118 else if (specs
->short_p
)
9120 ("both %<short%> and %<char%> in "
9121 "declaration specifiers"));
9122 else if (specs
->saturating_p
)
9124 ("both %<_Sat%> and %<char%> in "
9125 "declaration specifiers"));
9127 specs
->typespec_word
= cts_char
;
9130 if (specs
->saturating_p
)
9132 ("both %<_Sat%> and %<int%> in "
9133 "declaration specifiers"));
9135 specs
->typespec_word
= cts_int
;
9140 ("both %<long%> and %<float%> in "
9141 "declaration specifiers"));
9142 else if (specs
->short_p
)
9144 ("both %<short%> and %<float%> in "
9145 "declaration specifiers"));
9146 else if (specs
->signed_p
)
9148 ("both %<signed%> and %<float%> in "
9149 "declaration specifiers"));
9150 else if (specs
->unsigned_p
)
9152 ("both %<unsigned%> and %<float%> in "
9153 "declaration specifiers"));
9154 else if (specs
->saturating_p
)
9156 ("both %<_Sat%> and %<float%> in "
9157 "declaration specifiers"));
9159 specs
->typespec_word
= cts_float
;
9162 if (specs
->long_long_p
)
9164 ("both %<long long%> and %<double%> in "
9165 "declaration specifiers"));
9166 else if (specs
->short_p
)
9168 ("both %<short%> and %<double%> in "
9169 "declaration specifiers"));
9170 else if (specs
->signed_p
)
9172 ("both %<signed%> and %<double%> in "
9173 "declaration specifiers"));
9174 else if (specs
->unsigned_p
)
9176 ("both %<unsigned%> and %<double%> in "
9177 "declaration specifiers"));
9178 else if (specs
->saturating_p
)
9180 ("both %<_Sat%> and %<double%> in "
9181 "declaration specifiers"));
9183 specs
->typespec_word
= cts_double
;
9190 if (i
== RID_DFLOAT32
)
9192 else if (i
== RID_DFLOAT64
)
9195 str
= "_Decimal128";
9196 if (specs
->long_long_p
)
9198 ("both %<long long%> and %<%s%> in "
9199 "declaration specifiers"),
9203 ("both %<long%> and %<%s%> in "
9204 "declaration specifiers"),
9206 else if (specs
->short_p
)
9208 ("both %<short%> and %<%s%> in "
9209 "declaration specifiers"),
9211 else if (specs
->signed_p
)
9213 ("both %<signed%> and %<%s%> in "
9214 "declaration specifiers"),
9216 else if (specs
->unsigned_p
)
9218 ("both %<unsigned%> and %<%s%> in "
9219 "declaration specifiers"),
9221 else if (specs
->complex_p
)
9223 ("both %<complex%> and %<%s%> in "
9224 "declaration specifiers"),
9226 else if (specs
->saturating_p
)
9228 ("both %<_Sat%> and %<%s%> in "
9229 "declaration specifiers"),
9231 else if (i
== RID_DFLOAT32
)
9232 specs
->typespec_word
= cts_dfloat32
;
9233 else if (i
== RID_DFLOAT64
)
9234 specs
->typespec_word
= cts_dfloat64
;
9236 specs
->typespec_word
= cts_dfloat128
;
9238 if (!targetm
.decimal_float_supported_p ())
9240 ("decimal floating point not supported "
9241 "for this target"));
9242 pedwarn (loc
, OPT_pedantic
,
9243 "ISO C does not support decimal floating point");
9253 if (specs
->complex_p
)
9255 ("both %<complex%> and %<%s%> in "
9256 "declaration specifiers"),
9258 else if (i
== RID_FRACT
)
9259 specs
->typespec_word
= cts_fract
;
9261 specs
->typespec_word
= cts_accum
;
9263 if (!targetm
.fixed_point_supported_p ())
9265 "fixed-point types not supported for this target");
9266 pedwarn (loc
, OPT_pedantic
,
9267 "ISO C does not support fixed-point types");
9270 /* ObjC reserved word "id", handled below. */
9276 /* Now we have a typedef (a TYPE_DECL node), an identifier (some
9277 form of ObjC type, cases such as "int" and "long" being handled
9278 above), a TYPE (struct, union, enum and typeof specifiers) or an
9279 ERROR_MARK. In none of these cases may there have previously
9280 been any type specifiers. */
9281 if (specs
->type
|| specs
->typespec_word
!= cts_none
9282 || specs
->long_p
|| specs
->short_p
|| specs
->signed_p
9283 || specs
->unsigned_p
|| specs
->complex_p
)
9284 error_at (loc
, "two or more data types in declaration specifiers");
9285 else if (TREE_CODE (type
) == TYPE_DECL
)
9287 if (TREE_TYPE (type
) == error_mark_node
)
9288 ; /* Allow the type to default to int to avoid cascading errors. */
9291 specs
->type
= TREE_TYPE (type
);
9292 specs
->decl_attr
= DECL_ATTRIBUTES (type
);
9293 specs
->typedef_p
= true;
9294 specs
->explicit_signed_p
= C_TYPEDEF_EXPLICITLY_SIGNED (type
);
9296 /* If this typedef name is defined in a struct, then a C++
9297 lookup would return a different value. */
9299 && I_SYMBOL_BINDING (DECL_NAME (type
))->in_struct
)
9300 warning_at (loc
, OPT_Wc___compat
,
9301 "C++ lookup of %qD would return a field, not a type",
9304 /* If we are parsing a struct, record that a struct field
9306 if (warn_cxx_compat
&& struct_parse_info
!= NULL
)
9307 VEC_safe_push (tree
, heap
, struct_parse_info
->typedefs_seen
, type
);
9310 else if (TREE_CODE (type
) == IDENTIFIER_NODE
)
9312 tree t
= lookup_name (type
);
9313 if (!t
|| TREE_CODE (t
) != TYPE_DECL
)
9314 error_at (loc
, "%qE fails to be a typedef or built in type", type
);
9315 else if (TREE_TYPE (t
) == error_mark_node
)
9318 specs
->type
= TREE_TYPE (t
);
9322 if (TREE_CODE (type
) != ERROR_MARK
&& spec
.kind
== ctsk_typeof
)
9324 specs
->typedef_p
= true;
9328 specs
->expr
= build2 (COMPOUND_EXPR
, TREE_TYPE (spec
.expr
),
9329 specs
->expr
, spec
.expr
);
9331 specs
->expr
= spec
.expr
;
9332 specs
->expr_const_operands
&= spec
.expr_const_operands
;
9341 /* Add the storage class specifier or function specifier SCSPEC to the
9342 declaration specifiers SPECS, returning SPECS. */
9344 struct c_declspecs
*
9345 declspecs_add_scspec (struct c_declspecs
*specs
, tree scspec
)
9348 enum c_storage_class n
= csc_none
;
9350 specs
->declspecs_seen_p
= true;
9351 gcc_assert (TREE_CODE (scspec
) == IDENTIFIER_NODE
9352 && C_IS_RESERVED_WORD (scspec
));
9353 i
= C_RID_CODE (scspec
);
9354 if (specs
->non_sc_seen_p
)
9355 warning (OPT_Wold_style_declaration
,
9356 "%qE is not at beginning of declaration", scspec
);
9360 /* C99 permits duplicate inline. Although of doubtful utility,
9361 it seems simplest to permit it in gnu89 mode as well, as
9362 there is also little utility in maintaining this as a
9363 difference between gnu89 and C99 inline. */
9365 specs
->inline_p
= true;
9368 dupe
= specs
->thread_p
;
9369 if (specs
->storage_class
== csc_auto
)
9370 error ("%<__thread%> used with %<auto%>");
9371 else if (specs
->storage_class
== csc_register
)
9372 error ("%<__thread%> used with %<register%>");
9373 else if (specs
->storage_class
== csc_typedef
)
9374 error ("%<__thread%> used with %<typedef%>");
9376 specs
->thread_p
= true;
9383 /* Diagnose "__thread extern". */
9384 if (specs
->thread_p
)
9385 error ("%<__thread%> before %<extern%>");
9392 /* Diagnose "__thread static". */
9393 if (specs
->thread_p
)
9394 error ("%<__thread%> before %<static%>");
9402 if (n
!= csc_none
&& n
== specs
->storage_class
)
9405 error ("duplicate %qE", scspec
);
9408 if (specs
->storage_class
!= csc_none
&& n
!= specs
->storage_class
)
9410 error ("multiple storage classes in declaration specifiers");
9414 specs
->storage_class
= n
;
9415 if (n
!= csc_extern
&& n
!= csc_static
&& specs
->thread_p
)
9417 error ("%<__thread%> used with %qE", scspec
);
9418 specs
->thread_p
= false;
9425 /* Add the attributes ATTRS to the declaration specifiers SPECS,
9428 struct c_declspecs
*
9429 declspecs_add_attrs (struct c_declspecs
*specs
, tree attrs
)
9431 specs
->attrs
= chainon (attrs
, specs
->attrs
);
9432 specs
->declspecs_seen_p
= true;
9436 /* Combine "long", "short", "signed", "unsigned" and "_Complex" type
9437 specifiers with any other type specifier to determine the resulting
9438 type. This is where ISO C checks on complex types are made, since
9439 "_Complex long" is a prefix of the valid ISO C type "_Complex long
9442 struct c_declspecs
*
9443 finish_declspecs (struct c_declspecs
*specs
)
9445 /* If a type was specified as a whole, we have no modifiers and are
9447 if (specs
->type
!= NULL_TREE
)
9449 gcc_assert (!specs
->long_p
&& !specs
->long_long_p
&& !specs
->short_p
9450 && !specs
->signed_p
&& !specs
->unsigned_p
9451 && !specs
->complex_p
);
9453 /* Set a dummy type. */
9454 if (TREE_CODE (specs
->type
) == ERROR_MARK
)
9455 specs
->type
= integer_type_node
;
9459 /* If none of "void", "_Bool", "char", "int", "float" or "double"
9460 has been specified, treat it as "int" unless "_Complex" is
9461 present and there are no other specifiers. If we just have
9462 "_Complex", it is equivalent to "_Complex double", but e.g.
9463 "_Complex short" is equivalent to "_Complex short int". */
9464 if (specs
->typespec_word
== cts_none
)
9466 if (specs
->saturating_p
)
9468 error ("%<_Sat%> is used without %<_Fract%> or %<_Accum%>");
9469 if (!targetm
.fixed_point_supported_p ())
9470 error ("fixed-point types not supported for this target");
9471 specs
->typespec_word
= cts_fract
;
9473 else if (specs
->long_p
|| specs
->short_p
9474 || specs
->signed_p
|| specs
->unsigned_p
)
9476 specs
->typespec_word
= cts_int
;
9478 else if (specs
->complex_p
)
9480 specs
->typespec_word
= cts_double
;
9481 pedwarn (input_location
, OPT_pedantic
,
9482 "ISO C does not support plain %<complex%> meaning "
9483 "%<double complex%>");
9487 specs
->typespec_word
= cts_int
;
9488 specs
->default_int_p
= true;
9489 /* We don't diagnose this here because grokdeclarator will
9490 give more specific diagnostics according to whether it is
9491 a function definition. */
9495 /* If "signed" was specified, record this to distinguish "int" and
9496 "signed int" in the case of a bit-field with
9497 -funsigned-bitfields. */
9498 specs
->explicit_signed_p
= specs
->signed_p
;
9500 /* Now compute the actual type. */
9501 switch (specs
->typespec_word
)
9504 gcc_assert (!specs
->long_p
&& !specs
->short_p
9505 && !specs
->signed_p
&& !specs
->unsigned_p
9506 && !specs
->complex_p
);
9507 specs
->type
= void_type_node
;
9510 gcc_assert (!specs
->long_p
&& !specs
->short_p
9511 && !specs
->signed_p
&& !specs
->unsigned_p
9512 && !specs
->complex_p
);
9513 specs
->type
= boolean_type_node
;
9516 gcc_assert (!specs
->long_p
&& !specs
->short_p
);
9517 gcc_assert (!(specs
->signed_p
&& specs
->unsigned_p
));
9518 if (specs
->signed_p
)
9519 specs
->type
= signed_char_type_node
;
9520 else if (specs
->unsigned_p
)
9521 specs
->type
= unsigned_char_type_node
;
9523 specs
->type
= char_type_node
;
9524 if (specs
->complex_p
)
9526 pedwarn (input_location
, OPT_pedantic
,
9527 "ISO C does not support complex integer types");
9528 specs
->type
= build_complex_type (specs
->type
);
9532 gcc_assert (!specs
->long_p
&& !specs
->short_p
&& !specs
->long_long_p
);
9533 gcc_assert (!(specs
->signed_p
&& specs
->unsigned_p
));
9534 specs
->type
= (specs
->unsigned_p
9535 ? int128_unsigned_type_node
9536 : int128_integer_type_node
);
9537 if (specs
->complex_p
)
9539 pedwarn (input_location
, OPT_pedantic
,
9540 "ISO C does not support complex integer types");
9541 specs
->type
= build_complex_type (specs
->type
);
9545 gcc_assert (!(specs
->long_p
&& specs
->short_p
));
9546 gcc_assert (!(specs
->signed_p
&& specs
->unsigned_p
));
9547 if (specs
->long_long_p
)
9548 specs
->type
= (specs
->unsigned_p
9549 ? long_long_unsigned_type_node
9550 : long_long_integer_type_node
);
9551 else if (specs
->long_p
)
9552 specs
->type
= (specs
->unsigned_p
9553 ? long_unsigned_type_node
9554 : long_integer_type_node
);
9555 else if (specs
->short_p
)
9556 specs
->type
= (specs
->unsigned_p
9557 ? short_unsigned_type_node
9558 : short_integer_type_node
);
9560 specs
->type
= (specs
->unsigned_p
9561 ? unsigned_type_node
9562 : integer_type_node
);
9563 if (specs
->complex_p
)
9565 pedwarn (input_location
, OPT_pedantic
,
9566 "ISO C does not support complex integer types");
9567 specs
->type
= build_complex_type (specs
->type
);
9571 gcc_assert (!specs
->long_p
&& !specs
->short_p
9572 && !specs
->signed_p
&& !specs
->unsigned_p
);
9573 specs
->type
= (specs
->complex_p
9574 ? complex_float_type_node
9578 gcc_assert (!specs
->long_long_p
&& !specs
->short_p
9579 && !specs
->signed_p
&& !specs
->unsigned_p
);
9582 specs
->type
= (specs
->complex_p
9583 ? complex_long_double_type_node
9584 : long_double_type_node
);
9588 specs
->type
= (specs
->complex_p
9589 ? complex_double_type_node
9590 : double_type_node
);
9596 gcc_assert (!specs
->long_p
&& !specs
->long_long_p
&& !specs
->short_p
9597 && !specs
->signed_p
&& !specs
->unsigned_p
&& !specs
->complex_p
);
9598 if (specs
->typespec_word
== cts_dfloat32
)
9599 specs
->type
= dfloat32_type_node
;
9600 else if (specs
->typespec_word
== cts_dfloat64
)
9601 specs
->type
= dfloat64_type_node
;
9603 specs
->type
= dfloat128_type_node
;
9606 gcc_assert (!specs
->complex_p
);
9607 if (!targetm
.fixed_point_supported_p ())
9608 specs
->type
= integer_type_node
;
9609 else if (specs
->saturating_p
)
9611 if (specs
->long_long_p
)
9612 specs
->type
= specs
->unsigned_p
9613 ? sat_unsigned_long_long_fract_type_node
9614 : sat_long_long_fract_type_node
;
9615 else if (specs
->long_p
)
9616 specs
->type
= specs
->unsigned_p
9617 ? sat_unsigned_long_fract_type_node
9618 : sat_long_fract_type_node
;
9619 else if (specs
->short_p
)
9620 specs
->type
= specs
->unsigned_p
9621 ? sat_unsigned_short_fract_type_node
9622 : sat_short_fract_type_node
;
9624 specs
->type
= specs
->unsigned_p
9625 ? sat_unsigned_fract_type_node
9626 : sat_fract_type_node
;
9630 if (specs
->long_long_p
)
9631 specs
->type
= specs
->unsigned_p
9632 ? unsigned_long_long_fract_type_node
9633 : long_long_fract_type_node
;
9634 else if (specs
->long_p
)
9635 specs
->type
= specs
->unsigned_p
9636 ? unsigned_long_fract_type_node
9637 : long_fract_type_node
;
9638 else if (specs
->short_p
)
9639 specs
->type
= specs
->unsigned_p
9640 ? unsigned_short_fract_type_node
9641 : short_fract_type_node
;
9643 specs
->type
= specs
->unsigned_p
9644 ? unsigned_fract_type_node
9649 gcc_assert (!specs
->complex_p
);
9650 if (!targetm
.fixed_point_supported_p ())
9651 specs
->type
= integer_type_node
;
9652 else if (specs
->saturating_p
)
9654 if (specs
->long_long_p
)
9655 specs
->type
= specs
->unsigned_p
9656 ? sat_unsigned_long_long_accum_type_node
9657 : sat_long_long_accum_type_node
;
9658 else if (specs
->long_p
)
9659 specs
->type
= specs
->unsigned_p
9660 ? sat_unsigned_long_accum_type_node
9661 : sat_long_accum_type_node
;
9662 else if (specs
->short_p
)
9663 specs
->type
= specs
->unsigned_p
9664 ? sat_unsigned_short_accum_type_node
9665 : sat_short_accum_type_node
;
9667 specs
->type
= specs
->unsigned_p
9668 ? sat_unsigned_accum_type_node
9669 : sat_accum_type_node
;
9673 if (specs
->long_long_p
)
9674 specs
->type
= specs
->unsigned_p
9675 ? unsigned_long_long_accum_type_node
9676 : long_long_accum_type_node
;
9677 else if (specs
->long_p
)
9678 specs
->type
= specs
->unsigned_p
9679 ? unsigned_long_accum_type_node
9680 : long_accum_type_node
;
9681 else if (specs
->short_p
)
9682 specs
->type
= specs
->unsigned_p
9683 ? unsigned_short_accum_type_node
9684 : short_accum_type_node
;
9686 specs
->type
= specs
->unsigned_p
9687 ? unsigned_accum_type_node
9698 /* A subroutine of c_write_global_declarations. Perform final processing
9699 on one file scope's declarations (or the external scope's declarations),
9703 c_write_global_declarations_1 (tree globals
)
9708 /* Process the decls in the order they were written. */
9709 for (decl
= globals
; decl
; decl
= DECL_CHAIN (decl
))
9711 /* Check for used but undefined static functions using the C
9712 standard's definition of "used", and set TREE_NO_WARNING so
9713 that check_global_declarations doesn't repeat the check. */
9714 if (TREE_CODE (decl
) == FUNCTION_DECL
9715 && DECL_INITIAL (decl
) == 0
9716 && DECL_EXTERNAL (decl
)
9717 && !TREE_PUBLIC (decl
)
9718 && C_DECL_USED (decl
))
9720 pedwarn (input_location
, 0, "%q+F used but never defined", decl
);
9721 TREE_NO_WARNING (decl
) = 1;
9724 wrapup_global_declaration_1 (decl
);
9730 for (decl
= globals
; decl
; decl
= DECL_CHAIN (decl
))
9731 reconsider
|= wrapup_global_declaration_2 (decl
);
9735 for (decl
= globals
; decl
; decl
= DECL_CHAIN (decl
))
9736 check_global_declaration_1 (decl
);
9739 /* A subroutine of c_write_global_declarations Emit debug information for each
9740 of the declarations in GLOBALS. */
9743 c_write_global_declarations_2 (tree globals
)
9747 for (decl
= globals
; decl
; decl
= DECL_CHAIN (decl
))
9748 debug_hooks
->global_decl (decl
);
9751 /* Callback to collect a source_ref from a DECL. */
9754 collect_source_ref_cb (tree decl
)
9756 if (!DECL_IS_BUILTIN (decl
))
9757 collect_source_ref (LOCATION_FILE (decl_sloc (decl
, false)));
9760 /* Collect all references relevant to SOURCE_FILE. */
9763 collect_all_refs (const char *source_file
)
9768 FOR_EACH_VEC_ELT (tree
, all_translation_units
, i
, t
)
9769 collect_ada_nodes (BLOCK_VARS (DECL_INITIAL (t
)), source_file
);
9772 /* Iterate over all global declarations and call CALLBACK. */
9775 for_each_global_decl (void (*callback
) (tree decl
))
9782 FOR_EACH_VEC_ELT (tree
, all_translation_units
, i
, t
)
9784 decls
= DECL_INITIAL (t
);
9785 for (decl
= BLOCK_VARS (decls
); decl
; decl
= TREE_CHAIN (decl
))
9790 /* Preserve the external declarations scope across a garbage collect. */
9791 static GTY(()) tree ext_block
;
9794 c_write_global_declarations (void)
9799 /* We don't want to do this if generating a PCH. */
9803 /* Do the Objective-C stuff. This is where all the Objective-C
9804 module stuff gets generated (symtab, class/protocol/selector
9806 if (c_dialect_objc ())
9807 objc_write_global_declarations ();
9809 /* Close the external scope. */
9810 ext_block
= pop_scope ();
9812 gcc_assert (!current_scope
);
9814 /* Handle -fdump-ada-spec[-slim]. */
9815 if (dump_enabled_p (TDI_ada
))
9817 /* Build a table of files to generate specs for */
9818 if (get_dump_file_info (TDI_ada
)->flags
& TDF_SLIM
)
9819 collect_source_ref (main_input_filename
);
9821 for_each_global_decl (collect_source_ref_cb
);
9823 dump_ada_specs (collect_all_refs
, NULL
);
9828 tree tmp
= BLOCK_VARS (ext_block
);
9830 FILE * stream
= dump_begin (TDI_tu
, &flags
);
9833 dump_node (tmp
, flags
& ~TDF_SLIM
, stream
);
9834 dump_end (TDI_tu
, stream
);
9838 /* Process all file scopes in this compilation, and the external_scope,
9839 through wrapup_global_declarations and check_global_declarations. */
9840 FOR_EACH_VEC_ELT (tree
, all_translation_units
, i
, t
)
9841 c_write_global_declarations_1 (BLOCK_VARS (DECL_INITIAL (t
)));
9842 c_write_global_declarations_1 (BLOCK_VARS (ext_block
));
9844 /* We're done parsing; proceed to optimize and emit assembly.
9845 FIXME: shouldn't be the front end's responsibility to call this. */
9846 cgraph_finalize_compilation_unit ();
9848 /* After cgraph has had a chance to emit everything that's going to
9849 be emitted, output debug information for globals. */
9852 timevar_push (TV_SYMOUT
);
9853 FOR_EACH_VEC_ELT (tree
, all_translation_units
, i
, t
)
9854 c_write_global_declarations_2 (BLOCK_VARS (DECL_INITIAL (t
)));
9855 c_write_global_declarations_2 (BLOCK_VARS (ext_block
));
9856 timevar_pop (TV_SYMOUT
);
9862 /* Register reserved keyword WORD as qualifier for address space AS. */
9865 c_register_addr_space (const char *word
, addr_space_t as
)
9867 int rid
= RID_FIRST_ADDR_SPACE
+ as
;
9870 /* Address space qualifiers are only supported
9871 in C with GNU extensions enabled. */
9872 if (c_dialect_objc () || flag_no_asm
)
9875 id
= get_identifier (word
);
9876 C_SET_RID_CODE (id
, rid
);
9877 C_IS_RESERVED_WORD (id
) = 1;
9878 ridpointers
[rid
] = id
;
9881 #include "gt-c-decl.h"