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
4018 && (TREE_STATIC (*node
) || DECL_EXTERNAL (*node
)))
4019 || TREE_CODE (*node
) == FUNCTION_DECL
))
4021 if (TREE_CODE (*node
) == VAR_DECL
4022 && ((DECL_CONTEXT (*node
)
4023 && TREE_CODE (DECL_CONTEXT (*node
)) == FUNCTION_DECL
)
4024 || (current_function_decl
&& !DECL_EXTERNAL (*node
))))
4025 error ("%q+D in block scope inside of declare target directive",
4027 else if (TREE_CODE (*node
) == VAR_DECL
4028 && !lang_hooks
.types
.omp_mappable_type (TREE_TYPE (*node
)))
4029 error ("%q+D in declare target directive does not have mappable type",
4032 attributes
= tree_cons (get_identifier ("omp declare target"),
4033 NULL_TREE
, attributes
);
4035 return decl_attributes (node
, attributes
, flags
);
4039 /* Decode a declarator in an ordinary declaration or data definition.
4040 This is called as soon as the type information and variable name
4041 have been parsed, before parsing the initializer if any.
4042 Here we create the ..._DECL node, fill in its type,
4043 and put it on the list of decls for the current context.
4044 The ..._DECL node is returned as the value.
4046 Exception: for arrays where the length is not specified,
4047 the type is left null, to be filled in by `finish_decl'.
4049 Function definitions do not come here; they go to start_function
4050 instead. However, external and forward declarations of functions
4051 do go through here. Structure field declarations are done by
4052 grokfield and not through here. */
4055 start_decl (struct c_declarator
*declarator
, struct c_declspecs
*declspecs
,
4056 bool initialized
, tree attributes
)
4060 tree expr
= NULL_TREE
;
4061 enum deprecated_states deprecated_state
= DEPRECATED_NORMAL
;
4063 /* An object declared as __attribute__((deprecated)) suppresses
4064 warnings of uses of other deprecated items. */
4065 if (lookup_attribute ("deprecated", attributes
))
4066 deprecated_state
= DEPRECATED_SUPPRESS
;
4068 decl
= grokdeclarator (declarator
, declspecs
,
4069 NORMAL
, initialized
, NULL
, &attributes
, &expr
, NULL
,
4071 if (!decl
|| decl
== error_mark_node
)
4075 add_stmt (fold_convert (void_type_node
, expr
));
4077 if (TREE_CODE (decl
) != FUNCTION_DECL
&& MAIN_NAME_P (DECL_NAME (decl
)))
4078 warning (OPT_Wmain
, "%q+D is usually a function", decl
);
4081 /* Is it valid for this decl to have an initializer at all?
4082 If not, set INITIALIZED to zero, which will indirectly
4083 tell 'finish_decl' to ignore the initializer once it is parsed. */
4084 switch (TREE_CODE (decl
))
4087 error ("typedef %qD is initialized (use __typeof__ instead)", decl
);
4092 error ("function %qD is initialized like a variable", decl
);
4097 /* DECL_INITIAL in a PARM_DECL is really DECL_ARG_TYPE. */
4098 error ("parameter %qD is initialized", decl
);
4103 /* Don't allow initializations for incomplete types except for
4104 arrays which might be completed by the initialization. */
4106 /* This can happen if the array size is an undefined macro.
4107 We already gave a warning, so we don't need another one. */
4108 if (TREE_TYPE (decl
) == error_mark_node
)
4110 else if (COMPLETE_TYPE_P (TREE_TYPE (decl
)))
4112 /* A complete type is ok if size is fixed. */
4114 if (TREE_CODE (TYPE_SIZE (TREE_TYPE (decl
))) != INTEGER_CST
4115 || C_DECL_VARIABLE_SIZE (decl
))
4117 error ("variable-sized object may not be initialized");
4121 else if (TREE_CODE (TREE_TYPE (decl
)) != ARRAY_TYPE
)
4123 error ("variable %qD has initializer but incomplete type", decl
);
4126 else if (C_DECL_VARIABLE_SIZE (decl
))
4128 /* Although C99 is unclear about whether incomplete arrays
4129 of VLAs themselves count as VLAs, it does not make
4130 sense to permit them to be initialized given that
4131 ordinary VLAs may not be initialized. */
4132 error ("variable-sized object may not be initialized");
4139 if (current_scope
== file_scope
)
4140 TREE_STATIC (decl
) = 1;
4142 /* Tell 'pushdecl' this is an initialized decl
4143 even though we don't yet have the initializer expression.
4144 Also tell 'finish_decl' it may store the real initializer. */
4145 DECL_INITIAL (decl
) = error_mark_node
;
4148 /* If this is a function declaration, write a record describing it to the
4149 prototypes file (if requested). */
4151 if (TREE_CODE (decl
) == FUNCTION_DECL
)
4152 gen_aux_info_record (decl
, 0, 0, prototype_p (TREE_TYPE (decl
)));
4154 /* ANSI specifies that a tentative definition which is not merged with
4155 a non-tentative definition behaves exactly like a definition with an
4156 initializer equal to zero. (Section 3.7.2)
4158 -fno-common gives strict ANSI behavior, though this tends to break
4159 a large body of code that grew up without this rule.
4161 Thread-local variables are never common, since there's no entrenched
4162 body of code to break, and it allows more efficient variable references
4163 in the presence of dynamic linking. */
4165 if (TREE_CODE (decl
) == VAR_DECL
4167 && TREE_PUBLIC (decl
)
4168 && !DECL_THREAD_LOCAL_P (decl
)
4170 DECL_COMMON (decl
) = 1;
4172 /* Set attributes here so if duplicate decl, will have proper attributes. */
4173 c_decl_attributes (&decl
, attributes
, 0);
4175 /* Handle gnu_inline attribute. */
4176 if (declspecs
->inline_p
4177 && !flag_gnu89_inline
4178 && TREE_CODE (decl
) == FUNCTION_DECL
4179 && (lookup_attribute ("gnu_inline", DECL_ATTRIBUTES (decl
))
4180 || current_function_decl
))
4182 if (declspecs
->storage_class
== csc_auto
&& current_scope
!= file_scope
)
4184 else if (declspecs
->storage_class
!= csc_static
)
4185 DECL_EXTERNAL (decl
) = !DECL_EXTERNAL (decl
);
4188 if (TREE_CODE (decl
) == FUNCTION_DECL
4189 && targetm
.calls
.promote_prototypes (TREE_TYPE (decl
)))
4191 struct c_declarator
*ce
= declarator
;
4193 if (ce
->kind
== cdk_pointer
)
4194 ce
= declarator
->declarator
;
4195 if (ce
->kind
== cdk_function
)
4197 tree args
= ce
->u
.arg_info
->parms
;
4198 for (; args
; args
= DECL_CHAIN (args
))
4200 tree type
= TREE_TYPE (args
);
4201 if (type
&& INTEGRAL_TYPE_P (type
)
4202 && TYPE_PRECISION (type
) < TYPE_PRECISION (integer_type_node
))
4203 DECL_ARG_TYPE (args
) = c_type_promotes_to (type
);
4208 if (TREE_CODE (decl
) == FUNCTION_DECL
4209 && DECL_DECLARED_INLINE_P (decl
)
4210 && DECL_UNINLINABLE (decl
)
4211 && lookup_attribute ("noinline", DECL_ATTRIBUTES (decl
)))
4212 warning (OPT_Wattributes
, "inline function %q+D given attribute noinline",
4215 /* C99 6.7.4p3: An inline definition of a function with external
4216 linkage shall not contain a definition of a modifiable object
4217 with static storage duration... */
4218 if (TREE_CODE (decl
) == VAR_DECL
4219 && current_scope
!= file_scope
4220 && TREE_STATIC (decl
)
4221 && !TREE_READONLY (decl
)
4222 && DECL_DECLARED_INLINE_P (current_function_decl
)
4223 && DECL_EXTERNAL (current_function_decl
))
4224 record_inline_static (input_location
, current_function_decl
,
4225 decl
, csi_modifiable
);
4227 if (c_dialect_objc ()
4228 && (TREE_CODE (decl
) == VAR_DECL
4229 || TREE_CODE (decl
) == FUNCTION_DECL
))
4230 objc_check_global_decl (decl
);
4232 /* Add this decl to the current scope.
4233 TEM may equal DECL or it may be a previous decl of the same name. */
4234 tem
= pushdecl (decl
);
4236 if (initialized
&& DECL_EXTERNAL (tem
))
4238 DECL_EXTERNAL (tem
) = 0;
4239 TREE_STATIC (tem
) = 1;
4245 /* Subroutine of finish_decl. TYPE is the type of an uninitialized object
4246 DECL or the non-array element type if DECL is an uninitialized array.
4247 If that type has a const member, diagnose this. */
4250 diagnose_uninitialized_cst_member (tree decl
, tree type
)
4253 for (field
= TYPE_FIELDS (type
); field
; field
= TREE_CHAIN (field
))
4256 if (TREE_CODE (field
) != FIELD_DECL
)
4258 field_type
= strip_array_types (TREE_TYPE (field
));
4260 if (TYPE_QUALS (field_type
) & TYPE_QUAL_CONST
)
4262 warning_at (DECL_SOURCE_LOCATION (decl
), OPT_Wc___compat
,
4263 "uninitialized const member in %qT is invalid in C++",
4264 strip_array_types (TREE_TYPE (decl
)));
4265 inform (DECL_SOURCE_LOCATION (field
), "%qD should be initialized", field
);
4268 if (TREE_CODE (field_type
) == RECORD_TYPE
4269 || TREE_CODE (field_type
) == UNION_TYPE
)
4270 diagnose_uninitialized_cst_member (decl
, field_type
);
4274 /* Finish processing of a declaration;
4275 install its initial value.
4276 If ORIGTYPE is not NULL_TREE, it is the original type of INIT.
4277 If the length of an array type is not known before,
4278 it must be determined now, from the initial value, or it is an error.
4280 INIT_LOC is the location of the initial value. */
4283 finish_decl (tree decl
, location_t init_loc
, tree init
,
4284 tree origtype
, tree asmspec_tree
)
4287 bool was_incomplete
= (DECL_SIZE (decl
) == 0);
4288 const char *asmspec
= 0;
4290 /* If a name was specified, get the string. */
4291 if ((TREE_CODE (decl
) == FUNCTION_DECL
|| TREE_CODE (decl
) == VAR_DECL
)
4292 && DECL_FILE_SCOPE_P (decl
))
4293 asmspec_tree
= maybe_apply_renaming_pragma (decl
, asmspec_tree
);
4295 asmspec
= TREE_STRING_POINTER (asmspec_tree
);
4297 if (TREE_CODE (decl
) == VAR_DECL
4298 && TREE_STATIC (decl
)
4299 && global_bindings_p ())
4300 /* So decl is a global variable. Record the types it uses
4301 so that we can decide later to emit debug info for them. */
4302 record_types_used_by_current_var_decl (decl
);
4304 /* If `start_decl' didn't like having an initialization, ignore it now. */
4305 if (init
!= 0 && DECL_INITIAL (decl
) == 0)
4308 /* Don't crash if parm is initialized. */
4309 if (TREE_CODE (decl
) == PARM_DECL
)
4313 store_init_value (init_loc
, decl
, init
, origtype
);
4315 if (c_dialect_objc () && (TREE_CODE (decl
) == VAR_DECL
4316 || TREE_CODE (decl
) == FUNCTION_DECL
4317 || TREE_CODE (decl
) == FIELD_DECL
))
4318 objc_check_decl (decl
);
4320 type
= TREE_TYPE (decl
);
4322 /* Deduce size of array from initialization, if not already known. */
4323 if (TREE_CODE (type
) == ARRAY_TYPE
4324 && TYPE_DOMAIN (type
) == 0
4325 && TREE_CODE (decl
) != TYPE_DECL
)
4328 = (TREE_STATIC (decl
)
4329 /* Even if pedantic, an external linkage array
4330 may have incomplete type at first. */
4331 ? pedantic
&& !TREE_PUBLIC (decl
)
4332 : !DECL_EXTERNAL (decl
));
4334 = complete_array_type (&TREE_TYPE (decl
), DECL_INITIAL (decl
),
4337 /* Get the completed type made by complete_array_type. */
4338 type
= TREE_TYPE (decl
);
4343 error ("initializer fails to determine size of %q+D", decl
);
4348 error ("array size missing in %q+D", decl
);
4349 /* If a `static' var's size isn't known,
4350 make it extern as well as static, so it does not get
4352 If it is not `static', then do not mark extern;
4353 finish_incomplete_decl will give it a default size
4354 and it will get allocated. */
4355 else if (!pedantic
&& TREE_STATIC (decl
) && !TREE_PUBLIC (decl
))
4356 DECL_EXTERNAL (decl
) = 1;
4360 error ("zero or negative size array %q+D", decl
);
4364 /* For global variables, update the copy of the type that
4365 exists in the binding. */
4366 if (TREE_PUBLIC (decl
))
4368 struct c_binding
*b_ext
= I_SYMBOL_BINDING (DECL_NAME (decl
));
4369 while (b_ext
&& !B_IN_EXTERNAL_SCOPE (b_ext
))
4370 b_ext
= b_ext
->shadowed
;
4373 if (b_ext
->u
.type
&& comptypes (b_ext
->u
.type
, type
))
4374 b_ext
->u
.type
= composite_type (b_ext
->u
.type
, type
);
4376 b_ext
->u
.type
= type
;
4385 if (DECL_INITIAL (decl
))
4386 TREE_TYPE (DECL_INITIAL (decl
)) = type
;
4388 relayout_decl (decl
);
4391 if (TREE_CODE (decl
) == VAR_DECL
)
4393 if (init
&& TREE_CODE (init
) == CONSTRUCTOR
)
4394 add_flexible_array_elts_to_size (decl
, init
);
4396 if (DECL_SIZE (decl
) == 0 && TREE_TYPE (decl
) != error_mark_node
4397 && COMPLETE_TYPE_P (TREE_TYPE (decl
)))
4398 layout_decl (decl
, 0);
4400 if (DECL_SIZE (decl
) == 0
4401 /* Don't give an error if we already gave one earlier. */
4402 && TREE_TYPE (decl
) != error_mark_node
4403 && (TREE_STATIC (decl
)
4404 /* A static variable with an incomplete type
4405 is an error if it is initialized.
4406 Also if it is not file scope.
4407 Otherwise, let it through, but if it is not `extern'
4408 then it may cause an error message later. */
4409 ? (DECL_INITIAL (decl
) != 0
4410 || !DECL_FILE_SCOPE_P (decl
))
4411 /* An automatic variable with an incomplete type
4413 : !DECL_EXTERNAL (decl
)))
4415 error ("storage size of %q+D isn%'t known", decl
);
4416 TREE_TYPE (decl
) = error_mark_node
;
4419 if ((DECL_EXTERNAL (decl
) || TREE_STATIC (decl
))
4420 && DECL_SIZE (decl
) != 0)
4422 if (TREE_CODE (DECL_SIZE (decl
)) == INTEGER_CST
)
4423 constant_expression_warning (DECL_SIZE (decl
));
4426 error ("storage size of %q+D isn%'t constant", decl
);
4427 TREE_TYPE (decl
) = error_mark_node
;
4431 if (TREE_USED (type
))
4433 TREE_USED (decl
) = 1;
4434 DECL_READ_P (decl
) = 1;
4438 /* If this is a function and an assembler name is specified, reset DECL_RTL
4439 so we can give it its new name. Also, update builtin_decl if it
4440 was a normal built-in. */
4441 if (TREE_CODE (decl
) == FUNCTION_DECL
&& asmspec
)
4443 if (DECL_BUILT_IN_CLASS (decl
) == BUILT_IN_NORMAL
)
4444 set_builtin_user_assembler_name (decl
, asmspec
);
4445 set_user_assembler_name (decl
, asmspec
);
4448 /* If #pragma weak was used, mark the decl weak now. */
4449 maybe_apply_pragma_weak (decl
);
4451 /* Output the assembler code and/or RTL code for variables and functions,
4452 unless the type is an undefined structure or union.
4453 If not, it will get done when the type is completed. */
4455 if (TREE_CODE (decl
) == VAR_DECL
|| TREE_CODE (decl
) == FUNCTION_DECL
)
4457 /* Determine the ELF visibility. */
4458 if (TREE_PUBLIC (decl
))
4459 c_determine_visibility (decl
);
4461 /* This is a no-op in c-lang.c or something real in objc-act.c. */
4462 if (c_dialect_objc ())
4463 objc_check_decl (decl
);
4467 /* If this is not a static variable, issue a warning.
4468 It doesn't make any sense to give an ASMSPEC for an
4469 ordinary, non-register local variable. Historically,
4470 GCC has accepted -- but ignored -- the ASMSPEC in
4472 if (!DECL_FILE_SCOPE_P (decl
)
4473 && TREE_CODE (decl
) == VAR_DECL
4474 && !C_DECL_REGISTER (decl
)
4475 && !TREE_STATIC (decl
))
4476 warning (0, "ignoring asm-specifier for non-static local "
4477 "variable %q+D", decl
);
4479 set_user_assembler_name (decl
, asmspec
);
4482 if (DECL_FILE_SCOPE_P (decl
))
4484 if (DECL_INITIAL (decl
) == NULL_TREE
4485 || DECL_INITIAL (decl
) == error_mark_node
)
4486 /* Don't output anything
4487 when a tentative file-scope definition is seen.
4488 But at end of compilation, do output code for them. */
4489 DECL_DEFER_OUTPUT (decl
) = 1;
4490 if (asmspec
&& C_DECL_REGISTER (decl
))
4491 DECL_HARD_REGISTER (decl
) = 1;
4492 rest_of_decl_compilation (decl
, true, 0);
4496 /* In conjunction with an ASMSPEC, the `register'
4497 keyword indicates that we should place the variable
4498 in a particular register. */
4499 if (asmspec
&& C_DECL_REGISTER (decl
))
4501 DECL_HARD_REGISTER (decl
) = 1;
4502 /* This cannot be done for a structure with volatile
4503 fields, on which DECL_REGISTER will have been
4505 if (!DECL_REGISTER (decl
))
4506 error ("cannot put object with volatile field into register");
4509 if (TREE_CODE (decl
) != FUNCTION_DECL
)
4511 /* If we're building a variable sized type, and we might be
4512 reachable other than via the top of the current binding
4513 level, then create a new BIND_EXPR so that we deallocate
4514 the object at the right time. */
4515 /* Note that DECL_SIZE can be null due to errors. */
4516 if (DECL_SIZE (decl
)
4517 && !TREE_CONSTANT (DECL_SIZE (decl
))
4518 && STATEMENT_LIST_HAS_LABEL (cur_stmt_list
))
4521 bind
= build3 (BIND_EXPR
, void_type_node
, NULL
, NULL
, NULL
);
4522 TREE_SIDE_EFFECTS (bind
) = 1;
4524 BIND_EXPR_BODY (bind
) = push_stmt_list ();
4526 add_stmt (build_stmt (DECL_SOURCE_LOCATION (decl
),
4532 if (!DECL_FILE_SCOPE_P (decl
))
4534 /* Recompute the RTL of a local array now
4535 if it used to be an incomplete type. */
4537 && !TREE_STATIC (decl
) && !DECL_EXTERNAL (decl
))
4539 /* If we used it already as memory, it must stay in memory. */
4540 TREE_ADDRESSABLE (decl
) = TREE_USED (decl
);
4541 /* If it's still incomplete now, no init will save it. */
4542 if (DECL_SIZE (decl
) == 0)
4543 DECL_INITIAL (decl
) = 0;
4548 if (TREE_CODE (decl
) == TYPE_DECL
)
4550 if (!DECL_FILE_SCOPE_P (decl
)
4551 && variably_modified_type_p (TREE_TYPE (decl
), NULL_TREE
))
4552 add_stmt (build_stmt (DECL_SOURCE_LOCATION (decl
), DECL_EXPR
, decl
));
4554 rest_of_decl_compilation (decl
, DECL_FILE_SCOPE_P (decl
), 0);
4557 /* Install a cleanup (aka destructor) if one was given. */
4558 if (TREE_CODE (decl
) == VAR_DECL
&& !TREE_STATIC (decl
))
4560 tree attr
= lookup_attribute ("cleanup", DECL_ATTRIBUTES (decl
));
4563 tree cleanup_id
= TREE_VALUE (TREE_VALUE (attr
));
4564 tree cleanup_decl
= lookup_name (cleanup_id
);
4566 vec
<tree
, va_gc
> *v
;
4568 /* Build "cleanup(&decl)" for the destructor. */
4569 cleanup
= build_unary_op (input_location
, ADDR_EXPR
, decl
, 0);
4571 v
->quick_push (cleanup
);
4572 cleanup
= c_build_function_call_vec (DECL_SOURCE_LOCATION (decl
),
4573 vNULL
, cleanup_decl
, v
, NULL
);
4576 /* Don't warn about decl unused; the cleanup uses it. */
4577 TREE_USED (decl
) = 1;
4578 TREE_USED (cleanup_decl
) = 1;
4579 DECL_READ_P (decl
) = 1;
4581 push_cleanup (decl
, cleanup
, false);
4586 && TREE_CODE (decl
) == VAR_DECL
4587 && !DECL_EXTERNAL (decl
)
4588 && DECL_INITIAL (decl
) == NULL_TREE
)
4590 type
= strip_array_types (type
);
4591 if (TREE_READONLY (decl
))
4592 warning_at (DECL_SOURCE_LOCATION (decl
), OPT_Wc___compat
,
4593 "uninitialized const %qD is invalid in C++", decl
);
4594 else if ((TREE_CODE (type
) == RECORD_TYPE
4595 || TREE_CODE (type
) == UNION_TYPE
)
4596 && C_TYPE_FIELDS_READONLY (type
))
4597 diagnose_uninitialized_cst_member (decl
, type
);
4600 invoke_plugin_callbacks (PLUGIN_FINISH_DECL
, decl
);
4603 /* Given a parsed parameter declaration, decode it into a PARM_DECL.
4604 EXPR is NULL or a pointer to an expression that needs to be
4605 evaluated for the side effects of array size expressions in the
4609 grokparm (const struct c_parm
*parm
, tree
*expr
)
4611 tree attrs
= parm
->attrs
;
4612 tree decl
= grokdeclarator (parm
->declarator
, parm
->specs
, PARM
, false,
4613 NULL
, &attrs
, expr
, NULL
, DEPRECATED_NORMAL
);
4615 decl_attributes (&decl
, attrs
, 0);
4620 /* Given a parsed parameter declaration, decode it into a PARM_DECL
4621 and push that on the current scope. EXPR is a pointer to an
4622 expression that needs to be evaluated for the side effects of array
4623 size expressions in the parameters. */
4626 push_parm_decl (const struct c_parm
*parm
, tree
*expr
)
4628 tree attrs
= parm
->attrs
;
4631 decl
= grokdeclarator (parm
->declarator
, parm
->specs
, PARM
, false, NULL
,
4632 &attrs
, expr
, NULL
, DEPRECATED_NORMAL
);
4633 decl_attributes (&decl
, attrs
, 0);
4635 decl
= pushdecl (decl
);
4637 finish_decl (decl
, input_location
, NULL_TREE
, NULL_TREE
, NULL_TREE
);
4640 /* Mark all the parameter declarations to date as forward decls.
4641 Also diagnose use of this extension. */
4644 mark_forward_parm_decls (void)
4646 struct c_binding
*b
;
4648 if (pedantic
&& !current_scope
->warned_forward_parm_decls
)
4650 pedwarn (input_location
, OPT_Wpedantic
,
4651 "ISO C forbids forward parameter declarations");
4652 current_scope
->warned_forward_parm_decls
= true;
4655 for (b
= current_scope
->bindings
; b
; b
= b
->prev
)
4656 if (TREE_CODE (b
->decl
) == PARM_DECL
)
4657 TREE_ASM_WRITTEN (b
->decl
) = 1;
4660 /* Build a COMPOUND_LITERAL_EXPR. TYPE is the type given in the compound
4661 literal, which may be an incomplete array type completed by the
4662 initializer; INIT is a CONSTRUCTOR at LOC that initializes the compound
4663 literal. NON_CONST is true if the initializers contain something
4664 that cannot occur in a constant expression. */
4667 build_compound_literal (location_t loc
, tree type
, tree init
, bool non_const
)
4669 /* We do not use start_decl here because we have a type, not a declarator;
4670 and do not use finish_decl because the decl should be stored inside
4671 the COMPOUND_LITERAL_EXPR rather than added elsewhere as a DECL_EXPR. */
4676 if (type
== error_mark_node
4677 || init
== error_mark_node
)
4678 return error_mark_node
;
4680 decl
= build_decl (loc
, VAR_DECL
, NULL_TREE
, type
);
4681 DECL_EXTERNAL (decl
) = 0;
4682 TREE_PUBLIC (decl
) = 0;
4683 TREE_STATIC (decl
) = (current_scope
== file_scope
);
4684 DECL_CONTEXT (decl
) = current_function_decl
;
4685 TREE_USED (decl
) = 1;
4686 DECL_READ_P (decl
) = 1;
4687 TREE_TYPE (decl
) = type
;
4688 TREE_READONLY (decl
) = (TYPE_READONLY (type
)
4689 || (TREE_CODE (type
) == ARRAY_TYPE
4690 && TYPE_READONLY (TREE_TYPE (type
))));
4691 store_init_value (loc
, decl
, init
, NULL_TREE
);
4693 if (TREE_CODE (type
) == ARRAY_TYPE
&& !COMPLETE_TYPE_P (type
))
4695 int failure
= complete_array_type (&TREE_TYPE (decl
),
4696 DECL_INITIAL (decl
), true);
4697 /* If complete_array_type returns 3, it means that the
4698 initial value of the compound literal is empty. Allow it. */
4699 gcc_assert (failure
== 0 || failure
== 3);
4701 type
= TREE_TYPE (decl
);
4702 TREE_TYPE (DECL_INITIAL (decl
)) = type
;
4705 if (type
== error_mark_node
|| !COMPLETE_TYPE_P (type
))
4707 c_incomplete_type_error (NULL_TREE
, type
);
4708 return error_mark_node
;
4711 stmt
= build_stmt (DECL_SOURCE_LOCATION (decl
), DECL_EXPR
, decl
);
4712 complit
= build1 (COMPOUND_LITERAL_EXPR
, type
, stmt
);
4713 TREE_SIDE_EFFECTS (complit
) = 1;
4715 layout_decl (decl
, 0);
4717 if (TREE_STATIC (decl
))
4719 /* This decl needs a name for the assembler output. */
4720 set_compound_literal_name (decl
);
4721 DECL_DEFER_OUTPUT (decl
) = 1;
4722 DECL_COMDAT (decl
) = 1;
4723 DECL_ARTIFICIAL (decl
) = 1;
4724 DECL_IGNORED_P (decl
) = 1;
4726 rest_of_decl_compilation (decl
, 1, 0);
4731 complit
= build2 (C_MAYBE_CONST_EXPR
, type
, NULL
, complit
);
4732 C_MAYBE_CONST_EXPR_NON_CONST (complit
) = 1;
4738 /* Check the type of a compound literal. Here we just check that it
4739 is valid for C++. */
4742 check_compound_literal_type (location_t loc
, struct c_type_name
*type_name
)
4745 && (type_name
->specs
->typespec_kind
== ctsk_tagdef
4746 || type_name
->specs
->typespec_kind
== ctsk_tagfirstref
))
4747 warning_at (loc
, OPT_Wc___compat
,
4748 "defining a type in a compound literal is invalid in C++");
4751 /* Determine whether TYPE is a structure with a flexible array member,
4752 or a union containing such a structure (possibly recursively). */
4755 flexible_array_type_p (tree type
)
4758 switch (TREE_CODE (type
))
4761 x
= TYPE_FIELDS (type
);
4764 while (DECL_CHAIN (x
) != NULL_TREE
)
4766 if (TREE_CODE (TREE_TYPE (x
)) == ARRAY_TYPE
4767 && TYPE_SIZE (TREE_TYPE (x
)) == NULL_TREE
4768 && TYPE_DOMAIN (TREE_TYPE (x
)) != NULL_TREE
4769 && TYPE_MAX_VALUE (TYPE_DOMAIN (TREE_TYPE (x
))) == NULL_TREE
)
4773 for (x
= TYPE_FIELDS (type
); x
!= NULL_TREE
; x
= DECL_CHAIN (x
))
4775 if (flexible_array_type_p (TREE_TYPE (x
)))
4784 /* Performs sanity checks on the TYPE and WIDTH of the bit-field NAME,
4785 replacing with appropriate values if they are invalid. */
4787 check_bitfield_type_and_width (tree
*type
, tree
*width
, tree orig_name
)
4790 unsigned int max_width
;
4791 unsigned HOST_WIDE_INT w
;
4792 const char *name
= (orig_name
4793 ? identifier_to_locale (IDENTIFIER_POINTER (orig_name
))
4794 : _("<anonymous>"));
4796 /* Detect and ignore out of range field width and process valid
4798 if (!INTEGRAL_TYPE_P (TREE_TYPE (*width
)))
4800 error ("bit-field %qs width not an integer constant", name
);
4801 *width
= integer_one_node
;
4805 if (TREE_CODE (*width
) != INTEGER_CST
)
4807 *width
= c_fully_fold (*width
, false, NULL
);
4808 if (TREE_CODE (*width
) == INTEGER_CST
)
4809 pedwarn (input_location
, OPT_Wpedantic
,
4810 "bit-field %qs width not an integer constant expression",
4813 if (TREE_CODE (*width
) != INTEGER_CST
)
4815 error ("bit-field %qs width not an integer constant", name
);
4816 *width
= integer_one_node
;
4818 constant_expression_warning (*width
);
4819 if (tree_int_cst_sgn (*width
) < 0)
4821 error ("negative width in bit-field %qs", name
);
4822 *width
= integer_one_node
;
4824 else if (integer_zerop (*width
) && orig_name
)
4826 error ("zero width for bit-field %qs", name
);
4827 *width
= integer_one_node
;
4831 /* Detect invalid bit-field type. */
4832 if (TREE_CODE (*type
) != INTEGER_TYPE
4833 && TREE_CODE (*type
) != BOOLEAN_TYPE
4834 && TREE_CODE (*type
) != ENUMERAL_TYPE
)
4836 error ("bit-field %qs has invalid type", name
);
4837 *type
= unsigned_type_node
;
4840 type_mv
= TYPE_MAIN_VARIANT (*type
);
4841 if (!in_system_header_at (input_location
)
4842 && type_mv
!= integer_type_node
4843 && type_mv
!= unsigned_type_node
4844 && type_mv
!= boolean_type_node
4846 pedwarn (input_location
, OPT_Wpedantic
,
4847 "type of bit-field %qs is a GCC extension", name
);
4849 max_width
= TYPE_PRECISION (*type
);
4851 if (0 < compare_tree_int (*width
, max_width
))
4853 error ("width of %qs exceeds its type", name
);
4855 *width
= build_int_cst (integer_type_node
, w
);
4858 w
= tree_to_uhwi (*width
);
4860 if (TREE_CODE (*type
) == ENUMERAL_TYPE
)
4862 struct lang_type
*lt
= TYPE_LANG_SPECIFIC (*type
);
4864 || w
< tree_int_cst_min_precision (lt
->enum_min
, TYPE_UNSIGNED (*type
))
4865 || w
< tree_int_cst_min_precision (lt
->enum_max
, TYPE_UNSIGNED (*type
)))
4866 warning (0, "%qs is narrower than values of its type", name
);
4872 /* Print warning about variable length array if necessary. */
4875 warn_variable_length_array (tree name
, tree size
)
4877 int const_size
= TREE_CONSTANT (size
);
4879 if (!flag_isoc99
&& pedantic
&& warn_vla
!= 0)
4884 pedwarn (input_location
, OPT_Wvla
,
4885 "ISO C90 forbids array %qE whose size "
4886 "can%'t be evaluated",
4889 pedwarn (input_location
, OPT_Wvla
, "ISO C90 forbids array whose size "
4890 "can%'t be evaluated");
4895 pedwarn (input_location
, OPT_Wvla
,
4896 "ISO C90 forbids variable length array %qE",
4899 pedwarn (input_location
, OPT_Wvla
, "ISO C90 forbids variable length array");
4902 else if (warn_vla
> 0)
4908 "the size of array %qE can"
4909 "%'t be evaluated", name
);
4912 "the size of array can %'t be evaluated");
4918 "variable length array %qE is used",
4922 "variable length array is used");
4927 /* Given declspecs and a declarator,
4928 determine the name and type of the object declared
4929 and construct a ..._DECL node for it.
4930 (In one case we can return a ..._TYPE node instead.
4931 For invalid input we sometimes return 0.)
4933 DECLSPECS is a c_declspecs structure for the declaration specifiers.
4935 DECL_CONTEXT says which syntactic context this declaration is in:
4936 NORMAL for most contexts. Make a VAR_DECL or FUNCTION_DECL or TYPE_DECL.
4937 FUNCDEF for a function definition. Like NORMAL but a few different
4938 error messages in each case. Return value may be zero meaning
4939 this definition is too screwy to try to parse.
4940 PARM for a parameter declaration (either within a function prototype
4941 or before a function body). Make a PARM_DECL, or return void_type_node.
4942 TYPENAME if for a typename (in a cast or sizeof).
4943 Don't make a DECL node; just return the ..._TYPE node.
4944 FIELD for a struct or union field; make a FIELD_DECL.
4945 INITIALIZED is true if the decl has an initializer.
4946 WIDTH is non-NULL for bit-fields, and is a pointer to an INTEGER_CST node
4947 representing the width of the bit-field.
4948 DECL_ATTRS points to the list of attributes that should be added to this
4949 decl. Any nested attributes that belong on the decl itself will be
4951 If EXPR is not NULL, any expressions that need to be evaluated as
4952 part of evaluating variably modified types will be stored in *EXPR.
4953 If EXPR_CONST_OPERANDS is not NULL, *EXPR_CONST_OPERANDS will be
4954 set to indicate whether operands in *EXPR can be used in constant
4956 DEPRECATED_STATE is a deprecated_states value indicating whether
4957 deprecation warnings should be suppressed.
4959 In the TYPENAME case, DECLARATOR is really an absolute declarator.
4960 It may also be so in the PARM case, for a prototype where the
4961 argument type is specified but not the name.
4963 This function is where the complicated C meanings of `static'
4964 and `extern' are interpreted. */
4967 grokdeclarator (const struct c_declarator
*declarator
,
4968 struct c_declspecs
*declspecs
,
4969 enum decl_context decl_context
, bool initialized
, tree
*width
,
4970 tree
*decl_attrs
, tree
*expr
, bool *expr_const_operands
,
4971 enum deprecated_states deprecated_state
)
4973 tree type
= declspecs
->type
;
4974 bool threadp
= declspecs
->thread_p
;
4975 enum c_storage_class storage_class
= declspecs
->storage_class
;
4980 int type_quals
= TYPE_UNQUALIFIED
;
4981 tree name
= NULL_TREE
;
4982 bool funcdef_flag
= false;
4983 bool funcdef_syntax
= false;
4984 bool size_varies
= false;
4985 tree decl_attr
= declspecs
->decl_attr
;
4986 int array_ptr_quals
= TYPE_UNQUALIFIED
;
4987 tree array_ptr_attrs
= NULL_TREE
;
4988 int array_parm_static
= 0;
4989 bool array_parm_vla_unspec_p
= false;
4990 tree returned_attrs
= NULL_TREE
;
4991 bool bitfield
= width
!= NULL
;
4993 struct c_arg_info
*arg_info
= 0;
4994 addr_space_t as1
, as2
, address_space
;
4995 location_t loc
= UNKNOWN_LOCATION
;
4998 bool expr_const_operands_dummy
;
4999 enum c_declarator_kind first_non_attr_kind
;
5000 unsigned int alignas_align
= 0;
5002 if (TREE_CODE (type
) == ERROR_MARK
)
5003 return error_mark_node
;
5006 if (expr_const_operands
== NULL
)
5007 expr_const_operands
= &expr_const_operands_dummy
;
5009 *expr
= declspecs
->expr
;
5010 *expr_const_operands
= declspecs
->expr_const_operands
;
5012 if (decl_context
== FUNCDEF
)
5013 funcdef_flag
= true, decl_context
= NORMAL
;
5015 /* Look inside a declarator for the name being declared
5016 and get it as an IDENTIFIER_NODE, for an error message. */
5018 const struct c_declarator
*decl
= declarator
;
5020 first_non_attr_kind
= cdk_attrs
;
5030 funcdef_syntax
= (decl
->kind
== cdk_function
);
5031 decl
= decl
->declarator
;
5032 if (first_non_attr_kind
== cdk_attrs
)
5033 first_non_attr_kind
= decl
->kind
;
5037 decl
= decl
->declarator
;
5044 if (first_non_attr_kind
== cdk_attrs
)
5045 first_non_attr_kind
= decl
->kind
;
5054 gcc_assert (decl_context
== PARM
5055 || decl_context
== TYPENAME
5056 || (decl_context
== FIELD
5057 && declarator
->kind
== cdk_id
));
5058 gcc_assert (!initialized
);
5062 /* A function definition's declarator must have the form of
5063 a function declarator. */
5065 if (funcdef_flag
&& !funcdef_syntax
)
5068 /* If this looks like a function definition, make it one,
5069 even if it occurs where parms are expected.
5070 Then store_parm_decls will reject it and not use it as a parm. */
5071 if (decl_context
== NORMAL
&& !funcdef_flag
&& current_scope
->parm_flag
)
5072 decl_context
= PARM
;
5074 if (declspecs
->deprecated_p
&& deprecated_state
!= DEPRECATED_SUPPRESS
)
5075 warn_deprecated_use (declspecs
->type
, declspecs
->decl_attr
);
5077 if ((decl_context
== NORMAL
|| decl_context
== FIELD
)
5078 && current_scope
== file_scope
5079 && variably_modified_type_p (type
, NULL_TREE
))
5082 error_at (loc
, "variably modified %qE at file scope", name
);
5084 error_at (loc
, "variably modified field at file scope");
5085 type
= integer_type_node
;
5088 size_varies
= C_TYPE_VARIABLE_SIZE (type
) != 0;
5090 /* Diagnose defaulting to "int". */
5092 if (declspecs
->default_int_p
&& !in_system_header_at (input_location
))
5094 /* Issue a warning if this is an ISO C 99 program or if
5095 -Wreturn-type and this is a function, or if -Wimplicit;
5096 prefer the former warning since it is more explicit. */
5097 if ((warn_implicit_int
|| warn_return_type
|| flag_isoc99
)
5099 warn_about_return_type
= 1;
5103 pedwarn_c99 (loc
, flag_isoc99
? 0 : OPT_Wimplicit_int
,
5104 "type defaults to %<int%> in declaration of %qE",
5107 pedwarn_c99 (input_location
, flag_isoc99
? 0 : OPT_Wimplicit_int
,
5108 "type defaults to %<int%> in type name");
5112 /* Adjust the type if a bit-field is being declared,
5113 -funsigned-bitfields applied and the type is not explicitly
5115 if (bitfield
&& !flag_signed_bitfields
&& !declspecs
->explicit_signed_p
5116 && TREE_CODE (type
) == INTEGER_TYPE
)
5117 type
= unsigned_type_for (type
);
5119 /* Figure out the type qualifiers for the declaration. There are
5120 two ways a declaration can become qualified. One is something
5121 like `const int i' where the `const' is explicit. Another is
5122 something like `typedef const int CI; CI i' where the type of the
5123 declaration contains the `const'. A third possibility is that
5124 there is a type qualifier on the element type of a typedefed
5125 array type, in which case we should extract that qualifier so
5126 that c_apply_type_quals_to_decl receives the full list of
5127 qualifiers to work with (C90 is not entirely clear about whether
5128 duplicate qualifiers should be diagnosed in this case, but it
5129 seems most appropriate to do so). */
5130 element_type
= strip_array_types (type
);
5131 constp
= declspecs
->const_p
+ TYPE_READONLY (element_type
);
5132 restrictp
= declspecs
->restrict_p
+ TYPE_RESTRICT (element_type
);
5133 volatilep
= declspecs
->volatile_p
+ TYPE_VOLATILE (element_type
);
5134 atomicp
= declspecs
->atomic_p
+ TYPE_ATOMIC (element_type
);
5135 as1
= declspecs
->address_space
;
5136 as2
= TYPE_ADDR_SPACE (element_type
);
5137 address_space
= ADDR_SPACE_GENERIC_P (as1
)? as2
: as1
;
5139 if (pedantic
&& !flag_isoc99
)
5142 pedwarn (loc
, OPT_Wpedantic
, "duplicate %<const%>");
5144 pedwarn (loc
, OPT_Wpedantic
, "duplicate %<restrict%>");
5146 pedwarn (loc
, OPT_Wpedantic
, "duplicate %<volatile%>");
5148 pedwarn (loc
, OPT_Wpedantic
, "duplicate %<_Atomic%>");
5152 if (!ADDR_SPACE_GENERIC_P (as1
) && !ADDR_SPACE_GENERIC_P (as2
) && as1
!= as2
)
5153 error_at (loc
, "conflicting named address spaces (%s vs %s)",
5154 c_addr_space_name (as1
), c_addr_space_name (as2
));
5156 if ((TREE_CODE (type
) == ARRAY_TYPE
5157 || first_non_attr_kind
== cdk_array
)
5158 && TYPE_QUALS (element_type
))
5159 type
= TYPE_MAIN_VARIANT (type
);
5160 type_quals
= ((constp
? TYPE_QUAL_CONST
: 0)
5161 | (restrictp
? TYPE_QUAL_RESTRICT
: 0)
5162 | (volatilep
? TYPE_QUAL_VOLATILE
: 0)
5163 | (atomicp
? TYPE_QUAL_ATOMIC
: 0)
5164 | ENCODE_QUAL_ADDR_SPACE (address_space
));
5166 /* Applying the _Atomic qualifier to an array type (through the use
5167 of typedefs or typeof) must be detected here. If the qualifier
5168 is introduced later, any appearance of applying it to an array is
5169 actually applying it to an element of that array. */
5170 if (atomicp
&& TREE_CODE (type
) == ARRAY_TYPE
)
5171 error_at (loc
, "%<_Atomic%>-qualified array type");
5173 /* Warn about storage classes that are invalid for certain
5174 kinds of declarations (parameters, typenames, etc.). */
5178 || storage_class
== csc_auto
5179 || storage_class
== csc_register
5180 || storage_class
== csc_typedef
))
5182 if (storage_class
== csc_auto
)
5184 (current_scope
== file_scope
) ? 0 : OPT_Wpedantic
,
5185 "function definition declared %<auto%>");
5186 if (storage_class
== csc_register
)
5187 error_at (loc
, "function definition declared %<register%>");
5188 if (storage_class
== csc_typedef
)
5189 error_at (loc
, "function definition declared %<typedef%>");
5191 error_at (loc
, "function definition declared %qs",
5192 declspecs
->thread_gnu_p
? "__thread" : "_Thread_local");
5194 if (storage_class
== csc_auto
5195 || storage_class
== csc_register
5196 || storage_class
== csc_typedef
)
5197 storage_class
= csc_none
;
5199 else if (decl_context
!= NORMAL
&& (storage_class
!= csc_none
|| threadp
))
5201 if (decl_context
== PARM
&& storage_class
== csc_register
)
5205 switch (decl_context
)
5209 error_at (loc
, "storage class specified for structure "
5212 error_at (loc
, "storage class specified for structure field");
5216 error_at (loc
, "storage class specified for parameter %qE",
5219 error_at (loc
, "storage class specified for unnamed parameter");
5222 error_at (loc
, "storage class specified for typename");
5225 storage_class
= csc_none
;
5229 else if (storage_class
== csc_extern
5233 /* 'extern' with initialization is invalid if not at file scope. */
5234 if (current_scope
== file_scope
)
5236 /* It is fine to have 'extern const' when compiling at C
5237 and C++ intersection. */
5238 if (!(warn_cxx_compat
&& constp
))
5239 warning_at (loc
, 0, "%qE initialized and declared %<extern%>",
5243 error_at (loc
, "%qE has both %<extern%> and initializer", name
);
5245 else if (current_scope
== file_scope
)
5247 if (storage_class
== csc_auto
)
5248 error_at (loc
, "file-scope declaration of %qE specifies %<auto%>",
5250 if (pedantic
&& storage_class
== csc_register
)
5251 pedwarn (input_location
, OPT_Wpedantic
,
5252 "file-scope declaration of %qE specifies %<register%>", name
);
5256 if (storage_class
== csc_extern
&& funcdef_flag
)
5257 error_at (loc
, "nested function %qE declared %<extern%>", name
);
5258 else if (threadp
&& storage_class
== csc_none
)
5260 error_at (loc
, "function-scope %qE implicitly auto and declared "
5262 declspecs
->thread_gnu_p
? "__thread" : "_Thread_local");
5267 /* Now figure out the structure of the declarator proper.
5268 Descend through it, creating more complex types, until we reach
5269 the declared identifier (or NULL_TREE, in an absolute declarator).
5270 At each stage we maintain an unqualified version of the type
5271 together with any qualifiers that should be applied to it with
5272 c_build_qualified_type; this way, array types including
5273 multidimensional array types are first built up in unqualified
5274 form and then the qualified form is created with
5275 TYPE_MAIN_VARIANT pointing to the unqualified form. */
5277 while (declarator
&& declarator
->kind
!= cdk_id
)
5279 if (type
== error_mark_node
)
5281 declarator
= declarator
->declarator
;
5285 /* Each level of DECLARATOR is either a cdk_array (for ...[..]),
5286 a cdk_pointer (for *...),
5287 a cdk_function (for ...(...)),
5288 a cdk_attrs (for nested attributes),
5289 or a cdk_id (for the name being declared
5290 or the place in an absolute declarator
5291 where the name was omitted).
5292 For the last case, we have just exited the loop.
5294 At this point, TYPE is the type of elements of an array,
5295 or for a function to return, or for a pointer to point to.
5296 After this sequence of ifs, TYPE is the type of the
5297 array or function or pointer, and DECLARATOR has had its
5298 outermost layer removed. */
5300 if (array_ptr_quals
!= TYPE_UNQUALIFIED
5301 || array_ptr_attrs
!= NULL_TREE
5302 || array_parm_static
)
5304 /* Only the innermost declarator (making a parameter be of
5305 array type which is converted to pointer type)
5306 may have static or type qualifiers. */
5307 error_at (loc
, "static or type qualifiers in non-parameter array declarator");
5308 array_ptr_quals
= TYPE_UNQUALIFIED
;
5309 array_ptr_attrs
= NULL_TREE
;
5310 array_parm_static
= 0;
5313 switch (declarator
->kind
)
5317 /* A declarator with embedded attributes. */
5318 tree attrs
= declarator
->u
.attrs
;
5319 const struct c_declarator
*inner_decl
;
5321 declarator
= declarator
->declarator
;
5322 inner_decl
= declarator
;
5323 while (inner_decl
->kind
== cdk_attrs
)
5324 inner_decl
= inner_decl
->declarator
;
5325 if (inner_decl
->kind
== cdk_id
)
5326 attr_flags
|= (int) ATTR_FLAG_DECL_NEXT
;
5327 else if (inner_decl
->kind
== cdk_function
)
5328 attr_flags
|= (int) ATTR_FLAG_FUNCTION_NEXT
;
5329 else if (inner_decl
->kind
== cdk_array
)
5330 attr_flags
|= (int) ATTR_FLAG_ARRAY_NEXT
;
5331 returned_attrs
= decl_attributes (&type
,
5332 chainon (returned_attrs
, attrs
),
5338 tree itype
= NULL_TREE
;
5339 tree size
= declarator
->u
.array
.dimen
;
5340 /* The index is a signed object `sizetype' bits wide. */
5341 tree index_type
= c_common_signed_type (sizetype
);
5343 array_ptr_quals
= declarator
->u
.array
.quals
;
5344 array_ptr_attrs
= declarator
->u
.array
.attrs
;
5345 array_parm_static
= declarator
->u
.array
.static_p
;
5346 array_parm_vla_unspec_p
= declarator
->u
.array
.vla_unspec_p
;
5348 declarator
= declarator
->declarator
;
5350 /* Check for some types that there cannot be arrays of. */
5352 if (VOID_TYPE_P (type
))
5355 error_at (loc
, "declaration of %qE as array of voids", name
);
5357 error_at (loc
, "declaration of type name as array of voids");
5358 type
= error_mark_node
;
5361 if (TREE_CODE (type
) == FUNCTION_TYPE
)
5364 error_at (loc
, "declaration of %qE as array of functions",
5367 error_at (loc
, "declaration of type name as array of "
5369 type
= error_mark_node
;
5372 if (pedantic
&& !in_system_header_at (input_location
)
5373 && flexible_array_type_p (type
))
5374 pedwarn (loc
, OPT_Wpedantic
,
5375 "invalid use of structure with flexible array member");
5377 if (size
== error_mark_node
)
5378 type
= error_mark_node
;
5380 if (type
== error_mark_node
)
5383 /* If size was specified, set ITYPE to a range-type for
5384 that size. Otherwise, ITYPE remains null. finish_decl
5385 may figure it out from an initial value. */
5389 bool size_maybe_const
= true;
5390 bool size_int_const
= (TREE_CODE (size
) == INTEGER_CST
5391 && !TREE_OVERFLOW (size
));
5392 bool this_size_varies
= false;
5394 /* Strip NON_LVALUE_EXPRs since we aren't using as an
5396 STRIP_TYPE_NOPS (size
);
5398 if (!INTEGRAL_TYPE_P (TREE_TYPE (size
)))
5401 error_at (loc
, "size of array %qE has non-integer type",
5405 "size of unnamed array has non-integer type");
5406 size
= integer_one_node
;
5409 size
= c_fully_fold (size
, false, &size_maybe_const
);
5411 if (pedantic
&& size_maybe_const
&& integer_zerop (size
))
5414 pedwarn (loc
, OPT_Wpedantic
,
5415 "ISO C forbids zero-size array %qE", name
);
5417 pedwarn (loc
, OPT_Wpedantic
,
5418 "ISO C forbids zero-size array");
5421 if (TREE_CODE (size
) == INTEGER_CST
&& size_maybe_const
)
5423 constant_expression_warning (size
);
5424 if (tree_int_cst_sgn (size
) < 0)
5427 error_at (loc
, "size of array %qE is negative", name
);
5429 error_at (loc
, "size of unnamed array is negative");
5430 size
= integer_one_node
;
5432 /* Handle a size folded to an integer constant but
5433 not an integer constant expression. */
5434 if (!size_int_const
)
5436 /* If this is a file scope declaration of an
5437 ordinary identifier, this is invalid code;
5438 diagnosing it here and not subsequently
5439 treating the type as variable-length avoids
5440 more confusing diagnostics later. */
5441 if ((decl_context
== NORMAL
|| decl_context
== FIELD
)
5442 && current_scope
== file_scope
)
5443 pedwarn (input_location
, 0,
5444 "variably modified %qE at file scope",
5447 this_size_varies
= size_varies
= true;
5448 warn_variable_length_array (name
, size
);
5451 else if ((decl_context
== NORMAL
|| decl_context
== FIELD
)
5452 && current_scope
== file_scope
)
5454 error_at (loc
, "variably modified %qE at file scope", name
);
5455 size
= integer_one_node
;
5459 /* Make sure the array size remains visibly
5460 nonconstant even if it is (eg) a const variable
5461 with known value. */
5462 this_size_varies
= size_varies
= true;
5463 warn_variable_length_array (name
, size
);
5464 if (flag_sanitize
& SANITIZE_VLA
5465 && decl_context
== NORMAL
)
5467 /* Evaluate the array size only once. */
5468 size
= c_save_expr (size
);
5469 size
= c_fully_fold (size
, false, NULL
);
5470 size
= fold_build2 (COMPOUND_EXPR
, TREE_TYPE (size
),
5471 ubsan_instrument_vla (loc
, size
),
5476 if (integer_zerop (size
) && !this_size_varies
)
5478 /* A zero-length array cannot be represented with
5479 an unsigned index type, which is what we'll
5480 get with build_index_type. Create an
5481 open-ended range instead. */
5482 itype
= build_range_type (sizetype
, size
, NULL_TREE
);
5486 /* Arrange for the SAVE_EXPR on the inside of the
5487 MINUS_EXPR, which allows the -1 to get folded
5488 with the +1 that happens when building TYPE_SIZE. */
5490 size
= save_expr (size
);
5491 if (this_size_varies
&& TREE_CODE (size
) == INTEGER_CST
)
5492 size
= build2 (COMPOUND_EXPR
, TREE_TYPE (size
),
5493 integer_zero_node
, size
);
5495 /* Compute the maximum valid index, that is, size
5496 - 1. Do the calculation in index_type, so that
5497 if it is a variable the computations will be
5498 done in the proper mode. */
5499 itype
= fold_build2_loc (loc
, MINUS_EXPR
, index_type
,
5500 convert (index_type
, size
),
5501 convert (index_type
,
5504 /* The above overflows when size does not fit
5506 ??? While a size of INT_MAX+1 technically shouldn't
5507 cause an overflow (because we subtract 1), handling
5508 this case seems like an unnecessary complication. */
5509 if (TREE_CODE (size
) == INTEGER_CST
5510 && !int_fits_type_p (size
, index_type
))
5513 error_at (loc
, "size of array %qE is too large",
5516 error_at (loc
, "size of unnamed array is too large");
5517 type
= error_mark_node
;
5521 itype
= build_index_type (itype
);
5523 if (this_size_varies
)
5526 *expr
= build2 (COMPOUND_EXPR
, TREE_TYPE (size
),
5530 *expr_const_operands
&= size_maybe_const
;
5533 else if (decl_context
== FIELD
)
5535 bool flexible_array_member
= false;
5536 if (array_parm_vla_unspec_p
)
5537 /* Field names can in fact have function prototype
5538 scope so [*] is disallowed here through making
5539 the field variably modified, not through being
5540 something other than a declaration with function
5545 const struct c_declarator
*t
= declarator
;
5546 while (t
->kind
== cdk_attrs
)
5548 flexible_array_member
= (t
->kind
== cdk_id
);
5550 if (flexible_array_member
5551 && pedantic
&& !flag_isoc99
5552 && !in_system_header_at (input_location
))
5553 pedwarn (loc
, OPT_Wpedantic
,
5554 "ISO C90 does not support flexible array members");
5556 /* ISO C99 Flexible array members are effectively
5557 identical to GCC's zero-length array extension. */
5558 if (flexible_array_member
|| array_parm_vla_unspec_p
)
5559 itype
= build_range_type (sizetype
, size_zero_node
,
5562 else if (decl_context
== PARM
)
5564 if (array_parm_vla_unspec_p
)
5566 itype
= build_range_type (sizetype
, size_zero_node
, NULL_TREE
);
5570 else if (decl_context
== TYPENAME
)
5572 if (array_parm_vla_unspec_p
)
5575 warning (0, "%<[*]%> not in a declaration");
5576 /* We use this to avoid messing up with incomplete
5577 array types of the same type, that would
5578 otherwise be modified below. */
5579 itype
= build_range_type (sizetype
, size_zero_node
,
5585 /* Complain about arrays of incomplete types. */
5586 if (!COMPLETE_TYPE_P (type
))
5588 error_at (loc
, "array type has incomplete element type");
5589 type
= error_mark_node
;
5592 /* When itype is NULL, a shared incomplete array type is
5593 returned for all array of a given type. Elsewhere we
5594 make sure we don't complete that type before copying
5595 it, but here we want to make sure we don't ever
5596 modify the shared type, so we gcc_assert (itype)
5599 addr_space_t as
= DECODE_QUAL_ADDR_SPACE (type_quals
);
5600 if (!ADDR_SPACE_GENERIC_P (as
) && as
!= TYPE_ADDR_SPACE (type
))
5601 type
= build_qualified_type (type
,
5602 ENCODE_QUAL_ADDR_SPACE (as
));
5604 type
= build_array_type (type
, itype
);
5607 if (type
!= error_mark_node
)
5611 /* It is ok to modify type here even if itype is
5612 NULL: if size_varies, we're in a
5613 multi-dimensional array and the inner type has
5614 variable size, so the enclosing shared array type
5616 if (size
&& TREE_CODE (size
) == INTEGER_CST
)
5618 = build_distinct_type_copy (TYPE_MAIN_VARIANT (type
));
5619 C_TYPE_VARIABLE_SIZE (type
) = 1;
5622 /* The GCC extension for zero-length arrays differs from
5623 ISO flexible array members in that sizeof yields
5625 if (size
&& integer_zerop (size
))
5628 type
= build_distinct_type_copy (TYPE_MAIN_VARIANT (type
));
5629 TYPE_SIZE (type
) = bitsize_zero_node
;
5630 TYPE_SIZE_UNIT (type
) = size_zero_node
;
5631 SET_TYPE_STRUCTURAL_EQUALITY (type
);
5633 if (array_parm_vla_unspec_p
)
5636 /* The type is complete. C99 6.7.5.2p4 */
5637 type
= build_distinct_type_copy (TYPE_MAIN_VARIANT (type
));
5638 TYPE_SIZE (type
) = bitsize_zero_node
;
5639 TYPE_SIZE_UNIT (type
) = size_zero_node
;
5640 SET_TYPE_STRUCTURAL_EQUALITY (type
);
5644 if (decl_context
!= PARM
5645 && (array_ptr_quals
!= TYPE_UNQUALIFIED
5646 || array_ptr_attrs
!= NULL_TREE
5647 || array_parm_static
))
5649 error_at (loc
, "static or type qualifiers in non-parameter array declarator");
5650 array_ptr_quals
= TYPE_UNQUALIFIED
;
5651 array_ptr_attrs
= NULL_TREE
;
5652 array_parm_static
= 0;
5658 /* Say it's a definition only for the declarator closest
5659 to the identifier, apart possibly from some
5661 bool really_funcdef
= false;
5665 const struct c_declarator
*t
= declarator
->declarator
;
5666 while (t
->kind
== cdk_attrs
)
5668 really_funcdef
= (t
->kind
== cdk_id
);
5671 /* Declaring a function type. Make sure we have a valid
5672 type for the function to return. */
5673 if (type
== error_mark_node
)
5676 size_varies
= false;
5678 /* Warn about some types functions can't return. */
5679 if (TREE_CODE (type
) == FUNCTION_TYPE
)
5682 error_at (loc
, "%qE declared as function returning a "
5685 error_at (loc
, "type name declared as function "
5686 "returning a function");
5687 type
= integer_type_node
;
5689 if (TREE_CODE (type
) == ARRAY_TYPE
)
5692 error_at (loc
, "%qE declared as function returning an array",
5695 error_at (loc
, "type name declared as function returning "
5697 type
= integer_type_node
;
5699 errmsg
= targetm
.invalid_return_type (type
);
5703 type
= integer_type_node
;
5706 /* Construct the function type and go to the next
5707 inner layer of declarator. */
5708 arg_info
= declarator
->u
.arg_info
;
5709 arg_types
= grokparms (arg_info
, really_funcdef
);
5711 /* Type qualifiers before the return type of the function
5712 qualify the return type, not the function type. */
5715 /* Type qualifiers on a function return type are
5716 normally permitted by the standard but have no
5717 effect, so give a warning at -Wreturn-type.
5718 Qualifiers on a void return type are banned on
5719 function definitions in ISO C; GCC used to used
5720 them for noreturn functions. */
5721 if (VOID_TYPE_P (type
) && really_funcdef
)
5723 "function definition has qualified void return type");
5725 warning_at (loc
, OPT_Wignored_qualifiers
,
5726 "type qualifiers ignored on function return type");
5728 type
= c_build_qualified_type (type
, type_quals
);
5730 type_quals
= TYPE_UNQUALIFIED
;
5732 type
= build_function_type (type
, arg_types
);
5733 declarator
= declarator
->declarator
;
5735 /* Set the TYPE_CONTEXTs for each tagged type which is local to
5736 the formal parameter list of this FUNCTION_TYPE to point to
5737 the FUNCTION_TYPE node itself. */
5742 FOR_EACH_VEC_SAFE_ELT_REVERSE (arg_info
->tags
, ix
, tag
)
5743 TYPE_CONTEXT (tag
->type
) = type
;
5749 /* Merge any constancy or volatility into the target type
5751 if ((type_quals
& TYPE_QUAL_ATOMIC
)
5752 && TREE_CODE (type
) == FUNCTION_TYPE
)
5755 "%<_Atomic%>-qualified function type");
5756 type_quals
&= ~TYPE_QUAL_ATOMIC
;
5758 else if (pedantic
&& TREE_CODE (type
) == FUNCTION_TYPE
5760 pedwarn (loc
, OPT_Wpedantic
,
5761 "ISO C forbids qualified function types");
5763 type
= c_build_qualified_type (type
, type_quals
);
5764 size_varies
= false;
5766 /* When the pointed-to type involves components of variable size,
5767 care must be taken to ensure that the size evaluation code is
5768 emitted early enough to dominate all the possible later uses
5769 and late enough for the variables on which it depends to have
5772 This is expected to happen automatically when the pointed-to
5773 type has a name/declaration of it's own, but special attention
5774 is required if the type is anonymous.
5776 We handle the NORMAL and FIELD contexts here by attaching an
5777 artificial TYPE_DECL to such pointed-to type. This forces the
5778 sizes evaluation at a safe point and ensures it is not deferred
5779 until e.g. within a deeper conditional context.
5781 We expect nothing to be needed here for PARM or TYPENAME.
5782 Pushing a TYPE_DECL at this point for TYPENAME would actually
5783 be incorrect, as we might be in the middle of an expression
5784 with side effects on the pointed-to type size "arguments" prior
5785 to the pointer declaration point and the fake TYPE_DECL in the
5786 enclosing context would force the size evaluation prior to the
5789 if (!TYPE_NAME (type
)
5790 && (decl_context
== NORMAL
|| decl_context
== FIELD
)
5791 && variably_modified_type_p (type
, NULL_TREE
))
5793 tree decl
= build_decl (loc
, TYPE_DECL
, NULL_TREE
, type
);
5794 DECL_ARTIFICIAL (decl
) = 1;
5796 finish_decl (decl
, loc
, NULL_TREE
, NULL_TREE
, NULL_TREE
);
5797 TYPE_NAME (type
) = decl
;
5800 type
= c_build_pointer_type (type
);
5802 /* Process type qualifiers (such as const or volatile)
5803 that were given inside the `*'. */
5804 type_quals
= declarator
->u
.pointer_quals
;
5806 declarator
= declarator
->declarator
;
5813 *decl_attrs
= chainon (returned_attrs
, *decl_attrs
);
5815 /* Now TYPE has the actual type, apart from any qualifiers in
5818 /* Warn about address space used for things other than static memory or
5820 address_space
= DECODE_QUAL_ADDR_SPACE (type_quals
);
5821 if (!ADDR_SPACE_GENERIC_P (address_space
))
5823 if (decl_context
== NORMAL
)
5825 switch (storage_class
)
5828 error ("%qs combined with %<auto%> qualifier for %qE",
5829 c_addr_space_name (address_space
), name
);
5832 error ("%qs combined with %<register%> qualifier for %qE",
5833 c_addr_space_name (address_space
), name
);
5836 if (current_function_scope
)
5838 error ("%qs specified for auto variable %qE",
5839 c_addr_space_name (address_space
), name
);
5851 else if (decl_context
== PARM
&& TREE_CODE (type
) != ARRAY_TYPE
)
5854 error ("%qs specified for parameter %qE",
5855 c_addr_space_name (address_space
), name
);
5857 error ("%qs specified for unnamed parameter",
5858 c_addr_space_name (address_space
));
5860 else if (decl_context
== FIELD
)
5863 error ("%qs specified for structure field %qE",
5864 c_addr_space_name (address_space
), name
);
5866 error ("%qs specified for structure field",
5867 c_addr_space_name (address_space
));
5871 /* Check the type and width of a bit-field. */
5874 check_bitfield_type_and_width (&type
, width
, name
);
5875 /* C11 makes it implementation-defined (6.7.2.1#5) whether
5876 atomic types are permitted for bit-fields; we have no code to
5877 make bit-field accesses atomic, so disallow them. */
5878 if (type_quals
& TYPE_QUAL_ATOMIC
)
5881 error ("bit-field %qE has atomic type", name
);
5883 error ("bit-field has atomic type");
5884 type_quals
&= ~TYPE_QUAL_ATOMIC
;
5888 /* Reject invalid uses of _Alignas. */
5889 if (declspecs
->alignas_p
)
5891 if (storage_class
== csc_typedef
)
5892 error_at (loc
, "alignment specified for typedef %qE", name
);
5893 else if (storage_class
== csc_register
)
5894 error_at (loc
, "alignment specified for %<register%> object %qE",
5896 else if (decl_context
== PARM
)
5899 error_at (loc
, "alignment specified for parameter %qE", name
);
5901 error_at (loc
, "alignment specified for unnamed parameter");
5906 error_at (loc
, "alignment specified for bit-field %qE", name
);
5908 error_at (loc
, "alignment specified for unnamed bit-field");
5910 else if (TREE_CODE (type
) == FUNCTION_TYPE
)
5911 error_at (loc
, "alignment specified for function %qE", name
);
5912 else if (declspecs
->align_log
!= -1)
5914 alignas_align
= 1U << declspecs
->align_log
;
5915 if (alignas_align
< min_align_of_type (type
))
5918 error_at (loc
, "%<_Alignas%> specifiers cannot reduce "
5919 "alignment of %qE", name
);
5921 error_at (loc
, "%<_Alignas%> specifiers cannot reduce "
5922 "alignment of unnamed field");
5928 /* Did array size calculations overflow or does the array cover more
5929 than half of the address-space? */
5930 if (TREE_CODE (type
) == ARRAY_TYPE
5931 && COMPLETE_TYPE_P (type
)
5932 && TREE_CODE (TYPE_SIZE_UNIT (type
)) == INTEGER_CST
5933 && ! valid_constant_size_p (TYPE_SIZE_UNIT (type
)))
5936 error_at (loc
, "size of array %qE is too large", name
);
5938 error_at (loc
, "size of unnamed array is too large");
5939 /* If we proceed with the array type as it is, we'll eventually
5940 crash in tree_to_[su]hwi(). */
5941 type
= error_mark_node
;
5944 /* If this is declaring a typedef name, return a TYPE_DECL. */
5946 if (storage_class
== csc_typedef
)
5949 if ((type_quals
& TYPE_QUAL_ATOMIC
)
5950 && TREE_CODE (type
) == FUNCTION_TYPE
)
5953 "%<_Atomic%>-qualified function type");
5954 type_quals
&= ~TYPE_QUAL_ATOMIC
;
5956 else if (pedantic
&& TREE_CODE (type
) == FUNCTION_TYPE
5958 pedwarn (loc
, OPT_Wpedantic
,
5959 "ISO C forbids qualified function types");
5961 type
= c_build_qualified_type (type
, type_quals
);
5962 decl
= build_decl (declarator
->id_loc
,
5963 TYPE_DECL
, declarator
->u
.id
, type
);
5964 if (declspecs
->explicit_signed_p
)
5965 C_TYPEDEF_EXPLICITLY_SIGNED (decl
) = 1;
5966 if (declspecs
->inline_p
)
5967 pedwarn (loc
, 0,"typedef %q+D declared %<inline%>", decl
);
5968 if (declspecs
->noreturn_p
)
5969 pedwarn (loc
, 0,"typedef %q+D declared %<_Noreturn%>", decl
);
5971 if (warn_cxx_compat
&& declarator
->u
.id
!= NULL_TREE
)
5973 struct c_binding
*b
= I_TAG_BINDING (declarator
->u
.id
);
5976 && b
->decl
!= NULL_TREE
5977 && (B_IN_CURRENT_SCOPE (b
)
5978 || (current_scope
== file_scope
&& B_IN_EXTERNAL_SCOPE (b
)))
5979 && TYPE_MAIN_VARIANT (b
->decl
) != TYPE_MAIN_VARIANT (type
))
5981 warning_at (declarator
->id_loc
, OPT_Wc___compat
,
5982 ("using %qD as both a typedef and a tag is "
5985 if (b
->locus
!= UNKNOWN_LOCATION
)
5986 inform (b
->locus
, "originally defined here");
5993 /* If this is a type name (such as, in a cast or sizeof),
5994 compute the type and return it now. */
5996 if (decl_context
== TYPENAME
)
5998 /* Note that the grammar rejects storage classes in typenames
6000 gcc_assert (storage_class
== csc_none
&& !threadp
6001 && !declspecs
->inline_p
&& !declspecs
->noreturn_p
);
6002 if ((type_quals
& TYPE_QUAL_ATOMIC
)
6003 && TREE_CODE (type
) == FUNCTION_TYPE
)
6006 "%<_Atomic%>-qualified function type");
6007 type_quals
&= ~TYPE_QUAL_ATOMIC
;
6009 else if (pedantic
&& TREE_CODE (type
) == FUNCTION_TYPE
6011 pedwarn (loc
, OPT_Wpedantic
,
6012 "ISO C forbids const or volatile function types");
6014 type
= c_build_qualified_type (type
, type_quals
);
6018 if (pedantic
&& decl_context
== FIELD
6019 && variably_modified_type_p (type
, NULL_TREE
))
6022 pedwarn (loc
, OPT_Wpedantic
, "a member of a structure or union cannot "
6023 "have a variably modified type");
6026 /* Aside from typedefs and type names (handle above),
6027 `void' at top level (not within pointer)
6028 is allowed only in public variables.
6029 We don't complain about parms either, but that is because
6030 a better error message can be made later. */
6032 if (VOID_TYPE_P (type
) && decl_context
!= PARM
6033 && !((decl_context
!= FIELD
&& TREE_CODE (type
) != FUNCTION_TYPE
)
6034 && (storage_class
== csc_extern
6035 || (current_scope
== file_scope
6036 && !(storage_class
== csc_static
6037 || storage_class
== csc_register
)))))
6039 error_at (loc
, "variable or field %qE declared void", name
);
6040 type
= integer_type_node
;
6043 /* Now create the decl, which may be a VAR_DECL, a PARM_DECL
6044 or a FUNCTION_DECL, depending on DECL_CONTEXT and TYPE. */
6049 if (decl_context
== PARM
)
6053 /* A parameter declared as an array of T is really a pointer to T.
6054 One declared as a function is really a pointer to a function. */
6056 if (TREE_CODE (type
) == ARRAY_TYPE
)
6058 /* Transfer const-ness of array into that of type pointed to. */
6059 type
= TREE_TYPE (type
);
6061 type
= c_build_qualified_type (type
, type_quals
);
6062 type
= c_build_pointer_type (type
);
6063 type_quals
= array_ptr_quals
;
6065 type
= c_build_qualified_type (type
, type_quals
);
6067 /* We don't yet implement attributes in this context. */
6068 if (array_ptr_attrs
!= NULL_TREE
)
6069 warning_at (loc
, OPT_Wattributes
,
6070 "attributes in parameter array declarator ignored");
6072 size_varies
= false;
6074 else if (TREE_CODE (type
) == FUNCTION_TYPE
)
6076 if (type_quals
& TYPE_QUAL_ATOMIC
)
6079 "%<_Atomic%>-qualified function type");
6080 type_quals
&= ~TYPE_QUAL_ATOMIC
;
6082 else if (type_quals
)
6083 pedwarn (loc
, OPT_Wpedantic
,
6084 "ISO C forbids qualified function types");
6086 type
= c_build_qualified_type (type
, type_quals
);
6087 type
= c_build_pointer_type (type
);
6088 type_quals
= TYPE_UNQUALIFIED
;
6090 else if (type_quals
)
6091 type
= c_build_qualified_type (type
, type_quals
);
6093 decl
= build_decl (declarator
->id_loc
,
6094 PARM_DECL
, declarator
->u
.id
, type
);
6096 C_DECL_VARIABLE_SIZE (decl
) = 1;
6098 /* Compute the type actually passed in the parmlist,
6099 for the case where there is no prototype.
6100 (For example, shorts and chars are passed as ints.)
6101 When there is a prototype, this is overridden later. */
6103 if (type
== error_mark_node
)
6104 promoted_type
= type
;
6106 promoted_type
= c_type_promotes_to (type
);
6108 DECL_ARG_TYPE (decl
) = promoted_type
;
6109 if (declspecs
->inline_p
)
6110 pedwarn (loc
, 0, "parameter %q+D declared %<inline%>", decl
);
6111 if (declspecs
->noreturn_p
)
6112 pedwarn (loc
, 0, "parameter %q+D declared %<_Noreturn%>", decl
);
6114 else if (decl_context
== FIELD
)
6116 /* Note that the grammar rejects storage classes in typenames
6118 gcc_assert (storage_class
== csc_none
&& !threadp
6119 && !declspecs
->inline_p
&& !declspecs
->noreturn_p
);
6121 /* Structure field. It may not be a function. */
6123 if (TREE_CODE (type
) == FUNCTION_TYPE
)
6125 error_at (loc
, "field %qE declared as a function", name
);
6126 type
= build_pointer_type (type
);
6128 else if (TREE_CODE (type
) != ERROR_MARK
6129 && !COMPLETE_OR_UNBOUND_ARRAY_TYPE_P (type
))
6132 error_at (loc
, "field %qE has incomplete type", name
);
6134 error_at (loc
, "unnamed field has incomplete type");
6135 type
= error_mark_node
;
6137 type
= c_build_qualified_type (type
, type_quals
);
6138 decl
= build_decl (declarator
->id_loc
,
6139 FIELD_DECL
, declarator
->u
.id
, type
);
6140 DECL_NONADDRESSABLE_P (decl
) = bitfield
;
6141 if (bitfield
&& !declarator
->u
.id
)
6142 TREE_NO_WARNING (decl
) = 1;
6145 C_DECL_VARIABLE_SIZE (decl
) = 1;
6147 else if (TREE_CODE (type
) == FUNCTION_TYPE
)
6149 if (storage_class
== csc_register
|| threadp
)
6151 error_at (loc
, "invalid storage class for function %qE", name
);
6153 else if (current_scope
!= file_scope
)
6155 /* Function declaration not at file scope. Storage
6156 classes other than `extern' are not allowed, C99
6157 6.7.1p5, and `extern' makes no difference. However,
6158 GCC allows 'auto', perhaps with 'inline', to support
6159 nested functions. */
6160 if (storage_class
== csc_auto
)
6161 pedwarn (loc
, OPT_Wpedantic
,
6162 "invalid storage class for function %qE", name
);
6163 else if (storage_class
== csc_static
)
6165 error_at (loc
, "invalid storage class for function %qE", name
);
6167 storage_class
= declspecs
->storage_class
= csc_none
;
6173 decl
= build_decl (declarator
->id_loc
,
6174 FUNCTION_DECL
, declarator
->u
.id
, type
);
6175 decl
= build_decl_attribute_variant (decl
, decl_attr
);
6177 if (type_quals
& TYPE_QUAL_ATOMIC
)
6180 "%<_Atomic%>-qualified function type");
6181 type_quals
&= ~TYPE_QUAL_ATOMIC
;
6183 else if (pedantic
&& type_quals
&& !DECL_IN_SYSTEM_HEADER (decl
))
6184 pedwarn (loc
, OPT_Wpedantic
,
6185 "ISO C forbids qualified function types");
6187 /* Every function declaration is an external reference
6188 (DECL_EXTERNAL) except for those which are not at file
6189 scope and are explicitly declared "auto". This is
6190 forbidden by standard C (C99 6.7.1p5) and is interpreted by
6191 GCC to signify a forward declaration of a nested function. */
6192 if (storage_class
== csc_auto
&& current_scope
!= file_scope
)
6193 DECL_EXTERNAL (decl
) = 0;
6194 /* In C99, a function which is declared 'inline' with 'extern'
6195 is not an external reference (which is confusing). It
6196 means that the later definition of the function must be output
6197 in this file, C99 6.7.4p6. In GNU C89, a function declared
6198 'extern inline' is an external reference. */
6199 else if (declspecs
->inline_p
&& storage_class
!= csc_static
)
6200 DECL_EXTERNAL (decl
) = ((storage_class
== csc_extern
)
6201 == flag_gnu89_inline
);
6203 DECL_EXTERNAL (decl
) = !initialized
;
6205 /* Record absence of global scope for `static' or `auto'. */
6207 = !(storage_class
== csc_static
|| storage_class
== csc_auto
);
6209 /* For a function definition, record the argument information
6210 block where store_parm_decls will look for it. */
6212 current_function_arg_info
= arg_info
;
6214 if (declspecs
->default_int_p
)
6215 C_FUNCTION_IMPLICIT_INT (decl
) = 1;
6217 /* Record presence of `inline' and `_Noreturn', if it is
6219 if (flag_hosted
&& MAIN_NAME_P (declarator
->u
.id
))
6221 if (declspecs
->inline_p
)
6222 pedwarn (loc
, 0, "cannot inline function %<main%>");
6223 if (declspecs
->noreturn_p
)
6224 pedwarn (loc
, 0, "%<main%> declared %<_Noreturn%>");
6228 if (declspecs
->inline_p
)
6229 /* Record that the function is declared `inline'. */
6230 DECL_DECLARED_INLINE_P (decl
) = 1;
6231 if (declspecs
->noreturn_p
)
6236 pedwarn (loc
, OPT_Wpedantic
,
6237 "ISO C99 does not support %<_Noreturn%>");
6239 pedwarn (loc
, OPT_Wpedantic
,
6240 "ISO C90 does not support %<_Noreturn%>");
6242 TREE_THIS_VOLATILE (decl
) = 1;
6248 /* It's a variable. */
6249 /* An uninitialized decl with `extern' is a reference. */
6250 int extern_ref
= !initialized
&& storage_class
== csc_extern
;
6252 type
= c_build_qualified_type (type
, type_quals
);
6254 /* C99 6.2.2p7: It is invalid (compile-time undefined
6255 behavior) to create an 'extern' declaration for a
6256 variable if there is a global declaration that is
6257 'static' and the global declaration is not visible.
6258 (If the static declaration _is_ currently visible,
6259 the 'extern' declaration is taken to refer to that decl.) */
6260 if (extern_ref
&& current_scope
!= file_scope
)
6262 tree global_decl
= identifier_global_value (declarator
->u
.id
);
6263 tree visible_decl
= lookup_name (declarator
->u
.id
);
6266 && global_decl
!= visible_decl
6267 && TREE_CODE (global_decl
) == VAR_DECL
6268 && !TREE_PUBLIC (global_decl
))
6269 error_at (loc
, "variable previously declared %<static%> "
6270 "redeclared %<extern%>");
6273 decl
= build_decl (declarator
->id_loc
,
6274 VAR_DECL
, declarator
->u
.id
, type
);
6276 C_DECL_VARIABLE_SIZE (decl
) = 1;
6278 if (declspecs
->inline_p
)
6279 pedwarn (loc
, 0, "variable %q+D declared %<inline%>", decl
);
6280 if (declspecs
->noreturn_p
)
6281 pedwarn (loc
, 0, "variable %q+D declared %<_Noreturn%>", decl
);
6283 /* At file scope, an initialized extern declaration may follow
6284 a static declaration. In that case, DECL_EXTERNAL will be
6285 reset later in start_decl. */
6286 DECL_EXTERNAL (decl
) = (storage_class
== csc_extern
);
6288 /* At file scope, the presence of a `static' or `register' storage
6289 class specifier, or the absence of all storage class specifiers
6290 makes this declaration a definition (perhaps tentative). Also,
6291 the absence of `static' makes it public. */
6292 if (current_scope
== file_scope
)
6294 TREE_PUBLIC (decl
) = storage_class
!= csc_static
;
6295 TREE_STATIC (decl
) = !extern_ref
;
6297 /* Not at file scope, only `static' makes a static definition. */
6300 TREE_STATIC (decl
) = (storage_class
== csc_static
);
6301 TREE_PUBLIC (decl
) = extern_ref
;
6305 DECL_TLS_MODEL (decl
) = decl_default_tls_model (decl
);
6308 if ((storage_class
== csc_extern
6309 || (storage_class
== csc_none
6310 && TREE_CODE (type
) == FUNCTION_TYPE
6312 && variably_modified_type_p (type
, NULL_TREE
))
6315 if (TREE_CODE (type
) == FUNCTION_TYPE
)
6316 error_at (loc
, "non-nested function with variably modified type");
6318 error_at (loc
, "object with variably modified type must have "
6322 /* Record `register' declaration for warnings on &
6323 and in case doing stupid register allocation. */
6325 if (storage_class
== csc_register
)
6327 C_DECL_REGISTER (decl
) = 1;
6328 DECL_REGISTER (decl
) = 1;
6331 /* Record constancy and volatility. */
6332 c_apply_type_quals_to_decl (type_quals
, decl
);
6334 /* Apply _Alignas specifiers. */
6337 DECL_ALIGN (decl
) = alignas_align
* BITS_PER_UNIT
;
6338 DECL_USER_ALIGN (decl
) = 1;
6341 /* If a type has volatile components, it should be stored in memory.
6342 Otherwise, the fact that those components are volatile
6343 will be ignored, and would even crash the compiler.
6344 Of course, this only makes sense on VAR,PARM, and RESULT decl's. */
6345 if (C_TYPE_FIELDS_VOLATILE (TREE_TYPE (decl
))
6346 && (TREE_CODE (decl
) == VAR_DECL
|| TREE_CODE (decl
) == PARM_DECL
6347 || TREE_CODE (decl
) == RESULT_DECL
))
6349 /* It is not an error for a structure with volatile fields to
6350 be declared register, but reset DECL_REGISTER since it
6351 cannot actually go in a register. */
6352 int was_reg
= C_DECL_REGISTER (decl
);
6353 C_DECL_REGISTER (decl
) = 0;
6354 DECL_REGISTER (decl
) = 0;
6355 c_mark_addressable (decl
);
6356 C_DECL_REGISTER (decl
) = was_reg
;
6359 /* This is the earliest point at which we might know the assembler
6360 name of a variable. Thus, if it's known before this, die horribly. */
6361 gcc_assert (!DECL_ASSEMBLER_NAME_SET_P (decl
));
6364 && TREE_CODE (decl
) == VAR_DECL
6365 && TREE_PUBLIC (decl
)
6366 && TREE_STATIC (decl
)
6367 && (TREE_CODE (TREE_TYPE (decl
)) == RECORD_TYPE
6368 || TREE_CODE (TREE_TYPE (decl
)) == UNION_TYPE
6369 || TREE_CODE (TREE_TYPE (decl
)) == ENUMERAL_TYPE
)
6370 && TYPE_NAME (TREE_TYPE (decl
)) == NULL_TREE
)
6371 warning_at (DECL_SOURCE_LOCATION (decl
), OPT_Wc___compat
,
6372 ("non-local variable %qD with anonymous type is "
6373 "questionable in C++"),
6380 /* Decode the parameter-list info for a function type or function definition.
6381 The argument is the value returned by `get_parm_info' (or made in c-parse.c
6382 if there is an identifier list instead of a parameter decl list).
6383 These two functions are separate because when a function returns
6384 or receives functions then each is called multiple times but the order
6385 of calls is different. The last call to `grokparms' is always the one
6386 that contains the formal parameter names of a function definition.
6388 Return a list of arg types to use in the FUNCTION_TYPE for this function.
6390 FUNCDEF_FLAG is true for a function definition, false for
6391 a mere declaration. A nonempty identifier-list gets an error message
6392 when FUNCDEF_FLAG is false. */
6395 grokparms (struct c_arg_info
*arg_info
, bool funcdef_flag
)
6397 tree arg_types
= arg_info
->types
;
6399 if (funcdef_flag
&& arg_info
->had_vla_unspec
)
6401 /* A function definition isn't function prototype scope C99 6.2.1p4. */
6403 error ("%<[*]%> not allowed in other than function prototype scope");
6406 if (arg_types
== 0 && !funcdef_flag
6407 && !in_system_header_at (input_location
))
6408 warning (OPT_Wstrict_prototypes
,
6409 "function declaration isn%'t a prototype");
6411 if (arg_types
== error_mark_node
)
6412 return 0; /* don't set TYPE_ARG_TYPES in this case */
6414 else if (arg_types
&& TREE_CODE (TREE_VALUE (arg_types
)) == IDENTIFIER_NODE
)
6418 pedwarn (input_location
, 0, "parameter names (without types) in function declaration");
6419 arg_info
->parms
= NULL_TREE
;
6422 arg_info
->parms
= arg_info
->types
;
6424 arg_info
->types
= 0;
6429 tree parm
, type
, typelt
;
6430 unsigned int parmno
;
6433 /* If there is a parameter of incomplete type in a definition,
6434 this is an error. In a declaration this is valid, and a
6435 struct or union type may be completed later, before any calls
6436 or definition of the function. In the case where the tag was
6437 first declared within the parameter list, a warning has
6438 already been given. If a parameter has void type, then
6439 however the function cannot be defined or called, so
6442 for (parm
= arg_info
->parms
, typelt
= arg_types
, parmno
= 1;
6444 parm
= DECL_CHAIN (parm
), typelt
= TREE_CHAIN (typelt
), parmno
++)
6446 type
= TREE_VALUE (typelt
);
6447 if (type
== error_mark_node
)
6450 if (!COMPLETE_TYPE_P (type
))
6454 if (DECL_NAME (parm
))
6455 error_at (input_location
,
6456 "parameter %u (%q+D) has incomplete type",
6459 error_at (DECL_SOURCE_LOCATION (parm
),
6460 "parameter %u has incomplete type",
6463 TREE_VALUE (typelt
) = error_mark_node
;
6464 TREE_TYPE (parm
) = error_mark_node
;
6465 arg_types
= NULL_TREE
;
6467 else if (VOID_TYPE_P (type
))
6469 if (DECL_NAME (parm
))
6470 warning_at (input_location
, 0,
6471 "parameter %u (%q+D) has void type",
6474 warning_at (DECL_SOURCE_LOCATION (parm
), 0,
6475 "parameter %u has void type",
6480 errmsg
= targetm
.invalid_parameter_type (type
);
6484 TREE_VALUE (typelt
) = error_mark_node
;
6485 TREE_TYPE (parm
) = error_mark_node
;
6486 arg_types
= NULL_TREE
;
6489 if (DECL_NAME (parm
) && TREE_USED (parm
))
6490 warn_if_shadowing (parm
);
6496 /* Allocate and initialize a c_arg_info structure from the parser's
6500 build_arg_info (void)
6502 struct c_arg_info
*ret
= XOBNEW (&parser_obstack
, struct c_arg_info
);
6503 ret
->parms
= NULL_TREE
;
6505 ret
->types
= NULL_TREE
;
6506 ret
->others
= NULL_TREE
;
6507 ret
->pending_sizes
= NULL
;
6508 ret
->had_vla_unspec
= 0;
6512 /* Take apart the current scope and return a c_arg_info structure with
6513 info on a parameter list just parsed.
6515 This structure is later fed to 'grokparms' and 'store_parm_decls'.
6517 ELLIPSIS being true means the argument list ended in '...' so don't
6518 append a sentinel (void_list_node) to the end of the type-list.
6520 EXPR is NULL or an expression that needs to be evaluated for the
6521 side effects of array size expressions in the parameters. */
6524 get_parm_info (bool ellipsis
, tree expr
)
6526 struct c_binding
*b
= current_scope
->bindings
;
6527 struct c_arg_info
*arg_info
= build_arg_info ();
6530 vec
<c_arg_tag
, va_gc
> *tags
= NULL
;
6534 static bool explained_incomplete_types
= false;
6535 bool gave_void_only_once_err
= false;
6537 arg_info
->had_vla_unspec
= current_scope
->had_vla_unspec
;
6539 /* The bindings in this scope must not get put into a block.
6540 We will take care of deleting the binding nodes. */
6541 current_scope
->bindings
= 0;
6543 /* This function is only called if there was *something* on the
6547 /* A parameter list consisting solely of 'void' indicates that the
6548 function takes no arguments. But if the 'void' is qualified
6549 (by 'const' or 'volatile'), or has a storage class specifier
6550 ('register'), then the behavior is undefined; issue an error.
6551 Typedefs for 'void' are OK (see DR#157). */
6552 if (b
->prev
== 0 /* one binding */
6553 && TREE_CODE (b
->decl
) == PARM_DECL
/* which is a parameter */
6554 && !DECL_NAME (b
->decl
) /* anonymous */
6555 && VOID_TYPE_P (TREE_TYPE (b
->decl
))) /* of void type */
6557 if (TYPE_QUALS (TREE_TYPE (b
->decl
)) != TYPE_UNQUALIFIED
6558 || C_DECL_REGISTER (b
->decl
))
6559 error ("%<void%> as only parameter may not be qualified");
6561 /* There cannot be an ellipsis. */
6563 error ("%<void%> must be the only parameter");
6565 arg_info
->types
= void_list_node
;
6570 types
= void_list_node
;
6572 /* Break up the bindings list into parms, tags, types, and others;
6573 apply sanity checks; purge the name-to-decl bindings. */
6576 tree decl
= b
->decl
;
6577 tree type
= TREE_TYPE (decl
);
6579 const char *keyword
;
6581 switch (TREE_CODE (decl
))
6586 gcc_assert (I_SYMBOL_BINDING (b
->id
) == b
);
6587 I_SYMBOL_BINDING (b
->id
) = b
->shadowed
;
6590 /* Check for forward decls that never got their actual decl. */
6591 if (TREE_ASM_WRITTEN (decl
))
6592 error ("parameter %q+D has just a forward declaration", decl
);
6593 /* Check for (..., void, ...) and issue an error. */
6594 else if (VOID_TYPE_P (type
) && !DECL_NAME (decl
))
6596 if (!gave_void_only_once_err
)
6598 error ("%<void%> must be the only parameter");
6599 gave_void_only_once_err
= true;
6604 /* Valid parameter, add it to the list. */
6605 DECL_CHAIN (decl
) = parms
;
6608 /* Since there is a prototype, args are passed in their
6609 declared types. The back end may override this later. */
6610 DECL_ARG_TYPE (decl
) = type
;
6611 types
= tree_cons (0, type
, types
);
6615 case ENUMERAL_TYPE
: keyword
= "enum"; goto tag
;
6616 case UNION_TYPE
: keyword
= "union"; goto tag
;
6617 case RECORD_TYPE
: keyword
= "struct"; goto tag
;
6619 /* Types may not have tag-names, in which case the type
6620 appears in the bindings list with b->id NULL. */
6623 gcc_assert (I_TAG_BINDING (b
->id
) == b
);
6624 I_TAG_BINDING (b
->id
) = b
->shadowed
;
6627 /* Warn about any struct, union or enum tags defined in a
6628 parameter list. The scope of such types is limited to
6629 the parameter list, which is rarely if ever desirable
6630 (it's impossible to call such a function with type-
6631 correct arguments). An anonymous union parm type is
6632 meaningful as a GNU extension, so don't warn for that. */
6633 if (TREE_CODE (decl
) != UNION_TYPE
|| b
->id
!= 0)
6636 /* The %s will be one of 'struct', 'union', or 'enum'. */
6637 warning (0, "%<%s %E%> declared inside parameter list",
6640 /* The %s will be one of 'struct', 'union', or 'enum'. */
6641 warning (0, "anonymous %s declared inside parameter list",
6644 if (!explained_incomplete_types
)
6646 warning (0, "its scope is only this definition or declaration,"
6647 " which is probably not what you want");
6648 explained_incomplete_types
= true;
6654 vec_safe_push (tags
, tag
);
6660 /* CONST_DECLs appear here when we have an embedded enum,
6661 and TYPE_DECLs appear here when we have an embedded struct
6662 or union. No warnings for this - we already warned about the
6663 type itself. FUNCTION_DECLs appear when there is an implicit
6664 function declaration in the parameter list. */
6666 /* When we reinsert this decl in the function body, we need
6667 to reconstruct whether it was marked as nested. */
6668 gcc_assert (TREE_CODE (decl
) == FUNCTION_DECL
6671 DECL_CHAIN (decl
) = others
;
6676 /* error_mark_node appears here when we have an undeclared
6677 variable. Just throw it away. */
6680 gcc_assert (I_SYMBOL_BINDING (b
->id
) == b
);
6681 I_SYMBOL_BINDING (b
->id
) = b
->shadowed
;
6685 /* Other things that might be encountered. */
6692 b
= free_binding_and_advance (b
);
6695 arg_info
->parms
= parms
;
6696 arg_info
->tags
= tags
;
6697 arg_info
->types
= types
;
6698 arg_info
->others
= others
;
6699 arg_info
->pending_sizes
= expr
;
6703 /* Get the struct, enum or union (CODE says which) with tag NAME.
6704 Define the tag as a forward-reference with location LOC if it is
6705 not defined. Return a c_typespec structure for the type
6709 parser_xref_tag (location_t loc
, enum tree_code code
, tree name
)
6711 struct c_typespec ret
;
6715 ret
.expr
= NULL_TREE
;
6716 ret
.expr_const_operands
= true;
6718 /* If a cross reference is requested, look up the type
6719 already defined for this tag and return it. */
6721 ref
= lookup_tag (code
, name
, 0, &refloc
);
6722 /* If this is the right type of tag, return what we found.
6723 (This reference will be shadowed by shadow_tag later if appropriate.)
6724 If this is the wrong type of tag, do not return it. If it was the
6725 wrong type in the same scope, we will have had an error
6726 message already; if in a different scope and declaring
6727 a name, pending_xref_error will give an error message; but if in a
6728 different scope and not declaring a name, this tag should
6729 shadow the previous declaration of a different type of tag, and
6730 this would not work properly if we return the reference found.
6731 (For example, with "struct foo" in an outer scope, "union foo;"
6732 must shadow that tag with a new one of union type.) */
6733 ret
.kind
= (ref
? ctsk_tagref
: ctsk_tagfirstref
);
6734 if (ref
&& TREE_CODE (ref
) == code
)
6736 if (C_TYPE_DEFINED_IN_STRUCT (ref
)
6737 && loc
!= UNKNOWN_LOCATION
6743 warning_at (loc
, OPT_Wc___compat
,
6744 ("enum type defined in struct or union "
6745 "is not visible in C++"));
6746 inform (refloc
, "enum type defined here");
6749 warning_at (loc
, OPT_Wc___compat
,
6750 ("struct defined in struct or union "
6751 "is not visible in C++"));
6752 inform (refloc
, "struct defined here");
6755 warning_at (loc
, OPT_Wc___compat
,
6756 ("union defined in struct or union "
6757 "is not visible in C++"));
6758 inform (refloc
, "union defined here");
6769 /* If no such tag is yet defined, create a forward-reference node
6770 and record it as the "definition".
6771 When a real declaration of this type is found,
6772 the forward-reference will be altered into a real type. */
6774 ref
= make_node (code
);
6775 if (code
== ENUMERAL_TYPE
)
6777 /* Give the type a default layout like unsigned int
6778 to avoid crashing if it does not get defined. */
6779 SET_TYPE_MODE (ref
, TYPE_MODE (unsigned_type_node
));
6780 TYPE_ALIGN (ref
) = TYPE_ALIGN (unsigned_type_node
);
6781 TYPE_USER_ALIGN (ref
) = 0;
6782 TYPE_UNSIGNED (ref
) = 1;
6783 TYPE_PRECISION (ref
) = TYPE_PRECISION (unsigned_type_node
);
6784 TYPE_MIN_VALUE (ref
) = TYPE_MIN_VALUE (unsigned_type_node
);
6785 TYPE_MAX_VALUE (ref
) = TYPE_MAX_VALUE (unsigned_type_node
);
6788 pushtag (loc
, name
, ref
);
6794 /* Get the struct, enum or union (CODE says which) with tag NAME.
6795 Define the tag as a forward-reference if it is not defined.
6796 Return a tree for the type. */
6799 xref_tag (enum tree_code code
, tree name
)
6801 return parser_xref_tag (input_location
, code
, name
).spec
;
6804 /* Make sure that the tag NAME is defined *in the current scope*
6805 at least as a forward reference.
6806 LOC is the location of the struct's definition.
6807 CODE says which kind of tag NAME ought to be.
6809 This stores the current value of the file static STRUCT_PARSE_INFO
6810 in *ENCLOSING_STRUCT_PARSE_INFO, and points STRUCT_PARSE_INFO at a
6811 new c_struct_parse_info structure. The old value of
6812 STRUCT_PARSE_INFO is restored in finish_struct. */
6815 start_struct (location_t loc
, enum tree_code code
, tree name
,
6816 struct c_struct_parse_info
**enclosing_struct_parse_info
)
6818 /* If there is already a tag defined at this scope
6819 (as a forward reference), just return it. */
6821 tree ref
= NULL_TREE
;
6822 location_t refloc
= UNKNOWN_LOCATION
;
6824 if (name
!= NULL_TREE
)
6825 ref
= lookup_tag (code
, name
, 1, &refloc
);
6826 if (ref
&& TREE_CODE (ref
) == code
)
6828 if (TYPE_SIZE (ref
))
6830 if (code
== UNION_TYPE
)
6831 error_at (loc
, "redefinition of %<union %E%>", name
);
6833 error_at (loc
, "redefinition of %<struct %E%>", name
);
6834 if (refloc
!= UNKNOWN_LOCATION
)
6835 inform (refloc
, "originally defined here");
6836 /* Don't create structures using a name already in use. */
6839 else if (C_TYPE_BEING_DEFINED (ref
))
6841 if (code
== UNION_TYPE
)
6842 error_at (loc
, "nested redefinition of %<union %E%>", name
);
6844 error_at (loc
, "nested redefinition of %<struct %E%>", name
);
6845 /* Don't bother to report "originally defined here" for a
6846 nested redefinition; the original definition should be
6848 /* Don't create structures that contain themselves. */
6853 /* Otherwise create a forward-reference just so the tag is in scope. */
6855 if (ref
== NULL_TREE
|| TREE_CODE (ref
) != code
)
6857 ref
= make_node (code
);
6858 pushtag (loc
, name
, ref
);
6861 C_TYPE_BEING_DEFINED (ref
) = 1;
6862 TYPE_PACKED (ref
) = flag_pack_struct
;
6864 *enclosing_struct_parse_info
= struct_parse_info
;
6865 struct_parse_info
= XNEW (struct c_struct_parse_info
);
6866 struct_parse_info
->struct_types
.create (0);
6867 struct_parse_info
->fields
.create (0);
6868 struct_parse_info
->typedefs_seen
.create (0);
6870 /* FIXME: This will issue a warning for a use of a type defined
6871 within a statement expr used within sizeof, et. al. This is not
6872 terribly serious as C++ doesn't permit statement exprs within
6874 if (warn_cxx_compat
&& (in_sizeof
|| in_typeof
|| in_alignof
))
6875 warning_at (loc
, OPT_Wc___compat
,
6876 "defining type in %qs expression is invalid in C++",
6879 : (in_typeof
? "typeof" : "alignof")));
6884 /* Process the specs, declarator and width (NULL if omitted)
6885 of a structure component, returning a FIELD_DECL node.
6886 WIDTH is non-NULL for bit-fields only, and is an INTEGER_CST node.
6887 DECL_ATTRS is as for grokdeclarator.
6889 LOC is the location of the structure component.
6891 This is done during the parsing of the struct declaration.
6892 The FIELD_DECL nodes are chained together and the lot of them
6893 are ultimately passed to `build_struct' to make the RECORD_TYPE node. */
6896 grokfield (location_t loc
,
6897 struct c_declarator
*declarator
, struct c_declspecs
*declspecs
,
6898 tree width
, tree
*decl_attrs
)
6902 if (declarator
->kind
== cdk_id
&& declarator
->u
.id
== NULL_TREE
6903 && width
== NULL_TREE
)
6905 /* This is an unnamed decl.
6907 If we have something of the form "union { list } ;" then this
6908 is the anonymous union extension. Similarly for struct.
6910 If this is something of the form "struct foo;", then
6911 If MS or Plan 9 extensions are enabled, this is handled as
6912 an anonymous struct.
6913 Otherwise this is a forward declaration of a structure tag.
6915 If this is something of the form "foo;" and foo is a TYPE_DECL, then
6916 If foo names a structure or union without a tag, then this
6917 is an anonymous struct (this is permitted by C11).
6918 If MS or Plan 9 extensions are enabled and foo names a
6919 structure, then again this is an anonymous struct.
6920 Otherwise this is an error.
6922 Oh what a horrid tangled web we weave. I wonder if MS consciously
6923 took this from Plan 9 or if it was an accident of implementation
6924 that took root before someone noticed the bug... */
6926 tree type
= declspecs
->type
;
6927 bool type_ok
= (TREE_CODE (type
) == RECORD_TYPE
6928 || TREE_CODE (type
) == UNION_TYPE
);
6932 && (flag_ms_extensions
6933 || flag_plan9_extensions
6934 || !declspecs
->typedef_p
))
6936 if (flag_ms_extensions
|| flag_plan9_extensions
)
6938 else if (TYPE_NAME (type
) == NULL
)
6945 pedwarn (loc
, 0, "declaration does not declare anything");
6951 pedwarn (loc
, OPT_Wpedantic
,
6952 "ISO C99 doesn%'t support unnamed structs/unions");
6954 pedwarn (loc
, OPT_Wpedantic
,
6955 "ISO C90 doesn%'t support unnamed structs/unions");
6959 value
= grokdeclarator (declarator
, declspecs
, FIELD
, false,
6960 width
? &width
: NULL
, decl_attrs
, NULL
, NULL
,
6963 finish_decl (value
, loc
, NULL_TREE
, NULL_TREE
, NULL_TREE
);
6964 DECL_INITIAL (value
) = width
;
6966 if (warn_cxx_compat
&& DECL_NAME (value
) != NULL_TREE
)
6968 /* If we currently have a binding for this field, set the
6969 in_struct field in the binding, so that we warn about lookups
6971 struct c_binding
*b
= I_SYMBOL_BINDING (DECL_NAME (value
));
6974 /* If the in_struct field is not yet set, push it on a list
6975 to be cleared when this struct is finished. */
6978 struct_parse_info
->fields
.safe_push (b
);
6987 /* Subroutine of detect_field_duplicates: return whether X and Y,
6988 which are both fields in the same struct, have duplicate field
6992 is_duplicate_field (tree x
, tree y
)
6994 if (DECL_NAME (x
) != NULL_TREE
&& DECL_NAME (x
) == DECL_NAME (y
))
6997 /* When using -fplan9-extensions, an anonymous field whose name is a
6998 typedef can duplicate a field name. */
6999 if (flag_plan9_extensions
7000 && (DECL_NAME (x
) == NULL_TREE
|| DECL_NAME (y
) == NULL_TREE
))
7002 tree xt
, xn
, yt
, yn
;
7005 if (DECL_NAME (x
) != NULL_TREE
)
7007 else if ((TREE_CODE (xt
) == RECORD_TYPE
|| TREE_CODE (xt
) == UNION_TYPE
)
7008 && TYPE_NAME (xt
) != NULL_TREE
7009 && TREE_CODE (TYPE_NAME (xt
)) == TYPE_DECL
)
7010 xn
= DECL_NAME (TYPE_NAME (xt
));
7015 if (DECL_NAME (y
) != NULL_TREE
)
7017 else if ((TREE_CODE (yt
) == RECORD_TYPE
|| TREE_CODE (yt
) == UNION_TYPE
)
7018 && TYPE_NAME (yt
) != NULL_TREE
7019 && TREE_CODE (TYPE_NAME (yt
)) == TYPE_DECL
)
7020 yn
= DECL_NAME (TYPE_NAME (yt
));
7024 if (xn
!= NULL_TREE
&& xn
== yn
)
7031 /* Subroutine of detect_field_duplicates: add the fields of FIELDLIST
7032 to HTAB, giving errors for any duplicates. */
7035 detect_field_duplicates_hash (tree fieldlist
,
7036 hash_table
<pointer_hash
<tree_node
> > htab
)
7041 for (x
= fieldlist
; x
; x
= DECL_CHAIN (x
))
7042 if ((y
= DECL_NAME (x
)) != 0)
7044 slot
= htab
.find_slot (y
, INSERT
);
7047 error ("duplicate member %q+D", x
);
7048 DECL_NAME (x
) = NULL_TREE
;
7052 else if (TREE_CODE (TREE_TYPE (x
)) == RECORD_TYPE
7053 || TREE_CODE (TREE_TYPE (x
)) == UNION_TYPE
)
7055 detect_field_duplicates_hash (TYPE_FIELDS (TREE_TYPE (x
)), htab
);
7057 /* When using -fplan9-extensions, an anonymous field whose
7058 name is a typedef can duplicate a field name. */
7059 if (flag_plan9_extensions
7060 && TYPE_NAME (TREE_TYPE (x
)) != NULL_TREE
7061 && TREE_CODE (TYPE_NAME (TREE_TYPE (x
))) == TYPE_DECL
)
7063 tree xn
= DECL_NAME (TYPE_NAME (TREE_TYPE (x
)));
7064 slot
= htab
.find_slot (xn
, INSERT
);
7066 error ("duplicate member %q+D", TYPE_NAME (TREE_TYPE (x
)));
7072 /* Generate an error for any duplicate field names in FIELDLIST. Munge
7073 the list such that this does not present a problem later. */
7076 detect_field_duplicates (tree fieldlist
)
7081 /* If the struct is the list of instance variables of an Objective-C
7082 class, then we need to check all the instance variables of
7083 superclasses when checking for duplicates (since you can't have
7084 an instance variable in a subclass with the same name as an
7085 instance variable in a superclass). We pass on this job to the
7086 Objective-C compiler. objc_detect_field_duplicates() will return
7087 false if we are not checking the list of instance variables and
7088 the C frontend should proceed with the standard field duplicate
7089 checks. If we are checking the list of instance variables, the
7090 ObjC frontend will do the check, emit the errors if needed, and
7091 then return true. */
7092 if (c_dialect_objc ())
7093 if (objc_detect_field_duplicates (false))
7096 /* First, see if there are more than "a few" fields.
7097 This is trivially true if there are zero or one fields. */
7098 if (!fieldlist
|| !DECL_CHAIN (fieldlist
))
7103 if (DECL_NAME (x
) == NULL_TREE
7104 && (TREE_CODE (TREE_TYPE (x
)) == RECORD_TYPE
7105 || TREE_CODE (TREE_TYPE (x
)) == UNION_TYPE
))
7108 } while (timeout
> 0 && x
);
7110 /* If there were "few" fields and no anonymous structures or unions,
7111 avoid the overhead of allocating a hash table. Instead just do
7112 the nested traversal thing. */
7115 for (x
= DECL_CHAIN (fieldlist
); x
; x
= DECL_CHAIN (x
))
7116 /* When using -fplan9-extensions, we can have duplicates
7117 between typedef names and fields. */
7119 || (flag_plan9_extensions
7120 && DECL_NAME (x
) == NULL_TREE
7121 && (TREE_CODE (TREE_TYPE (x
)) == RECORD_TYPE
7122 || TREE_CODE (TREE_TYPE (x
)) == UNION_TYPE
)
7123 && TYPE_NAME (TREE_TYPE (x
)) != NULL_TREE
7124 && TREE_CODE (TYPE_NAME (TREE_TYPE (x
))) == TYPE_DECL
))
7126 for (y
= fieldlist
; y
!= x
; y
= TREE_CHAIN (y
))
7127 if (is_duplicate_field (y
, x
))
7129 error ("duplicate member %q+D", x
);
7130 DECL_NAME (x
) = NULL_TREE
;
7136 hash_table
<pointer_hash
<tree_node
> > htab
;
7139 detect_field_duplicates_hash (fieldlist
, htab
);
7144 /* Finish up struct info used by -Wc++-compat. */
7147 warn_cxx_compat_finish_struct (tree fieldlist
)
7151 struct c_binding
*b
;
7153 /* Set the C_TYPE_DEFINED_IN_STRUCT flag for each type defined in
7154 the current struct. We do this now at the end of the struct
7155 because the flag is used to issue visibility warnings, and we
7156 only want to issue those warnings if the type is referenced
7157 outside of the struct declaration. */
7158 FOR_EACH_VEC_ELT (struct_parse_info
->struct_types
, ix
, x
)
7159 C_TYPE_DEFINED_IN_STRUCT (x
) = 1;
7161 /* The TYPEDEFS_SEEN field of STRUCT_PARSE_INFO is a list of
7162 typedefs used when declaring fields in this struct. If the name
7163 of any of the fields is also a typedef name then the struct would
7164 not parse in C++, because the C++ lookup rules say that the
7165 typedef name would be looked up in the context of the struct, and
7166 would thus be the field rather than the typedef. */
7167 if (!struct_parse_info
->typedefs_seen
.is_empty ()
7168 && fieldlist
!= NULL_TREE
)
7170 /* Use a pointer_set using the name of the typedef. We can use
7171 a pointer_set because identifiers are interned. */
7172 struct pointer_set_t
*tset
= pointer_set_create ();
7174 FOR_EACH_VEC_ELT (struct_parse_info
->typedefs_seen
, ix
, x
)
7175 pointer_set_insert (tset
, DECL_NAME (x
));
7177 for (x
= fieldlist
; x
!= NULL_TREE
; x
= DECL_CHAIN (x
))
7179 if (DECL_NAME (x
) != NULL_TREE
7180 && pointer_set_contains (tset
, DECL_NAME (x
)))
7182 warning_at (DECL_SOURCE_LOCATION (x
), OPT_Wc___compat
,
7183 ("using %qD as both field and typedef name is "
7186 /* FIXME: It would be nice to report the location where
7187 the typedef name is used. */
7191 pointer_set_destroy (tset
);
7194 /* For each field which has a binding and which was not defined in
7195 an enclosing struct, clear the in_struct field. */
7196 FOR_EACH_VEC_ELT (struct_parse_info
->fields
, ix
, b
)
7200 /* Fill in the fields of a RECORD_TYPE or UNION_TYPE node, T.
7201 LOC is the location of the RECORD_TYPE or UNION_TYPE's definition.
7202 FIELDLIST is a chain of FIELD_DECL nodes for the fields.
7203 ATTRIBUTES are attributes to be applied to the structure.
7205 ENCLOSING_STRUCT_PARSE_INFO is the value of STRUCT_PARSE_INFO when
7206 the struct was started. */
7209 finish_struct (location_t loc
, tree t
, tree fieldlist
, tree attributes
,
7210 struct c_struct_parse_info
*enclosing_struct_parse_info
)
7213 bool toplevel
= file_scope
== current_scope
;
7214 int saw_named_field
;
7216 /* If this type was previously laid out as a forward reference,
7217 make sure we lay it out again. */
7221 decl_attributes (&t
, attributes
, (int) ATTR_FLAG_TYPE_IN_PLACE
);
7225 for (x
= fieldlist
; x
; x
= DECL_CHAIN (x
))
7227 if (DECL_NAME (x
) != 0)
7230 && (TREE_CODE (TREE_TYPE (x
)) == RECORD_TYPE
7231 || TREE_CODE (TREE_TYPE (x
)) == UNION_TYPE
))
7237 if (TREE_CODE (t
) == UNION_TYPE
)
7240 pedwarn (loc
, OPT_Wpedantic
, "union has no named members");
7242 pedwarn (loc
, OPT_Wpedantic
, "union has no members");
7247 pedwarn (loc
, OPT_Wpedantic
, "struct has no named members");
7249 pedwarn (loc
, OPT_Wpedantic
, "struct has no members");
7254 /* Install struct as DECL_CONTEXT of each field decl.
7255 Also process specified field sizes, found in the DECL_INITIAL,
7256 storing 0 there after the type has been changed to precision equal
7257 to its width, rather than the precision of the specified standard
7258 type. (Correct layout requires the original type to have been preserved
7261 saw_named_field
= 0;
7262 for (x
= fieldlist
; x
; x
= DECL_CHAIN (x
))
7264 if (TREE_TYPE (x
) == error_mark_node
)
7267 DECL_CONTEXT (x
) = t
;
7269 /* If any field is const, the structure type is pseudo-const. */
7270 if (TREE_READONLY (x
))
7271 C_TYPE_FIELDS_READONLY (t
) = 1;
7274 /* A field that is pseudo-const makes the structure likewise. */
7275 tree t1
= strip_array_types (TREE_TYPE (x
));
7276 if ((TREE_CODE (t1
) == RECORD_TYPE
|| TREE_CODE (t1
) == UNION_TYPE
)
7277 && C_TYPE_FIELDS_READONLY (t1
))
7278 C_TYPE_FIELDS_READONLY (t
) = 1;
7281 /* Any field that is volatile means variables of this type must be
7282 treated in some ways as volatile. */
7283 if (TREE_THIS_VOLATILE (x
))
7284 C_TYPE_FIELDS_VOLATILE (t
) = 1;
7286 /* Any field of nominal variable size implies structure is too. */
7287 if (C_DECL_VARIABLE_SIZE (x
))
7288 C_TYPE_VARIABLE_SIZE (t
) = 1;
7290 if (DECL_INITIAL (x
))
7292 unsigned HOST_WIDE_INT width
= tree_to_uhwi (DECL_INITIAL (x
));
7293 DECL_SIZE (x
) = bitsize_int (width
);
7294 DECL_BIT_FIELD (x
) = 1;
7295 SET_DECL_C_BIT_FIELD (x
);
7299 && (DECL_BIT_FIELD (x
)
7300 || TYPE_ALIGN (TREE_TYPE (x
)) > BITS_PER_UNIT
))
7301 DECL_PACKED (x
) = 1;
7303 /* Detect flexible array member in an invalid context. */
7304 if (TREE_CODE (TREE_TYPE (x
)) == ARRAY_TYPE
7305 && TYPE_SIZE (TREE_TYPE (x
)) == NULL_TREE
7306 && TYPE_DOMAIN (TREE_TYPE (x
)) != NULL_TREE
7307 && TYPE_MAX_VALUE (TYPE_DOMAIN (TREE_TYPE (x
))) == NULL_TREE
)
7309 if (TREE_CODE (t
) == UNION_TYPE
)
7311 error_at (DECL_SOURCE_LOCATION (x
),
7312 "flexible array member in union");
7313 TREE_TYPE (x
) = error_mark_node
;
7315 else if (DECL_CHAIN (x
) != NULL_TREE
)
7317 error_at (DECL_SOURCE_LOCATION (x
),
7318 "flexible array member not at end of struct");
7319 TREE_TYPE (x
) = error_mark_node
;
7321 else if (!saw_named_field
)
7323 error_at (DECL_SOURCE_LOCATION (x
),
7324 "flexible array member in otherwise empty struct");
7325 TREE_TYPE (x
) = error_mark_node
;
7329 if (pedantic
&& TREE_CODE (t
) == RECORD_TYPE
7330 && flexible_array_type_p (TREE_TYPE (x
)))
7331 pedwarn (DECL_SOURCE_LOCATION (x
), OPT_Wpedantic
,
7332 "invalid use of structure with flexible array member");
7335 || TREE_CODE (TREE_TYPE (x
)) == RECORD_TYPE
7336 || TREE_CODE (TREE_TYPE (x
)) == UNION_TYPE
)
7337 saw_named_field
= 1;
7340 detect_field_duplicates (fieldlist
);
7342 /* Now we have the nearly final fieldlist. Record it,
7343 then lay out the structure or union (including the fields). */
7345 TYPE_FIELDS (t
) = fieldlist
;
7349 if (TYPE_SIZE_UNIT (t
)
7350 && TREE_CODE (TYPE_SIZE_UNIT (t
)) == INTEGER_CST
7351 && !TREE_OVERFLOW (TYPE_SIZE_UNIT (t
))
7352 && !valid_constant_size_p (TYPE_SIZE_UNIT (t
)))
7353 error ("type %qT is too large", t
);
7355 /* Give bit-fields their proper types. */
7357 tree
*fieldlistp
= &fieldlist
;
7359 if (TREE_CODE (*fieldlistp
) == FIELD_DECL
&& DECL_INITIAL (*fieldlistp
)
7360 && TREE_TYPE (*fieldlistp
) != error_mark_node
)
7362 unsigned HOST_WIDE_INT width
7363 = tree_to_uhwi (DECL_INITIAL (*fieldlistp
));
7364 tree type
= TREE_TYPE (*fieldlistp
);
7365 if (width
!= TYPE_PRECISION (type
))
7367 TREE_TYPE (*fieldlistp
)
7368 = c_build_bitfield_integer_type (width
, TYPE_UNSIGNED (type
));
7369 DECL_MODE (*fieldlistp
) = TYPE_MODE (TREE_TYPE (*fieldlistp
));
7371 DECL_INITIAL (*fieldlistp
) = 0;
7374 fieldlistp
= &DECL_CHAIN (*fieldlistp
);
7377 /* Now we have the truly final field list.
7378 Store it in this type and in the variants. */
7380 TYPE_FIELDS (t
) = fieldlist
;
7382 /* If there are lots of fields, sort so we can look through them fast.
7383 We arbitrarily consider 16 or more elts to be "a lot". */
7388 for (x
= fieldlist
; x
; x
= DECL_CHAIN (x
))
7390 if (len
> 15 || DECL_NAME (x
) == NULL
)
7398 struct lang_type
*space
;
7399 struct sorted_fields_type
*space2
;
7401 len
+= list_length (x
);
7403 /* Use the same allocation policy here that make_node uses, to
7404 ensure that this lives as long as the rest of the struct decl.
7405 All decls in an inline function need to be saved. */
7407 space
= ggc_alloc_cleared_lang_type (sizeof (struct lang_type
));
7408 space2
= ggc_alloc_sorted_fields_type
7409 (sizeof (struct sorted_fields_type
) + len
* sizeof (tree
));
7413 field_array
= &space2
->elts
[0];
7414 for (x
= fieldlist
; x
; x
= DECL_CHAIN (x
))
7416 field_array
[len
++] = x
;
7418 /* If there is anonymous struct or union, break out of the loop. */
7419 if (DECL_NAME (x
) == NULL
)
7422 /* Found no anonymous struct/union. Add the TYPE_LANG_SPECIFIC. */
7425 TYPE_LANG_SPECIFIC (t
) = space
;
7426 TYPE_LANG_SPECIFIC (t
)->s
->len
= len
;
7427 field_array
= TYPE_LANG_SPECIFIC (t
)->s
->elts
;
7428 qsort (field_array
, len
, sizeof (tree
), field_decl_cmp
);
7433 for (x
= TYPE_MAIN_VARIANT (t
); x
; x
= TYPE_NEXT_VARIANT (x
))
7435 TYPE_FIELDS (x
) = TYPE_FIELDS (t
);
7436 TYPE_LANG_SPECIFIC (x
) = TYPE_LANG_SPECIFIC (t
);
7437 C_TYPE_FIELDS_READONLY (x
) = C_TYPE_FIELDS_READONLY (t
);
7438 C_TYPE_FIELDS_VOLATILE (x
) = C_TYPE_FIELDS_VOLATILE (t
);
7439 C_TYPE_VARIABLE_SIZE (x
) = C_TYPE_VARIABLE_SIZE (t
);
7442 /* If this was supposed to be a transparent union, but we can't
7443 make it one, warn and turn off the flag. */
7444 if (TREE_CODE (t
) == UNION_TYPE
7445 && TYPE_TRANSPARENT_AGGR (t
)
7446 && (!TYPE_FIELDS (t
) || TYPE_MODE (t
) != DECL_MODE (TYPE_FIELDS (t
))))
7448 TYPE_TRANSPARENT_AGGR (t
) = 0;
7449 warning_at (loc
, 0, "union cannot be made transparent");
7452 /* If this structure or union completes the type of any previous
7453 variable declaration, lay it out and output its rtl. */
7454 for (x
= C_TYPE_INCOMPLETE_VARS (TYPE_MAIN_VARIANT (t
));
7458 tree decl
= TREE_VALUE (x
);
7459 if (TREE_CODE (TREE_TYPE (decl
)) == ARRAY_TYPE
)
7460 layout_array_type (TREE_TYPE (decl
));
7461 if (TREE_CODE (decl
) != TYPE_DECL
)
7463 layout_decl (decl
, 0);
7464 if (c_dialect_objc ())
7465 objc_check_decl (decl
);
7466 rest_of_decl_compilation (decl
, toplevel
, 0);
7469 C_TYPE_INCOMPLETE_VARS (TYPE_MAIN_VARIANT (t
)) = 0;
7471 /* Update type location to the one of the definition, instead of e.g.
7472 a forward declaration. */
7473 if (TYPE_STUB_DECL (t
))
7474 DECL_SOURCE_LOCATION (TYPE_STUB_DECL (t
)) = loc
;
7476 /* Finish debugging output for this type. */
7477 rest_of_type_compilation (t
, toplevel
);
7479 /* If we're inside a function proper, i.e. not file-scope and not still
7480 parsing parameters, then arrange for the size of a variable sized type
7482 if (building_stmt_list_p () && variably_modified_type_p (t
, NULL_TREE
))
7483 add_stmt (build_stmt (loc
,
7484 DECL_EXPR
, build_decl (loc
, TYPE_DECL
, NULL
, t
)));
7486 if (warn_cxx_compat
)
7487 warn_cxx_compat_finish_struct (fieldlist
);
7489 struct_parse_info
->struct_types
.release ();
7490 struct_parse_info
->fields
.release ();
7491 struct_parse_info
->typedefs_seen
.release ();
7492 XDELETE (struct_parse_info
);
7494 struct_parse_info
= enclosing_struct_parse_info
;
7496 /* If this struct is defined inside a struct, add it to
7499 && struct_parse_info
!= NULL
7500 && !in_sizeof
&& !in_typeof
&& !in_alignof
)
7501 struct_parse_info
->struct_types
.safe_push (t
);
7506 /* Lay out the type T, and its element type, and so on. */
7509 layout_array_type (tree t
)
7511 if (TREE_CODE (TREE_TYPE (t
)) == ARRAY_TYPE
)
7512 layout_array_type (TREE_TYPE (t
));
7516 /* Begin compiling the definition of an enumeration type.
7517 NAME is its name (or null if anonymous).
7518 LOC is the enum's location.
7519 Returns the type object, as yet incomplete.
7520 Also records info about it so that build_enumerator
7521 may be used to declare the individual values as they are read. */
7524 start_enum (location_t loc
, struct c_enum_contents
*the_enum
, tree name
)
7526 tree enumtype
= NULL_TREE
;
7527 location_t enumloc
= UNKNOWN_LOCATION
;
7529 /* If this is the real definition for a previous forward reference,
7530 fill in the contents in the same object that used to be the
7531 forward reference. */
7533 if (name
!= NULL_TREE
)
7534 enumtype
= lookup_tag (ENUMERAL_TYPE
, name
, 1, &enumloc
);
7536 if (enumtype
== 0 || TREE_CODE (enumtype
) != ENUMERAL_TYPE
)
7538 enumtype
= make_node (ENUMERAL_TYPE
);
7539 pushtag (loc
, name
, enumtype
);
7542 if (C_TYPE_BEING_DEFINED (enumtype
))
7543 error_at (loc
, "nested redefinition of %<enum %E%>", name
);
7545 C_TYPE_BEING_DEFINED (enumtype
) = 1;
7547 if (TYPE_VALUES (enumtype
) != 0)
7549 /* This enum is a named one that has been declared already. */
7550 error_at (loc
, "redeclaration of %<enum %E%>", name
);
7551 if (enumloc
!= UNKNOWN_LOCATION
)
7552 inform (enumloc
, "originally defined here");
7554 /* Completely replace its old definition.
7555 The old enumerators remain defined, however. */
7556 TYPE_VALUES (enumtype
) = 0;
7559 the_enum
->enum_next_value
= integer_zero_node
;
7560 the_enum
->enum_overflow
= 0;
7562 if (flag_short_enums
)
7563 TYPE_PACKED (enumtype
) = 1;
7565 /* FIXME: This will issue a warning for a use of a type defined
7566 within sizeof in a statement expr. This is not terribly serious
7567 as C++ doesn't permit statement exprs within sizeof anyhow. */
7568 if (warn_cxx_compat
&& (in_sizeof
|| in_typeof
|| in_alignof
))
7569 warning_at (loc
, OPT_Wc___compat
,
7570 "defining type in %qs expression is invalid in C++",
7573 : (in_typeof
? "typeof" : "alignof")));
7578 /* After processing and defining all the values of an enumeration type,
7579 install their decls in the enumeration type and finish it off.
7580 ENUMTYPE is the type object, VALUES a list of decl-value pairs,
7581 and ATTRIBUTES are the specified attributes.
7582 Returns ENUMTYPE. */
7585 finish_enum (tree enumtype
, tree values
, tree attributes
)
7588 tree minnode
= 0, maxnode
= 0;
7589 int precision
, unsign
;
7590 bool toplevel
= (file_scope
== current_scope
);
7591 struct lang_type
*lt
;
7593 decl_attributes (&enumtype
, attributes
, (int) ATTR_FLAG_TYPE_IN_PLACE
);
7595 /* Calculate the maximum value of any enumerator in this type. */
7597 if (values
== error_mark_node
)
7598 minnode
= maxnode
= integer_zero_node
;
7601 minnode
= maxnode
= TREE_VALUE (values
);
7602 for (pair
= TREE_CHAIN (values
); pair
; pair
= TREE_CHAIN (pair
))
7604 tree value
= TREE_VALUE (pair
);
7605 if (tree_int_cst_lt (maxnode
, value
))
7607 if (tree_int_cst_lt (value
, minnode
))
7612 /* Construct the final type of this enumeration. It is the same
7613 as one of the integral types - the narrowest one that fits, except
7614 that normally we only go as narrow as int - and signed iff any of
7615 the values are negative. */
7616 unsign
= (tree_int_cst_sgn (minnode
) >= 0);
7617 precision
= MAX (tree_int_cst_min_precision (minnode
, unsign
),
7618 tree_int_cst_min_precision (maxnode
, unsign
));
7620 if (TYPE_PACKED (enumtype
) || precision
> TYPE_PRECISION (integer_type_node
))
7622 tem
= c_common_type_for_size (precision
, unsign
);
7625 warning (0, "enumeration values exceed range of largest integer");
7626 tem
= long_long_integer_type_node
;
7630 tem
= unsign
? unsigned_type_node
: integer_type_node
;
7632 TYPE_MIN_VALUE (enumtype
) = TYPE_MIN_VALUE (tem
);
7633 TYPE_MAX_VALUE (enumtype
) = TYPE_MAX_VALUE (tem
);
7634 TYPE_UNSIGNED (enumtype
) = TYPE_UNSIGNED (tem
);
7635 TYPE_SIZE (enumtype
) = 0;
7637 /* If the precision of the type was specific with an attribute and it
7638 was too small, give an error. Otherwise, use it. */
7639 if (TYPE_PRECISION (enumtype
))
7641 if (precision
> TYPE_PRECISION (enumtype
))
7642 error ("specified mode too small for enumeral values");
7645 TYPE_PRECISION (enumtype
) = TYPE_PRECISION (tem
);
7647 layout_type (enumtype
);
7649 if (values
!= error_mark_node
)
7651 /* Change the type of the enumerators to be the enum type. We
7652 need to do this irrespective of the size of the enum, for
7653 proper type checking. Replace the DECL_INITIALs of the
7654 enumerators, and the value slots of the list, with copies
7655 that have the enum type; they cannot be modified in place
7656 because they may be shared (e.g. integer_zero_node) Finally,
7657 change the purpose slots to point to the names of the decls. */
7658 for (pair
= values
; pair
; pair
= TREE_CHAIN (pair
))
7660 tree enu
= TREE_PURPOSE (pair
);
7661 tree ini
= DECL_INITIAL (enu
);
7663 TREE_TYPE (enu
) = enumtype
;
7665 /* The ISO C Standard mandates enumerators to have type int,
7666 even though the underlying type of an enum type is
7667 unspecified. However, GCC allows enumerators of any
7668 integer type as an extensions. build_enumerator()
7669 converts any enumerators that fit in an int to type int,
7670 to avoid promotions to unsigned types when comparing
7671 integers with enumerators that fit in the int range.
7672 When -pedantic is given, build_enumerator() would have
7673 already warned about those that don't fit. Here we
7674 convert the rest to the enumerator type. */
7675 if (TREE_TYPE (ini
) != integer_type_node
)
7676 ini
= convert (enumtype
, ini
);
7678 DECL_INITIAL (enu
) = ini
;
7679 TREE_PURPOSE (pair
) = DECL_NAME (enu
);
7680 TREE_VALUE (pair
) = ini
;
7683 TYPE_VALUES (enumtype
) = values
;
7686 /* Record the min/max values so that we can warn about bit-field
7687 enumerations that are too small for the values. */
7688 lt
= ggc_alloc_cleared_lang_type (sizeof (struct lang_type
));
7689 lt
->enum_min
= minnode
;
7690 lt
->enum_max
= maxnode
;
7691 TYPE_LANG_SPECIFIC (enumtype
) = lt
;
7693 /* Fix up all variant types of this enum type. */
7694 for (tem
= TYPE_MAIN_VARIANT (enumtype
); tem
; tem
= TYPE_NEXT_VARIANT (tem
))
7696 if (tem
== enumtype
)
7698 TYPE_VALUES (tem
) = TYPE_VALUES (enumtype
);
7699 TYPE_MIN_VALUE (tem
) = TYPE_MIN_VALUE (enumtype
);
7700 TYPE_MAX_VALUE (tem
) = TYPE_MAX_VALUE (enumtype
);
7701 TYPE_SIZE (tem
) = TYPE_SIZE (enumtype
);
7702 TYPE_SIZE_UNIT (tem
) = TYPE_SIZE_UNIT (enumtype
);
7703 SET_TYPE_MODE (tem
, TYPE_MODE (enumtype
));
7704 TYPE_PRECISION (tem
) = TYPE_PRECISION (enumtype
);
7705 TYPE_ALIGN (tem
) = TYPE_ALIGN (enumtype
);
7706 TYPE_USER_ALIGN (tem
) = TYPE_USER_ALIGN (enumtype
);
7707 TYPE_UNSIGNED (tem
) = TYPE_UNSIGNED (enumtype
);
7708 TYPE_LANG_SPECIFIC (tem
) = TYPE_LANG_SPECIFIC (enumtype
);
7711 /* Finish debugging output for this type. */
7712 rest_of_type_compilation (enumtype
, toplevel
);
7714 /* If this enum is defined inside a struct, add it to
7717 && struct_parse_info
!= NULL
7718 && !in_sizeof
&& !in_typeof
&& !in_alignof
)
7719 struct_parse_info
->struct_types
.safe_push (enumtype
);
7724 /* Build and install a CONST_DECL for one value of the
7725 current enumeration type (one that was begun with start_enum).
7726 DECL_LOC is the location of the enumerator.
7727 LOC is the location of the '=' operator if any, DECL_LOC otherwise.
7728 Return a tree-list containing the CONST_DECL and its value.
7729 Assignment of sequential values by default is handled here. */
7732 build_enumerator (location_t decl_loc
, location_t loc
,
7733 struct c_enum_contents
*the_enum
, tree name
, tree value
)
7737 /* Validate and default VALUE. */
7741 /* Don't issue more errors for error_mark_node (i.e. an
7742 undeclared identifier) - just ignore the value expression. */
7743 if (value
== error_mark_node
)
7745 else if (!INTEGRAL_TYPE_P (TREE_TYPE (value
)))
7747 error_at (loc
, "enumerator value for %qE is not an integer constant",
7753 if (TREE_CODE (value
) != INTEGER_CST
)
7755 value
= c_fully_fold (value
, false, NULL
);
7756 if (TREE_CODE (value
) == INTEGER_CST
)
7757 pedwarn (loc
, OPT_Wpedantic
,
7758 "enumerator value for %qE is not an integer "
7759 "constant expression", name
);
7761 if (TREE_CODE (value
) != INTEGER_CST
)
7763 error ("enumerator value for %qE is not an integer constant",
7769 value
= default_conversion (value
);
7770 constant_expression_warning (value
);
7775 /* Default based on previous value. */
7776 /* It should no longer be possible to have NON_LVALUE_EXPR
7780 value
= the_enum
->enum_next_value
;
7781 if (the_enum
->enum_overflow
)
7782 error_at (loc
, "overflow in enumeration values");
7784 /* Even though the underlying type of an enum is unspecified, the
7785 type of enumeration constants is explicitly defined as int
7786 (6.4.4.3/2 in the C99 Standard). GCC allows any integer type as
7788 else if (!int_fits_type_p (value
, integer_type_node
))
7789 pedwarn (loc
, OPT_Wpedantic
,
7790 "ISO C restricts enumerator values to range of %<int%>");
7792 /* The ISO C Standard mandates enumerators to have type int, even
7793 though the underlying type of an enum type is unspecified.
7794 However, GCC allows enumerators of any integer type as an
7795 extensions. Here we convert any enumerators that fit in an int
7796 to type int, to avoid promotions to unsigned types when comparing
7797 integers with enumerators that fit in the int range. When
7798 -pedantic is given, we would have already warned about those that
7799 don't fit. We have to do this here rather than in finish_enum
7800 because this value may be used to define more enumerators. */
7801 if (int_fits_type_p (value
, integer_type_node
))
7802 value
= convert (integer_type_node
, value
);
7804 /* Set basis for default for next value. */
7805 the_enum
->enum_next_value
7806 = build_binary_op (EXPR_LOC_OR_LOC (value
, input_location
),
7807 PLUS_EXPR
, value
, integer_one_node
, 0);
7808 the_enum
->enum_overflow
= tree_int_cst_lt (the_enum
->enum_next_value
, value
);
7810 /* Now create a declaration for the enum value name. */
7812 type
= TREE_TYPE (value
);
7813 type
= c_common_type_for_size (MAX (TYPE_PRECISION (type
),
7814 TYPE_PRECISION (integer_type_node
)),
7815 (TYPE_PRECISION (type
)
7816 >= TYPE_PRECISION (integer_type_node
)
7817 && TYPE_UNSIGNED (type
)));
7819 decl
= build_decl (decl_loc
, CONST_DECL
, name
, type
);
7820 DECL_INITIAL (decl
) = convert (type
, value
);
7823 return tree_cons (decl
, value
, NULL_TREE
);
7827 /* Create the FUNCTION_DECL for a function definition.
7828 DECLSPECS, DECLARATOR and ATTRIBUTES are the parts of
7829 the declaration; they describe the function's name and the type it returns,
7830 but twisted together in a fashion that parallels the syntax of C.
7832 This function creates a binding context for the function body
7833 as well as setting up the FUNCTION_DECL in current_function_decl.
7835 Returns 1 on success. If the DECLARATOR is not suitable for a function
7836 (it defines a datum instead), we return 0, which tells
7837 yyparse to report a parse error. */
7840 start_function (struct c_declspecs
*declspecs
, struct c_declarator
*declarator
,
7843 tree decl1
, old_decl
;
7844 tree restype
, resdecl
;
7847 current_function_returns_value
= 0; /* Assume, until we see it does. */
7848 current_function_returns_null
= 0;
7849 current_function_returns_abnormally
= 0;
7850 warn_about_return_type
= 0;
7851 c_switch_stack
= NULL
;
7853 /* Indicate no valid break/continue context by setting these variables
7854 to some non-null, non-label value. We'll notice and emit the proper
7855 error message in c_finish_bc_stmt. */
7856 c_break_label
= c_cont_label
= size_zero_node
;
7858 decl1
= grokdeclarator (declarator
, declspecs
, FUNCDEF
, true, NULL
,
7859 &attributes
, NULL
, NULL
, DEPRECATED_NORMAL
);
7861 /* If the declarator is not suitable for a function definition,
7862 cause a syntax error. */
7864 || TREE_CODE (decl1
) != FUNCTION_DECL
)
7867 loc
= DECL_SOURCE_LOCATION (decl1
);
7869 c_decl_attributes (&decl1
, attributes
, 0);
7871 if (DECL_DECLARED_INLINE_P (decl1
)
7872 && DECL_UNINLINABLE (decl1
)
7873 && lookup_attribute ("noinline", DECL_ATTRIBUTES (decl1
)))
7874 warning_at (loc
, OPT_Wattributes
,
7875 "inline function %qD given attribute noinline",
7878 /* Handle gnu_inline attribute. */
7879 if (declspecs
->inline_p
7880 && !flag_gnu89_inline
7881 && TREE_CODE (decl1
) == FUNCTION_DECL
7882 && (lookup_attribute ("gnu_inline", DECL_ATTRIBUTES (decl1
))
7883 || current_function_decl
))
7885 if (declspecs
->storage_class
!= csc_static
)
7886 DECL_EXTERNAL (decl1
) = !DECL_EXTERNAL (decl1
);
7889 announce_function (decl1
);
7891 if (!COMPLETE_OR_VOID_TYPE_P (TREE_TYPE (TREE_TYPE (decl1
))))
7893 error_at (loc
, "return type is an incomplete type");
7894 /* Make it return void instead. */
7896 = build_function_type (void_type_node
,
7897 TYPE_ARG_TYPES (TREE_TYPE (decl1
)));
7900 if (warn_about_return_type
)
7901 pedwarn_c99 (loc
, flag_isoc99
? 0
7902 : (warn_return_type
? OPT_Wreturn_type
: OPT_Wimplicit_int
),
7903 "return type defaults to %<int%>");
7905 /* Make the init_value nonzero so pushdecl knows this is not tentative.
7906 error_mark_node is replaced below (in pop_scope) with the BLOCK. */
7907 DECL_INITIAL (decl1
) = error_mark_node
;
7909 /* A nested function is not global. */
7910 if (current_function_decl
!= 0)
7911 TREE_PUBLIC (decl1
) = 0;
7913 /* If this definition isn't a prototype and we had a prototype declaration
7914 before, copy the arg type info from that prototype. */
7915 old_decl
= lookup_name_in_scope (DECL_NAME (decl1
), current_scope
);
7916 if (old_decl
&& TREE_CODE (old_decl
) != FUNCTION_DECL
)
7918 current_function_prototype_locus
= UNKNOWN_LOCATION
;
7919 current_function_prototype_built_in
= false;
7920 current_function_prototype_arg_types
= NULL_TREE
;
7921 if (!prototype_p (TREE_TYPE (decl1
)))
7923 if (old_decl
!= 0 && TREE_CODE (TREE_TYPE (old_decl
)) == FUNCTION_TYPE
7924 && comptypes (TREE_TYPE (TREE_TYPE (decl1
)),
7925 TREE_TYPE (TREE_TYPE (old_decl
))))
7927 TREE_TYPE (decl1
) = composite_type (TREE_TYPE (old_decl
),
7929 current_function_prototype_locus
= DECL_SOURCE_LOCATION (old_decl
);
7930 current_function_prototype_built_in
7931 = C_DECL_BUILTIN_PROTOTYPE (old_decl
);
7932 current_function_prototype_arg_types
7933 = TYPE_ARG_TYPES (TREE_TYPE (decl1
));
7935 if (TREE_PUBLIC (decl1
))
7937 /* If there is an external prototype declaration of this
7938 function, record its location but do not copy information
7939 to this decl. This may be an invisible declaration
7940 (built-in or in a scope which has finished) or simply
7941 have more refined argument types than any declaration
7943 struct c_binding
*b
;
7944 for (b
= I_SYMBOL_BINDING (DECL_NAME (decl1
)); b
; b
= b
->shadowed
)
7945 if (B_IN_SCOPE (b
, external_scope
))
7949 tree ext_decl
, ext_type
;
7951 ext_type
= b
->u
.type
? b
->u
.type
: TREE_TYPE (ext_decl
);
7952 if (TREE_CODE (ext_type
) == FUNCTION_TYPE
7953 && comptypes (TREE_TYPE (TREE_TYPE (decl1
)),
7954 TREE_TYPE (ext_type
)))
7956 current_function_prototype_locus
7957 = DECL_SOURCE_LOCATION (ext_decl
);
7958 current_function_prototype_built_in
7959 = C_DECL_BUILTIN_PROTOTYPE (ext_decl
);
7960 current_function_prototype_arg_types
7961 = TYPE_ARG_TYPES (ext_type
);
7967 /* Optionally warn of old-fashioned def with no previous prototype. */
7968 if (warn_strict_prototypes
7969 && old_decl
!= error_mark_node
7970 && !prototype_p (TREE_TYPE (decl1
))
7971 && C_DECL_ISNT_PROTOTYPE (old_decl
))
7972 warning_at (loc
, OPT_Wstrict_prototypes
,
7973 "function declaration isn%'t a prototype");
7974 /* Optionally warn of any global def with no previous prototype. */
7975 else if (warn_missing_prototypes
7976 && old_decl
!= error_mark_node
7977 && TREE_PUBLIC (decl1
)
7978 && !MAIN_NAME_P (DECL_NAME (decl1
))
7979 && C_DECL_ISNT_PROTOTYPE (old_decl
)
7980 && !DECL_DECLARED_INLINE_P (decl1
))
7981 warning_at (loc
, OPT_Wmissing_prototypes
,
7982 "no previous prototype for %qD", decl1
);
7983 /* Optionally warn of any def with no previous prototype
7984 if the function has already been used. */
7985 else if (warn_missing_prototypes
7987 && old_decl
!= error_mark_node
7988 && TREE_USED (old_decl
)
7989 && !prototype_p (TREE_TYPE (old_decl
)))
7990 warning_at (loc
, OPT_Wmissing_prototypes
,
7991 "%qD was used with no prototype before its definition", decl1
);
7992 /* Optionally warn of any global def with no previous declaration. */
7993 else if (warn_missing_declarations
7994 && TREE_PUBLIC (decl1
)
7996 && !MAIN_NAME_P (DECL_NAME (decl1
)))
7997 warning_at (loc
, OPT_Wmissing_declarations
,
7998 "no previous declaration for %qD",
8000 /* Optionally warn of any def with no previous declaration
8001 if the function has already been used. */
8002 else if (warn_missing_declarations
8004 && old_decl
!= error_mark_node
8005 && TREE_USED (old_decl
)
8006 && C_DECL_IMPLICIT (old_decl
))
8007 warning_at (loc
, OPT_Wmissing_declarations
,
8008 "%qD was used with no declaration before its definition", decl1
);
8010 /* This function exists in static storage.
8011 (This does not mean `static' in the C sense!) */
8012 TREE_STATIC (decl1
) = 1;
8014 /* This is the earliest point at which we might know the assembler
8015 name of the function. Thus, if it's set before this, die horribly. */
8016 gcc_assert (!DECL_ASSEMBLER_NAME_SET_P (decl1
));
8018 /* If #pragma weak was used, mark the decl weak now. */
8019 if (current_scope
== file_scope
)
8020 maybe_apply_pragma_weak (decl1
);
8022 /* Warn for unlikely, improbable, or stupid declarations of `main'. */
8023 if (warn_main
&& MAIN_NAME_P (DECL_NAME (decl1
)))
8025 if (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (decl1
)))
8026 != integer_type_node
)
8027 pedwarn (loc
, OPT_Wmain
, "return type of %qD is not %<int%>", decl1
);
8029 check_main_parameter_types (decl1
);
8031 if (!TREE_PUBLIC (decl1
))
8032 pedwarn (loc
, OPT_Wmain
,
8033 "%qD is normally a non-static function", decl1
);
8036 /* Record the decl so that the function name is defined.
8037 If we already have a decl for this name, and it is a FUNCTION_DECL,
8038 use the old decl. */
8040 current_function_decl
= pushdecl (decl1
);
8043 declare_parm_level ();
8045 restype
= TREE_TYPE (TREE_TYPE (current_function_decl
));
8046 resdecl
= build_decl (loc
, RESULT_DECL
, NULL_TREE
, restype
);
8047 DECL_ARTIFICIAL (resdecl
) = 1;
8048 DECL_IGNORED_P (resdecl
) = 1;
8049 DECL_RESULT (current_function_decl
) = resdecl
;
8051 start_fname_decls ();
8056 /* Subroutine of store_parm_decls which handles new-style function
8057 definitions (prototype format). The parms already have decls, so we
8058 need only record them as in effect and complain if any redundant
8059 old-style parm decls were written. */
8061 store_parm_decls_newstyle (tree fndecl
, const struct c_arg_info
*arg_info
)
8067 if (current_scope
->bindings
)
8069 error_at (DECL_SOURCE_LOCATION (fndecl
),
8070 "old-style parameter declarations in prototyped "
8071 "function definition");
8073 /* Get rid of the old-style declarations. */
8077 /* Don't issue this warning for nested functions, and don't issue this
8078 warning if we got here because ARG_INFO_TYPES was error_mark_node
8079 (this happens when a function definition has just an ellipsis in
8080 its parameter list). */
8081 else if (!in_system_header_at (input_location
)
8082 && !current_function_scope
8083 && arg_info
->types
!= error_mark_node
)
8084 warning_at (DECL_SOURCE_LOCATION (fndecl
), OPT_Wtraditional
,
8085 "traditional C rejects ISO C style function definitions");
8087 /* Now make all the parameter declarations visible in the function body.
8088 We can bypass most of the grunt work of pushdecl. */
8089 for (decl
= arg_info
->parms
; decl
; decl
= DECL_CHAIN (decl
))
8091 DECL_CONTEXT (decl
) = current_function_decl
;
8092 if (DECL_NAME (decl
))
8094 bind (DECL_NAME (decl
), decl
, current_scope
,
8095 /*invisible=*/false, /*nested=*/false,
8097 if (!TREE_USED (decl
))
8098 warn_if_shadowing (decl
);
8101 error_at (DECL_SOURCE_LOCATION (decl
), "parameter name omitted");
8104 /* Record the parameter list in the function declaration. */
8105 DECL_ARGUMENTS (fndecl
) = arg_info
->parms
;
8107 /* Now make all the ancillary declarations visible, likewise. */
8108 for (decl
= arg_info
->others
; decl
; decl
= DECL_CHAIN (decl
))
8110 DECL_CONTEXT (decl
) = current_function_decl
;
8111 if (DECL_NAME (decl
))
8112 bind (DECL_NAME (decl
), decl
, current_scope
,
8113 /*invisible=*/false,
8114 /*nested=*/(TREE_CODE (decl
) == FUNCTION_DECL
),
8118 /* And all the tag declarations. */
8119 FOR_EACH_VEC_SAFE_ELT_REVERSE (arg_info
->tags
, ix
, tag
)
8121 bind (tag
->id
, tag
->type
, current_scope
,
8122 /*invisible=*/false, /*nested=*/false, UNKNOWN_LOCATION
);
8125 /* Subroutine of store_parm_decls which handles old-style function
8126 definitions (separate parameter list and declarations). */
8129 store_parm_decls_oldstyle (tree fndecl
, const struct c_arg_info
*arg_info
)
8131 struct c_binding
*b
;
8132 tree parm
, decl
, last
;
8133 tree parmids
= arg_info
->parms
;
8134 struct pointer_set_t
*seen_args
= pointer_set_create ();
8136 if (!in_system_header_at (input_location
))
8137 warning_at (DECL_SOURCE_LOCATION (fndecl
),
8138 OPT_Wold_style_definition
, "old-style function definition");
8140 /* Match each formal parameter name with its declaration. Save each
8141 decl in the appropriate TREE_PURPOSE slot of the parmids chain. */
8142 for (parm
= parmids
; parm
; parm
= TREE_CHAIN (parm
))
8144 if (TREE_VALUE (parm
) == 0)
8146 error_at (DECL_SOURCE_LOCATION (fndecl
),
8147 "parameter name missing from parameter list");
8148 TREE_PURPOSE (parm
) = 0;
8152 b
= I_SYMBOL_BINDING (TREE_VALUE (parm
));
8153 if (b
&& B_IN_CURRENT_SCOPE (b
))
8156 /* Skip erroneous parameters. */
8157 if (decl
== error_mark_node
)
8159 /* If we got something other than a PARM_DECL it is an error. */
8160 if (TREE_CODE (decl
) != PARM_DECL
)
8161 error_at (DECL_SOURCE_LOCATION (decl
),
8162 "%qD declared as a non-parameter", decl
);
8163 /* If the declaration is already marked, we have a duplicate
8164 name. Complain and ignore the duplicate. */
8165 else if (pointer_set_contains (seen_args
, decl
))
8167 error_at (DECL_SOURCE_LOCATION (decl
),
8168 "multiple parameters named %qD", decl
);
8169 TREE_PURPOSE (parm
) = 0;
8172 /* If the declaration says "void", complain and turn it into
8174 else if (VOID_TYPE_P (TREE_TYPE (decl
)))
8176 error_at (DECL_SOURCE_LOCATION (decl
),
8177 "parameter %qD declared with void type", decl
);
8178 TREE_TYPE (decl
) = integer_type_node
;
8179 DECL_ARG_TYPE (decl
) = integer_type_node
;
8180 layout_decl (decl
, 0);
8182 warn_if_shadowing (decl
);
8184 /* If no declaration found, default to int. */
8187 /* FIXME diagnostics: This should be the location of the argument,
8188 not the FNDECL. E.g., for an old-style declaration
8190 int f10(v) { blah; }
8192 We should use the location of the V, not the F10.
8193 Unfortunately, the V is an IDENTIFIER_NODE which has no
8194 location. In the future we need locations for c_arg_info
8197 See gcc.dg/Wshadow-3.c for an example of this problem. */
8198 decl
= build_decl (DECL_SOURCE_LOCATION (fndecl
),
8199 PARM_DECL
, TREE_VALUE (parm
), integer_type_node
);
8200 DECL_ARG_TYPE (decl
) = TREE_TYPE (decl
);
8202 warn_if_shadowing (decl
);
8205 pedwarn (DECL_SOURCE_LOCATION (decl
),
8206 0, "type of %qD defaults to %<int%>", decl
);
8208 warning_at (DECL_SOURCE_LOCATION (decl
),
8209 OPT_Wmissing_parameter_type
,
8210 "type of %qD defaults to %<int%>", decl
);
8213 TREE_PURPOSE (parm
) = decl
;
8214 pointer_set_insert (seen_args
, decl
);
8217 /* Now examine the parms chain for incomplete declarations
8218 and declarations with no corresponding names. */
8220 for (b
= current_scope
->bindings
; b
; b
= b
->prev
)
8223 if (TREE_CODE (parm
) != PARM_DECL
)
8226 if (TREE_TYPE (parm
) != error_mark_node
8227 && !COMPLETE_TYPE_P (TREE_TYPE (parm
)))
8229 error_at (DECL_SOURCE_LOCATION (parm
),
8230 "parameter %qD has incomplete type", parm
);
8231 TREE_TYPE (parm
) = error_mark_node
;
8234 if (!pointer_set_contains (seen_args
, parm
))
8236 error_at (DECL_SOURCE_LOCATION (parm
),
8237 "declaration for parameter %qD but no such parameter",
8240 /* Pretend the parameter was not missing.
8241 This gets us to a standard state and minimizes
8242 further error messages. */
8243 parmids
= chainon (parmids
, tree_cons (parm
, 0, 0));
8247 /* Chain the declarations together in the order of the list of
8248 names. Store that chain in the function decl, replacing the
8249 list of names. Update the current scope to match. */
8250 DECL_ARGUMENTS (fndecl
) = 0;
8252 for (parm
= parmids
; parm
; parm
= TREE_CHAIN (parm
))
8253 if (TREE_PURPOSE (parm
))
8255 if (parm
&& TREE_PURPOSE (parm
))
8257 last
= TREE_PURPOSE (parm
);
8258 DECL_ARGUMENTS (fndecl
) = last
;
8260 for (parm
= TREE_CHAIN (parm
); parm
; parm
= TREE_CHAIN (parm
))
8261 if (TREE_PURPOSE (parm
))
8263 DECL_CHAIN (last
) = TREE_PURPOSE (parm
);
8264 last
= TREE_PURPOSE (parm
);
8266 DECL_CHAIN (last
) = 0;
8269 pointer_set_destroy (seen_args
);
8271 /* If there was a previous prototype,
8272 set the DECL_ARG_TYPE of each argument according to
8273 the type previously specified, and report any mismatches. */
8275 if (current_function_prototype_arg_types
)
8278 for (parm
= DECL_ARGUMENTS (fndecl
),
8279 type
= current_function_prototype_arg_types
;
8280 parm
|| (type
&& TREE_VALUE (type
) != error_mark_node
8281 && (TYPE_MAIN_VARIANT (TREE_VALUE (type
)) != void_type_node
));
8282 parm
= DECL_CHAIN (parm
), type
= TREE_CHAIN (type
))
8284 if (parm
== 0 || type
== 0
8285 || TYPE_MAIN_VARIANT (TREE_VALUE (type
)) == void_type_node
)
8287 if (current_function_prototype_built_in
)
8288 warning_at (DECL_SOURCE_LOCATION (fndecl
),
8289 0, "number of arguments doesn%'t match "
8290 "built-in prototype");
8293 /* FIXME diagnostics: This should be the location of
8294 FNDECL, but there is bug when a prototype is
8295 declared inside function context, but defined
8296 outside of it (e.g., gcc.dg/pr15698-2.c). In
8297 which case FNDECL gets the location of the
8298 prototype, not the definition. */
8299 error_at (input_location
,
8300 "number of arguments doesn%'t match prototype");
8302 error_at (current_function_prototype_locus
,
8303 "prototype declaration");
8307 /* Type for passing arg must be consistent with that
8308 declared for the arg. ISO C says we take the unqualified
8309 type for parameters declared with qualified type. */
8310 if (TREE_TYPE (parm
) != error_mark_node
8311 && TREE_TYPE (type
) != error_mark_node
8312 && ((TYPE_ATOMIC (DECL_ARG_TYPE (parm
))
8313 != TYPE_ATOMIC (TREE_VALUE (type
)))
8314 || !comptypes (TYPE_MAIN_VARIANT (DECL_ARG_TYPE (parm
)),
8315 TYPE_MAIN_VARIANT (TREE_VALUE (type
)))))
8317 if ((TYPE_ATOMIC (DECL_ARG_TYPE (parm
))
8318 == TYPE_ATOMIC (TREE_VALUE (type
)))
8319 && (TYPE_MAIN_VARIANT (TREE_TYPE (parm
))
8320 == TYPE_MAIN_VARIANT (TREE_VALUE (type
))))
8322 /* Adjust argument to match prototype. E.g. a previous
8323 `int foo(float);' prototype causes
8324 `int foo(x) float x; {...}' to be treated like
8325 `int foo(float x) {...}'. This is particularly
8326 useful for argument types like uid_t. */
8327 DECL_ARG_TYPE (parm
) = TREE_TYPE (parm
);
8329 if (targetm
.calls
.promote_prototypes (TREE_TYPE (current_function_decl
))
8330 && INTEGRAL_TYPE_P (TREE_TYPE (parm
))
8331 && TYPE_PRECISION (TREE_TYPE (parm
))
8332 < TYPE_PRECISION (integer_type_node
))
8333 DECL_ARG_TYPE (parm
)
8334 = c_type_promotes_to (TREE_TYPE (parm
));
8336 /* ??? Is it possible to get here with a
8337 built-in prototype or will it always have
8338 been diagnosed as conflicting with an
8339 old-style definition and discarded? */
8340 if (current_function_prototype_built_in
)
8341 warning_at (DECL_SOURCE_LOCATION (parm
),
8342 OPT_Wpedantic
, "promoted argument %qD "
8343 "doesn%'t match built-in prototype", parm
);
8346 pedwarn (DECL_SOURCE_LOCATION (parm
),
8347 OPT_Wpedantic
, "promoted argument %qD "
8348 "doesn%'t match prototype", parm
);
8349 pedwarn (current_function_prototype_locus
, OPT_Wpedantic
,
8350 "prototype declaration");
8355 if (current_function_prototype_built_in
)
8356 warning_at (DECL_SOURCE_LOCATION (parm
),
8357 0, "argument %qD doesn%'t match "
8358 "built-in prototype", parm
);
8361 error_at (DECL_SOURCE_LOCATION (parm
),
8362 "argument %qD doesn%'t match prototype", parm
);
8363 error_at (current_function_prototype_locus
,
8364 "prototype declaration");
8369 TYPE_ACTUAL_ARG_TYPES (TREE_TYPE (fndecl
)) = 0;
8372 /* Otherwise, create a prototype that would match. */
8376 tree actual
= 0, last
= 0, type
;
8378 for (parm
= DECL_ARGUMENTS (fndecl
); parm
; parm
= DECL_CHAIN (parm
))
8380 type
= tree_cons (NULL_TREE
, DECL_ARG_TYPE (parm
), NULL_TREE
);
8382 TREE_CHAIN (last
) = type
;
8387 type
= tree_cons (NULL_TREE
, void_type_node
, NULL_TREE
);
8389 TREE_CHAIN (last
) = type
;
8393 /* We are going to assign a new value for the TYPE_ACTUAL_ARG_TYPES
8394 of the type of this function, but we need to avoid having this
8395 affect the types of other similarly-typed functions, so we must
8396 first force the generation of an identical (but separate) type
8397 node for the relevant function type. The new node we create
8398 will be a variant of the main variant of the original function
8401 TREE_TYPE (fndecl
) = build_variant_type_copy (TREE_TYPE (fndecl
));
8403 TYPE_ACTUAL_ARG_TYPES (TREE_TYPE (fndecl
)) = actual
;
8407 /* Store parameter declarations passed in ARG_INFO into the current
8408 function declaration. */
8411 store_parm_decls_from (struct c_arg_info
*arg_info
)
8413 current_function_arg_info
= arg_info
;
8414 store_parm_decls ();
8417 /* Store the parameter declarations into the current function declaration.
8418 This is called after parsing the parameter declarations, before
8419 digesting the body of the function.
8421 For an old-style definition, construct a prototype out of the old-style
8422 parameter declarations and inject it into the function's type. */
8425 store_parm_decls (void)
8427 tree fndecl
= current_function_decl
;
8430 /* The argument information block for FNDECL. */
8431 struct c_arg_info
*arg_info
= current_function_arg_info
;
8432 current_function_arg_info
= 0;
8434 /* True if this definition is written with a prototype. Note:
8435 despite C99 6.7.5.3p14, we can *not* treat an empty argument
8436 list in a function definition as equivalent to (void) -- an
8437 empty argument list specifies the function has no parameters,
8438 but only (void) sets up a prototype for future calls. */
8439 proto
= arg_info
->types
!= 0;
8442 store_parm_decls_newstyle (fndecl
, arg_info
);
8444 store_parm_decls_oldstyle (fndecl
, arg_info
);
8446 /* The next call to push_scope will be a function body. */
8448 next_is_function_body
= true;
8450 /* Write a record describing this function definition to the prototypes
8451 file (if requested). */
8453 gen_aux_info_record (fndecl
, 1, 0, proto
);
8455 /* Initialize the RTL code for the function. */
8456 allocate_struct_function (fndecl
, false);
8458 if (warn_unused_local_typedefs
)
8459 cfun
->language
= ggc_alloc_cleared_language_function ();
8461 /* Begin the statement tree for this function. */
8462 DECL_SAVED_TREE (fndecl
) = push_stmt_list ();
8464 /* ??? Insert the contents of the pending sizes list into the function
8465 to be evaluated. The only reason left to have this is
8466 void foo(int n, int array[n++])
8467 because we throw away the array type in favor of a pointer type, and
8468 thus won't naturally see the SAVE_EXPR containing the increment. All
8469 other pending sizes would be handled by gimplify_parameters. */
8470 if (arg_info
->pending_sizes
)
8471 add_stmt (arg_info
->pending_sizes
);
8474 /* Store PARM_DECLs in PARMS into scope temporarily. Used for
8475 c_finish_omp_declare_simd for function prototypes. No diagnostics
8479 temp_store_parm_decls (tree fndecl
, tree parms
)
8482 for (tree p
= parms
; p
; p
= DECL_CHAIN (p
))
8484 DECL_CONTEXT (p
) = fndecl
;
8486 bind (DECL_NAME (p
), p
, current_scope
,
8487 /*invisible=*/false, /*nested=*/false,
8492 /* Undo what temp_store_parm_decls did. */
8495 temp_pop_parm_decls (void)
8497 /* Clear all bindings in this temporary scope, so that
8498 pop_scope doesn't create a BLOCK. */
8499 struct c_binding
*b
= current_scope
->bindings
;
8500 current_scope
->bindings
= NULL
;
8501 for (; b
; b
= free_binding_and_advance (b
))
8503 gcc_assert (TREE_CODE (b
->decl
) == PARM_DECL
);
8504 gcc_assert (I_SYMBOL_BINDING (b
->id
) == b
);
8505 I_SYMBOL_BINDING (b
->id
) = b
->shadowed
;
8506 if (b
->shadowed
&& b
->shadowed
->u
.type
)
8507 TREE_TYPE (b
->shadowed
->decl
) = b
->shadowed
->u
.type
;
8513 /* Finish up a function declaration and compile that function
8514 all the way to assembler language output. Then free the storage
8515 for the function definition.
8517 This is called after parsing the body of the function definition. */
8520 finish_function (void)
8522 tree fndecl
= current_function_decl
;
8524 if (c_dialect_objc ())
8525 objc_finish_function ();
8527 if (TREE_CODE (fndecl
) == FUNCTION_DECL
8528 && targetm
.calls
.promote_prototypes (TREE_TYPE (fndecl
)))
8530 tree args
= DECL_ARGUMENTS (fndecl
);
8531 for (; args
; args
= DECL_CHAIN (args
))
8533 tree type
= TREE_TYPE (args
);
8534 if (INTEGRAL_TYPE_P (type
)
8535 && TYPE_PRECISION (type
) < TYPE_PRECISION (integer_type_node
))
8536 DECL_ARG_TYPE (args
) = c_type_promotes_to (type
);
8540 if (DECL_INITIAL (fndecl
) && DECL_INITIAL (fndecl
) != error_mark_node
)
8541 BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl
)) = fndecl
;
8543 /* Must mark the RESULT_DECL as being in this function. */
8545 if (DECL_RESULT (fndecl
) && DECL_RESULT (fndecl
) != error_mark_node
)
8546 DECL_CONTEXT (DECL_RESULT (fndecl
)) = fndecl
;
8548 if (MAIN_NAME_P (DECL_NAME (fndecl
)) && flag_hosted
8549 && TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (fndecl
)))
8550 == integer_type_node
&& flag_isoc99
)
8552 /* Hack. We don't want the middle-end to warn that this return
8553 is unreachable, so we mark its location as special. Using
8554 UNKNOWN_LOCATION has the problem that it gets clobbered in
8555 annotate_one_with_locus. A cleaner solution might be to
8556 ensure ! should_carry_locus_p (stmt), but that needs a flag.
8558 c_finish_return (BUILTINS_LOCATION
, integer_zero_node
, NULL_TREE
);
8561 /* Tie off the statement tree for this function. */
8562 DECL_SAVED_TREE (fndecl
) = pop_stmt_list (DECL_SAVED_TREE (fndecl
));
8564 /* If the function has _Cilk_spawn in front of a function call inside it
8565 i.e. it is a spawning function, then add the appropriate Cilk plus
8566 functions inside. */
8567 if (fn_contains_cilk_spawn_p (cfun
))
8568 cfun
->cilk_frame_decl
= insert_cilk_frame (fndecl
);
8570 finish_fname_decls ();
8572 /* Complain if there's just no return statement. */
8573 if (warn_return_type
8574 && TREE_CODE (TREE_TYPE (TREE_TYPE (fndecl
))) != VOID_TYPE
8575 && !current_function_returns_value
&& !current_function_returns_null
8576 /* Don't complain if we are no-return. */
8577 && !current_function_returns_abnormally
8578 /* Don't complain if we are declared noreturn. */
8579 && !TREE_THIS_VOLATILE (fndecl
)
8580 /* Don't warn for main(). */
8581 && !MAIN_NAME_P (DECL_NAME (fndecl
))
8582 /* Or if they didn't actually specify a return type. */
8583 && !C_FUNCTION_IMPLICIT_INT (fndecl
)
8584 /* Normally, with -Wreturn-type, flow will complain, but we might
8585 optimize out static functions. */
8586 && !TREE_PUBLIC (fndecl
))
8588 warning (OPT_Wreturn_type
,
8589 "no return statement in function returning non-void");
8590 TREE_NO_WARNING (fndecl
) = 1;
8593 /* Complain about parameters that are only set, but never otherwise used. */
8594 if (warn_unused_but_set_parameter
)
8598 for (decl
= DECL_ARGUMENTS (fndecl
);
8600 decl
= DECL_CHAIN (decl
))
8601 if (TREE_USED (decl
)
8602 && TREE_CODE (decl
) == PARM_DECL
8603 && !DECL_READ_P (decl
)
8605 && !DECL_ARTIFICIAL (decl
)
8606 && !TREE_NO_WARNING (decl
))
8607 warning_at (DECL_SOURCE_LOCATION (decl
),
8608 OPT_Wunused_but_set_parameter
,
8609 "parameter %qD set but not used", decl
);
8612 /* Complain about locally defined typedefs that are not used in this
8614 maybe_warn_unused_local_typedefs ();
8616 /* Store the end of the function, so that we get good line number
8617 info for the epilogue. */
8618 cfun
->function_end_locus
= input_location
;
8620 /* Finalize the ELF visibility for the function. */
8621 c_determine_visibility (fndecl
);
8623 /* For GNU C extern inline functions disregard inline limits. */
8624 if (DECL_EXTERNAL (fndecl
)
8625 && DECL_DECLARED_INLINE_P (fndecl
))
8626 DECL_DISREGARD_INLINE_LIMITS (fndecl
) = 1;
8628 /* Genericize before inlining. Delay genericizing nested functions
8629 until their parent function is genericized. Since finalizing
8630 requires GENERIC, delay that as well. */
8632 if (DECL_INITIAL (fndecl
) && DECL_INITIAL (fndecl
) != error_mark_node
8633 && !undef_nested_function
)
8635 if (!decl_function_context (fndecl
))
8637 invoke_plugin_callbacks (PLUGIN_PRE_GENERICIZE
, fndecl
);
8638 c_genericize (fndecl
);
8640 /* ??? Objc emits functions after finalizing the compilation unit.
8641 This should be cleaned up later and this conditional removed. */
8642 if (cgraph_global_info_ready
)
8644 cgraph_add_new_function (fndecl
, false);
8647 cgraph_finalize_function (fndecl
, false);
8651 /* Register this function with cgraph just far enough to get it
8652 added to our parent's nested function list. Handy, since the
8653 C front end doesn't have such a list. */
8654 (void) cgraph_get_create_node (fndecl
);
8658 if (!decl_function_context (fndecl
))
8659 undef_nested_function
= false;
8661 if (cfun
->language
!= NULL
)
8663 ggc_free (cfun
->language
);
8664 cfun
->language
= NULL
;
8667 /* We're leaving the context of this function, so zap cfun.
8668 It's still in DECL_STRUCT_FUNCTION, and we'll restore it in
8669 tree_rest_of_compilation. */
8671 current_function_decl
= NULL
;
8674 /* Check the declarations given in a for-loop for satisfying the C99
8675 constraints. If exactly one such decl is found, return it. LOC is
8676 the location of the opening parenthesis of the for loop. The last
8677 parameter allows you to control the "for loop initial declarations
8678 are only allowed in C99 mode". Normally, you should pass
8679 flag_isoc99 as that parameter. But in some cases (Objective-C
8680 foreach loop, for example) we want to run the checks in this
8681 function even if not in C99 mode, so we allow the caller to turn
8682 off the error about not being in C99 mode.
8686 check_for_loop_decls (location_t loc
, bool turn_off_iso_c99_error
)
8688 struct c_binding
*b
;
8689 tree one_decl
= NULL_TREE
;
8692 if (!turn_off_iso_c99_error
)
8694 static bool hint
= true;
8695 /* If we get here, declarations have been used in a for loop without
8696 the C99 for loop scope. This doesn't make much sense, so don't
8698 error_at (loc
, "%<for%> loop initial declarations "
8699 "are only allowed in C99 or C11 mode");
8703 "use option -std=c99, -std=gnu99, -std=c11 or -std=gnu11 "
8704 "to compile your code");
8709 /* C99 subclause 6.8.5 paragraph 3:
8711 [#3] The declaration part of a for statement shall only
8712 declare identifiers for objects having storage class auto or
8715 It isn't clear whether, in this sentence, "identifiers" binds to
8716 "shall only declare" or to "objects" - that is, whether all identifiers
8717 declared must be identifiers for objects, or whether the restriction
8718 only applies to those that are. (A question on this in comp.std.c
8719 in November 2000 received no answer.) We implement the strictest
8720 interpretation, to avoid creating an extension which later causes
8723 for (b
= current_scope
->bindings
; b
; b
= b
->prev
)
8726 tree decl
= b
->decl
;
8731 switch (TREE_CODE (decl
))
8735 location_t decl_loc
= DECL_SOURCE_LOCATION (decl
);
8736 if (TREE_STATIC (decl
))
8738 "declaration of static variable %qD in %<for%> loop "
8739 "initial declaration", decl
);
8740 else if (DECL_EXTERNAL (decl
))
8742 "declaration of %<extern%> variable %qD in %<for%> loop "
8743 "initial declaration", decl
);
8749 "%<struct %E%> declared in %<for%> loop initial "
8754 "%<union %E%> declared in %<for%> loop initial declaration",
8758 error_at (loc
, "%<enum %E%> declared in %<for%> loop "
8759 "initial declaration", id
);
8762 error_at (loc
, "declaration of non-variable "
8763 "%qD in %<for%> loop initial declaration", decl
);
8770 return n_decls
== 1 ? one_decl
: NULL_TREE
;
8773 /* Save and reinitialize the variables
8774 used during compilation of a C function. */
8777 c_push_function_context (void)
8779 struct language_function
*p
= cfun
->language
;
8780 /* cfun->language might have been already allocated by the use of
8781 -Wunused-local-typedefs. In that case, just re-use it. */
8783 cfun
->language
= p
= ggc_alloc_cleared_language_function ();
8785 p
->base
.x_stmt_tree
= c_stmt_tree
;
8786 c_stmt_tree
.x_cur_stmt_list
= vec_safe_copy (c_stmt_tree
.x_cur_stmt_list
);
8787 p
->x_break_label
= c_break_label
;
8788 p
->x_cont_label
= c_cont_label
;
8789 p
->x_switch_stack
= c_switch_stack
;
8790 p
->arg_info
= current_function_arg_info
;
8791 p
->returns_value
= current_function_returns_value
;
8792 p
->returns_null
= current_function_returns_null
;
8793 p
->returns_abnormally
= current_function_returns_abnormally
;
8794 p
->warn_about_return_type
= warn_about_return_type
;
8796 push_function_context ();
8799 /* Restore the variables used during compilation of a C function. */
8802 c_pop_function_context (void)
8804 struct language_function
*p
;
8806 pop_function_context ();
8809 /* When -Wunused-local-typedefs is in effect, cfun->languages is
8810 used to store data throughout the life time of the current cfun,
8811 So don't deallocate it. */
8812 if (!warn_unused_local_typedefs
)
8813 cfun
->language
= NULL
;
8815 if (DECL_STRUCT_FUNCTION (current_function_decl
) == 0
8816 && DECL_SAVED_TREE (current_function_decl
) == NULL_TREE
)
8818 /* Stop pointing to the local nodes about to be freed. */
8819 /* But DECL_INITIAL must remain nonzero so we know this
8820 was an actual function definition. */
8821 DECL_INITIAL (current_function_decl
) = error_mark_node
;
8822 DECL_ARGUMENTS (current_function_decl
) = 0;
8825 c_stmt_tree
= p
->base
.x_stmt_tree
;
8826 p
->base
.x_stmt_tree
.x_cur_stmt_list
= NULL
;
8827 c_break_label
= p
->x_break_label
;
8828 c_cont_label
= p
->x_cont_label
;
8829 c_switch_stack
= p
->x_switch_stack
;
8830 current_function_arg_info
= p
->arg_info
;
8831 current_function_returns_value
= p
->returns_value
;
8832 current_function_returns_null
= p
->returns_null
;
8833 current_function_returns_abnormally
= p
->returns_abnormally
;
8834 warn_about_return_type
= p
->warn_about_return_type
;
8837 /* The functions below are required for functionality of doing
8838 function at once processing in the C front end. Currently these
8839 functions are not called from anywhere in the C front end, but as
8840 these changes continue, that will change. */
8842 /* Returns the stmt_tree (if any) to which statements are currently
8843 being added. If there is no active statement-tree, NULL is
8847 current_stmt_tree (void)
8849 return &c_stmt_tree
;
8852 /* Return the global value of T as a symbol. */
8855 identifier_global_value (tree t
)
8857 struct c_binding
*b
;
8859 for (b
= I_SYMBOL_BINDING (t
); b
; b
= b
->shadowed
)
8860 if (B_IN_FILE_SCOPE (b
) || B_IN_EXTERNAL_SCOPE (b
))
8866 /* In C, the only C-linkage public declaration is at file scope. */
8869 c_linkage_bindings (tree name
)
8871 return identifier_global_value (name
);
8874 /* Record a builtin type for C. If NAME is non-NULL, it is the name used;
8875 otherwise the name is found in ridpointers from RID_INDEX. */
8878 record_builtin_type (enum rid rid_index
, const char *name
, tree type
)
8882 id
= ridpointers
[(int) rid_index
];
8884 id
= get_identifier (name
);
8885 decl
= build_decl (UNKNOWN_LOCATION
, TYPE_DECL
, id
, type
);
8887 if (debug_hooks
->type_decl
)
8888 debug_hooks
->type_decl (decl
, false);
8891 /* Build the void_list_node (void_type_node having been created). */
8893 build_void_list_node (void)
8895 tree t
= build_tree_list (NULL_TREE
, void_type_node
);
8899 /* Return a c_parm structure with the given SPECS, ATTRS and DECLARATOR. */
8902 build_c_parm (struct c_declspecs
*specs
, tree attrs
,
8903 struct c_declarator
*declarator
)
8905 struct c_parm
*ret
= XOBNEW (&parser_obstack
, struct c_parm
);
8908 ret
->declarator
= declarator
;
8912 /* Return a declarator with nested attributes. TARGET is the inner
8913 declarator to which these attributes apply. ATTRS are the
8916 struct c_declarator
*
8917 build_attrs_declarator (tree attrs
, struct c_declarator
*target
)
8919 struct c_declarator
*ret
= XOBNEW (&parser_obstack
, struct c_declarator
);
8920 ret
->kind
= cdk_attrs
;
8921 ret
->declarator
= target
;
8922 ret
->u
.attrs
= attrs
;
8926 /* Return a declarator for a function with arguments specified by ARGS
8927 and return type specified by TARGET. */
8929 struct c_declarator
*
8930 build_function_declarator (struct c_arg_info
*args
,
8931 struct c_declarator
*target
)
8933 struct c_declarator
*ret
= XOBNEW (&parser_obstack
, struct c_declarator
);
8934 ret
->kind
= cdk_function
;
8935 ret
->declarator
= target
;
8936 ret
->u
.arg_info
= args
;
8940 /* Return a declarator for the identifier IDENT (which may be
8941 NULL_TREE for an abstract declarator). */
8943 struct c_declarator
*
8944 build_id_declarator (tree ident
)
8946 struct c_declarator
*ret
= XOBNEW (&parser_obstack
, struct c_declarator
);
8948 ret
->declarator
= 0;
8950 /* Default value - may get reset to a more precise location. */
8951 ret
->id_loc
= input_location
;
8955 /* Return something to represent absolute declarators containing a *.
8956 TARGET is the absolute declarator that the * contains.
8957 TYPE_QUALS_ATTRS is a structure for type qualifiers and attributes
8958 to apply to the pointer type. */
8960 struct c_declarator
*
8961 make_pointer_declarator (struct c_declspecs
*type_quals_attrs
,
8962 struct c_declarator
*target
)
8966 struct c_declarator
*itarget
= target
;
8967 struct c_declarator
*ret
= XOBNEW (&parser_obstack
, struct c_declarator
);
8968 if (type_quals_attrs
)
8970 attrs
= type_quals_attrs
->attrs
;
8971 quals
= quals_from_declspecs (type_quals_attrs
);
8972 if (attrs
!= NULL_TREE
)
8973 itarget
= build_attrs_declarator (attrs
, target
);
8975 ret
->kind
= cdk_pointer
;
8976 ret
->declarator
= itarget
;
8977 ret
->u
.pointer_quals
= quals
;
8981 /* Return a pointer to a structure for an empty list of declaration
8984 struct c_declspecs
*
8985 build_null_declspecs (void)
8987 struct c_declspecs
*ret
= XOBNEW (&parser_obstack
, struct c_declspecs
);
8988 memset (&ret
->locations
, 0, cdw_number_of_elements
);
8993 ret
->align_log
= -1;
8994 ret
->typespec_word
= cts_none
;
8995 ret
->storage_class
= csc_none
;
8996 ret
->expr_const_operands
= true;
8997 ret
->declspecs_seen_p
= false;
8998 ret
->typespec_kind
= ctsk_none
;
8999 ret
->non_sc_seen_p
= false;
9000 ret
->typedef_p
= false;
9001 ret
->explicit_signed_p
= false;
9002 ret
->deprecated_p
= false;
9003 ret
->default_int_p
= false;
9004 ret
->long_p
= false;
9005 ret
->long_long_p
= false;
9006 ret
->short_p
= false;
9007 ret
->signed_p
= false;
9008 ret
->unsigned_p
= false;
9009 ret
->complex_p
= false;
9010 ret
->inline_p
= false;
9011 ret
->noreturn_p
= false;
9012 ret
->thread_p
= false;
9013 ret
->thread_gnu_p
= false;
9014 ret
->const_p
= false;
9015 ret
->volatile_p
= false;
9016 ret
->atomic_p
= false;
9017 ret
->restrict_p
= false;
9018 ret
->saturating_p
= false;
9019 ret
->alignas_p
= false;
9020 ret
->address_space
= ADDR_SPACE_GENERIC
;
9024 /* Add the address space ADDRSPACE to the declaration specifiers
9025 SPECS, returning SPECS. */
9027 struct c_declspecs
*
9028 declspecs_add_addrspace (source_location location
,
9029 struct c_declspecs
*specs
, addr_space_t as
)
9031 specs
->non_sc_seen_p
= true;
9032 specs
->declspecs_seen_p
= true;
9034 if (!ADDR_SPACE_GENERIC_P (specs
->address_space
)
9035 && specs
->address_space
!= as
)
9036 error ("incompatible address space qualifiers %qs and %qs",
9037 c_addr_space_name (as
),
9038 c_addr_space_name (specs
->address_space
));
9041 specs
->address_space
= as
;
9042 specs
->locations
[cdw_address_space
] = location
;
9047 /* Add the type qualifier QUAL to the declaration specifiers SPECS,
9050 struct c_declspecs
*
9051 declspecs_add_qual (source_location loc
,
9052 struct c_declspecs
*specs
, tree qual
)
9056 specs
->non_sc_seen_p
= true;
9057 specs
->declspecs_seen_p
= true;
9058 gcc_assert (TREE_CODE (qual
) == IDENTIFIER_NODE
9059 && C_IS_RESERVED_WORD (qual
));
9060 i
= C_RID_CODE (qual
);
9064 dupe
= specs
->const_p
;
9065 specs
->const_p
= true;
9066 specs
->locations
[cdw_const
] = loc
;
9069 dupe
= specs
->volatile_p
;
9070 specs
->volatile_p
= true;
9071 specs
->locations
[cdw_volatile
] = loc
;
9074 dupe
= specs
->restrict_p
;
9075 specs
->restrict_p
= true;
9076 specs
->locations
[cdw_restrict
] = loc
;
9079 dupe
= specs
->atomic_p
;
9080 specs
->atomic_p
= true;
9085 if (dupe
&& !flag_isoc99
)
9086 pedwarn (loc
, OPT_Wpedantic
, "duplicate %qE", qual
);
9090 /* Add the type specifier TYPE to the declaration specifiers SPECS,
9093 struct c_declspecs
*
9094 declspecs_add_type (location_t loc
, struct c_declspecs
*specs
,
9095 struct c_typespec spec
)
9097 tree type
= spec
.spec
;
9098 specs
->non_sc_seen_p
= true;
9099 specs
->declspecs_seen_p
= true;
9100 specs
->typespec_kind
= spec
.kind
;
9101 if (TREE_DEPRECATED (type
))
9102 specs
->deprecated_p
= true;
9104 /* Handle type specifier keywords. */
9105 if (TREE_CODE (type
) == IDENTIFIER_NODE
9106 && C_IS_RESERVED_WORD (type
)
9107 && C_RID_CODE (type
) != RID_CXX_COMPAT_WARN
)
9109 enum rid i
= C_RID_CODE (type
);
9112 error_at (loc
, "two or more data types in declaration specifiers");
9115 if ((int) i
<= (int) RID_LAST_MODIFIER
)
9117 /* "long", "short", "signed", "unsigned", "_Complex" or "_Sat". */
9122 if (specs
->long_long_p
)
9124 error_at (loc
, "%<long long long%> is too long for GCC");
9129 if (specs
->typespec_word
== cts_double
)
9132 ("both %<long long%> and %<double%> in "
9133 "declaration specifiers"));
9136 pedwarn_c90 (loc
, OPT_Wlong_long
,
9137 "ISO C90 does not support %<long long%>");
9138 specs
->long_long_p
= 1;
9139 specs
->locations
[cdw_long_long
] = loc
;
9144 ("both %<long%> and %<short%> in "
9145 "declaration specifiers"));
9146 else if (specs
->typespec_word
== cts_auto_type
)
9148 ("both %<long%> and %<__auto_type%> in "
9149 "declaration specifiers"));
9150 else if (specs
->typespec_word
== cts_void
)
9152 ("both %<long%> and %<void%> in "
9153 "declaration specifiers"));
9154 else if (specs
->typespec_word
== cts_int128
)
9156 ("both %<long%> and %<__int128%> in "
9157 "declaration specifiers"));
9158 else if (specs
->typespec_word
== cts_bool
)
9160 ("both %<long%> and %<_Bool%> in "
9161 "declaration specifiers"));
9162 else if (specs
->typespec_word
== cts_char
)
9164 ("both %<long%> and %<char%> in "
9165 "declaration specifiers"));
9166 else if (specs
->typespec_word
== cts_float
)
9168 ("both %<long%> and %<float%> in "
9169 "declaration specifiers"));
9170 else if (specs
->typespec_word
== cts_dfloat32
)
9172 ("both %<long%> and %<_Decimal32%> in "
9173 "declaration specifiers"));
9174 else if (specs
->typespec_word
== cts_dfloat64
)
9176 ("both %<long%> and %<_Decimal64%> in "
9177 "declaration specifiers"));
9178 else if (specs
->typespec_word
== cts_dfloat128
)
9180 ("both %<long%> and %<_Decimal128%> in "
9181 "declaration specifiers"));
9184 specs
->long_p
= true;
9185 specs
->locations
[cdw_long
] = loc
;
9189 dupe
= specs
->short_p
;
9192 ("both %<long%> and %<short%> in "
9193 "declaration specifiers"));
9194 else if (specs
->typespec_word
== cts_auto_type
)
9196 ("both %<short%> and %<__auto_type%> in "
9197 "declaration specifiers"));
9198 else if (specs
->typespec_word
== cts_void
)
9200 ("both %<short%> and %<void%> in "
9201 "declaration specifiers"));
9202 else if (specs
->typespec_word
== cts_int128
)
9204 ("both %<short%> and %<__int128%> in "
9205 "declaration specifiers"));
9206 else if (specs
->typespec_word
== cts_bool
)
9208 ("both %<short%> and %<_Bool%> in "
9209 "declaration specifiers"));
9210 else if (specs
->typespec_word
== cts_char
)
9212 ("both %<short%> and %<char%> in "
9213 "declaration specifiers"));
9214 else if (specs
->typespec_word
== cts_float
)
9216 ("both %<short%> and %<float%> in "
9217 "declaration specifiers"));
9218 else if (specs
->typespec_word
== cts_double
)
9220 ("both %<short%> and %<double%> in "
9221 "declaration specifiers"));
9222 else if (specs
->typespec_word
== cts_dfloat32
)
9224 ("both %<short%> and %<_Decimal32%> in "
9225 "declaration specifiers"));
9226 else if (specs
->typespec_word
== cts_dfloat64
)
9228 ("both %<short%> and %<_Decimal64%> in "
9229 "declaration specifiers"));
9230 else if (specs
->typespec_word
== cts_dfloat128
)
9232 ("both %<short%> and %<_Decimal128%> in "
9233 "declaration specifiers"));
9236 specs
->short_p
= true;
9237 specs
->locations
[cdw_short
] = loc
;
9241 dupe
= specs
->signed_p
;
9242 if (specs
->unsigned_p
)
9244 ("both %<signed%> and %<unsigned%> in "
9245 "declaration specifiers"));
9246 else if (specs
->typespec_word
== cts_auto_type
)
9248 ("both %<signed%> and %<__auto_type%> in "
9249 "declaration specifiers"));
9250 else if (specs
->typespec_word
== cts_void
)
9252 ("both %<signed%> and %<void%> in "
9253 "declaration specifiers"));
9254 else if (specs
->typespec_word
== cts_bool
)
9256 ("both %<signed%> and %<_Bool%> in "
9257 "declaration specifiers"));
9258 else if (specs
->typespec_word
== cts_float
)
9260 ("both %<signed%> and %<float%> in "
9261 "declaration specifiers"));
9262 else if (specs
->typespec_word
== cts_double
)
9264 ("both %<signed%> and %<double%> in "
9265 "declaration specifiers"));
9266 else if (specs
->typespec_word
== cts_dfloat32
)
9268 ("both %<signed%> and %<_Decimal32%> in "
9269 "declaration specifiers"));
9270 else if (specs
->typespec_word
== cts_dfloat64
)
9272 ("both %<signed%> and %<_Decimal64%> in "
9273 "declaration specifiers"));
9274 else if (specs
->typespec_word
== cts_dfloat128
)
9276 ("both %<signed%> and %<_Decimal128%> in "
9277 "declaration specifiers"));
9280 specs
->signed_p
= true;
9281 specs
->locations
[cdw_signed
] = loc
;
9285 dupe
= specs
->unsigned_p
;
9286 if (specs
->signed_p
)
9288 ("both %<signed%> and %<unsigned%> in "
9289 "declaration specifiers"));
9290 else if (specs
->typespec_word
== cts_auto_type
)
9292 ("both %<unsigned%> and %<__auto_type%> in "
9293 "declaration specifiers"));
9294 else if (specs
->typespec_word
== cts_void
)
9296 ("both %<unsigned%> and %<void%> in "
9297 "declaration specifiers"));
9298 else if (specs
->typespec_word
== cts_bool
)
9300 ("both %<unsigned%> and %<_Bool%> in "
9301 "declaration specifiers"));
9302 else if (specs
->typespec_word
== cts_float
)
9304 ("both %<unsigned%> and %<float%> in "
9305 "declaration specifiers"));
9306 else if (specs
->typespec_word
== cts_double
)
9308 ("both %<unsigned%> and %<double%> in "
9309 "declaration specifiers"));
9310 else if (specs
->typespec_word
== cts_dfloat32
)
9312 ("both %<unsigned%> and %<_Decimal32%> in "
9313 "declaration specifiers"));
9314 else if (specs
->typespec_word
== cts_dfloat64
)
9316 ("both %<unsigned%> and %<_Decimal64%> in "
9317 "declaration specifiers"));
9318 else if (specs
->typespec_word
== cts_dfloat128
)
9320 ("both %<unsigned%> and %<_Decimal128%> in "
9321 "declaration specifiers"));
9324 specs
->unsigned_p
= true;
9325 specs
->locations
[cdw_unsigned
] = loc
;
9329 dupe
= specs
->complex_p
;
9330 if (!flag_isoc99
&& !in_system_header_at (loc
))
9331 pedwarn (loc
, OPT_Wpedantic
,
9332 "ISO C90 does not support complex types");
9333 if (specs
->typespec_word
== cts_auto_type
)
9335 ("both %<complex%> and %<__auto_type%> in "
9336 "declaration specifiers"));
9337 else if (specs
->typespec_word
== cts_void
)
9339 ("both %<complex%> and %<void%> in "
9340 "declaration specifiers"));
9341 else if (specs
->typespec_word
== cts_bool
)
9343 ("both %<complex%> and %<_Bool%> in "
9344 "declaration specifiers"));
9345 else if (specs
->typespec_word
== cts_dfloat32
)
9347 ("both %<complex%> and %<_Decimal32%> in "
9348 "declaration specifiers"));
9349 else if (specs
->typespec_word
== cts_dfloat64
)
9351 ("both %<complex%> and %<_Decimal64%> in "
9352 "declaration specifiers"));
9353 else if (specs
->typespec_word
== cts_dfloat128
)
9355 ("both %<complex%> and %<_Decimal128%> in "
9356 "declaration specifiers"));
9357 else if (specs
->typespec_word
== cts_fract
)
9359 ("both %<complex%> and %<_Fract%> in "
9360 "declaration specifiers"));
9361 else if (specs
->typespec_word
== cts_accum
)
9363 ("both %<complex%> and %<_Accum%> in "
9364 "declaration specifiers"));
9365 else if (specs
->saturating_p
)
9367 ("both %<complex%> and %<_Sat%> in "
9368 "declaration specifiers"));
9371 specs
->complex_p
= true;
9372 specs
->locations
[cdw_complex
] = loc
;
9376 dupe
= specs
->saturating_p
;
9377 pedwarn (loc
, OPT_Wpedantic
,
9378 "ISO C does not support saturating types");
9379 if (specs
->typespec_word
== cts_int128
)
9382 ("both %<_Sat%> and %<__int128%> in "
9383 "declaration specifiers"));
9385 else if (specs
->typespec_word
== cts_auto_type
)
9387 ("both %<_Sat%> and %<__auto_type%> in "
9388 "declaration specifiers"));
9389 else if (specs
->typespec_word
== cts_void
)
9391 ("both %<_Sat%> and %<void%> in "
9392 "declaration specifiers"));
9393 else if (specs
->typespec_word
== cts_bool
)
9395 ("both %<_Sat%> and %<_Bool%> in "
9396 "declaration specifiers"));
9397 else if (specs
->typespec_word
== cts_char
)
9399 ("both %<_Sat%> and %<char%> in "
9400 "declaration specifiers"));
9401 else if (specs
->typespec_word
== cts_int
)
9403 ("both %<_Sat%> and %<int%> in "
9404 "declaration specifiers"));
9405 else if (specs
->typespec_word
== cts_float
)
9407 ("both %<_Sat%> and %<float%> in "
9408 "declaration specifiers"));
9409 else if (specs
->typespec_word
== cts_double
)
9411 ("both %<_Sat%> and %<double%> in "
9412 "declaration specifiers"));
9413 else if (specs
->typespec_word
== cts_dfloat32
)
9415 ("both %<_Sat%> and %<_Decimal32%> in "
9416 "declaration specifiers"));
9417 else if (specs
->typespec_word
== cts_dfloat64
)
9419 ("both %<_Sat%> and %<_Decimal64%> in "
9420 "declaration specifiers"));
9421 else if (specs
->typespec_word
== cts_dfloat128
)
9423 ("both %<_Sat%> and %<_Decimal128%> in "
9424 "declaration specifiers"));
9425 else if (specs
->complex_p
)
9427 ("both %<_Sat%> and %<complex%> in "
9428 "declaration specifiers"));
9431 specs
->saturating_p
= true;
9432 specs
->locations
[cdw_saturating
] = loc
;
9440 error_at (loc
, "duplicate %qE", type
);
9446 /* "void", "_Bool", "char", "int", "float", "double", "_Decimal32",
9447 "__int128", "_Decimal64", "_Decimal128", "_Fract", "_Accum" or
9449 if (specs
->typespec_word
!= cts_none
)
9452 "two or more data types in declaration specifiers");
9460 ("both %<long%> and %<__auto_type%> in "
9461 "declaration specifiers"));
9462 else if (specs
->short_p
)
9464 ("both %<short%> and %<__auto_type%> in "
9465 "declaration specifiers"));
9466 else if (specs
->signed_p
)
9468 ("both %<signed%> and %<__auto_type%> in "
9469 "declaration specifiers"));
9470 else if (specs
->unsigned_p
)
9472 ("both %<unsigned%> and %<__auto_type%> in "
9473 "declaration specifiers"));
9474 else if (specs
->complex_p
)
9476 ("both %<complex%> and %<__auto_type%> in "
9477 "declaration specifiers"));
9478 else if (specs
->saturating_p
)
9480 ("both %<_Sat%> and %<__auto_type%> in "
9481 "declaration specifiers"));
9484 specs
->typespec_word
= cts_auto_type
;
9485 specs
->locations
[cdw_typespec
] = loc
;
9489 if (int128_integer_type_node
== NULL_TREE
)
9491 error_at (loc
, "%<__int128%> is not supported for this target");
9494 if (!in_system_header_at (input_location
))
9495 pedwarn (loc
, OPT_Wpedantic
,
9496 "ISO C does not support %<__int128%> type");
9500 ("both %<__int128%> and %<long%> in "
9501 "declaration specifiers"));
9502 else if (specs
->saturating_p
)
9504 ("both %<_Sat%> and %<__int128%> in "
9505 "declaration specifiers"));
9506 else if (specs
->short_p
)
9508 ("both %<__int128%> and %<short%> in "
9509 "declaration specifiers"));
9512 specs
->typespec_word
= cts_int128
;
9513 specs
->locations
[cdw_typespec
] = loc
;
9519 ("both %<long%> and %<void%> in "
9520 "declaration specifiers"));
9521 else if (specs
->short_p
)
9523 ("both %<short%> and %<void%> in "
9524 "declaration specifiers"));
9525 else if (specs
->signed_p
)
9527 ("both %<signed%> and %<void%> in "
9528 "declaration specifiers"));
9529 else if (specs
->unsigned_p
)
9531 ("both %<unsigned%> and %<void%> in "
9532 "declaration specifiers"));
9533 else if (specs
->complex_p
)
9535 ("both %<complex%> and %<void%> in "
9536 "declaration specifiers"));
9537 else if (specs
->saturating_p
)
9539 ("both %<_Sat%> and %<void%> in "
9540 "declaration specifiers"));
9543 specs
->typespec_word
= cts_void
;
9544 specs
->locations
[cdw_typespec
] = loc
;
9550 ("both %<long%> and %<_Bool%> in "
9551 "declaration specifiers"));
9552 else if (specs
->short_p
)
9554 ("both %<short%> and %<_Bool%> in "
9555 "declaration specifiers"));
9556 else if (specs
->signed_p
)
9558 ("both %<signed%> and %<_Bool%> in "
9559 "declaration specifiers"));
9560 else if (specs
->unsigned_p
)
9562 ("both %<unsigned%> and %<_Bool%> in "
9563 "declaration specifiers"));
9564 else if (specs
->complex_p
)
9566 ("both %<complex%> and %<_Bool%> in "
9567 "declaration specifiers"));
9568 else if (specs
->saturating_p
)
9570 ("both %<_Sat%> and %<_Bool%> in "
9571 "declaration specifiers"));
9574 specs
->typespec_word
= cts_bool
;
9575 specs
->locations
[cdw_typespec
] = loc
;
9581 ("both %<long%> and %<char%> in "
9582 "declaration specifiers"));
9583 else if (specs
->short_p
)
9585 ("both %<short%> and %<char%> in "
9586 "declaration specifiers"));
9587 else if (specs
->saturating_p
)
9589 ("both %<_Sat%> and %<char%> in "
9590 "declaration specifiers"));
9593 specs
->typespec_word
= cts_char
;
9594 specs
->locations
[cdw_typespec
] = loc
;
9598 if (specs
->saturating_p
)
9600 ("both %<_Sat%> and %<int%> in "
9601 "declaration specifiers"));
9604 specs
->typespec_word
= cts_int
;
9605 specs
->locations
[cdw_typespec
] = loc
;
9611 ("both %<long%> and %<float%> in "
9612 "declaration specifiers"));
9613 else if (specs
->short_p
)
9615 ("both %<short%> and %<float%> in "
9616 "declaration specifiers"));
9617 else if (specs
->signed_p
)
9619 ("both %<signed%> and %<float%> in "
9620 "declaration specifiers"));
9621 else if (specs
->unsigned_p
)
9623 ("both %<unsigned%> and %<float%> in "
9624 "declaration specifiers"));
9625 else if (specs
->saturating_p
)
9627 ("both %<_Sat%> and %<float%> in "
9628 "declaration specifiers"));
9631 specs
->typespec_word
= cts_float
;
9632 specs
->locations
[cdw_typespec
] = loc
;
9636 if (specs
->long_long_p
)
9638 ("both %<long long%> and %<double%> in "
9639 "declaration specifiers"));
9640 else if (specs
->short_p
)
9642 ("both %<short%> and %<double%> in "
9643 "declaration specifiers"));
9644 else if (specs
->signed_p
)
9646 ("both %<signed%> and %<double%> in "
9647 "declaration specifiers"));
9648 else if (specs
->unsigned_p
)
9650 ("both %<unsigned%> and %<double%> in "
9651 "declaration specifiers"));
9652 else if (specs
->saturating_p
)
9654 ("both %<_Sat%> and %<double%> in "
9655 "declaration specifiers"));
9658 specs
->typespec_word
= cts_double
;
9659 specs
->locations
[cdw_typespec
] = loc
;
9667 if (i
== RID_DFLOAT32
)
9669 else if (i
== RID_DFLOAT64
)
9672 str
= "_Decimal128";
9673 if (specs
->long_long_p
)
9675 ("both %<long long%> and %<%s%> in "
9676 "declaration specifiers"),
9680 ("both %<long%> and %<%s%> in "
9681 "declaration specifiers"),
9683 else if (specs
->short_p
)
9685 ("both %<short%> and %<%s%> in "
9686 "declaration specifiers"),
9688 else if (specs
->signed_p
)
9690 ("both %<signed%> and %<%s%> in "
9691 "declaration specifiers"),
9693 else if (specs
->unsigned_p
)
9695 ("both %<unsigned%> and %<%s%> in "
9696 "declaration specifiers"),
9698 else if (specs
->complex_p
)
9700 ("both %<complex%> and %<%s%> in "
9701 "declaration specifiers"),
9703 else if (specs
->saturating_p
)
9705 ("both %<_Sat%> and %<%s%> in "
9706 "declaration specifiers"),
9708 else if (i
== RID_DFLOAT32
)
9709 specs
->typespec_word
= cts_dfloat32
;
9710 else if (i
== RID_DFLOAT64
)
9711 specs
->typespec_word
= cts_dfloat64
;
9713 specs
->typespec_word
= cts_dfloat128
;
9714 specs
->locations
[cdw_typespec
] = loc
;
9716 if (!targetm
.decimal_float_supported_p ())
9718 ("decimal floating point not supported "
9719 "for this target"));
9720 pedwarn (loc
, OPT_Wpedantic
,
9721 "ISO C does not support decimal floating point");
9731 if (specs
->complex_p
)
9733 ("both %<complex%> and %<%s%> in "
9734 "declaration specifiers"),
9736 else if (i
== RID_FRACT
)
9737 specs
->typespec_word
= cts_fract
;
9739 specs
->typespec_word
= cts_accum
;
9740 specs
->locations
[cdw_typespec
] = loc
;
9742 if (!targetm
.fixed_point_supported_p ())
9744 "fixed-point types not supported for this target");
9745 pedwarn (loc
, OPT_Wpedantic
,
9746 "ISO C does not support fixed-point types");
9749 /* ObjC reserved word "id", handled below. */
9755 /* Now we have a typedef (a TYPE_DECL node), an identifier (some
9756 form of ObjC type, cases such as "int" and "long" being handled
9757 above), a TYPE (struct, union, enum and typeof specifiers) or an
9758 ERROR_MARK. In none of these cases may there have previously
9759 been any type specifiers. */
9760 if (specs
->type
|| specs
->typespec_word
!= cts_none
9761 || specs
->long_p
|| specs
->short_p
|| specs
->signed_p
9762 || specs
->unsigned_p
|| specs
->complex_p
)
9763 error_at (loc
, "two or more data types in declaration specifiers");
9764 else if (TREE_CODE (type
) == TYPE_DECL
)
9766 if (TREE_TYPE (type
) == error_mark_node
)
9767 ; /* Allow the type to default to int to avoid cascading errors. */
9770 specs
->type
= TREE_TYPE (type
);
9771 specs
->decl_attr
= DECL_ATTRIBUTES (type
);
9772 specs
->typedef_p
= true;
9773 specs
->explicit_signed_p
= C_TYPEDEF_EXPLICITLY_SIGNED (type
);
9774 specs
->locations
[cdw_typedef
] = loc
;
9776 /* If this typedef name is defined in a struct, then a C++
9777 lookup would return a different value. */
9779 && I_SYMBOL_BINDING (DECL_NAME (type
))->in_struct
)
9780 warning_at (loc
, OPT_Wc___compat
,
9781 "C++ lookup of %qD would return a field, not a type",
9784 /* If we are parsing a struct, record that a struct field
9786 if (warn_cxx_compat
&& struct_parse_info
!= NULL
)
9787 struct_parse_info
->typedefs_seen
.safe_push (type
);
9790 else if (TREE_CODE (type
) == IDENTIFIER_NODE
)
9792 tree t
= lookup_name (type
);
9793 if (!t
|| TREE_CODE (t
) != TYPE_DECL
)
9794 error_at (loc
, "%qE fails to be a typedef or built in type", type
);
9795 else if (TREE_TYPE (t
) == error_mark_node
)
9799 specs
->type
= TREE_TYPE (t
);
9800 specs
->locations
[cdw_typespec
] = loc
;
9805 if (TREE_CODE (type
) != ERROR_MARK
&& spec
.kind
== ctsk_typeof
)
9807 specs
->typedef_p
= true;
9808 specs
->locations
[cdw_typedef
] = loc
;
9812 specs
->expr
= build2 (COMPOUND_EXPR
, TREE_TYPE (spec
.expr
),
9813 specs
->expr
, spec
.expr
);
9815 specs
->expr
= spec
.expr
;
9816 specs
->expr_const_operands
&= spec
.expr_const_operands
;
9825 /* Add the storage class specifier or function specifier SCSPEC to the
9826 declaration specifiers SPECS, returning SPECS. */
9828 struct c_declspecs
*
9829 declspecs_add_scspec (source_location loc
,
9830 struct c_declspecs
*specs
,
9834 enum c_storage_class n
= csc_none
;
9836 specs
->declspecs_seen_p
= true;
9837 gcc_assert (TREE_CODE (scspec
) == IDENTIFIER_NODE
9838 && C_IS_RESERVED_WORD (scspec
));
9839 i
= C_RID_CODE (scspec
);
9840 if (specs
->non_sc_seen_p
)
9841 warning (OPT_Wold_style_declaration
,
9842 "%qE is not at beginning of declaration", scspec
);
9846 /* C99 permits duplicate inline. Although of doubtful utility,
9847 it seems simplest to permit it in gnu89 mode as well, as
9848 there is also little utility in maintaining this as a
9849 difference between gnu89 and C99 inline. */
9851 specs
->inline_p
= true;
9852 specs
->locations
[cdw_inline
] = loc
;
9855 /* Duplicate _Noreturn is permitted. */
9857 specs
->noreturn_p
= true;
9858 specs
->locations
[cdw_noreturn
] = loc
;
9861 dupe
= specs
->thread_p
;
9862 if (specs
->storage_class
== csc_auto
)
9863 error ("%qE used with %<auto%>", scspec
);
9864 else if (specs
->storage_class
== csc_register
)
9865 error ("%qE used with %<register%>", scspec
);
9866 else if (specs
->storage_class
== csc_typedef
)
9867 error ("%qE used with %<typedef%>", scspec
);
9870 specs
->thread_p
= true;
9871 specs
->thread_gnu_p
= (strcmp (IDENTIFIER_POINTER (scspec
),
9873 /* A diagnostic is not required for the use of this
9874 identifier in the implementation namespace; only diagnose
9875 it for the C11 spelling because of existing code using
9876 the other spelling. */
9877 if (!flag_isoc11
&& !specs
->thread_gnu_p
)
9880 pedwarn (loc
, OPT_Wpedantic
,
9881 "ISO C99 does not support %qE", scspec
);
9883 pedwarn (loc
, OPT_Wpedantic
,
9884 "ISO C90 does not support %qE", scspec
);
9886 specs
->locations
[cdw_thread
] = loc
;
9894 /* Diagnose "__thread extern". */
9895 if (specs
->thread_p
&& specs
->thread_gnu_p
)
9896 error ("%<__thread%> before %<extern%>");
9903 /* Diagnose "__thread static". */
9904 if (specs
->thread_p
&& specs
->thread_gnu_p
)
9905 error ("%<__thread%> before %<static%>");
9913 if (n
!= csc_none
&& n
== specs
->storage_class
)
9917 if (i
== RID_THREAD
)
9918 error ("duplicate %<_Thread_local%> or %<__thread%>");
9920 error ("duplicate %qE", scspec
);
9924 if (specs
->storage_class
!= csc_none
&& n
!= specs
->storage_class
)
9926 error ("multiple storage classes in declaration specifiers");
9930 specs
->storage_class
= n
;
9931 specs
->locations
[cdw_storage_class
] = loc
;
9932 if (n
!= csc_extern
&& n
!= csc_static
&& specs
->thread_p
)
9934 error ("%qs used with %qE",
9935 specs
->thread_gnu_p
? "__thread" : "_Thread_local",
9937 specs
->thread_p
= false;
9944 /* Add the attributes ATTRS to the declaration specifiers SPECS,
9947 struct c_declspecs
*
9948 declspecs_add_attrs (source_location loc
, struct c_declspecs
*specs
, tree attrs
)
9950 specs
->attrs
= chainon (attrs
, specs
->attrs
);
9951 specs
->locations
[cdw_attributes
] = loc
;
9952 specs
->declspecs_seen_p
= true;
9956 /* Add an _Alignas specifier (expression ALIGN, or type whose
9957 alignment is ALIGN) to the declaration specifiers SPECS, returning
9959 struct c_declspecs
*
9960 declspecs_add_alignas (source_location loc
,
9961 struct c_declspecs
*specs
, tree align
)
9964 specs
->alignas_p
= true;
9965 specs
->locations
[cdw_alignas
] = loc
;
9966 if (align
== error_mark_node
)
9968 align_log
= check_user_alignment (align
, true);
9969 if (align_log
> specs
->align_log
)
9970 specs
->align_log
= align_log
;
9974 /* Combine "long", "short", "signed", "unsigned" and "_Complex" type
9975 specifiers with any other type specifier to determine the resulting
9976 type. This is where ISO C checks on complex types are made, since
9977 "_Complex long" is a prefix of the valid ISO C type "_Complex long
9980 struct c_declspecs
*
9981 finish_declspecs (struct c_declspecs
*specs
)
9983 /* If a type was specified as a whole, we have no modifiers and are
9985 if (specs
->type
!= NULL_TREE
)
9987 gcc_assert (!specs
->long_p
&& !specs
->long_long_p
&& !specs
->short_p
9988 && !specs
->signed_p
&& !specs
->unsigned_p
9989 && !specs
->complex_p
);
9991 /* Set a dummy type. */
9992 if (TREE_CODE (specs
->type
) == ERROR_MARK
)
9993 specs
->type
= integer_type_node
;
9997 /* If none of "void", "_Bool", "char", "int", "float" or "double"
9998 has been specified, treat it as "int" unless "_Complex" is
9999 present and there are no other specifiers. If we just have
10000 "_Complex", it is equivalent to "_Complex double", but e.g.
10001 "_Complex short" is equivalent to "_Complex short int". */
10002 if (specs
->typespec_word
== cts_none
)
10004 if (specs
->saturating_p
)
10006 error_at (specs
->locations
[cdw_saturating
],
10007 "%<_Sat%> is used without %<_Fract%> or %<_Accum%>");
10008 if (!targetm
.fixed_point_supported_p ())
10009 error_at (specs
->locations
[cdw_saturating
],
10010 "fixed-point types not supported for this target");
10011 specs
->typespec_word
= cts_fract
;
10013 else if (specs
->long_p
|| specs
->short_p
10014 || specs
->signed_p
|| specs
->unsigned_p
)
10016 specs
->typespec_word
= cts_int
;
10018 else if (specs
->complex_p
)
10020 specs
->typespec_word
= cts_double
;
10021 pedwarn (specs
->locations
[cdw_complex
], OPT_Wpedantic
,
10022 "ISO C does not support plain %<complex%> meaning "
10023 "%<double complex%>");
10027 specs
->typespec_word
= cts_int
;
10028 specs
->default_int_p
= true;
10029 /* We don't diagnose this here because grokdeclarator will
10030 give more specific diagnostics according to whether it is
10031 a function definition. */
10035 /* If "signed" was specified, record this to distinguish "int" and
10036 "signed int" in the case of a bit-field with
10037 -funsigned-bitfields. */
10038 specs
->explicit_signed_p
= specs
->signed_p
;
10040 /* Now compute the actual type. */
10041 switch (specs
->typespec_word
)
10043 case cts_auto_type
:
10044 gcc_assert (!specs
->long_p
&& !specs
->short_p
10045 && !specs
->signed_p
&& !specs
->unsigned_p
10046 && !specs
->complex_p
);
10047 /* Type to be filled in later. */
10050 gcc_assert (!specs
->long_p
&& !specs
->short_p
10051 && !specs
->signed_p
&& !specs
->unsigned_p
10052 && !specs
->complex_p
);
10053 specs
->type
= void_type_node
;
10056 gcc_assert (!specs
->long_p
&& !specs
->short_p
10057 && !specs
->signed_p
&& !specs
->unsigned_p
10058 && !specs
->complex_p
);
10059 specs
->type
= boolean_type_node
;
10062 gcc_assert (!specs
->long_p
&& !specs
->short_p
);
10063 gcc_assert (!(specs
->signed_p
&& specs
->unsigned_p
));
10064 if (specs
->signed_p
)
10065 specs
->type
= signed_char_type_node
;
10066 else if (specs
->unsigned_p
)
10067 specs
->type
= unsigned_char_type_node
;
10069 specs
->type
= char_type_node
;
10070 if (specs
->complex_p
)
10072 pedwarn (specs
->locations
[cdw_complex
], OPT_Wpedantic
,
10073 "ISO C does not support complex integer types");
10074 specs
->type
= build_complex_type (specs
->type
);
10078 gcc_assert (!specs
->long_p
&& !specs
->short_p
&& !specs
->long_long_p
);
10079 gcc_assert (!(specs
->signed_p
&& specs
->unsigned_p
));
10080 specs
->type
= (specs
->unsigned_p
10081 ? int128_unsigned_type_node
10082 : int128_integer_type_node
);
10083 if (specs
->complex_p
)
10085 pedwarn (specs
->locations
[cdw_complex
], OPT_Wpedantic
,
10086 "ISO C does not support complex integer types");
10087 specs
->type
= build_complex_type (specs
->type
);
10091 gcc_assert (!(specs
->long_p
&& specs
->short_p
));
10092 gcc_assert (!(specs
->signed_p
&& specs
->unsigned_p
));
10093 if (specs
->long_long_p
)
10094 specs
->type
= (specs
->unsigned_p
10095 ? long_long_unsigned_type_node
10096 : long_long_integer_type_node
);
10097 else if (specs
->long_p
)
10098 specs
->type
= (specs
->unsigned_p
10099 ? long_unsigned_type_node
10100 : long_integer_type_node
);
10101 else if (specs
->short_p
)
10102 specs
->type
= (specs
->unsigned_p
10103 ? short_unsigned_type_node
10104 : short_integer_type_node
);
10106 specs
->type
= (specs
->unsigned_p
10107 ? unsigned_type_node
10108 : integer_type_node
);
10109 if (specs
->complex_p
)
10111 pedwarn (specs
->locations
[cdw_complex
], OPT_Wpedantic
,
10112 "ISO C does not support complex integer types");
10113 specs
->type
= build_complex_type (specs
->type
);
10117 gcc_assert (!specs
->long_p
&& !specs
->short_p
10118 && !specs
->signed_p
&& !specs
->unsigned_p
);
10119 specs
->type
= (specs
->complex_p
10120 ? complex_float_type_node
10121 : float_type_node
);
10124 gcc_assert (!specs
->long_long_p
&& !specs
->short_p
10125 && !specs
->signed_p
&& !specs
->unsigned_p
);
10128 specs
->type
= (specs
->complex_p
10129 ? complex_long_double_type_node
10130 : long_double_type_node
);
10134 specs
->type
= (specs
->complex_p
10135 ? complex_double_type_node
10136 : double_type_node
);
10141 case cts_dfloat128
:
10142 gcc_assert (!specs
->long_p
&& !specs
->long_long_p
&& !specs
->short_p
10143 && !specs
->signed_p
&& !specs
->unsigned_p
&& !specs
->complex_p
);
10144 if (specs
->typespec_word
== cts_dfloat32
)
10145 specs
->type
= dfloat32_type_node
;
10146 else if (specs
->typespec_word
== cts_dfloat64
)
10147 specs
->type
= dfloat64_type_node
;
10149 specs
->type
= dfloat128_type_node
;
10152 gcc_assert (!specs
->complex_p
);
10153 if (!targetm
.fixed_point_supported_p ())
10154 specs
->type
= integer_type_node
;
10155 else if (specs
->saturating_p
)
10157 if (specs
->long_long_p
)
10158 specs
->type
= specs
->unsigned_p
10159 ? sat_unsigned_long_long_fract_type_node
10160 : sat_long_long_fract_type_node
;
10161 else if (specs
->long_p
)
10162 specs
->type
= specs
->unsigned_p
10163 ? sat_unsigned_long_fract_type_node
10164 : sat_long_fract_type_node
;
10165 else if (specs
->short_p
)
10166 specs
->type
= specs
->unsigned_p
10167 ? sat_unsigned_short_fract_type_node
10168 : sat_short_fract_type_node
;
10170 specs
->type
= specs
->unsigned_p
10171 ? sat_unsigned_fract_type_node
10172 : sat_fract_type_node
;
10176 if (specs
->long_long_p
)
10177 specs
->type
= specs
->unsigned_p
10178 ? unsigned_long_long_fract_type_node
10179 : long_long_fract_type_node
;
10180 else if (specs
->long_p
)
10181 specs
->type
= specs
->unsigned_p
10182 ? unsigned_long_fract_type_node
10183 : long_fract_type_node
;
10184 else if (specs
->short_p
)
10185 specs
->type
= specs
->unsigned_p
10186 ? unsigned_short_fract_type_node
10187 : short_fract_type_node
;
10189 specs
->type
= specs
->unsigned_p
10190 ? unsigned_fract_type_node
10195 gcc_assert (!specs
->complex_p
);
10196 if (!targetm
.fixed_point_supported_p ())
10197 specs
->type
= integer_type_node
;
10198 else if (specs
->saturating_p
)
10200 if (specs
->long_long_p
)
10201 specs
->type
= specs
->unsigned_p
10202 ? sat_unsigned_long_long_accum_type_node
10203 : sat_long_long_accum_type_node
;
10204 else if (specs
->long_p
)
10205 specs
->type
= specs
->unsigned_p
10206 ? sat_unsigned_long_accum_type_node
10207 : sat_long_accum_type_node
;
10208 else if (specs
->short_p
)
10209 specs
->type
= specs
->unsigned_p
10210 ? sat_unsigned_short_accum_type_node
10211 : sat_short_accum_type_node
;
10213 specs
->type
= specs
->unsigned_p
10214 ? sat_unsigned_accum_type_node
10215 : sat_accum_type_node
;
10219 if (specs
->long_long_p
)
10220 specs
->type
= specs
->unsigned_p
10221 ? unsigned_long_long_accum_type_node
10222 : long_long_accum_type_node
;
10223 else if (specs
->long_p
)
10224 specs
->type
= specs
->unsigned_p
10225 ? unsigned_long_accum_type_node
10226 : long_accum_type_node
;
10227 else if (specs
->short_p
)
10228 specs
->type
= specs
->unsigned_p
10229 ? unsigned_short_accum_type_node
10230 : short_accum_type_node
;
10232 specs
->type
= specs
->unsigned_p
10233 ? unsigned_accum_type_node
10238 gcc_unreachable ();
10244 /* A subroutine of c_write_global_declarations. Perform final processing
10245 on one file scope's declarations (or the external scope's declarations),
10249 c_write_global_declarations_1 (tree globals
)
10254 /* Process the decls in the order they were written. */
10255 for (decl
= globals
; decl
; decl
= DECL_CHAIN (decl
))
10257 /* Check for used but undefined static functions using the C
10258 standard's definition of "used", and set TREE_NO_WARNING so
10259 that check_global_declarations doesn't repeat the check. */
10260 if (TREE_CODE (decl
) == FUNCTION_DECL
10261 && DECL_INITIAL (decl
) == 0
10262 && DECL_EXTERNAL (decl
)
10263 && !TREE_PUBLIC (decl
)
10264 && C_DECL_USED (decl
))
10266 pedwarn (input_location
, 0, "%q+F used but never defined", decl
);
10267 TREE_NO_WARNING (decl
) = 1;
10270 wrapup_global_declaration_1 (decl
);
10275 reconsider
= false;
10276 for (decl
= globals
; decl
; decl
= DECL_CHAIN (decl
))
10277 reconsider
|= wrapup_global_declaration_2 (decl
);
10279 while (reconsider
);
10281 for (decl
= globals
; decl
; decl
= DECL_CHAIN (decl
))
10282 check_global_declaration_1 (decl
);
10285 /* A subroutine of c_write_global_declarations Emit debug information for each
10286 of the declarations in GLOBALS. */
10289 c_write_global_declarations_2 (tree globals
)
10293 for (decl
= globals
; decl
; decl
= DECL_CHAIN (decl
))
10294 debug_hooks
->global_decl (decl
);
10297 /* Callback to collect a source_ref from a DECL. */
10300 collect_source_ref_cb (tree decl
)
10302 if (!DECL_IS_BUILTIN (decl
))
10303 collect_source_ref (LOCATION_FILE (decl_sloc (decl
, false)));
10306 /* Preserve the external declarations scope across a garbage collect. */
10307 static GTY(()) tree ext_block
;
10309 /* Collect all references relevant to SOURCE_FILE. */
10312 collect_all_refs (const char *source_file
)
10317 FOR_EACH_VEC_ELT (*all_translation_units
, i
, t
)
10318 collect_ada_nodes (BLOCK_VARS (DECL_INITIAL (t
)), source_file
);
10320 collect_ada_nodes (BLOCK_VARS (ext_block
), source_file
);
10323 /* Iterate over all global declarations and call CALLBACK. */
10326 for_each_global_decl (void (*callback
) (tree decl
))
10333 FOR_EACH_VEC_ELT (*all_translation_units
, i
, t
)
10335 decls
= DECL_INITIAL (t
);
10336 for (decl
= BLOCK_VARS (decls
); decl
; decl
= TREE_CHAIN (decl
))
10340 for (decl
= BLOCK_VARS (ext_block
); decl
; decl
= TREE_CHAIN (decl
))
10345 c_write_global_declarations (void)
10350 /* We don't want to do this if generating a PCH. */
10354 timevar_start (TV_PHASE_DEFERRED
);
10356 /* Do the Objective-C stuff. This is where all the Objective-C
10357 module stuff gets generated (symtab, class/protocol/selector
10359 if (c_dialect_objc ())
10360 objc_write_global_declarations ();
10362 /* Close the external scope. */
10363 ext_block
= pop_scope ();
10364 external_scope
= 0;
10365 gcc_assert (!current_scope
);
10367 /* Handle -fdump-ada-spec[-slim]. */
10368 if (flag_dump_ada_spec
|| flag_dump_ada_spec_slim
)
10370 /* Build a table of files to generate specs for */
10371 if (flag_dump_ada_spec_slim
)
10372 collect_source_ref (main_input_filename
);
10374 for_each_global_decl (collect_source_ref_cb
);
10376 dump_ada_specs (collect_all_refs
, NULL
);
10381 tree tmp
= BLOCK_VARS (ext_block
);
10383 FILE * stream
= dump_begin (TDI_tu
, &flags
);
10386 dump_node (tmp
, flags
& ~TDF_SLIM
, stream
);
10387 dump_end (TDI_tu
, stream
);
10391 /* Process all file scopes in this compilation, and the external_scope,
10392 through wrapup_global_declarations and check_global_declarations. */
10393 FOR_EACH_VEC_ELT (*all_translation_units
, i
, t
)
10394 c_write_global_declarations_1 (BLOCK_VARS (DECL_INITIAL (t
)));
10395 c_write_global_declarations_1 (BLOCK_VARS (ext_block
));
10397 timevar_stop (TV_PHASE_DEFERRED
);
10398 timevar_start (TV_PHASE_OPT_GEN
);
10400 /* We're done parsing; proceed to optimize and emit assembly.
10401 FIXME: shouldn't be the front end's responsibility to call this. */
10402 finalize_compilation_unit ();
10404 timevar_stop (TV_PHASE_OPT_GEN
);
10405 timevar_start (TV_PHASE_DBGINFO
);
10407 /* After cgraph has had a chance to emit everything that's going to
10408 be emitted, output debug information for globals. */
10409 if (!seen_error ())
10411 timevar_push (TV_SYMOUT
);
10412 FOR_EACH_VEC_ELT (*all_translation_units
, i
, t
)
10413 c_write_global_declarations_2 (BLOCK_VARS (DECL_INITIAL (t
)));
10414 c_write_global_declarations_2 (BLOCK_VARS (ext_block
));
10415 timevar_pop (TV_SYMOUT
);
10419 timevar_stop (TV_PHASE_DBGINFO
);
10422 /* Register reserved keyword WORD as qualifier for address space AS. */
10425 c_register_addr_space (const char *word
, addr_space_t as
)
10427 int rid
= RID_FIRST_ADDR_SPACE
+ as
;
10430 /* Address space qualifiers are only supported
10431 in C with GNU extensions enabled. */
10432 if (c_dialect_objc () || flag_no_asm
)
10435 id
= get_identifier (word
);
10436 C_SET_RID_CODE (id
, rid
);
10437 C_IS_RESERVED_WORD (id
) = 1;
10438 ridpointers
[rid
] = id
;
10441 /* Return identifier to look up for omp declare reduction. */
10444 c_omp_reduction_id (enum tree_code reduction_code
, tree reduction_id
)
10446 const char *p
= NULL
;
10447 switch (reduction_code
)
10449 case PLUS_EXPR
: p
= "+"; break;
10450 case MULT_EXPR
: p
= "*"; break;
10451 case MINUS_EXPR
: p
= "-"; break;
10452 case BIT_AND_EXPR
: p
= "&"; break;
10453 case BIT_XOR_EXPR
: p
= "^"; break;
10454 case BIT_IOR_EXPR
: p
= "|"; break;
10455 case TRUTH_ANDIF_EXPR
: p
= "&&"; break;
10456 case TRUTH_ORIF_EXPR
: p
= "||"; break;
10457 case MIN_EXPR
: p
= "min"; break;
10458 case MAX_EXPR
: p
= "max"; break;
10465 if (TREE_CODE (reduction_id
) != IDENTIFIER_NODE
)
10466 return error_mark_node
;
10467 p
= IDENTIFIER_POINTER (reduction_id
);
10470 const char prefix
[] = "omp declare reduction ";
10471 size_t lenp
= sizeof (prefix
);
10472 size_t len
= strlen (p
);
10473 char *name
= XALLOCAVEC (char, lenp
+ len
);
10474 memcpy (name
, prefix
, lenp
- 1);
10475 memcpy (name
+ lenp
- 1, p
, len
+ 1);
10476 return get_identifier (name
);
10479 /* Lookup REDUCTION_ID in the current scope, or create an artificial
10480 VAR_DECL, bind it into the current scope and return it. */
10483 c_omp_reduction_decl (tree reduction_id
)
10485 struct c_binding
*b
= I_SYMBOL_BINDING (reduction_id
);
10486 if (b
!= NULL
&& B_IN_CURRENT_SCOPE (b
))
10489 tree decl
= build_decl (BUILTINS_LOCATION
, VAR_DECL
,
10490 reduction_id
, integer_type_node
);
10491 DECL_ARTIFICIAL (decl
) = 1;
10492 DECL_EXTERNAL (decl
) = 1;
10493 TREE_STATIC (decl
) = 1;
10494 TREE_PUBLIC (decl
) = 0;
10495 bind (reduction_id
, decl
, current_scope
, true, false, BUILTINS_LOCATION
);
10499 /* Lookup REDUCTION_ID in the first scope where it has entry for TYPE. */
10502 c_omp_reduction_lookup (tree reduction_id
, tree type
)
10504 struct c_binding
*b
= I_SYMBOL_BINDING (reduction_id
);
10508 for (t
= DECL_INITIAL (b
->decl
); t
; t
= TREE_CHAIN (t
))
10509 if (comptypes (TREE_PURPOSE (t
), type
))
10510 return TREE_VALUE (t
);
10513 return error_mark_node
;
10516 /* Helper function called via walk_tree, to diagnose invalid
10517 #pragma omp declare reduction combiners or initializers. */
10520 c_check_omp_declare_reduction_r (tree
*tp
, int *, void *data
)
10522 tree
*vars
= (tree
*) data
;
10523 if (SSA_VAR_P (*tp
)
10524 && !DECL_ARTIFICIAL (*tp
)
10528 location_t loc
= DECL_SOURCE_LOCATION (vars
[0]);
10529 if (strcmp (IDENTIFIER_POINTER (DECL_NAME (vars
[0])), "omp_out") == 0)
10530 error_at (loc
, "%<#pragma omp declare reduction%> combiner refers to "
10531 "variable %qD which is not %<omp_out%> nor %<omp_in%>",
10534 error_at (loc
, "%<#pragma omp declare reduction%> initializer refers "
10535 "to variable %qD which is not %<omp_priv%> nor "
10543 #include "gt-c-c-decl.h"