1 /* Process declarations and variables for C compiler.
2 Copyright (C) 1988-2014 Free Software Foundation, Inc.
4 This file is part of GCC.
6 GCC is free software; you can redistribute it and/or modify it under
7 the terms of the GNU General Public License as published by the Free
8 Software Foundation; either version 3, or (at your option) any later
11 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
12 WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
16 You should have received a copy of the GNU General Public License
17 along with GCC; see the file COPYING3. If not see
18 <http://www.gnu.org/licenses/>. */
20 /* Process declarations and symbol lookup for C front end.
21 Also constructs types; the standard scalar types at initialization,
22 and structure, union, array and enum types when they are declared. */
24 /* ??? not all decl nodes are given the most useful possible
25 line numbers. For example, the CONST_DECLs for enum values. */
29 #include "coretypes.h"
34 #include "print-tree.h"
35 #include "stor-layout.h"
38 #include "stringpool.h"
39 #include "tree-inline.h"
50 #include "c-family/c-common.h"
51 #include "c-family/c-objc.h"
52 #include "c-family/c-pragma.h"
53 #include "c-family/c-ubsan.h"
55 #include "langhooks.h"
56 #include "tree-iterator.h"
57 #include "diagnostic-core.h"
60 #include "hash-table.h"
61 #include "langhooks-def.h"
62 #include "pointer-set.h"
64 #include "c-family/c-ada-spec.h"
67 /* In grokdeclarator, distinguish syntactic contexts of declarators. */
69 { NORMAL
, /* Ordinary declaration */
70 FUNCDEF
, /* Function definition */
71 PARM
, /* Declaration of parm before function body */
72 FIELD
, /* Declaration inside struct or union */
73 TYPENAME
}; /* Typename (inside cast or sizeof) */
75 /* States indicating how grokdeclarator() should handle declspecs marked
76 with __attribute__((deprecated)). An object declared as
77 __attribute__((deprecated)) suppresses warnings of uses of other
80 enum deprecated_states
{
86 /* Nonzero if we have seen an invalid cross reference
87 to a struct, union, or enum, but not yet printed the message. */
88 tree pending_invalid_xref
;
90 /* File and line to appear in the eventual error message. */
91 location_t pending_invalid_xref_location
;
93 /* The file and line that the prototype came from if this is an
94 old-style definition; used for diagnostics in
95 store_parm_decls_oldstyle. */
97 static location_t current_function_prototype_locus
;
99 /* Whether this prototype was built-in. */
101 static bool current_function_prototype_built_in
;
103 /* The argument type information of this prototype. */
105 static tree current_function_prototype_arg_types
;
107 /* The argument information structure for the function currently being
110 static struct c_arg_info
*current_function_arg_info
;
112 /* The obstack on which parser and related data structures, which are
113 not live beyond their top-level declaration or definition, are
115 struct obstack parser_obstack
;
117 /* The current statement tree. */
119 static GTY(()) struct stmt_tree_s c_stmt_tree
;
121 /* State saving variables. */
125 /* A list of decls to be made automatically visible in each file scope. */
126 static GTY(()) tree visible_builtins
;
128 /* Set to 0 at beginning of a function definition, set to 1 if
129 a return statement that specifies a return value is seen. */
131 int current_function_returns_value
;
133 /* Set to 0 at beginning of a function definition, set to 1 if
134 a return statement with no argument is seen. */
136 int current_function_returns_null
;
138 /* Set to 0 at beginning of a function definition, set to 1 if
139 a call to a noreturn function is seen. */
141 int current_function_returns_abnormally
;
143 /* Set to nonzero by `grokdeclarator' for a function
144 whose return type is defaulted, if warnings for this are desired. */
146 static int warn_about_return_type
;
148 /* Nonzero when the current toplevel function contains a declaration
149 of a nested function which is never defined. */
151 static bool undef_nested_function
;
153 /* Mode used to build pointers (VOIDmode means ptr_mode). */
155 enum machine_mode c_default_pointer_mode
= VOIDmode
;
157 /* If non-zero, implicit "omp declare target" attribute is added into the
159 int current_omp_declare_target_attribute
;
161 /* Each c_binding structure describes one binding of an identifier to
162 a decl. All the decls in a scope - irrespective of namespace - are
163 chained together by the ->prev field, which (as the name implies)
164 runs in reverse order. All the decls in a given namespace bound to
165 a given identifier are chained by the ->shadowed field, which runs
166 from inner to outer scopes.
168 The ->decl field usually points to a DECL node, but there are two
169 exceptions. In the namespace of type tags, the bound entity is a
170 RECORD_TYPE, UNION_TYPE, or ENUMERAL_TYPE node. If an undeclared
171 identifier is encountered, it is bound to error_mark_node to
172 suppress further errors about that identifier in the current
175 The ->u.type field stores the type of the declaration in this scope;
176 if NULL, the type is the type of the ->decl field. This is only of
177 relevance for objects with external or internal linkage which may
178 be redeclared in inner scopes, forming composite types that only
179 persist for the duration of those scopes. In the external scope,
180 this stores the composite of all the types declared for this
181 object, visible or not. The ->inner_comp field (used only at file
182 scope) stores whether an incomplete array type at file scope was
183 completed at an inner scope to an array size other than 1.
185 The ->u.label field is used for labels. It points to a structure
186 which stores additional information used for warnings.
188 The depth field is copied from the scope structure that holds this
189 decl. It is used to preserve the proper ordering of the ->shadowed
190 field (see bind()) and also for a handful of special-case checks.
191 Finally, the invisible bit is true for a decl which should be
192 ignored for purposes of normal name lookup, and the nested bit is
193 true for a decl that's been bound a second time in an inner scope;
194 in all such cases, the binding in the outer scope will have its
195 invisible bit true. */
197 struct GTY((chain_next ("%h.prev"))) c_binding
{
198 union GTY(()) { /* first so GTY desc can use decl */
199 tree
GTY((tag ("0"))) type
; /* the type in this scope */
200 struct c_label_vars
* GTY((tag ("1"))) label
; /* for warnings */
201 } GTY((desc ("TREE_CODE (%0.decl) == LABEL_DECL"))) u
;
202 tree decl
; /* the decl bound */
203 tree id
; /* the identifier it's bound to */
204 struct c_binding
*prev
; /* the previous decl in this scope */
205 struct c_binding
*shadowed
; /* the innermost decl shadowed by this one */
206 unsigned int depth
: 28; /* depth of this scope */
207 BOOL_BITFIELD invisible
: 1; /* normal lookup should ignore this binding */
208 BOOL_BITFIELD nested
: 1; /* do not set DECL_CONTEXT when popping */
209 BOOL_BITFIELD inner_comp
: 1; /* incomplete array completed in inner scope */
210 BOOL_BITFIELD in_struct
: 1; /* currently defined as struct field */
211 location_t locus
; /* location for nested bindings */
213 #define B_IN_SCOPE(b1, b2) ((b1)->depth == (b2)->depth)
214 #define B_IN_CURRENT_SCOPE(b) ((b)->depth == current_scope->depth)
215 #define B_IN_FILE_SCOPE(b) ((b)->depth == 1 /*file_scope->depth*/)
216 #define B_IN_EXTERNAL_SCOPE(b) ((b)->depth == 0 /*external_scope->depth*/)
218 #define I_SYMBOL_BINDING(node) \
219 (((struct lang_identifier *) IDENTIFIER_NODE_CHECK(node))->symbol_binding)
220 #define I_SYMBOL_DECL(node) \
221 (I_SYMBOL_BINDING(node) ? I_SYMBOL_BINDING(node)->decl : 0)
223 #define I_TAG_BINDING(node) \
224 (((struct lang_identifier *) IDENTIFIER_NODE_CHECK(node))->tag_binding)
225 #define I_TAG_DECL(node) \
226 (I_TAG_BINDING(node) ? I_TAG_BINDING(node)->decl : 0)
228 #define I_LABEL_BINDING(node) \
229 (((struct lang_identifier *) IDENTIFIER_NODE_CHECK(node))->label_binding)
230 #define I_LABEL_DECL(node) \
231 (I_LABEL_BINDING(node) ? I_LABEL_BINDING(node)->decl : 0)
233 /* Each C symbol points to three linked lists of c_binding structures.
234 These describe the values of the identifier in the three different
235 namespaces defined by the language. */
237 struct GTY(()) lang_identifier
{
238 struct c_common_identifier common_id
;
239 struct c_binding
*symbol_binding
; /* vars, funcs, constants, typedefs */
240 struct c_binding
*tag_binding
; /* struct/union/enum tags */
241 struct c_binding
*label_binding
; /* labels */
244 /* Validate c-lang.c's assumptions. */
245 extern char C_SIZEOF_STRUCT_LANG_IDENTIFIER_isnt_accurate
246 [(sizeof(struct lang_identifier
) == C_SIZEOF_STRUCT_LANG_IDENTIFIER
) ? 1 : -1];
248 /* The resulting tree type. */
250 union GTY((desc ("TREE_CODE (&%h.generic) == IDENTIFIER_NODE"),
251 chain_next ("(union lang_tree_node *) c_tree_chain_next (&%h.generic)"))) lang_tree_node
253 union tree_node
GTY ((tag ("0"),
254 desc ("tree_node_structure (&%h)")))
256 struct lang_identifier
GTY ((tag ("1"))) identifier
;
259 /* Track bindings and other things that matter for goto warnings. For
260 efficiency, we do not gather all the decls at the point of
261 definition. Instead, we point into the bindings structure. As
262 scopes are popped, we update these structures and gather the decls
263 that matter at that time. */
265 struct GTY(()) c_spot_bindings
{
266 /* The currently open scope which holds bindings defined when the
267 label was defined or the goto statement was found. */
268 struct c_scope
*scope
;
269 /* The bindings in the scope field which were defined at the point
270 of the label or goto. This lets us look at older or newer
271 bindings in the scope, as appropriate. */
272 struct c_binding
*bindings_in_scope
;
273 /* The number of statement expressions that have started since this
274 label or goto statement was defined. This is zero if we are at
275 the same statement expression level. It is positive if we are in
276 a statement expression started since this spot. It is negative
277 if this spot was in a statement expression and we have left
280 /* Whether we started in a statement expression but are no longer in
281 it. This is set to true if stmt_exprs ever goes negative. */
285 /* This structure is used to keep track of bindings seen when a goto
286 statement is defined. This is only used if we see the goto
287 statement before we see the label. */
289 struct GTY(()) c_goto_bindings
{
290 /* The location of the goto statement. */
292 /* The bindings of the goto statement. */
293 struct c_spot_bindings goto_bindings
;
296 typedef struct c_goto_bindings
*c_goto_bindings_p
;
298 /* The additional information we keep track of for a label binding.
299 These fields are updated as scopes are popped. */
301 struct GTY(()) c_label_vars
{
302 /* The shadowed c_label_vars, when one label shadows another (which
303 can only happen using a __label__ declaration). */
304 struct c_label_vars
*shadowed
;
305 /* The bindings when the label was defined. */
306 struct c_spot_bindings label_bindings
;
307 /* A list of decls that we care about: decls about which we should
308 warn if a goto branches to this label from later in the function.
309 Decls are added to this list as scopes are popped. We only add
310 the decls that matter. */
311 vec
<tree
, va_gc
> *decls_in_scope
;
312 /* A list of goto statements to this label. This is only used for
313 goto statements seen before the label was defined, so that we can
314 issue appropriate warnings for them. */
315 vec
<c_goto_bindings_p
, va_gc
> *gotos
;
318 /* Each c_scope structure describes the complete contents of one
319 scope. Four scopes are distinguished specially: the innermost or
320 current scope, the innermost function scope, the file scope (always
321 the second to outermost) and the outermost or external scope.
323 Most declarations are recorded in the current scope.
325 All normal label declarations are recorded in the innermost
326 function scope, as are bindings of undeclared identifiers to
327 error_mark_node. (GCC permits nested functions as an extension,
328 hence the 'innermost' qualifier.) Explicitly declared labels
329 (using the __label__ extension) appear in the current scope.
331 Being in the file scope (current_scope == file_scope) causes
332 special behavior in several places below. Also, under some
333 conditions the Objective-C front end records declarations in the
334 file scope even though that isn't the current scope.
336 All declarations with external linkage are recorded in the external
337 scope, even if they aren't visible there; this models the fact that
338 such declarations are visible to the entire program, and (with a
339 bit of cleverness, see pushdecl) allows diagnosis of some violations
340 of C99 6.2.2p7 and 6.2.7p2:
342 If, within the same translation unit, the same identifier appears
343 with both internal and external linkage, the behavior is
346 All declarations that refer to the same object or function shall
347 have compatible type; otherwise, the behavior is undefined.
349 Initially only the built-in declarations, which describe compiler
350 intrinsic functions plus a subset of the standard library, are in
353 The order of the blocks list matters, and it is frequently appended
354 to. To avoid having to walk all the way to the end of the list on
355 each insertion, or reverse the list later, we maintain a pointer to
356 the last list entry. (FIXME: It should be feasible to use a reversed
359 The bindings list is strictly in reverse order of declarations;
360 pop_scope relies on this. */
363 struct GTY((chain_next ("%h.outer"))) c_scope
{
364 /* The scope containing this one. */
365 struct c_scope
*outer
;
367 /* The next outermost function scope. */
368 struct c_scope
*outer_function
;
370 /* All bindings in this scope. */
371 struct c_binding
*bindings
;
373 /* For each scope (except the global one), a chain of BLOCK nodes
374 for all the scopes that were entered and exited one level down. */
378 /* The depth of this scope. Used to keep the ->shadowed chain of
379 bindings sorted innermost to outermost. */
380 unsigned int depth
: 28;
382 /* True if we are currently filling this scope with parameter
384 BOOL_BITFIELD parm_flag
: 1;
386 /* True if we saw [*] in this scope. Used to give an error messages
387 if these appears in a function definition. */
388 BOOL_BITFIELD had_vla_unspec
: 1;
390 /* True if we already complained about forward parameter decls
391 in this scope. This prevents double warnings on
392 foo (int a; int b; ...) */
393 BOOL_BITFIELD warned_forward_parm_decls
: 1;
395 /* True if this is the outermost block scope of a function body.
396 This scope contains the parameters, the local variables declared
397 in the outermost block, and all the labels (except those in
398 nested functions, or declared at block scope with __label__). */
399 BOOL_BITFIELD function_body
: 1;
401 /* True means make a BLOCK for this scope no matter what. */
402 BOOL_BITFIELD keep
: 1;
404 /* True means that an unsuffixed float constant is _Decimal64. */
405 BOOL_BITFIELD float_const_decimal64
: 1;
407 /* True if this scope has any label bindings. This is used to speed
408 up searching for labels when popping scopes, particularly since
409 labels are normally only found at function scope. */
410 BOOL_BITFIELD has_label_bindings
: 1;
412 /* True if we should issue a warning if a goto statement crosses any
413 of the bindings. We still need to check the list of bindings to
414 find the specific ones we need to warn about. This is true if
415 decl_jump_unsafe would return true for any of the bindings. This
416 is used to avoid looping over all the bindings unnecessarily. */
417 BOOL_BITFIELD has_jump_unsafe_decl
: 1;
420 /* The scope currently in effect. */
422 static GTY(()) struct c_scope
*current_scope
;
424 /* The innermost function scope. Ordinary (not explicitly declared)
425 labels, bindings to error_mark_node, and the lazily-created
426 bindings of __func__ and its friends get this scope. */
428 static GTY(()) struct c_scope
*current_function_scope
;
430 /* The C file scope. This is reset for each input translation unit. */
432 static GTY(()) struct c_scope
*file_scope
;
434 /* The outermost scope. This is used for all declarations with
435 external linkage, and only these, hence the name. */
437 static GTY(()) struct c_scope
*external_scope
;
439 /* A chain of c_scope structures awaiting reuse. */
441 static GTY((deletable
)) struct c_scope
*scope_freelist
;
443 /* A chain of c_binding structures awaiting reuse. */
445 static GTY((deletable
)) struct c_binding
*binding_freelist
;
447 /* Append VAR to LIST in scope SCOPE. */
448 #define SCOPE_LIST_APPEND(scope, list, decl) do { \
449 struct c_scope *s_ = (scope); \
451 if (s_->list##_last) \
452 BLOCK_CHAIN (s_->list##_last) = d_; \
455 s_->list##_last = d_; \
458 /* Concatenate FROM in scope FSCOPE onto TO in scope TSCOPE. */
459 #define SCOPE_LIST_CONCAT(tscope, to, fscope, from) do { \
460 struct c_scope *t_ = (tscope); \
461 struct c_scope *f_ = (fscope); \
463 BLOCK_CHAIN (t_->to##_last) = f_->from; \
466 t_->to##_last = f_->from##_last; \
469 /* A c_inline_static structure stores details of a static identifier
470 referenced in a definition of a function that may be an inline
471 definition if no subsequent declaration of that function uses
472 "extern" or does not use "inline". */
474 struct GTY((chain_next ("%h.next"))) c_inline_static
{
475 /* The location for a diagnostic. */
478 /* The function that may be an inline definition. */
481 /* The object or function referenced. */
484 /* What sort of reference this is. */
485 enum c_inline_static_type type
;
487 /* The next such structure or NULL. */
488 struct c_inline_static
*next
;
491 /* List of static identifiers used or referenced in functions that may
492 be inline definitions. */
493 static GTY(()) struct c_inline_static
*c_inline_statics
;
495 /* True means unconditionally make a BLOCK for the next scope pushed. */
497 static bool keep_next_level_flag
;
499 /* True means the next call to push_scope will be the outermost scope
500 of a function body, so do not push a new scope, merely cease
501 expecting parameter decls. */
503 static bool next_is_function_body
;
505 /* A vector of pointers to c_binding structures. */
507 typedef struct c_binding
*c_binding_ptr
;
509 /* Information that we keep for a struct or union while it is being
512 struct c_struct_parse_info
514 /* If warn_cxx_compat, a list of types defined within this
516 vec
<tree
> struct_types
;
517 /* If warn_cxx_compat, a list of field names which have bindings,
518 and which are defined in this struct, but which are not defined
519 in any enclosing struct. This is used to clear the in_struct
520 field of the c_bindings structure. */
521 vec
<c_binding_ptr
> fields
;
522 /* If warn_cxx_compat, a list of typedef names used when defining
523 fields in this struct. */
524 vec
<tree
> typedefs_seen
;
527 /* Information for the struct or union currently being parsed, or
528 NULL if not parsing a struct or union. */
529 static struct c_struct_parse_info
*struct_parse_info
;
531 /* Forward declarations. */
532 static tree
lookup_name_in_scope (tree
, struct c_scope
*);
533 static tree
c_make_fname_decl (location_t
, tree
, int);
534 static tree
grokdeclarator (const struct c_declarator
*,
535 struct c_declspecs
*,
536 enum decl_context
, bool, tree
*, tree
*, tree
*,
537 bool *, enum deprecated_states
);
538 static tree
grokparms (struct c_arg_info
*, bool);
539 static void layout_array_type (tree
);
541 /* T is a statement. Add it to the statement-tree. This is the
542 C/ObjC version--C++ has a slightly different version of this
548 enum tree_code code
= TREE_CODE (t
);
550 if (CAN_HAVE_LOCATION_P (t
) && code
!= LABEL_EXPR
)
552 if (!EXPR_HAS_LOCATION (t
))
553 SET_EXPR_LOCATION (t
, input_location
);
556 if (code
== LABEL_EXPR
|| code
== CASE_LABEL_EXPR
)
557 STATEMENT_LIST_HAS_LABEL (cur_stmt_list
) = 1;
559 /* Add T to the statement-tree. Non-side-effect statements need to be
560 recorded during statement expressions. */
561 if (!building_stmt_list_p ())
563 append_to_statement_list_force (t
, &cur_stmt_list
);
568 /* Build a pointer type using the default pointer mode. */
571 c_build_pointer_type (tree to_type
)
573 addr_space_t as
= to_type
== error_mark_node
? ADDR_SPACE_GENERIC
574 : TYPE_ADDR_SPACE (to_type
);
575 enum machine_mode pointer_mode
;
577 if (as
!= ADDR_SPACE_GENERIC
|| c_default_pointer_mode
== VOIDmode
)
578 pointer_mode
= targetm
.addr_space
.pointer_mode (as
);
580 pointer_mode
= c_default_pointer_mode
;
581 return build_pointer_type_for_mode (to_type
, pointer_mode
, false);
585 /* Return true if we will want to say something if a goto statement
589 decl_jump_unsafe (tree decl
)
591 if (error_operand_p (decl
))
594 /* Always warn about crossing variably modified types. */
595 if ((TREE_CODE (decl
) == VAR_DECL
|| TREE_CODE (decl
) == TYPE_DECL
)
596 && variably_modified_type_p (TREE_TYPE (decl
), NULL_TREE
))
599 /* Otherwise, only warn if -Wgoto-misses-init and this is an
600 initialized automatic decl. */
601 if (warn_jump_misses_init
602 && TREE_CODE (decl
) == VAR_DECL
603 && !TREE_STATIC (decl
)
604 && DECL_INITIAL (decl
) != NULL_TREE
)
612 c_print_identifier (FILE *file
, tree node
, int indent
)
614 print_node (file
, "symbol", I_SYMBOL_DECL (node
), indent
+ 4);
615 print_node (file
, "tag", I_TAG_DECL (node
), indent
+ 4);
616 print_node (file
, "label", I_LABEL_DECL (node
), indent
+ 4);
617 if (C_IS_RESERVED_WORD (node
) && C_RID_CODE (node
) != RID_CXX_COMPAT_WARN
)
619 tree rid
= ridpointers
[C_RID_CODE (node
)];
620 indent_to (file
, indent
+ 4);
621 fprintf (file
, "rid " HOST_PTR_PRINTF
" \"%s\"",
622 (void *) rid
, IDENTIFIER_POINTER (rid
));
626 /* Establish a binding between NAME, an IDENTIFIER_NODE, and DECL,
627 which may be any of several kinds of DECL or TYPE or error_mark_node,
628 in the scope SCOPE. */
630 bind (tree name
, tree decl
, struct c_scope
*scope
, bool invisible
,
631 bool nested
, location_t locus
)
633 struct c_binding
*b
, **here
;
635 if (binding_freelist
)
637 b
= binding_freelist
;
638 binding_freelist
= b
->prev
;
641 b
= ggc_alloc_c_binding ();
646 b
->depth
= scope
->depth
;
647 b
->invisible
= invisible
;
655 b
->prev
= scope
->bindings
;
658 if (decl_jump_unsafe (decl
))
659 scope
->has_jump_unsafe_decl
= 1;
664 switch (TREE_CODE (decl
))
666 case LABEL_DECL
: here
= &I_LABEL_BINDING (name
); break;
669 case RECORD_TYPE
: here
= &I_TAG_BINDING (name
); break;
675 case ERROR_MARK
: here
= &I_SYMBOL_BINDING (name
); break;
681 /* Locate the appropriate place in the chain of shadowed decls
682 to insert this binding. Normally, scope == current_scope and
683 this does nothing. */
684 while (*here
&& (*here
)->depth
> scope
->depth
)
685 here
= &(*here
)->shadowed
;
691 /* Clear the binding structure B, stick it on the binding_freelist,
692 and return the former value of b->prev. This is used by pop_scope
693 and get_parm_info to iterate destructively over all the bindings
694 from a given scope. */
695 static struct c_binding
*
696 free_binding_and_advance (struct c_binding
*b
)
698 struct c_binding
*prev
= b
->prev
;
700 memset (b
, 0, sizeof (struct c_binding
));
701 b
->prev
= binding_freelist
;
702 binding_freelist
= b
;
707 /* Bind a label. Like bind, but skip fields which aren't used for
708 labels, and add the LABEL_VARS value. */
710 bind_label (tree name
, tree label
, struct c_scope
*scope
,
711 struct c_label_vars
*label_vars
)
715 bind (name
, label
, scope
, /*invisible=*/false, /*nested=*/false,
718 scope
->has_label_bindings
= true;
721 gcc_assert (b
->decl
== label
);
722 label_vars
->shadowed
= b
->u
.label
;
723 b
->u
.label
= label_vars
;
726 /* Hook called at end of compilation to assume 1 elt
727 for a file-scope tentative array defn that wasn't complete before. */
730 c_finish_incomplete_decl (tree decl
)
732 if (TREE_CODE (decl
) == VAR_DECL
)
734 tree type
= TREE_TYPE (decl
);
735 if (type
!= error_mark_node
736 && TREE_CODE (type
) == ARRAY_TYPE
737 && !DECL_EXTERNAL (decl
)
738 && TYPE_DOMAIN (type
) == 0)
740 warning_at (DECL_SOURCE_LOCATION (decl
),
741 0, "array %q+D assumed to have one element", decl
);
743 complete_array_type (&TREE_TYPE (decl
), NULL_TREE
, true);
745 relayout_decl (decl
);
750 /* Record that inline function FUNC contains a reference (location
751 LOC) to static DECL (file-scope or function-local according to
755 record_inline_static (location_t loc
, tree func
, tree decl
,
756 enum c_inline_static_type type
)
758 struct c_inline_static
*csi
= ggc_alloc_c_inline_static ();
760 csi
->function
= func
;
761 csi
->static_decl
= decl
;
763 csi
->next
= c_inline_statics
;
764 c_inline_statics
= csi
;
767 /* Check for references to static declarations in inline functions at
768 the end of the translation unit and diagnose them if the functions
769 are still inline definitions. */
772 check_inline_statics (void)
774 struct c_inline_static
*csi
;
775 for (csi
= c_inline_statics
; csi
; csi
= csi
->next
)
777 if (DECL_EXTERNAL (csi
->function
))
781 pedwarn (csi
->location
, 0,
782 "%qD is static but used in inline function %qD "
783 "which is not static", csi
->static_decl
, csi
->function
);
786 pedwarn (csi
->location
, 0,
787 "%q+D is static but declared in inline function %qD "
788 "which is not static", csi
->static_decl
, csi
->function
);
794 c_inline_statics
= NULL
;
797 /* Fill in a c_spot_bindings structure. If DEFINING is true, set it
798 for the current state, otherwise set it to uninitialized. */
801 set_spot_bindings (struct c_spot_bindings
*p
, bool defining
)
805 p
->scope
= current_scope
;
806 p
->bindings_in_scope
= current_scope
->bindings
;
811 p
->bindings_in_scope
= NULL
;
814 p
->left_stmt_expr
= false;
817 /* Update spot bindings P as we pop out of SCOPE. Return true if we
818 should push decls for a label. */
821 update_spot_bindings (struct c_scope
*scope
, struct c_spot_bindings
*p
)
823 if (p
->scope
!= scope
)
825 /* This label or goto is defined in some other scope, or it is a
826 label which is not yet defined. There is nothing to
831 /* Adjust the spot bindings to refer to the bindings already defined
832 in the enclosing scope. */
833 p
->scope
= scope
->outer
;
834 p
->bindings_in_scope
= p
->scope
->bindings
;
839 /* The Objective-C front-end often needs to determine the current scope. */
842 objc_get_current_scope (void)
844 return current_scope
;
847 /* The following function is used only by Objective-C. It needs to live here
848 because it accesses the innards of c_scope. */
851 objc_mark_locals_volatile (void *enclosing_blk
)
853 struct c_scope
*scope
;
856 for (scope
= current_scope
;
857 scope
&& scope
!= enclosing_blk
;
858 scope
= scope
->outer
)
860 for (b
= scope
->bindings
; b
; b
= b
->prev
)
861 objc_volatilize_decl (b
->decl
);
863 /* Do not climb up past the current function. */
864 if (scope
->function_body
)
869 /* Return true if we are in the global binding level. */
872 global_bindings_p (void)
874 return current_scope
== file_scope
;
878 keep_next_level (void)
880 keep_next_level_flag
= true;
883 /* Set the flag for the FLOAT_CONST_DECIMAL64 pragma being ON. */
886 set_float_const_decimal64 (void)
888 current_scope
->float_const_decimal64
= true;
891 /* Clear the flag for the FLOAT_CONST_DECIMAL64 pragma. */
894 clear_float_const_decimal64 (void)
896 current_scope
->float_const_decimal64
= false;
899 /* Return nonzero if an unsuffixed float constant is _Decimal64. */
902 float_const_decimal64_p (void)
904 return current_scope
->float_const_decimal64
;
907 /* Identify this scope as currently being filled with parameters. */
910 declare_parm_level (void)
912 current_scope
->parm_flag
= true;
918 if (next_is_function_body
)
920 /* This is the transition from the parameters to the top level
921 of the function body. These are the same scope
922 (C99 6.2.1p4,6) so we do not push another scope structure.
923 next_is_function_body is set only by store_parm_decls, which
924 in turn is called when and only when we are about to
925 encounter the opening curly brace for the function body.
927 The outermost block of a function always gets a BLOCK node,
928 because the debugging output routines expect that each
929 function has at least one BLOCK. */
930 current_scope
->parm_flag
= false;
931 current_scope
->function_body
= true;
932 current_scope
->keep
= true;
933 current_scope
->outer_function
= current_function_scope
;
934 current_function_scope
= current_scope
;
936 keep_next_level_flag
= false;
937 next_is_function_body
= false;
939 /* The FLOAT_CONST_DECIMAL64 pragma applies to nested scopes. */
940 if (current_scope
->outer
)
941 current_scope
->float_const_decimal64
942 = current_scope
->outer
->float_const_decimal64
;
944 current_scope
->float_const_decimal64
= false;
948 struct c_scope
*scope
;
951 scope
= scope_freelist
;
952 scope_freelist
= scope
->outer
;
955 scope
= ggc_alloc_cleared_c_scope ();
957 /* The FLOAT_CONST_DECIMAL64 pragma applies to nested scopes. */
959 scope
->float_const_decimal64
= current_scope
->float_const_decimal64
;
961 scope
->float_const_decimal64
= false;
963 scope
->keep
= keep_next_level_flag
;
964 scope
->outer
= current_scope
;
965 scope
->depth
= current_scope
? (current_scope
->depth
+ 1) : 0;
967 /* Check for scope depth overflow. Unlikely (2^28 == 268,435,456) but
969 if (current_scope
&& scope
->depth
== 0)
972 sorry ("GCC supports only %u nested scopes", scope
->depth
);
975 current_scope
= scope
;
976 keep_next_level_flag
= false;
980 /* This is called when we are leaving SCOPE. For each label defined
981 in SCOPE, add any appropriate decls to its decls_in_scope fields.
982 These are the decls whose initialization will be skipped by a goto
983 later in the function. */
986 update_label_decls (struct c_scope
*scope
)
993 if (s
->has_label_bindings
)
997 for (b
= s
->bindings
; b
!= NULL
; b
= b
->prev
)
999 struct c_label_vars
*label_vars
;
1000 struct c_binding
*b1
;
1003 struct c_goto_bindings
*g
;
1005 if (TREE_CODE (b
->decl
) != LABEL_DECL
)
1007 label_vars
= b
->u
.label
;
1009 b1
= label_vars
->label_bindings
.bindings_in_scope
;
1010 if (label_vars
->label_bindings
.scope
== NULL
)
1013 hjud
= label_vars
->label_bindings
.scope
->has_jump_unsafe_decl
;
1014 if (update_spot_bindings (scope
, &label_vars
->label_bindings
))
1016 /* This label is defined in this scope. */
1019 for (; b1
!= NULL
; b1
= b1
->prev
)
1021 /* A goto from later in the function to this
1022 label will never see the initialization
1023 of B1, if any. Save it to issue a
1024 warning if needed. */
1025 if (decl_jump_unsafe (b1
->decl
))
1026 vec_safe_push(label_vars
->decls_in_scope
, b1
->decl
);
1031 /* Update the bindings of any goto statements associated
1033 FOR_EACH_VEC_SAFE_ELT (label_vars
->gotos
, ix
, g
)
1034 update_spot_bindings (scope
, &g
->goto_bindings
);
1038 /* Don't search beyond the current function. */
1039 if (s
== current_function_scope
)
1046 /* Set the TYPE_CONTEXT of all of TYPE's variants to CONTEXT. */
1049 set_type_context (tree type
, tree context
)
1051 for (type
= TYPE_MAIN_VARIANT (type
); type
;
1052 type
= TYPE_NEXT_VARIANT (type
))
1053 TYPE_CONTEXT (type
) = context
;
1056 /* Exit a scope. Restore the state of the identifier-decl mappings
1057 that were in effect when this scope was entered. Return a BLOCK
1058 node containing all the DECLs in this scope that are of interest
1059 to debug info generation. */
1064 struct c_scope
*scope
= current_scope
;
1065 tree block
, context
, p
;
1066 struct c_binding
*b
;
1068 bool functionbody
= scope
->function_body
;
1069 bool keep
= functionbody
|| scope
->keep
|| scope
->bindings
;
1071 update_label_decls (scope
);
1073 /* If appropriate, create a BLOCK to record the decls for the life
1074 of this function. */
1078 block
= make_node (BLOCK
);
1079 BLOCK_SUBBLOCKS (block
) = scope
->blocks
;
1080 TREE_USED (block
) = 1;
1082 /* In each subblock, record that this is its superior. */
1083 for (p
= scope
->blocks
; p
; p
= BLOCK_CHAIN (p
))
1084 BLOCK_SUPERCONTEXT (p
) = block
;
1086 BLOCK_VARS (block
) = 0;
1089 /* The TYPE_CONTEXTs for all of the tagged types belonging to this
1090 scope must be set so that they point to the appropriate
1091 construct, i.e. either to the current FUNCTION_DECL node, or
1092 else to the BLOCK node we just constructed.
1094 Note that for tagged types whose scope is just the formal
1095 parameter list for some function type specification, we can't
1096 properly set their TYPE_CONTEXTs here, because we don't have a
1097 pointer to the appropriate FUNCTION_TYPE node readily available
1098 to us. For those cases, the TYPE_CONTEXTs of the relevant tagged
1099 type nodes get set in `grokdeclarator' as soon as we have created
1100 the FUNCTION_TYPE node which will represent the "scope" for these
1101 "parameter list local" tagged types. */
1102 if (scope
->function_body
)
1103 context
= current_function_decl
;
1104 else if (scope
== file_scope
)
1106 tree file_decl
= build_translation_unit_decl (NULL_TREE
);
1107 context
= file_decl
;
1112 /* Clear all bindings in this scope. */
1113 for (b
= scope
->bindings
; b
; b
= free_binding_and_advance (b
))
1116 switch (TREE_CODE (p
))
1119 /* Warnings for unused labels, errors for undefined labels. */
1120 if (TREE_USED (p
) && !DECL_INITIAL (p
))
1122 error ("label %q+D used but not defined", p
);
1123 DECL_INITIAL (p
) = error_mark_node
;
1126 warn_for_unused_label (p
);
1128 /* Labels go in BLOCK_VARS. */
1129 DECL_CHAIN (p
) = BLOCK_VARS (block
);
1130 BLOCK_VARS (block
) = p
;
1131 gcc_assert (I_LABEL_BINDING (b
->id
) == b
);
1132 I_LABEL_BINDING (b
->id
) = b
->shadowed
;
1134 /* Also pop back to the shadowed label_vars. */
1135 release_tree_vector (b
->u
.label
->decls_in_scope
);
1136 b
->u
.label
= b
->u
.label
->shadowed
;
1142 set_type_context (p
, context
);
1144 /* Types may not have tag-names, in which case the type
1145 appears in the bindings list with b->id NULL. */
1148 gcc_assert (I_TAG_BINDING (b
->id
) == b
);
1149 I_TAG_BINDING (b
->id
) = b
->shadowed
;
1154 /* Propagate TREE_ADDRESSABLE from nested functions to their
1155 containing functions. */
1156 if (!TREE_ASM_WRITTEN (p
)
1157 && DECL_INITIAL (p
) != 0
1158 && TREE_ADDRESSABLE (p
)
1159 && DECL_ABSTRACT_ORIGIN (p
) != 0
1160 && DECL_ABSTRACT_ORIGIN (p
) != p
)
1161 TREE_ADDRESSABLE (DECL_ABSTRACT_ORIGIN (p
)) = 1;
1162 if (!DECL_EXTERNAL (p
)
1163 && !DECL_INITIAL (p
)
1164 && scope
!= file_scope
1165 && scope
!= external_scope
)
1167 error ("nested function %q+D declared but never defined", p
);
1168 undef_nested_function
= true;
1170 else if (DECL_DECLARED_INLINE_P (p
)
1172 && !DECL_INITIAL (p
))
1174 /* C99 6.7.4p6: "a function with external linkage... declared
1175 with an inline function specifier ... shall also be defined
1176 in the same translation unit." */
1177 if (!flag_gnu89_inline
)
1178 pedwarn (input_location
, 0,
1179 "inline function %q+D declared but never defined", p
);
1180 DECL_EXTERNAL (p
) = 1;
1186 /* Warnings for unused variables. */
1187 if ((!TREE_USED (p
) || !DECL_READ_P (p
))
1188 && !TREE_NO_WARNING (p
)
1189 && !DECL_IN_SYSTEM_HEADER (p
)
1191 && !DECL_ARTIFICIAL (p
)
1192 && scope
!= file_scope
1193 && scope
!= external_scope
)
1196 warning (OPT_Wunused_variable
, "unused variable %q+D", p
);
1197 else if (DECL_CONTEXT (p
) == current_function_decl
)
1198 warning_at (DECL_SOURCE_LOCATION (p
),
1199 OPT_Wunused_but_set_variable
,
1200 "variable %qD set but not used", p
);
1205 error ("type of array %q+D completed incompatibly with"
1206 " implicit initialization", p
);
1213 /* All of these go in BLOCK_VARS, but only if this is the
1214 binding in the home scope. */
1217 DECL_CHAIN (p
) = BLOCK_VARS (block
);
1218 BLOCK_VARS (block
) = p
;
1220 else if (VAR_OR_FUNCTION_DECL_P (p
) && scope
!= file_scope
)
1222 /* For block local externs add a special
1223 DECL_EXTERNAL decl for debug info generation. */
1224 tree extp
= copy_node (p
);
1226 DECL_EXTERNAL (extp
) = 1;
1227 TREE_STATIC (extp
) = 0;
1228 TREE_PUBLIC (extp
) = 1;
1229 DECL_INITIAL (extp
) = NULL_TREE
;
1230 DECL_LANG_SPECIFIC (extp
) = NULL
;
1231 DECL_CONTEXT (extp
) = current_function_decl
;
1232 if (TREE_CODE (p
) == FUNCTION_DECL
)
1234 DECL_RESULT (extp
) = NULL_TREE
;
1235 DECL_SAVED_TREE (extp
) = NULL_TREE
;
1236 DECL_STRUCT_FUNCTION (extp
) = NULL
;
1238 if (b
->locus
!= UNKNOWN_LOCATION
)
1239 DECL_SOURCE_LOCATION (extp
) = b
->locus
;
1240 DECL_CHAIN (extp
) = BLOCK_VARS (block
);
1241 BLOCK_VARS (block
) = extp
;
1243 /* If this is the file scope set DECL_CONTEXT of each decl to
1244 the TRANSLATION_UNIT_DECL. This makes same_translation_unit_p
1246 if (scope
== file_scope
)
1248 DECL_CONTEXT (p
) = context
;
1249 if (TREE_CODE (p
) == TYPE_DECL
1250 && TREE_TYPE (p
) != error_mark_node
)
1251 set_type_context (TREE_TYPE (p
), context
);
1255 /* Parameters go in DECL_ARGUMENTS, not BLOCK_VARS, and have
1256 already been put there by store_parm_decls. Unused-
1257 parameter warnings are handled by function.c.
1258 error_mark_node obviously does not go in BLOCK_VARS and
1259 does not get unused-variable warnings. */
1262 /* It is possible for a decl not to have a name. We get
1263 here with b->id NULL in this case. */
1266 gcc_assert (I_SYMBOL_BINDING (b
->id
) == b
);
1267 I_SYMBOL_BINDING (b
->id
) = b
->shadowed
;
1268 if (b
->shadowed
&& b
->shadowed
->u
.type
)
1269 TREE_TYPE (b
->shadowed
->decl
) = b
->shadowed
->u
.type
;
1279 /* Dispose of the block that we just made inside some higher level. */
1280 if ((scope
->function_body
|| scope
== file_scope
) && context
)
1282 DECL_INITIAL (context
) = block
;
1283 BLOCK_SUPERCONTEXT (block
) = context
;
1285 else if (scope
->outer
)
1288 SCOPE_LIST_APPEND (scope
->outer
, blocks
, block
);
1289 /* If we did not make a block for the scope just exited, any
1290 blocks made for inner scopes must be carried forward so they
1291 will later become subblocks of something else. */
1292 else if (scope
->blocks
)
1293 SCOPE_LIST_CONCAT (scope
->outer
, blocks
, scope
, blocks
);
1296 /* Pop the current scope, and free the structure for reuse. */
1297 current_scope
= scope
->outer
;
1298 if (scope
->function_body
)
1299 current_function_scope
= scope
->outer_function
;
1301 memset (scope
, 0, sizeof (struct c_scope
));
1302 scope
->outer
= scope_freelist
;
1303 scope_freelist
= scope
;
1309 push_file_scope (void)
1317 file_scope
= current_scope
;
1319 start_fname_decls ();
1321 for (decl
= visible_builtins
; decl
; decl
= DECL_CHAIN (decl
))
1322 bind (DECL_NAME (decl
), decl
, file_scope
,
1323 /*invisible=*/false, /*nested=*/true, DECL_SOURCE_LOCATION (decl
));
1327 pop_file_scope (void)
1329 /* In case there were missing closebraces, get us back to the global
1331 while (current_scope
!= file_scope
)
1334 /* __FUNCTION__ is defined at file scope (""). This
1335 call may not be necessary as my tests indicate it
1336 still works without it. */
1337 finish_fname_decls ();
1339 check_inline_statics ();
1341 /* This is the point to write out a PCH if we're doing that.
1342 In that case we do not want to do anything else. */
1345 c_common_write_pch ();
1349 /* Pop off the file scope and close this translation unit. */
1353 maybe_apply_pending_pragma_weaks ();
1356 /* Adjust the bindings for the start of a statement expression. */
1359 c_bindings_start_stmt_expr (struct c_spot_bindings
* switch_bindings
)
1361 struct c_scope
*scope
;
1363 for (scope
= current_scope
; scope
!= NULL
; scope
= scope
->outer
)
1365 struct c_binding
*b
;
1367 if (!scope
->has_label_bindings
)
1370 for (b
= scope
->bindings
; b
!= NULL
; b
= b
->prev
)
1372 struct c_label_vars
*label_vars
;
1374 struct c_goto_bindings
*g
;
1376 if (TREE_CODE (b
->decl
) != LABEL_DECL
)
1378 label_vars
= b
->u
.label
;
1379 ++label_vars
->label_bindings
.stmt_exprs
;
1380 FOR_EACH_VEC_SAFE_ELT (label_vars
->gotos
, ix
, g
)
1381 ++g
->goto_bindings
.stmt_exprs
;
1385 if (switch_bindings
!= NULL
)
1386 ++switch_bindings
->stmt_exprs
;
1389 /* Adjust the bindings for the end of a statement expression. */
1392 c_bindings_end_stmt_expr (struct c_spot_bindings
*switch_bindings
)
1394 struct c_scope
*scope
;
1396 for (scope
= current_scope
; scope
!= NULL
; scope
= scope
->outer
)
1398 struct c_binding
*b
;
1400 if (!scope
->has_label_bindings
)
1403 for (b
= scope
->bindings
; b
!= NULL
; b
= b
->prev
)
1405 struct c_label_vars
*label_vars
;
1407 struct c_goto_bindings
*g
;
1409 if (TREE_CODE (b
->decl
) != LABEL_DECL
)
1411 label_vars
= b
->u
.label
;
1412 --label_vars
->label_bindings
.stmt_exprs
;
1413 if (label_vars
->label_bindings
.stmt_exprs
< 0)
1415 label_vars
->label_bindings
.left_stmt_expr
= true;
1416 label_vars
->label_bindings
.stmt_exprs
= 0;
1418 FOR_EACH_VEC_SAFE_ELT (label_vars
->gotos
, ix
, g
)
1420 --g
->goto_bindings
.stmt_exprs
;
1421 if (g
->goto_bindings
.stmt_exprs
< 0)
1423 g
->goto_bindings
.left_stmt_expr
= true;
1424 g
->goto_bindings
.stmt_exprs
= 0;
1430 if (switch_bindings
!= NULL
)
1432 --switch_bindings
->stmt_exprs
;
1433 gcc_assert (switch_bindings
->stmt_exprs
>= 0);
1437 /* Push a definition or a declaration of struct, union or enum tag "name".
1438 "type" should be the type node.
1439 We assume that the tag "name" is not already defined, and has a location
1442 Note that the definition may really be just a forward reference.
1443 In that case, the TYPE_SIZE will be zero. */
1446 pushtag (location_t loc
, tree name
, tree type
)
1448 /* Record the identifier as the type's name if it has none. */
1449 if (name
&& !TYPE_NAME (type
))
1450 TYPE_NAME (type
) = name
;
1451 bind (name
, type
, current_scope
, /*invisible=*/false, /*nested=*/false, loc
);
1453 /* Create a fake NULL-named TYPE_DECL node whose TREE_TYPE will be the
1454 tagged type we just added to the current scope. This fake
1455 NULL-named TYPE_DECL node helps dwarfout.c to know when it needs
1456 to output a representation of a tagged type, and it also gives
1457 us a convenient place to record the "scope start" address for the
1460 TYPE_STUB_DECL (type
) = pushdecl (build_decl (loc
,
1461 TYPE_DECL
, NULL_TREE
, type
));
1463 /* An approximation for now, so we can tell this is a function-scope tag.
1464 This will be updated in pop_scope. */
1465 TYPE_CONTEXT (type
) = DECL_CONTEXT (TYPE_STUB_DECL (type
));
1467 if (warn_cxx_compat
&& name
!= NULL_TREE
)
1469 struct c_binding
*b
= I_SYMBOL_BINDING (name
);
1472 && b
->decl
!= NULL_TREE
1473 && TREE_CODE (b
->decl
) == TYPE_DECL
1474 && (B_IN_CURRENT_SCOPE (b
)
1475 || (current_scope
== file_scope
&& B_IN_EXTERNAL_SCOPE (b
)))
1476 && (TYPE_MAIN_VARIANT (TREE_TYPE (b
->decl
))
1477 != TYPE_MAIN_VARIANT (type
)))
1479 warning_at (loc
, OPT_Wc___compat
,
1480 ("using %qD as both a typedef and a tag is "
1483 if (b
->locus
!= UNKNOWN_LOCATION
)
1484 inform (b
->locus
, "originally defined here");
1489 /* Subroutine of compare_decls. Allow harmless mismatches in return
1490 and argument types provided that the type modes match. This function
1491 return a unified type given a suitable match, and 0 otherwise. */
1494 match_builtin_function_types (tree newtype
, tree oldtype
)
1496 tree newrettype
, oldrettype
;
1497 tree newargs
, oldargs
;
1498 tree trytype
, tryargs
;
1500 /* Accept the return type of the new declaration if same modes. */
1501 oldrettype
= TREE_TYPE (oldtype
);
1502 newrettype
= TREE_TYPE (newtype
);
1504 if (TYPE_MODE (oldrettype
) != TYPE_MODE (newrettype
))
1507 oldargs
= TYPE_ARG_TYPES (oldtype
);
1508 newargs
= TYPE_ARG_TYPES (newtype
);
1511 while (oldargs
|| newargs
)
1515 || !TREE_VALUE (oldargs
)
1516 || !TREE_VALUE (newargs
)
1517 || TYPE_MODE (TREE_VALUE (oldargs
))
1518 != TYPE_MODE (TREE_VALUE (newargs
)))
1521 oldargs
= TREE_CHAIN (oldargs
);
1522 newargs
= TREE_CHAIN (newargs
);
1525 trytype
= build_function_type (newrettype
, tryargs
);
1526 return build_type_attribute_variant (trytype
, TYPE_ATTRIBUTES (oldtype
));
1529 /* Subroutine of diagnose_mismatched_decls. Check for function type
1530 mismatch involving an empty arglist vs a nonempty one and give clearer
1533 diagnose_arglist_conflict (tree newdecl
, tree olddecl
,
1534 tree newtype
, tree oldtype
)
1538 if (TREE_CODE (olddecl
) != FUNCTION_DECL
1539 || !comptypes (TREE_TYPE (oldtype
), TREE_TYPE (newtype
))
1540 || !((!prototype_p (oldtype
) && DECL_INITIAL (olddecl
) == 0)
1541 || (!prototype_p (newtype
) && DECL_INITIAL (newdecl
) == 0)))
1544 t
= TYPE_ARG_TYPES (oldtype
);
1546 t
= TYPE_ARG_TYPES (newtype
);
1547 for (; t
; t
= TREE_CHAIN (t
))
1549 tree type
= TREE_VALUE (t
);
1551 if (TREE_CHAIN (t
) == 0
1552 && TYPE_MAIN_VARIANT (type
) != void_type_node
)
1554 inform (input_location
, "a parameter list with an ellipsis can%'t match "
1555 "an empty parameter name list declaration");
1559 if (c_type_promotes_to (type
) != type
)
1561 inform (input_location
, "an argument type that has a default promotion can%'t match "
1562 "an empty parameter name list declaration");
1568 /* Another subroutine of diagnose_mismatched_decls. OLDDECL is an
1569 old-style function definition, NEWDECL is a prototype declaration.
1570 Diagnose inconsistencies in the argument list. Returns TRUE if
1571 the prototype is compatible, FALSE if not. */
1573 validate_proto_after_old_defn (tree newdecl
, tree newtype
, tree oldtype
)
1575 tree newargs
, oldargs
;
1578 #define END_OF_ARGLIST(t) ((t) == void_type_node)
1580 oldargs
= TYPE_ACTUAL_ARG_TYPES (oldtype
);
1581 newargs
= TYPE_ARG_TYPES (newtype
);
1586 tree oldargtype
= TREE_VALUE (oldargs
);
1587 tree newargtype
= TREE_VALUE (newargs
);
1589 if (oldargtype
== error_mark_node
|| newargtype
== error_mark_node
)
1592 oldargtype
= (TYPE_ATOMIC (oldargtype
)
1593 ? c_build_qualified_type (TYPE_MAIN_VARIANT (oldargtype
),
1595 : TYPE_MAIN_VARIANT (oldargtype
));
1596 newargtype
= (TYPE_ATOMIC (newargtype
)
1597 ? c_build_qualified_type (TYPE_MAIN_VARIANT (newargtype
),
1599 : TYPE_MAIN_VARIANT (newargtype
));
1601 if (END_OF_ARGLIST (oldargtype
) && END_OF_ARGLIST (newargtype
))
1604 /* Reaching the end of just one list means the two decls don't
1605 agree on the number of arguments. */
1606 if (END_OF_ARGLIST (oldargtype
))
1608 error ("prototype for %q+D declares more arguments "
1609 "than previous old-style definition", newdecl
);
1612 else if (END_OF_ARGLIST (newargtype
))
1614 error ("prototype for %q+D declares fewer arguments "
1615 "than previous old-style definition", newdecl
);
1619 /* Type for passing arg must be consistent with that declared
1621 else if (!comptypes (oldargtype
, newargtype
))
1623 error ("prototype for %q+D declares argument %d"
1624 " with incompatible type",
1629 oldargs
= TREE_CHAIN (oldargs
);
1630 newargs
= TREE_CHAIN (newargs
);
1634 /* If we get here, no errors were found, but do issue a warning
1635 for this poor-style construct. */
1636 warning (0, "prototype for %q+D follows non-prototype definition",
1639 #undef END_OF_ARGLIST
1642 /* Subroutine of diagnose_mismatched_decls. Report the location of DECL,
1643 first in a pair of mismatched declarations, using the diagnostic
1646 locate_old_decl (tree decl
)
1648 if (TREE_CODE (decl
) == FUNCTION_DECL
&& DECL_BUILT_IN (decl
)
1649 && !C_DECL_DECLARED_BUILTIN (decl
))
1651 else if (DECL_INITIAL (decl
))
1652 inform (input_location
, "previous definition of %q+D was here", decl
);
1653 else if (C_DECL_IMPLICIT (decl
))
1654 inform (input_location
, "previous implicit declaration of %q+D was here", decl
);
1656 inform (input_location
, "previous declaration of %q+D was here", decl
);
1659 /* Subroutine of duplicate_decls. Compare NEWDECL to OLDDECL.
1660 Returns true if the caller should proceed to merge the two, false
1661 if OLDDECL should simply be discarded. As a side effect, issues
1662 all necessary diagnostics for invalid or poor-style combinations.
1663 If it returns true, writes the types of NEWDECL and OLDDECL to
1664 *NEWTYPEP and *OLDTYPEP - these may have been adjusted from
1665 TREE_TYPE (NEWDECL, OLDDECL) respectively. */
1668 diagnose_mismatched_decls (tree newdecl
, tree olddecl
,
1669 tree
*newtypep
, tree
*oldtypep
)
1671 tree newtype
, oldtype
;
1672 bool pedwarned
= false;
1673 bool warned
= false;
1676 #define DECL_EXTERN_INLINE(DECL) (DECL_DECLARED_INLINE_P (DECL) \
1677 && DECL_EXTERNAL (DECL))
1679 /* If we have error_mark_node for either decl or type, just discard
1680 the previous decl - we're in an error cascade already. */
1681 if (olddecl
== error_mark_node
|| newdecl
== error_mark_node
)
1683 *oldtypep
= oldtype
= TREE_TYPE (olddecl
);
1684 *newtypep
= newtype
= TREE_TYPE (newdecl
);
1685 if (oldtype
== error_mark_node
|| newtype
== error_mark_node
)
1688 /* Two different categories of symbol altogether. This is an error
1689 unless OLDDECL is a builtin. OLDDECL will be discarded in any case. */
1690 if (TREE_CODE (olddecl
) != TREE_CODE (newdecl
))
1692 if (!(TREE_CODE (olddecl
) == FUNCTION_DECL
1693 && DECL_BUILT_IN (olddecl
)
1694 && !C_DECL_DECLARED_BUILTIN (olddecl
)))
1696 error ("%q+D redeclared as different kind of symbol", newdecl
);
1697 locate_old_decl (olddecl
);
1699 else if (TREE_PUBLIC (newdecl
))
1700 warning (0, "built-in function %q+D declared as non-function",
1703 warning (OPT_Wshadow
, "declaration of %q+D shadows "
1704 "a built-in function", newdecl
);
1708 /* Enumerators have no linkage, so may only be declared once in a
1710 if (TREE_CODE (olddecl
) == CONST_DECL
)
1712 error ("redeclaration of enumerator %q+D", newdecl
);
1713 locate_old_decl (olddecl
);
1717 if (!comptypes (oldtype
, newtype
))
1719 if (TREE_CODE (olddecl
) == FUNCTION_DECL
1720 && DECL_BUILT_IN (olddecl
) && !C_DECL_DECLARED_BUILTIN (olddecl
))
1722 /* Accept harmless mismatch in function types.
1723 This is for the ffs and fprintf builtins. */
1724 tree trytype
= match_builtin_function_types (newtype
, oldtype
);
1726 if (trytype
&& comptypes (newtype
, trytype
))
1727 *oldtypep
= oldtype
= trytype
;
1730 /* If types don't match for a built-in, throw away the
1731 built-in. No point in calling locate_old_decl here, it
1732 won't print anything. */
1733 warning (0, "conflicting types for built-in function %q+D",
1738 else if (TREE_CODE (olddecl
) == FUNCTION_DECL
1739 && DECL_IS_BUILTIN (olddecl
))
1741 /* A conflicting function declaration for a predeclared
1742 function that isn't actually built in. Objective C uses
1743 these. The new declaration silently overrides everything
1744 but the volatility (i.e. noreturn) indication. See also
1745 below. FIXME: Make Objective C use normal builtins. */
1746 TREE_THIS_VOLATILE (newdecl
) |= TREE_THIS_VOLATILE (olddecl
);
1749 /* Permit void foo (...) to match int foo (...) if the latter is
1750 the definition and implicit int was used. See
1751 c-torture/compile/920625-2.c. */
1752 else if (TREE_CODE (newdecl
) == FUNCTION_DECL
&& DECL_INITIAL (newdecl
)
1753 && TYPE_MAIN_VARIANT (TREE_TYPE (oldtype
)) == void_type_node
1754 && TYPE_MAIN_VARIANT (TREE_TYPE (newtype
)) == integer_type_node
1755 && C_FUNCTION_IMPLICIT_INT (newdecl
) && !DECL_INITIAL (olddecl
))
1757 pedwarned
= pedwarn (input_location
, 0,
1758 "conflicting types for %q+D", newdecl
);
1759 /* Make sure we keep void as the return type. */
1760 TREE_TYPE (newdecl
) = *newtypep
= newtype
= oldtype
;
1761 C_FUNCTION_IMPLICIT_INT (newdecl
) = 0;
1763 /* Permit void foo (...) to match an earlier call to foo (...) with
1764 no declared type (thus, implicitly int). */
1765 else if (TREE_CODE (newdecl
) == FUNCTION_DECL
1766 && TYPE_MAIN_VARIANT (TREE_TYPE (newtype
)) == void_type_node
1767 && TYPE_MAIN_VARIANT (TREE_TYPE (oldtype
)) == integer_type_node
1768 && C_DECL_IMPLICIT (olddecl
) && !DECL_INITIAL (olddecl
))
1770 pedwarned
= pedwarn (input_location
, 0,
1771 "conflicting types for %q+D", newdecl
);
1772 /* Make sure we keep void as the return type. */
1773 TREE_TYPE (olddecl
) = *oldtypep
= oldtype
= newtype
;
1777 int new_quals
= TYPE_QUALS (newtype
);
1778 int old_quals
= TYPE_QUALS (oldtype
);
1780 if (new_quals
!= old_quals
)
1782 addr_space_t new_addr
= DECODE_QUAL_ADDR_SPACE (new_quals
);
1783 addr_space_t old_addr
= DECODE_QUAL_ADDR_SPACE (old_quals
);
1784 if (new_addr
!= old_addr
)
1786 if (ADDR_SPACE_GENERIC_P (new_addr
))
1787 error ("conflicting named address spaces (generic vs %s) "
1789 c_addr_space_name (old_addr
), newdecl
);
1790 else if (ADDR_SPACE_GENERIC_P (old_addr
))
1791 error ("conflicting named address spaces (%s vs generic) "
1793 c_addr_space_name (new_addr
), newdecl
);
1795 error ("conflicting named address spaces (%s vs %s) "
1797 c_addr_space_name (new_addr
),
1798 c_addr_space_name (old_addr
),
1802 if (CLEAR_QUAL_ADDR_SPACE (new_quals
)
1803 != CLEAR_QUAL_ADDR_SPACE (old_quals
))
1804 error ("conflicting type qualifiers for %q+D", newdecl
);
1807 error ("conflicting types for %q+D", newdecl
);
1808 diagnose_arglist_conflict (newdecl
, olddecl
, newtype
, oldtype
);
1809 locate_old_decl (olddecl
);
1814 /* Redeclaration of a type is a constraint violation (6.7.2.3p1),
1815 but silently ignore the redeclaration if either is in a system
1816 header. (Conflicting redeclarations were handled above.) This
1817 is allowed for C11 if the types are the same, not just
1819 if (TREE_CODE (newdecl
) == TYPE_DECL
)
1821 bool types_different
= false;
1822 int comptypes_result
;
1825 = comptypes_check_different_types (oldtype
, newtype
, &types_different
);
1827 if (comptypes_result
!= 1 || types_different
)
1829 error ("redefinition of typedef %q+D with different type", newdecl
);
1830 locate_old_decl (olddecl
);
1834 if (DECL_IN_SYSTEM_HEADER (newdecl
)
1835 || DECL_IN_SYSTEM_HEADER (olddecl
)
1836 || TREE_NO_WARNING (newdecl
)
1837 || TREE_NO_WARNING (olddecl
))
1838 return true; /* Allow OLDDECL to continue in use. */
1840 if (variably_modified_type_p (newtype
, NULL
))
1842 error ("redefinition of typedef %q+D with variably modified type",
1844 locate_old_decl (olddecl
);
1846 else if (pedantic
&& !flag_isoc11
)
1848 pedwarn (input_location
, OPT_Wpedantic
,
1849 "redefinition of typedef %q+D", newdecl
);
1850 locate_old_decl (olddecl
);
1856 /* Function declarations can either be 'static' or 'extern' (no
1857 qualifier is equivalent to 'extern' - C99 6.2.2p5) and therefore
1858 can never conflict with each other on account of linkage
1859 (6.2.2p4). Multiple definitions are not allowed (6.9p3,5) but
1860 gnu89 mode permits two definitions if one is 'extern inline' and
1861 one is not. The non- extern-inline definition supersedes the
1862 extern-inline definition. */
1864 else if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
1866 /* If you declare a built-in function name as static, or
1867 define the built-in with an old-style definition (so we
1868 can't validate the argument list) the built-in definition is
1869 overridden, but optionally warn this was a bad choice of name. */
1870 if (DECL_BUILT_IN (olddecl
)
1871 && !C_DECL_DECLARED_BUILTIN (olddecl
)
1872 && (!TREE_PUBLIC (newdecl
)
1873 || (DECL_INITIAL (newdecl
)
1874 && !prototype_p (TREE_TYPE (newdecl
)))))
1876 warning (OPT_Wshadow
, "declaration of %q+D shadows "
1877 "a built-in function", newdecl
);
1878 /* Discard the old built-in function. */
1882 if (DECL_INITIAL (newdecl
))
1884 if (DECL_INITIAL (olddecl
))
1886 /* If both decls are in the same TU and the new declaration
1887 isn't overriding an extern inline reject the new decl.
1888 In c99, no overriding is allowed in the same translation
1890 if ((!DECL_EXTERN_INLINE (olddecl
)
1891 || DECL_EXTERN_INLINE (newdecl
)
1892 || (!flag_gnu89_inline
1893 && (!DECL_DECLARED_INLINE_P (olddecl
)
1894 || !lookup_attribute ("gnu_inline",
1895 DECL_ATTRIBUTES (olddecl
)))
1896 && (!DECL_DECLARED_INLINE_P (newdecl
)
1897 || !lookup_attribute ("gnu_inline",
1898 DECL_ATTRIBUTES (newdecl
))))
1900 && same_translation_unit_p (newdecl
, olddecl
))
1902 error ("redefinition of %q+D", newdecl
);
1903 locate_old_decl (olddecl
);
1908 /* If we have a prototype after an old-style function definition,
1909 the argument types must be checked specially. */
1910 else if (DECL_INITIAL (olddecl
)
1911 && !prototype_p (oldtype
) && prototype_p (newtype
)
1912 && TYPE_ACTUAL_ARG_TYPES (oldtype
)
1913 && !validate_proto_after_old_defn (newdecl
, newtype
, oldtype
))
1915 locate_old_decl (olddecl
);
1918 /* A non-static declaration (even an "extern") followed by a
1919 static declaration is undefined behavior per C99 6.2.2p3-5,7.
1920 The same is true for a static forward declaration at block
1921 scope followed by a non-static declaration/definition at file
1922 scope. Static followed by non-static at the same scope is
1923 not undefined behavior, and is the most convenient way to get
1924 some effects (see e.g. what unwind-dw2-fde-glibc.c does to
1925 the definition of _Unwind_Find_FDE in unwind-dw2-fde.c), but
1926 we do diagnose it if -Wtraditional. */
1927 if (TREE_PUBLIC (olddecl
) && !TREE_PUBLIC (newdecl
))
1929 /* Two exceptions to the rule. If olddecl is an extern
1930 inline, or a predeclared function that isn't actually
1931 built in, newdecl silently overrides olddecl. The latter
1932 occur only in Objective C; see also above. (FIXME: Make
1933 Objective C use normal builtins.) */
1934 if (!DECL_IS_BUILTIN (olddecl
)
1935 && !DECL_EXTERN_INLINE (olddecl
))
1937 error ("static declaration of %q+D follows "
1938 "non-static declaration", newdecl
);
1939 locate_old_decl (olddecl
);
1943 else if (TREE_PUBLIC (newdecl
) && !TREE_PUBLIC (olddecl
))
1945 if (DECL_CONTEXT (olddecl
))
1947 error ("non-static declaration of %q+D follows "
1948 "static declaration", newdecl
);
1949 locate_old_decl (olddecl
);
1952 else if (warn_traditional
)
1954 warned
|= warning (OPT_Wtraditional
,
1955 "non-static declaration of %q+D "
1956 "follows static declaration", newdecl
);
1960 /* Make sure gnu_inline attribute is either not present, or
1961 present on all inline decls. */
1962 if (DECL_DECLARED_INLINE_P (olddecl
)
1963 && DECL_DECLARED_INLINE_P (newdecl
))
1965 bool newa
= lookup_attribute ("gnu_inline",
1966 DECL_ATTRIBUTES (newdecl
)) != NULL
;
1967 bool olda
= lookup_attribute ("gnu_inline",
1968 DECL_ATTRIBUTES (olddecl
)) != NULL
;
1971 error_at (input_location
, "%<gnu_inline%> attribute present on %q+D",
1972 newa
? newdecl
: olddecl
);
1973 error_at (DECL_SOURCE_LOCATION (newa
? olddecl
: newdecl
),
1978 else if (TREE_CODE (newdecl
) == VAR_DECL
)
1980 /* Only variables can be thread-local, and all declarations must
1981 agree on this property. */
1982 if (C_DECL_THREADPRIVATE_P (olddecl
) && !DECL_THREAD_LOCAL_P (newdecl
))
1984 /* Nothing to check. Since OLDDECL is marked threadprivate
1985 and NEWDECL does not have a thread-local attribute, we
1986 will merge the threadprivate attribute into NEWDECL. */
1989 else if (DECL_THREAD_LOCAL_P (newdecl
) != DECL_THREAD_LOCAL_P (olddecl
))
1991 if (DECL_THREAD_LOCAL_P (newdecl
))
1992 error ("thread-local declaration of %q+D follows "
1993 "non-thread-local declaration", newdecl
);
1995 error ("non-thread-local declaration of %q+D follows "
1996 "thread-local declaration", newdecl
);
1998 locate_old_decl (olddecl
);
2002 /* Multiple initialized definitions are not allowed (6.9p3,5). */
2003 if (DECL_INITIAL (newdecl
) && DECL_INITIAL (olddecl
))
2005 error ("redefinition of %q+D", newdecl
);
2006 locate_old_decl (olddecl
);
2010 /* Objects declared at file scope: if the first declaration had
2011 external linkage (even if it was an external reference) the
2012 second must have external linkage as well, or the behavior is
2013 undefined. If the first declaration had internal linkage, then
2014 the second must too, or else be an external reference (in which
2015 case the composite declaration still has internal linkage).
2016 As for function declarations, we warn about the static-then-
2017 extern case only for -Wtraditional. See generally 6.2.2p3-5,7. */
2018 if (DECL_FILE_SCOPE_P (newdecl
)
2019 && TREE_PUBLIC (newdecl
) != TREE_PUBLIC (olddecl
))
2021 if (DECL_EXTERNAL (newdecl
))
2023 if (!DECL_FILE_SCOPE_P (olddecl
))
2025 error ("extern declaration of %q+D follows "
2026 "declaration with no linkage", newdecl
);
2027 locate_old_decl (olddecl
);
2030 else if (warn_traditional
)
2032 warned
|= warning (OPT_Wtraditional
,
2033 "non-static declaration of %q+D "
2034 "follows static declaration", newdecl
);
2039 if (TREE_PUBLIC (newdecl
))
2040 error ("non-static declaration of %q+D follows "
2041 "static declaration", newdecl
);
2043 error ("static declaration of %q+D follows "
2044 "non-static declaration", newdecl
);
2046 locate_old_decl (olddecl
);
2050 /* Two objects with the same name declared at the same block
2051 scope must both be external references (6.7p3). */
2052 else if (!DECL_FILE_SCOPE_P (newdecl
))
2054 if (DECL_EXTERNAL (newdecl
))
2056 /* Extern with initializer at block scope, which will
2057 already have received an error. */
2059 else if (DECL_EXTERNAL (olddecl
))
2061 error ("declaration of %q+D with no linkage follows "
2062 "extern declaration", newdecl
);
2063 locate_old_decl (olddecl
);
2067 error ("redeclaration of %q+D with no linkage", newdecl
);
2068 locate_old_decl (olddecl
);
2074 /* C++ does not permit a decl to appear multiple times at file
2077 && DECL_FILE_SCOPE_P (newdecl
)
2078 && !DECL_EXTERNAL (newdecl
)
2079 && !DECL_EXTERNAL (olddecl
))
2080 warned
|= warning_at (DECL_SOURCE_LOCATION (newdecl
),
2082 ("duplicate declaration of %qD is "
2088 /* All decls must agree on a visibility. */
2089 if (CODE_CONTAINS_STRUCT (TREE_CODE (newdecl
), TS_DECL_WITH_VIS
)
2090 && DECL_VISIBILITY_SPECIFIED (newdecl
) && DECL_VISIBILITY_SPECIFIED (olddecl
)
2091 && DECL_VISIBILITY (newdecl
) != DECL_VISIBILITY (olddecl
))
2093 warned
|= warning (0, "redeclaration of %q+D with different visibility "
2094 "(old visibility preserved)", newdecl
);
2097 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
2099 /* Diagnose inline __attribute__ ((noinline)) which is silly. */
2100 if (DECL_DECLARED_INLINE_P (newdecl
)
2101 && lookup_attribute ("noinline", DECL_ATTRIBUTES (olddecl
)))
2103 warned
|= warning (OPT_Wattributes
,
2104 "inline declaration of %qD follows "
2105 "declaration with attribute noinline", newdecl
);
2107 else if (DECL_DECLARED_INLINE_P (olddecl
)
2108 && lookup_attribute ("noinline", DECL_ATTRIBUTES (newdecl
)))
2110 warned
|= warning (OPT_Wattributes
,
2111 "declaration of %q+D with attribute "
2112 "noinline follows inline declaration ", newdecl
);
2115 else /* PARM_DECL, VAR_DECL */
2117 /* Redeclaration of a parameter is a constraint violation (this is
2118 not explicitly stated, but follows from C99 6.7p3 [no more than
2119 one declaration of the same identifier with no linkage in the
2120 same scope, except type tags] and 6.2.2p6 [parameters have no
2121 linkage]). We must check for a forward parameter declaration,
2122 indicated by TREE_ASM_WRITTEN on the old declaration - this is
2123 an extension, the mandatory diagnostic for which is handled by
2124 mark_forward_parm_decls. */
2126 if (TREE_CODE (newdecl
) == PARM_DECL
2127 && (!TREE_ASM_WRITTEN (olddecl
) || TREE_ASM_WRITTEN (newdecl
)))
2129 error ("redefinition of parameter %q+D", newdecl
);
2130 locate_old_decl (olddecl
);
2135 /* Optional warning for completely redundant decls. */
2136 if (!warned
&& !pedwarned
2137 && warn_redundant_decls
2138 /* Don't warn about a function declaration followed by a
2140 && !(TREE_CODE (newdecl
) == FUNCTION_DECL
2141 && DECL_INITIAL (newdecl
) && !DECL_INITIAL (olddecl
))
2142 /* Don't warn about redundant redeclarations of builtins. */
2143 && !(TREE_CODE (newdecl
) == FUNCTION_DECL
2144 && !DECL_BUILT_IN (newdecl
)
2145 && DECL_BUILT_IN (olddecl
)
2146 && !C_DECL_DECLARED_BUILTIN (olddecl
))
2147 /* Don't warn about an extern followed by a definition. */
2148 && !(DECL_EXTERNAL (olddecl
) && !DECL_EXTERNAL (newdecl
))
2149 /* Don't warn about forward parameter decls. */
2150 && !(TREE_CODE (newdecl
) == PARM_DECL
2151 && TREE_ASM_WRITTEN (olddecl
) && !TREE_ASM_WRITTEN (newdecl
))
2152 /* Don't warn about a variable definition following a declaration. */
2153 && !(TREE_CODE (newdecl
) == VAR_DECL
2154 && DECL_INITIAL (newdecl
) && !DECL_INITIAL (olddecl
)))
2156 warned
= warning (OPT_Wredundant_decls
, "redundant redeclaration of %q+D",
2160 /* Report location of previous decl/defn. */
2161 if (warned
|| pedwarned
)
2162 locate_old_decl (olddecl
);
2164 #undef DECL_EXTERN_INLINE
2169 /* Subroutine of duplicate_decls. NEWDECL has been found to be
2170 consistent with OLDDECL, but carries new information. Merge the
2171 new information into OLDDECL. This function issues no
2175 merge_decls (tree newdecl
, tree olddecl
, tree newtype
, tree oldtype
)
2177 bool new_is_definition
= (TREE_CODE (newdecl
) == FUNCTION_DECL
2178 && DECL_INITIAL (newdecl
) != 0);
2179 bool new_is_prototype
= (TREE_CODE (newdecl
) == FUNCTION_DECL
2180 && prototype_p (TREE_TYPE (newdecl
)));
2181 bool old_is_prototype
= (TREE_CODE (olddecl
) == FUNCTION_DECL
2182 && prototype_p (TREE_TYPE (olddecl
)));
2184 /* For real parm decl following a forward decl, rechain the old decl
2185 in its new location and clear TREE_ASM_WRITTEN (it's not a
2186 forward decl anymore). */
2187 if (TREE_CODE (newdecl
) == PARM_DECL
2188 && TREE_ASM_WRITTEN (olddecl
) && !TREE_ASM_WRITTEN (newdecl
))
2190 struct c_binding
*b
, **here
;
2192 for (here
= ¤t_scope
->bindings
; *here
; here
= &(*here
)->prev
)
2193 if ((*here
)->decl
== olddecl
)
2200 b
->prev
= current_scope
->bindings
;
2201 current_scope
->bindings
= b
;
2203 TREE_ASM_WRITTEN (olddecl
) = 0;
2206 DECL_ATTRIBUTES (newdecl
)
2207 = targetm
.merge_decl_attributes (olddecl
, newdecl
);
2209 /* Merge the data types specified in the two decls. */
2211 = TREE_TYPE (olddecl
)
2212 = composite_type (newtype
, oldtype
);
2214 /* Lay the type out, unless already done. */
2215 if (!comptypes (oldtype
, TREE_TYPE (newdecl
)))
2217 if (TREE_TYPE (newdecl
) != error_mark_node
)
2218 layout_type (TREE_TYPE (newdecl
));
2219 if (TREE_CODE (newdecl
) != FUNCTION_DECL
2220 && TREE_CODE (newdecl
) != TYPE_DECL
2221 && TREE_CODE (newdecl
) != CONST_DECL
)
2222 layout_decl (newdecl
, 0);
2226 /* Since the type is OLDDECL's, make OLDDECL's size go with. */
2227 DECL_SIZE (newdecl
) = DECL_SIZE (olddecl
);
2228 DECL_SIZE_UNIT (newdecl
) = DECL_SIZE_UNIT (olddecl
);
2229 DECL_MODE (newdecl
) = DECL_MODE (olddecl
);
2230 if (DECL_ALIGN (olddecl
) > DECL_ALIGN (newdecl
))
2232 DECL_ALIGN (newdecl
) = DECL_ALIGN (olddecl
);
2233 DECL_USER_ALIGN (newdecl
) |= DECL_USER_ALIGN (olddecl
);
2237 /* Keep the old rtl since we can safely use it. */
2238 if (HAS_RTL_P (olddecl
))
2239 COPY_DECL_RTL (olddecl
, newdecl
);
2241 /* Merge the type qualifiers. */
2242 if (TREE_READONLY (newdecl
))
2243 TREE_READONLY (olddecl
) = 1;
2245 if (TREE_THIS_VOLATILE (newdecl
))
2246 TREE_THIS_VOLATILE (olddecl
) = 1;
2248 /* Merge deprecatedness. */
2249 if (TREE_DEPRECATED (newdecl
))
2250 TREE_DEPRECATED (olddecl
) = 1;
2252 /* If a decl is in a system header and the other isn't, keep the one on the
2253 system header. Otherwise, keep source location of definition rather than
2254 declaration and of prototype rather than non-prototype unless that
2255 prototype is built-in. */
2256 if (CODE_CONTAINS_STRUCT (TREE_CODE (olddecl
), TS_DECL_WITH_VIS
)
2257 && DECL_IN_SYSTEM_HEADER (olddecl
)
2258 && !DECL_IN_SYSTEM_HEADER (newdecl
) )
2259 DECL_SOURCE_LOCATION (newdecl
) = DECL_SOURCE_LOCATION (olddecl
);
2260 else if (CODE_CONTAINS_STRUCT (TREE_CODE (olddecl
), TS_DECL_WITH_VIS
)
2261 && DECL_IN_SYSTEM_HEADER (newdecl
)
2262 && !DECL_IN_SYSTEM_HEADER (olddecl
))
2263 DECL_SOURCE_LOCATION (olddecl
) = DECL_SOURCE_LOCATION (newdecl
);
2264 else if ((DECL_INITIAL (newdecl
) == 0 && DECL_INITIAL (olddecl
) != 0)
2265 || (old_is_prototype
&& !new_is_prototype
2266 && !C_DECL_BUILTIN_PROTOTYPE (olddecl
)))
2267 DECL_SOURCE_LOCATION (newdecl
) = DECL_SOURCE_LOCATION (olddecl
);
2269 /* Merge the initialization information. */
2270 if (DECL_INITIAL (newdecl
) == 0)
2271 DECL_INITIAL (newdecl
) = DECL_INITIAL (olddecl
);
2273 /* Merge the threadprivate attribute. */
2274 if (TREE_CODE (olddecl
) == VAR_DECL
&& C_DECL_THREADPRIVATE_P (olddecl
))
2276 DECL_TLS_MODEL (newdecl
) = DECL_TLS_MODEL (olddecl
);
2277 C_DECL_THREADPRIVATE_P (newdecl
) = 1;
2280 if (CODE_CONTAINS_STRUCT (TREE_CODE (olddecl
), TS_DECL_WITH_VIS
))
2282 /* Merge the section attribute.
2283 We want to issue an error if the sections conflict but that
2284 must be done later in decl_attributes since we are called
2285 before attributes are assigned. */
2286 if (DECL_SECTION_NAME (newdecl
) == NULL_TREE
)
2287 DECL_SECTION_NAME (newdecl
) = DECL_SECTION_NAME (olddecl
);
2289 /* Copy the assembler name.
2290 Currently, it can only be defined in the prototype. */
2291 COPY_DECL_ASSEMBLER_NAME (olddecl
, newdecl
);
2293 /* Use visibility of whichever declaration had it specified */
2294 if (DECL_VISIBILITY_SPECIFIED (olddecl
))
2296 DECL_VISIBILITY (newdecl
) = DECL_VISIBILITY (olddecl
);
2297 DECL_VISIBILITY_SPECIFIED (newdecl
) = 1;
2300 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
2302 DECL_STATIC_CONSTRUCTOR(newdecl
) |= DECL_STATIC_CONSTRUCTOR(olddecl
);
2303 DECL_STATIC_DESTRUCTOR (newdecl
) |= DECL_STATIC_DESTRUCTOR (olddecl
);
2304 DECL_NO_LIMIT_STACK (newdecl
) |= DECL_NO_LIMIT_STACK (olddecl
);
2305 DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (newdecl
)
2306 |= DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (olddecl
);
2307 TREE_THIS_VOLATILE (newdecl
) |= TREE_THIS_VOLATILE (olddecl
);
2308 DECL_IS_MALLOC (newdecl
) |= DECL_IS_MALLOC (olddecl
);
2309 DECL_IS_OPERATOR_NEW (newdecl
) |= DECL_IS_OPERATOR_NEW (olddecl
);
2310 TREE_READONLY (newdecl
) |= TREE_READONLY (olddecl
);
2311 DECL_PURE_P (newdecl
) |= DECL_PURE_P (olddecl
);
2312 DECL_IS_NOVOPS (newdecl
) |= DECL_IS_NOVOPS (olddecl
);
2315 /* Merge the storage class information. */
2316 merge_weak (newdecl
, olddecl
);
2318 /* For functions, static overrides non-static. */
2319 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
2321 TREE_PUBLIC (newdecl
) &= TREE_PUBLIC (olddecl
);
2322 /* This is since we don't automatically
2323 copy the attributes of NEWDECL into OLDDECL. */
2324 TREE_PUBLIC (olddecl
) = TREE_PUBLIC (newdecl
);
2325 /* If this clears `static', clear it in the identifier too. */
2326 if (!TREE_PUBLIC (olddecl
))
2327 TREE_PUBLIC (DECL_NAME (olddecl
)) = 0;
2331 /* In c99, 'extern' declaration before (or after) 'inline' means this
2332 function is not DECL_EXTERNAL, unless 'gnu_inline' attribute
2334 if (TREE_CODE (newdecl
) == FUNCTION_DECL
2335 && !flag_gnu89_inline
2336 && (DECL_DECLARED_INLINE_P (newdecl
)
2337 || DECL_DECLARED_INLINE_P (olddecl
))
2338 && (!DECL_DECLARED_INLINE_P (newdecl
)
2339 || !DECL_DECLARED_INLINE_P (olddecl
)
2340 || !DECL_EXTERNAL (olddecl
))
2341 && DECL_EXTERNAL (newdecl
)
2342 && !lookup_attribute ("gnu_inline", DECL_ATTRIBUTES (newdecl
))
2343 && !current_function_decl
)
2344 DECL_EXTERNAL (newdecl
) = 0;
2346 /* An inline definition following a static declaration is not
2348 if (new_is_definition
2349 && (DECL_DECLARED_INLINE_P (newdecl
)
2350 || DECL_DECLARED_INLINE_P (olddecl
))
2351 && !TREE_PUBLIC (olddecl
))
2352 DECL_EXTERNAL (newdecl
) = 0;
2354 if (DECL_EXTERNAL (newdecl
))
2356 TREE_STATIC (newdecl
) = TREE_STATIC (olddecl
);
2357 DECL_EXTERNAL (newdecl
) = DECL_EXTERNAL (olddecl
);
2359 /* An extern decl does not override previous storage class. */
2360 TREE_PUBLIC (newdecl
) = TREE_PUBLIC (olddecl
);
2361 if (!DECL_EXTERNAL (newdecl
))
2363 DECL_CONTEXT (newdecl
) = DECL_CONTEXT (olddecl
);
2364 DECL_COMMON (newdecl
) = DECL_COMMON (olddecl
);
2369 TREE_STATIC (olddecl
) = TREE_STATIC (newdecl
);
2370 TREE_PUBLIC (olddecl
) = TREE_PUBLIC (newdecl
);
2373 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
2375 /* If we're redefining a function previously defined as extern
2376 inline, make sure we emit debug info for the inline before we
2377 throw it away, in case it was inlined into a function that
2378 hasn't been written out yet. */
2379 if (new_is_definition
&& DECL_INITIAL (olddecl
))
2380 /* The new defn must not be inline. */
2381 DECL_UNINLINABLE (newdecl
) = 1;
2384 /* If either decl says `inline', this fn is inline, unless
2385 its definition was passed already. */
2386 if (DECL_DECLARED_INLINE_P (newdecl
)
2387 || DECL_DECLARED_INLINE_P (olddecl
))
2388 DECL_DECLARED_INLINE_P (newdecl
) = 1;
2390 DECL_UNINLINABLE (newdecl
) = DECL_UNINLINABLE (olddecl
)
2391 = (DECL_UNINLINABLE (newdecl
) || DECL_UNINLINABLE (olddecl
));
2393 DECL_DISREGARD_INLINE_LIMITS (newdecl
)
2394 = DECL_DISREGARD_INLINE_LIMITS (olddecl
)
2395 = (DECL_DISREGARD_INLINE_LIMITS (newdecl
)
2396 || DECL_DISREGARD_INLINE_LIMITS (olddecl
));
2399 if (DECL_BUILT_IN (olddecl
))
2401 /* If redeclaring a builtin function, it stays built in.
2402 But it gets tagged as having been declared. */
2403 DECL_BUILT_IN_CLASS (newdecl
) = DECL_BUILT_IN_CLASS (olddecl
);
2404 DECL_FUNCTION_CODE (newdecl
) = DECL_FUNCTION_CODE (olddecl
);
2405 C_DECL_DECLARED_BUILTIN (newdecl
) = 1;
2406 if (new_is_prototype
)
2408 C_DECL_BUILTIN_PROTOTYPE (newdecl
) = 0;
2409 if (DECL_BUILT_IN_CLASS (newdecl
) == BUILT_IN_NORMAL
)
2411 enum built_in_function fncode
= DECL_FUNCTION_CODE (newdecl
);
2414 /* If a compatible prototype of these builtin functions
2415 is seen, assume the runtime implements it with the
2416 expected semantics. */
2417 case BUILT_IN_STPCPY
:
2418 if (builtin_decl_explicit_p (fncode
))
2419 set_builtin_decl_implicit_p (fncode
, true);
2427 C_DECL_BUILTIN_PROTOTYPE (newdecl
)
2428 = C_DECL_BUILTIN_PROTOTYPE (olddecl
);
2431 /* Preserve function specific target and optimization options */
2432 if (DECL_FUNCTION_SPECIFIC_TARGET (olddecl
)
2433 && !DECL_FUNCTION_SPECIFIC_TARGET (newdecl
))
2434 DECL_FUNCTION_SPECIFIC_TARGET (newdecl
)
2435 = DECL_FUNCTION_SPECIFIC_TARGET (olddecl
);
2437 if (DECL_FUNCTION_SPECIFIC_OPTIMIZATION (olddecl
)
2438 && !DECL_FUNCTION_SPECIFIC_OPTIMIZATION (newdecl
))
2439 DECL_FUNCTION_SPECIFIC_OPTIMIZATION (newdecl
)
2440 = DECL_FUNCTION_SPECIFIC_OPTIMIZATION (olddecl
);
2442 /* Also preserve various other info from the definition. */
2443 if (!new_is_definition
)
2446 DECL_RESULT (newdecl
) = DECL_RESULT (olddecl
);
2447 DECL_INITIAL (newdecl
) = DECL_INITIAL (olddecl
);
2448 DECL_STRUCT_FUNCTION (newdecl
) = DECL_STRUCT_FUNCTION (olddecl
);
2449 DECL_SAVED_TREE (newdecl
) = DECL_SAVED_TREE (olddecl
);
2450 DECL_ARGUMENTS (newdecl
) = copy_list (DECL_ARGUMENTS (olddecl
));
2451 for (t
= DECL_ARGUMENTS (newdecl
); t
; t
= DECL_CHAIN (t
))
2452 DECL_CONTEXT (t
) = newdecl
;
2454 /* See if we've got a function to instantiate from. */
2455 if (DECL_SAVED_TREE (olddecl
))
2456 DECL_ABSTRACT_ORIGIN (newdecl
)
2457 = DECL_ABSTRACT_ORIGIN (olddecl
);
2461 /* Merge the USED information. */
2462 if (TREE_USED (olddecl
))
2463 TREE_USED (newdecl
) = 1;
2464 else if (TREE_USED (newdecl
))
2465 TREE_USED (olddecl
) = 1;
2466 if (TREE_CODE (olddecl
) == VAR_DECL
|| TREE_CODE (olddecl
) == PARM_DECL
)
2467 DECL_READ_P (newdecl
) |= DECL_READ_P (olddecl
);
2468 if (DECL_PRESERVE_P (olddecl
))
2469 DECL_PRESERVE_P (newdecl
) = 1;
2470 else if (DECL_PRESERVE_P (newdecl
))
2471 DECL_PRESERVE_P (olddecl
) = 1;
2473 /* Copy most of the decl-specific fields of NEWDECL into OLDDECL.
2474 But preserve OLDDECL's DECL_UID, DECL_CONTEXT and
2475 DECL_ARGUMENTS (if appropriate). */
2477 unsigned olddecl_uid
= DECL_UID (olddecl
);
2478 tree olddecl_context
= DECL_CONTEXT (olddecl
);
2479 tree olddecl_arguments
= NULL
;
2480 if (TREE_CODE (olddecl
) == FUNCTION_DECL
)
2481 olddecl_arguments
= DECL_ARGUMENTS (olddecl
);
2483 memcpy ((char *) olddecl
+ sizeof (struct tree_common
),
2484 (char *) newdecl
+ sizeof (struct tree_common
),
2485 sizeof (struct tree_decl_common
) - sizeof (struct tree_common
));
2486 DECL_USER_ALIGN (olddecl
) = DECL_USER_ALIGN (newdecl
);
2487 switch (TREE_CODE (olddecl
))
2497 memcpy ((char *) olddecl
+ sizeof (struct tree_decl_common
),
2498 (char *) newdecl
+ sizeof (struct tree_decl_common
),
2499 tree_code_size (TREE_CODE (olddecl
)) - sizeof (struct tree_decl_common
));
2504 memcpy ((char *) olddecl
+ sizeof (struct tree_decl_common
),
2505 (char *) newdecl
+ sizeof (struct tree_decl_common
),
2506 sizeof (struct tree_decl_non_common
) - sizeof (struct tree_decl_common
));
2508 DECL_UID (olddecl
) = olddecl_uid
;
2509 DECL_CONTEXT (olddecl
) = olddecl_context
;
2510 if (TREE_CODE (olddecl
) == FUNCTION_DECL
)
2511 DECL_ARGUMENTS (olddecl
) = olddecl_arguments
;
2514 /* If OLDDECL had its DECL_RTL instantiated, re-invoke make_decl_rtl
2515 so that encode_section_info has a chance to look at the new decl
2516 flags and attributes. */
2517 if (DECL_RTL_SET_P (olddecl
)
2518 && (TREE_CODE (olddecl
) == FUNCTION_DECL
2519 || (TREE_CODE (olddecl
) == VAR_DECL
2520 && TREE_STATIC (olddecl
))))
2521 make_decl_rtl (olddecl
);
2524 /* Handle when a new declaration NEWDECL has the same name as an old
2525 one OLDDECL in the same binding contour. Prints an error message
2528 If safely possible, alter OLDDECL to look like NEWDECL, and return
2529 true. Otherwise, return false. */
2532 duplicate_decls (tree newdecl
, tree olddecl
)
2534 tree newtype
= NULL
, oldtype
= NULL
;
2536 if (!diagnose_mismatched_decls (newdecl
, olddecl
, &newtype
, &oldtype
))
2538 /* Avoid `unused variable' and other warnings for OLDDECL. */
2539 TREE_NO_WARNING (olddecl
) = 1;
2543 merge_decls (newdecl
, olddecl
, newtype
, oldtype
);
2548 /* Check whether decl-node NEW_DECL shadows an existing declaration. */
2550 warn_if_shadowing (tree new_decl
)
2552 struct c_binding
*b
;
2554 /* Shadow warnings wanted? */
2556 /* No shadow warnings for internally generated vars. */
2557 || DECL_IS_BUILTIN (new_decl
)
2558 /* No shadow warnings for vars made for inlining. */
2559 || DECL_FROM_INLINE (new_decl
))
2562 /* Is anything being shadowed? Invisible decls do not count. */
2563 for (b
= I_SYMBOL_BINDING (DECL_NAME (new_decl
)); b
; b
= b
->shadowed
)
2564 if (b
->decl
&& b
->decl
!= new_decl
&& !b
->invisible
2565 && (b
->decl
== error_mark_node
2566 || diagnostic_report_warnings_p (global_dc
,
2567 DECL_SOURCE_LOCATION (b
->decl
))))
2569 tree old_decl
= b
->decl
;
2571 if (old_decl
== error_mark_node
)
2573 warning (OPT_Wshadow
, "declaration of %q+D shadows previous "
2574 "non-variable", new_decl
);
2577 else if (TREE_CODE (old_decl
) == PARM_DECL
)
2578 warning (OPT_Wshadow
, "declaration of %q+D shadows a parameter",
2580 else if (DECL_FILE_SCOPE_P (old_decl
))
2582 /* Do not warn if a variable shadows a function, unless
2583 the variable is a function or a pointer-to-function. */
2584 if (TREE_CODE (old_decl
) == FUNCTION_DECL
2585 && TREE_CODE (new_decl
) != FUNCTION_DECL
2586 && !FUNCTION_POINTER_TYPE_P (TREE_TYPE (new_decl
)))
2589 warning_at (DECL_SOURCE_LOCATION (new_decl
), OPT_Wshadow
,
2590 "declaration of %qD shadows a global declaration",
2593 else if (TREE_CODE (old_decl
) == FUNCTION_DECL
2594 && DECL_BUILT_IN (old_decl
))
2596 warning (OPT_Wshadow
, "declaration of %q+D shadows "
2597 "a built-in function", new_decl
);
2601 warning (OPT_Wshadow
, "declaration of %q+D shadows a previous local",
2604 warning_at (DECL_SOURCE_LOCATION (old_decl
), OPT_Wshadow
,
2605 "shadowed declaration is here");
2611 /* Record a decl-node X as belonging to the current lexical scope.
2612 Check for errors (such as an incompatible declaration for the same
2613 name already seen in the same scope).
2615 Returns either X or an old decl for the same name.
2616 If an old decl is returned, it may have been smashed
2617 to agree with what X says. */
2622 tree name
= DECL_NAME (x
);
2623 struct c_scope
*scope
= current_scope
;
2624 struct c_binding
*b
;
2625 bool nested
= false;
2626 location_t locus
= DECL_SOURCE_LOCATION (x
);
2628 /* Must set DECL_CONTEXT for everything not at file scope or
2629 DECL_FILE_SCOPE_P won't work. Local externs don't count
2630 unless they have initializers (which generate code). */
2631 if (current_function_decl
2632 && ((TREE_CODE (x
) != FUNCTION_DECL
&& TREE_CODE (x
) != VAR_DECL
)
2633 || DECL_INITIAL (x
) || !DECL_EXTERNAL (x
)))
2634 DECL_CONTEXT (x
) = current_function_decl
;
2636 /* Anonymous decls are just inserted in the scope. */
2639 bind (name
, x
, scope
, /*invisible=*/false, /*nested=*/false,
2644 /* First, see if there is another declaration with the same name in
2645 the current scope. If there is, duplicate_decls may do all the
2646 work for us. If duplicate_decls returns false, that indicates
2647 two incompatible decls in the same scope; we are to silently
2648 replace the old one (duplicate_decls has issued all appropriate
2649 diagnostics). In particular, we should not consider possible
2650 duplicates in the external scope, or shadowing. */
2651 b
= I_SYMBOL_BINDING (name
);
2652 if (b
&& B_IN_SCOPE (b
, scope
))
2654 struct c_binding
*b_ext
, *b_use
;
2655 tree type
= TREE_TYPE (x
);
2656 tree visdecl
= b
->decl
;
2657 tree vistype
= TREE_TYPE (visdecl
);
2658 if (TREE_CODE (TREE_TYPE (x
)) == ARRAY_TYPE
2659 && COMPLETE_TYPE_P (TREE_TYPE (x
)))
2660 b
->inner_comp
= false;
2663 /* If this is an external linkage declaration, we should check
2664 for compatibility with the type in the external scope before
2665 setting the type at this scope based on the visible
2666 information only. */
2667 if (TREE_PUBLIC (x
) && TREE_PUBLIC (visdecl
))
2669 while (b_ext
&& !B_IN_EXTERNAL_SCOPE (b_ext
))
2670 b_ext
= b_ext
->shadowed
;
2675 TREE_TYPE (b_use
->decl
) = b_use
->u
.type
;
2678 if (duplicate_decls (x
, b_use
->decl
))
2682 /* Save the updated type in the external scope and
2683 restore the proper type for this scope. */
2685 if (comptypes (vistype
, type
))
2686 thistype
= composite_type (vistype
, type
);
2688 thistype
= TREE_TYPE (b_use
->decl
);
2689 b_use
->u
.type
= TREE_TYPE (b_use
->decl
);
2690 if (TREE_CODE (b_use
->decl
) == FUNCTION_DECL
2691 && DECL_BUILT_IN (b_use
->decl
))
2693 = build_type_attribute_variant (thistype
,
2696 TREE_TYPE (b_use
->decl
) = thistype
;
2701 goto skip_external_and_shadow_checks
;
2704 /* All declarations with external linkage, and all external
2705 references, go in the external scope, no matter what scope is
2706 current. However, the binding in that scope is ignored for
2707 purposes of normal name lookup. A separate binding structure is
2708 created in the requested scope; this governs the normal
2709 visibility of the symbol.
2711 The binding in the externals scope is used exclusively for
2712 detecting duplicate declarations of the same object, no matter
2713 what scope they are in; this is what we do here. (C99 6.2.7p2:
2714 All declarations that refer to the same object or function shall
2715 have compatible type; otherwise, the behavior is undefined.) */
2716 if (DECL_EXTERNAL (x
) || scope
== file_scope
)
2718 tree type
= TREE_TYPE (x
);
2721 bool type_saved
= false;
2722 if (b
&& !B_IN_EXTERNAL_SCOPE (b
)
2723 && (TREE_CODE (b
->decl
) == FUNCTION_DECL
2724 || TREE_CODE (b
->decl
) == VAR_DECL
)
2725 && DECL_FILE_SCOPE_P (b
->decl
))
2728 vistype
= TREE_TYPE (visdecl
);
2730 if (scope
!= file_scope
2731 && !DECL_IN_SYSTEM_HEADER (x
))
2732 warning (OPT_Wnested_externs
, "nested extern declaration of %qD", x
);
2734 while (b
&& !B_IN_EXTERNAL_SCOPE (b
))
2736 /* If this decl might be modified, save its type. This is
2737 done here rather than when the decl is first bound
2738 because the type may change after first binding, through
2739 being completed or through attributes being added. If we
2740 encounter multiple such decls, only the first should have
2741 its type saved; the others will already have had their
2742 proper types saved and the types will not have changed as
2743 their scopes will not have been re-entered. */
2744 if (DECL_P (b
->decl
) && DECL_FILE_SCOPE_P (b
->decl
) && !type_saved
)
2746 b
->u
.type
= TREE_TYPE (b
->decl
);
2749 if (B_IN_FILE_SCOPE (b
)
2750 && TREE_CODE (b
->decl
) == VAR_DECL
2751 && TREE_STATIC (b
->decl
)
2752 && TREE_CODE (TREE_TYPE (b
->decl
)) == ARRAY_TYPE
2753 && !TYPE_DOMAIN (TREE_TYPE (b
->decl
))
2754 && TREE_CODE (type
) == ARRAY_TYPE
2755 && TYPE_DOMAIN (type
)
2756 && TYPE_MAX_VALUE (TYPE_DOMAIN (type
))
2757 && !integer_zerop (TYPE_MAX_VALUE (TYPE_DOMAIN (type
))))
2759 /* Array type completed in inner scope, which should be
2760 diagnosed if the completion does not have size 1 and
2761 it does not get completed in the file scope. */
2762 b
->inner_comp
= true;
2767 /* If a matching external declaration has been found, set its
2768 type to the composite of all the types of that declaration.
2769 After the consistency checks, it will be reset to the
2770 composite of the visible types only. */
2771 if (b
&& (TREE_PUBLIC (x
) || same_translation_unit_p (x
, b
->decl
))
2773 TREE_TYPE (b
->decl
) = b
->u
.type
;
2775 /* The point of the same_translation_unit_p check here is,
2776 we want to detect a duplicate decl for a construct like
2777 foo() { extern bar(); } ... static bar(); but not if
2778 they are in different translation units. In any case,
2779 the static does not go in the externals scope. */
2781 && (TREE_PUBLIC (x
) || same_translation_unit_p (x
, b
->decl
))
2782 && duplicate_decls (x
, b
->decl
))
2787 if (comptypes (vistype
, type
))
2788 thistype
= composite_type (vistype
, type
);
2790 thistype
= TREE_TYPE (b
->decl
);
2794 b
->u
.type
= TREE_TYPE (b
->decl
);
2795 if (TREE_CODE (b
->decl
) == FUNCTION_DECL
&& DECL_BUILT_IN (b
->decl
))
2797 = build_type_attribute_variant (thistype
,
2798 TYPE_ATTRIBUTES (b
->u
.type
));
2799 TREE_TYPE (b
->decl
) = thistype
;
2800 bind (name
, b
->decl
, scope
, /*invisible=*/false, /*nested=*/true,
2804 else if (TREE_PUBLIC (x
))
2806 if (visdecl
&& !b
&& duplicate_decls (x
, visdecl
))
2808 /* An external declaration at block scope referring to a
2809 visible entity with internal linkage. The composite
2810 type will already be correct for this scope, so we
2811 just need to fall through to make the declaration in
2818 bind (name
, x
, external_scope
, /*invisible=*/true,
2819 /*nested=*/false, locus
);
2825 if (TREE_CODE (x
) != PARM_DECL
)
2826 warn_if_shadowing (x
);
2828 skip_external_and_shadow_checks
:
2829 if (TREE_CODE (x
) == TYPE_DECL
)
2831 /* So this is a typedef, set its underlying type. */
2832 set_underlying_type (x
);
2834 /* If X is a typedef defined in the current function, record it
2835 for the purpose of implementing the -Wunused-local-typedefs
2837 record_locally_defined_typedef (x
);
2840 bind (name
, x
, scope
, /*invisible=*/false, nested
, locus
);
2842 /* If x's type is incomplete because it's based on a
2843 structure or union which has not yet been fully declared,
2844 attach it to that structure or union type, so we can go
2845 back and complete the variable declaration later, if the
2846 structure or union gets fully declared.
2848 If the input is erroneous, we can have error_mark in the type
2849 slot (e.g. "f(void a, ...)") - that doesn't count as an
2851 if (TREE_TYPE (x
) != error_mark_node
2852 && !COMPLETE_TYPE_P (TREE_TYPE (x
)))
2854 tree element
= TREE_TYPE (x
);
2856 while (TREE_CODE (element
) == ARRAY_TYPE
)
2857 element
= TREE_TYPE (element
);
2858 element
= TYPE_MAIN_VARIANT (element
);
2860 if ((TREE_CODE (element
) == RECORD_TYPE
2861 || TREE_CODE (element
) == UNION_TYPE
)
2862 && (TREE_CODE (x
) != TYPE_DECL
2863 || TREE_CODE (TREE_TYPE (x
)) == ARRAY_TYPE
)
2864 && !COMPLETE_TYPE_P (element
))
2865 C_TYPE_INCOMPLETE_VARS (element
)
2866 = tree_cons (NULL_TREE
, x
, C_TYPE_INCOMPLETE_VARS (element
));
2871 /* Record X as belonging to file scope.
2872 This is used only internally by the Objective-C front end,
2873 and is limited to its needs. duplicate_decls is not called;
2874 if there is any preexisting decl for this identifier, it is an ICE. */
2877 pushdecl_top_level (tree x
)
2880 bool nested
= false;
2881 gcc_assert (TREE_CODE (x
) == VAR_DECL
|| TREE_CODE (x
) == CONST_DECL
);
2883 name
= DECL_NAME (x
);
2885 gcc_assert (TREE_CODE (x
) == CONST_DECL
|| !I_SYMBOL_BINDING (name
));
2887 if (TREE_PUBLIC (x
))
2889 bind (name
, x
, external_scope
, /*invisible=*/true, /*nested=*/false,
2894 bind (name
, x
, file_scope
, /*invisible=*/false, nested
, UNKNOWN_LOCATION
);
2900 implicit_decl_warning (tree id
, tree olddecl
)
2902 if (warn_implicit_function_declaration
)
2907 warned
= pedwarn (input_location
, OPT_Wimplicit_function_declaration
,
2908 "implicit declaration of function %qE", id
);
2910 warned
= warning (OPT_Wimplicit_function_declaration
,
2911 G_("implicit declaration of function %qE"), id
);
2912 if (olddecl
&& warned
)
2913 locate_old_decl (olddecl
);
2917 /* Generate an implicit declaration for identifier FUNCTIONID at LOC as a
2918 function of type int (). */
2921 implicitly_declare (location_t loc
, tree functionid
)
2923 struct c_binding
*b
;
2927 for (b
= I_SYMBOL_BINDING (functionid
); b
; b
= b
->shadowed
)
2929 if (B_IN_SCOPE (b
, external_scope
))
2938 if (decl
== error_mark_node
)
2941 /* FIXME: Objective-C has weird not-really-builtin functions
2942 which are supposed to be visible automatically. They wind up
2943 in the external scope because they're pushed before the file
2944 scope gets created. Catch this here and rebind them into the
2946 if (!DECL_BUILT_IN (decl
) && DECL_IS_BUILTIN (decl
))
2948 bind (functionid
, decl
, file_scope
,
2949 /*invisible=*/false, /*nested=*/true,
2950 DECL_SOURCE_LOCATION (decl
));
2955 tree newtype
= default_function_type
;
2957 TREE_TYPE (decl
) = b
->u
.type
;
2958 /* Implicit declaration of a function already declared
2959 (somehow) in a different scope, or as a built-in.
2960 If this is the first time this has happened, warn;
2961 then recycle the old declaration but with the new type. */
2962 if (!C_DECL_IMPLICIT (decl
))
2964 implicit_decl_warning (functionid
, decl
);
2965 C_DECL_IMPLICIT (decl
) = 1;
2967 if (DECL_BUILT_IN (decl
))
2969 newtype
= build_type_attribute_variant (newtype
,
2971 (TREE_TYPE (decl
)));
2972 if (!comptypes (newtype
, TREE_TYPE (decl
)))
2974 warning_at (loc
, 0, "incompatible implicit declaration of "
2975 "built-in function %qD", decl
);
2976 newtype
= TREE_TYPE (decl
);
2981 if (!comptypes (newtype
, TREE_TYPE (decl
)))
2983 error_at (loc
, "incompatible implicit declaration of function %qD", decl
);
2984 locate_old_decl (decl
);
2987 b
->u
.type
= TREE_TYPE (decl
);
2988 TREE_TYPE (decl
) = newtype
;
2989 bind (functionid
, decl
, current_scope
,
2990 /*invisible=*/false, /*nested=*/true,
2991 DECL_SOURCE_LOCATION (decl
));
2996 /* Not seen before. */
2997 decl
= build_decl (loc
, FUNCTION_DECL
, functionid
, default_function_type
);
2998 DECL_EXTERNAL (decl
) = 1;
2999 TREE_PUBLIC (decl
) = 1;
3000 C_DECL_IMPLICIT (decl
) = 1;
3001 implicit_decl_warning (functionid
, 0);
3002 asmspec_tree
= maybe_apply_renaming_pragma (decl
, /*asmname=*/NULL
);
3004 set_user_assembler_name (decl
, TREE_STRING_POINTER (asmspec_tree
));
3006 /* C89 says implicit declarations are in the innermost block.
3007 So we record the decl in the standard fashion. */
3008 decl
= pushdecl (decl
);
3010 /* No need to call objc_check_decl here - it's a function type. */
3011 rest_of_decl_compilation (decl
, 0, 0);
3013 /* Write a record describing this implicit function declaration
3014 to the prototypes file (if requested). */
3015 gen_aux_info_record (decl
, 0, 1, 0);
3017 /* Possibly apply some default attributes to this implicit declaration. */
3018 decl_attributes (&decl
, NULL_TREE
, 0);
3023 /* Issue an error message for a reference to an undeclared variable
3024 ID, including a reference to a builtin outside of function-call
3025 context. Establish a binding of the identifier to error_mark_node
3026 in an appropriate scope, which will suppress further errors for the
3027 same identifier. The error message should be given location LOC. */
3029 undeclared_variable (location_t loc
, tree id
)
3031 static bool already
= false;
3032 struct c_scope
*scope
;
3034 if (current_function_decl
== 0)
3036 error_at (loc
, "%qE undeclared here (not in a function)", id
);
3037 scope
= current_scope
;
3041 if (!objc_diagnose_private_ivar (id
))
3042 error_at (loc
, "%qE undeclared (first use in this function)", id
);
3045 inform (loc
, "each undeclared identifier is reported only"
3046 " once for each function it appears in");
3050 /* If we are parsing old-style parameter decls, current_function_decl
3051 will be nonnull but current_function_scope will be null. */
3052 scope
= current_function_scope
? current_function_scope
: current_scope
;
3054 bind (id
, error_mark_node
, scope
, /*invisible=*/false, /*nested=*/false,
3058 /* Subroutine of lookup_label, declare_label, define_label: construct a
3059 LABEL_DECL with all the proper frills. Also create a struct
3060 c_label_vars initialized for the current scope. */
3063 make_label (location_t location
, tree name
, bool defining
,
3064 struct c_label_vars
**p_label_vars
)
3066 tree label
= build_decl (location
, LABEL_DECL
, name
, void_type_node
);
3067 struct c_label_vars
*label_vars
;
3069 DECL_CONTEXT (label
) = current_function_decl
;
3070 DECL_MODE (label
) = VOIDmode
;
3072 label_vars
= ggc_alloc_c_label_vars ();
3073 label_vars
->shadowed
= NULL
;
3074 set_spot_bindings (&label_vars
->label_bindings
, defining
);
3075 label_vars
->decls_in_scope
= make_tree_vector ();
3076 label_vars
->gotos
= NULL
;
3077 *p_label_vars
= label_vars
;
3082 /* Get the LABEL_DECL corresponding to identifier NAME as a label.
3083 Create one if none exists so far for the current function.
3084 This is called when a label is used in a goto expression or
3085 has its address taken. */
3088 lookup_label (tree name
)
3091 struct c_label_vars
*label_vars
;
3093 if (current_function_scope
== 0)
3095 error ("label %qE referenced outside of any function", name
);
3099 /* Use a label already defined or ref'd with this name, but not if
3100 it is inherited from a containing function and wasn't declared
3102 label
= I_LABEL_DECL (name
);
3103 if (label
&& (DECL_CONTEXT (label
) == current_function_decl
3104 || C_DECLARED_LABEL_FLAG (label
)))
3106 /* If the label has only been declared, update its apparent
3107 location to point here, for better diagnostics if it
3108 turns out not to have been defined. */
3109 if (DECL_INITIAL (label
) == NULL_TREE
)
3110 DECL_SOURCE_LOCATION (label
) = input_location
;
3114 /* No label binding for that identifier; make one. */
3115 label
= make_label (input_location
, name
, false, &label_vars
);
3117 /* Ordinary labels go in the current function scope. */
3118 bind_label (name
, label
, current_function_scope
, label_vars
);
3123 /* Issue a warning about DECL for a goto statement at GOTO_LOC going
3127 warn_about_goto (location_t goto_loc
, tree label
, tree decl
)
3129 if (variably_modified_type_p (TREE_TYPE (decl
), NULL_TREE
))
3131 "jump into scope of identifier with variably modified type");
3133 warning_at (goto_loc
, OPT_Wjump_misses_init
,
3134 "jump skips variable initialization");
3135 inform (DECL_SOURCE_LOCATION (label
), "label %qD defined here", label
);
3136 inform (DECL_SOURCE_LOCATION (decl
), "%qD declared here", decl
);
3139 /* Look up a label because of a goto statement. This is like
3140 lookup_label, but also issues any appropriate warnings. */
3143 lookup_label_for_goto (location_t loc
, tree name
)
3146 struct c_label_vars
*label_vars
;
3150 label
= lookup_label (name
);
3151 if (label
== NULL_TREE
)
3154 /* If we are jumping to a different function, we can't issue any
3156 if (DECL_CONTEXT (label
) != current_function_decl
)
3158 gcc_assert (C_DECLARED_LABEL_FLAG (label
));
3162 label_vars
= I_LABEL_BINDING (name
)->u
.label
;
3164 /* If the label has not yet been defined, then push this goto on a
3165 list for possible later warnings. */
3166 if (label_vars
->label_bindings
.scope
== NULL
)
3168 struct c_goto_bindings
*g
;
3170 g
= ggc_alloc_c_goto_bindings ();
3172 set_spot_bindings (&g
->goto_bindings
, true);
3173 vec_safe_push (label_vars
->gotos
, g
);
3177 /* If there are any decls in label_vars->decls_in_scope, then this
3178 goto has missed the declaration of the decl. This happens for a
3184 Issue a warning or error. */
3185 FOR_EACH_VEC_SAFE_ELT (label_vars
->decls_in_scope
, ix
, decl
)
3186 warn_about_goto (loc
, label
, decl
);
3188 if (label_vars
->label_bindings
.left_stmt_expr
)
3190 error_at (loc
, "jump into statement expression");
3191 inform (DECL_SOURCE_LOCATION (label
), "label %qD defined here", label
);
3197 /* Make a label named NAME in the current function, shadowing silently
3198 any that may be inherited from containing functions or containing
3199 scopes. This is called for __label__ declarations. */
3202 declare_label (tree name
)
3204 struct c_binding
*b
= I_LABEL_BINDING (name
);
3206 struct c_label_vars
*label_vars
;
3208 /* Check to make sure that the label hasn't already been declared
3210 if (b
&& B_IN_CURRENT_SCOPE (b
))
3212 error ("duplicate label declaration %qE", name
);
3213 locate_old_decl (b
->decl
);
3215 /* Just use the previous declaration. */
3219 label
= make_label (input_location
, name
, false, &label_vars
);
3220 C_DECLARED_LABEL_FLAG (label
) = 1;
3222 /* Declared labels go in the current scope. */
3223 bind_label (name
, label
, current_scope
, label_vars
);
3228 /* When we define a label, issue any appropriate warnings if there are
3229 any gotos earlier in the function which jump to this label. */
3232 check_earlier_gotos (tree label
, struct c_label_vars
* label_vars
)
3235 struct c_goto_bindings
*g
;
3237 FOR_EACH_VEC_SAFE_ELT (label_vars
->gotos
, ix
, g
)
3239 struct c_binding
*b
;
3240 struct c_scope
*scope
;
3242 /* We have a goto to this label. The goto is going forward. In
3243 g->scope, the goto is going to skip any binding which was
3244 defined after g->bindings_in_scope. */
3245 if (g
->goto_bindings
.scope
->has_jump_unsafe_decl
)
3247 for (b
= g
->goto_bindings
.scope
->bindings
;
3248 b
!= g
->goto_bindings
.bindings_in_scope
;
3251 if (decl_jump_unsafe (b
->decl
))
3252 warn_about_goto (g
->loc
, label
, b
->decl
);
3256 /* We also need to warn about decls defined in any scopes
3257 between the scope of the label and the scope of the goto. */
3258 for (scope
= label_vars
->label_bindings
.scope
;
3259 scope
!= g
->goto_bindings
.scope
;
3260 scope
= scope
->outer
)
3262 gcc_assert (scope
!= NULL
);
3263 if (scope
->has_jump_unsafe_decl
)
3265 if (scope
== label_vars
->label_bindings
.scope
)
3266 b
= label_vars
->label_bindings
.bindings_in_scope
;
3268 b
= scope
->bindings
;
3269 for (; b
!= NULL
; b
= b
->prev
)
3271 if (decl_jump_unsafe (b
->decl
))
3272 warn_about_goto (g
->loc
, label
, b
->decl
);
3277 if (g
->goto_bindings
.stmt_exprs
> 0)
3279 error_at (g
->loc
, "jump into statement expression");
3280 inform (DECL_SOURCE_LOCATION (label
), "label %qD defined here",
3285 /* Now that the label is defined, we will issue warnings about
3286 subsequent gotos to this label when we see them. */
3287 vec_safe_truncate (label_vars
->gotos
, 0);
3288 label_vars
->gotos
= NULL
;
3291 /* Define a label, specifying the location in the source file.
3292 Return the LABEL_DECL node for the label, if the definition is valid.
3293 Otherwise return 0. */
3296 define_label (location_t location
, tree name
)
3298 /* Find any preexisting label with this name. It is an error
3299 if that label has already been defined in this function, or
3300 if there is a containing function with a declared label with
3302 tree label
= I_LABEL_DECL (name
);
3305 && ((DECL_CONTEXT (label
) == current_function_decl
3306 && DECL_INITIAL (label
) != 0)
3307 || (DECL_CONTEXT (label
) != current_function_decl
3308 && C_DECLARED_LABEL_FLAG (label
))))
3310 error_at (location
, "duplicate label %qD", label
);
3311 locate_old_decl (label
);
3314 else if (label
&& DECL_CONTEXT (label
) == current_function_decl
)
3316 struct c_label_vars
*label_vars
= I_LABEL_BINDING (name
)->u
.label
;
3318 /* The label has been used or declared already in this function,
3319 but not defined. Update its location to point to this
3321 DECL_SOURCE_LOCATION (label
) = location
;
3322 set_spot_bindings (&label_vars
->label_bindings
, true);
3324 /* Issue warnings as required about any goto statements from
3325 earlier in the function. */
3326 check_earlier_gotos (label
, label_vars
);
3330 struct c_label_vars
*label_vars
;
3332 /* No label binding for that identifier; make one. */
3333 label
= make_label (location
, name
, true, &label_vars
);
3335 /* Ordinary labels go in the current function scope. */
3336 bind_label (name
, label
, current_function_scope
, label_vars
);
3339 if (!in_system_header_at (input_location
) && lookup_name (name
))
3340 warning_at (location
, OPT_Wtraditional
,
3341 "traditional C lacks a separate namespace "
3342 "for labels, identifier %qE conflicts", name
);
3344 /* Mark label as having been defined. */
3345 DECL_INITIAL (label
) = error_mark_node
;
3349 /* Get the bindings for a new switch statement. This is used to issue
3350 warnings as appropriate for jumps from the switch to case or
3353 struct c_spot_bindings
*
3354 c_get_switch_bindings (void)
3356 struct c_spot_bindings
*switch_bindings
;
3358 switch_bindings
= XNEW (struct c_spot_bindings
);
3359 set_spot_bindings (switch_bindings
, true);
3360 return switch_bindings
;
3364 c_release_switch_bindings (struct c_spot_bindings
*bindings
)
3366 gcc_assert (bindings
->stmt_exprs
== 0 && !bindings
->left_stmt_expr
);
3370 /* This is called at the point of a case or default label to issue
3371 warnings about decls as needed. It returns true if it found an
3372 error, not just a warning. */
3375 c_check_switch_jump_warnings (struct c_spot_bindings
*switch_bindings
,
3376 location_t switch_loc
, location_t case_loc
)
3379 struct c_scope
*scope
;
3382 for (scope
= current_scope
;
3383 scope
!= switch_bindings
->scope
;
3384 scope
= scope
->outer
)
3386 struct c_binding
*b
;
3388 gcc_assert (scope
!= NULL
);
3390 if (!scope
->has_jump_unsafe_decl
)
3393 for (b
= scope
->bindings
; b
!= NULL
; b
= b
->prev
)
3395 if (decl_jump_unsafe (b
->decl
))
3397 if (variably_modified_type_p (TREE_TYPE (b
->decl
), NULL_TREE
))
3401 ("switch jumps into scope of identifier with "
3402 "variably modified type"));
3405 warning_at (case_loc
, OPT_Wjump_misses_init
,
3406 "switch jumps over variable initialization");
3407 inform (switch_loc
, "switch starts here");
3408 inform (DECL_SOURCE_LOCATION (b
->decl
), "%qD declared here",
3414 if (switch_bindings
->stmt_exprs
> 0)
3417 error_at (case_loc
, "switch jumps into statement expression");
3418 inform (switch_loc
, "switch starts here");
3424 /* Given NAME, an IDENTIFIER_NODE,
3425 return the structure (or union or enum) definition for that name.
3426 If THISLEVEL_ONLY is nonzero, searches only the current_scope.
3427 CODE says which kind of type the caller wants;
3428 it is RECORD_TYPE or UNION_TYPE or ENUMERAL_TYPE.
3429 If PLOC is not NULL and this returns non-null, it sets *PLOC to the
3430 location where the tag was defined.
3431 If the wrong kind of type is found, an error is reported. */
3434 lookup_tag (enum tree_code code
, tree name
, int thislevel_only
,
3437 struct c_binding
*b
= I_TAG_BINDING (name
);
3443 /* We only care about whether it's in this level if
3444 thislevel_only was set or it might be a type clash. */
3445 if (thislevel_only
|| TREE_CODE (b
->decl
) != code
)
3447 /* For our purposes, a tag in the external scope is the same as
3448 a tag in the file scope. (Primarily relevant to Objective-C
3449 and its builtin structure tags, which get pushed before the
3450 file scope is created.) */
3451 if (B_IN_CURRENT_SCOPE (b
)
3452 || (current_scope
== file_scope
&& B_IN_EXTERNAL_SCOPE (b
)))
3456 if (thislevel_only
&& !thislevel
)
3459 if (TREE_CODE (b
->decl
) != code
)
3461 /* Definition isn't the kind we were looking for. */
3462 pending_invalid_xref
= name
;
3463 pending_invalid_xref_location
= input_location
;
3465 /* If in the same binding level as a declaration as a tag
3466 of a different type, this must not be allowed to
3467 shadow that tag, so give the error immediately.
3468 (For example, "struct foo; union foo;" is invalid.) */
3470 pending_xref_error ();
3479 /* Print an error message now
3480 for a recent invalid struct, union or enum cross reference.
3481 We don't print them immediately because they are not invalid
3482 when used in the `struct foo;' construct for shadowing. */
3485 pending_xref_error (void)
3487 if (pending_invalid_xref
!= 0)
3488 error_at (pending_invalid_xref_location
, "%qE defined as wrong kind of tag",
3489 pending_invalid_xref
);
3490 pending_invalid_xref
= 0;
3494 /* Look up NAME in the current scope and its superiors
3495 in the namespace of variables, functions and typedefs.
3496 Return a ..._DECL node of some kind representing its definition,
3497 or return 0 if it is undefined. */
3500 lookup_name (tree name
)
3502 struct c_binding
*b
= I_SYMBOL_BINDING (name
);
3503 if (b
&& !b
->invisible
)
3505 maybe_record_typedef_use (b
->decl
);
3511 /* Similar to `lookup_name' but look only at the indicated scope. */
3514 lookup_name_in_scope (tree name
, struct c_scope
*scope
)
3516 struct c_binding
*b
;
3518 for (b
= I_SYMBOL_BINDING (name
); b
; b
= b
->shadowed
)
3519 if (B_IN_SCOPE (b
, scope
))
3524 /* Create the predefined scalar types of C,
3525 and some nodes representing standard constants (0, 1, (void *) 0).
3526 Initialize the global scope.
3527 Make definitions for built-in primitive functions. */
3530 c_init_decl_processing (void)
3532 location_t save_loc
= input_location
;
3534 /* Initialize reserved words for parser. */
3537 current_function_decl
= 0;
3539 gcc_obstack_init (&parser_obstack
);
3541 /* Make the externals scope. */
3543 external_scope
= current_scope
;
3545 /* Declarations from c_common_nodes_and_builtins must not be associated
3546 with this input file, lest we get differences between using and not
3547 using preprocessed headers. */
3548 input_location
= BUILTINS_LOCATION
;
3550 c_common_nodes_and_builtins ();
3552 /* In C, comparisons and TRUTH_* expressions have type int. */
3553 truthvalue_type_node
= integer_type_node
;
3554 truthvalue_true_node
= integer_one_node
;
3555 truthvalue_false_node
= integer_zero_node
;
3557 /* Even in C99, which has a real boolean type. */
3558 pushdecl (build_decl (UNKNOWN_LOCATION
, TYPE_DECL
, get_identifier ("_Bool"),
3559 boolean_type_node
));
3561 input_location
= save_loc
;
3563 pedantic_lvalues
= true;
3565 make_fname_decl
= c_make_fname_decl
;
3566 start_fname_decls ();
3569 /* Create the VAR_DECL at LOC for __FUNCTION__ etc. ID is the name to
3570 give the decl, NAME is the initialization string and TYPE_DEP
3571 indicates whether NAME depended on the type of the function. As we
3572 don't yet implement delayed emission of static data, we mark the
3573 decl as emitted so it is not placed in the output. Anything using
3574 it must therefore pull out the STRING_CST initializer directly.
3578 c_make_fname_decl (location_t loc
, tree id
, int type_dep
)
3580 const char *name
= fname_as_string (type_dep
);
3581 tree decl
, type
, init
;
3582 size_t length
= strlen (name
);
3584 type
= build_array_type (char_type_node
,
3585 build_index_type (size_int (length
)));
3586 type
= c_build_qualified_type (type
, TYPE_QUAL_CONST
);
3588 decl
= build_decl (loc
, VAR_DECL
, id
, type
);
3590 TREE_STATIC (decl
) = 1;
3591 TREE_READONLY (decl
) = 1;
3592 DECL_ARTIFICIAL (decl
) = 1;
3594 init
= build_string (length
+ 1, name
);
3595 free (CONST_CAST (char *, name
));
3596 TREE_TYPE (init
) = type
;
3597 DECL_INITIAL (decl
) = init
;
3599 TREE_USED (decl
) = 1;
3601 if (current_function_decl
3602 /* For invalid programs like this:
3605 const char* p = __FUNCTION__;
3607 the __FUNCTION__ is believed to appear in K&R style function
3608 parameter declarator. In that case we still don't have
3610 && (!seen_error () || current_function_scope
))
3612 DECL_CONTEXT (decl
) = current_function_decl
;
3613 bind (id
, decl
, current_function_scope
,
3614 /*invisible=*/false, /*nested=*/false, UNKNOWN_LOCATION
);
3617 finish_decl (decl
, loc
, init
, NULL_TREE
, NULL_TREE
);
3623 c_builtin_function (tree decl
)
3625 tree type
= TREE_TYPE (decl
);
3626 tree id
= DECL_NAME (decl
);
3628 const char *name
= IDENTIFIER_POINTER (id
);
3629 C_DECL_BUILTIN_PROTOTYPE (decl
) = prototype_p (type
);
3631 /* Should never be called on a symbol with a preexisting meaning. */
3632 gcc_assert (!I_SYMBOL_BINDING (id
));
3634 bind (id
, decl
, external_scope
, /*invisible=*/true, /*nested=*/false,
3637 /* Builtins in the implementation namespace are made visible without
3638 needing to be explicitly declared. See push_file_scope. */
3639 if (name
[0] == '_' && (name
[1] == '_' || ISUPPER (name
[1])))
3641 DECL_CHAIN (decl
) = visible_builtins
;
3642 visible_builtins
= decl
;
3649 c_builtin_function_ext_scope (tree decl
)
3651 tree type
= TREE_TYPE (decl
);
3652 tree id
= DECL_NAME (decl
);
3654 const char *name
= IDENTIFIER_POINTER (id
);
3655 C_DECL_BUILTIN_PROTOTYPE (decl
) = prototype_p (type
);
3658 bind (id
, decl
, external_scope
, /*invisible=*/false, /*nested=*/false,
3661 /* Builtins in the implementation namespace are made visible without
3662 needing to be explicitly declared. See push_file_scope. */
3663 if (name
[0] == '_' && (name
[1] == '_' || ISUPPER (name
[1])))
3665 DECL_CHAIN (decl
) = visible_builtins
;
3666 visible_builtins
= decl
;
3672 /* Called when a declaration is seen that contains no names to declare.
3673 If its type is a reference to a structure, union or enum inherited
3674 from a containing scope, shadow that tag name for the current scope
3675 with a forward reference.
3676 If its type defines a new named structure or union
3677 or defines an enum, it is valid but we need not do anything here.
3678 Otherwise, it is an error. */
3681 shadow_tag (const struct c_declspecs
*declspecs
)
3683 shadow_tag_warned (declspecs
, 0);
3686 /* WARNED is 1 if we have done a pedwarn, 2 if we have done a warning,
3689 shadow_tag_warned (const struct c_declspecs
*declspecs
, int warned
)
3691 bool found_tag
= false;
3693 if (declspecs
->type
&& !declspecs
->default_int_p
&& !declspecs
->typedef_p
)
3695 tree value
= declspecs
->type
;
3696 enum tree_code code
= TREE_CODE (value
);
3698 if (code
== RECORD_TYPE
|| code
== UNION_TYPE
|| code
== ENUMERAL_TYPE
)
3699 /* Used to test also that TYPE_SIZE (value) != 0.
3700 That caused warning for `struct foo;' at top level in the file. */
3702 tree name
= TYPE_NAME (value
);
3707 if (declspecs
->restrict_p
)
3709 error ("invalid use of %<restrict%>");
3715 if (warned
!= 1 && code
!= ENUMERAL_TYPE
)
3716 /* Empty unnamed enum OK */
3718 pedwarn (input_location
, 0,
3719 "unnamed struct/union that defines no instances");
3723 else if (declspecs
->typespec_kind
!= ctsk_tagdef
3724 && declspecs
->typespec_kind
!= ctsk_tagfirstref
3725 && declspecs
->storage_class
!= csc_none
)
3728 pedwarn (input_location
, 0,
3729 "empty declaration with storage class specifier "
3730 "does not redeclare tag");
3732 pending_xref_error ();
3734 else if (declspecs
->typespec_kind
!= ctsk_tagdef
3735 && declspecs
->typespec_kind
!= ctsk_tagfirstref
3736 && (declspecs
->const_p
3737 || declspecs
->volatile_p
3738 || declspecs
->atomic_p
3739 || declspecs
->restrict_p
3740 || declspecs
->address_space
))
3743 pedwarn (input_location
, 0,
3744 "empty declaration with type qualifier "
3745 "does not redeclare tag");
3747 pending_xref_error ();
3749 else if (declspecs
->typespec_kind
!= ctsk_tagdef
3750 && declspecs
->typespec_kind
!= ctsk_tagfirstref
3751 && declspecs
->alignas_p
)
3754 pedwarn (input_location
, 0,
3755 "empty declaration with %<_Alignas%> "
3756 "does not redeclare tag");
3758 pending_xref_error ();
3762 pending_invalid_xref
= 0;
3763 t
= lookup_tag (code
, name
, 1, NULL
);
3767 t
= make_node (code
);
3768 pushtag (input_location
, name
, t
);
3774 if (warned
!= 1 && !in_system_header_at (input_location
))
3776 pedwarn (input_location
, 0,
3777 "useless type name in empty declaration");
3782 else if (warned
!= 1 && !in_system_header_at (input_location
)
3783 && declspecs
->typedef_p
)
3785 pedwarn (input_location
, 0, "useless type name in empty declaration");
3789 pending_invalid_xref
= 0;
3791 if (declspecs
->inline_p
)
3793 error ("%<inline%> in empty declaration");
3797 if (declspecs
->noreturn_p
)
3799 error ("%<_Noreturn%> in empty declaration");
3803 if (current_scope
== file_scope
&& declspecs
->storage_class
== csc_auto
)
3805 error ("%<auto%> in file-scope empty declaration");
3809 if (current_scope
== file_scope
&& declspecs
->storage_class
== csc_register
)
3811 error ("%<register%> in file-scope empty declaration");
3815 if (!warned
&& !in_system_header_at (input_location
)
3816 && declspecs
->storage_class
!= csc_none
)
3818 warning (0, "useless storage class specifier in empty declaration");
3822 if (!warned
&& !in_system_header_at (input_location
) && declspecs
->thread_p
)
3824 warning (0, "useless %qs in empty declaration",
3825 declspecs
->thread_gnu_p
? "__thread" : "_Thread_local");
3830 && !in_system_header_at (input_location
)
3831 && (declspecs
->const_p
3832 || declspecs
->volatile_p
3833 || declspecs
->atomic_p
3834 || declspecs
->restrict_p
3835 || declspecs
->address_space
))
3837 warning (0, "useless type qualifier in empty declaration");
3841 if (!warned
&& !in_system_header_at (input_location
)
3842 && declspecs
->alignas_p
)
3844 warning (0, "useless %<_Alignas%> in empty declaration");
3851 pedwarn (input_location
, 0, "empty declaration");
3856 /* Return the qualifiers from SPECS as a bitwise OR of TYPE_QUAL_*
3857 bits. SPECS represents declaration specifiers that the grammar
3858 only permits to contain type qualifiers and attributes. */
3861 quals_from_declspecs (const struct c_declspecs
*specs
)
3863 int quals
= ((specs
->const_p
? TYPE_QUAL_CONST
: 0)
3864 | (specs
->volatile_p
? TYPE_QUAL_VOLATILE
: 0)
3865 | (specs
->restrict_p
? TYPE_QUAL_RESTRICT
: 0)
3866 | (specs
->atomic_p
? TYPE_QUAL_ATOMIC
: 0)
3867 | (ENCODE_QUAL_ADDR_SPACE (specs
->address_space
)));
3868 gcc_assert (!specs
->type
3869 && !specs
->decl_attr
3870 && specs
->typespec_word
== cts_none
3871 && specs
->storage_class
== csc_none
3872 && !specs
->typedef_p
3873 && !specs
->explicit_signed_p
3874 && !specs
->deprecated_p
3876 && !specs
->long_long_p
3879 && !specs
->unsigned_p
3880 && !specs
->complex_p
3882 && !specs
->noreturn_p
3883 && !specs
->thread_p
);
3887 /* Construct an array declarator. LOC is the location of the
3888 beginning of the array (usually the opening brace). EXPR is the
3889 expression inside [], or NULL_TREE. QUALS are the type qualifiers
3890 inside the [] (to be applied to the pointer to which a parameter
3891 array is converted). STATIC_P is true if "static" is inside the
3892 [], false otherwise. VLA_UNSPEC_P is true if the array is [*], a
3893 VLA of unspecified length which is nevertheless a complete type,
3894 false otherwise. The field for the contained declarator is left to
3895 be filled in by set_array_declarator_inner. */
3897 struct c_declarator
*
3898 build_array_declarator (location_t loc
,
3899 tree expr
, struct c_declspecs
*quals
, bool static_p
,
3902 struct c_declarator
*declarator
= XOBNEW (&parser_obstack
,
3903 struct c_declarator
);
3904 declarator
->id_loc
= loc
;
3905 declarator
->kind
= cdk_array
;
3906 declarator
->declarator
= 0;
3907 declarator
->u
.array
.dimen
= expr
;
3910 declarator
->u
.array
.attrs
= quals
->attrs
;
3911 declarator
->u
.array
.quals
= quals_from_declspecs (quals
);
3915 declarator
->u
.array
.attrs
= NULL_TREE
;
3916 declarator
->u
.array
.quals
= 0;
3918 declarator
->u
.array
.static_p
= static_p
;
3919 declarator
->u
.array
.vla_unspec_p
= vla_unspec_p
;
3922 if (static_p
|| quals
!= NULL
)
3923 pedwarn (loc
, OPT_Wpedantic
,
3924 "ISO C90 does not support %<static%> or type "
3925 "qualifiers in parameter array declarators");
3927 pedwarn (loc
, OPT_Wpedantic
,
3928 "ISO C90 does not support %<[*]%> array declarators");
3932 if (!current_scope
->parm_flag
)
3935 error_at (loc
, "%<[*]%> not allowed in other than "
3936 "function prototype scope");
3937 declarator
->u
.array
.vla_unspec_p
= false;
3940 current_scope
->had_vla_unspec
= true;
3945 /* Set the contained declarator of an array declarator. DECL is the
3946 declarator, as constructed by build_array_declarator; INNER is what
3947 appears on the left of the []. */
3949 struct c_declarator
*
3950 set_array_declarator_inner (struct c_declarator
*decl
,
3951 struct c_declarator
*inner
)
3953 decl
->declarator
= inner
;
3957 /* INIT is a constructor that forms DECL's initializer. If the final
3958 element initializes a flexible array field, add the size of that
3959 initializer to DECL's size. */
3962 add_flexible_array_elts_to_size (tree decl
, tree init
)
3966 if (vec_safe_is_empty (CONSTRUCTOR_ELTS (init
)))
3969 elt
= CONSTRUCTOR_ELTS (init
)->last ().value
;
3970 type
= TREE_TYPE (elt
);
3971 if (TREE_CODE (type
) == ARRAY_TYPE
3972 && TYPE_SIZE (type
) == NULL_TREE
3973 && TYPE_DOMAIN (type
) != NULL_TREE
3974 && TYPE_MAX_VALUE (TYPE_DOMAIN (type
)) == NULL_TREE
)
3976 complete_array_type (&type
, elt
, false);
3978 = size_binop (PLUS_EXPR
, DECL_SIZE (decl
), TYPE_SIZE (type
));
3979 DECL_SIZE_UNIT (decl
)
3980 = size_binop (PLUS_EXPR
, DECL_SIZE_UNIT (decl
), TYPE_SIZE_UNIT (type
));
3984 /* Decode a "typename", such as "int **", returning a ..._TYPE node.
3985 Set *EXPR, if EXPR not NULL, to any expression to be evaluated
3986 before the type name, and set *EXPR_CONST_OPERANDS, if
3987 EXPR_CONST_OPERANDS not NULL, to indicate whether the type name may
3988 appear in a constant expression. */
3991 groktypename (struct c_type_name
*type_name
, tree
*expr
,
3992 bool *expr_const_operands
)
3995 tree attrs
= type_name
->specs
->attrs
;
3997 type_name
->specs
->attrs
= NULL_TREE
;
3999 type
= grokdeclarator (type_name
->declarator
, type_name
->specs
, TYPENAME
,
4000 false, NULL
, &attrs
, expr
, expr_const_operands
,
4003 /* Apply attributes. */
4004 decl_attributes (&type
, attrs
, 0);
4009 /* Wrapper for decl_attributes that adds some implicit attributes
4010 to VAR_DECLs or FUNCTION_DECLs. */
4013 c_decl_attributes (tree
*node
, tree attributes
, int flags
)
4015 /* Add implicit "omp declare target" attribute if requested. */
4016 if (current_omp_declare_target_attribute
4017 && ((TREE_CODE (*node
) == VAR_DECL
&& TREE_STATIC (*node
))
4018 || TREE_CODE (*node
) == FUNCTION_DECL
))
4020 if (TREE_CODE (*node
) == VAR_DECL
4021 && ((DECL_CONTEXT (*node
)
4022 && TREE_CODE (DECL_CONTEXT (*node
)) == FUNCTION_DECL
)
4023 || (current_function_decl
&& !DECL_EXTERNAL (*node
))))
4024 error ("%q+D in block scope inside of declare target directive",
4026 else if (TREE_CODE (*node
) == VAR_DECL
4027 && !lang_hooks
.types
.omp_mappable_type (TREE_TYPE (*node
)))
4028 error ("%q+D in declare target directive does not have mappable type",
4031 attributes
= tree_cons (get_identifier ("omp declare target"),
4032 NULL_TREE
, attributes
);
4034 return decl_attributes (node
, attributes
, flags
);
4038 /* Decode a declarator in an ordinary declaration or data definition.
4039 This is called as soon as the type information and variable name
4040 have been parsed, before parsing the initializer if any.
4041 Here we create the ..._DECL node, fill in its type,
4042 and put it on the list of decls for the current context.
4043 The ..._DECL node is returned as the value.
4045 Exception: for arrays where the length is not specified,
4046 the type is left null, to be filled in by `finish_decl'.
4048 Function definitions do not come here; they go to start_function
4049 instead. However, external and forward declarations of functions
4050 do go through here. Structure field declarations are done by
4051 grokfield and not through here. */
4054 start_decl (struct c_declarator
*declarator
, struct c_declspecs
*declspecs
,
4055 bool initialized
, tree attributes
)
4059 tree expr
= NULL_TREE
;
4060 enum deprecated_states deprecated_state
= DEPRECATED_NORMAL
;
4062 /* An object declared as __attribute__((deprecated)) suppresses
4063 warnings of uses of other deprecated items. */
4064 if (lookup_attribute ("deprecated", attributes
))
4065 deprecated_state
= DEPRECATED_SUPPRESS
;
4067 decl
= grokdeclarator (declarator
, declspecs
,
4068 NORMAL
, initialized
, NULL
, &attributes
, &expr
, NULL
,
4074 add_stmt (fold_convert (void_type_node
, expr
));
4076 if (TREE_CODE (decl
) != FUNCTION_DECL
&& MAIN_NAME_P (DECL_NAME (decl
)))
4077 warning (OPT_Wmain
, "%q+D is usually a function", decl
);
4080 /* Is it valid for this decl to have an initializer at all?
4081 If not, set INITIALIZED to zero, which will indirectly
4082 tell 'finish_decl' to ignore the initializer once it is parsed. */
4083 switch (TREE_CODE (decl
))
4086 error ("typedef %qD is initialized (use __typeof__ instead)", decl
);
4091 error ("function %qD is initialized like a variable", decl
);
4096 /* DECL_INITIAL in a PARM_DECL is really DECL_ARG_TYPE. */
4097 error ("parameter %qD is initialized", decl
);
4102 /* Don't allow initializations for incomplete types except for
4103 arrays which might be completed by the initialization. */
4105 /* This can happen if the array size is an undefined macro.
4106 We already gave a warning, so we don't need another one. */
4107 if (TREE_TYPE (decl
) == error_mark_node
)
4109 else if (COMPLETE_TYPE_P (TREE_TYPE (decl
)))
4111 /* A complete type is ok if size is fixed. */
4113 if (TREE_CODE (TYPE_SIZE (TREE_TYPE (decl
))) != INTEGER_CST
4114 || C_DECL_VARIABLE_SIZE (decl
))
4116 error ("variable-sized object may not be initialized");
4120 else if (TREE_CODE (TREE_TYPE (decl
)) != ARRAY_TYPE
)
4122 error ("variable %qD has initializer but incomplete type", decl
);
4125 else if (C_DECL_VARIABLE_SIZE (decl
))
4127 /* Although C99 is unclear about whether incomplete arrays
4128 of VLAs themselves count as VLAs, it does not make
4129 sense to permit them to be initialized given that
4130 ordinary VLAs may not be initialized. */
4131 error ("variable-sized object may not be initialized");
4138 if (current_scope
== file_scope
)
4139 TREE_STATIC (decl
) = 1;
4141 /* Tell 'pushdecl' this is an initialized decl
4142 even though we don't yet have the initializer expression.
4143 Also tell 'finish_decl' it may store the real initializer. */
4144 DECL_INITIAL (decl
) = error_mark_node
;
4147 /* If this is a function declaration, write a record describing it to the
4148 prototypes file (if requested). */
4150 if (TREE_CODE (decl
) == FUNCTION_DECL
)
4151 gen_aux_info_record (decl
, 0, 0, prototype_p (TREE_TYPE (decl
)));
4153 /* ANSI specifies that a tentative definition which is not merged with
4154 a non-tentative definition behaves exactly like a definition with an
4155 initializer equal to zero. (Section 3.7.2)
4157 -fno-common gives strict ANSI behavior, though this tends to break
4158 a large body of code that grew up without this rule.
4160 Thread-local variables are never common, since there's no entrenched
4161 body of code to break, and it allows more efficient variable references
4162 in the presence of dynamic linking. */
4164 if (TREE_CODE (decl
) == VAR_DECL
4166 && TREE_PUBLIC (decl
)
4167 && !DECL_THREAD_LOCAL_P (decl
)
4169 DECL_COMMON (decl
) = 1;
4171 /* Set attributes here so if duplicate decl, will have proper attributes. */
4172 c_decl_attributes (&decl
, attributes
, 0);
4174 /* Handle gnu_inline attribute. */
4175 if (declspecs
->inline_p
4176 && !flag_gnu89_inline
4177 && TREE_CODE (decl
) == FUNCTION_DECL
4178 && (lookup_attribute ("gnu_inline", DECL_ATTRIBUTES (decl
))
4179 || current_function_decl
))
4181 if (declspecs
->storage_class
== csc_auto
&& current_scope
!= file_scope
)
4183 else if (declspecs
->storage_class
!= csc_static
)
4184 DECL_EXTERNAL (decl
) = !DECL_EXTERNAL (decl
);
4187 if (TREE_CODE (decl
) == FUNCTION_DECL
4188 && targetm
.calls
.promote_prototypes (TREE_TYPE (decl
)))
4190 struct c_declarator
*ce
= declarator
;
4192 if (ce
->kind
== cdk_pointer
)
4193 ce
= declarator
->declarator
;
4194 if (ce
->kind
== cdk_function
)
4196 tree args
= ce
->u
.arg_info
->parms
;
4197 for (; args
; args
= DECL_CHAIN (args
))
4199 tree type
= TREE_TYPE (args
);
4200 if (type
&& INTEGRAL_TYPE_P (type
)
4201 && TYPE_PRECISION (type
) < TYPE_PRECISION (integer_type_node
))
4202 DECL_ARG_TYPE (args
) = c_type_promotes_to (type
);
4207 if (TREE_CODE (decl
) == FUNCTION_DECL
4208 && DECL_DECLARED_INLINE_P (decl
)
4209 && DECL_UNINLINABLE (decl
)
4210 && lookup_attribute ("noinline", DECL_ATTRIBUTES (decl
)))
4211 warning (OPT_Wattributes
, "inline function %q+D given attribute noinline",
4214 /* C99 6.7.4p3: An inline definition of a function with external
4215 linkage shall not contain a definition of a modifiable object
4216 with static storage duration... */
4217 if (TREE_CODE (decl
) == VAR_DECL
4218 && current_scope
!= file_scope
4219 && TREE_STATIC (decl
)
4220 && !TREE_READONLY (decl
)
4221 && DECL_DECLARED_INLINE_P (current_function_decl
)
4222 && DECL_EXTERNAL (current_function_decl
))
4223 record_inline_static (input_location
, current_function_decl
,
4224 decl
, csi_modifiable
);
4226 if (c_dialect_objc ()
4227 && (TREE_CODE (decl
) == VAR_DECL
4228 || TREE_CODE (decl
) == FUNCTION_DECL
))
4229 objc_check_global_decl (decl
);
4231 /* Add this decl to the current scope.
4232 TEM may equal DECL or it may be a previous decl of the same name. */
4233 tem
= pushdecl (decl
);
4235 if (initialized
&& DECL_EXTERNAL (tem
))
4237 DECL_EXTERNAL (tem
) = 0;
4238 TREE_STATIC (tem
) = 1;
4244 /* Subroutine of finish_decl. TYPE is the type of an uninitialized object
4245 DECL or the non-array element type if DECL is an uninitialized array.
4246 If that type has a const member, diagnose this. */
4249 diagnose_uninitialized_cst_member (tree decl
, tree type
)
4252 for (field
= TYPE_FIELDS (type
); field
; field
= TREE_CHAIN (field
))
4255 if (TREE_CODE (field
) != FIELD_DECL
)
4257 field_type
= strip_array_types (TREE_TYPE (field
));
4259 if (TYPE_QUALS (field_type
) & TYPE_QUAL_CONST
)
4261 warning_at (DECL_SOURCE_LOCATION (decl
), OPT_Wc___compat
,
4262 "uninitialized const member in %qT is invalid in C++",
4263 strip_array_types (TREE_TYPE (decl
)));
4264 inform (DECL_SOURCE_LOCATION (field
), "%qD should be initialized", field
);
4267 if (TREE_CODE (field_type
) == RECORD_TYPE
4268 || TREE_CODE (field_type
) == UNION_TYPE
)
4269 diagnose_uninitialized_cst_member (decl
, field_type
);
4273 /* Finish processing of a declaration;
4274 install its initial value.
4275 If ORIGTYPE is not NULL_TREE, it is the original type of INIT.
4276 If the length of an array type is not known before,
4277 it must be determined now, from the initial value, or it is an error.
4279 INIT_LOC is the location of the initial value. */
4282 finish_decl (tree decl
, location_t init_loc
, tree init
,
4283 tree origtype
, tree asmspec_tree
)
4286 bool was_incomplete
= (DECL_SIZE (decl
) == 0);
4287 const char *asmspec
= 0;
4289 /* If a name was specified, get the string. */
4290 if ((TREE_CODE (decl
) == FUNCTION_DECL
|| TREE_CODE (decl
) == VAR_DECL
)
4291 && DECL_FILE_SCOPE_P (decl
))
4292 asmspec_tree
= maybe_apply_renaming_pragma (decl
, asmspec_tree
);
4294 asmspec
= TREE_STRING_POINTER (asmspec_tree
);
4296 if (TREE_CODE (decl
) == VAR_DECL
4297 && TREE_STATIC (decl
)
4298 && global_bindings_p ())
4299 /* So decl is a global variable. Record the types it uses
4300 so that we can decide later to emit debug info for them. */
4301 record_types_used_by_current_var_decl (decl
);
4303 /* If `start_decl' didn't like having an initialization, ignore it now. */
4304 if (init
!= 0 && DECL_INITIAL (decl
) == 0)
4307 /* Don't crash if parm is initialized. */
4308 if (TREE_CODE (decl
) == PARM_DECL
)
4312 store_init_value (init_loc
, decl
, init
, origtype
);
4314 if (c_dialect_objc () && (TREE_CODE (decl
) == VAR_DECL
4315 || TREE_CODE (decl
) == FUNCTION_DECL
4316 || TREE_CODE (decl
) == FIELD_DECL
))
4317 objc_check_decl (decl
);
4319 type
= TREE_TYPE (decl
);
4321 /* Deduce size of array from initialization, if not already known. */
4322 if (TREE_CODE (type
) == ARRAY_TYPE
4323 && TYPE_DOMAIN (type
) == 0
4324 && TREE_CODE (decl
) != TYPE_DECL
)
4327 = (TREE_STATIC (decl
)
4328 /* Even if pedantic, an external linkage array
4329 may have incomplete type at first. */
4330 ? pedantic
&& !TREE_PUBLIC (decl
)
4331 : !DECL_EXTERNAL (decl
));
4333 = complete_array_type (&TREE_TYPE (decl
), DECL_INITIAL (decl
),
4336 /* Get the completed type made by complete_array_type. */
4337 type
= TREE_TYPE (decl
);
4342 error ("initializer fails to determine size of %q+D", decl
);
4347 error ("array size missing in %q+D", decl
);
4348 /* If a `static' var's size isn't known,
4349 make it extern as well as static, so it does not get
4351 If it is not `static', then do not mark extern;
4352 finish_incomplete_decl will give it a default size
4353 and it will get allocated. */
4354 else if (!pedantic
&& TREE_STATIC (decl
) && !TREE_PUBLIC (decl
))
4355 DECL_EXTERNAL (decl
) = 1;
4359 error ("zero or negative size array %q+D", decl
);
4363 /* For global variables, update the copy of the type that
4364 exists in the binding. */
4365 if (TREE_PUBLIC (decl
))
4367 struct c_binding
*b_ext
= I_SYMBOL_BINDING (DECL_NAME (decl
));
4368 while (b_ext
&& !B_IN_EXTERNAL_SCOPE (b_ext
))
4369 b_ext
= b_ext
->shadowed
;
4372 if (b_ext
->u
.type
&& comptypes (b_ext
->u
.type
, type
))
4373 b_ext
->u
.type
= composite_type (b_ext
->u
.type
, type
);
4375 b_ext
->u
.type
= type
;
4384 if (DECL_INITIAL (decl
))
4385 TREE_TYPE (DECL_INITIAL (decl
)) = type
;
4387 relayout_decl (decl
);
4390 if (TREE_CODE (decl
) == VAR_DECL
)
4392 if (init
&& TREE_CODE (init
) == CONSTRUCTOR
)
4393 add_flexible_array_elts_to_size (decl
, init
);
4395 if (DECL_SIZE (decl
) == 0 && TREE_TYPE (decl
) != error_mark_node
4396 && COMPLETE_TYPE_P (TREE_TYPE (decl
)))
4397 layout_decl (decl
, 0);
4399 if (DECL_SIZE (decl
) == 0
4400 /* Don't give an error if we already gave one earlier. */
4401 && TREE_TYPE (decl
) != error_mark_node
4402 && (TREE_STATIC (decl
)
4403 /* A static variable with an incomplete type
4404 is an error if it is initialized.
4405 Also if it is not file scope.
4406 Otherwise, let it through, but if it is not `extern'
4407 then it may cause an error message later. */
4408 ? (DECL_INITIAL (decl
) != 0
4409 || !DECL_FILE_SCOPE_P (decl
))
4410 /* An automatic variable with an incomplete type
4412 : !DECL_EXTERNAL (decl
)))
4414 error ("storage size of %q+D isn%'t known", decl
);
4415 TREE_TYPE (decl
) = error_mark_node
;
4418 if ((DECL_EXTERNAL (decl
) || TREE_STATIC (decl
))
4419 && DECL_SIZE (decl
) != 0)
4421 if (TREE_CODE (DECL_SIZE (decl
)) == INTEGER_CST
)
4422 constant_expression_warning (DECL_SIZE (decl
));
4425 error ("storage size of %q+D isn%'t constant", decl
);
4426 TREE_TYPE (decl
) = error_mark_node
;
4430 if (TREE_USED (type
))
4432 TREE_USED (decl
) = 1;
4433 DECL_READ_P (decl
) = 1;
4437 /* If this is a function and an assembler name is specified, reset DECL_RTL
4438 so we can give it its new name. Also, update builtin_decl if it
4439 was a normal built-in. */
4440 if (TREE_CODE (decl
) == FUNCTION_DECL
&& asmspec
)
4442 if (DECL_BUILT_IN_CLASS (decl
) == BUILT_IN_NORMAL
)
4443 set_builtin_user_assembler_name (decl
, asmspec
);
4444 set_user_assembler_name (decl
, asmspec
);
4447 /* If #pragma weak was used, mark the decl weak now. */
4448 maybe_apply_pragma_weak (decl
);
4450 /* Output the assembler code and/or RTL code for variables and functions,
4451 unless the type is an undefined structure or union.
4452 If not, it will get done when the type is completed. */
4454 if (TREE_CODE (decl
) == VAR_DECL
|| TREE_CODE (decl
) == FUNCTION_DECL
)
4456 /* Determine the ELF visibility. */
4457 if (TREE_PUBLIC (decl
))
4458 c_determine_visibility (decl
);
4460 /* This is a no-op in c-lang.c or something real in objc-act.c. */
4461 if (c_dialect_objc ())
4462 objc_check_decl (decl
);
4466 /* If this is not a static variable, issue a warning.
4467 It doesn't make any sense to give an ASMSPEC for an
4468 ordinary, non-register local variable. Historically,
4469 GCC has accepted -- but ignored -- the ASMSPEC in
4471 if (!DECL_FILE_SCOPE_P (decl
)
4472 && TREE_CODE (decl
) == VAR_DECL
4473 && !C_DECL_REGISTER (decl
)
4474 && !TREE_STATIC (decl
))
4475 warning (0, "ignoring asm-specifier for non-static local "
4476 "variable %q+D", decl
);
4478 set_user_assembler_name (decl
, asmspec
);
4481 if (DECL_FILE_SCOPE_P (decl
))
4483 if (DECL_INITIAL (decl
) == NULL_TREE
4484 || DECL_INITIAL (decl
) == error_mark_node
)
4485 /* Don't output anything
4486 when a tentative file-scope definition is seen.
4487 But at end of compilation, do output code for them. */
4488 DECL_DEFER_OUTPUT (decl
) = 1;
4489 if (asmspec
&& C_DECL_REGISTER (decl
))
4490 DECL_HARD_REGISTER (decl
) = 1;
4491 rest_of_decl_compilation (decl
, true, 0);
4495 /* In conjunction with an ASMSPEC, the `register'
4496 keyword indicates that we should place the variable
4497 in a particular register. */
4498 if (asmspec
&& C_DECL_REGISTER (decl
))
4500 DECL_HARD_REGISTER (decl
) = 1;
4501 /* This cannot be done for a structure with volatile
4502 fields, on which DECL_REGISTER will have been
4504 if (!DECL_REGISTER (decl
))
4505 error ("cannot put object with volatile field into register");
4508 if (TREE_CODE (decl
) != FUNCTION_DECL
)
4510 /* If we're building a variable sized type, and we might be
4511 reachable other than via the top of the current binding
4512 level, then create a new BIND_EXPR so that we deallocate
4513 the object at the right time. */
4514 /* Note that DECL_SIZE can be null due to errors. */
4515 if (DECL_SIZE (decl
)
4516 && !TREE_CONSTANT (DECL_SIZE (decl
))
4517 && STATEMENT_LIST_HAS_LABEL (cur_stmt_list
))
4520 bind
= build3 (BIND_EXPR
, void_type_node
, NULL
, NULL
, NULL
);
4521 TREE_SIDE_EFFECTS (bind
) = 1;
4523 BIND_EXPR_BODY (bind
) = push_stmt_list ();
4525 add_stmt (build_stmt (DECL_SOURCE_LOCATION (decl
),
4531 if (!DECL_FILE_SCOPE_P (decl
))
4533 /* Recompute the RTL of a local array now
4534 if it used to be an incomplete type. */
4536 && !TREE_STATIC (decl
) && !DECL_EXTERNAL (decl
))
4538 /* If we used it already as memory, it must stay in memory. */
4539 TREE_ADDRESSABLE (decl
) = TREE_USED (decl
);
4540 /* If it's still incomplete now, no init will save it. */
4541 if (DECL_SIZE (decl
) == 0)
4542 DECL_INITIAL (decl
) = 0;
4547 if (TREE_CODE (decl
) == TYPE_DECL
)
4549 if (!DECL_FILE_SCOPE_P (decl
)
4550 && variably_modified_type_p (TREE_TYPE (decl
), NULL_TREE
))
4551 add_stmt (build_stmt (DECL_SOURCE_LOCATION (decl
), DECL_EXPR
, decl
));
4553 rest_of_decl_compilation (decl
, DECL_FILE_SCOPE_P (decl
), 0);
4556 /* Install a cleanup (aka destructor) if one was given. */
4557 if (TREE_CODE (decl
) == VAR_DECL
&& !TREE_STATIC (decl
))
4559 tree attr
= lookup_attribute ("cleanup", DECL_ATTRIBUTES (decl
));
4562 tree cleanup_id
= TREE_VALUE (TREE_VALUE (attr
));
4563 tree cleanup_decl
= lookup_name (cleanup_id
);
4565 vec
<tree
, va_gc
> *v
;
4567 /* Build "cleanup(&decl)" for the destructor. */
4568 cleanup
= build_unary_op (input_location
, ADDR_EXPR
, decl
, 0);
4570 v
->quick_push (cleanup
);
4571 cleanup
= c_build_function_call_vec (DECL_SOURCE_LOCATION (decl
),
4572 vNULL
, cleanup_decl
, v
, NULL
);
4575 /* Don't warn about decl unused; the cleanup uses it. */
4576 TREE_USED (decl
) = 1;
4577 TREE_USED (cleanup_decl
) = 1;
4578 DECL_READ_P (decl
) = 1;
4580 push_cleanup (decl
, cleanup
, false);
4585 && TREE_CODE (decl
) == VAR_DECL
4586 && !DECL_EXTERNAL (decl
)
4587 && DECL_INITIAL (decl
) == NULL_TREE
)
4589 type
= strip_array_types (type
);
4590 if (TREE_READONLY (decl
))
4591 warning_at (DECL_SOURCE_LOCATION (decl
), OPT_Wc___compat
,
4592 "uninitialized const %qD is invalid in C++", decl
);
4593 else if ((TREE_CODE (type
) == RECORD_TYPE
4594 || TREE_CODE (type
) == UNION_TYPE
)
4595 && C_TYPE_FIELDS_READONLY (type
))
4596 diagnose_uninitialized_cst_member (decl
, type
);
4599 invoke_plugin_callbacks (PLUGIN_FINISH_DECL
, decl
);
4602 /* Given a parsed parameter declaration, decode it into a PARM_DECL.
4603 EXPR is NULL or a pointer to an expression that needs to be
4604 evaluated for the side effects of array size expressions in the
4608 grokparm (const struct c_parm
*parm
, tree
*expr
)
4610 tree attrs
= parm
->attrs
;
4611 tree decl
= grokdeclarator (parm
->declarator
, parm
->specs
, PARM
, false,
4612 NULL
, &attrs
, expr
, NULL
, DEPRECATED_NORMAL
);
4614 decl_attributes (&decl
, attrs
, 0);
4619 /* Given a parsed parameter declaration, decode it into a PARM_DECL
4620 and push that on the current scope. EXPR is a pointer to an
4621 expression that needs to be evaluated for the side effects of array
4622 size expressions in the parameters. */
4625 push_parm_decl (const struct c_parm
*parm
, tree
*expr
)
4627 tree attrs
= parm
->attrs
;
4630 decl
= grokdeclarator (parm
->declarator
, parm
->specs
, PARM
, false, NULL
,
4631 &attrs
, expr
, NULL
, DEPRECATED_NORMAL
);
4632 decl_attributes (&decl
, attrs
, 0);
4634 decl
= pushdecl (decl
);
4636 finish_decl (decl
, input_location
, NULL_TREE
, NULL_TREE
, NULL_TREE
);
4639 /* Mark all the parameter declarations to date as forward decls.
4640 Also diagnose use of this extension. */
4643 mark_forward_parm_decls (void)
4645 struct c_binding
*b
;
4647 if (pedantic
&& !current_scope
->warned_forward_parm_decls
)
4649 pedwarn (input_location
, OPT_Wpedantic
,
4650 "ISO C forbids forward parameter declarations");
4651 current_scope
->warned_forward_parm_decls
= true;
4654 for (b
= current_scope
->bindings
; b
; b
= b
->prev
)
4655 if (TREE_CODE (b
->decl
) == PARM_DECL
)
4656 TREE_ASM_WRITTEN (b
->decl
) = 1;
4659 /* Build a COMPOUND_LITERAL_EXPR. TYPE is the type given in the compound
4660 literal, which may be an incomplete array type completed by the
4661 initializer; INIT is a CONSTRUCTOR at LOC that initializes the compound
4662 literal. NON_CONST is true if the initializers contain something
4663 that cannot occur in a constant expression. */
4666 build_compound_literal (location_t loc
, tree type
, tree init
, bool non_const
)
4668 /* We do not use start_decl here because we have a type, not a declarator;
4669 and do not use finish_decl because the decl should be stored inside
4670 the COMPOUND_LITERAL_EXPR rather than added elsewhere as a DECL_EXPR. */
4675 if (type
== error_mark_node
4676 || init
== error_mark_node
)
4677 return error_mark_node
;
4679 decl
= build_decl (loc
, VAR_DECL
, NULL_TREE
, type
);
4680 DECL_EXTERNAL (decl
) = 0;
4681 TREE_PUBLIC (decl
) = 0;
4682 TREE_STATIC (decl
) = (current_scope
== file_scope
);
4683 DECL_CONTEXT (decl
) = current_function_decl
;
4684 TREE_USED (decl
) = 1;
4685 DECL_READ_P (decl
) = 1;
4686 TREE_TYPE (decl
) = type
;
4687 TREE_READONLY (decl
) = (TYPE_READONLY (type
)
4688 || (TREE_CODE (type
) == ARRAY_TYPE
4689 && TYPE_READONLY (TREE_TYPE (type
))));
4690 store_init_value (loc
, decl
, init
, NULL_TREE
);
4692 if (TREE_CODE (type
) == ARRAY_TYPE
&& !COMPLETE_TYPE_P (type
))
4694 int failure
= complete_array_type (&TREE_TYPE (decl
),
4695 DECL_INITIAL (decl
), true);
4696 /* If complete_array_type returns 3, it means that the
4697 initial value of the compound literal is empty. Allow it. */
4698 gcc_assert (failure
== 0 || failure
== 3);
4700 type
= TREE_TYPE (decl
);
4701 TREE_TYPE (DECL_INITIAL (decl
)) = type
;
4704 if (type
== error_mark_node
|| !COMPLETE_TYPE_P (type
))
4706 c_incomplete_type_error (NULL_TREE
, type
);
4707 return error_mark_node
;
4710 stmt
= build_stmt (DECL_SOURCE_LOCATION (decl
), DECL_EXPR
, decl
);
4711 complit
= build1 (COMPOUND_LITERAL_EXPR
, type
, stmt
);
4712 TREE_SIDE_EFFECTS (complit
) = 1;
4714 layout_decl (decl
, 0);
4716 if (TREE_STATIC (decl
))
4718 /* This decl needs a name for the assembler output. */
4719 set_compound_literal_name (decl
);
4720 DECL_DEFER_OUTPUT (decl
) = 1;
4721 DECL_COMDAT (decl
) = 1;
4722 DECL_ARTIFICIAL (decl
) = 1;
4723 DECL_IGNORED_P (decl
) = 1;
4725 rest_of_decl_compilation (decl
, 1, 0);
4730 complit
= build2 (C_MAYBE_CONST_EXPR
, type
, NULL
, complit
);
4731 C_MAYBE_CONST_EXPR_NON_CONST (complit
) = 1;
4737 /* Check the type of a compound literal. Here we just check that it
4738 is valid for C++. */
4741 check_compound_literal_type (location_t loc
, struct c_type_name
*type_name
)
4744 && (type_name
->specs
->typespec_kind
== ctsk_tagdef
4745 || type_name
->specs
->typespec_kind
== ctsk_tagfirstref
))
4746 warning_at (loc
, OPT_Wc___compat
,
4747 "defining a type in a compound literal is invalid in C++");
4750 /* Determine whether TYPE is a structure with a flexible array member,
4751 or a union containing such a structure (possibly recursively). */
4754 flexible_array_type_p (tree type
)
4757 switch (TREE_CODE (type
))
4760 x
= TYPE_FIELDS (type
);
4763 while (DECL_CHAIN (x
) != NULL_TREE
)
4765 if (TREE_CODE (TREE_TYPE (x
)) == ARRAY_TYPE
4766 && TYPE_SIZE (TREE_TYPE (x
)) == NULL_TREE
4767 && TYPE_DOMAIN (TREE_TYPE (x
)) != NULL_TREE
4768 && TYPE_MAX_VALUE (TYPE_DOMAIN (TREE_TYPE (x
))) == NULL_TREE
)
4772 for (x
= TYPE_FIELDS (type
); x
!= NULL_TREE
; x
= DECL_CHAIN (x
))
4774 if (flexible_array_type_p (TREE_TYPE (x
)))
4783 /* Performs sanity checks on the TYPE and WIDTH of the bit-field NAME,
4784 replacing with appropriate values if they are invalid. */
4786 check_bitfield_type_and_width (tree
*type
, tree
*width
, tree orig_name
)
4789 unsigned int max_width
;
4790 unsigned HOST_WIDE_INT w
;
4791 const char *name
= (orig_name
4792 ? identifier_to_locale (IDENTIFIER_POINTER (orig_name
))
4793 : _("<anonymous>"));
4795 /* Detect and ignore out of range field width and process valid
4797 if (!INTEGRAL_TYPE_P (TREE_TYPE (*width
)))
4799 error ("bit-field %qs width not an integer constant", name
);
4800 *width
= integer_one_node
;
4804 if (TREE_CODE (*width
) != INTEGER_CST
)
4806 *width
= c_fully_fold (*width
, false, NULL
);
4807 if (TREE_CODE (*width
) == INTEGER_CST
)
4808 pedwarn (input_location
, OPT_Wpedantic
,
4809 "bit-field %qs width not an integer constant expression",
4812 if (TREE_CODE (*width
) != INTEGER_CST
)
4814 error ("bit-field %qs width not an integer constant", name
);
4815 *width
= integer_one_node
;
4817 constant_expression_warning (*width
);
4818 if (tree_int_cst_sgn (*width
) < 0)
4820 error ("negative width in bit-field %qs", name
);
4821 *width
= integer_one_node
;
4823 else if (integer_zerop (*width
) && orig_name
)
4825 error ("zero width for bit-field %qs", name
);
4826 *width
= integer_one_node
;
4830 /* Detect invalid bit-field type. */
4831 if (TREE_CODE (*type
) != INTEGER_TYPE
4832 && TREE_CODE (*type
) != BOOLEAN_TYPE
4833 && TREE_CODE (*type
) != ENUMERAL_TYPE
)
4835 error ("bit-field %qs has invalid type", name
);
4836 *type
= unsigned_type_node
;
4839 type_mv
= TYPE_MAIN_VARIANT (*type
);
4840 if (!in_system_header_at (input_location
)
4841 && type_mv
!= integer_type_node
4842 && type_mv
!= unsigned_type_node
4843 && type_mv
!= boolean_type_node
4845 pedwarn (input_location
, OPT_Wpedantic
,
4846 "type of bit-field %qs is a GCC extension", name
);
4848 max_width
= TYPE_PRECISION (*type
);
4850 if (0 < compare_tree_int (*width
, max_width
))
4852 error ("width of %qs exceeds its type", name
);
4854 *width
= build_int_cst (integer_type_node
, w
);
4857 w
= tree_to_uhwi (*width
);
4859 if (TREE_CODE (*type
) == ENUMERAL_TYPE
)
4861 struct lang_type
*lt
= TYPE_LANG_SPECIFIC (*type
);
4863 || w
< tree_int_cst_min_precision (lt
->enum_min
, TYPE_UNSIGNED (*type
))
4864 || w
< tree_int_cst_min_precision (lt
->enum_max
, TYPE_UNSIGNED (*type
)))
4865 warning (0, "%qs is narrower than values of its type", name
);
4871 /* Print warning about variable length array if necessary. */
4874 warn_variable_length_array (tree name
, tree size
)
4876 int const_size
= TREE_CONSTANT (size
);
4878 if (!flag_isoc99
&& pedantic
&& warn_vla
!= 0)
4883 pedwarn (input_location
, OPT_Wvla
,
4884 "ISO C90 forbids array %qE whose size "
4885 "can%'t be evaluated",
4888 pedwarn (input_location
, OPT_Wvla
, "ISO C90 forbids array whose size "
4889 "can%'t be evaluated");
4894 pedwarn (input_location
, OPT_Wvla
,
4895 "ISO C90 forbids variable length array %qE",
4898 pedwarn (input_location
, OPT_Wvla
, "ISO C90 forbids variable length array");
4901 else if (warn_vla
> 0)
4907 "the size of array %qE can"
4908 "%'t be evaluated", name
);
4911 "the size of array can %'t be evaluated");
4917 "variable length array %qE is used",
4921 "variable length array is used");
4926 /* Given declspecs and a declarator,
4927 determine the name and type of the object declared
4928 and construct a ..._DECL node for it.
4929 (In one case we can return a ..._TYPE node instead.
4930 For invalid input we sometimes return 0.)
4932 DECLSPECS is a c_declspecs structure for the declaration specifiers.
4934 DECL_CONTEXT says which syntactic context this declaration is in:
4935 NORMAL for most contexts. Make a VAR_DECL or FUNCTION_DECL or TYPE_DECL.
4936 FUNCDEF for a function definition. Like NORMAL but a few different
4937 error messages in each case. Return value may be zero meaning
4938 this definition is too screwy to try to parse.
4939 PARM for a parameter declaration (either within a function prototype
4940 or before a function body). Make a PARM_DECL, or return void_type_node.
4941 TYPENAME if for a typename (in a cast or sizeof).
4942 Don't make a DECL node; just return the ..._TYPE node.
4943 FIELD for a struct or union field; make a FIELD_DECL.
4944 INITIALIZED is true if the decl has an initializer.
4945 WIDTH is non-NULL for bit-fields, and is a pointer to an INTEGER_CST node
4946 representing the width of the bit-field.
4947 DECL_ATTRS points to the list of attributes that should be added to this
4948 decl. Any nested attributes that belong on the decl itself will be
4950 If EXPR is not NULL, any expressions that need to be evaluated as
4951 part of evaluating variably modified types will be stored in *EXPR.
4952 If EXPR_CONST_OPERANDS is not NULL, *EXPR_CONST_OPERANDS will be
4953 set to indicate whether operands in *EXPR can be used in constant
4955 DEPRECATED_STATE is a deprecated_states value indicating whether
4956 deprecation warnings should be suppressed.
4958 In the TYPENAME case, DECLARATOR is really an absolute declarator.
4959 It may also be so in the PARM case, for a prototype where the
4960 argument type is specified but not the name.
4962 This function is where the complicated C meanings of `static'
4963 and `extern' are interpreted. */
4966 grokdeclarator (const struct c_declarator
*declarator
,
4967 struct c_declspecs
*declspecs
,
4968 enum decl_context decl_context
, bool initialized
, tree
*width
,
4969 tree
*decl_attrs
, tree
*expr
, bool *expr_const_operands
,
4970 enum deprecated_states deprecated_state
)
4972 tree type
= declspecs
->type
;
4973 bool threadp
= declspecs
->thread_p
;
4974 enum c_storage_class storage_class
= declspecs
->storage_class
;
4979 int type_quals
= TYPE_UNQUALIFIED
;
4980 tree name
= NULL_TREE
;
4981 bool funcdef_flag
= false;
4982 bool funcdef_syntax
= false;
4983 bool size_varies
= false;
4984 tree decl_attr
= declspecs
->decl_attr
;
4985 int array_ptr_quals
= TYPE_UNQUALIFIED
;
4986 tree array_ptr_attrs
= NULL_TREE
;
4987 int array_parm_static
= 0;
4988 bool array_parm_vla_unspec_p
= false;
4989 tree returned_attrs
= NULL_TREE
;
4990 bool bitfield
= width
!= NULL
;
4992 struct c_arg_info
*arg_info
= 0;
4993 addr_space_t as1
, as2
, address_space
;
4994 location_t loc
= UNKNOWN_LOCATION
;
4997 bool expr_const_operands_dummy
;
4998 enum c_declarator_kind first_non_attr_kind
;
4999 unsigned int alignas_align
= 0;
5001 if (TREE_CODE (type
) == ERROR_MARK
)
5002 return error_mark_node
;
5005 if (expr_const_operands
== NULL
)
5006 expr_const_operands
= &expr_const_operands_dummy
;
5008 *expr
= declspecs
->expr
;
5009 *expr_const_operands
= declspecs
->expr_const_operands
;
5011 if (decl_context
== FUNCDEF
)
5012 funcdef_flag
= true, decl_context
= NORMAL
;
5014 /* Look inside a declarator for the name being declared
5015 and get it as an IDENTIFIER_NODE, for an error message. */
5017 const struct c_declarator
*decl
= declarator
;
5019 first_non_attr_kind
= cdk_attrs
;
5029 funcdef_syntax
= (decl
->kind
== cdk_function
);
5030 decl
= decl
->declarator
;
5031 if (first_non_attr_kind
== cdk_attrs
)
5032 first_non_attr_kind
= decl
->kind
;
5036 decl
= decl
->declarator
;
5043 if (first_non_attr_kind
== cdk_attrs
)
5044 first_non_attr_kind
= decl
->kind
;
5053 gcc_assert (decl_context
== PARM
5054 || decl_context
== TYPENAME
5055 || (decl_context
== FIELD
5056 && declarator
->kind
== cdk_id
));
5057 gcc_assert (!initialized
);
5061 /* A function definition's declarator must have the form of
5062 a function declarator. */
5064 if (funcdef_flag
&& !funcdef_syntax
)
5067 /* If this looks like a function definition, make it one,
5068 even if it occurs where parms are expected.
5069 Then store_parm_decls will reject it and not use it as a parm. */
5070 if (decl_context
== NORMAL
&& !funcdef_flag
&& current_scope
->parm_flag
)
5071 decl_context
= PARM
;
5073 if (declspecs
->deprecated_p
&& deprecated_state
!= DEPRECATED_SUPPRESS
)
5074 warn_deprecated_use (declspecs
->type
, declspecs
->decl_attr
);
5076 if ((decl_context
== NORMAL
|| decl_context
== FIELD
)
5077 && current_scope
== file_scope
5078 && variably_modified_type_p (type
, NULL_TREE
))
5081 error_at (loc
, "variably modified %qE at file scope", name
);
5083 error_at (loc
, "variably modified field at file scope");
5084 type
= integer_type_node
;
5087 size_varies
= C_TYPE_VARIABLE_SIZE (type
) != 0;
5089 /* Diagnose defaulting to "int". */
5091 if (declspecs
->default_int_p
&& !in_system_header_at (input_location
))
5093 /* Issue a warning if this is an ISO C 99 program or if
5094 -Wreturn-type and this is a function, or if -Wimplicit;
5095 prefer the former warning since it is more explicit. */
5096 if ((warn_implicit_int
|| warn_return_type
|| flag_isoc99
)
5098 warn_about_return_type
= 1;
5102 pedwarn_c99 (loc
, flag_isoc99
? 0 : OPT_Wimplicit_int
,
5103 "type defaults to %<int%> in declaration of %qE",
5106 pedwarn_c99 (input_location
, flag_isoc99
? 0 : OPT_Wimplicit_int
,
5107 "type defaults to %<int%> in type name");
5111 /* Adjust the type if a bit-field is being declared,
5112 -funsigned-bitfields applied and the type is not explicitly
5114 if (bitfield
&& !flag_signed_bitfields
&& !declspecs
->explicit_signed_p
5115 && TREE_CODE (type
) == INTEGER_TYPE
)
5116 type
= unsigned_type_for (type
);
5118 /* Figure out the type qualifiers for the declaration. There are
5119 two ways a declaration can become qualified. One is something
5120 like `const int i' where the `const' is explicit. Another is
5121 something like `typedef const int CI; CI i' where the type of the
5122 declaration contains the `const'. A third possibility is that
5123 there is a type qualifier on the element type of a typedefed
5124 array type, in which case we should extract that qualifier so
5125 that c_apply_type_quals_to_decl receives the full list of
5126 qualifiers to work with (C90 is not entirely clear about whether
5127 duplicate qualifiers should be diagnosed in this case, but it
5128 seems most appropriate to do so). */
5129 element_type
= strip_array_types (type
);
5130 constp
= declspecs
->const_p
+ TYPE_READONLY (element_type
);
5131 restrictp
= declspecs
->restrict_p
+ TYPE_RESTRICT (element_type
);
5132 volatilep
= declspecs
->volatile_p
+ TYPE_VOLATILE (element_type
);
5133 atomicp
= declspecs
->atomic_p
+ TYPE_ATOMIC (element_type
);
5134 as1
= declspecs
->address_space
;
5135 as2
= TYPE_ADDR_SPACE (element_type
);
5136 address_space
= ADDR_SPACE_GENERIC_P (as1
)? as2
: as1
;
5138 if (pedantic
&& !flag_isoc99
)
5141 pedwarn (loc
, OPT_Wpedantic
, "duplicate %<const%>");
5143 pedwarn (loc
, OPT_Wpedantic
, "duplicate %<restrict%>");
5145 pedwarn (loc
, OPT_Wpedantic
, "duplicate %<volatile%>");
5147 pedwarn (loc
, OPT_Wpedantic
, "duplicate %<_Atomic%>");
5151 if (!ADDR_SPACE_GENERIC_P (as1
) && !ADDR_SPACE_GENERIC_P (as2
) && as1
!= as2
)
5152 error_at (loc
, "conflicting named address spaces (%s vs %s)",
5153 c_addr_space_name (as1
), c_addr_space_name (as2
));
5155 if ((TREE_CODE (type
) == ARRAY_TYPE
5156 || first_non_attr_kind
== cdk_array
)
5157 && TYPE_QUALS (element_type
))
5158 type
= TYPE_MAIN_VARIANT (type
);
5159 type_quals
= ((constp
? TYPE_QUAL_CONST
: 0)
5160 | (restrictp
? TYPE_QUAL_RESTRICT
: 0)
5161 | (volatilep
? TYPE_QUAL_VOLATILE
: 0)
5162 | (atomicp
? TYPE_QUAL_ATOMIC
: 0)
5163 | ENCODE_QUAL_ADDR_SPACE (address_space
));
5165 /* Applying the _Atomic qualifier to an array type (through the use
5166 of typedefs or typeof) must be detected here. If the qualifier
5167 is introduced later, any appearance of applying it to an array is
5168 actually applying it to an element of that array. */
5169 if (atomicp
&& TREE_CODE (type
) == ARRAY_TYPE
)
5170 error_at (loc
, "%<_Atomic%>-qualified array type");
5172 /* Warn about storage classes that are invalid for certain
5173 kinds of declarations (parameters, typenames, etc.). */
5177 || storage_class
== csc_auto
5178 || storage_class
== csc_register
5179 || storage_class
== csc_typedef
))
5181 if (storage_class
== csc_auto
)
5183 (current_scope
== file_scope
) ? 0 : OPT_Wpedantic
,
5184 "function definition declared %<auto%>");
5185 if (storage_class
== csc_register
)
5186 error_at (loc
, "function definition declared %<register%>");
5187 if (storage_class
== csc_typedef
)
5188 error_at (loc
, "function definition declared %<typedef%>");
5190 error_at (loc
, "function definition declared %qs",
5191 declspecs
->thread_gnu_p
? "__thread" : "_Thread_local");
5193 if (storage_class
== csc_auto
5194 || storage_class
== csc_register
5195 || storage_class
== csc_typedef
)
5196 storage_class
= csc_none
;
5198 else if (decl_context
!= NORMAL
&& (storage_class
!= csc_none
|| threadp
))
5200 if (decl_context
== PARM
&& storage_class
== csc_register
)
5204 switch (decl_context
)
5208 error_at (loc
, "storage class specified for structure "
5211 error_at (loc
, "storage class specified for structure field");
5215 error_at (loc
, "storage class specified for parameter %qE",
5218 error_at (loc
, "storage class specified for unnamed parameter");
5221 error_at (loc
, "storage class specified for typename");
5224 storage_class
= csc_none
;
5228 else if (storage_class
== csc_extern
5232 /* 'extern' with initialization is invalid if not at file scope. */
5233 if (current_scope
== file_scope
)
5235 /* It is fine to have 'extern const' when compiling at C
5236 and C++ intersection. */
5237 if (!(warn_cxx_compat
&& constp
))
5238 warning_at (loc
, 0, "%qE initialized and declared %<extern%>",
5242 error_at (loc
, "%qE has both %<extern%> and initializer", name
);
5244 else if (current_scope
== file_scope
)
5246 if (storage_class
== csc_auto
)
5247 error_at (loc
, "file-scope declaration of %qE specifies %<auto%>",
5249 if (pedantic
&& storage_class
== csc_register
)
5250 pedwarn (input_location
, OPT_Wpedantic
,
5251 "file-scope declaration of %qE specifies %<register%>", name
);
5255 if (storage_class
== csc_extern
&& funcdef_flag
)
5256 error_at (loc
, "nested function %qE declared %<extern%>", name
);
5257 else if (threadp
&& storage_class
== csc_none
)
5259 error_at (loc
, "function-scope %qE implicitly auto and declared "
5261 declspecs
->thread_gnu_p
? "__thread" : "_Thread_local");
5266 /* Now figure out the structure of the declarator proper.
5267 Descend through it, creating more complex types, until we reach
5268 the declared identifier (or NULL_TREE, in an absolute declarator).
5269 At each stage we maintain an unqualified version of the type
5270 together with any qualifiers that should be applied to it with
5271 c_build_qualified_type; this way, array types including
5272 multidimensional array types are first built up in unqualified
5273 form and then the qualified form is created with
5274 TYPE_MAIN_VARIANT pointing to the unqualified form. */
5276 while (declarator
&& declarator
->kind
!= cdk_id
)
5278 if (type
== error_mark_node
)
5280 declarator
= declarator
->declarator
;
5284 /* Each level of DECLARATOR is either a cdk_array (for ...[..]),
5285 a cdk_pointer (for *...),
5286 a cdk_function (for ...(...)),
5287 a cdk_attrs (for nested attributes),
5288 or a cdk_id (for the name being declared
5289 or the place in an absolute declarator
5290 where the name was omitted).
5291 For the last case, we have just exited the loop.
5293 At this point, TYPE is the type of elements of an array,
5294 or for a function to return, or for a pointer to point to.
5295 After this sequence of ifs, TYPE is the type of the
5296 array or function or pointer, and DECLARATOR has had its
5297 outermost layer removed. */
5299 if (array_ptr_quals
!= TYPE_UNQUALIFIED
5300 || array_ptr_attrs
!= NULL_TREE
5301 || array_parm_static
)
5303 /* Only the innermost declarator (making a parameter be of
5304 array type which is converted to pointer type)
5305 may have static or type qualifiers. */
5306 error_at (loc
, "static or type qualifiers in non-parameter array declarator");
5307 array_ptr_quals
= TYPE_UNQUALIFIED
;
5308 array_ptr_attrs
= NULL_TREE
;
5309 array_parm_static
= 0;
5312 switch (declarator
->kind
)
5316 /* A declarator with embedded attributes. */
5317 tree attrs
= declarator
->u
.attrs
;
5318 const struct c_declarator
*inner_decl
;
5320 declarator
= declarator
->declarator
;
5321 inner_decl
= declarator
;
5322 while (inner_decl
->kind
== cdk_attrs
)
5323 inner_decl
= inner_decl
->declarator
;
5324 if (inner_decl
->kind
== cdk_id
)
5325 attr_flags
|= (int) ATTR_FLAG_DECL_NEXT
;
5326 else if (inner_decl
->kind
== cdk_function
)
5327 attr_flags
|= (int) ATTR_FLAG_FUNCTION_NEXT
;
5328 else if (inner_decl
->kind
== cdk_array
)
5329 attr_flags
|= (int) ATTR_FLAG_ARRAY_NEXT
;
5330 returned_attrs
= decl_attributes (&type
,
5331 chainon (returned_attrs
, attrs
),
5337 tree itype
= NULL_TREE
;
5338 tree size
= declarator
->u
.array
.dimen
;
5339 /* The index is a signed object `sizetype' bits wide. */
5340 tree index_type
= c_common_signed_type (sizetype
);
5342 array_ptr_quals
= declarator
->u
.array
.quals
;
5343 array_ptr_attrs
= declarator
->u
.array
.attrs
;
5344 array_parm_static
= declarator
->u
.array
.static_p
;
5345 array_parm_vla_unspec_p
= declarator
->u
.array
.vla_unspec_p
;
5347 declarator
= declarator
->declarator
;
5349 /* Check for some types that there cannot be arrays of. */
5351 if (VOID_TYPE_P (type
))
5354 error_at (loc
, "declaration of %qE as array of voids", name
);
5356 error_at (loc
, "declaration of type name as array of voids");
5357 type
= error_mark_node
;
5360 if (TREE_CODE (type
) == FUNCTION_TYPE
)
5363 error_at (loc
, "declaration of %qE as array of functions",
5366 error_at (loc
, "declaration of type name as array of "
5368 type
= error_mark_node
;
5371 if (pedantic
&& !in_system_header_at (input_location
)
5372 && flexible_array_type_p (type
))
5373 pedwarn (loc
, OPT_Wpedantic
,
5374 "invalid use of structure with flexible array member");
5376 if (size
== error_mark_node
)
5377 type
= error_mark_node
;
5379 if (type
== error_mark_node
)
5382 /* If size was specified, set ITYPE to a range-type for
5383 that size. Otherwise, ITYPE remains null. finish_decl
5384 may figure it out from an initial value. */
5388 bool size_maybe_const
= true;
5389 bool size_int_const
= (TREE_CODE (size
) == INTEGER_CST
5390 && !TREE_OVERFLOW (size
));
5391 bool this_size_varies
= false;
5393 /* Strip NON_LVALUE_EXPRs since we aren't using as an
5395 STRIP_TYPE_NOPS (size
);
5397 if (!INTEGRAL_TYPE_P (TREE_TYPE (size
)))
5400 error_at (loc
, "size of array %qE has non-integer type",
5404 "size of unnamed array has non-integer type");
5405 size
= integer_one_node
;
5408 size
= c_fully_fold (size
, false, &size_maybe_const
);
5410 if (pedantic
&& size_maybe_const
&& integer_zerop (size
))
5413 pedwarn (loc
, OPT_Wpedantic
,
5414 "ISO C forbids zero-size array %qE", name
);
5416 pedwarn (loc
, OPT_Wpedantic
,
5417 "ISO C forbids zero-size array");
5420 if (TREE_CODE (size
) == INTEGER_CST
&& size_maybe_const
)
5422 constant_expression_warning (size
);
5423 if (tree_int_cst_sgn (size
) < 0)
5426 error_at (loc
, "size of array %qE is negative", name
);
5428 error_at (loc
, "size of unnamed array is negative");
5429 size
= integer_one_node
;
5431 /* Handle a size folded to an integer constant but
5432 not an integer constant expression. */
5433 if (!size_int_const
)
5435 /* If this is a file scope declaration of an
5436 ordinary identifier, this is invalid code;
5437 diagnosing it here and not subsequently
5438 treating the type as variable-length avoids
5439 more confusing diagnostics later. */
5440 if ((decl_context
== NORMAL
|| decl_context
== FIELD
)
5441 && current_scope
== file_scope
)
5442 pedwarn (input_location
, 0,
5443 "variably modified %qE at file scope",
5446 this_size_varies
= size_varies
= true;
5447 warn_variable_length_array (name
, size
);
5450 else if ((decl_context
== NORMAL
|| decl_context
== FIELD
)
5451 && current_scope
== file_scope
)
5453 error_at (loc
, "variably modified %qE at file scope", name
);
5454 size
= integer_one_node
;
5458 /* Make sure the array size remains visibly
5459 nonconstant even if it is (eg) a const variable
5460 with known value. */
5461 this_size_varies
= size_varies
= true;
5462 warn_variable_length_array (name
, size
);
5463 if (flag_sanitize
& SANITIZE_VLA
5464 && decl_context
== NORMAL
)
5466 /* Evaluate the array size only once. */
5467 size
= c_save_expr (size
);
5468 size
= c_fully_fold (size
, false, NULL
);
5469 size
= fold_build2 (COMPOUND_EXPR
, TREE_TYPE (size
),
5470 ubsan_instrument_vla (loc
, size
),
5475 if (integer_zerop (size
) && !this_size_varies
)
5477 /* A zero-length array cannot be represented with
5478 an unsigned index type, which is what we'll
5479 get with build_index_type. Create an
5480 open-ended range instead. */
5481 itype
= build_range_type (sizetype
, size
, NULL_TREE
);
5485 /* Arrange for the SAVE_EXPR on the inside of the
5486 MINUS_EXPR, which allows the -1 to get folded
5487 with the +1 that happens when building TYPE_SIZE. */
5489 size
= save_expr (size
);
5490 if (this_size_varies
&& TREE_CODE (size
) == INTEGER_CST
)
5491 size
= build2 (COMPOUND_EXPR
, TREE_TYPE (size
),
5492 integer_zero_node
, size
);
5494 /* Compute the maximum valid index, that is, size
5495 - 1. Do the calculation in index_type, so that
5496 if it is a variable the computations will be
5497 done in the proper mode. */
5498 itype
= fold_build2_loc (loc
, MINUS_EXPR
, index_type
,
5499 convert (index_type
, size
),
5500 convert (index_type
,
5503 /* The above overflows when size does not fit
5505 ??? While a size of INT_MAX+1 technically shouldn't
5506 cause an overflow (because we subtract 1), handling
5507 this case seems like an unnecessary complication. */
5508 if (TREE_CODE (size
) == INTEGER_CST
5509 && !int_fits_type_p (size
, index_type
))
5512 error_at (loc
, "size of array %qE is too large",
5515 error_at (loc
, "size of unnamed array is too large");
5516 type
= error_mark_node
;
5520 itype
= build_index_type (itype
);
5522 if (this_size_varies
)
5525 *expr
= build2 (COMPOUND_EXPR
, TREE_TYPE (size
),
5529 *expr_const_operands
&= size_maybe_const
;
5532 else if (decl_context
== FIELD
)
5534 bool flexible_array_member
= false;
5535 if (array_parm_vla_unspec_p
)
5536 /* Field names can in fact have function prototype
5537 scope so [*] is disallowed here through making
5538 the field variably modified, not through being
5539 something other than a declaration with function
5544 const struct c_declarator
*t
= declarator
;
5545 while (t
->kind
== cdk_attrs
)
5547 flexible_array_member
= (t
->kind
== cdk_id
);
5549 if (flexible_array_member
5550 && pedantic
&& !flag_isoc99
5551 && !in_system_header_at (input_location
))
5552 pedwarn (loc
, OPT_Wpedantic
,
5553 "ISO C90 does not support flexible array members");
5555 /* ISO C99 Flexible array members are effectively
5556 identical to GCC's zero-length array extension. */
5557 if (flexible_array_member
|| array_parm_vla_unspec_p
)
5558 itype
= build_range_type (sizetype
, size_zero_node
,
5561 else if (decl_context
== PARM
)
5563 if (array_parm_vla_unspec_p
)
5565 itype
= build_range_type (sizetype
, size_zero_node
, NULL_TREE
);
5569 else if (decl_context
== TYPENAME
)
5571 if (array_parm_vla_unspec_p
)
5574 warning (0, "%<[*]%> not in a declaration");
5575 /* We use this to avoid messing up with incomplete
5576 array types of the same type, that would
5577 otherwise be modified below. */
5578 itype
= build_range_type (sizetype
, size_zero_node
,
5584 /* Complain about arrays of incomplete types. */
5585 if (!COMPLETE_TYPE_P (type
))
5587 error_at (loc
, "array type has incomplete element type");
5588 type
= error_mark_node
;
5591 /* When itype is NULL, a shared incomplete array type is
5592 returned for all array of a given type. Elsewhere we
5593 make sure we don't complete that type before copying
5594 it, but here we want to make sure we don't ever
5595 modify the shared type, so we gcc_assert (itype)
5598 addr_space_t as
= DECODE_QUAL_ADDR_SPACE (type_quals
);
5599 if (!ADDR_SPACE_GENERIC_P (as
) && as
!= TYPE_ADDR_SPACE (type
))
5600 type
= build_qualified_type (type
,
5601 ENCODE_QUAL_ADDR_SPACE (as
));
5603 type
= build_array_type (type
, itype
);
5606 if (type
!= error_mark_node
)
5610 /* It is ok to modify type here even if itype is
5611 NULL: if size_varies, we're in a
5612 multi-dimensional array and the inner type has
5613 variable size, so the enclosing shared array type
5615 if (size
&& TREE_CODE (size
) == INTEGER_CST
)
5617 = build_distinct_type_copy (TYPE_MAIN_VARIANT (type
));
5618 C_TYPE_VARIABLE_SIZE (type
) = 1;
5621 /* The GCC extension for zero-length arrays differs from
5622 ISO flexible array members in that sizeof yields
5624 if (size
&& integer_zerop (size
))
5627 type
= build_distinct_type_copy (TYPE_MAIN_VARIANT (type
));
5628 TYPE_SIZE (type
) = bitsize_zero_node
;
5629 TYPE_SIZE_UNIT (type
) = size_zero_node
;
5630 SET_TYPE_STRUCTURAL_EQUALITY (type
);
5632 if (array_parm_vla_unspec_p
)
5635 /* The type is complete. C99 6.7.5.2p4 */
5636 type
= build_distinct_type_copy (TYPE_MAIN_VARIANT (type
));
5637 TYPE_SIZE (type
) = bitsize_zero_node
;
5638 TYPE_SIZE_UNIT (type
) = size_zero_node
;
5639 SET_TYPE_STRUCTURAL_EQUALITY (type
);
5643 if (decl_context
!= PARM
5644 && (array_ptr_quals
!= TYPE_UNQUALIFIED
5645 || array_ptr_attrs
!= NULL_TREE
5646 || array_parm_static
))
5648 error_at (loc
, "static or type qualifiers in non-parameter array declarator");
5649 array_ptr_quals
= TYPE_UNQUALIFIED
;
5650 array_ptr_attrs
= NULL_TREE
;
5651 array_parm_static
= 0;
5657 /* Say it's a definition only for the declarator closest
5658 to the identifier, apart possibly from some
5660 bool really_funcdef
= false;
5664 const struct c_declarator
*t
= declarator
->declarator
;
5665 while (t
->kind
== cdk_attrs
)
5667 really_funcdef
= (t
->kind
== cdk_id
);
5670 /* Declaring a function type. Make sure we have a valid
5671 type for the function to return. */
5672 if (type
== error_mark_node
)
5675 size_varies
= false;
5677 /* Warn about some types functions can't return. */
5678 if (TREE_CODE (type
) == FUNCTION_TYPE
)
5681 error_at (loc
, "%qE declared as function returning a "
5684 error_at (loc
, "type name declared as function "
5685 "returning a function");
5686 type
= integer_type_node
;
5688 if (TREE_CODE (type
) == ARRAY_TYPE
)
5691 error_at (loc
, "%qE declared as function returning an array",
5694 error_at (loc
, "type name declared as function returning "
5696 type
= integer_type_node
;
5698 errmsg
= targetm
.invalid_return_type (type
);
5702 type
= integer_type_node
;
5705 /* Construct the function type and go to the next
5706 inner layer of declarator. */
5707 arg_info
= declarator
->u
.arg_info
;
5708 arg_types
= grokparms (arg_info
, really_funcdef
);
5710 /* Type qualifiers before the return type of the function
5711 qualify the return type, not the function type. */
5714 /* Type qualifiers on a function return type are
5715 normally permitted by the standard but have no
5716 effect, so give a warning at -Wreturn-type.
5717 Qualifiers on a void return type are banned on
5718 function definitions in ISO C; GCC used to used
5719 them for noreturn functions. */
5720 if (VOID_TYPE_P (type
) && really_funcdef
)
5722 "function definition has qualified void return type");
5724 warning_at (loc
, OPT_Wignored_qualifiers
,
5725 "type qualifiers ignored on function return type");
5727 type
= c_build_qualified_type (type
, type_quals
);
5729 type_quals
= TYPE_UNQUALIFIED
;
5731 type
= build_function_type (type
, arg_types
);
5732 declarator
= declarator
->declarator
;
5734 /* Set the TYPE_CONTEXTs for each tagged type which is local to
5735 the formal parameter list of this FUNCTION_TYPE to point to
5736 the FUNCTION_TYPE node itself. */
5741 FOR_EACH_VEC_SAFE_ELT_REVERSE (arg_info
->tags
, ix
, tag
)
5742 TYPE_CONTEXT (tag
->type
) = type
;
5748 /* Merge any constancy or volatility into the target type
5750 if ((type_quals
& TYPE_QUAL_ATOMIC
)
5751 && TREE_CODE (type
) == FUNCTION_TYPE
)
5754 "%<_Atomic%>-qualified function type");
5755 type_quals
&= ~TYPE_QUAL_ATOMIC
;
5757 else if (pedantic
&& TREE_CODE (type
) == FUNCTION_TYPE
5759 pedwarn (loc
, OPT_Wpedantic
,
5760 "ISO C forbids qualified function types");
5762 type
= c_build_qualified_type (type
, type_quals
);
5763 size_varies
= false;
5765 /* When the pointed-to type involves components of variable size,
5766 care must be taken to ensure that the size evaluation code is
5767 emitted early enough to dominate all the possible later uses
5768 and late enough for the variables on which it depends to have
5771 This is expected to happen automatically when the pointed-to
5772 type has a name/declaration of it's own, but special attention
5773 is required if the type is anonymous.
5775 We handle the NORMAL and FIELD contexts here by attaching an
5776 artificial TYPE_DECL to such pointed-to type. This forces the
5777 sizes evaluation at a safe point and ensures it is not deferred
5778 until e.g. within a deeper conditional context.
5780 We expect nothing to be needed here for PARM or TYPENAME.
5781 Pushing a TYPE_DECL at this point for TYPENAME would actually
5782 be incorrect, as we might be in the middle of an expression
5783 with side effects on the pointed-to type size "arguments" prior
5784 to the pointer declaration point and the fake TYPE_DECL in the
5785 enclosing context would force the size evaluation prior to the
5788 if (!TYPE_NAME (type
)
5789 && (decl_context
== NORMAL
|| decl_context
== FIELD
)
5790 && variably_modified_type_p (type
, NULL_TREE
))
5792 tree decl
= build_decl (loc
, TYPE_DECL
, NULL_TREE
, type
);
5793 DECL_ARTIFICIAL (decl
) = 1;
5795 finish_decl (decl
, loc
, NULL_TREE
, NULL_TREE
, NULL_TREE
);
5796 TYPE_NAME (type
) = decl
;
5799 type
= c_build_pointer_type (type
);
5801 /* Process type qualifiers (such as const or volatile)
5802 that were given inside the `*'. */
5803 type_quals
= declarator
->u
.pointer_quals
;
5805 declarator
= declarator
->declarator
;
5812 *decl_attrs
= chainon (returned_attrs
, *decl_attrs
);
5814 /* Now TYPE has the actual type, apart from any qualifiers in
5817 /* Warn about address space used for things other than static memory or
5819 address_space
= DECODE_QUAL_ADDR_SPACE (type_quals
);
5820 if (!ADDR_SPACE_GENERIC_P (address_space
))
5822 if (decl_context
== NORMAL
)
5824 switch (storage_class
)
5827 error ("%qs combined with %<auto%> qualifier for %qE",
5828 c_addr_space_name (address_space
), name
);
5831 error ("%qs combined with %<register%> qualifier for %qE",
5832 c_addr_space_name (address_space
), name
);
5835 if (current_function_scope
)
5837 error ("%qs specified for auto variable %qE",
5838 c_addr_space_name (address_space
), name
);
5850 else if (decl_context
== PARM
&& TREE_CODE (type
) != ARRAY_TYPE
)
5853 error ("%qs specified for parameter %qE",
5854 c_addr_space_name (address_space
), name
);
5856 error ("%qs specified for unnamed parameter",
5857 c_addr_space_name (address_space
));
5859 else if (decl_context
== FIELD
)
5862 error ("%qs specified for structure field %qE",
5863 c_addr_space_name (address_space
), name
);
5865 error ("%qs specified for structure field",
5866 c_addr_space_name (address_space
));
5870 /* Check the type and width of a bit-field. */
5873 check_bitfield_type_and_width (&type
, width
, name
);
5874 /* C11 makes it implementation-defined (6.7.2.1#5) whether
5875 atomic types are permitted for bit-fields; we have no code to
5876 make bit-field accesses atomic, so disallow them. */
5877 if (type_quals
& TYPE_QUAL_ATOMIC
)
5880 error ("bit-field %qE has atomic type", name
);
5882 error ("bit-field has atomic type");
5883 type_quals
&= ~TYPE_QUAL_ATOMIC
;
5887 /* Reject invalid uses of _Alignas. */
5888 if (declspecs
->alignas_p
)
5890 if (storage_class
== csc_typedef
)
5891 error_at (loc
, "alignment specified for typedef %qE", name
);
5892 else if (storage_class
== csc_register
)
5893 error_at (loc
, "alignment specified for %<register%> object %qE",
5895 else if (decl_context
== PARM
)
5898 error_at (loc
, "alignment specified for parameter %qE", name
);
5900 error_at (loc
, "alignment specified for unnamed parameter");
5905 error_at (loc
, "alignment specified for bit-field %qE", name
);
5907 error_at (loc
, "alignment specified for unnamed bit-field");
5909 else if (TREE_CODE (type
) == FUNCTION_TYPE
)
5910 error_at (loc
, "alignment specified for function %qE", name
);
5911 else if (declspecs
->align_log
!= -1)
5913 alignas_align
= 1U << declspecs
->align_log
;
5914 if (alignas_align
< TYPE_ALIGN_UNIT (type
))
5917 error_at (loc
, "%<_Alignas%> specifiers cannot reduce "
5918 "alignment of %qE", name
);
5920 error_at (loc
, "%<_Alignas%> specifiers cannot reduce "
5921 "alignment of unnamed field");
5927 /* Did array size calculations overflow or does the array cover more
5928 than half of the address-space? */
5929 if (TREE_CODE (type
) == ARRAY_TYPE
5930 && COMPLETE_TYPE_P (type
)
5931 && TREE_CODE (TYPE_SIZE_UNIT (type
)) == INTEGER_CST
5932 && ! valid_constant_size_p (TYPE_SIZE_UNIT (type
)))
5935 error_at (loc
, "size of array %qE is too large", name
);
5937 error_at (loc
, "size of unnamed array is too large");
5938 /* If we proceed with the array type as it is, we'll eventually
5939 crash in tree_to_[su]hwi(). */
5940 type
= error_mark_node
;
5943 /* If this is declaring a typedef name, return a TYPE_DECL. */
5945 if (storage_class
== csc_typedef
)
5948 if ((type_quals
& TYPE_QUAL_ATOMIC
)
5949 && TREE_CODE (type
) == FUNCTION_TYPE
)
5952 "%<_Atomic%>-qualified function type");
5953 type_quals
&= ~TYPE_QUAL_ATOMIC
;
5955 else if (pedantic
&& TREE_CODE (type
) == FUNCTION_TYPE
5957 pedwarn (loc
, OPT_Wpedantic
,
5958 "ISO C forbids qualified function types");
5960 type
= c_build_qualified_type (type
, type_quals
);
5961 decl
= build_decl (declarator
->id_loc
,
5962 TYPE_DECL
, declarator
->u
.id
, type
);
5963 if (declspecs
->explicit_signed_p
)
5964 C_TYPEDEF_EXPLICITLY_SIGNED (decl
) = 1;
5965 if (declspecs
->inline_p
)
5966 pedwarn (loc
, 0,"typedef %q+D declared %<inline%>", decl
);
5967 if (declspecs
->noreturn_p
)
5968 pedwarn (loc
, 0,"typedef %q+D declared %<_Noreturn%>", decl
);
5970 if (warn_cxx_compat
&& declarator
->u
.id
!= NULL_TREE
)
5972 struct c_binding
*b
= I_TAG_BINDING (declarator
->u
.id
);
5975 && b
->decl
!= NULL_TREE
5976 && (B_IN_CURRENT_SCOPE (b
)
5977 || (current_scope
== file_scope
&& B_IN_EXTERNAL_SCOPE (b
)))
5978 && TYPE_MAIN_VARIANT (b
->decl
) != TYPE_MAIN_VARIANT (type
))
5980 warning_at (declarator
->id_loc
, OPT_Wc___compat
,
5981 ("using %qD as both a typedef and a tag is "
5984 if (b
->locus
!= UNKNOWN_LOCATION
)
5985 inform (b
->locus
, "originally defined here");
5992 /* If this is a type name (such as, in a cast or sizeof),
5993 compute the type and return it now. */
5995 if (decl_context
== TYPENAME
)
5997 /* Note that the grammar rejects storage classes in typenames
5999 gcc_assert (storage_class
== csc_none
&& !threadp
6000 && !declspecs
->inline_p
&& !declspecs
->noreturn_p
);
6001 if ((type_quals
& TYPE_QUAL_ATOMIC
)
6002 && TREE_CODE (type
) == FUNCTION_TYPE
)
6005 "%<_Atomic%>-qualified function type");
6006 type_quals
&= ~TYPE_QUAL_ATOMIC
;
6008 else if (pedantic
&& TREE_CODE (type
) == FUNCTION_TYPE
6010 pedwarn (loc
, OPT_Wpedantic
,
6011 "ISO C forbids const or volatile function types");
6013 type
= c_build_qualified_type (type
, type_quals
);
6017 if (pedantic
&& decl_context
== FIELD
6018 && variably_modified_type_p (type
, NULL_TREE
))
6021 pedwarn (loc
, OPT_Wpedantic
, "a member of a structure or union cannot "
6022 "have a variably modified type");
6025 /* Aside from typedefs and type names (handle above),
6026 `void' at top level (not within pointer)
6027 is allowed only in public variables.
6028 We don't complain about parms either, but that is because
6029 a better error message can be made later. */
6031 if (VOID_TYPE_P (type
) && decl_context
!= PARM
6032 && !((decl_context
!= FIELD
&& TREE_CODE (type
) != FUNCTION_TYPE
)
6033 && (storage_class
== csc_extern
6034 || (current_scope
== file_scope
6035 && !(storage_class
== csc_static
6036 || storage_class
== csc_register
)))))
6038 error_at (loc
, "variable or field %qE declared void", name
);
6039 type
= integer_type_node
;
6042 /* Now create the decl, which may be a VAR_DECL, a PARM_DECL
6043 or a FUNCTION_DECL, depending on DECL_CONTEXT and TYPE. */
6048 if (decl_context
== PARM
)
6052 /* A parameter declared as an array of T is really a pointer to T.
6053 One declared as a function is really a pointer to a function. */
6055 if (TREE_CODE (type
) == ARRAY_TYPE
)
6057 /* Transfer const-ness of array into that of type pointed to. */
6058 type
= TREE_TYPE (type
);
6060 type
= c_build_qualified_type (type
, type_quals
);
6061 type
= c_build_pointer_type (type
);
6062 type_quals
= array_ptr_quals
;
6064 type
= c_build_qualified_type (type
, type_quals
);
6066 /* We don't yet implement attributes in this context. */
6067 if (array_ptr_attrs
!= NULL_TREE
)
6068 warning_at (loc
, OPT_Wattributes
,
6069 "attributes in parameter array declarator ignored");
6071 size_varies
= false;
6073 else if (TREE_CODE (type
) == FUNCTION_TYPE
)
6075 if (type_quals
& TYPE_QUAL_ATOMIC
)
6078 "%<_Atomic%>-qualified function type");
6079 type_quals
&= ~TYPE_QUAL_ATOMIC
;
6081 else if (type_quals
)
6082 pedwarn (loc
, OPT_Wpedantic
,
6083 "ISO C forbids qualified function types");
6085 type
= c_build_qualified_type (type
, type_quals
);
6086 type
= c_build_pointer_type (type
);
6087 type_quals
= TYPE_UNQUALIFIED
;
6089 else if (type_quals
)
6090 type
= c_build_qualified_type (type
, type_quals
);
6092 decl
= build_decl (declarator
->id_loc
,
6093 PARM_DECL
, declarator
->u
.id
, type
);
6095 C_DECL_VARIABLE_SIZE (decl
) = 1;
6097 /* Compute the type actually passed in the parmlist,
6098 for the case where there is no prototype.
6099 (For example, shorts and chars are passed as ints.)
6100 When there is a prototype, this is overridden later. */
6102 if (type
== error_mark_node
)
6103 promoted_type
= type
;
6105 promoted_type
= c_type_promotes_to (type
);
6107 DECL_ARG_TYPE (decl
) = promoted_type
;
6108 if (declspecs
->inline_p
)
6109 pedwarn (loc
, 0, "parameter %q+D declared %<inline%>", decl
);
6110 if (declspecs
->noreturn_p
)
6111 pedwarn (loc
, 0, "parameter %q+D declared %<_Noreturn%>", decl
);
6113 else if (decl_context
== FIELD
)
6115 /* Note that the grammar rejects storage classes in typenames
6117 gcc_assert (storage_class
== csc_none
&& !threadp
6118 && !declspecs
->inline_p
&& !declspecs
->noreturn_p
);
6120 /* Structure field. It may not be a function. */
6122 if (TREE_CODE (type
) == FUNCTION_TYPE
)
6124 error_at (loc
, "field %qE declared as a function", name
);
6125 type
= build_pointer_type (type
);
6127 else if (TREE_CODE (type
) != ERROR_MARK
6128 && !COMPLETE_OR_UNBOUND_ARRAY_TYPE_P (type
))
6131 error_at (loc
, "field %qE has incomplete type", name
);
6133 error_at (loc
, "unnamed field has incomplete type");
6134 type
= error_mark_node
;
6136 type
= c_build_qualified_type (type
, type_quals
);
6137 decl
= build_decl (declarator
->id_loc
,
6138 FIELD_DECL
, declarator
->u
.id
, type
);
6139 DECL_NONADDRESSABLE_P (decl
) = bitfield
;
6140 if (bitfield
&& !declarator
->u
.id
)
6141 TREE_NO_WARNING (decl
) = 1;
6144 C_DECL_VARIABLE_SIZE (decl
) = 1;
6146 else if (TREE_CODE (type
) == FUNCTION_TYPE
)
6148 if (storage_class
== csc_register
|| threadp
)
6150 error_at (loc
, "invalid storage class for function %qE", name
);
6152 else if (current_scope
!= file_scope
)
6154 /* Function declaration not at file scope. Storage
6155 classes other than `extern' are not allowed, C99
6156 6.7.1p5, and `extern' makes no difference. However,
6157 GCC allows 'auto', perhaps with 'inline', to support
6158 nested functions. */
6159 if (storage_class
== csc_auto
)
6160 pedwarn (loc
, OPT_Wpedantic
,
6161 "invalid storage class for function %qE", name
);
6162 else if (storage_class
== csc_static
)
6164 error_at (loc
, "invalid storage class for function %qE", name
);
6166 storage_class
= declspecs
->storage_class
= csc_none
;
6172 decl
= build_decl (declarator
->id_loc
,
6173 FUNCTION_DECL
, declarator
->u
.id
, type
);
6174 decl
= build_decl_attribute_variant (decl
, decl_attr
);
6176 if (type_quals
& TYPE_QUAL_ATOMIC
)
6179 "%<_Atomic%>-qualified function type");
6180 type_quals
&= ~TYPE_QUAL_ATOMIC
;
6182 else if (pedantic
&& type_quals
&& !DECL_IN_SYSTEM_HEADER (decl
))
6183 pedwarn (loc
, OPT_Wpedantic
,
6184 "ISO C forbids qualified function types");
6186 /* Every function declaration is an external reference
6187 (DECL_EXTERNAL) except for those which are not at file
6188 scope and are explicitly declared "auto". This is
6189 forbidden by standard C (C99 6.7.1p5) and is interpreted by
6190 GCC to signify a forward declaration of a nested function. */
6191 if (storage_class
== csc_auto
&& current_scope
!= file_scope
)
6192 DECL_EXTERNAL (decl
) = 0;
6193 /* In C99, a function which is declared 'inline' with 'extern'
6194 is not an external reference (which is confusing). It
6195 means that the later definition of the function must be output
6196 in this file, C99 6.7.4p6. In GNU C89, a function declared
6197 'extern inline' is an external reference. */
6198 else if (declspecs
->inline_p
&& storage_class
!= csc_static
)
6199 DECL_EXTERNAL (decl
) = ((storage_class
== csc_extern
)
6200 == flag_gnu89_inline
);
6202 DECL_EXTERNAL (decl
) = !initialized
;
6204 /* Record absence of global scope for `static' or `auto'. */
6206 = !(storage_class
== csc_static
|| storage_class
== csc_auto
);
6208 /* For a function definition, record the argument information
6209 block where store_parm_decls will look for it. */
6211 current_function_arg_info
= arg_info
;
6213 if (declspecs
->default_int_p
)
6214 C_FUNCTION_IMPLICIT_INT (decl
) = 1;
6216 /* Record presence of `inline' and `_Noreturn', if it is
6218 if (flag_hosted
&& MAIN_NAME_P (declarator
->u
.id
))
6220 if (declspecs
->inline_p
)
6221 pedwarn (loc
, 0, "cannot inline function %<main%>");
6222 if (declspecs
->noreturn_p
)
6223 pedwarn (loc
, 0, "%<main%> declared %<_Noreturn%>");
6227 if (declspecs
->inline_p
)
6228 /* Record that the function is declared `inline'. */
6229 DECL_DECLARED_INLINE_P (decl
) = 1;
6230 if (declspecs
->noreturn_p
)
6235 pedwarn (loc
, OPT_Wpedantic
,
6236 "ISO C99 does not support %<_Noreturn%>");
6238 pedwarn (loc
, OPT_Wpedantic
,
6239 "ISO C90 does not support %<_Noreturn%>");
6241 TREE_THIS_VOLATILE (decl
) = 1;
6247 /* It's a variable. */
6248 /* An uninitialized decl with `extern' is a reference. */
6249 int extern_ref
= !initialized
&& storage_class
== csc_extern
;
6251 type
= c_build_qualified_type (type
, type_quals
);
6253 /* C99 6.2.2p7: It is invalid (compile-time undefined
6254 behavior) to create an 'extern' declaration for a
6255 variable if there is a global declaration that is
6256 'static' and the global declaration is not visible.
6257 (If the static declaration _is_ currently visible,
6258 the 'extern' declaration is taken to refer to that decl.) */
6259 if (extern_ref
&& current_scope
!= file_scope
)
6261 tree global_decl
= identifier_global_value (declarator
->u
.id
);
6262 tree visible_decl
= lookup_name (declarator
->u
.id
);
6265 && global_decl
!= visible_decl
6266 && TREE_CODE (global_decl
) == VAR_DECL
6267 && !TREE_PUBLIC (global_decl
))
6268 error_at (loc
, "variable previously declared %<static%> "
6269 "redeclared %<extern%>");
6272 decl
= build_decl (declarator
->id_loc
,
6273 VAR_DECL
, declarator
->u
.id
, type
);
6275 C_DECL_VARIABLE_SIZE (decl
) = 1;
6277 if (declspecs
->inline_p
)
6278 pedwarn (loc
, 0, "variable %q+D declared %<inline%>", decl
);
6279 if (declspecs
->noreturn_p
)
6280 pedwarn (loc
, 0, "variable %q+D declared %<_Noreturn%>", decl
);
6282 /* At file scope, an initialized extern declaration may follow
6283 a static declaration. In that case, DECL_EXTERNAL will be
6284 reset later in start_decl. */
6285 DECL_EXTERNAL (decl
) = (storage_class
== csc_extern
);
6287 /* At file scope, the presence of a `static' or `register' storage
6288 class specifier, or the absence of all storage class specifiers
6289 makes this declaration a definition (perhaps tentative). Also,
6290 the absence of `static' makes it public. */
6291 if (current_scope
== file_scope
)
6293 TREE_PUBLIC (decl
) = storage_class
!= csc_static
;
6294 TREE_STATIC (decl
) = !extern_ref
;
6296 /* Not at file scope, only `static' makes a static definition. */
6299 TREE_STATIC (decl
) = (storage_class
== csc_static
);
6300 TREE_PUBLIC (decl
) = extern_ref
;
6304 DECL_TLS_MODEL (decl
) = decl_default_tls_model (decl
);
6307 if ((storage_class
== csc_extern
6308 || (storage_class
== csc_none
6309 && TREE_CODE (type
) == FUNCTION_TYPE
6311 && variably_modified_type_p (type
, NULL_TREE
))
6314 if (TREE_CODE (type
) == FUNCTION_TYPE
)
6315 error_at (loc
, "non-nested function with variably modified type");
6317 error_at (loc
, "object with variably modified type must have "
6321 /* Record `register' declaration for warnings on &
6322 and in case doing stupid register allocation. */
6324 if (storage_class
== csc_register
)
6326 C_DECL_REGISTER (decl
) = 1;
6327 DECL_REGISTER (decl
) = 1;
6330 /* Record constancy and volatility. */
6331 c_apply_type_quals_to_decl (type_quals
, decl
);
6333 /* Apply _Alignas specifiers. */
6336 DECL_ALIGN (decl
) = alignas_align
* BITS_PER_UNIT
;
6337 DECL_USER_ALIGN (decl
) = 1;
6340 /* If a type has volatile components, it should be stored in memory.
6341 Otherwise, the fact that those components are volatile
6342 will be ignored, and would even crash the compiler.
6343 Of course, this only makes sense on VAR,PARM, and RESULT decl's. */
6344 if (C_TYPE_FIELDS_VOLATILE (TREE_TYPE (decl
))
6345 && (TREE_CODE (decl
) == VAR_DECL
|| TREE_CODE (decl
) == PARM_DECL
6346 || TREE_CODE (decl
) == RESULT_DECL
))
6348 /* It is not an error for a structure with volatile fields to
6349 be declared register, but reset DECL_REGISTER since it
6350 cannot actually go in a register. */
6351 int was_reg
= C_DECL_REGISTER (decl
);
6352 C_DECL_REGISTER (decl
) = 0;
6353 DECL_REGISTER (decl
) = 0;
6354 c_mark_addressable (decl
);
6355 C_DECL_REGISTER (decl
) = was_reg
;
6358 /* This is the earliest point at which we might know the assembler
6359 name of a variable. Thus, if it's known before this, die horribly. */
6360 gcc_assert (!DECL_ASSEMBLER_NAME_SET_P (decl
));
6363 && TREE_CODE (decl
) == VAR_DECL
6364 && TREE_PUBLIC (decl
)
6365 && TREE_STATIC (decl
)
6366 && (TREE_CODE (TREE_TYPE (decl
)) == RECORD_TYPE
6367 || TREE_CODE (TREE_TYPE (decl
)) == UNION_TYPE
6368 || TREE_CODE (TREE_TYPE (decl
)) == ENUMERAL_TYPE
)
6369 && TYPE_NAME (TREE_TYPE (decl
)) == NULL_TREE
)
6370 warning_at (DECL_SOURCE_LOCATION (decl
), OPT_Wc___compat
,
6371 ("non-local variable %qD with anonymous type is "
6372 "questionable in C++"),
6379 /* Decode the parameter-list info for a function type or function definition.
6380 The argument is the value returned by `get_parm_info' (or made in c-parse.c
6381 if there is an identifier list instead of a parameter decl list).
6382 These two functions are separate because when a function returns
6383 or receives functions then each is called multiple times but the order
6384 of calls is different. The last call to `grokparms' is always the one
6385 that contains the formal parameter names of a function definition.
6387 Return a list of arg types to use in the FUNCTION_TYPE for this function.
6389 FUNCDEF_FLAG is true for a function definition, false for
6390 a mere declaration. A nonempty identifier-list gets an error message
6391 when FUNCDEF_FLAG is false. */
6394 grokparms (struct c_arg_info
*arg_info
, bool funcdef_flag
)
6396 tree arg_types
= arg_info
->types
;
6398 if (funcdef_flag
&& arg_info
->had_vla_unspec
)
6400 /* A function definition isn't function prototype scope C99 6.2.1p4. */
6402 error ("%<[*]%> not allowed in other than function prototype scope");
6405 if (arg_types
== 0 && !funcdef_flag
6406 && !in_system_header_at (input_location
))
6407 warning (OPT_Wstrict_prototypes
,
6408 "function declaration isn%'t a prototype");
6410 if (arg_types
== error_mark_node
)
6411 return 0; /* don't set TYPE_ARG_TYPES in this case */
6413 else if (arg_types
&& TREE_CODE (TREE_VALUE (arg_types
)) == IDENTIFIER_NODE
)
6417 pedwarn (input_location
, 0, "parameter names (without types) in function declaration");
6418 arg_info
->parms
= NULL_TREE
;
6421 arg_info
->parms
= arg_info
->types
;
6423 arg_info
->types
= 0;
6428 tree parm
, type
, typelt
;
6429 unsigned int parmno
;
6432 /* If there is a parameter of incomplete type in a definition,
6433 this is an error. In a declaration this is valid, and a
6434 struct or union type may be completed later, before any calls
6435 or definition of the function. In the case where the tag was
6436 first declared within the parameter list, a warning has
6437 already been given. If a parameter has void type, then
6438 however the function cannot be defined or called, so
6441 for (parm
= arg_info
->parms
, typelt
= arg_types
, parmno
= 1;
6443 parm
= DECL_CHAIN (parm
), typelt
= TREE_CHAIN (typelt
), parmno
++)
6445 type
= TREE_VALUE (typelt
);
6446 if (type
== error_mark_node
)
6449 if (!COMPLETE_TYPE_P (type
))
6453 if (DECL_NAME (parm
))
6454 error_at (input_location
,
6455 "parameter %u (%q+D) has incomplete type",
6458 error_at (DECL_SOURCE_LOCATION (parm
),
6459 "parameter %u has incomplete type",
6462 TREE_VALUE (typelt
) = error_mark_node
;
6463 TREE_TYPE (parm
) = error_mark_node
;
6464 arg_types
= NULL_TREE
;
6466 else if (VOID_TYPE_P (type
))
6468 if (DECL_NAME (parm
))
6469 warning_at (input_location
, 0,
6470 "parameter %u (%q+D) has void type",
6473 warning_at (DECL_SOURCE_LOCATION (parm
), 0,
6474 "parameter %u has void type",
6479 errmsg
= targetm
.invalid_parameter_type (type
);
6483 TREE_VALUE (typelt
) = error_mark_node
;
6484 TREE_TYPE (parm
) = error_mark_node
;
6485 arg_types
= NULL_TREE
;
6488 if (DECL_NAME (parm
) && TREE_USED (parm
))
6489 warn_if_shadowing (parm
);
6495 /* Allocate and initialize a c_arg_info structure from the parser's
6499 build_arg_info (void)
6501 struct c_arg_info
*ret
= XOBNEW (&parser_obstack
, struct c_arg_info
);
6502 ret
->parms
= NULL_TREE
;
6504 ret
->types
= NULL_TREE
;
6505 ret
->others
= NULL_TREE
;
6506 ret
->pending_sizes
= NULL
;
6507 ret
->had_vla_unspec
= 0;
6511 /* Take apart the current scope and return a c_arg_info structure with
6512 info on a parameter list just parsed.
6514 This structure is later fed to 'grokparms' and 'store_parm_decls'.
6516 ELLIPSIS being true means the argument list ended in '...' so don't
6517 append a sentinel (void_list_node) to the end of the type-list.
6519 EXPR is NULL or an expression that needs to be evaluated for the
6520 side effects of array size expressions in the parameters. */
6523 get_parm_info (bool ellipsis
, tree expr
)
6525 struct c_binding
*b
= current_scope
->bindings
;
6526 struct c_arg_info
*arg_info
= build_arg_info ();
6529 vec
<c_arg_tag
, va_gc
> *tags
= NULL
;
6533 static bool explained_incomplete_types
= false;
6534 bool gave_void_only_once_err
= false;
6536 arg_info
->had_vla_unspec
= current_scope
->had_vla_unspec
;
6538 /* The bindings in this scope must not get put into a block.
6539 We will take care of deleting the binding nodes. */
6540 current_scope
->bindings
= 0;
6542 /* This function is only called if there was *something* on the
6546 /* A parameter list consisting solely of 'void' indicates that the
6547 function takes no arguments. But if the 'void' is qualified
6548 (by 'const' or 'volatile'), or has a storage class specifier
6549 ('register'), then the behavior is undefined; issue an error.
6550 Typedefs for 'void' are OK (see DR#157). */
6551 if (b
->prev
== 0 /* one binding */
6552 && TREE_CODE (b
->decl
) == PARM_DECL
/* which is a parameter */
6553 && !DECL_NAME (b
->decl
) /* anonymous */
6554 && VOID_TYPE_P (TREE_TYPE (b
->decl
))) /* of void type */
6556 if (TYPE_QUALS (TREE_TYPE (b
->decl
)) != TYPE_UNQUALIFIED
6557 || C_DECL_REGISTER (b
->decl
))
6558 error ("%<void%> as only parameter may not be qualified");
6560 /* There cannot be an ellipsis. */
6562 error ("%<void%> must be the only parameter");
6564 arg_info
->types
= void_list_node
;
6569 types
= void_list_node
;
6571 /* Break up the bindings list into parms, tags, types, and others;
6572 apply sanity checks; purge the name-to-decl bindings. */
6575 tree decl
= b
->decl
;
6576 tree type
= TREE_TYPE (decl
);
6578 const char *keyword
;
6580 switch (TREE_CODE (decl
))
6585 gcc_assert (I_SYMBOL_BINDING (b
->id
) == b
);
6586 I_SYMBOL_BINDING (b
->id
) = b
->shadowed
;
6589 /* Check for forward decls that never got their actual decl. */
6590 if (TREE_ASM_WRITTEN (decl
))
6591 error ("parameter %q+D has just a forward declaration", decl
);
6592 /* Check for (..., void, ...) and issue an error. */
6593 else if (VOID_TYPE_P (type
) && !DECL_NAME (decl
))
6595 if (!gave_void_only_once_err
)
6597 error ("%<void%> must be the only parameter");
6598 gave_void_only_once_err
= true;
6603 /* Valid parameter, add it to the list. */
6604 DECL_CHAIN (decl
) = parms
;
6607 /* Since there is a prototype, args are passed in their
6608 declared types. The back end may override this later. */
6609 DECL_ARG_TYPE (decl
) = type
;
6610 types
= tree_cons (0, type
, types
);
6614 case ENUMERAL_TYPE
: keyword
= "enum"; goto tag
;
6615 case UNION_TYPE
: keyword
= "union"; goto tag
;
6616 case RECORD_TYPE
: keyword
= "struct"; goto tag
;
6618 /* Types may not have tag-names, in which case the type
6619 appears in the bindings list with b->id NULL. */
6622 gcc_assert (I_TAG_BINDING (b
->id
) == b
);
6623 I_TAG_BINDING (b
->id
) = b
->shadowed
;
6626 /* Warn about any struct, union or enum tags defined in a
6627 parameter list. The scope of such types is limited to
6628 the parameter list, which is rarely if ever desirable
6629 (it's impossible to call such a function with type-
6630 correct arguments). An anonymous union parm type is
6631 meaningful as a GNU extension, so don't warn for that. */
6632 if (TREE_CODE (decl
) != UNION_TYPE
|| b
->id
!= 0)
6635 /* The %s will be one of 'struct', 'union', or 'enum'. */
6636 warning (0, "%<%s %E%> declared inside parameter list",
6639 /* The %s will be one of 'struct', 'union', or 'enum'. */
6640 warning (0, "anonymous %s declared inside parameter list",
6643 if (!explained_incomplete_types
)
6645 warning (0, "its scope is only this definition or declaration,"
6646 " which is probably not what you want");
6647 explained_incomplete_types
= true;
6653 vec_safe_push (tags
, tag
);
6659 /* CONST_DECLs appear here when we have an embedded enum,
6660 and TYPE_DECLs appear here when we have an embedded struct
6661 or union. No warnings for this - we already warned about the
6662 type itself. FUNCTION_DECLs appear when there is an implicit
6663 function declaration in the parameter list. */
6665 /* When we reinsert this decl in the function body, we need
6666 to reconstruct whether it was marked as nested. */
6667 gcc_assert (TREE_CODE (decl
) == FUNCTION_DECL
6670 DECL_CHAIN (decl
) = others
;
6675 /* error_mark_node appears here when we have an undeclared
6676 variable. Just throw it away. */
6679 gcc_assert (I_SYMBOL_BINDING (b
->id
) == b
);
6680 I_SYMBOL_BINDING (b
->id
) = b
->shadowed
;
6684 /* Other things that might be encountered. */
6691 b
= free_binding_and_advance (b
);
6694 arg_info
->parms
= parms
;
6695 arg_info
->tags
= tags
;
6696 arg_info
->types
= types
;
6697 arg_info
->others
= others
;
6698 arg_info
->pending_sizes
= expr
;
6702 /* Get the struct, enum or union (CODE says which) with tag NAME.
6703 Define the tag as a forward-reference with location LOC if it is
6704 not defined. Return a c_typespec structure for the type
6708 parser_xref_tag (location_t loc
, enum tree_code code
, tree name
)
6710 struct c_typespec ret
;
6714 ret
.expr
= NULL_TREE
;
6715 ret
.expr_const_operands
= true;
6717 /* If a cross reference is requested, look up the type
6718 already defined for this tag and return it. */
6720 ref
= lookup_tag (code
, name
, 0, &refloc
);
6721 /* If this is the right type of tag, return what we found.
6722 (This reference will be shadowed by shadow_tag later if appropriate.)
6723 If this is the wrong type of tag, do not return it. If it was the
6724 wrong type in the same scope, we will have had an error
6725 message already; if in a different scope and declaring
6726 a name, pending_xref_error will give an error message; but if in a
6727 different scope and not declaring a name, this tag should
6728 shadow the previous declaration of a different type of tag, and
6729 this would not work properly if we return the reference found.
6730 (For example, with "struct foo" in an outer scope, "union foo;"
6731 must shadow that tag with a new one of union type.) */
6732 ret
.kind
= (ref
? ctsk_tagref
: ctsk_tagfirstref
);
6733 if (ref
&& TREE_CODE (ref
) == code
)
6735 if (C_TYPE_DEFINED_IN_STRUCT (ref
)
6736 && loc
!= UNKNOWN_LOCATION
6742 warning_at (loc
, OPT_Wc___compat
,
6743 ("enum type defined in struct or union "
6744 "is not visible in C++"));
6745 inform (refloc
, "enum type defined here");
6748 warning_at (loc
, OPT_Wc___compat
,
6749 ("struct defined in struct or union "
6750 "is not visible in C++"));
6751 inform (refloc
, "struct defined here");
6754 warning_at (loc
, OPT_Wc___compat
,
6755 ("union defined in struct or union "
6756 "is not visible in C++"));
6757 inform (refloc
, "union defined here");
6768 /* If no such tag is yet defined, create a forward-reference node
6769 and record it as the "definition".
6770 When a real declaration of this type is found,
6771 the forward-reference will be altered into a real type. */
6773 ref
= make_node (code
);
6774 if (code
== ENUMERAL_TYPE
)
6776 /* Give the type a default layout like unsigned int
6777 to avoid crashing if it does not get defined. */
6778 SET_TYPE_MODE (ref
, TYPE_MODE (unsigned_type_node
));
6779 TYPE_ALIGN (ref
) = TYPE_ALIGN (unsigned_type_node
);
6780 TYPE_USER_ALIGN (ref
) = 0;
6781 TYPE_UNSIGNED (ref
) = 1;
6782 TYPE_PRECISION (ref
) = TYPE_PRECISION (unsigned_type_node
);
6783 TYPE_MIN_VALUE (ref
) = TYPE_MIN_VALUE (unsigned_type_node
);
6784 TYPE_MAX_VALUE (ref
) = TYPE_MAX_VALUE (unsigned_type_node
);
6787 pushtag (loc
, name
, ref
);
6793 /* Get the struct, enum or union (CODE says which) with tag NAME.
6794 Define the tag as a forward-reference if it is not defined.
6795 Return a tree for the type. */
6798 xref_tag (enum tree_code code
, tree name
)
6800 return parser_xref_tag (input_location
, code
, name
).spec
;
6803 /* Make sure that the tag NAME is defined *in the current scope*
6804 at least as a forward reference.
6805 LOC is the location of the struct's definition.
6806 CODE says which kind of tag NAME ought to be.
6808 This stores the current value of the file static STRUCT_PARSE_INFO
6809 in *ENCLOSING_STRUCT_PARSE_INFO, and points STRUCT_PARSE_INFO at a
6810 new c_struct_parse_info structure. The old value of
6811 STRUCT_PARSE_INFO is restored in finish_struct. */
6814 start_struct (location_t loc
, enum tree_code code
, tree name
,
6815 struct c_struct_parse_info
**enclosing_struct_parse_info
)
6817 /* If there is already a tag defined at this scope
6818 (as a forward reference), just return it. */
6820 tree ref
= NULL_TREE
;
6821 location_t refloc
= UNKNOWN_LOCATION
;
6823 if (name
!= NULL_TREE
)
6824 ref
= lookup_tag (code
, name
, 1, &refloc
);
6825 if (ref
&& TREE_CODE (ref
) == code
)
6827 if (TYPE_SIZE (ref
))
6829 if (code
== UNION_TYPE
)
6830 error_at (loc
, "redefinition of %<union %E%>", name
);
6832 error_at (loc
, "redefinition of %<struct %E%>", name
);
6833 if (refloc
!= UNKNOWN_LOCATION
)
6834 inform (refloc
, "originally defined here");
6835 /* Don't create structures using a name already in use. */
6838 else if (C_TYPE_BEING_DEFINED (ref
))
6840 if (code
== UNION_TYPE
)
6841 error_at (loc
, "nested redefinition of %<union %E%>", name
);
6843 error_at (loc
, "nested redefinition of %<struct %E%>", name
);
6844 /* Don't bother to report "originally defined here" for a
6845 nested redefinition; the original definition should be
6847 /* Don't create structures that contain themselves. */
6852 /* Otherwise create a forward-reference just so the tag is in scope. */
6854 if (ref
== NULL_TREE
|| TREE_CODE (ref
) != code
)
6856 ref
= make_node (code
);
6857 pushtag (loc
, name
, ref
);
6860 C_TYPE_BEING_DEFINED (ref
) = 1;
6861 TYPE_PACKED (ref
) = flag_pack_struct
;
6863 *enclosing_struct_parse_info
= struct_parse_info
;
6864 struct_parse_info
= XNEW (struct c_struct_parse_info
);
6865 struct_parse_info
->struct_types
.create (0);
6866 struct_parse_info
->fields
.create (0);
6867 struct_parse_info
->typedefs_seen
.create (0);
6869 /* FIXME: This will issue a warning for a use of a type defined
6870 within a statement expr used within sizeof, et. al. This is not
6871 terribly serious as C++ doesn't permit statement exprs within
6873 if (warn_cxx_compat
&& (in_sizeof
|| in_typeof
|| in_alignof
))
6874 warning_at (loc
, OPT_Wc___compat
,
6875 "defining type in %qs expression is invalid in C++",
6878 : (in_typeof
? "typeof" : "alignof")));
6883 /* Process the specs, declarator and width (NULL if omitted)
6884 of a structure component, returning a FIELD_DECL node.
6885 WIDTH is non-NULL for bit-fields only, and is an INTEGER_CST node.
6886 DECL_ATTRS is as for grokdeclarator.
6888 LOC is the location of the structure component.
6890 This is done during the parsing of the struct declaration.
6891 The FIELD_DECL nodes are chained together and the lot of them
6892 are ultimately passed to `build_struct' to make the RECORD_TYPE node. */
6895 grokfield (location_t loc
,
6896 struct c_declarator
*declarator
, struct c_declspecs
*declspecs
,
6897 tree width
, tree
*decl_attrs
)
6901 if (declarator
->kind
== cdk_id
&& declarator
->u
.id
== NULL_TREE
6902 && width
== NULL_TREE
)
6904 /* This is an unnamed decl.
6906 If we have something of the form "union { list } ;" then this
6907 is the anonymous union extension. Similarly for struct.
6909 If this is something of the form "struct foo;", then
6910 If MS or Plan 9 extensions are enabled, this is handled as
6911 an anonymous struct.
6912 Otherwise this is a forward declaration of a structure tag.
6914 If this is something of the form "foo;" and foo is a TYPE_DECL, then
6915 If foo names a structure or union without a tag, then this
6916 is an anonymous struct (this is permitted by C11).
6917 If MS or Plan 9 extensions are enabled and foo names a
6918 structure, then again this is an anonymous struct.
6919 Otherwise this is an error.
6921 Oh what a horrid tangled web we weave. I wonder if MS consciously
6922 took this from Plan 9 or if it was an accident of implementation
6923 that took root before someone noticed the bug... */
6925 tree type
= declspecs
->type
;
6926 bool type_ok
= (TREE_CODE (type
) == RECORD_TYPE
6927 || TREE_CODE (type
) == UNION_TYPE
);
6931 && (flag_ms_extensions
6932 || flag_plan9_extensions
6933 || !declspecs
->typedef_p
))
6935 if (flag_ms_extensions
|| flag_plan9_extensions
)
6937 else if (TYPE_NAME (type
) == NULL
)
6944 pedwarn (loc
, 0, "declaration does not declare anything");
6950 pedwarn (loc
, OPT_Wpedantic
,
6951 "ISO C99 doesn%'t support unnamed structs/unions");
6953 pedwarn (loc
, OPT_Wpedantic
,
6954 "ISO C90 doesn%'t support unnamed structs/unions");
6958 value
= grokdeclarator (declarator
, declspecs
, FIELD
, false,
6959 width
? &width
: NULL
, decl_attrs
, NULL
, NULL
,
6962 finish_decl (value
, loc
, NULL_TREE
, NULL_TREE
, NULL_TREE
);
6963 DECL_INITIAL (value
) = width
;
6965 if (warn_cxx_compat
&& DECL_NAME (value
) != NULL_TREE
)
6967 /* If we currently have a binding for this field, set the
6968 in_struct field in the binding, so that we warn about lookups
6970 struct c_binding
*b
= I_SYMBOL_BINDING (DECL_NAME (value
));
6973 /* If the in_struct field is not yet set, push it on a list
6974 to be cleared when this struct is finished. */
6977 struct_parse_info
->fields
.safe_push (b
);
6986 /* Subroutine of detect_field_duplicates: return whether X and Y,
6987 which are both fields in the same struct, have duplicate field
6991 is_duplicate_field (tree x
, tree y
)
6993 if (DECL_NAME (x
) != NULL_TREE
&& DECL_NAME (x
) == DECL_NAME (y
))
6996 /* When using -fplan9-extensions, an anonymous field whose name is a
6997 typedef can duplicate a field name. */
6998 if (flag_plan9_extensions
6999 && (DECL_NAME (x
) == NULL_TREE
|| DECL_NAME (y
) == NULL_TREE
))
7001 tree xt
, xn
, yt
, yn
;
7004 if (DECL_NAME (x
) != NULL_TREE
)
7006 else if ((TREE_CODE (xt
) == RECORD_TYPE
|| TREE_CODE (xt
) == UNION_TYPE
)
7007 && TYPE_NAME (xt
) != NULL_TREE
7008 && TREE_CODE (TYPE_NAME (xt
)) == TYPE_DECL
)
7009 xn
= DECL_NAME (TYPE_NAME (xt
));
7014 if (DECL_NAME (y
) != NULL_TREE
)
7016 else if ((TREE_CODE (yt
) == RECORD_TYPE
|| TREE_CODE (yt
) == UNION_TYPE
)
7017 && TYPE_NAME (yt
) != NULL_TREE
7018 && TREE_CODE (TYPE_NAME (yt
)) == TYPE_DECL
)
7019 yn
= DECL_NAME (TYPE_NAME (yt
));
7023 if (xn
!= NULL_TREE
&& xn
== yn
)
7030 /* Subroutine of detect_field_duplicates: add the fields of FIELDLIST
7031 to HTAB, giving errors for any duplicates. */
7034 detect_field_duplicates_hash (tree fieldlist
,
7035 hash_table
<pointer_hash
<tree_node
> > htab
)
7040 for (x
= fieldlist
; x
; x
= DECL_CHAIN (x
))
7041 if ((y
= DECL_NAME (x
)) != 0)
7043 slot
= htab
.find_slot (y
, INSERT
);
7046 error ("duplicate member %q+D", x
);
7047 DECL_NAME (x
) = NULL_TREE
;
7051 else if (TREE_CODE (TREE_TYPE (x
)) == RECORD_TYPE
7052 || TREE_CODE (TREE_TYPE (x
)) == UNION_TYPE
)
7054 detect_field_duplicates_hash (TYPE_FIELDS (TREE_TYPE (x
)), htab
);
7056 /* When using -fplan9-extensions, an anonymous field whose
7057 name is a typedef can duplicate a field name. */
7058 if (flag_plan9_extensions
7059 && TYPE_NAME (TREE_TYPE (x
)) != NULL_TREE
7060 && TREE_CODE (TYPE_NAME (TREE_TYPE (x
))) == TYPE_DECL
)
7062 tree xn
= DECL_NAME (TYPE_NAME (TREE_TYPE (x
)));
7063 slot
= htab
.find_slot (xn
, INSERT
);
7065 error ("duplicate member %q+D", TYPE_NAME (TREE_TYPE (x
)));
7071 /* Generate an error for any duplicate field names in FIELDLIST. Munge
7072 the list such that this does not present a problem later. */
7075 detect_field_duplicates (tree fieldlist
)
7080 /* If the struct is the list of instance variables of an Objective-C
7081 class, then we need to check all the instance variables of
7082 superclasses when checking for duplicates (since you can't have
7083 an instance variable in a subclass with the same name as an
7084 instance variable in a superclass). We pass on this job to the
7085 Objective-C compiler. objc_detect_field_duplicates() will return
7086 false if we are not checking the list of instance variables and
7087 the C frontend should proceed with the standard field duplicate
7088 checks. If we are checking the list of instance variables, the
7089 ObjC frontend will do the check, emit the errors if needed, and
7090 then return true. */
7091 if (c_dialect_objc ())
7092 if (objc_detect_field_duplicates (false))
7095 /* First, see if there are more than "a few" fields.
7096 This is trivially true if there are zero or one fields. */
7097 if (!fieldlist
|| !DECL_CHAIN (fieldlist
))
7102 if (DECL_NAME (x
) == NULL_TREE
7103 && (TREE_CODE (TREE_TYPE (x
)) == RECORD_TYPE
7104 || TREE_CODE (TREE_TYPE (x
)) == UNION_TYPE
))
7107 } while (timeout
> 0 && x
);
7109 /* If there were "few" fields and no anonymous structures or unions,
7110 avoid the overhead of allocating a hash table. Instead just do
7111 the nested traversal thing. */
7114 for (x
= DECL_CHAIN (fieldlist
); x
; x
= DECL_CHAIN (x
))
7115 /* When using -fplan9-extensions, we can have duplicates
7116 between typedef names and fields. */
7118 || (flag_plan9_extensions
7119 && DECL_NAME (x
) == NULL_TREE
7120 && (TREE_CODE (TREE_TYPE (x
)) == RECORD_TYPE
7121 || TREE_CODE (TREE_TYPE (x
)) == UNION_TYPE
)
7122 && TYPE_NAME (TREE_TYPE (x
)) != NULL_TREE
7123 && TREE_CODE (TYPE_NAME (TREE_TYPE (x
))) == TYPE_DECL
))
7125 for (y
= fieldlist
; y
!= x
; y
= TREE_CHAIN (y
))
7126 if (is_duplicate_field (y
, x
))
7128 error ("duplicate member %q+D", x
);
7129 DECL_NAME (x
) = NULL_TREE
;
7135 hash_table
<pointer_hash
<tree_node
> > htab
;
7138 detect_field_duplicates_hash (fieldlist
, htab
);
7143 /* Finish up struct info used by -Wc++-compat. */
7146 warn_cxx_compat_finish_struct (tree fieldlist
)
7150 struct c_binding
*b
;
7152 /* Set the C_TYPE_DEFINED_IN_STRUCT flag for each type defined in
7153 the current struct. We do this now at the end of the struct
7154 because the flag is used to issue visibility warnings, and we
7155 only want to issue those warnings if the type is referenced
7156 outside of the struct declaration. */
7157 FOR_EACH_VEC_ELT (struct_parse_info
->struct_types
, ix
, x
)
7158 C_TYPE_DEFINED_IN_STRUCT (x
) = 1;
7160 /* The TYPEDEFS_SEEN field of STRUCT_PARSE_INFO is a list of
7161 typedefs used when declaring fields in this struct. If the name
7162 of any of the fields is also a typedef name then the struct would
7163 not parse in C++, because the C++ lookup rules say that the
7164 typedef name would be looked up in the context of the struct, and
7165 would thus be the field rather than the typedef. */
7166 if (!struct_parse_info
->typedefs_seen
.is_empty ()
7167 && fieldlist
!= NULL_TREE
)
7169 /* Use a pointer_set using the name of the typedef. We can use
7170 a pointer_set because identifiers are interned. */
7171 struct pointer_set_t
*tset
= pointer_set_create ();
7173 FOR_EACH_VEC_ELT (struct_parse_info
->typedefs_seen
, ix
, x
)
7174 pointer_set_insert (tset
, DECL_NAME (x
));
7176 for (x
= fieldlist
; x
!= NULL_TREE
; x
= DECL_CHAIN (x
))
7178 if (DECL_NAME (x
) != NULL_TREE
7179 && pointer_set_contains (tset
, DECL_NAME (x
)))
7181 warning_at (DECL_SOURCE_LOCATION (x
), OPT_Wc___compat
,
7182 ("using %qD as both field and typedef name is "
7185 /* FIXME: It would be nice to report the location where
7186 the typedef name is used. */
7190 pointer_set_destroy (tset
);
7193 /* For each field which has a binding and which was not defined in
7194 an enclosing struct, clear the in_struct field. */
7195 FOR_EACH_VEC_ELT (struct_parse_info
->fields
, ix
, b
)
7199 /* Fill in the fields of a RECORD_TYPE or UNION_TYPE node, T.
7200 LOC is the location of the RECORD_TYPE or UNION_TYPE's definition.
7201 FIELDLIST is a chain of FIELD_DECL nodes for the fields.
7202 ATTRIBUTES are attributes to be applied to the structure.
7204 ENCLOSING_STRUCT_PARSE_INFO is the value of STRUCT_PARSE_INFO when
7205 the struct was started. */
7208 finish_struct (location_t loc
, tree t
, tree fieldlist
, tree attributes
,
7209 struct c_struct_parse_info
*enclosing_struct_parse_info
)
7212 bool toplevel
= file_scope
== current_scope
;
7213 int saw_named_field
;
7215 /* If this type was previously laid out as a forward reference,
7216 make sure we lay it out again. */
7220 decl_attributes (&t
, attributes
, (int) ATTR_FLAG_TYPE_IN_PLACE
);
7224 for (x
= fieldlist
; x
; x
= DECL_CHAIN (x
))
7226 if (DECL_NAME (x
) != 0)
7229 && (TREE_CODE (TREE_TYPE (x
)) == RECORD_TYPE
7230 || TREE_CODE (TREE_TYPE (x
)) == UNION_TYPE
))
7236 if (TREE_CODE (t
) == UNION_TYPE
)
7239 pedwarn (loc
, OPT_Wpedantic
, "union has no named members");
7241 pedwarn (loc
, OPT_Wpedantic
, "union has no members");
7246 pedwarn (loc
, OPT_Wpedantic
, "struct has no named members");
7248 pedwarn (loc
, OPT_Wpedantic
, "struct has no members");
7253 /* Install struct as DECL_CONTEXT of each field decl.
7254 Also process specified field sizes, found in the DECL_INITIAL,
7255 storing 0 there after the type has been changed to precision equal
7256 to its width, rather than the precision of the specified standard
7257 type. (Correct layout requires the original type to have been preserved
7260 saw_named_field
= 0;
7261 for (x
= fieldlist
; x
; x
= DECL_CHAIN (x
))
7263 if (TREE_TYPE (x
) == error_mark_node
)
7266 DECL_CONTEXT (x
) = t
;
7268 /* If any field is const, the structure type is pseudo-const. */
7269 if (TREE_READONLY (x
))
7270 C_TYPE_FIELDS_READONLY (t
) = 1;
7273 /* A field that is pseudo-const makes the structure likewise. */
7274 tree t1
= strip_array_types (TREE_TYPE (x
));
7275 if ((TREE_CODE (t1
) == RECORD_TYPE
|| TREE_CODE (t1
) == UNION_TYPE
)
7276 && C_TYPE_FIELDS_READONLY (t1
))
7277 C_TYPE_FIELDS_READONLY (t
) = 1;
7280 /* Any field that is volatile means variables of this type must be
7281 treated in some ways as volatile. */
7282 if (TREE_THIS_VOLATILE (x
))
7283 C_TYPE_FIELDS_VOLATILE (t
) = 1;
7285 /* Any field of nominal variable size implies structure is too. */
7286 if (C_DECL_VARIABLE_SIZE (x
))
7287 C_TYPE_VARIABLE_SIZE (t
) = 1;
7289 if (DECL_INITIAL (x
))
7291 unsigned HOST_WIDE_INT width
= tree_to_uhwi (DECL_INITIAL (x
));
7292 DECL_SIZE (x
) = bitsize_int (width
);
7293 DECL_BIT_FIELD (x
) = 1;
7294 SET_DECL_C_BIT_FIELD (x
);
7298 && (DECL_BIT_FIELD (x
)
7299 || TYPE_ALIGN (TREE_TYPE (x
)) > BITS_PER_UNIT
))
7300 DECL_PACKED (x
) = 1;
7302 /* Detect flexible array member in an invalid context. */
7303 if (TREE_CODE (TREE_TYPE (x
)) == ARRAY_TYPE
7304 && TYPE_SIZE (TREE_TYPE (x
)) == NULL_TREE
7305 && TYPE_DOMAIN (TREE_TYPE (x
)) != NULL_TREE
7306 && TYPE_MAX_VALUE (TYPE_DOMAIN (TREE_TYPE (x
))) == NULL_TREE
)
7308 if (TREE_CODE (t
) == UNION_TYPE
)
7310 error_at (DECL_SOURCE_LOCATION (x
),
7311 "flexible array member in union");
7312 TREE_TYPE (x
) = error_mark_node
;
7314 else if (DECL_CHAIN (x
) != NULL_TREE
)
7316 error_at (DECL_SOURCE_LOCATION (x
),
7317 "flexible array member not at end of struct");
7318 TREE_TYPE (x
) = error_mark_node
;
7320 else if (!saw_named_field
)
7322 error_at (DECL_SOURCE_LOCATION (x
),
7323 "flexible array member in otherwise empty struct");
7324 TREE_TYPE (x
) = error_mark_node
;
7328 if (pedantic
&& TREE_CODE (t
) == RECORD_TYPE
7329 && flexible_array_type_p (TREE_TYPE (x
)))
7330 pedwarn (DECL_SOURCE_LOCATION (x
), OPT_Wpedantic
,
7331 "invalid use of structure with flexible array member");
7334 || TREE_CODE (TREE_TYPE (x
)) == RECORD_TYPE
7335 || TREE_CODE (TREE_TYPE (x
)) == UNION_TYPE
)
7336 saw_named_field
= 1;
7339 detect_field_duplicates (fieldlist
);
7341 /* Now we have the nearly final fieldlist. Record it,
7342 then lay out the structure or union (including the fields). */
7344 TYPE_FIELDS (t
) = fieldlist
;
7348 if (TYPE_SIZE_UNIT (t
)
7349 && TREE_CODE (TYPE_SIZE_UNIT (t
)) == INTEGER_CST
7350 && !TREE_OVERFLOW (TYPE_SIZE_UNIT (t
))
7351 && !valid_constant_size_p (TYPE_SIZE_UNIT (t
)))
7352 error ("type %qT is too large", t
);
7354 /* Give bit-fields their proper types. */
7356 tree
*fieldlistp
= &fieldlist
;
7358 if (TREE_CODE (*fieldlistp
) == FIELD_DECL
&& DECL_INITIAL (*fieldlistp
)
7359 && TREE_TYPE (*fieldlistp
) != error_mark_node
)
7361 unsigned HOST_WIDE_INT width
7362 = tree_to_uhwi (DECL_INITIAL (*fieldlistp
));
7363 tree type
= TREE_TYPE (*fieldlistp
);
7364 if (width
!= TYPE_PRECISION (type
))
7366 TREE_TYPE (*fieldlistp
)
7367 = c_build_bitfield_integer_type (width
, TYPE_UNSIGNED (type
));
7368 DECL_MODE (*fieldlistp
) = TYPE_MODE (TREE_TYPE (*fieldlistp
));
7370 DECL_INITIAL (*fieldlistp
) = 0;
7373 fieldlistp
= &DECL_CHAIN (*fieldlistp
);
7376 /* Now we have the truly final field list.
7377 Store it in this type and in the variants. */
7379 TYPE_FIELDS (t
) = fieldlist
;
7381 /* If there are lots of fields, sort so we can look through them fast.
7382 We arbitrarily consider 16 or more elts to be "a lot". */
7387 for (x
= fieldlist
; x
; x
= DECL_CHAIN (x
))
7389 if (len
> 15 || DECL_NAME (x
) == NULL
)
7397 struct lang_type
*space
;
7398 struct sorted_fields_type
*space2
;
7400 len
+= list_length (x
);
7402 /* Use the same allocation policy here that make_node uses, to
7403 ensure that this lives as long as the rest of the struct decl.
7404 All decls in an inline function need to be saved. */
7406 space
= ggc_alloc_cleared_lang_type (sizeof (struct lang_type
));
7407 space2
= ggc_alloc_sorted_fields_type
7408 (sizeof (struct sorted_fields_type
) + len
* sizeof (tree
));
7412 field_array
= &space2
->elts
[0];
7413 for (x
= fieldlist
; x
; x
= DECL_CHAIN (x
))
7415 field_array
[len
++] = x
;
7417 /* If there is anonymous struct or union, break out of the loop. */
7418 if (DECL_NAME (x
) == NULL
)
7421 /* Found no anonymous struct/union. Add the TYPE_LANG_SPECIFIC. */
7424 TYPE_LANG_SPECIFIC (t
) = space
;
7425 TYPE_LANG_SPECIFIC (t
)->s
->len
= len
;
7426 field_array
= TYPE_LANG_SPECIFIC (t
)->s
->elts
;
7427 qsort (field_array
, len
, sizeof (tree
), field_decl_cmp
);
7432 for (x
= TYPE_MAIN_VARIANT (t
); x
; x
= TYPE_NEXT_VARIANT (x
))
7434 TYPE_FIELDS (x
) = TYPE_FIELDS (t
);
7435 TYPE_LANG_SPECIFIC (x
) = TYPE_LANG_SPECIFIC (t
);
7436 C_TYPE_FIELDS_READONLY (x
) = C_TYPE_FIELDS_READONLY (t
);
7437 C_TYPE_FIELDS_VOLATILE (x
) = C_TYPE_FIELDS_VOLATILE (t
);
7438 C_TYPE_VARIABLE_SIZE (x
) = C_TYPE_VARIABLE_SIZE (t
);
7441 /* If this was supposed to be a transparent union, but we can't
7442 make it one, warn and turn off the flag. */
7443 if (TREE_CODE (t
) == UNION_TYPE
7444 && TYPE_TRANSPARENT_AGGR (t
)
7445 && (!TYPE_FIELDS (t
) || TYPE_MODE (t
) != DECL_MODE (TYPE_FIELDS (t
))))
7447 TYPE_TRANSPARENT_AGGR (t
) = 0;
7448 warning_at (loc
, 0, "union cannot be made transparent");
7451 /* If this structure or union completes the type of any previous
7452 variable declaration, lay it out and output its rtl. */
7453 for (x
= C_TYPE_INCOMPLETE_VARS (TYPE_MAIN_VARIANT (t
));
7457 tree decl
= TREE_VALUE (x
);
7458 if (TREE_CODE (TREE_TYPE (decl
)) == ARRAY_TYPE
)
7459 layout_array_type (TREE_TYPE (decl
));
7460 if (TREE_CODE (decl
) != TYPE_DECL
)
7462 layout_decl (decl
, 0);
7463 if (c_dialect_objc ())
7464 objc_check_decl (decl
);
7465 rest_of_decl_compilation (decl
, toplevel
, 0);
7468 C_TYPE_INCOMPLETE_VARS (TYPE_MAIN_VARIANT (t
)) = 0;
7470 /* Update type location to the one of the definition, instead of e.g.
7471 a forward declaration. */
7472 if (TYPE_STUB_DECL (t
))
7473 DECL_SOURCE_LOCATION (TYPE_STUB_DECL (t
)) = loc
;
7475 /* Finish debugging output for this type. */
7476 rest_of_type_compilation (t
, toplevel
);
7478 /* If we're inside a function proper, i.e. not file-scope and not still
7479 parsing parameters, then arrange for the size of a variable sized type
7481 if (building_stmt_list_p () && variably_modified_type_p (t
, NULL_TREE
))
7482 add_stmt (build_stmt (loc
,
7483 DECL_EXPR
, build_decl (loc
, TYPE_DECL
, NULL
, t
)));
7485 if (warn_cxx_compat
)
7486 warn_cxx_compat_finish_struct (fieldlist
);
7488 struct_parse_info
->struct_types
.release ();
7489 struct_parse_info
->fields
.release ();
7490 struct_parse_info
->typedefs_seen
.release ();
7491 XDELETE (struct_parse_info
);
7493 struct_parse_info
= enclosing_struct_parse_info
;
7495 /* If this struct is defined inside a struct, add it to
7498 && struct_parse_info
!= NULL
7499 && !in_sizeof
&& !in_typeof
&& !in_alignof
)
7500 struct_parse_info
->struct_types
.safe_push (t
);
7505 /* Lay out the type T, and its element type, and so on. */
7508 layout_array_type (tree t
)
7510 if (TREE_CODE (TREE_TYPE (t
)) == ARRAY_TYPE
)
7511 layout_array_type (TREE_TYPE (t
));
7515 /* Begin compiling the definition of an enumeration type.
7516 NAME is its name (or null if anonymous).
7517 LOC is the enum's location.
7518 Returns the type object, as yet incomplete.
7519 Also records info about it so that build_enumerator
7520 may be used to declare the individual values as they are read. */
7523 start_enum (location_t loc
, struct c_enum_contents
*the_enum
, tree name
)
7525 tree enumtype
= NULL_TREE
;
7526 location_t enumloc
= UNKNOWN_LOCATION
;
7528 /* If this is the real definition for a previous forward reference,
7529 fill in the contents in the same object that used to be the
7530 forward reference. */
7532 if (name
!= NULL_TREE
)
7533 enumtype
= lookup_tag (ENUMERAL_TYPE
, name
, 1, &enumloc
);
7535 if (enumtype
== 0 || TREE_CODE (enumtype
) != ENUMERAL_TYPE
)
7537 enumtype
= make_node (ENUMERAL_TYPE
);
7538 pushtag (loc
, name
, enumtype
);
7541 if (C_TYPE_BEING_DEFINED (enumtype
))
7542 error_at (loc
, "nested redefinition of %<enum %E%>", name
);
7544 C_TYPE_BEING_DEFINED (enumtype
) = 1;
7546 if (TYPE_VALUES (enumtype
) != 0)
7548 /* This enum is a named one that has been declared already. */
7549 error_at (loc
, "redeclaration of %<enum %E%>", name
);
7550 if (enumloc
!= UNKNOWN_LOCATION
)
7551 inform (enumloc
, "originally defined here");
7553 /* Completely replace its old definition.
7554 The old enumerators remain defined, however. */
7555 TYPE_VALUES (enumtype
) = 0;
7558 the_enum
->enum_next_value
= integer_zero_node
;
7559 the_enum
->enum_overflow
= 0;
7561 if (flag_short_enums
)
7562 TYPE_PACKED (enumtype
) = 1;
7564 /* FIXME: This will issue a warning for a use of a type defined
7565 within sizeof in a statement expr. This is not terribly serious
7566 as C++ doesn't permit statement exprs within sizeof anyhow. */
7567 if (warn_cxx_compat
&& (in_sizeof
|| in_typeof
|| in_alignof
))
7568 warning_at (loc
, OPT_Wc___compat
,
7569 "defining type in %qs expression is invalid in C++",
7572 : (in_typeof
? "typeof" : "alignof")));
7577 /* After processing and defining all the values of an enumeration type,
7578 install their decls in the enumeration type and finish it off.
7579 ENUMTYPE is the type object, VALUES a list of decl-value pairs,
7580 and ATTRIBUTES are the specified attributes.
7581 Returns ENUMTYPE. */
7584 finish_enum (tree enumtype
, tree values
, tree attributes
)
7587 tree minnode
= 0, maxnode
= 0;
7588 int precision
, unsign
;
7589 bool toplevel
= (file_scope
== current_scope
);
7590 struct lang_type
*lt
;
7592 decl_attributes (&enumtype
, attributes
, (int) ATTR_FLAG_TYPE_IN_PLACE
);
7594 /* Calculate the maximum value of any enumerator in this type. */
7596 if (values
== error_mark_node
)
7597 minnode
= maxnode
= integer_zero_node
;
7600 minnode
= maxnode
= TREE_VALUE (values
);
7601 for (pair
= TREE_CHAIN (values
); pair
; pair
= TREE_CHAIN (pair
))
7603 tree value
= TREE_VALUE (pair
);
7604 if (tree_int_cst_lt (maxnode
, value
))
7606 if (tree_int_cst_lt (value
, minnode
))
7611 /* Construct the final type of this enumeration. It is the same
7612 as one of the integral types - the narrowest one that fits, except
7613 that normally we only go as narrow as int - and signed iff any of
7614 the values are negative. */
7615 unsign
= (tree_int_cst_sgn (minnode
) >= 0);
7616 precision
= MAX (tree_int_cst_min_precision (minnode
, unsign
),
7617 tree_int_cst_min_precision (maxnode
, unsign
));
7619 if (TYPE_PACKED (enumtype
) || precision
> TYPE_PRECISION (integer_type_node
))
7621 tem
= c_common_type_for_size (precision
, unsign
);
7624 warning (0, "enumeration values exceed range of largest integer");
7625 tem
= long_long_integer_type_node
;
7629 tem
= unsign
? unsigned_type_node
: integer_type_node
;
7631 TYPE_MIN_VALUE (enumtype
) = TYPE_MIN_VALUE (tem
);
7632 TYPE_MAX_VALUE (enumtype
) = TYPE_MAX_VALUE (tem
);
7633 TYPE_UNSIGNED (enumtype
) = TYPE_UNSIGNED (tem
);
7634 TYPE_SIZE (enumtype
) = 0;
7636 /* If the precision of the type was specific with an attribute and it
7637 was too small, give an error. Otherwise, use it. */
7638 if (TYPE_PRECISION (enumtype
))
7640 if (precision
> TYPE_PRECISION (enumtype
))
7641 error ("specified mode too small for enumeral values");
7644 TYPE_PRECISION (enumtype
) = TYPE_PRECISION (tem
);
7646 layout_type (enumtype
);
7648 if (values
!= error_mark_node
)
7650 /* Change the type of the enumerators to be the enum type. We
7651 need to do this irrespective of the size of the enum, for
7652 proper type checking. Replace the DECL_INITIALs of the
7653 enumerators, and the value slots of the list, with copies
7654 that have the enum type; they cannot be modified in place
7655 because they may be shared (e.g. integer_zero_node) Finally,
7656 change the purpose slots to point to the names of the decls. */
7657 for (pair
= values
; pair
; pair
= TREE_CHAIN (pair
))
7659 tree enu
= TREE_PURPOSE (pair
);
7660 tree ini
= DECL_INITIAL (enu
);
7662 TREE_TYPE (enu
) = enumtype
;
7664 /* The ISO C Standard mandates enumerators to have type int,
7665 even though the underlying type of an enum type is
7666 unspecified. However, GCC allows enumerators of any
7667 integer type as an extensions. build_enumerator()
7668 converts any enumerators that fit in an int to type int,
7669 to avoid promotions to unsigned types when comparing
7670 integers with enumerators that fit in the int range.
7671 When -pedantic is given, build_enumerator() would have
7672 already warned about those that don't fit. Here we
7673 convert the rest to the enumerator type. */
7674 if (TREE_TYPE (ini
) != integer_type_node
)
7675 ini
= convert (enumtype
, ini
);
7677 DECL_INITIAL (enu
) = ini
;
7678 TREE_PURPOSE (pair
) = DECL_NAME (enu
);
7679 TREE_VALUE (pair
) = ini
;
7682 TYPE_VALUES (enumtype
) = values
;
7685 /* Record the min/max values so that we can warn about bit-field
7686 enumerations that are too small for the values. */
7687 lt
= ggc_alloc_cleared_lang_type (sizeof (struct lang_type
));
7688 lt
->enum_min
= minnode
;
7689 lt
->enum_max
= maxnode
;
7690 TYPE_LANG_SPECIFIC (enumtype
) = lt
;
7692 /* Fix up all variant types of this enum type. */
7693 for (tem
= TYPE_MAIN_VARIANT (enumtype
); tem
; tem
= TYPE_NEXT_VARIANT (tem
))
7695 if (tem
== enumtype
)
7697 TYPE_VALUES (tem
) = TYPE_VALUES (enumtype
);
7698 TYPE_MIN_VALUE (tem
) = TYPE_MIN_VALUE (enumtype
);
7699 TYPE_MAX_VALUE (tem
) = TYPE_MAX_VALUE (enumtype
);
7700 TYPE_SIZE (tem
) = TYPE_SIZE (enumtype
);
7701 TYPE_SIZE_UNIT (tem
) = TYPE_SIZE_UNIT (enumtype
);
7702 SET_TYPE_MODE (tem
, TYPE_MODE (enumtype
));
7703 TYPE_PRECISION (tem
) = TYPE_PRECISION (enumtype
);
7704 TYPE_ALIGN (tem
) = TYPE_ALIGN (enumtype
);
7705 TYPE_USER_ALIGN (tem
) = TYPE_USER_ALIGN (enumtype
);
7706 TYPE_UNSIGNED (tem
) = TYPE_UNSIGNED (enumtype
);
7707 TYPE_LANG_SPECIFIC (tem
) = TYPE_LANG_SPECIFIC (enumtype
);
7710 /* Finish debugging output for this type. */
7711 rest_of_type_compilation (enumtype
, toplevel
);
7713 /* If this enum is defined inside a struct, add it to
7716 && struct_parse_info
!= NULL
7717 && !in_sizeof
&& !in_typeof
&& !in_alignof
)
7718 struct_parse_info
->struct_types
.safe_push (enumtype
);
7723 /* Build and install a CONST_DECL for one value of the
7724 current enumeration type (one that was begun with start_enum).
7725 DECL_LOC is the location of the enumerator.
7726 LOC is the location of the '=' operator if any, DECL_LOC otherwise.
7727 Return a tree-list containing the CONST_DECL and its value.
7728 Assignment of sequential values by default is handled here. */
7731 build_enumerator (location_t decl_loc
, location_t loc
,
7732 struct c_enum_contents
*the_enum
, tree name
, tree value
)
7736 /* Validate and default VALUE. */
7740 /* Don't issue more errors for error_mark_node (i.e. an
7741 undeclared identifier) - just ignore the value expression. */
7742 if (value
== error_mark_node
)
7744 else if (!INTEGRAL_TYPE_P (TREE_TYPE (value
)))
7746 error_at (loc
, "enumerator value for %qE is not an integer constant",
7752 if (TREE_CODE (value
) != INTEGER_CST
)
7754 value
= c_fully_fold (value
, false, NULL
);
7755 if (TREE_CODE (value
) == INTEGER_CST
)
7756 pedwarn (loc
, OPT_Wpedantic
,
7757 "enumerator value for %qE is not an integer "
7758 "constant expression", name
);
7760 if (TREE_CODE (value
) != INTEGER_CST
)
7762 error ("enumerator value for %qE is not an integer constant",
7768 value
= default_conversion (value
);
7769 constant_expression_warning (value
);
7774 /* Default based on previous value. */
7775 /* It should no longer be possible to have NON_LVALUE_EXPR
7779 value
= the_enum
->enum_next_value
;
7780 if (the_enum
->enum_overflow
)
7781 error_at (loc
, "overflow in enumeration values");
7783 /* Even though the underlying type of an enum is unspecified, the
7784 type of enumeration constants is explicitly defined as int
7785 (6.4.4.3/2 in the C99 Standard). GCC allows any integer type as
7787 else if (!int_fits_type_p (value
, integer_type_node
))
7788 pedwarn (loc
, OPT_Wpedantic
,
7789 "ISO C restricts enumerator values to range of %<int%>");
7791 /* The ISO C Standard mandates enumerators to have type int, even
7792 though the underlying type of an enum type is unspecified.
7793 However, GCC allows enumerators of any integer type as an
7794 extensions. Here we convert any enumerators that fit in an int
7795 to type int, to avoid promotions to unsigned types when comparing
7796 integers with enumerators that fit in the int range. When
7797 -pedantic is given, we would have already warned about those that
7798 don't fit. We have to do this here rather than in finish_enum
7799 because this value may be used to define more enumerators. */
7800 if (int_fits_type_p (value
, integer_type_node
))
7801 value
= convert (integer_type_node
, value
);
7803 /* Set basis for default for next value. */
7804 the_enum
->enum_next_value
7805 = build_binary_op (EXPR_LOC_OR_LOC (value
, input_location
),
7806 PLUS_EXPR
, value
, integer_one_node
, 0);
7807 the_enum
->enum_overflow
= tree_int_cst_lt (the_enum
->enum_next_value
, value
);
7809 /* Now create a declaration for the enum value name. */
7811 type
= TREE_TYPE (value
);
7812 type
= c_common_type_for_size (MAX (TYPE_PRECISION (type
),
7813 TYPE_PRECISION (integer_type_node
)),
7814 (TYPE_PRECISION (type
)
7815 >= TYPE_PRECISION (integer_type_node
)
7816 && TYPE_UNSIGNED (type
)));
7818 decl
= build_decl (decl_loc
, CONST_DECL
, name
, type
);
7819 DECL_INITIAL (decl
) = convert (type
, value
);
7822 return tree_cons (decl
, value
, NULL_TREE
);
7826 /* Create the FUNCTION_DECL for a function definition.
7827 DECLSPECS, DECLARATOR and ATTRIBUTES are the parts of
7828 the declaration; they describe the function's name and the type it returns,
7829 but twisted together in a fashion that parallels the syntax of C.
7831 This function creates a binding context for the function body
7832 as well as setting up the FUNCTION_DECL in current_function_decl.
7834 Returns 1 on success. If the DECLARATOR is not suitable for a function
7835 (it defines a datum instead), we return 0, which tells
7836 yyparse to report a parse error. */
7839 start_function (struct c_declspecs
*declspecs
, struct c_declarator
*declarator
,
7842 tree decl1
, old_decl
;
7843 tree restype
, resdecl
;
7846 current_function_returns_value
= 0; /* Assume, until we see it does. */
7847 current_function_returns_null
= 0;
7848 current_function_returns_abnormally
= 0;
7849 warn_about_return_type
= 0;
7850 c_switch_stack
= NULL
;
7852 /* Indicate no valid break/continue context by setting these variables
7853 to some non-null, non-label value. We'll notice and emit the proper
7854 error message in c_finish_bc_stmt. */
7855 c_break_label
= c_cont_label
= size_zero_node
;
7857 decl1
= grokdeclarator (declarator
, declspecs
, FUNCDEF
, true, NULL
,
7858 &attributes
, NULL
, NULL
, DEPRECATED_NORMAL
);
7860 /* If the declarator is not suitable for a function definition,
7861 cause a syntax error. */
7863 || TREE_CODE (decl1
) != FUNCTION_DECL
)
7866 loc
= DECL_SOURCE_LOCATION (decl1
);
7868 c_decl_attributes (&decl1
, attributes
, 0);
7870 if (DECL_DECLARED_INLINE_P (decl1
)
7871 && DECL_UNINLINABLE (decl1
)
7872 && lookup_attribute ("noinline", DECL_ATTRIBUTES (decl1
)))
7873 warning_at (loc
, OPT_Wattributes
,
7874 "inline function %qD given attribute noinline",
7877 /* Handle gnu_inline attribute. */
7878 if (declspecs
->inline_p
7879 && !flag_gnu89_inline
7880 && TREE_CODE (decl1
) == FUNCTION_DECL
7881 && (lookup_attribute ("gnu_inline", DECL_ATTRIBUTES (decl1
))
7882 || current_function_decl
))
7884 if (declspecs
->storage_class
!= csc_static
)
7885 DECL_EXTERNAL (decl1
) = !DECL_EXTERNAL (decl1
);
7888 announce_function (decl1
);
7890 if (!COMPLETE_OR_VOID_TYPE_P (TREE_TYPE (TREE_TYPE (decl1
))))
7892 error_at (loc
, "return type is an incomplete type");
7893 /* Make it return void instead. */
7895 = build_function_type (void_type_node
,
7896 TYPE_ARG_TYPES (TREE_TYPE (decl1
)));
7899 if (warn_about_return_type
)
7900 pedwarn_c99 (loc
, flag_isoc99
? 0
7901 : (warn_return_type
? OPT_Wreturn_type
: OPT_Wimplicit_int
),
7902 "return type defaults to %<int%>");
7904 /* Make the init_value nonzero so pushdecl knows this is not tentative.
7905 error_mark_node is replaced below (in pop_scope) with the BLOCK. */
7906 DECL_INITIAL (decl1
) = error_mark_node
;
7908 /* A nested function is not global. */
7909 if (current_function_decl
!= 0)
7910 TREE_PUBLIC (decl1
) = 0;
7912 /* If this definition isn't a prototype and we had a prototype declaration
7913 before, copy the arg type info from that prototype. */
7914 old_decl
= lookup_name_in_scope (DECL_NAME (decl1
), current_scope
);
7915 if (old_decl
&& TREE_CODE (old_decl
) != FUNCTION_DECL
)
7917 current_function_prototype_locus
= UNKNOWN_LOCATION
;
7918 current_function_prototype_built_in
= false;
7919 current_function_prototype_arg_types
= NULL_TREE
;
7920 if (!prototype_p (TREE_TYPE (decl1
)))
7922 if (old_decl
!= 0 && TREE_CODE (TREE_TYPE (old_decl
)) == FUNCTION_TYPE
7923 && comptypes (TREE_TYPE (TREE_TYPE (decl1
)),
7924 TREE_TYPE (TREE_TYPE (old_decl
))))
7926 TREE_TYPE (decl1
) = composite_type (TREE_TYPE (old_decl
),
7928 current_function_prototype_locus
= DECL_SOURCE_LOCATION (old_decl
);
7929 current_function_prototype_built_in
7930 = C_DECL_BUILTIN_PROTOTYPE (old_decl
);
7931 current_function_prototype_arg_types
7932 = TYPE_ARG_TYPES (TREE_TYPE (decl1
));
7934 if (TREE_PUBLIC (decl1
))
7936 /* If there is an external prototype declaration of this
7937 function, record its location but do not copy information
7938 to this decl. This may be an invisible declaration
7939 (built-in or in a scope which has finished) or simply
7940 have more refined argument types than any declaration
7942 struct c_binding
*b
;
7943 for (b
= I_SYMBOL_BINDING (DECL_NAME (decl1
)); b
; b
= b
->shadowed
)
7944 if (B_IN_SCOPE (b
, external_scope
))
7948 tree ext_decl
, ext_type
;
7950 ext_type
= b
->u
.type
? b
->u
.type
: TREE_TYPE (ext_decl
);
7951 if (TREE_CODE (ext_type
) == FUNCTION_TYPE
7952 && comptypes (TREE_TYPE (TREE_TYPE (decl1
)),
7953 TREE_TYPE (ext_type
)))
7955 current_function_prototype_locus
7956 = DECL_SOURCE_LOCATION (ext_decl
);
7957 current_function_prototype_built_in
7958 = C_DECL_BUILTIN_PROTOTYPE (ext_decl
);
7959 current_function_prototype_arg_types
7960 = TYPE_ARG_TYPES (ext_type
);
7966 /* Optionally warn of old-fashioned def with no previous prototype. */
7967 if (warn_strict_prototypes
7968 && old_decl
!= error_mark_node
7969 && !prototype_p (TREE_TYPE (decl1
))
7970 && C_DECL_ISNT_PROTOTYPE (old_decl
))
7971 warning_at (loc
, OPT_Wstrict_prototypes
,
7972 "function declaration isn%'t a prototype");
7973 /* Optionally warn of any global def with no previous prototype. */
7974 else if (warn_missing_prototypes
7975 && old_decl
!= error_mark_node
7976 && TREE_PUBLIC (decl1
)
7977 && !MAIN_NAME_P (DECL_NAME (decl1
))
7978 && C_DECL_ISNT_PROTOTYPE (old_decl
)
7979 && !DECL_DECLARED_INLINE_P (decl1
))
7980 warning_at (loc
, OPT_Wmissing_prototypes
,
7981 "no previous prototype for %qD", decl1
);
7982 /* Optionally warn of any def with no previous prototype
7983 if the function has already been used. */
7984 else if (warn_missing_prototypes
7986 && old_decl
!= error_mark_node
7987 && TREE_USED (old_decl
)
7988 && !prototype_p (TREE_TYPE (old_decl
)))
7989 warning_at (loc
, OPT_Wmissing_prototypes
,
7990 "%qD was used with no prototype before its definition", decl1
);
7991 /* Optionally warn of any global def with no previous declaration. */
7992 else if (warn_missing_declarations
7993 && TREE_PUBLIC (decl1
)
7995 && !MAIN_NAME_P (DECL_NAME (decl1
)))
7996 warning_at (loc
, OPT_Wmissing_declarations
,
7997 "no previous declaration for %qD",
7999 /* Optionally warn of any def with no previous declaration
8000 if the function has already been used. */
8001 else if (warn_missing_declarations
8003 && old_decl
!= error_mark_node
8004 && TREE_USED (old_decl
)
8005 && C_DECL_IMPLICIT (old_decl
))
8006 warning_at (loc
, OPT_Wmissing_declarations
,
8007 "%qD was used with no declaration before its definition", decl1
);
8009 /* This function exists in static storage.
8010 (This does not mean `static' in the C sense!) */
8011 TREE_STATIC (decl1
) = 1;
8013 /* This is the earliest point at which we might know the assembler
8014 name of the function. Thus, if it's set before this, die horribly. */
8015 gcc_assert (!DECL_ASSEMBLER_NAME_SET_P (decl1
));
8017 /* If #pragma weak was used, mark the decl weak now. */
8018 if (current_scope
== file_scope
)
8019 maybe_apply_pragma_weak (decl1
);
8021 /* Warn for unlikely, improbable, or stupid declarations of `main'. */
8022 if (warn_main
&& MAIN_NAME_P (DECL_NAME (decl1
)))
8024 if (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (decl1
)))
8025 != integer_type_node
)
8026 pedwarn (loc
, OPT_Wmain
, "return type of %qD is not %<int%>", decl1
);
8028 check_main_parameter_types (decl1
);
8030 if (!TREE_PUBLIC (decl1
))
8031 pedwarn (loc
, OPT_Wmain
,
8032 "%qD is normally a non-static function", decl1
);
8035 /* Record the decl so that the function name is defined.
8036 If we already have a decl for this name, and it is a FUNCTION_DECL,
8037 use the old decl. */
8039 current_function_decl
= pushdecl (decl1
);
8042 declare_parm_level ();
8044 restype
= TREE_TYPE (TREE_TYPE (current_function_decl
));
8045 resdecl
= build_decl (loc
, RESULT_DECL
, NULL_TREE
, restype
);
8046 DECL_ARTIFICIAL (resdecl
) = 1;
8047 DECL_IGNORED_P (resdecl
) = 1;
8048 DECL_RESULT (current_function_decl
) = resdecl
;
8050 start_fname_decls ();
8055 /* Subroutine of store_parm_decls which handles new-style function
8056 definitions (prototype format). The parms already have decls, so we
8057 need only record them as in effect and complain if any redundant
8058 old-style parm decls were written. */
8060 store_parm_decls_newstyle (tree fndecl
, const struct c_arg_info
*arg_info
)
8066 if (current_scope
->bindings
)
8068 error_at (DECL_SOURCE_LOCATION (fndecl
),
8069 "old-style parameter declarations in prototyped "
8070 "function definition");
8072 /* Get rid of the old-style declarations. */
8076 /* Don't issue this warning for nested functions, and don't issue this
8077 warning if we got here because ARG_INFO_TYPES was error_mark_node
8078 (this happens when a function definition has just an ellipsis in
8079 its parameter list). */
8080 else if (!in_system_header_at (input_location
)
8081 && !current_function_scope
8082 && arg_info
->types
!= error_mark_node
)
8083 warning_at (DECL_SOURCE_LOCATION (fndecl
), OPT_Wtraditional
,
8084 "traditional C rejects ISO C style function definitions");
8086 /* Now make all the parameter declarations visible in the function body.
8087 We can bypass most of the grunt work of pushdecl. */
8088 for (decl
= arg_info
->parms
; decl
; decl
= DECL_CHAIN (decl
))
8090 DECL_CONTEXT (decl
) = current_function_decl
;
8091 if (DECL_NAME (decl
))
8093 bind (DECL_NAME (decl
), decl
, current_scope
,
8094 /*invisible=*/false, /*nested=*/false,
8096 if (!TREE_USED (decl
))
8097 warn_if_shadowing (decl
);
8100 error_at (DECL_SOURCE_LOCATION (decl
), "parameter name omitted");
8103 /* Record the parameter list in the function declaration. */
8104 DECL_ARGUMENTS (fndecl
) = arg_info
->parms
;
8106 /* Now make all the ancillary declarations visible, likewise. */
8107 for (decl
= arg_info
->others
; decl
; decl
= DECL_CHAIN (decl
))
8109 DECL_CONTEXT (decl
) = current_function_decl
;
8110 if (DECL_NAME (decl
))
8111 bind (DECL_NAME (decl
), decl
, current_scope
,
8112 /*invisible=*/false,
8113 /*nested=*/(TREE_CODE (decl
) == FUNCTION_DECL
),
8117 /* And all the tag declarations. */
8118 FOR_EACH_VEC_SAFE_ELT_REVERSE (arg_info
->tags
, ix
, tag
)
8120 bind (tag
->id
, tag
->type
, current_scope
,
8121 /*invisible=*/false, /*nested=*/false, UNKNOWN_LOCATION
);
8124 /* Subroutine of store_parm_decls which handles old-style function
8125 definitions (separate parameter list and declarations). */
8128 store_parm_decls_oldstyle (tree fndecl
, const struct c_arg_info
*arg_info
)
8130 struct c_binding
*b
;
8131 tree parm
, decl
, last
;
8132 tree parmids
= arg_info
->parms
;
8133 struct pointer_set_t
*seen_args
= pointer_set_create ();
8135 if (!in_system_header_at (input_location
))
8136 warning_at (DECL_SOURCE_LOCATION (fndecl
),
8137 OPT_Wold_style_definition
, "old-style function definition");
8139 /* Match each formal parameter name with its declaration. Save each
8140 decl in the appropriate TREE_PURPOSE slot of the parmids chain. */
8141 for (parm
= parmids
; parm
; parm
= TREE_CHAIN (parm
))
8143 if (TREE_VALUE (parm
) == 0)
8145 error_at (DECL_SOURCE_LOCATION (fndecl
),
8146 "parameter name missing from parameter list");
8147 TREE_PURPOSE (parm
) = 0;
8151 b
= I_SYMBOL_BINDING (TREE_VALUE (parm
));
8152 if (b
&& B_IN_CURRENT_SCOPE (b
))
8155 /* Skip erroneous parameters. */
8156 if (decl
== error_mark_node
)
8158 /* If we got something other than a PARM_DECL it is an error. */
8159 if (TREE_CODE (decl
) != PARM_DECL
)
8160 error_at (DECL_SOURCE_LOCATION (decl
),
8161 "%qD declared as a non-parameter", decl
);
8162 /* If the declaration is already marked, we have a duplicate
8163 name. Complain and ignore the duplicate. */
8164 else if (pointer_set_contains (seen_args
, decl
))
8166 error_at (DECL_SOURCE_LOCATION (decl
),
8167 "multiple parameters named %qD", decl
);
8168 TREE_PURPOSE (parm
) = 0;
8171 /* If the declaration says "void", complain and turn it into
8173 else if (VOID_TYPE_P (TREE_TYPE (decl
)))
8175 error_at (DECL_SOURCE_LOCATION (decl
),
8176 "parameter %qD declared with void type", decl
);
8177 TREE_TYPE (decl
) = integer_type_node
;
8178 DECL_ARG_TYPE (decl
) = integer_type_node
;
8179 layout_decl (decl
, 0);
8181 warn_if_shadowing (decl
);
8183 /* If no declaration found, default to int. */
8186 /* FIXME diagnostics: This should be the location of the argument,
8187 not the FNDECL. E.g., for an old-style declaration
8189 int f10(v) { blah; }
8191 We should use the location of the V, not the F10.
8192 Unfortunately, the V is an IDENTIFIER_NODE which has no
8193 location. In the future we need locations for c_arg_info
8196 See gcc.dg/Wshadow-3.c for an example of this problem. */
8197 decl
= build_decl (DECL_SOURCE_LOCATION (fndecl
),
8198 PARM_DECL
, TREE_VALUE (parm
), integer_type_node
);
8199 DECL_ARG_TYPE (decl
) = TREE_TYPE (decl
);
8201 warn_if_shadowing (decl
);
8204 pedwarn (DECL_SOURCE_LOCATION (decl
),
8205 0, "type of %qD defaults to %<int%>", decl
);
8207 warning_at (DECL_SOURCE_LOCATION (decl
),
8208 OPT_Wmissing_parameter_type
,
8209 "type of %qD defaults to %<int%>", decl
);
8212 TREE_PURPOSE (parm
) = decl
;
8213 pointer_set_insert (seen_args
, decl
);
8216 /* Now examine the parms chain for incomplete declarations
8217 and declarations with no corresponding names. */
8219 for (b
= current_scope
->bindings
; b
; b
= b
->prev
)
8222 if (TREE_CODE (parm
) != PARM_DECL
)
8225 if (TREE_TYPE (parm
) != error_mark_node
8226 && !COMPLETE_TYPE_P (TREE_TYPE (parm
)))
8228 error_at (DECL_SOURCE_LOCATION (parm
),
8229 "parameter %qD has incomplete type", parm
);
8230 TREE_TYPE (parm
) = error_mark_node
;
8233 if (!pointer_set_contains (seen_args
, parm
))
8235 error_at (DECL_SOURCE_LOCATION (parm
),
8236 "declaration for parameter %qD but no such parameter",
8239 /* Pretend the parameter was not missing.
8240 This gets us to a standard state and minimizes
8241 further error messages. */
8242 parmids
= chainon (parmids
, tree_cons (parm
, 0, 0));
8246 /* Chain the declarations together in the order of the list of
8247 names. Store that chain in the function decl, replacing the
8248 list of names. Update the current scope to match. */
8249 DECL_ARGUMENTS (fndecl
) = 0;
8251 for (parm
= parmids
; parm
; parm
= TREE_CHAIN (parm
))
8252 if (TREE_PURPOSE (parm
))
8254 if (parm
&& TREE_PURPOSE (parm
))
8256 last
= TREE_PURPOSE (parm
);
8257 DECL_ARGUMENTS (fndecl
) = last
;
8259 for (parm
= TREE_CHAIN (parm
); parm
; parm
= TREE_CHAIN (parm
))
8260 if (TREE_PURPOSE (parm
))
8262 DECL_CHAIN (last
) = TREE_PURPOSE (parm
);
8263 last
= TREE_PURPOSE (parm
);
8265 DECL_CHAIN (last
) = 0;
8268 pointer_set_destroy (seen_args
);
8270 /* If there was a previous prototype,
8271 set the DECL_ARG_TYPE of each argument according to
8272 the type previously specified, and report any mismatches. */
8274 if (current_function_prototype_arg_types
)
8277 for (parm
= DECL_ARGUMENTS (fndecl
),
8278 type
= current_function_prototype_arg_types
;
8279 parm
|| (type
&& TREE_VALUE (type
) != error_mark_node
8280 && (TYPE_MAIN_VARIANT (TREE_VALUE (type
)) != void_type_node
));
8281 parm
= DECL_CHAIN (parm
), type
= TREE_CHAIN (type
))
8283 if (parm
== 0 || type
== 0
8284 || TYPE_MAIN_VARIANT (TREE_VALUE (type
)) == void_type_node
)
8286 if (current_function_prototype_built_in
)
8287 warning_at (DECL_SOURCE_LOCATION (fndecl
),
8288 0, "number of arguments doesn%'t match "
8289 "built-in prototype");
8292 /* FIXME diagnostics: This should be the location of
8293 FNDECL, but there is bug when a prototype is
8294 declared inside function context, but defined
8295 outside of it (e.g., gcc.dg/pr15698-2.c). In
8296 which case FNDECL gets the location of the
8297 prototype, not the definition. */
8298 error_at (input_location
,
8299 "number of arguments doesn%'t match prototype");
8301 error_at (current_function_prototype_locus
,
8302 "prototype declaration");
8306 /* Type for passing arg must be consistent with that
8307 declared for the arg. ISO C says we take the unqualified
8308 type for parameters declared with qualified type. */
8309 if (TREE_TYPE (parm
) != error_mark_node
8310 && TREE_TYPE (type
) != error_mark_node
8311 && ((TYPE_ATOMIC (DECL_ARG_TYPE (parm
))
8312 != TYPE_ATOMIC (TREE_VALUE (type
)))
8313 || !comptypes (TYPE_MAIN_VARIANT (DECL_ARG_TYPE (parm
)),
8314 TYPE_MAIN_VARIANT (TREE_VALUE (type
)))))
8316 if ((TYPE_ATOMIC (DECL_ARG_TYPE (parm
))
8317 == TYPE_ATOMIC (TREE_VALUE (type
)))
8318 && (TYPE_MAIN_VARIANT (TREE_TYPE (parm
))
8319 == TYPE_MAIN_VARIANT (TREE_VALUE (type
))))
8321 /* Adjust argument to match prototype. E.g. a previous
8322 `int foo(float);' prototype causes
8323 `int foo(x) float x; {...}' to be treated like
8324 `int foo(float x) {...}'. This is particularly
8325 useful for argument types like uid_t. */
8326 DECL_ARG_TYPE (parm
) = TREE_TYPE (parm
);
8328 if (targetm
.calls
.promote_prototypes (TREE_TYPE (current_function_decl
))
8329 && INTEGRAL_TYPE_P (TREE_TYPE (parm
))
8330 && TYPE_PRECISION (TREE_TYPE (parm
))
8331 < TYPE_PRECISION (integer_type_node
))
8332 DECL_ARG_TYPE (parm
)
8333 = c_type_promotes_to (TREE_TYPE (parm
));
8335 /* ??? Is it possible to get here with a
8336 built-in prototype or will it always have
8337 been diagnosed as conflicting with an
8338 old-style definition and discarded? */
8339 if (current_function_prototype_built_in
)
8340 warning_at (DECL_SOURCE_LOCATION (parm
),
8341 OPT_Wpedantic
, "promoted argument %qD "
8342 "doesn%'t match built-in prototype", parm
);
8345 pedwarn (DECL_SOURCE_LOCATION (parm
),
8346 OPT_Wpedantic
, "promoted argument %qD "
8347 "doesn%'t match prototype", parm
);
8348 pedwarn (current_function_prototype_locus
, OPT_Wpedantic
,
8349 "prototype declaration");
8354 if (current_function_prototype_built_in
)
8355 warning_at (DECL_SOURCE_LOCATION (parm
),
8356 0, "argument %qD doesn%'t match "
8357 "built-in prototype", parm
);
8360 error_at (DECL_SOURCE_LOCATION (parm
),
8361 "argument %qD doesn%'t match prototype", parm
);
8362 error_at (current_function_prototype_locus
,
8363 "prototype declaration");
8368 TYPE_ACTUAL_ARG_TYPES (TREE_TYPE (fndecl
)) = 0;
8371 /* Otherwise, create a prototype that would match. */
8375 tree actual
= 0, last
= 0, type
;
8377 for (parm
= DECL_ARGUMENTS (fndecl
); parm
; parm
= DECL_CHAIN (parm
))
8379 type
= tree_cons (NULL_TREE
, DECL_ARG_TYPE (parm
), NULL_TREE
);
8381 TREE_CHAIN (last
) = type
;
8386 type
= tree_cons (NULL_TREE
, void_type_node
, NULL_TREE
);
8388 TREE_CHAIN (last
) = type
;
8392 /* We are going to assign a new value for the TYPE_ACTUAL_ARG_TYPES
8393 of the type of this function, but we need to avoid having this
8394 affect the types of other similarly-typed functions, so we must
8395 first force the generation of an identical (but separate) type
8396 node for the relevant function type. The new node we create
8397 will be a variant of the main variant of the original function
8400 TREE_TYPE (fndecl
) = build_variant_type_copy (TREE_TYPE (fndecl
));
8402 TYPE_ACTUAL_ARG_TYPES (TREE_TYPE (fndecl
)) = actual
;
8406 /* Store parameter declarations passed in ARG_INFO into the current
8407 function declaration. */
8410 store_parm_decls_from (struct c_arg_info
*arg_info
)
8412 current_function_arg_info
= arg_info
;
8413 store_parm_decls ();
8416 /* Store the parameter declarations into the current function declaration.
8417 This is called after parsing the parameter declarations, before
8418 digesting the body of the function.
8420 For an old-style definition, construct a prototype out of the old-style
8421 parameter declarations and inject it into the function's type. */
8424 store_parm_decls (void)
8426 tree fndecl
= current_function_decl
;
8429 /* The argument information block for FNDECL. */
8430 struct c_arg_info
*arg_info
= current_function_arg_info
;
8431 current_function_arg_info
= 0;
8433 /* True if this definition is written with a prototype. Note:
8434 despite C99 6.7.5.3p14, we can *not* treat an empty argument
8435 list in a function definition as equivalent to (void) -- an
8436 empty argument list specifies the function has no parameters,
8437 but only (void) sets up a prototype for future calls. */
8438 proto
= arg_info
->types
!= 0;
8441 store_parm_decls_newstyle (fndecl
, arg_info
);
8443 store_parm_decls_oldstyle (fndecl
, arg_info
);
8445 /* The next call to push_scope will be a function body. */
8447 next_is_function_body
= true;
8449 /* Write a record describing this function definition to the prototypes
8450 file (if requested). */
8452 gen_aux_info_record (fndecl
, 1, 0, proto
);
8454 /* Initialize the RTL code for the function. */
8455 allocate_struct_function (fndecl
, false);
8457 if (warn_unused_local_typedefs
)
8458 cfun
->language
= ggc_alloc_cleared_language_function ();
8460 /* Begin the statement tree for this function. */
8461 DECL_SAVED_TREE (fndecl
) = push_stmt_list ();
8463 /* ??? Insert the contents of the pending sizes list into the function
8464 to be evaluated. The only reason left to have this is
8465 void foo(int n, int array[n++])
8466 because we throw away the array type in favor of a pointer type, and
8467 thus won't naturally see the SAVE_EXPR containing the increment. All
8468 other pending sizes would be handled by gimplify_parameters. */
8469 if (arg_info
->pending_sizes
)
8470 add_stmt (arg_info
->pending_sizes
);
8473 /* Store PARM_DECLs in PARMS into scope temporarily. Used for
8474 c_finish_omp_declare_simd for function prototypes. No diagnostics
8478 temp_store_parm_decls (tree fndecl
, tree parms
)
8481 for (tree p
= parms
; p
; p
= DECL_CHAIN (p
))
8483 DECL_CONTEXT (p
) = fndecl
;
8485 bind (DECL_NAME (p
), p
, current_scope
,
8486 /*invisible=*/false, /*nested=*/false,
8491 /* Undo what temp_store_parm_decls did. */
8494 temp_pop_parm_decls (void)
8496 /* Clear all bindings in this temporary scope, so that
8497 pop_scope doesn't create a BLOCK. */
8498 struct c_binding
*b
= current_scope
->bindings
;
8499 current_scope
->bindings
= NULL
;
8500 for (; b
; b
= free_binding_and_advance (b
))
8502 gcc_assert (TREE_CODE (b
->decl
) == PARM_DECL
);
8503 gcc_assert (I_SYMBOL_BINDING (b
->id
) == b
);
8504 I_SYMBOL_BINDING (b
->id
) = b
->shadowed
;
8505 if (b
->shadowed
&& b
->shadowed
->u
.type
)
8506 TREE_TYPE (b
->shadowed
->decl
) = b
->shadowed
->u
.type
;
8512 /* Finish up a function declaration and compile that function
8513 all the way to assembler language output. Then free the storage
8514 for the function definition.
8516 This is called after parsing the body of the function definition. */
8519 finish_function (void)
8521 tree fndecl
= current_function_decl
;
8523 if (c_dialect_objc ())
8524 objc_finish_function ();
8526 if (TREE_CODE (fndecl
) == FUNCTION_DECL
8527 && targetm
.calls
.promote_prototypes (TREE_TYPE (fndecl
)))
8529 tree args
= DECL_ARGUMENTS (fndecl
);
8530 for (; args
; args
= DECL_CHAIN (args
))
8532 tree type
= TREE_TYPE (args
);
8533 if (INTEGRAL_TYPE_P (type
)
8534 && TYPE_PRECISION (type
) < TYPE_PRECISION (integer_type_node
))
8535 DECL_ARG_TYPE (args
) = c_type_promotes_to (type
);
8539 if (DECL_INITIAL (fndecl
) && DECL_INITIAL (fndecl
) != error_mark_node
)
8540 BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl
)) = fndecl
;
8542 /* Must mark the RESULT_DECL as being in this function. */
8544 if (DECL_RESULT (fndecl
) && DECL_RESULT (fndecl
) != error_mark_node
)
8545 DECL_CONTEXT (DECL_RESULT (fndecl
)) = fndecl
;
8547 if (MAIN_NAME_P (DECL_NAME (fndecl
)) && flag_hosted
8548 && TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (fndecl
)))
8549 == integer_type_node
&& flag_isoc99
)
8551 /* Hack. We don't want the middle-end to warn that this return
8552 is unreachable, so we mark its location as special. Using
8553 UNKNOWN_LOCATION has the problem that it gets clobbered in
8554 annotate_one_with_locus. A cleaner solution might be to
8555 ensure ! should_carry_locus_p (stmt), but that needs a flag.
8557 c_finish_return (BUILTINS_LOCATION
, integer_zero_node
, NULL_TREE
);
8560 /* Tie off the statement tree for this function. */
8561 DECL_SAVED_TREE (fndecl
) = pop_stmt_list (DECL_SAVED_TREE (fndecl
));
8563 /* If the function has _Cilk_spawn in front of a function call inside it
8564 i.e. it is a spawning function, then add the appropriate Cilk plus
8565 functions inside. */
8566 if (fn_contains_cilk_spawn_p (cfun
))
8567 cfun
->cilk_frame_decl
= insert_cilk_frame (fndecl
);
8569 finish_fname_decls ();
8571 /* Complain if there's just no return statement. */
8572 if (warn_return_type
8573 && TREE_CODE (TREE_TYPE (TREE_TYPE (fndecl
))) != VOID_TYPE
8574 && !current_function_returns_value
&& !current_function_returns_null
8575 /* Don't complain if we are no-return. */
8576 && !current_function_returns_abnormally
8577 /* Don't complain if we are declared noreturn. */
8578 && !TREE_THIS_VOLATILE (fndecl
)
8579 /* Don't warn for main(). */
8580 && !MAIN_NAME_P (DECL_NAME (fndecl
))
8581 /* Or if they didn't actually specify a return type. */
8582 && !C_FUNCTION_IMPLICIT_INT (fndecl
)
8583 /* Normally, with -Wreturn-type, flow will complain, but we might
8584 optimize out static functions. */
8585 && !TREE_PUBLIC (fndecl
))
8587 warning (OPT_Wreturn_type
,
8588 "no return statement in function returning non-void");
8589 TREE_NO_WARNING (fndecl
) = 1;
8592 /* Complain about parameters that are only set, but never otherwise used. */
8593 if (warn_unused_but_set_parameter
)
8597 for (decl
= DECL_ARGUMENTS (fndecl
);
8599 decl
= DECL_CHAIN (decl
))
8600 if (TREE_USED (decl
)
8601 && TREE_CODE (decl
) == PARM_DECL
8602 && !DECL_READ_P (decl
)
8604 && !DECL_ARTIFICIAL (decl
)
8605 && !TREE_NO_WARNING (decl
))
8606 warning_at (DECL_SOURCE_LOCATION (decl
),
8607 OPT_Wunused_but_set_parameter
,
8608 "parameter %qD set but not used", decl
);
8611 /* Complain about locally defined typedefs that are not used in this
8613 maybe_warn_unused_local_typedefs ();
8615 /* Store the end of the function, so that we get good line number
8616 info for the epilogue. */
8617 cfun
->function_end_locus
= input_location
;
8619 /* Finalize the ELF visibility for the function. */
8620 c_determine_visibility (fndecl
);
8622 /* For GNU C extern inline functions disregard inline limits. */
8623 if (DECL_EXTERNAL (fndecl
)
8624 && DECL_DECLARED_INLINE_P (fndecl
))
8625 DECL_DISREGARD_INLINE_LIMITS (fndecl
) = 1;
8627 /* Genericize before inlining. Delay genericizing nested functions
8628 until their parent function is genericized. Since finalizing
8629 requires GENERIC, delay that as well. */
8631 if (DECL_INITIAL (fndecl
) && DECL_INITIAL (fndecl
) != error_mark_node
8632 && !undef_nested_function
)
8634 if (!decl_function_context (fndecl
))
8636 invoke_plugin_callbacks (PLUGIN_PRE_GENERICIZE
, fndecl
);
8637 c_genericize (fndecl
);
8639 /* ??? Objc emits functions after finalizing the compilation unit.
8640 This should be cleaned up later and this conditional removed. */
8641 if (cgraph_global_info_ready
)
8643 cgraph_add_new_function (fndecl
, false);
8646 cgraph_finalize_function (fndecl
, false);
8650 /* Register this function with cgraph just far enough to get it
8651 added to our parent's nested function list. Handy, since the
8652 C front end doesn't have such a list. */
8653 (void) cgraph_get_create_node (fndecl
);
8657 if (!decl_function_context (fndecl
))
8658 undef_nested_function
= false;
8660 if (cfun
->language
!= NULL
)
8662 ggc_free (cfun
->language
);
8663 cfun
->language
= NULL
;
8666 /* We're leaving the context of this function, so zap cfun.
8667 It's still in DECL_STRUCT_FUNCTION, and we'll restore it in
8668 tree_rest_of_compilation. */
8670 current_function_decl
= NULL
;
8673 /* Check the declarations given in a for-loop for satisfying the C99
8674 constraints. If exactly one such decl is found, return it. LOC is
8675 the location of the opening parenthesis of the for loop. The last
8676 parameter allows you to control the "for loop initial declarations
8677 are only allowed in C99 mode". Normally, you should pass
8678 flag_isoc99 as that parameter. But in some cases (Objective-C
8679 foreach loop, for example) we want to run the checks in this
8680 function even if not in C99 mode, so we allow the caller to turn
8681 off the error about not being in C99 mode.
8685 check_for_loop_decls (location_t loc
, bool turn_off_iso_c99_error
)
8687 struct c_binding
*b
;
8688 tree one_decl
= NULL_TREE
;
8691 if (!turn_off_iso_c99_error
)
8693 static bool hint
= true;
8694 /* If we get here, declarations have been used in a for loop without
8695 the C99 for loop scope. This doesn't make much sense, so don't
8697 error_at (loc
, "%<for%> loop initial declarations "
8698 "are only allowed in C99 or C11 mode");
8702 "use option -std=c99, -std=gnu99, -std=c11 or -std=gnu11 "
8703 "to compile your code");
8708 /* C99 subclause 6.8.5 paragraph 3:
8710 [#3] The declaration part of a for statement shall only
8711 declare identifiers for objects having storage class auto or
8714 It isn't clear whether, in this sentence, "identifiers" binds to
8715 "shall only declare" or to "objects" - that is, whether all identifiers
8716 declared must be identifiers for objects, or whether the restriction
8717 only applies to those that are. (A question on this in comp.std.c
8718 in November 2000 received no answer.) We implement the strictest
8719 interpretation, to avoid creating an extension which later causes
8722 for (b
= current_scope
->bindings
; b
; b
= b
->prev
)
8725 tree decl
= b
->decl
;
8730 switch (TREE_CODE (decl
))
8734 location_t decl_loc
= DECL_SOURCE_LOCATION (decl
);
8735 if (TREE_STATIC (decl
))
8737 "declaration of static variable %qD in %<for%> loop "
8738 "initial declaration", decl
);
8739 else if (DECL_EXTERNAL (decl
))
8741 "declaration of %<extern%> variable %qD in %<for%> loop "
8742 "initial declaration", decl
);
8748 "%<struct %E%> declared in %<for%> loop initial "
8753 "%<union %E%> declared in %<for%> loop initial declaration",
8757 error_at (loc
, "%<enum %E%> declared in %<for%> loop "
8758 "initial declaration", id
);
8761 error_at (loc
, "declaration of non-variable "
8762 "%qD in %<for%> loop initial declaration", decl
);
8769 return n_decls
== 1 ? one_decl
: NULL_TREE
;
8772 /* Save and reinitialize the variables
8773 used during compilation of a C function. */
8776 c_push_function_context (void)
8778 struct language_function
*p
= cfun
->language
;
8779 /* cfun->language might have been already allocated by the use of
8780 -Wunused-local-typedefs. In that case, just re-use it. */
8782 cfun
->language
= p
= ggc_alloc_cleared_language_function ();
8784 p
->base
.x_stmt_tree
= c_stmt_tree
;
8785 c_stmt_tree
.x_cur_stmt_list
= vec_safe_copy (c_stmt_tree
.x_cur_stmt_list
);
8786 p
->x_break_label
= c_break_label
;
8787 p
->x_cont_label
= c_cont_label
;
8788 p
->x_switch_stack
= c_switch_stack
;
8789 p
->arg_info
= current_function_arg_info
;
8790 p
->returns_value
= current_function_returns_value
;
8791 p
->returns_null
= current_function_returns_null
;
8792 p
->returns_abnormally
= current_function_returns_abnormally
;
8793 p
->warn_about_return_type
= warn_about_return_type
;
8795 push_function_context ();
8798 /* Restore the variables used during compilation of a C function. */
8801 c_pop_function_context (void)
8803 struct language_function
*p
;
8805 pop_function_context ();
8808 /* When -Wunused-local-typedefs is in effect, cfun->languages is
8809 used to store data throughout the life time of the current cfun,
8810 So don't deallocate it. */
8811 if (!warn_unused_local_typedefs
)
8812 cfun
->language
= NULL
;
8814 if (DECL_STRUCT_FUNCTION (current_function_decl
) == 0
8815 && DECL_SAVED_TREE (current_function_decl
) == NULL_TREE
)
8817 /* Stop pointing to the local nodes about to be freed. */
8818 /* But DECL_INITIAL must remain nonzero so we know this
8819 was an actual function definition. */
8820 DECL_INITIAL (current_function_decl
) = error_mark_node
;
8821 DECL_ARGUMENTS (current_function_decl
) = 0;
8824 c_stmt_tree
= p
->base
.x_stmt_tree
;
8825 p
->base
.x_stmt_tree
.x_cur_stmt_list
= NULL
;
8826 c_break_label
= p
->x_break_label
;
8827 c_cont_label
= p
->x_cont_label
;
8828 c_switch_stack
= p
->x_switch_stack
;
8829 current_function_arg_info
= p
->arg_info
;
8830 current_function_returns_value
= p
->returns_value
;
8831 current_function_returns_null
= p
->returns_null
;
8832 current_function_returns_abnormally
= p
->returns_abnormally
;
8833 warn_about_return_type
= p
->warn_about_return_type
;
8836 /* The functions below are required for functionality of doing
8837 function at once processing in the C front end. Currently these
8838 functions are not called from anywhere in the C front end, but as
8839 these changes continue, that will change. */
8841 /* Returns the stmt_tree (if any) to which statements are currently
8842 being added. If there is no active statement-tree, NULL is
8846 current_stmt_tree (void)
8848 return &c_stmt_tree
;
8851 /* Return the global value of T as a symbol. */
8854 identifier_global_value (tree t
)
8856 struct c_binding
*b
;
8858 for (b
= I_SYMBOL_BINDING (t
); b
; b
= b
->shadowed
)
8859 if (B_IN_FILE_SCOPE (b
) || B_IN_EXTERNAL_SCOPE (b
))
8865 /* In C, the only C-linkage public declaration is at file scope. */
8868 c_linkage_bindings (tree name
)
8870 return identifier_global_value (name
);
8873 /* Record a builtin type for C. If NAME is non-NULL, it is the name used;
8874 otherwise the name is found in ridpointers from RID_INDEX. */
8877 record_builtin_type (enum rid rid_index
, const char *name
, tree type
)
8881 id
= ridpointers
[(int) rid_index
];
8883 id
= get_identifier (name
);
8884 decl
= build_decl (UNKNOWN_LOCATION
, TYPE_DECL
, id
, type
);
8886 if (debug_hooks
->type_decl
)
8887 debug_hooks
->type_decl (decl
, false);
8890 /* Build the void_list_node (void_type_node having been created). */
8892 build_void_list_node (void)
8894 tree t
= build_tree_list (NULL_TREE
, void_type_node
);
8898 /* Return a c_parm structure with the given SPECS, ATTRS and DECLARATOR. */
8901 build_c_parm (struct c_declspecs
*specs
, tree attrs
,
8902 struct c_declarator
*declarator
)
8904 struct c_parm
*ret
= XOBNEW (&parser_obstack
, struct c_parm
);
8907 ret
->declarator
= declarator
;
8911 /* Return a declarator with nested attributes. TARGET is the inner
8912 declarator to which these attributes apply. ATTRS are the
8915 struct c_declarator
*
8916 build_attrs_declarator (tree attrs
, struct c_declarator
*target
)
8918 struct c_declarator
*ret
= XOBNEW (&parser_obstack
, struct c_declarator
);
8919 ret
->kind
= cdk_attrs
;
8920 ret
->declarator
= target
;
8921 ret
->u
.attrs
= attrs
;
8925 /* Return a declarator for a function with arguments specified by ARGS
8926 and return type specified by TARGET. */
8928 struct c_declarator
*
8929 build_function_declarator (struct c_arg_info
*args
,
8930 struct c_declarator
*target
)
8932 struct c_declarator
*ret
= XOBNEW (&parser_obstack
, struct c_declarator
);
8933 ret
->kind
= cdk_function
;
8934 ret
->declarator
= target
;
8935 ret
->u
.arg_info
= args
;
8939 /* Return a declarator for the identifier IDENT (which may be
8940 NULL_TREE for an abstract declarator). */
8942 struct c_declarator
*
8943 build_id_declarator (tree ident
)
8945 struct c_declarator
*ret
= XOBNEW (&parser_obstack
, struct c_declarator
);
8947 ret
->declarator
= 0;
8949 /* Default value - may get reset to a more precise location. */
8950 ret
->id_loc
= input_location
;
8954 /* Return something to represent absolute declarators containing a *.
8955 TARGET is the absolute declarator that the * contains.
8956 TYPE_QUALS_ATTRS is a structure for type qualifiers and attributes
8957 to apply to the pointer type. */
8959 struct c_declarator
*
8960 make_pointer_declarator (struct c_declspecs
*type_quals_attrs
,
8961 struct c_declarator
*target
)
8965 struct c_declarator
*itarget
= target
;
8966 struct c_declarator
*ret
= XOBNEW (&parser_obstack
, struct c_declarator
);
8967 if (type_quals_attrs
)
8969 attrs
= type_quals_attrs
->attrs
;
8970 quals
= quals_from_declspecs (type_quals_attrs
);
8971 if (attrs
!= NULL_TREE
)
8972 itarget
= build_attrs_declarator (attrs
, target
);
8974 ret
->kind
= cdk_pointer
;
8975 ret
->declarator
= itarget
;
8976 ret
->u
.pointer_quals
= quals
;
8980 /* Return a pointer to a structure for an empty list of declaration
8983 struct c_declspecs
*
8984 build_null_declspecs (void)
8986 struct c_declspecs
*ret
= XOBNEW (&parser_obstack
, struct c_declspecs
);
8987 memset (&ret
->locations
, 0, cdw_number_of_elements
);
8992 ret
->align_log
= -1;
8993 ret
->typespec_word
= cts_none
;
8994 ret
->storage_class
= csc_none
;
8995 ret
->expr_const_operands
= true;
8996 ret
->declspecs_seen_p
= false;
8997 ret
->typespec_kind
= ctsk_none
;
8998 ret
->non_sc_seen_p
= false;
8999 ret
->typedef_p
= false;
9000 ret
->explicit_signed_p
= false;
9001 ret
->deprecated_p
= false;
9002 ret
->default_int_p
= false;
9003 ret
->long_p
= false;
9004 ret
->long_long_p
= false;
9005 ret
->short_p
= false;
9006 ret
->signed_p
= false;
9007 ret
->unsigned_p
= false;
9008 ret
->complex_p
= false;
9009 ret
->inline_p
= false;
9010 ret
->noreturn_p
= false;
9011 ret
->thread_p
= false;
9012 ret
->thread_gnu_p
= false;
9013 ret
->const_p
= false;
9014 ret
->volatile_p
= false;
9015 ret
->atomic_p
= false;
9016 ret
->restrict_p
= false;
9017 ret
->saturating_p
= false;
9018 ret
->alignas_p
= false;
9019 ret
->address_space
= ADDR_SPACE_GENERIC
;
9023 /* Add the address space ADDRSPACE to the declaration specifiers
9024 SPECS, returning SPECS. */
9026 struct c_declspecs
*
9027 declspecs_add_addrspace (source_location location
,
9028 struct c_declspecs
*specs
, addr_space_t as
)
9030 specs
->non_sc_seen_p
= true;
9031 specs
->declspecs_seen_p
= true;
9033 if (!ADDR_SPACE_GENERIC_P (specs
->address_space
)
9034 && specs
->address_space
!= as
)
9035 error ("incompatible address space qualifiers %qs and %qs",
9036 c_addr_space_name (as
),
9037 c_addr_space_name (specs
->address_space
));
9040 specs
->address_space
= as
;
9041 specs
->locations
[cdw_address_space
] = location
;
9046 /* Add the type qualifier QUAL to the declaration specifiers SPECS,
9049 struct c_declspecs
*
9050 declspecs_add_qual (source_location loc
,
9051 struct c_declspecs
*specs
, tree qual
)
9055 specs
->non_sc_seen_p
= true;
9056 specs
->declspecs_seen_p
= true;
9057 gcc_assert (TREE_CODE (qual
) == IDENTIFIER_NODE
9058 && C_IS_RESERVED_WORD (qual
));
9059 i
= C_RID_CODE (qual
);
9063 dupe
= specs
->const_p
;
9064 specs
->const_p
= true;
9065 specs
->locations
[cdw_const
] = loc
;
9068 dupe
= specs
->volatile_p
;
9069 specs
->volatile_p
= true;
9070 specs
->locations
[cdw_volatile
] = loc
;
9073 dupe
= specs
->restrict_p
;
9074 specs
->restrict_p
= true;
9075 specs
->locations
[cdw_restrict
] = loc
;
9078 dupe
= specs
->atomic_p
;
9079 specs
->atomic_p
= true;
9084 if (dupe
&& !flag_isoc99
)
9085 pedwarn (loc
, OPT_Wpedantic
, "duplicate %qE", qual
);
9089 /* Add the type specifier TYPE to the declaration specifiers SPECS,
9092 struct c_declspecs
*
9093 declspecs_add_type (location_t loc
, struct c_declspecs
*specs
,
9094 struct c_typespec spec
)
9096 tree type
= spec
.spec
;
9097 specs
->non_sc_seen_p
= true;
9098 specs
->declspecs_seen_p
= true;
9099 specs
->typespec_kind
= spec
.kind
;
9100 if (TREE_DEPRECATED (type
))
9101 specs
->deprecated_p
= true;
9103 /* Handle type specifier keywords. */
9104 if (TREE_CODE (type
) == IDENTIFIER_NODE
9105 && C_IS_RESERVED_WORD (type
)
9106 && C_RID_CODE (type
) != RID_CXX_COMPAT_WARN
)
9108 enum rid i
= C_RID_CODE (type
);
9111 error_at (loc
, "two or more data types in declaration specifiers");
9114 if ((int) i
<= (int) RID_LAST_MODIFIER
)
9116 /* "long", "short", "signed", "unsigned", "_Complex" or "_Sat". */
9121 if (specs
->long_long_p
)
9123 error_at (loc
, "%<long long long%> is too long for GCC");
9128 if (specs
->typespec_word
== cts_double
)
9131 ("both %<long long%> and %<double%> in "
9132 "declaration specifiers"));
9135 pedwarn_c90 (loc
, OPT_Wlong_long
,
9136 "ISO C90 does not support %<long long%>");
9137 specs
->long_long_p
= 1;
9138 specs
->locations
[cdw_long_long
] = loc
;
9143 ("both %<long%> and %<short%> in "
9144 "declaration specifiers"));
9145 else if (specs
->typespec_word
== cts_auto_type
)
9147 ("both %<long%> and %<__auto_type%> in "
9148 "declaration specifiers"));
9149 else if (specs
->typespec_word
== cts_void
)
9151 ("both %<long%> and %<void%> in "
9152 "declaration specifiers"));
9153 else if (specs
->typespec_word
== cts_int128
)
9155 ("both %<long%> and %<__int128%> in "
9156 "declaration specifiers"));
9157 else if (specs
->typespec_word
== cts_bool
)
9159 ("both %<long%> and %<_Bool%> in "
9160 "declaration specifiers"));
9161 else if (specs
->typespec_word
== cts_char
)
9163 ("both %<long%> and %<char%> in "
9164 "declaration specifiers"));
9165 else if (specs
->typespec_word
== cts_float
)
9167 ("both %<long%> and %<float%> in "
9168 "declaration specifiers"));
9169 else if (specs
->typespec_word
== cts_dfloat32
)
9171 ("both %<long%> and %<_Decimal32%> in "
9172 "declaration specifiers"));
9173 else if (specs
->typespec_word
== cts_dfloat64
)
9175 ("both %<long%> and %<_Decimal64%> in "
9176 "declaration specifiers"));
9177 else if (specs
->typespec_word
== cts_dfloat128
)
9179 ("both %<long%> and %<_Decimal128%> in "
9180 "declaration specifiers"));
9183 specs
->long_p
= true;
9184 specs
->locations
[cdw_long
] = loc
;
9188 dupe
= specs
->short_p
;
9191 ("both %<long%> and %<short%> in "
9192 "declaration specifiers"));
9193 else if (specs
->typespec_word
== cts_auto_type
)
9195 ("both %<short%> and %<__auto_type%> in "
9196 "declaration specifiers"));
9197 else if (specs
->typespec_word
== cts_void
)
9199 ("both %<short%> and %<void%> in "
9200 "declaration specifiers"));
9201 else if (specs
->typespec_word
== cts_int128
)
9203 ("both %<short%> and %<__int128%> in "
9204 "declaration specifiers"));
9205 else if (specs
->typespec_word
== cts_bool
)
9207 ("both %<short%> and %<_Bool%> in "
9208 "declaration specifiers"));
9209 else if (specs
->typespec_word
== cts_char
)
9211 ("both %<short%> and %<char%> in "
9212 "declaration specifiers"));
9213 else if (specs
->typespec_word
== cts_float
)
9215 ("both %<short%> and %<float%> in "
9216 "declaration specifiers"));
9217 else if (specs
->typespec_word
== cts_double
)
9219 ("both %<short%> and %<double%> in "
9220 "declaration specifiers"));
9221 else if (specs
->typespec_word
== cts_dfloat32
)
9223 ("both %<short%> and %<_Decimal32%> in "
9224 "declaration specifiers"));
9225 else if (specs
->typespec_word
== cts_dfloat64
)
9227 ("both %<short%> and %<_Decimal64%> in "
9228 "declaration specifiers"));
9229 else if (specs
->typespec_word
== cts_dfloat128
)
9231 ("both %<short%> and %<_Decimal128%> in "
9232 "declaration specifiers"));
9235 specs
->short_p
= true;
9236 specs
->locations
[cdw_short
] = loc
;
9240 dupe
= specs
->signed_p
;
9241 if (specs
->unsigned_p
)
9243 ("both %<signed%> and %<unsigned%> in "
9244 "declaration specifiers"));
9245 else if (specs
->typespec_word
== cts_auto_type
)
9247 ("both %<signed%> and %<__auto_type%> in "
9248 "declaration specifiers"));
9249 else if (specs
->typespec_word
== cts_void
)
9251 ("both %<signed%> and %<void%> in "
9252 "declaration specifiers"));
9253 else if (specs
->typespec_word
== cts_bool
)
9255 ("both %<signed%> and %<_Bool%> in "
9256 "declaration specifiers"));
9257 else if (specs
->typespec_word
== cts_float
)
9259 ("both %<signed%> and %<float%> in "
9260 "declaration specifiers"));
9261 else if (specs
->typespec_word
== cts_double
)
9263 ("both %<signed%> and %<double%> in "
9264 "declaration specifiers"));
9265 else if (specs
->typespec_word
== cts_dfloat32
)
9267 ("both %<signed%> and %<_Decimal32%> in "
9268 "declaration specifiers"));
9269 else if (specs
->typespec_word
== cts_dfloat64
)
9271 ("both %<signed%> and %<_Decimal64%> in "
9272 "declaration specifiers"));
9273 else if (specs
->typespec_word
== cts_dfloat128
)
9275 ("both %<signed%> and %<_Decimal128%> in "
9276 "declaration specifiers"));
9279 specs
->signed_p
= true;
9280 specs
->locations
[cdw_signed
] = loc
;
9284 dupe
= specs
->unsigned_p
;
9285 if (specs
->signed_p
)
9287 ("both %<signed%> and %<unsigned%> in "
9288 "declaration specifiers"));
9289 else if (specs
->typespec_word
== cts_auto_type
)
9291 ("both %<unsigned%> and %<__auto_type%> in "
9292 "declaration specifiers"));
9293 else if (specs
->typespec_word
== cts_void
)
9295 ("both %<unsigned%> and %<void%> in "
9296 "declaration specifiers"));
9297 else if (specs
->typespec_word
== cts_bool
)
9299 ("both %<unsigned%> and %<_Bool%> in "
9300 "declaration specifiers"));
9301 else if (specs
->typespec_word
== cts_float
)
9303 ("both %<unsigned%> and %<float%> in "
9304 "declaration specifiers"));
9305 else if (specs
->typespec_word
== cts_double
)
9307 ("both %<unsigned%> and %<double%> in "
9308 "declaration specifiers"));
9309 else if (specs
->typespec_word
== cts_dfloat32
)
9311 ("both %<unsigned%> and %<_Decimal32%> in "
9312 "declaration specifiers"));
9313 else if (specs
->typespec_word
== cts_dfloat64
)
9315 ("both %<unsigned%> and %<_Decimal64%> in "
9316 "declaration specifiers"));
9317 else if (specs
->typespec_word
== cts_dfloat128
)
9319 ("both %<unsigned%> and %<_Decimal128%> in "
9320 "declaration specifiers"));
9323 specs
->unsigned_p
= true;
9324 specs
->locations
[cdw_unsigned
] = loc
;
9328 dupe
= specs
->complex_p
;
9329 if (!flag_isoc99
&& !in_system_header_at (loc
))
9330 pedwarn (loc
, OPT_Wpedantic
,
9331 "ISO C90 does not support complex types");
9332 if (specs
->typespec_word
== cts_auto_type
)
9334 ("both %<complex%> and %<__auto_type%> in "
9335 "declaration specifiers"));
9336 else if (specs
->typespec_word
== cts_void
)
9338 ("both %<complex%> and %<void%> in "
9339 "declaration specifiers"));
9340 else if (specs
->typespec_word
== cts_bool
)
9342 ("both %<complex%> and %<_Bool%> in "
9343 "declaration specifiers"));
9344 else if (specs
->typespec_word
== cts_dfloat32
)
9346 ("both %<complex%> and %<_Decimal32%> in "
9347 "declaration specifiers"));
9348 else if (specs
->typespec_word
== cts_dfloat64
)
9350 ("both %<complex%> and %<_Decimal64%> in "
9351 "declaration specifiers"));
9352 else if (specs
->typespec_word
== cts_dfloat128
)
9354 ("both %<complex%> and %<_Decimal128%> in "
9355 "declaration specifiers"));
9356 else if (specs
->typespec_word
== cts_fract
)
9358 ("both %<complex%> and %<_Fract%> in "
9359 "declaration specifiers"));
9360 else if (specs
->typespec_word
== cts_accum
)
9362 ("both %<complex%> and %<_Accum%> in "
9363 "declaration specifiers"));
9364 else if (specs
->saturating_p
)
9366 ("both %<complex%> and %<_Sat%> in "
9367 "declaration specifiers"));
9370 specs
->complex_p
= true;
9371 specs
->locations
[cdw_complex
] = loc
;
9375 dupe
= specs
->saturating_p
;
9376 pedwarn (loc
, OPT_Wpedantic
,
9377 "ISO C does not support saturating types");
9378 if (specs
->typespec_word
== cts_int128
)
9381 ("both %<_Sat%> and %<__int128%> in "
9382 "declaration specifiers"));
9384 else if (specs
->typespec_word
== cts_auto_type
)
9386 ("both %<_Sat%> and %<__auto_type%> in "
9387 "declaration specifiers"));
9388 else if (specs
->typespec_word
== cts_void
)
9390 ("both %<_Sat%> and %<void%> in "
9391 "declaration specifiers"));
9392 else if (specs
->typespec_word
== cts_bool
)
9394 ("both %<_Sat%> and %<_Bool%> in "
9395 "declaration specifiers"));
9396 else if (specs
->typespec_word
== cts_char
)
9398 ("both %<_Sat%> and %<char%> in "
9399 "declaration specifiers"));
9400 else if (specs
->typespec_word
== cts_int
)
9402 ("both %<_Sat%> and %<int%> in "
9403 "declaration specifiers"));
9404 else if (specs
->typespec_word
== cts_float
)
9406 ("both %<_Sat%> and %<float%> in "
9407 "declaration specifiers"));
9408 else if (specs
->typespec_word
== cts_double
)
9410 ("both %<_Sat%> and %<double%> in "
9411 "declaration specifiers"));
9412 else if (specs
->typespec_word
== cts_dfloat32
)
9414 ("both %<_Sat%> and %<_Decimal32%> in "
9415 "declaration specifiers"));
9416 else if (specs
->typespec_word
== cts_dfloat64
)
9418 ("both %<_Sat%> and %<_Decimal64%> in "
9419 "declaration specifiers"));
9420 else if (specs
->typespec_word
== cts_dfloat128
)
9422 ("both %<_Sat%> and %<_Decimal128%> in "
9423 "declaration specifiers"));
9424 else if (specs
->complex_p
)
9426 ("both %<_Sat%> and %<complex%> in "
9427 "declaration specifiers"));
9430 specs
->saturating_p
= true;
9431 specs
->locations
[cdw_saturating
] = loc
;
9439 error_at (loc
, "duplicate %qE", type
);
9445 /* "void", "_Bool", "char", "int", "float", "double", "_Decimal32",
9446 "__int128", "_Decimal64", "_Decimal128", "_Fract", "_Accum" or
9448 if (specs
->typespec_word
!= cts_none
)
9451 "two or more data types in declaration specifiers");
9459 ("both %<long%> and %<__auto_type%> in "
9460 "declaration specifiers"));
9461 else if (specs
->short_p
)
9463 ("both %<short%> and %<__auto_type%> in "
9464 "declaration specifiers"));
9465 else if (specs
->signed_p
)
9467 ("both %<signed%> and %<__auto_type%> in "
9468 "declaration specifiers"));
9469 else if (specs
->unsigned_p
)
9471 ("both %<unsigned%> and %<__auto_type%> in "
9472 "declaration specifiers"));
9473 else if (specs
->complex_p
)
9475 ("both %<complex%> and %<__auto_type%> in "
9476 "declaration specifiers"));
9477 else if (specs
->saturating_p
)
9479 ("both %<_Sat%> and %<__auto_type%> in "
9480 "declaration specifiers"));
9483 specs
->typespec_word
= cts_auto_type
;
9484 specs
->locations
[cdw_typespec
] = loc
;
9488 if (int128_integer_type_node
== NULL_TREE
)
9490 error_at (loc
, "%<__int128%> is not supported for this target");
9493 if (!in_system_header_at (input_location
))
9494 pedwarn (loc
, OPT_Wpedantic
,
9495 "ISO C does not support %<__int128%> type");
9499 ("both %<__int128%> and %<long%> in "
9500 "declaration specifiers"));
9501 else if (specs
->saturating_p
)
9503 ("both %<_Sat%> and %<__int128%> in "
9504 "declaration specifiers"));
9505 else if (specs
->short_p
)
9507 ("both %<__int128%> and %<short%> in "
9508 "declaration specifiers"));
9511 specs
->typespec_word
= cts_int128
;
9512 specs
->locations
[cdw_typespec
] = loc
;
9518 ("both %<long%> and %<void%> in "
9519 "declaration specifiers"));
9520 else if (specs
->short_p
)
9522 ("both %<short%> and %<void%> in "
9523 "declaration specifiers"));
9524 else if (specs
->signed_p
)
9526 ("both %<signed%> and %<void%> in "
9527 "declaration specifiers"));
9528 else if (specs
->unsigned_p
)
9530 ("both %<unsigned%> and %<void%> in "
9531 "declaration specifiers"));
9532 else if (specs
->complex_p
)
9534 ("both %<complex%> and %<void%> in "
9535 "declaration specifiers"));
9536 else if (specs
->saturating_p
)
9538 ("both %<_Sat%> and %<void%> in "
9539 "declaration specifiers"));
9542 specs
->typespec_word
= cts_void
;
9543 specs
->locations
[cdw_typespec
] = loc
;
9549 ("both %<long%> and %<_Bool%> in "
9550 "declaration specifiers"));
9551 else if (specs
->short_p
)
9553 ("both %<short%> and %<_Bool%> in "
9554 "declaration specifiers"));
9555 else if (specs
->signed_p
)
9557 ("both %<signed%> and %<_Bool%> in "
9558 "declaration specifiers"));
9559 else if (specs
->unsigned_p
)
9561 ("both %<unsigned%> and %<_Bool%> in "
9562 "declaration specifiers"));
9563 else if (specs
->complex_p
)
9565 ("both %<complex%> and %<_Bool%> in "
9566 "declaration specifiers"));
9567 else if (specs
->saturating_p
)
9569 ("both %<_Sat%> and %<_Bool%> in "
9570 "declaration specifiers"));
9573 specs
->typespec_word
= cts_bool
;
9574 specs
->locations
[cdw_typespec
] = loc
;
9580 ("both %<long%> and %<char%> in "
9581 "declaration specifiers"));
9582 else if (specs
->short_p
)
9584 ("both %<short%> and %<char%> in "
9585 "declaration specifiers"));
9586 else if (specs
->saturating_p
)
9588 ("both %<_Sat%> and %<char%> in "
9589 "declaration specifiers"));
9592 specs
->typespec_word
= cts_char
;
9593 specs
->locations
[cdw_typespec
] = loc
;
9597 if (specs
->saturating_p
)
9599 ("both %<_Sat%> and %<int%> in "
9600 "declaration specifiers"));
9603 specs
->typespec_word
= cts_int
;
9604 specs
->locations
[cdw_typespec
] = loc
;
9610 ("both %<long%> and %<float%> in "
9611 "declaration specifiers"));
9612 else if (specs
->short_p
)
9614 ("both %<short%> and %<float%> in "
9615 "declaration specifiers"));
9616 else if (specs
->signed_p
)
9618 ("both %<signed%> and %<float%> in "
9619 "declaration specifiers"));
9620 else if (specs
->unsigned_p
)
9622 ("both %<unsigned%> and %<float%> in "
9623 "declaration specifiers"));
9624 else if (specs
->saturating_p
)
9626 ("both %<_Sat%> and %<float%> in "
9627 "declaration specifiers"));
9630 specs
->typespec_word
= cts_float
;
9631 specs
->locations
[cdw_typespec
] = loc
;
9635 if (specs
->long_long_p
)
9637 ("both %<long long%> and %<double%> in "
9638 "declaration specifiers"));
9639 else if (specs
->short_p
)
9641 ("both %<short%> and %<double%> in "
9642 "declaration specifiers"));
9643 else if (specs
->signed_p
)
9645 ("both %<signed%> and %<double%> in "
9646 "declaration specifiers"));
9647 else if (specs
->unsigned_p
)
9649 ("both %<unsigned%> and %<double%> in "
9650 "declaration specifiers"));
9651 else if (specs
->saturating_p
)
9653 ("both %<_Sat%> and %<double%> in "
9654 "declaration specifiers"));
9657 specs
->typespec_word
= cts_double
;
9658 specs
->locations
[cdw_typespec
] = loc
;
9666 if (i
== RID_DFLOAT32
)
9668 else if (i
== RID_DFLOAT64
)
9671 str
= "_Decimal128";
9672 if (specs
->long_long_p
)
9674 ("both %<long long%> and %<%s%> in "
9675 "declaration specifiers"),
9679 ("both %<long%> and %<%s%> in "
9680 "declaration specifiers"),
9682 else if (specs
->short_p
)
9684 ("both %<short%> and %<%s%> in "
9685 "declaration specifiers"),
9687 else if (specs
->signed_p
)
9689 ("both %<signed%> and %<%s%> in "
9690 "declaration specifiers"),
9692 else if (specs
->unsigned_p
)
9694 ("both %<unsigned%> and %<%s%> in "
9695 "declaration specifiers"),
9697 else if (specs
->complex_p
)
9699 ("both %<complex%> and %<%s%> in "
9700 "declaration specifiers"),
9702 else if (specs
->saturating_p
)
9704 ("both %<_Sat%> and %<%s%> in "
9705 "declaration specifiers"),
9707 else if (i
== RID_DFLOAT32
)
9708 specs
->typespec_word
= cts_dfloat32
;
9709 else if (i
== RID_DFLOAT64
)
9710 specs
->typespec_word
= cts_dfloat64
;
9712 specs
->typespec_word
= cts_dfloat128
;
9713 specs
->locations
[cdw_typespec
] = loc
;
9715 if (!targetm
.decimal_float_supported_p ())
9717 ("decimal floating point not supported "
9718 "for this target"));
9719 pedwarn (loc
, OPT_Wpedantic
,
9720 "ISO C does not support decimal floating point");
9730 if (specs
->complex_p
)
9732 ("both %<complex%> and %<%s%> in "
9733 "declaration specifiers"),
9735 else if (i
== RID_FRACT
)
9736 specs
->typespec_word
= cts_fract
;
9738 specs
->typespec_word
= cts_accum
;
9739 specs
->locations
[cdw_typespec
] = loc
;
9741 if (!targetm
.fixed_point_supported_p ())
9743 "fixed-point types not supported for this target");
9744 pedwarn (loc
, OPT_Wpedantic
,
9745 "ISO C does not support fixed-point types");
9748 /* ObjC reserved word "id", handled below. */
9754 /* Now we have a typedef (a TYPE_DECL node), an identifier (some
9755 form of ObjC type, cases such as "int" and "long" being handled
9756 above), a TYPE (struct, union, enum and typeof specifiers) or an
9757 ERROR_MARK. In none of these cases may there have previously
9758 been any type specifiers. */
9759 if (specs
->type
|| specs
->typespec_word
!= cts_none
9760 || specs
->long_p
|| specs
->short_p
|| specs
->signed_p
9761 || specs
->unsigned_p
|| specs
->complex_p
)
9762 error_at (loc
, "two or more data types in declaration specifiers");
9763 else if (TREE_CODE (type
) == TYPE_DECL
)
9765 if (TREE_TYPE (type
) == error_mark_node
)
9766 ; /* Allow the type to default to int to avoid cascading errors. */
9769 specs
->type
= TREE_TYPE (type
);
9770 specs
->decl_attr
= DECL_ATTRIBUTES (type
);
9771 specs
->typedef_p
= true;
9772 specs
->explicit_signed_p
= C_TYPEDEF_EXPLICITLY_SIGNED (type
);
9773 specs
->locations
[cdw_typedef
] = loc
;
9775 /* If this typedef name is defined in a struct, then a C++
9776 lookup would return a different value. */
9778 && I_SYMBOL_BINDING (DECL_NAME (type
))->in_struct
)
9779 warning_at (loc
, OPT_Wc___compat
,
9780 "C++ lookup of %qD would return a field, not a type",
9783 /* If we are parsing a struct, record that a struct field
9785 if (warn_cxx_compat
&& struct_parse_info
!= NULL
)
9786 struct_parse_info
->typedefs_seen
.safe_push (type
);
9789 else if (TREE_CODE (type
) == IDENTIFIER_NODE
)
9791 tree t
= lookup_name (type
);
9792 if (!t
|| TREE_CODE (t
) != TYPE_DECL
)
9793 error_at (loc
, "%qE fails to be a typedef or built in type", type
);
9794 else if (TREE_TYPE (t
) == error_mark_node
)
9798 specs
->type
= TREE_TYPE (t
);
9799 specs
->locations
[cdw_typespec
] = loc
;
9804 if (TREE_CODE (type
) != ERROR_MARK
&& spec
.kind
== ctsk_typeof
)
9806 specs
->typedef_p
= true;
9807 specs
->locations
[cdw_typedef
] = loc
;
9811 specs
->expr
= build2 (COMPOUND_EXPR
, TREE_TYPE (spec
.expr
),
9812 specs
->expr
, spec
.expr
);
9814 specs
->expr
= spec
.expr
;
9815 specs
->expr_const_operands
&= spec
.expr_const_operands
;
9824 /* Add the storage class specifier or function specifier SCSPEC to the
9825 declaration specifiers SPECS, returning SPECS. */
9827 struct c_declspecs
*
9828 declspecs_add_scspec (source_location loc
,
9829 struct c_declspecs
*specs
,
9833 enum c_storage_class n
= csc_none
;
9835 specs
->declspecs_seen_p
= true;
9836 gcc_assert (TREE_CODE (scspec
) == IDENTIFIER_NODE
9837 && C_IS_RESERVED_WORD (scspec
));
9838 i
= C_RID_CODE (scspec
);
9839 if (specs
->non_sc_seen_p
)
9840 warning (OPT_Wold_style_declaration
,
9841 "%qE is not at beginning of declaration", scspec
);
9845 /* C99 permits duplicate inline. Although of doubtful utility,
9846 it seems simplest to permit it in gnu89 mode as well, as
9847 there is also little utility in maintaining this as a
9848 difference between gnu89 and C99 inline. */
9850 specs
->inline_p
= true;
9851 specs
->locations
[cdw_inline
] = loc
;
9854 /* Duplicate _Noreturn is permitted. */
9856 specs
->noreturn_p
= true;
9857 specs
->locations
[cdw_noreturn
] = loc
;
9860 dupe
= specs
->thread_p
;
9861 if (specs
->storage_class
== csc_auto
)
9862 error ("%qE used with %<auto%>", scspec
);
9863 else if (specs
->storage_class
== csc_register
)
9864 error ("%qE used with %<register%>", scspec
);
9865 else if (specs
->storage_class
== csc_typedef
)
9866 error ("%qE used with %<typedef%>", scspec
);
9869 specs
->thread_p
= true;
9870 specs
->thread_gnu_p
= (strcmp (IDENTIFIER_POINTER (scspec
),
9872 /* A diagnostic is not required for the use of this
9873 identifier in the implementation namespace; only diagnose
9874 it for the C11 spelling because of existing code using
9875 the other spelling. */
9876 if (!flag_isoc11
&& !specs
->thread_gnu_p
)
9879 pedwarn (loc
, OPT_Wpedantic
,
9880 "ISO C99 does not support %qE", scspec
);
9882 pedwarn (loc
, OPT_Wpedantic
,
9883 "ISO C90 does not support %qE", scspec
);
9885 specs
->locations
[cdw_thread
] = loc
;
9893 /* Diagnose "__thread extern". */
9894 if (specs
->thread_p
&& specs
->thread_gnu_p
)
9895 error ("%<__thread%> before %<extern%>");
9902 /* Diagnose "__thread static". */
9903 if (specs
->thread_p
&& specs
->thread_gnu_p
)
9904 error ("%<__thread%> before %<static%>");
9912 if (n
!= csc_none
&& n
== specs
->storage_class
)
9916 if (i
== RID_THREAD
)
9917 error ("duplicate %<_Thread_local%> or %<__thread%>");
9919 error ("duplicate %qE", scspec
);
9923 if (specs
->storage_class
!= csc_none
&& n
!= specs
->storage_class
)
9925 error ("multiple storage classes in declaration specifiers");
9929 specs
->storage_class
= n
;
9930 specs
->locations
[cdw_storage_class
] = loc
;
9931 if (n
!= csc_extern
&& n
!= csc_static
&& specs
->thread_p
)
9933 error ("%qs used with %qE",
9934 specs
->thread_gnu_p
? "__thread" : "_Thread_local",
9936 specs
->thread_p
= false;
9943 /* Add the attributes ATTRS to the declaration specifiers SPECS,
9946 struct c_declspecs
*
9947 declspecs_add_attrs (source_location loc
, struct c_declspecs
*specs
, tree attrs
)
9949 specs
->attrs
= chainon (attrs
, specs
->attrs
);
9950 specs
->locations
[cdw_attributes
] = loc
;
9951 specs
->declspecs_seen_p
= true;
9955 /* Add an _Alignas specifier (expression ALIGN, or type whose
9956 alignment is ALIGN) to the declaration specifiers SPECS, returning
9958 struct c_declspecs
*
9959 declspecs_add_alignas (source_location loc
,
9960 struct c_declspecs
*specs
, tree align
)
9963 specs
->alignas_p
= true;
9964 specs
->locations
[cdw_alignas
] = loc
;
9965 if (align
== error_mark_node
)
9967 align_log
= check_user_alignment (align
, true);
9968 if (align_log
> specs
->align_log
)
9969 specs
->align_log
= align_log
;
9973 /* Combine "long", "short", "signed", "unsigned" and "_Complex" type
9974 specifiers with any other type specifier to determine the resulting
9975 type. This is where ISO C checks on complex types are made, since
9976 "_Complex long" is a prefix of the valid ISO C type "_Complex long
9979 struct c_declspecs
*
9980 finish_declspecs (struct c_declspecs
*specs
)
9982 /* If a type was specified as a whole, we have no modifiers and are
9984 if (specs
->type
!= NULL_TREE
)
9986 gcc_assert (!specs
->long_p
&& !specs
->long_long_p
&& !specs
->short_p
9987 && !specs
->signed_p
&& !specs
->unsigned_p
9988 && !specs
->complex_p
);
9990 /* Set a dummy type. */
9991 if (TREE_CODE (specs
->type
) == ERROR_MARK
)
9992 specs
->type
= integer_type_node
;
9996 /* If none of "void", "_Bool", "char", "int", "float" or "double"
9997 has been specified, treat it as "int" unless "_Complex" is
9998 present and there are no other specifiers. If we just have
9999 "_Complex", it is equivalent to "_Complex double", but e.g.
10000 "_Complex short" is equivalent to "_Complex short int". */
10001 if (specs
->typespec_word
== cts_none
)
10003 if (specs
->saturating_p
)
10005 error_at (specs
->locations
[cdw_saturating
],
10006 "%<_Sat%> is used without %<_Fract%> or %<_Accum%>");
10007 if (!targetm
.fixed_point_supported_p ())
10008 error_at (specs
->locations
[cdw_saturating
],
10009 "fixed-point types not supported for this target");
10010 specs
->typespec_word
= cts_fract
;
10012 else if (specs
->long_p
|| specs
->short_p
10013 || specs
->signed_p
|| specs
->unsigned_p
)
10015 specs
->typespec_word
= cts_int
;
10017 else if (specs
->complex_p
)
10019 specs
->typespec_word
= cts_double
;
10020 pedwarn (specs
->locations
[cdw_complex
], OPT_Wpedantic
,
10021 "ISO C does not support plain %<complex%> meaning "
10022 "%<double complex%>");
10026 specs
->typespec_word
= cts_int
;
10027 specs
->default_int_p
= true;
10028 /* We don't diagnose this here because grokdeclarator will
10029 give more specific diagnostics according to whether it is
10030 a function definition. */
10034 /* If "signed" was specified, record this to distinguish "int" and
10035 "signed int" in the case of a bit-field with
10036 -funsigned-bitfields. */
10037 specs
->explicit_signed_p
= specs
->signed_p
;
10039 /* Now compute the actual type. */
10040 switch (specs
->typespec_word
)
10042 case cts_auto_type
:
10043 gcc_assert (!specs
->long_p
&& !specs
->short_p
10044 && !specs
->signed_p
&& !specs
->unsigned_p
10045 && !specs
->complex_p
);
10046 /* Type to be filled in later. */
10049 gcc_assert (!specs
->long_p
&& !specs
->short_p
10050 && !specs
->signed_p
&& !specs
->unsigned_p
10051 && !specs
->complex_p
);
10052 specs
->type
= void_type_node
;
10055 gcc_assert (!specs
->long_p
&& !specs
->short_p
10056 && !specs
->signed_p
&& !specs
->unsigned_p
10057 && !specs
->complex_p
);
10058 specs
->type
= boolean_type_node
;
10061 gcc_assert (!specs
->long_p
&& !specs
->short_p
);
10062 gcc_assert (!(specs
->signed_p
&& specs
->unsigned_p
));
10063 if (specs
->signed_p
)
10064 specs
->type
= signed_char_type_node
;
10065 else if (specs
->unsigned_p
)
10066 specs
->type
= unsigned_char_type_node
;
10068 specs
->type
= char_type_node
;
10069 if (specs
->complex_p
)
10071 pedwarn (specs
->locations
[cdw_complex
], OPT_Wpedantic
,
10072 "ISO C does not support complex integer types");
10073 specs
->type
= build_complex_type (specs
->type
);
10077 gcc_assert (!specs
->long_p
&& !specs
->short_p
&& !specs
->long_long_p
);
10078 gcc_assert (!(specs
->signed_p
&& specs
->unsigned_p
));
10079 specs
->type
= (specs
->unsigned_p
10080 ? int128_unsigned_type_node
10081 : int128_integer_type_node
);
10082 if (specs
->complex_p
)
10084 pedwarn (specs
->locations
[cdw_complex
], OPT_Wpedantic
,
10085 "ISO C does not support complex integer types");
10086 specs
->type
= build_complex_type (specs
->type
);
10090 gcc_assert (!(specs
->long_p
&& specs
->short_p
));
10091 gcc_assert (!(specs
->signed_p
&& specs
->unsigned_p
));
10092 if (specs
->long_long_p
)
10093 specs
->type
= (specs
->unsigned_p
10094 ? long_long_unsigned_type_node
10095 : long_long_integer_type_node
);
10096 else if (specs
->long_p
)
10097 specs
->type
= (specs
->unsigned_p
10098 ? long_unsigned_type_node
10099 : long_integer_type_node
);
10100 else if (specs
->short_p
)
10101 specs
->type
= (specs
->unsigned_p
10102 ? short_unsigned_type_node
10103 : short_integer_type_node
);
10105 specs
->type
= (specs
->unsigned_p
10106 ? unsigned_type_node
10107 : integer_type_node
);
10108 if (specs
->complex_p
)
10110 pedwarn (specs
->locations
[cdw_complex
], OPT_Wpedantic
,
10111 "ISO C does not support complex integer types");
10112 specs
->type
= build_complex_type (specs
->type
);
10116 gcc_assert (!specs
->long_p
&& !specs
->short_p
10117 && !specs
->signed_p
&& !specs
->unsigned_p
);
10118 specs
->type
= (specs
->complex_p
10119 ? complex_float_type_node
10120 : float_type_node
);
10123 gcc_assert (!specs
->long_long_p
&& !specs
->short_p
10124 && !specs
->signed_p
&& !specs
->unsigned_p
);
10127 specs
->type
= (specs
->complex_p
10128 ? complex_long_double_type_node
10129 : long_double_type_node
);
10133 specs
->type
= (specs
->complex_p
10134 ? complex_double_type_node
10135 : double_type_node
);
10140 case cts_dfloat128
:
10141 gcc_assert (!specs
->long_p
&& !specs
->long_long_p
&& !specs
->short_p
10142 && !specs
->signed_p
&& !specs
->unsigned_p
&& !specs
->complex_p
);
10143 if (specs
->typespec_word
== cts_dfloat32
)
10144 specs
->type
= dfloat32_type_node
;
10145 else if (specs
->typespec_word
== cts_dfloat64
)
10146 specs
->type
= dfloat64_type_node
;
10148 specs
->type
= dfloat128_type_node
;
10151 gcc_assert (!specs
->complex_p
);
10152 if (!targetm
.fixed_point_supported_p ())
10153 specs
->type
= integer_type_node
;
10154 else if (specs
->saturating_p
)
10156 if (specs
->long_long_p
)
10157 specs
->type
= specs
->unsigned_p
10158 ? sat_unsigned_long_long_fract_type_node
10159 : sat_long_long_fract_type_node
;
10160 else if (specs
->long_p
)
10161 specs
->type
= specs
->unsigned_p
10162 ? sat_unsigned_long_fract_type_node
10163 : sat_long_fract_type_node
;
10164 else if (specs
->short_p
)
10165 specs
->type
= specs
->unsigned_p
10166 ? sat_unsigned_short_fract_type_node
10167 : sat_short_fract_type_node
;
10169 specs
->type
= specs
->unsigned_p
10170 ? sat_unsigned_fract_type_node
10171 : sat_fract_type_node
;
10175 if (specs
->long_long_p
)
10176 specs
->type
= specs
->unsigned_p
10177 ? unsigned_long_long_fract_type_node
10178 : long_long_fract_type_node
;
10179 else if (specs
->long_p
)
10180 specs
->type
= specs
->unsigned_p
10181 ? unsigned_long_fract_type_node
10182 : long_fract_type_node
;
10183 else if (specs
->short_p
)
10184 specs
->type
= specs
->unsigned_p
10185 ? unsigned_short_fract_type_node
10186 : short_fract_type_node
;
10188 specs
->type
= specs
->unsigned_p
10189 ? unsigned_fract_type_node
10194 gcc_assert (!specs
->complex_p
);
10195 if (!targetm
.fixed_point_supported_p ())
10196 specs
->type
= integer_type_node
;
10197 else if (specs
->saturating_p
)
10199 if (specs
->long_long_p
)
10200 specs
->type
= specs
->unsigned_p
10201 ? sat_unsigned_long_long_accum_type_node
10202 : sat_long_long_accum_type_node
;
10203 else if (specs
->long_p
)
10204 specs
->type
= specs
->unsigned_p
10205 ? sat_unsigned_long_accum_type_node
10206 : sat_long_accum_type_node
;
10207 else if (specs
->short_p
)
10208 specs
->type
= specs
->unsigned_p
10209 ? sat_unsigned_short_accum_type_node
10210 : sat_short_accum_type_node
;
10212 specs
->type
= specs
->unsigned_p
10213 ? sat_unsigned_accum_type_node
10214 : sat_accum_type_node
;
10218 if (specs
->long_long_p
)
10219 specs
->type
= specs
->unsigned_p
10220 ? unsigned_long_long_accum_type_node
10221 : long_long_accum_type_node
;
10222 else if (specs
->long_p
)
10223 specs
->type
= specs
->unsigned_p
10224 ? unsigned_long_accum_type_node
10225 : long_accum_type_node
;
10226 else if (specs
->short_p
)
10227 specs
->type
= specs
->unsigned_p
10228 ? unsigned_short_accum_type_node
10229 : short_accum_type_node
;
10231 specs
->type
= specs
->unsigned_p
10232 ? unsigned_accum_type_node
10237 gcc_unreachable ();
10243 /* A subroutine of c_write_global_declarations. Perform final processing
10244 on one file scope's declarations (or the external scope's declarations),
10248 c_write_global_declarations_1 (tree globals
)
10253 /* Process the decls in the order they were written. */
10254 for (decl
= globals
; decl
; decl
= DECL_CHAIN (decl
))
10256 /* Check for used but undefined static functions using the C
10257 standard's definition of "used", and set TREE_NO_WARNING so
10258 that check_global_declarations doesn't repeat the check. */
10259 if (TREE_CODE (decl
) == FUNCTION_DECL
10260 && DECL_INITIAL (decl
) == 0
10261 && DECL_EXTERNAL (decl
)
10262 && !TREE_PUBLIC (decl
)
10263 && C_DECL_USED (decl
))
10265 pedwarn (input_location
, 0, "%q+F used but never defined", decl
);
10266 TREE_NO_WARNING (decl
) = 1;
10269 wrapup_global_declaration_1 (decl
);
10274 reconsider
= false;
10275 for (decl
= globals
; decl
; decl
= DECL_CHAIN (decl
))
10276 reconsider
|= wrapup_global_declaration_2 (decl
);
10278 while (reconsider
);
10280 for (decl
= globals
; decl
; decl
= DECL_CHAIN (decl
))
10281 check_global_declaration_1 (decl
);
10284 /* A subroutine of c_write_global_declarations Emit debug information for each
10285 of the declarations in GLOBALS. */
10288 c_write_global_declarations_2 (tree globals
)
10292 for (decl
= globals
; decl
; decl
= DECL_CHAIN (decl
))
10293 debug_hooks
->global_decl (decl
);
10296 /* Callback to collect a source_ref from a DECL. */
10299 collect_source_ref_cb (tree decl
)
10301 if (!DECL_IS_BUILTIN (decl
))
10302 collect_source_ref (LOCATION_FILE (decl_sloc (decl
, false)));
10305 /* Preserve the external declarations scope across a garbage collect. */
10306 static GTY(()) tree ext_block
;
10308 /* Collect all references relevant to SOURCE_FILE. */
10311 collect_all_refs (const char *source_file
)
10316 FOR_EACH_VEC_ELT (*all_translation_units
, i
, t
)
10317 collect_ada_nodes (BLOCK_VARS (DECL_INITIAL (t
)), source_file
);
10319 collect_ada_nodes (BLOCK_VARS (ext_block
), source_file
);
10322 /* Iterate over all global declarations and call CALLBACK. */
10325 for_each_global_decl (void (*callback
) (tree decl
))
10332 FOR_EACH_VEC_ELT (*all_translation_units
, i
, t
)
10334 decls
= DECL_INITIAL (t
);
10335 for (decl
= BLOCK_VARS (decls
); decl
; decl
= TREE_CHAIN (decl
))
10339 for (decl
= BLOCK_VARS (ext_block
); decl
; decl
= TREE_CHAIN (decl
))
10344 c_write_global_declarations (void)
10349 /* We don't want to do this if generating a PCH. */
10353 timevar_start (TV_PHASE_DEFERRED
);
10355 /* Do the Objective-C stuff. This is where all the Objective-C
10356 module stuff gets generated (symtab, class/protocol/selector
10358 if (c_dialect_objc ())
10359 objc_write_global_declarations ();
10361 /* Close the external scope. */
10362 ext_block
= pop_scope ();
10363 external_scope
= 0;
10364 gcc_assert (!current_scope
);
10366 /* Handle -fdump-ada-spec[-slim]. */
10367 if (flag_dump_ada_spec
|| flag_dump_ada_spec_slim
)
10369 /* Build a table of files to generate specs for */
10370 if (flag_dump_ada_spec_slim
)
10371 collect_source_ref (main_input_filename
);
10373 for_each_global_decl (collect_source_ref_cb
);
10375 dump_ada_specs (collect_all_refs
, NULL
);
10380 tree tmp
= BLOCK_VARS (ext_block
);
10382 FILE * stream
= dump_begin (TDI_tu
, &flags
);
10385 dump_node (tmp
, flags
& ~TDF_SLIM
, stream
);
10386 dump_end (TDI_tu
, stream
);
10390 /* Process all file scopes in this compilation, and the external_scope,
10391 through wrapup_global_declarations and check_global_declarations. */
10392 FOR_EACH_VEC_ELT (*all_translation_units
, i
, t
)
10393 c_write_global_declarations_1 (BLOCK_VARS (DECL_INITIAL (t
)));
10394 c_write_global_declarations_1 (BLOCK_VARS (ext_block
));
10396 timevar_stop (TV_PHASE_DEFERRED
);
10397 timevar_start (TV_PHASE_OPT_GEN
);
10399 /* We're done parsing; proceed to optimize and emit assembly.
10400 FIXME: shouldn't be the front end's responsibility to call this. */
10401 finalize_compilation_unit ();
10403 timevar_stop (TV_PHASE_OPT_GEN
);
10404 timevar_start (TV_PHASE_DBGINFO
);
10406 /* After cgraph has had a chance to emit everything that's going to
10407 be emitted, output debug information for globals. */
10408 if (!seen_error ())
10410 timevar_push (TV_SYMOUT
);
10411 FOR_EACH_VEC_ELT (*all_translation_units
, i
, t
)
10412 c_write_global_declarations_2 (BLOCK_VARS (DECL_INITIAL (t
)));
10413 c_write_global_declarations_2 (BLOCK_VARS (ext_block
));
10414 timevar_pop (TV_SYMOUT
);
10418 timevar_stop (TV_PHASE_DBGINFO
);
10421 /* Register reserved keyword WORD as qualifier for address space AS. */
10424 c_register_addr_space (const char *word
, addr_space_t as
)
10426 int rid
= RID_FIRST_ADDR_SPACE
+ as
;
10429 /* Address space qualifiers are only supported
10430 in C with GNU extensions enabled. */
10431 if (c_dialect_objc () || flag_no_asm
)
10434 id
= get_identifier (word
);
10435 C_SET_RID_CODE (id
, rid
);
10436 C_IS_RESERVED_WORD (id
) = 1;
10437 ridpointers
[rid
] = id
;
10440 /* Return identifier to look up for omp declare reduction. */
10443 c_omp_reduction_id (enum tree_code reduction_code
, tree reduction_id
)
10445 const char *p
= NULL
;
10446 switch (reduction_code
)
10448 case PLUS_EXPR
: p
= "+"; break;
10449 case MULT_EXPR
: p
= "*"; break;
10450 case MINUS_EXPR
: p
= "-"; break;
10451 case BIT_AND_EXPR
: p
= "&"; break;
10452 case BIT_XOR_EXPR
: p
= "^"; break;
10453 case BIT_IOR_EXPR
: p
= "|"; break;
10454 case TRUTH_ANDIF_EXPR
: p
= "&&"; break;
10455 case TRUTH_ORIF_EXPR
: p
= "||"; break;
10456 case MIN_EXPR
: p
= "min"; break;
10457 case MAX_EXPR
: p
= "max"; break;
10464 if (TREE_CODE (reduction_id
) != IDENTIFIER_NODE
)
10465 return error_mark_node
;
10466 p
= IDENTIFIER_POINTER (reduction_id
);
10469 const char prefix
[] = "omp declare reduction ";
10470 size_t lenp
= sizeof (prefix
);
10471 size_t len
= strlen (p
);
10472 char *name
= XALLOCAVEC (char, lenp
+ len
);
10473 memcpy (name
, prefix
, lenp
- 1);
10474 memcpy (name
+ lenp
- 1, p
, len
+ 1);
10475 return get_identifier (name
);
10478 /* Lookup REDUCTION_ID in the current scope, or create an artificial
10479 VAR_DECL, bind it into the current scope and return it. */
10482 c_omp_reduction_decl (tree reduction_id
)
10484 struct c_binding
*b
= I_SYMBOL_BINDING (reduction_id
);
10485 if (b
!= NULL
&& B_IN_CURRENT_SCOPE (b
))
10488 tree decl
= build_decl (BUILTINS_LOCATION
, VAR_DECL
,
10489 reduction_id
, integer_type_node
);
10490 DECL_ARTIFICIAL (decl
) = 1;
10491 DECL_EXTERNAL (decl
) = 1;
10492 TREE_STATIC (decl
) = 1;
10493 TREE_PUBLIC (decl
) = 0;
10494 bind (reduction_id
, decl
, current_scope
, true, false, BUILTINS_LOCATION
);
10498 /* Lookup REDUCTION_ID in the first scope where it has entry for TYPE. */
10501 c_omp_reduction_lookup (tree reduction_id
, tree type
)
10503 struct c_binding
*b
= I_SYMBOL_BINDING (reduction_id
);
10507 for (t
= DECL_INITIAL (b
->decl
); t
; t
= TREE_CHAIN (t
))
10508 if (comptypes (TREE_PURPOSE (t
), type
))
10509 return TREE_VALUE (t
);
10512 return error_mark_node
;
10515 /* Helper function called via walk_tree, to diagnose invalid
10516 #pragma omp declare reduction combiners or initializers. */
10519 c_check_omp_declare_reduction_r (tree
*tp
, int *, void *data
)
10521 tree
*vars
= (tree
*) data
;
10522 if (SSA_VAR_P (*tp
)
10523 && !DECL_ARTIFICIAL (*tp
)
10527 location_t loc
= DECL_SOURCE_LOCATION (vars
[0]);
10528 if (strcmp (IDENTIFIER_POINTER (DECL_NAME (vars
[0])), "omp_out") == 0)
10529 error_at (loc
, "%<#pragma omp declare reduction%> combiner refers to "
10530 "variable %qD which is not %<omp_out%> nor %<omp_in%>",
10533 error_at (loc
, "%<#pragma omp declare reduction%> initializer refers "
10534 "to variable %qD which is not %<omp_priv%> nor "
10542 #include "gt-c-c-decl.h"