1 /* Process declarations and variables for C compiler.
2 Copyright (C) 1988-2015 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 "fold-const.h"
35 #include "print-tree.h"
36 #include "stor-layout.h"
39 #include "stringpool.h"
40 #include "tree-inline.h"
42 #include "hard-reg-set.h"
52 #include "c-family/c-common.h"
53 #include "c-family/c-objc.h"
54 #include "c-family/c-pragma.h"
55 #include "c-family/c-ubsan.h"
57 #include "langhooks.h"
58 #include "tree-iterator.h"
59 #include "diagnostic-core.h"
62 #include "langhooks-def.h"
64 #include "c-family/c-ada-spec.h"
68 /* In grokdeclarator, distinguish syntactic contexts of declarators. */
70 { NORMAL
, /* Ordinary declaration */
71 FUNCDEF
, /* Function definition */
72 PARM
, /* Declaration of parm before function body */
73 FIELD
, /* Declaration inside struct or union */
74 TYPENAME
}; /* Typename (inside cast or sizeof) */
76 /* States indicating how grokdeclarator() should handle declspecs marked
77 with __attribute__((deprecated)). An object declared as
78 __attribute__((deprecated)) suppresses warnings of uses of other
81 enum deprecated_states
{
87 /* Nonzero if we have seen an invalid cross reference
88 to a struct, union, or enum, but not yet printed the message. */
89 tree pending_invalid_xref
;
91 /* File and line to appear in the eventual error message. */
92 location_t pending_invalid_xref_location
;
94 /* The file and line that the prototype came from if this is an
95 old-style definition; used for diagnostics in
96 store_parm_decls_oldstyle. */
98 static location_t current_function_prototype_locus
;
100 /* Whether this prototype was built-in. */
102 static bool current_function_prototype_built_in
;
104 /* The argument type information of this prototype. */
106 static tree current_function_prototype_arg_types
;
108 /* The argument information structure for the function currently being
111 static struct c_arg_info
*current_function_arg_info
;
113 /* The obstack on which parser and related data structures, which are
114 not live beyond their top-level declaration or definition, are
116 struct obstack parser_obstack
;
118 /* The current statement tree. */
120 static GTY(()) struct stmt_tree_s c_stmt_tree
;
122 /* State saving variables. */
126 /* A list of decls to be made automatically visible in each file scope. */
127 static GTY(()) tree visible_builtins
;
129 /* Set to 0 at beginning of a function definition, set to 1 if
130 a return statement that specifies a return value is seen. */
132 int current_function_returns_value
;
134 /* Set to 0 at beginning of a function definition, set to 1 if
135 a return statement with no argument is seen. */
137 int current_function_returns_null
;
139 /* Set to 0 at beginning of a function definition, set to 1 if
140 a call to a noreturn function is seen. */
142 int current_function_returns_abnormally
;
144 /* Set to nonzero by `grokdeclarator' for a function
145 whose return type is defaulted, if warnings for this are desired. */
147 static int warn_about_return_type
;
149 /* Nonzero when the current toplevel function contains a declaration
150 of a nested function which is never defined. */
152 static bool undef_nested_function
;
154 /* If non-zero, implicit "omp declare target" attribute is added into the
156 int current_omp_declare_target_attribute
;
158 /* Each c_binding structure describes one binding of an identifier to
159 a decl. All the decls in a scope - irrespective of namespace - are
160 chained together by the ->prev field, which (as the name implies)
161 runs in reverse order. All the decls in a given namespace bound to
162 a given identifier are chained by the ->shadowed field, which runs
163 from inner to outer scopes.
165 The ->decl field usually points to a DECL node, but there are two
166 exceptions. In the namespace of type tags, the bound entity is a
167 RECORD_TYPE, UNION_TYPE, or ENUMERAL_TYPE node. If an undeclared
168 identifier is encountered, it is bound to error_mark_node to
169 suppress further errors about that identifier in the current
172 The ->u.type field stores the type of the declaration in this scope;
173 if NULL, the type is the type of the ->decl field. This is only of
174 relevance for objects with external or internal linkage which may
175 be redeclared in inner scopes, forming composite types that only
176 persist for the duration of those scopes. In the external scope,
177 this stores the composite of all the types declared for this
178 object, visible or not. The ->inner_comp field (used only at file
179 scope) stores whether an incomplete array type at file scope was
180 completed at an inner scope to an array size other than 1.
182 The ->u.label field is used for labels. It points to a structure
183 which stores additional information used for warnings.
185 The depth field is copied from the scope structure that holds this
186 decl. It is used to preserve the proper ordering of the ->shadowed
187 field (see bind()) and also for a handful of special-case checks.
188 Finally, the invisible bit is true for a decl which should be
189 ignored for purposes of normal name lookup, and the nested bit is
190 true for a decl that's been bound a second time in an inner scope;
191 in all such cases, the binding in the outer scope will have its
192 invisible bit true. */
194 struct GTY((chain_next ("%h.prev"))) c_binding
{
195 union GTY(()) { /* first so GTY desc can use decl */
196 tree
GTY((tag ("0"))) type
; /* the type in this scope */
197 struct c_label_vars
* GTY((tag ("1"))) label
; /* for warnings */
198 } GTY((desc ("TREE_CODE (%0.decl) == LABEL_DECL"))) u
;
199 tree decl
; /* the decl bound */
200 tree id
; /* the identifier it's bound to */
201 struct c_binding
*prev
; /* the previous decl in this scope */
202 struct c_binding
*shadowed
; /* the innermost decl shadowed by this one */
203 unsigned int depth
: 28; /* depth of this scope */
204 BOOL_BITFIELD invisible
: 1; /* normal lookup should ignore this binding */
205 BOOL_BITFIELD nested
: 1; /* do not set DECL_CONTEXT when popping */
206 BOOL_BITFIELD inner_comp
: 1; /* incomplete array completed in inner scope */
207 BOOL_BITFIELD in_struct
: 1; /* currently defined as struct field */
208 location_t locus
; /* location for nested bindings */
210 #define B_IN_SCOPE(b1, b2) ((b1)->depth == (b2)->depth)
211 #define B_IN_CURRENT_SCOPE(b) ((b)->depth == current_scope->depth)
212 #define B_IN_FILE_SCOPE(b) ((b)->depth == 1 /*file_scope->depth*/)
213 #define B_IN_EXTERNAL_SCOPE(b) ((b)->depth == 0 /*external_scope->depth*/)
215 /* Each C symbol points to three linked lists of c_binding structures.
216 These describe the values of the identifier in the three different
217 namespaces defined by the language. */
219 struct GTY(()) lang_identifier
{
220 struct c_common_identifier common_id
;
221 struct c_binding
*symbol_binding
; /* vars, funcs, constants, typedefs */
222 struct c_binding
*tag_binding
; /* struct/union/enum tags */
223 struct c_binding
*label_binding
; /* labels */
226 /* Validate c-lang.c's assumptions. */
227 extern char C_SIZEOF_STRUCT_LANG_IDENTIFIER_isnt_accurate
228 [(sizeof(struct lang_identifier
) == C_SIZEOF_STRUCT_LANG_IDENTIFIER
) ? 1 : -1];
230 /* The binding oracle; see c-tree.h. */
231 void (*c_binding_oracle
) (enum c_oracle_request
, tree identifier
);
233 /* This flag is set on an identifier if we have previously asked the
234 binding oracle for this identifier's symbol binding. */
235 #define I_SYMBOL_CHECKED(node) \
236 (TREE_LANG_FLAG_4 (IDENTIFIER_NODE_CHECK (node)))
238 static inline struct c_binding
* *
239 i_symbol_binding (tree node
)
241 struct lang_identifier
*lid
242 = (struct lang_identifier
*) IDENTIFIER_NODE_CHECK (node
);
244 if (lid
->symbol_binding
== NULL
245 && c_binding_oracle
!= NULL
246 && !I_SYMBOL_CHECKED (node
))
248 /* Set the "checked" flag first, to avoid infinite recursion
249 when the binding oracle calls back into gcc. */
250 I_SYMBOL_CHECKED (node
) = 1;
251 c_binding_oracle (C_ORACLE_SYMBOL
, node
);
254 return &lid
->symbol_binding
;
257 #define I_SYMBOL_BINDING(node) (*i_symbol_binding (node))
259 #define I_SYMBOL_DECL(node) \
260 (I_SYMBOL_BINDING(node) ? I_SYMBOL_BINDING(node)->decl : 0)
262 /* This flag is set on an identifier if we have previously asked the
263 binding oracle for this identifier's tag binding. */
264 #define I_TAG_CHECKED(node) \
265 (TREE_LANG_FLAG_5 (IDENTIFIER_NODE_CHECK (node)))
267 static inline struct c_binding
**
268 i_tag_binding (tree node
)
270 struct lang_identifier
*lid
271 = (struct lang_identifier
*) IDENTIFIER_NODE_CHECK (node
);
273 if (lid
->tag_binding
== NULL
274 && c_binding_oracle
!= NULL
275 && !I_TAG_CHECKED (node
))
277 /* Set the "checked" flag first, to avoid infinite recursion
278 when the binding oracle calls back into gcc. */
279 I_TAG_CHECKED (node
) = 1;
280 c_binding_oracle (C_ORACLE_TAG
, node
);
283 return &lid
->tag_binding
;
286 #define I_TAG_BINDING(node) (*i_tag_binding (node))
288 #define I_TAG_DECL(node) \
289 (I_TAG_BINDING(node) ? I_TAG_BINDING(node)->decl : 0)
291 /* This flag is set on an identifier if we have previously asked the
292 binding oracle for this identifier's label binding. */
293 #define I_LABEL_CHECKED(node) \
294 (TREE_LANG_FLAG_6 (IDENTIFIER_NODE_CHECK (node)))
296 static inline struct c_binding
**
297 i_label_binding (tree node
)
299 struct lang_identifier
*lid
300 = (struct lang_identifier
*) IDENTIFIER_NODE_CHECK (node
);
302 if (lid
->label_binding
== NULL
303 && c_binding_oracle
!= NULL
304 && !I_LABEL_CHECKED (node
))
306 /* Set the "checked" flag first, to avoid infinite recursion
307 when the binding oracle calls back into gcc. */
308 I_LABEL_CHECKED (node
) = 1;
309 c_binding_oracle (C_ORACLE_LABEL
, node
);
312 return &lid
->label_binding
;
315 #define I_LABEL_BINDING(node) (*i_label_binding (node))
317 #define I_LABEL_DECL(node) \
318 (I_LABEL_BINDING(node) ? I_LABEL_BINDING(node)->decl : 0)
320 /* The resulting tree type. */
322 union GTY((desc ("TREE_CODE (&%h.generic) == IDENTIFIER_NODE"),
323 chain_next ("(union lang_tree_node *) c_tree_chain_next (&%h.generic)"))) lang_tree_node
325 union tree_node
GTY ((tag ("0"),
326 desc ("tree_node_structure (&%h)")))
328 struct lang_identifier
GTY ((tag ("1"))) identifier
;
331 /* Track bindings and other things that matter for goto warnings. For
332 efficiency, we do not gather all the decls at the point of
333 definition. Instead, we point into the bindings structure. As
334 scopes are popped, we update these structures and gather the decls
335 that matter at that time. */
337 struct GTY(()) c_spot_bindings
{
338 /* The currently open scope which holds bindings defined when the
339 label was defined or the goto statement was found. */
340 struct c_scope
*scope
;
341 /* The bindings in the scope field which were defined at the point
342 of the label or goto. This lets us look at older or newer
343 bindings in the scope, as appropriate. */
344 struct c_binding
*bindings_in_scope
;
345 /* The number of statement expressions that have started since this
346 label or goto statement was defined. This is zero if we are at
347 the same statement expression level. It is positive if we are in
348 a statement expression started since this spot. It is negative
349 if this spot was in a statement expression and we have left
352 /* Whether we started in a statement expression but are no longer in
353 it. This is set to true if stmt_exprs ever goes negative. */
357 /* This structure is used to keep track of bindings seen when a goto
358 statement is defined. This is only used if we see the goto
359 statement before we see the label. */
361 struct GTY(()) c_goto_bindings
{
362 /* The location of the goto statement. */
364 /* The bindings of the goto statement. */
365 struct c_spot_bindings goto_bindings
;
368 typedef struct c_goto_bindings
*c_goto_bindings_p
;
370 /* The additional information we keep track of for a label binding.
371 These fields are updated as scopes are popped. */
373 struct GTY(()) c_label_vars
{
374 /* The shadowed c_label_vars, when one label shadows another (which
375 can only happen using a __label__ declaration). */
376 struct c_label_vars
*shadowed
;
377 /* The bindings when the label was defined. */
378 struct c_spot_bindings label_bindings
;
379 /* A list of decls that we care about: decls about which we should
380 warn if a goto branches to this label from later in the function.
381 Decls are added to this list as scopes are popped. We only add
382 the decls that matter. */
383 vec
<tree
, va_gc
> *decls_in_scope
;
384 /* A list of goto statements to this label. This is only used for
385 goto statements seen before the label was defined, so that we can
386 issue appropriate warnings for them. */
387 vec
<c_goto_bindings_p
, va_gc
> *gotos
;
390 /* Each c_scope structure describes the complete contents of one
391 scope. Four scopes are distinguished specially: the innermost or
392 current scope, the innermost function scope, the file scope (always
393 the second to outermost) and the outermost or external scope.
395 Most declarations are recorded in the current scope.
397 All normal label declarations are recorded in the innermost
398 function scope, as are bindings of undeclared identifiers to
399 error_mark_node. (GCC permits nested functions as an extension,
400 hence the 'innermost' qualifier.) Explicitly declared labels
401 (using the __label__ extension) appear in the current scope.
403 Being in the file scope (current_scope == file_scope) causes
404 special behavior in several places below. Also, under some
405 conditions the Objective-C front end records declarations in the
406 file scope even though that isn't the current scope.
408 All declarations with external linkage are recorded in the external
409 scope, even if they aren't visible there; this models the fact that
410 such declarations are visible to the entire program, and (with a
411 bit of cleverness, see pushdecl) allows diagnosis of some violations
412 of C99 6.2.2p7 and 6.2.7p2:
414 If, within the same translation unit, the same identifier appears
415 with both internal and external linkage, the behavior is
418 All declarations that refer to the same object or function shall
419 have compatible type; otherwise, the behavior is undefined.
421 Initially only the built-in declarations, which describe compiler
422 intrinsic functions plus a subset of the standard library, are in
425 The order of the blocks list matters, and it is frequently appended
426 to. To avoid having to walk all the way to the end of the list on
427 each insertion, or reverse the list later, we maintain a pointer to
428 the last list entry. (FIXME: It should be feasible to use a reversed
431 The bindings list is strictly in reverse order of declarations;
432 pop_scope relies on this. */
435 struct GTY((chain_next ("%h.outer"))) c_scope
{
436 /* The scope containing this one. */
437 struct c_scope
*outer
;
439 /* The next outermost function scope. */
440 struct c_scope
*outer_function
;
442 /* All bindings in this scope. */
443 struct c_binding
*bindings
;
445 /* For each scope (except the global one), a chain of BLOCK nodes
446 for all the scopes that were entered and exited one level down. */
450 /* The depth of this scope. Used to keep the ->shadowed chain of
451 bindings sorted innermost to outermost. */
452 unsigned int depth
: 28;
454 /* True if we are currently filling this scope with parameter
456 BOOL_BITFIELD parm_flag
: 1;
458 /* True if we saw [*] in this scope. Used to give an error messages
459 if these appears in a function definition. */
460 BOOL_BITFIELD had_vla_unspec
: 1;
462 /* True if we already complained about forward parameter decls
463 in this scope. This prevents double warnings on
464 foo (int a; int b; ...) */
465 BOOL_BITFIELD warned_forward_parm_decls
: 1;
467 /* True if this is the outermost block scope of a function body.
468 This scope contains the parameters, the local variables declared
469 in the outermost block, and all the labels (except those in
470 nested functions, or declared at block scope with __label__). */
471 BOOL_BITFIELD function_body
: 1;
473 /* True means make a BLOCK for this scope no matter what. */
474 BOOL_BITFIELD keep
: 1;
476 /* True means that an unsuffixed float constant is _Decimal64. */
477 BOOL_BITFIELD float_const_decimal64
: 1;
479 /* True if this scope has any label bindings. This is used to speed
480 up searching for labels when popping scopes, particularly since
481 labels are normally only found at function scope. */
482 BOOL_BITFIELD has_label_bindings
: 1;
484 /* True if we should issue a warning if a goto statement crosses any
485 of the bindings. We still need to check the list of bindings to
486 find the specific ones we need to warn about. This is true if
487 decl_jump_unsafe would return true for any of the bindings. This
488 is used to avoid looping over all the bindings unnecessarily. */
489 BOOL_BITFIELD has_jump_unsafe_decl
: 1;
492 /* The scope currently in effect. */
494 static GTY(()) struct c_scope
*current_scope
;
496 /* The innermost function scope. Ordinary (not explicitly declared)
497 labels, bindings to error_mark_node, and the lazily-created
498 bindings of __func__ and its friends get this scope. */
500 static GTY(()) struct c_scope
*current_function_scope
;
502 /* The C file scope. This is reset for each input translation unit. */
504 static GTY(()) struct c_scope
*file_scope
;
506 /* The outermost scope. This is used for all declarations with
507 external linkage, and only these, hence the name. */
509 static GTY(()) struct c_scope
*external_scope
;
511 /* A chain of c_scope structures awaiting reuse. */
513 static GTY((deletable
)) struct c_scope
*scope_freelist
;
515 /* A chain of c_binding structures awaiting reuse. */
517 static GTY((deletable
)) struct c_binding
*binding_freelist
;
519 /* Append VAR to LIST in scope SCOPE. */
520 #define SCOPE_LIST_APPEND(scope, list, decl) do { \
521 struct c_scope *s_ = (scope); \
523 if (s_->list##_last) \
524 BLOCK_CHAIN (s_->list##_last) = d_; \
527 s_->list##_last = d_; \
530 /* Concatenate FROM in scope FSCOPE onto TO in scope TSCOPE. */
531 #define SCOPE_LIST_CONCAT(tscope, to, fscope, from) do { \
532 struct c_scope *t_ = (tscope); \
533 struct c_scope *f_ = (fscope); \
535 BLOCK_CHAIN (t_->to##_last) = f_->from; \
538 t_->to##_last = f_->from##_last; \
541 /* A c_inline_static structure stores details of a static identifier
542 referenced in a definition of a function that may be an inline
543 definition if no subsequent declaration of that function uses
544 "extern" or does not use "inline". */
546 struct GTY((chain_next ("%h.next"))) c_inline_static
{
547 /* The location for a diagnostic. */
550 /* The function that may be an inline definition. */
553 /* The object or function referenced. */
556 /* What sort of reference this is. */
557 enum c_inline_static_type type
;
559 /* The next such structure or NULL. */
560 struct c_inline_static
*next
;
563 /* List of static identifiers used or referenced in functions that may
564 be inline definitions. */
565 static GTY(()) struct c_inline_static
*c_inline_statics
;
567 /* True means unconditionally make a BLOCK for the next scope pushed. */
569 static bool keep_next_level_flag
;
571 /* True means the next call to push_scope will be the outermost scope
572 of a function body, so do not push a new scope, merely cease
573 expecting parameter decls. */
575 static bool next_is_function_body
;
577 /* A vector of pointers to c_binding structures. */
579 typedef struct c_binding
*c_binding_ptr
;
581 /* Information that we keep for a struct or union while it is being
584 struct c_struct_parse_info
586 /* If warn_cxx_compat, a list of types defined within this
588 vec
<tree
> struct_types
;
589 /* If warn_cxx_compat, a list of field names which have bindings,
590 and which are defined in this struct, but which are not defined
591 in any enclosing struct. This is used to clear the in_struct
592 field of the c_bindings structure. */
593 vec
<c_binding_ptr
> fields
;
594 /* If warn_cxx_compat, a list of typedef names used when defining
595 fields in this struct. */
596 vec
<tree
> typedefs_seen
;
599 /* Information for the struct or union currently being parsed, or
600 NULL if not parsing a struct or union. */
601 static struct c_struct_parse_info
*struct_parse_info
;
603 /* Forward declarations. */
604 static tree
lookup_name_in_scope (tree
, struct c_scope
*);
605 static tree
c_make_fname_decl (location_t
, tree
, int);
606 static tree
grokdeclarator (const struct c_declarator
*,
607 struct c_declspecs
*,
608 enum decl_context
, bool, tree
*, tree
*, tree
*,
609 bool *, enum deprecated_states
);
610 static tree
grokparms (struct c_arg_info
*, bool);
611 static void layout_array_type (tree
);
612 static void warn_defaults_to (location_t
, int, const char *, ...)
613 ATTRIBUTE_GCC_DIAG(3,4);
615 /* T is a statement. Add it to the statement-tree. This is the
616 C/ObjC version--C++ has a slightly different version of this
622 enum tree_code code
= TREE_CODE (t
);
624 if (CAN_HAVE_LOCATION_P (t
) && code
!= LABEL_EXPR
)
626 if (!EXPR_HAS_LOCATION (t
))
627 SET_EXPR_LOCATION (t
, input_location
);
630 if (code
== LABEL_EXPR
|| code
== CASE_LABEL_EXPR
)
631 STATEMENT_LIST_HAS_LABEL (cur_stmt_list
) = 1;
633 /* Add T to the statement-tree. Non-side-effect statements need to be
634 recorded during statement expressions. */
635 if (!building_stmt_list_p ())
637 append_to_statement_list_force (t
, &cur_stmt_list
);
642 /* Build a pointer type using the default pointer mode. */
645 c_build_pointer_type (tree to_type
)
647 addr_space_t as
= to_type
== error_mark_node
? ADDR_SPACE_GENERIC
648 : TYPE_ADDR_SPACE (to_type
);
649 machine_mode pointer_mode
;
651 if (as
!= ADDR_SPACE_GENERIC
|| c_default_pointer_mode
== VOIDmode
)
652 pointer_mode
= targetm
.addr_space
.pointer_mode (as
);
654 pointer_mode
= c_default_pointer_mode
;
655 return build_pointer_type_for_mode (to_type
, pointer_mode
, false);
659 /* Return true if we will want to say something if a goto statement
663 decl_jump_unsafe (tree decl
)
665 if (error_operand_p (decl
))
668 /* Always warn about crossing variably modified types. */
669 if ((VAR_P (decl
) || TREE_CODE (decl
) == TYPE_DECL
)
670 && variably_modified_type_p (TREE_TYPE (decl
), NULL_TREE
))
673 /* Otherwise, only warn if -Wgoto-misses-init and this is an
674 initialized automatic decl. */
675 if (warn_jump_misses_init
677 && !TREE_STATIC (decl
)
678 && DECL_INITIAL (decl
) != NULL_TREE
)
686 c_print_identifier (FILE *file
, tree node
, int indent
)
688 void (*save
) (enum c_oracle_request
, tree identifier
);
690 /* Temporarily hide any binding oracle. Without this, calls to
691 debug_tree from the debugger will end up calling into the oracle,
692 making for a confusing debug session. As the oracle isn't needed
693 here for normal operation, it's simplest to suppress it. */
694 save
= c_binding_oracle
;
695 c_binding_oracle
= NULL
;
697 print_node (file
, "symbol", I_SYMBOL_DECL (node
), indent
+ 4);
698 print_node (file
, "tag", I_TAG_DECL (node
), indent
+ 4);
699 print_node (file
, "label", I_LABEL_DECL (node
), indent
+ 4);
700 if (C_IS_RESERVED_WORD (node
) && C_RID_CODE (node
) != RID_CXX_COMPAT_WARN
)
702 tree rid
= ridpointers
[C_RID_CODE (node
)];
703 indent_to (file
, indent
+ 4);
704 fprintf (file
, "rid " HOST_PTR_PRINTF
" \"%s\"",
705 (void *) rid
, IDENTIFIER_POINTER (rid
));
708 c_binding_oracle
= save
;
711 /* Establish a binding between NAME, an IDENTIFIER_NODE, and DECL,
712 which may be any of several kinds of DECL or TYPE or error_mark_node,
713 in the scope SCOPE. */
715 bind (tree name
, tree decl
, struct c_scope
*scope
, bool invisible
,
716 bool nested
, location_t locus
)
718 struct c_binding
*b
, **here
;
720 if (binding_freelist
)
722 b
= binding_freelist
;
723 binding_freelist
= b
->prev
;
726 b
= ggc_alloc
<c_binding
> ();
731 b
->depth
= scope
->depth
;
732 b
->invisible
= invisible
;
740 b
->prev
= scope
->bindings
;
743 if (decl_jump_unsafe (decl
))
744 scope
->has_jump_unsafe_decl
= 1;
749 switch (TREE_CODE (decl
))
751 case LABEL_DECL
: here
= &I_LABEL_BINDING (name
); break;
754 case RECORD_TYPE
: here
= &I_TAG_BINDING (name
); break;
760 case ERROR_MARK
: here
= &I_SYMBOL_BINDING (name
); break;
766 /* Locate the appropriate place in the chain of shadowed decls
767 to insert this binding. Normally, scope == current_scope and
768 this does nothing. */
769 while (*here
&& (*here
)->depth
> scope
->depth
)
770 here
= &(*here
)->shadowed
;
776 /* Clear the binding structure B, stick it on the binding_freelist,
777 and return the former value of b->prev. This is used by pop_scope
778 and get_parm_info to iterate destructively over all the bindings
779 from a given scope. */
780 static struct c_binding
*
781 free_binding_and_advance (struct c_binding
*b
)
783 struct c_binding
*prev
= b
->prev
;
785 memset (b
, 0, sizeof (struct c_binding
));
786 b
->prev
= binding_freelist
;
787 binding_freelist
= b
;
792 /* Bind a label. Like bind, but skip fields which aren't used for
793 labels, and add the LABEL_VARS value. */
795 bind_label (tree name
, tree label
, struct c_scope
*scope
,
796 struct c_label_vars
*label_vars
)
800 bind (name
, label
, scope
, /*invisible=*/false, /*nested=*/false,
803 scope
->has_label_bindings
= true;
806 gcc_assert (b
->decl
== label
);
807 label_vars
->shadowed
= b
->u
.label
;
808 b
->u
.label
= label_vars
;
811 /* Hook called at end of compilation to assume 1 elt
812 for a file-scope tentative array defn that wasn't complete before. */
815 c_finish_incomplete_decl (tree decl
)
819 tree type
= TREE_TYPE (decl
);
820 if (type
!= error_mark_node
821 && TREE_CODE (type
) == ARRAY_TYPE
822 && !DECL_EXTERNAL (decl
)
823 && TYPE_DOMAIN (type
) == 0)
825 warning_at (DECL_SOURCE_LOCATION (decl
),
826 0, "array %q+D assumed to have one element", decl
);
828 complete_array_type (&TREE_TYPE (decl
), NULL_TREE
, true);
830 relayout_decl (decl
);
835 /* Record that inline function FUNC contains a reference (location
836 LOC) to static DECL (file-scope or function-local according to
840 record_inline_static (location_t loc
, tree func
, tree decl
,
841 enum c_inline_static_type type
)
843 c_inline_static
*csi
= ggc_alloc
<c_inline_static
> ();
845 csi
->function
= func
;
846 csi
->static_decl
= decl
;
848 csi
->next
= c_inline_statics
;
849 c_inline_statics
= csi
;
852 /* Check for references to static declarations in inline functions at
853 the end of the translation unit and diagnose them if the functions
854 are still inline definitions. */
857 check_inline_statics (void)
859 struct c_inline_static
*csi
;
860 for (csi
= c_inline_statics
; csi
; csi
= csi
->next
)
862 if (DECL_EXTERNAL (csi
->function
))
866 pedwarn (csi
->location
, 0,
867 "%qD is static but used in inline function %qD "
868 "which is not static", csi
->static_decl
, csi
->function
);
871 pedwarn (csi
->location
, 0,
872 "%q+D is static but declared in inline function %qD "
873 "which is not static", csi
->static_decl
, csi
->function
);
879 c_inline_statics
= NULL
;
882 /* Fill in a c_spot_bindings structure. If DEFINING is true, set it
883 for the current state, otherwise set it to uninitialized. */
886 set_spot_bindings (struct c_spot_bindings
*p
, bool defining
)
890 p
->scope
= current_scope
;
891 p
->bindings_in_scope
= current_scope
->bindings
;
896 p
->bindings_in_scope
= NULL
;
899 p
->left_stmt_expr
= false;
902 /* Update spot bindings P as we pop out of SCOPE. Return true if we
903 should push decls for a label. */
906 update_spot_bindings (struct c_scope
*scope
, struct c_spot_bindings
*p
)
908 if (p
->scope
!= scope
)
910 /* This label or goto is defined in some other scope, or it is a
911 label which is not yet defined. There is nothing to
916 /* Adjust the spot bindings to refer to the bindings already defined
917 in the enclosing scope. */
918 p
->scope
= scope
->outer
;
919 p
->bindings_in_scope
= p
->scope
->bindings
;
924 /* The Objective-C front-end often needs to determine the current scope. */
927 objc_get_current_scope (void)
929 return current_scope
;
932 /* The following function is used only by Objective-C. It needs to live here
933 because it accesses the innards of c_scope. */
936 objc_mark_locals_volatile (void *enclosing_blk
)
938 struct c_scope
*scope
;
941 for (scope
= current_scope
;
942 scope
&& scope
!= enclosing_blk
;
943 scope
= scope
->outer
)
945 for (b
= scope
->bindings
; b
; b
= b
->prev
)
946 objc_volatilize_decl (b
->decl
);
948 /* Do not climb up past the current function. */
949 if (scope
->function_body
)
954 /* Return true if we are in the global binding level. */
957 global_bindings_p (void)
959 return current_scope
== file_scope
;
963 keep_next_level (void)
965 keep_next_level_flag
= true;
968 /* Set the flag for the FLOAT_CONST_DECIMAL64 pragma being ON. */
971 set_float_const_decimal64 (void)
973 current_scope
->float_const_decimal64
= true;
976 /* Clear the flag for the FLOAT_CONST_DECIMAL64 pragma. */
979 clear_float_const_decimal64 (void)
981 current_scope
->float_const_decimal64
= false;
984 /* Return nonzero if an unsuffixed float constant is _Decimal64. */
987 float_const_decimal64_p (void)
989 return current_scope
->float_const_decimal64
;
992 /* Identify this scope as currently being filled with parameters. */
995 declare_parm_level (void)
997 current_scope
->parm_flag
= true;
1003 if (next_is_function_body
)
1005 /* This is the transition from the parameters to the top level
1006 of the function body. These are the same scope
1007 (C99 6.2.1p4,6) so we do not push another scope structure.
1008 next_is_function_body is set only by store_parm_decls, which
1009 in turn is called when and only when we are about to
1010 encounter the opening curly brace for the function body.
1012 The outermost block of a function always gets a BLOCK node,
1013 because the debugging output routines expect that each
1014 function has at least one BLOCK. */
1015 current_scope
->parm_flag
= false;
1016 current_scope
->function_body
= true;
1017 current_scope
->keep
= true;
1018 current_scope
->outer_function
= current_function_scope
;
1019 current_function_scope
= current_scope
;
1021 keep_next_level_flag
= false;
1022 next_is_function_body
= false;
1024 /* The FLOAT_CONST_DECIMAL64 pragma applies to nested scopes. */
1025 if (current_scope
->outer
)
1026 current_scope
->float_const_decimal64
1027 = current_scope
->outer
->float_const_decimal64
;
1029 current_scope
->float_const_decimal64
= false;
1033 struct c_scope
*scope
;
1036 scope
= scope_freelist
;
1037 scope_freelist
= scope
->outer
;
1040 scope
= ggc_cleared_alloc
<c_scope
> ();
1042 /* The FLOAT_CONST_DECIMAL64 pragma applies to nested scopes. */
1044 scope
->float_const_decimal64
= current_scope
->float_const_decimal64
;
1046 scope
->float_const_decimal64
= false;
1048 scope
->keep
= keep_next_level_flag
;
1049 scope
->outer
= current_scope
;
1050 scope
->depth
= current_scope
? (current_scope
->depth
+ 1) : 0;
1052 /* Check for scope depth overflow. Unlikely (2^28 == 268,435,456) but
1054 if (current_scope
&& scope
->depth
== 0)
1057 sorry ("GCC supports only %u nested scopes", scope
->depth
);
1060 current_scope
= scope
;
1061 keep_next_level_flag
= false;
1065 /* This is called when we are leaving SCOPE. For each label defined
1066 in SCOPE, add any appropriate decls to its decls_in_scope fields.
1067 These are the decls whose initialization will be skipped by a goto
1068 later in the function. */
1071 update_label_decls (struct c_scope
*scope
)
1078 if (s
->has_label_bindings
)
1080 struct c_binding
*b
;
1082 for (b
= s
->bindings
; b
!= NULL
; b
= b
->prev
)
1084 struct c_label_vars
*label_vars
;
1085 struct c_binding
*b1
;
1088 struct c_goto_bindings
*g
;
1090 if (TREE_CODE (b
->decl
) != LABEL_DECL
)
1092 label_vars
= b
->u
.label
;
1094 b1
= label_vars
->label_bindings
.bindings_in_scope
;
1095 if (label_vars
->label_bindings
.scope
== NULL
)
1098 hjud
= label_vars
->label_bindings
.scope
->has_jump_unsafe_decl
;
1099 if (update_spot_bindings (scope
, &label_vars
->label_bindings
))
1101 /* This label is defined in this scope. */
1104 for (; b1
!= NULL
; b1
= b1
->prev
)
1106 /* A goto from later in the function to this
1107 label will never see the initialization
1108 of B1, if any. Save it to issue a
1109 warning if needed. */
1110 if (decl_jump_unsafe (b1
->decl
))
1111 vec_safe_push(label_vars
->decls_in_scope
, b1
->decl
);
1116 /* Update the bindings of any goto statements associated
1118 FOR_EACH_VEC_SAFE_ELT (label_vars
->gotos
, ix
, g
)
1119 update_spot_bindings (scope
, &g
->goto_bindings
);
1123 /* Don't search beyond the current function. */
1124 if (s
== current_function_scope
)
1131 /* Set the TYPE_CONTEXT of all of TYPE's variants to CONTEXT. */
1134 set_type_context (tree type
, tree context
)
1136 for (type
= TYPE_MAIN_VARIANT (type
); type
;
1137 type
= TYPE_NEXT_VARIANT (type
))
1138 TYPE_CONTEXT (type
) = context
;
1141 /* Exit a scope. Restore the state of the identifier-decl mappings
1142 that were in effect when this scope was entered. Return a BLOCK
1143 node containing all the DECLs in this scope that are of interest
1144 to debug info generation. */
1149 struct c_scope
*scope
= current_scope
;
1150 tree block
, context
, p
;
1151 struct c_binding
*b
;
1153 bool functionbody
= scope
->function_body
;
1154 bool keep
= functionbody
|| scope
->keep
|| scope
->bindings
;
1156 update_label_decls (scope
);
1158 /* If appropriate, create a BLOCK to record the decls for the life
1159 of this function. */
1163 block
= make_node (BLOCK
);
1164 BLOCK_SUBBLOCKS (block
) = scope
->blocks
;
1165 TREE_USED (block
) = 1;
1167 /* In each subblock, record that this is its superior. */
1168 for (p
= scope
->blocks
; p
; p
= BLOCK_CHAIN (p
))
1169 BLOCK_SUPERCONTEXT (p
) = block
;
1171 BLOCK_VARS (block
) = 0;
1174 /* The TYPE_CONTEXTs for all of the tagged types belonging to this
1175 scope must be set so that they point to the appropriate
1176 construct, i.e. either to the current FUNCTION_DECL node, or
1177 else to the BLOCK node we just constructed.
1179 Note that for tagged types whose scope is just the formal
1180 parameter list for some function type specification, we can't
1181 properly set their TYPE_CONTEXTs here, because we don't have a
1182 pointer to the appropriate FUNCTION_TYPE node readily available
1183 to us. For those cases, the TYPE_CONTEXTs of the relevant tagged
1184 type nodes get set in `grokdeclarator' as soon as we have created
1185 the FUNCTION_TYPE node which will represent the "scope" for these
1186 "parameter list local" tagged types. */
1187 if (scope
->function_body
)
1188 context
= current_function_decl
;
1189 else if (scope
== file_scope
)
1191 tree file_decl
= build_translation_unit_decl (NULL_TREE
);
1192 context
= file_decl
;
1193 debug_hooks
->register_main_translation_unit (file_decl
);
1198 /* Clear all bindings in this scope. */
1199 for (b
= scope
->bindings
; b
; b
= free_binding_and_advance (b
))
1202 switch (TREE_CODE (p
))
1205 /* Warnings for unused labels, errors for undefined labels. */
1206 if (TREE_USED (p
) && !DECL_INITIAL (p
))
1208 error ("label %q+D used but not defined", p
);
1209 DECL_INITIAL (p
) = error_mark_node
;
1212 warn_for_unused_label (p
);
1214 /* Labels go in BLOCK_VARS. */
1215 DECL_CHAIN (p
) = BLOCK_VARS (block
);
1216 BLOCK_VARS (block
) = p
;
1217 gcc_assert (I_LABEL_BINDING (b
->id
) == b
);
1218 I_LABEL_BINDING (b
->id
) = b
->shadowed
;
1220 /* Also pop back to the shadowed label_vars. */
1221 release_tree_vector (b
->u
.label
->decls_in_scope
);
1222 b
->u
.label
= b
->u
.label
->shadowed
;
1228 set_type_context (p
, context
);
1230 /* Types may not have tag-names, in which case the type
1231 appears in the bindings list with b->id NULL. */
1234 gcc_assert (I_TAG_BINDING (b
->id
) == b
);
1235 I_TAG_BINDING (b
->id
) = b
->shadowed
;
1240 /* Propagate TREE_ADDRESSABLE from nested functions to their
1241 containing functions. */
1242 if (!TREE_ASM_WRITTEN (p
)
1243 && DECL_INITIAL (p
) != 0
1244 && TREE_ADDRESSABLE (p
)
1245 && DECL_ABSTRACT_ORIGIN (p
) != 0
1246 && DECL_ABSTRACT_ORIGIN (p
) != p
)
1247 TREE_ADDRESSABLE (DECL_ABSTRACT_ORIGIN (p
)) = 1;
1248 if (!DECL_EXTERNAL (p
)
1249 && !DECL_INITIAL (p
)
1250 && scope
!= file_scope
1251 && scope
!= external_scope
)
1253 error ("nested function %q+D declared but never defined", p
);
1254 undef_nested_function
= true;
1256 else if (DECL_DECLARED_INLINE_P (p
)
1258 && !DECL_INITIAL (p
))
1260 /* C99 6.7.4p6: "a function with external linkage... declared
1261 with an inline function specifier ... shall also be defined
1262 in the same translation unit." */
1263 if (!flag_gnu89_inline
1264 && !lookup_attribute ("gnu_inline", DECL_ATTRIBUTES (p
))
1265 && scope
!= external_scope
)
1266 pedwarn (input_location
, 0,
1267 "inline function %q+D declared but never defined", p
);
1268 DECL_EXTERNAL (p
) = 1;
1274 /* Warnings for unused variables. */
1275 if ((!TREE_USED (p
) || !DECL_READ_P (p
))
1276 && !TREE_NO_WARNING (p
)
1277 && !DECL_IN_SYSTEM_HEADER (p
)
1279 && !DECL_ARTIFICIAL (p
)
1280 && scope
!= file_scope
1281 && scope
!= external_scope
)
1284 warning (OPT_Wunused_variable
, "unused variable %q+D", p
);
1285 else if (DECL_CONTEXT (p
) == current_function_decl
)
1286 warning_at (DECL_SOURCE_LOCATION (p
),
1287 OPT_Wunused_but_set_variable
,
1288 "variable %qD set but not used", p
);
1293 error ("type of array %q+D completed incompatibly with"
1294 " implicit initialization", p
);
1301 /* All of these go in BLOCK_VARS, but only if this is the
1302 binding in the home scope. */
1305 DECL_CHAIN (p
) = BLOCK_VARS (block
);
1306 BLOCK_VARS (block
) = p
;
1308 else if (VAR_OR_FUNCTION_DECL_P (p
) && scope
!= file_scope
)
1310 /* For block local externs add a special
1311 DECL_EXTERNAL decl for debug info generation. */
1312 tree extp
= copy_node (p
);
1314 DECL_EXTERNAL (extp
) = 1;
1315 TREE_STATIC (extp
) = 0;
1316 TREE_PUBLIC (extp
) = 1;
1317 DECL_INITIAL (extp
) = NULL_TREE
;
1318 DECL_LANG_SPECIFIC (extp
) = NULL
;
1319 DECL_CONTEXT (extp
) = current_function_decl
;
1320 if (TREE_CODE (p
) == FUNCTION_DECL
)
1322 DECL_RESULT (extp
) = NULL_TREE
;
1323 DECL_SAVED_TREE (extp
) = NULL_TREE
;
1324 DECL_STRUCT_FUNCTION (extp
) = NULL
;
1326 if (b
->locus
!= UNKNOWN_LOCATION
)
1327 DECL_SOURCE_LOCATION (extp
) = b
->locus
;
1328 DECL_CHAIN (extp
) = BLOCK_VARS (block
);
1329 BLOCK_VARS (block
) = extp
;
1331 /* If this is the file scope set DECL_CONTEXT of each decl to
1332 the TRANSLATION_UNIT_DECL. This makes same_translation_unit_p
1334 if (scope
== file_scope
)
1336 DECL_CONTEXT (p
) = context
;
1337 if (TREE_CODE (p
) == TYPE_DECL
1338 && TREE_TYPE (p
) != error_mark_node
)
1339 set_type_context (TREE_TYPE (p
), context
);
1343 /* Parameters go in DECL_ARGUMENTS, not BLOCK_VARS, and have
1344 already been put there by store_parm_decls. Unused-
1345 parameter warnings are handled by function.c.
1346 error_mark_node obviously does not go in BLOCK_VARS and
1347 does not get unused-variable warnings. */
1350 /* It is possible for a decl not to have a name. We get
1351 here with b->id NULL in this case. */
1354 gcc_assert (I_SYMBOL_BINDING (b
->id
) == b
);
1355 I_SYMBOL_BINDING (b
->id
) = b
->shadowed
;
1356 if (b
->shadowed
&& b
->shadowed
->u
.type
)
1357 TREE_TYPE (b
->shadowed
->decl
) = b
->shadowed
->u
.type
;
1367 /* Dispose of the block that we just made inside some higher level. */
1368 if ((scope
->function_body
|| scope
== file_scope
) && context
)
1370 DECL_INITIAL (context
) = block
;
1371 BLOCK_SUPERCONTEXT (block
) = context
;
1373 else if (scope
->outer
)
1376 SCOPE_LIST_APPEND (scope
->outer
, blocks
, block
);
1377 /* If we did not make a block for the scope just exited, any
1378 blocks made for inner scopes must be carried forward so they
1379 will later become subblocks of something else. */
1380 else if (scope
->blocks
)
1381 SCOPE_LIST_CONCAT (scope
->outer
, blocks
, scope
, blocks
);
1384 /* Pop the current scope, and free the structure for reuse. */
1385 current_scope
= scope
->outer
;
1386 if (scope
->function_body
)
1387 current_function_scope
= scope
->outer_function
;
1389 memset (scope
, 0, sizeof (struct c_scope
));
1390 scope
->outer
= scope_freelist
;
1391 scope_freelist
= scope
;
1397 push_file_scope (void)
1405 file_scope
= current_scope
;
1407 start_fname_decls ();
1409 for (decl
= visible_builtins
; decl
; decl
= DECL_CHAIN (decl
))
1410 bind (DECL_NAME (decl
), decl
, file_scope
,
1411 /*invisible=*/false, /*nested=*/true, DECL_SOURCE_LOCATION (decl
));
1415 pop_file_scope (void)
1417 /* In case there were missing closebraces, get us back to the global
1419 while (current_scope
!= file_scope
)
1422 /* __FUNCTION__ is defined at file scope (""). This
1423 call may not be necessary as my tests indicate it
1424 still works without it. */
1425 finish_fname_decls ();
1427 check_inline_statics ();
1429 /* This is the point to write out a PCH if we're doing that.
1430 In that case we do not want to do anything else. */
1433 c_common_write_pch ();
1437 /* Pop off the file scope and close this translation unit. */
1441 maybe_apply_pending_pragma_weaks ();
1444 /* Adjust the bindings for the start of a statement expression. */
1447 c_bindings_start_stmt_expr (struct c_spot_bindings
* switch_bindings
)
1449 struct c_scope
*scope
;
1451 for (scope
= current_scope
; scope
!= NULL
; scope
= scope
->outer
)
1453 struct c_binding
*b
;
1455 if (!scope
->has_label_bindings
)
1458 for (b
= scope
->bindings
; b
!= NULL
; b
= b
->prev
)
1460 struct c_label_vars
*label_vars
;
1462 struct c_goto_bindings
*g
;
1464 if (TREE_CODE (b
->decl
) != LABEL_DECL
)
1466 label_vars
= b
->u
.label
;
1467 ++label_vars
->label_bindings
.stmt_exprs
;
1468 FOR_EACH_VEC_SAFE_ELT (label_vars
->gotos
, ix
, g
)
1469 ++g
->goto_bindings
.stmt_exprs
;
1473 if (switch_bindings
!= NULL
)
1474 ++switch_bindings
->stmt_exprs
;
1477 /* Adjust the bindings for the end of a statement expression. */
1480 c_bindings_end_stmt_expr (struct c_spot_bindings
*switch_bindings
)
1482 struct c_scope
*scope
;
1484 for (scope
= current_scope
; scope
!= NULL
; scope
= scope
->outer
)
1486 struct c_binding
*b
;
1488 if (!scope
->has_label_bindings
)
1491 for (b
= scope
->bindings
; b
!= NULL
; b
= b
->prev
)
1493 struct c_label_vars
*label_vars
;
1495 struct c_goto_bindings
*g
;
1497 if (TREE_CODE (b
->decl
) != LABEL_DECL
)
1499 label_vars
= b
->u
.label
;
1500 --label_vars
->label_bindings
.stmt_exprs
;
1501 if (label_vars
->label_bindings
.stmt_exprs
< 0)
1503 label_vars
->label_bindings
.left_stmt_expr
= true;
1504 label_vars
->label_bindings
.stmt_exprs
= 0;
1506 FOR_EACH_VEC_SAFE_ELT (label_vars
->gotos
, ix
, g
)
1508 --g
->goto_bindings
.stmt_exprs
;
1509 if (g
->goto_bindings
.stmt_exprs
< 0)
1511 g
->goto_bindings
.left_stmt_expr
= true;
1512 g
->goto_bindings
.stmt_exprs
= 0;
1518 if (switch_bindings
!= NULL
)
1520 --switch_bindings
->stmt_exprs
;
1521 gcc_assert (switch_bindings
->stmt_exprs
>= 0);
1525 /* Push a definition or a declaration of struct, union or enum tag "name".
1526 "type" should be the type node.
1527 We assume that the tag "name" is not already defined, and has a location
1530 Note that the definition may really be just a forward reference.
1531 In that case, the TYPE_SIZE will be zero. */
1534 pushtag (location_t loc
, tree name
, tree type
)
1536 /* Record the identifier as the type's name if it has none. */
1537 if (name
&& !TYPE_NAME (type
))
1538 TYPE_NAME (type
) = name
;
1539 bind (name
, type
, current_scope
, /*invisible=*/false, /*nested=*/false, loc
);
1541 /* Create a fake NULL-named TYPE_DECL node whose TREE_TYPE will be the
1542 tagged type we just added to the current scope. This fake
1543 NULL-named TYPE_DECL node helps dwarfout.c to know when it needs
1544 to output a representation of a tagged type, and it also gives
1545 us a convenient place to record the "scope start" address for the
1548 TYPE_STUB_DECL (type
) = pushdecl (build_decl (loc
,
1549 TYPE_DECL
, NULL_TREE
, type
));
1551 /* An approximation for now, so we can tell this is a function-scope tag.
1552 This will be updated in pop_scope. */
1553 TYPE_CONTEXT (type
) = DECL_CONTEXT (TYPE_STUB_DECL (type
));
1555 if (warn_cxx_compat
&& name
!= NULL_TREE
)
1557 struct c_binding
*b
= I_SYMBOL_BINDING (name
);
1560 && b
->decl
!= NULL_TREE
1561 && TREE_CODE (b
->decl
) == TYPE_DECL
1562 && (B_IN_CURRENT_SCOPE (b
)
1563 || (current_scope
== file_scope
&& B_IN_EXTERNAL_SCOPE (b
)))
1564 && (TYPE_MAIN_VARIANT (TREE_TYPE (b
->decl
))
1565 != TYPE_MAIN_VARIANT (type
)))
1567 warning_at (loc
, OPT_Wc___compat
,
1568 ("using %qD as both a typedef and a tag is "
1571 if (b
->locus
!= UNKNOWN_LOCATION
)
1572 inform (b
->locus
, "originally defined here");
1577 /* An exported interface to pushtag. This is used by the gdb plugin's
1578 binding oracle to introduce a new tag binding. */
1581 c_pushtag (location_t loc
, tree name
, tree type
)
1583 pushtag (loc
, name
, type
);
1586 /* An exported interface to bind a declaration. LOC is the location
1587 to use. DECL is the declaration to bind. The decl's name is used
1588 to determine how it is bound. If DECL is a VAR_DECL, then
1589 IS_GLOBAL determines whether the decl is put into the global (file
1590 and external) scope or the current function's scope; if DECL is not
1591 a VAR_DECL then it is always put into the file scope. */
1594 c_bind (location_t loc
, tree decl
, bool is_global
)
1596 struct c_scope
*scope
;
1597 bool nested
= false;
1599 if (!VAR_P (decl
) || current_function_scope
== NULL
)
1601 /* Types and functions are always considered to be global. */
1603 DECL_EXTERNAL (decl
) = 1;
1604 TREE_PUBLIC (decl
) = 1;
1608 /* Also bind it into the external scope. */
1609 bind (DECL_NAME (decl
), decl
, external_scope
, true, false, loc
);
1612 DECL_EXTERNAL (decl
) = 1;
1613 TREE_PUBLIC (decl
) = 1;
1617 DECL_CONTEXT (decl
) = current_function_decl
;
1618 TREE_PUBLIC (decl
) = 0;
1619 scope
= current_function_scope
;
1622 bind (DECL_NAME (decl
), decl
, scope
, false, nested
, loc
);
1625 /* Subroutine of compare_decls. Allow harmless mismatches in return
1626 and argument types provided that the type modes match. This function
1627 return a unified type given a suitable match, and 0 otherwise. */
1630 match_builtin_function_types (tree newtype
, tree oldtype
)
1632 tree newrettype
, oldrettype
;
1633 tree newargs
, oldargs
;
1634 tree trytype
, tryargs
;
1636 /* Accept the return type of the new declaration if same modes. */
1637 oldrettype
= TREE_TYPE (oldtype
);
1638 newrettype
= TREE_TYPE (newtype
);
1640 if (TYPE_MODE (oldrettype
) != TYPE_MODE (newrettype
))
1643 oldargs
= TYPE_ARG_TYPES (oldtype
);
1644 newargs
= TYPE_ARG_TYPES (newtype
);
1647 while (oldargs
|| newargs
)
1651 || !TREE_VALUE (oldargs
)
1652 || !TREE_VALUE (newargs
)
1653 || TYPE_MODE (TREE_VALUE (oldargs
))
1654 != TYPE_MODE (TREE_VALUE (newargs
)))
1657 oldargs
= TREE_CHAIN (oldargs
);
1658 newargs
= TREE_CHAIN (newargs
);
1661 trytype
= build_function_type (newrettype
, tryargs
);
1662 return build_type_attribute_variant (trytype
, TYPE_ATTRIBUTES (oldtype
));
1665 /* Subroutine of diagnose_mismatched_decls. Check for function type
1666 mismatch involving an empty arglist vs a nonempty one and give clearer
1669 diagnose_arglist_conflict (tree newdecl
, tree olddecl
,
1670 tree newtype
, tree oldtype
)
1674 if (TREE_CODE (olddecl
) != FUNCTION_DECL
1675 || !comptypes (TREE_TYPE (oldtype
), TREE_TYPE (newtype
))
1676 || !((!prototype_p (oldtype
) && DECL_INITIAL (olddecl
) == 0)
1677 || (!prototype_p (newtype
) && DECL_INITIAL (newdecl
) == 0)))
1680 t
= TYPE_ARG_TYPES (oldtype
);
1682 t
= TYPE_ARG_TYPES (newtype
);
1683 for (; t
; t
= TREE_CHAIN (t
))
1685 tree type
= TREE_VALUE (t
);
1687 if (TREE_CHAIN (t
) == 0
1688 && TYPE_MAIN_VARIANT (type
) != void_type_node
)
1690 inform (input_location
, "a parameter list with an ellipsis can%'t match "
1691 "an empty parameter name list declaration");
1695 if (c_type_promotes_to (type
) != type
)
1697 inform (input_location
, "an argument type that has a default promotion can%'t match "
1698 "an empty parameter name list declaration");
1704 /* Another subroutine of diagnose_mismatched_decls. OLDDECL is an
1705 old-style function definition, NEWDECL is a prototype declaration.
1706 Diagnose inconsistencies in the argument list. Returns TRUE if
1707 the prototype is compatible, FALSE if not. */
1709 validate_proto_after_old_defn (tree newdecl
, tree newtype
, tree oldtype
)
1711 tree newargs
, oldargs
;
1714 #define END_OF_ARGLIST(t) ((t) == void_type_node)
1716 oldargs
= TYPE_ACTUAL_ARG_TYPES (oldtype
);
1717 newargs
= TYPE_ARG_TYPES (newtype
);
1722 tree oldargtype
= TREE_VALUE (oldargs
);
1723 tree newargtype
= TREE_VALUE (newargs
);
1725 if (oldargtype
== error_mark_node
|| newargtype
== error_mark_node
)
1728 oldargtype
= (TYPE_ATOMIC (oldargtype
)
1729 ? c_build_qualified_type (TYPE_MAIN_VARIANT (oldargtype
),
1731 : TYPE_MAIN_VARIANT (oldargtype
));
1732 newargtype
= (TYPE_ATOMIC (newargtype
)
1733 ? c_build_qualified_type (TYPE_MAIN_VARIANT (newargtype
),
1735 : TYPE_MAIN_VARIANT (newargtype
));
1737 if (END_OF_ARGLIST (oldargtype
) && END_OF_ARGLIST (newargtype
))
1740 /* Reaching the end of just one list means the two decls don't
1741 agree on the number of arguments. */
1742 if (END_OF_ARGLIST (oldargtype
))
1744 error ("prototype for %q+D declares more arguments "
1745 "than previous old-style definition", newdecl
);
1748 else if (END_OF_ARGLIST (newargtype
))
1750 error ("prototype for %q+D declares fewer arguments "
1751 "than previous old-style definition", newdecl
);
1755 /* Type for passing arg must be consistent with that declared
1757 else if (!comptypes (oldargtype
, newargtype
))
1759 error ("prototype for %q+D declares argument %d"
1760 " with incompatible type",
1765 oldargs
= TREE_CHAIN (oldargs
);
1766 newargs
= TREE_CHAIN (newargs
);
1770 /* If we get here, no errors were found, but do issue a warning
1771 for this poor-style construct. */
1772 warning (0, "prototype for %q+D follows non-prototype definition",
1775 #undef END_OF_ARGLIST
1778 /* Subroutine of diagnose_mismatched_decls. Report the location of DECL,
1779 first in a pair of mismatched declarations, using the diagnostic
1782 locate_old_decl (tree decl
)
1784 if (TREE_CODE (decl
) == FUNCTION_DECL
&& DECL_BUILT_IN (decl
)
1785 && !C_DECL_DECLARED_BUILTIN (decl
))
1787 else if (DECL_INITIAL (decl
))
1788 inform (input_location
, "previous definition of %q+D was here", decl
);
1789 else if (C_DECL_IMPLICIT (decl
))
1790 inform (input_location
, "previous implicit declaration of %q+D was here", decl
);
1792 inform (input_location
, "previous declaration of %q+D was here", decl
);
1795 /* Subroutine of duplicate_decls. Compare NEWDECL to OLDDECL.
1796 Returns true if the caller should proceed to merge the two, false
1797 if OLDDECL should simply be discarded. As a side effect, issues
1798 all necessary diagnostics for invalid or poor-style combinations.
1799 If it returns true, writes the types of NEWDECL and OLDDECL to
1800 *NEWTYPEP and *OLDTYPEP - these may have been adjusted from
1801 TREE_TYPE (NEWDECL, OLDDECL) respectively. */
1804 diagnose_mismatched_decls (tree newdecl
, tree olddecl
,
1805 tree
*newtypep
, tree
*oldtypep
)
1807 tree newtype
, oldtype
;
1808 bool pedwarned
= false;
1809 bool warned
= false;
1812 #define DECL_EXTERN_INLINE(DECL) (DECL_DECLARED_INLINE_P (DECL) \
1813 && DECL_EXTERNAL (DECL))
1815 /* If we have error_mark_node for either decl or type, just discard
1816 the previous decl - we're in an error cascade already. */
1817 if (olddecl
== error_mark_node
|| newdecl
== error_mark_node
)
1819 *oldtypep
= oldtype
= TREE_TYPE (olddecl
);
1820 *newtypep
= newtype
= TREE_TYPE (newdecl
);
1821 if (oldtype
== error_mark_node
|| newtype
== error_mark_node
)
1824 /* Two different categories of symbol altogether. This is an error
1825 unless OLDDECL is a builtin. OLDDECL will be discarded in any case. */
1826 if (TREE_CODE (olddecl
) != TREE_CODE (newdecl
))
1828 if (!(TREE_CODE (olddecl
) == FUNCTION_DECL
1829 && DECL_BUILT_IN (olddecl
)
1830 && !C_DECL_DECLARED_BUILTIN (olddecl
)))
1832 error ("%q+D redeclared as different kind of symbol", newdecl
);
1833 locate_old_decl (olddecl
);
1835 else if (TREE_PUBLIC (newdecl
))
1836 warning (0, "built-in function %q+D declared as non-function",
1839 warning (OPT_Wshadow
, "declaration of %q+D shadows "
1840 "a built-in function", newdecl
);
1844 /* Enumerators have no linkage, so may only be declared once in a
1846 if (TREE_CODE (olddecl
) == CONST_DECL
)
1848 error ("redeclaration of enumerator %q+D", newdecl
);
1849 locate_old_decl (olddecl
);
1853 if (!comptypes (oldtype
, newtype
))
1855 if (TREE_CODE (olddecl
) == FUNCTION_DECL
1856 && DECL_BUILT_IN (olddecl
) && !C_DECL_DECLARED_BUILTIN (olddecl
))
1858 /* Accept harmless mismatch in function types.
1859 This is for the ffs and fprintf builtins. */
1860 tree trytype
= match_builtin_function_types (newtype
, oldtype
);
1862 if (trytype
&& comptypes (newtype
, trytype
))
1863 *oldtypep
= oldtype
= trytype
;
1866 /* If types don't match for a built-in, throw away the
1867 built-in. No point in calling locate_old_decl here, it
1868 won't print anything. */
1869 warning (0, "conflicting types for built-in function %q+D",
1874 else if (TREE_CODE (olddecl
) == FUNCTION_DECL
1875 && DECL_IS_BUILTIN (olddecl
))
1877 /* A conflicting function declaration for a predeclared
1878 function that isn't actually built in. Objective C uses
1879 these. The new declaration silently overrides everything
1880 but the volatility (i.e. noreturn) indication. See also
1881 below. FIXME: Make Objective C use normal builtins. */
1882 TREE_THIS_VOLATILE (newdecl
) |= TREE_THIS_VOLATILE (olddecl
);
1885 /* Permit void foo (...) to match int foo (...) if the latter is
1886 the definition and implicit int was used. See
1887 c-torture/compile/920625-2.c. */
1888 else if (TREE_CODE (newdecl
) == FUNCTION_DECL
&& DECL_INITIAL (newdecl
)
1889 && TYPE_MAIN_VARIANT (TREE_TYPE (oldtype
)) == void_type_node
1890 && TYPE_MAIN_VARIANT (TREE_TYPE (newtype
)) == integer_type_node
1891 && C_FUNCTION_IMPLICIT_INT (newdecl
) && !DECL_INITIAL (olddecl
))
1893 pedwarned
= pedwarn (input_location
, 0,
1894 "conflicting types for %q+D", newdecl
);
1895 /* Make sure we keep void as the return type. */
1896 TREE_TYPE (newdecl
) = *newtypep
= newtype
= oldtype
;
1897 C_FUNCTION_IMPLICIT_INT (newdecl
) = 0;
1899 /* Permit void foo (...) to match an earlier call to foo (...) with
1900 no declared type (thus, implicitly int). */
1901 else if (TREE_CODE (newdecl
) == FUNCTION_DECL
1902 && TYPE_MAIN_VARIANT (TREE_TYPE (newtype
)) == void_type_node
1903 && TYPE_MAIN_VARIANT (TREE_TYPE (oldtype
)) == integer_type_node
1904 && C_DECL_IMPLICIT (olddecl
) && !DECL_INITIAL (olddecl
))
1906 pedwarned
= pedwarn (input_location
, 0,
1907 "conflicting types for %q+D", newdecl
);
1908 /* Make sure we keep void as the return type. */
1909 TREE_TYPE (olddecl
) = *oldtypep
= oldtype
= newtype
;
1913 int new_quals
= TYPE_QUALS (newtype
);
1914 int old_quals
= TYPE_QUALS (oldtype
);
1916 if (new_quals
!= old_quals
)
1918 addr_space_t new_addr
= DECODE_QUAL_ADDR_SPACE (new_quals
);
1919 addr_space_t old_addr
= DECODE_QUAL_ADDR_SPACE (old_quals
);
1920 if (new_addr
!= old_addr
)
1922 if (ADDR_SPACE_GENERIC_P (new_addr
))
1923 error ("conflicting named address spaces (generic vs %s) "
1925 c_addr_space_name (old_addr
), newdecl
);
1926 else if (ADDR_SPACE_GENERIC_P (old_addr
))
1927 error ("conflicting named address spaces (%s vs generic) "
1929 c_addr_space_name (new_addr
), newdecl
);
1931 error ("conflicting named address spaces (%s vs %s) "
1933 c_addr_space_name (new_addr
),
1934 c_addr_space_name (old_addr
),
1938 if (CLEAR_QUAL_ADDR_SPACE (new_quals
)
1939 != CLEAR_QUAL_ADDR_SPACE (old_quals
))
1940 error ("conflicting type qualifiers for %q+D", newdecl
);
1943 error ("conflicting types for %q+D", newdecl
);
1944 diagnose_arglist_conflict (newdecl
, olddecl
, newtype
, oldtype
);
1945 locate_old_decl (olddecl
);
1950 /* Redeclaration of a type is a constraint violation (6.7.2.3p1),
1951 but silently ignore the redeclaration if either is in a system
1952 header. (Conflicting redeclarations were handled above.) This
1953 is allowed for C11 if the types are the same, not just
1955 if (TREE_CODE (newdecl
) == TYPE_DECL
)
1957 bool types_different
= false;
1958 int comptypes_result
;
1961 = comptypes_check_different_types (oldtype
, newtype
, &types_different
);
1963 if (comptypes_result
!= 1 || types_different
)
1965 error ("redefinition of typedef %q+D with different type", newdecl
);
1966 locate_old_decl (olddecl
);
1970 if (DECL_IN_SYSTEM_HEADER (newdecl
)
1971 || DECL_IN_SYSTEM_HEADER (olddecl
)
1972 || TREE_NO_WARNING (newdecl
)
1973 || TREE_NO_WARNING (olddecl
))
1974 return true; /* Allow OLDDECL to continue in use. */
1976 if (variably_modified_type_p (newtype
, NULL
))
1978 error ("redefinition of typedef %q+D with variably modified type",
1980 locate_old_decl (olddecl
);
1982 else if (pedwarn_c99 (input_location
, OPT_Wpedantic
,
1983 "redefinition of typedef %q+D", newdecl
))
1984 locate_old_decl (olddecl
);
1989 /* Function declarations can either be 'static' or 'extern' (no
1990 qualifier is equivalent to 'extern' - C99 6.2.2p5) and therefore
1991 can never conflict with each other on account of linkage
1992 (6.2.2p4). Multiple definitions are not allowed (6.9p3,5) but
1993 gnu89 mode permits two definitions if one is 'extern inline' and
1994 one is not. The non- extern-inline definition supersedes the
1995 extern-inline definition. */
1997 else if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
1999 /* If you declare a built-in function name as static, or
2000 define the built-in with an old-style definition (so we
2001 can't validate the argument list) the built-in definition is
2002 overridden, but optionally warn this was a bad choice of name. */
2003 if (DECL_BUILT_IN (olddecl
)
2004 && !C_DECL_DECLARED_BUILTIN (olddecl
)
2005 && (!TREE_PUBLIC (newdecl
)
2006 || (DECL_INITIAL (newdecl
)
2007 && !prototype_p (TREE_TYPE (newdecl
)))))
2009 warning (OPT_Wshadow
, "declaration of %q+D shadows "
2010 "a built-in function", newdecl
);
2011 /* Discard the old built-in function. */
2015 if (DECL_INITIAL (newdecl
))
2017 if (DECL_INITIAL (olddecl
))
2019 /* If both decls are in the same TU and the new declaration
2020 isn't overriding an extern inline reject the new decl.
2021 In c99, no overriding is allowed in the same translation
2023 if ((!DECL_EXTERN_INLINE (olddecl
)
2024 || DECL_EXTERN_INLINE (newdecl
)
2025 || (!flag_gnu89_inline
2026 && (!DECL_DECLARED_INLINE_P (olddecl
)
2027 || !lookup_attribute ("gnu_inline",
2028 DECL_ATTRIBUTES (olddecl
)))
2029 && (!DECL_DECLARED_INLINE_P (newdecl
)
2030 || !lookup_attribute ("gnu_inline",
2031 DECL_ATTRIBUTES (newdecl
))))
2033 && same_translation_unit_p (newdecl
, olddecl
))
2035 error ("redefinition of %q+D", newdecl
);
2036 locate_old_decl (olddecl
);
2041 /* If we have a prototype after an old-style function definition,
2042 the argument types must be checked specially. */
2043 else if (DECL_INITIAL (olddecl
)
2044 && !prototype_p (oldtype
) && prototype_p (newtype
)
2045 && TYPE_ACTUAL_ARG_TYPES (oldtype
)
2046 && !validate_proto_after_old_defn (newdecl
, newtype
, oldtype
))
2048 locate_old_decl (olddecl
);
2051 /* A non-static declaration (even an "extern") followed by a
2052 static declaration is undefined behavior per C99 6.2.2p3-5,7.
2053 The same is true for a static forward declaration at block
2054 scope followed by a non-static declaration/definition at file
2055 scope. Static followed by non-static at the same scope is
2056 not undefined behavior, and is the most convenient way to get
2057 some effects (see e.g. what unwind-dw2-fde-glibc.c does to
2058 the definition of _Unwind_Find_FDE in unwind-dw2-fde.c), but
2059 we do diagnose it if -Wtraditional. */
2060 if (TREE_PUBLIC (olddecl
) && !TREE_PUBLIC (newdecl
))
2062 /* Two exceptions to the rule. If olddecl is an extern
2063 inline, or a predeclared function that isn't actually
2064 built in, newdecl silently overrides olddecl. The latter
2065 occur only in Objective C; see also above. (FIXME: Make
2066 Objective C use normal builtins.) */
2067 if (!DECL_IS_BUILTIN (olddecl
)
2068 && !DECL_EXTERN_INLINE (olddecl
))
2070 error ("static declaration of %q+D follows "
2071 "non-static declaration", newdecl
);
2072 locate_old_decl (olddecl
);
2076 else if (TREE_PUBLIC (newdecl
) && !TREE_PUBLIC (olddecl
))
2078 if (DECL_CONTEXT (olddecl
))
2080 error ("non-static declaration of %q+D follows "
2081 "static declaration", newdecl
);
2082 locate_old_decl (olddecl
);
2085 else if (warn_traditional
)
2087 warned
|= warning (OPT_Wtraditional
,
2088 "non-static declaration of %q+D "
2089 "follows static declaration", newdecl
);
2093 /* Make sure gnu_inline attribute is either not present, or
2094 present on all inline decls. */
2095 if (DECL_DECLARED_INLINE_P (olddecl
)
2096 && DECL_DECLARED_INLINE_P (newdecl
))
2098 bool newa
= lookup_attribute ("gnu_inline",
2099 DECL_ATTRIBUTES (newdecl
)) != NULL
;
2100 bool olda
= lookup_attribute ("gnu_inline",
2101 DECL_ATTRIBUTES (olddecl
)) != NULL
;
2104 error_at (input_location
, "%<gnu_inline%> attribute present on %q+D",
2105 newa
? newdecl
: olddecl
);
2106 error_at (DECL_SOURCE_LOCATION (newa
? olddecl
: newdecl
),
2111 else if (VAR_P (newdecl
))
2113 /* Only variables can be thread-local, and all declarations must
2114 agree on this property. */
2115 if (C_DECL_THREADPRIVATE_P (olddecl
) && !DECL_THREAD_LOCAL_P (newdecl
))
2117 /* Nothing to check. Since OLDDECL is marked threadprivate
2118 and NEWDECL does not have a thread-local attribute, we
2119 will merge the threadprivate attribute into NEWDECL. */
2122 else if (DECL_THREAD_LOCAL_P (newdecl
) != DECL_THREAD_LOCAL_P (olddecl
))
2124 if (DECL_THREAD_LOCAL_P (newdecl
))
2125 error ("thread-local declaration of %q+D follows "
2126 "non-thread-local declaration", newdecl
);
2128 error ("non-thread-local declaration of %q+D follows "
2129 "thread-local declaration", newdecl
);
2131 locate_old_decl (olddecl
);
2135 /* Multiple initialized definitions are not allowed (6.9p3,5). */
2136 if (DECL_INITIAL (newdecl
) && DECL_INITIAL (olddecl
))
2138 error ("redefinition of %q+D", newdecl
);
2139 locate_old_decl (olddecl
);
2143 /* Objects declared at file scope: if the first declaration had
2144 external linkage (even if it was an external reference) the
2145 second must have external linkage as well, or the behavior is
2146 undefined. If the first declaration had internal linkage, then
2147 the second must too, or else be an external reference (in which
2148 case the composite declaration still has internal linkage).
2149 As for function declarations, we warn about the static-then-
2150 extern case only for -Wtraditional. See generally 6.2.2p3-5,7. */
2151 if (DECL_FILE_SCOPE_P (newdecl
)
2152 && TREE_PUBLIC (newdecl
) != TREE_PUBLIC (olddecl
))
2154 if (DECL_EXTERNAL (newdecl
))
2156 if (!DECL_FILE_SCOPE_P (olddecl
))
2158 error ("extern declaration of %q+D follows "
2159 "declaration with no linkage", newdecl
);
2160 locate_old_decl (olddecl
);
2163 else if (warn_traditional
)
2165 warned
|= warning (OPT_Wtraditional
,
2166 "non-static declaration of %q+D "
2167 "follows static declaration", newdecl
);
2172 if (TREE_PUBLIC (newdecl
))
2173 error ("non-static declaration of %q+D follows "
2174 "static declaration", newdecl
);
2176 error ("static declaration of %q+D follows "
2177 "non-static declaration", newdecl
);
2179 locate_old_decl (olddecl
);
2183 /* Two objects with the same name declared at the same block
2184 scope must both be external references (6.7p3). */
2185 else if (!DECL_FILE_SCOPE_P (newdecl
))
2187 if (DECL_EXTERNAL (newdecl
))
2189 /* Extern with initializer at block scope, which will
2190 already have received an error. */
2192 else if (DECL_EXTERNAL (olddecl
))
2194 error ("declaration of %q+D with no linkage follows "
2195 "extern declaration", newdecl
);
2196 locate_old_decl (olddecl
);
2200 error ("redeclaration of %q+D with no linkage", newdecl
);
2201 locate_old_decl (olddecl
);
2207 /* C++ does not permit a decl to appear multiple times at file
2210 && DECL_FILE_SCOPE_P (newdecl
)
2211 && !DECL_EXTERNAL (newdecl
)
2212 && !DECL_EXTERNAL (olddecl
))
2213 warned
|= warning_at (DECL_SOURCE_LOCATION (newdecl
),
2215 ("duplicate declaration of %qD is "
2221 /* All decls must agree on a visibility. */
2222 if (CODE_CONTAINS_STRUCT (TREE_CODE (newdecl
), TS_DECL_WITH_VIS
)
2223 && DECL_VISIBILITY_SPECIFIED (newdecl
) && DECL_VISIBILITY_SPECIFIED (olddecl
)
2224 && DECL_VISIBILITY (newdecl
) != DECL_VISIBILITY (olddecl
))
2226 warned
|= warning (0, "redeclaration of %q+D with different visibility "
2227 "(old visibility preserved)", newdecl
);
2230 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
2232 /* Diagnose inline __attribute__ ((noinline)) which is silly. */
2233 if (DECL_DECLARED_INLINE_P (newdecl
)
2234 && lookup_attribute ("noinline", DECL_ATTRIBUTES (olddecl
)))
2235 warned
|= warning (OPT_Wattributes
,
2236 "inline declaration of %qD follows "
2237 "declaration with attribute noinline", newdecl
);
2238 else if (DECL_DECLARED_INLINE_P (olddecl
)
2239 && lookup_attribute ("noinline", DECL_ATTRIBUTES (newdecl
)))
2240 warned
|= warning (OPT_Wattributes
,
2241 "declaration of %q+D with attribute "
2242 "noinline follows inline declaration ", newdecl
);
2243 else if (lookup_attribute ("noinline", DECL_ATTRIBUTES (newdecl
))
2244 && lookup_attribute ("always_inline", DECL_ATTRIBUTES (olddecl
)))
2245 warned
|= warning (OPT_Wattributes
,
2246 "declaration of %q+D with attribute "
2247 "%qs follows declaration with attribute %qs",
2248 newdecl
, "noinline", "always_inline");
2249 else if (lookup_attribute ("always_inline", DECL_ATTRIBUTES (newdecl
))
2250 && lookup_attribute ("noinline", DECL_ATTRIBUTES (olddecl
)))
2251 warned
|= warning (OPT_Wattributes
,
2252 "declaration of %q+D with attribute "
2253 "%qs follows declaration with attribute %qs",
2254 newdecl
, "always_inline", "noinline");
2255 else if (lookup_attribute ("cold", DECL_ATTRIBUTES (newdecl
))
2256 && lookup_attribute ("hot", DECL_ATTRIBUTES (olddecl
)))
2257 warned
|= warning (OPT_Wattributes
,
2258 "declaration of %q+D with attribute %qs follows "
2259 "declaration with attribute %qs", newdecl
, "cold",
2261 else if (lookup_attribute ("hot", DECL_ATTRIBUTES (newdecl
))
2262 && lookup_attribute ("cold", DECL_ATTRIBUTES (olddecl
)))
2263 warned
|= warning (OPT_Wattributes
,
2264 "declaration of %q+D with attribute %qs follows "
2265 "declaration with attribute %qs", newdecl
, "hot",
2268 else /* PARM_DECL, VAR_DECL */
2270 /* Redeclaration of a parameter is a constraint violation (this is
2271 not explicitly stated, but follows from C99 6.7p3 [no more than
2272 one declaration of the same identifier with no linkage in the
2273 same scope, except type tags] and 6.2.2p6 [parameters have no
2274 linkage]). We must check for a forward parameter declaration,
2275 indicated by TREE_ASM_WRITTEN on the old declaration - this is
2276 an extension, the mandatory diagnostic for which is handled by
2277 mark_forward_parm_decls. */
2279 if (TREE_CODE (newdecl
) == PARM_DECL
2280 && (!TREE_ASM_WRITTEN (olddecl
) || TREE_ASM_WRITTEN (newdecl
)))
2282 error ("redefinition of parameter %q+D", newdecl
);
2283 locate_old_decl (olddecl
);
2288 /* Optional warning for completely redundant decls. */
2289 if (!warned
&& !pedwarned
2290 && warn_redundant_decls
2291 /* Don't warn about a function declaration followed by a
2293 && !(TREE_CODE (newdecl
) == FUNCTION_DECL
2294 && DECL_INITIAL (newdecl
) && !DECL_INITIAL (olddecl
))
2295 /* Don't warn about redundant redeclarations of builtins. */
2296 && !(TREE_CODE (newdecl
) == FUNCTION_DECL
2297 && !DECL_BUILT_IN (newdecl
)
2298 && DECL_BUILT_IN (olddecl
)
2299 && !C_DECL_DECLARED_BUILTIN (olddecl
))
2300 /* Don't warn about an extern followed by a definition. */
2301 && !(DECL_EXTERNAL (olddecl
) && !DECL_EXTERNAL (newdecl
))
2302 /* Don't warn about forward parameter decls. */
2303 && !(TREE_CODE (newdecl
) == PARM_DECL
2304 && TREE_ASM_WRITTEN (olddecl
) && !TREE_ASM_WRITTEN (newdecl
))
2305 /* Don't warn about a variable definition following a declaration. */
2306 && !(VAR_P (newdecl
)
2307 && DECL_INITIAL (newdecl
) && !DECL_INITIAL (olddecl
)))
2309 warned
= warning (OPT_Wredundant_decls
, "redundant redeclaration of %q+D",
2313 /* Report location of previous decl/defn. */
2314 if (warned
|| pedwarned
)
2315 locate_old_decl (olddecl
);
2317 #undef DECL_EXTERN_INLINE
2322 /* Subroutine of duplicate_decls. NEWDECL has been found to be
2323 consistent with OLDDECL, but carries new information. Merge the
2324 new information into OLDDECL. This function issues no
2328 merge_decls (tree newdecl
, tree olddecl
, tree newtype
, tree oldtype
)
2330 bool new_is_definition
= (TREE_CODE (newdecl
) == FUNCTION_DECL
2331 && DECL_INITIAL (newdecl
) != 0);
2332 bool new_is_prototype
= (TREE_CODE (newdecl
) == FUNCTION_DECL
2333 && prototype_p (TREE_TYPE (newdecl
)));
2334 bool old_is_prototype
= (TREE_CODE (olddecl
) == FUNCTION_DECL
2335 && prototype_p (TREE_TYPE (olddecl
)));
2337 /* For real parm decl following a forward decl, rechain the old decl
2338 in its new location and clear TREE_ASM_WRITTEN (it's not a
2339 forward decl anymore). */
2340 if (TREE_CODE (newdecl
) == PARM_DECL
2341 && TREE_ASM_WRITTEN (olddecl
) && !TREE_ASM_WRITTEN (newdecl
))
2343 struct c_binding
*b
, **here
;
2345 for (here
= ¤t_scope
->bindings
; *here
; here
= &(*here
)->prev
)
2346 if ((*here
)->decl
== olddecl
)
2353 b
->prev
= current_scope
->bindings
;
2354 current_scope
->bindings
= b
;
2356 TREE_ASM_WRITTEN (olddecl
) = 0;
2359 DECL_ATTRIBUTES (newdecl
)
2360 = targetm
.merge_decl_attributes (olddecl
, newdecl
);
2362 /* Merge the data types specified in the two decls. */
2364 = TREE_TYPE (olddecl
)
2365 = composite_type (newtype
, oldtype
);
2367 /* Lay the type out, unless already done. */
2368 if (!comptypes (oldtype
, TREE_TYPE (newdecl
)))
2370 if (TREE_TYPE (newdecl
) != error_mark_node
)
2371 layout_type (TREE_TYPE (newdecl
));
2372 if (TREE_CODE (newdecl
) != FUNCTION_DECL
2373 && TREE_CODE (newdecl
) != TYPE_DECL
2374 && TREE_CODE (newdecl
) != CONST_DECL
)
2375 layout_decl (newdecl
, 0);
2379 /* Since the type is OLDDECL's, make OLDDECL's size go with. */
2380 DECL_SIZE (newdecl
) = DECL_SIZE (olddecl
);
2381 DECL_SIZE_UNIT (newdecl
) = DECL_SIZE_UNIT (olddecl
);
2382 DECL_MODE (newdecl
) = DECL_MODE (olddecl
);
2383 if (DECL_ALIGN (olddecl
) > DECL_ALIGN (newdecl
))
2385 DECL_ALIGN (newdecl
) = DECL_ALIGN (olddecl
);
2386 DECL_USER_ALIGN (newdecl
) |= DECL_USER_ALIGN (olddecl
);
2390 /* Keep the old rtl since we can safely use it. */
2391 if (HAS_RTL_P (olddecl
))
2392 COPY_DECL_RTL (olddecl
, newdecl
);
2394 /* Merge the type qualifiers. */
2395 if (TREE_READONLY (newdecl
))
2396 TREE_READONLY (olddecl
) = 1;
2398 if (TREE_THIS_VOLATILE (newdecl
))
2399 TREE_THIS_VOLATILE (olddecl
) = 1;
2401 /* Merge deprecatedness. */
2402 if (TREE_DEPRECATED (newdecl
))
2403 TREE_DEPRECATED (olddecl
) = 1;
2405 /* If a decl is in a system header and the other isn't, keep the one on the
2406 system header. Otherwise, keep source location of definition rather than
2407 declaration and of prototype rather than non-prototype unless that
2408 prototype is built-in. */
2409 if (CODE_CONTAINS_STRUCT (TREE_CODE (olddecl
), TS_DECL_WITH_VIS
)
2410 && DECL_IN_SYSTEM_HEADER (olddecl
)
2411 && !DECL_IN_SYSTEM_HEADER (newdecl
) )
2412 DECL_SOURCE_LOCATION (newdecl
) = DECL_SOURCE_LOCATION (olddecl
);
2413 else if (CODE_CONTAINS_STRUCT (TREE_CODE (olddecl
), TS_DECL_WITH_VIS
)
2414 && DECL_IN_SYSTEM_HEADER (newdecl
)
2415 && !DECL_IN_SYSTEM_HEADER (olddecl
))
2416 DECL_SOURCE_LOCATION (olddecl
) = DECL_SOURCE_LOCATION (newdecl
);
2417 else if ((DECL_INITIAL (newdecl
) == 0 && DECL_INITIAL (olddecl
) != 0)
2418 || (old_is_prototype
&& !new_is_prototype
2419 && !C_DECL_BUILTIN_PROTOTYPE (olddecl
)))
2420 DECL_SOURCE_LOCATION (newdecl
) = DECL_SOURCE_LOCATION (olddecl
);
2422 /* Merge the initialization information. */
2423 if (DECL_INITIAL (newdecl
) == 0)
2424 DECL_INITIAL (newdecl
) = DECL_INITIAL (olddecl
);
2426 /* Merge the threadprivate attribute. */
2427 if (VAR_P (olddecl
) && C_DECL_THREADPRIVATE_P (olddecl
))
2428 C_DECL_THREADPRIVATE_P (newdecl
) = 1;
2430 if (CODE_CONTAINS_STRUCT (TREE_CODE (olddecl
), TS_DECL_WITH_VIS
))
2432 /* Copy the assembler name.
2433 Currently, it can only be defined in the prototype. */
2434 COPY_DECL_ASSEMBLER_NAME (olddecl
, newdecl
);
2436 /* Use visibility of whichever declaration had it specified */
2437 if (DECL_VISIBILITY_SPECIFIED (olddecl
))
2439 DECL_VISIBILITY (newdecl
) = DECL_VISIBILITY (olddecl
);
2440 DECL_VISIBILITY_SPECIFIED (newdecl
) = 1;
2443 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
2445 DECL_STATIC_CONSTRUCTOR(newdecl
) |= DECL_STATIC_CONSTRUCTOR(olddecl
);
2446 DECL_STATIC_DESTRUCTOR (newdecl
) |= DECL_STATIC_DESTRUCTOR (olddecl
);
2447 DECL_NO_LIMIT_STACK (newdecl
) |= DECL_NO_LIMIT_STACK (olddecl
);
2448 DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (newdecl
)
2449 |= DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (olddecl
);
2450 TREE_THIS_VOLATILE (newdecl
) |= TREE_THIS_VOLATILE (olddecl
);
2451 DECL_IS_MALLOC (newdecl
) |= DECL_IS_MALLOC (olddecl
);
2452 DECL_IS_OPERATOR_NEW (newdecl
) |= DECL_IS_OPERATOR_NEW (olddecl
);
2453 TREE_READONLY (newdecl
) |= TREE_READONLY (olddecl
);
2454 DECL_PURE_P (newdecl
) |= DECL_PURE_P (olddecl
);
2455 DECL_IS_NOVOPS (newdecl
) |= DECL_IS_NOVOPS (olddecl
);
2458 /* Merge the storage class information. */
2459 merge_weak (newdecl
, olddecl
);
2461 /* For functions, static overrides non-static. */
2462 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
2464 TREE_PUBLIC (newdecl
) &= TREE_PUBLIC (olddecl
);
2465 /* This is since we don't automatically
2466 copy the attributes of NEWDECL into OLDDECL. */
2467 TREE_PUBLIC (olddecl
) = TREE_PUBLIC (newdecl
);
2468 /* If this clears `static', clear it in the identifier too. */
2469 if (!TREE_PUBLIC (olddecl
))
2470 TREE_PUBLIC (DECL_NAME (olddecl
)) = 0;
2474 /* In c99, 'extern' declaration before (or after) 'inline' means this
2475 function is not DECL_EXTERNAL, unless 'gnu_inline' attribute
2477 if (TREE_CODE (newdecl
) == FUNCTION_DECL
2478 && !flag_gnu89_inline
2479 && (DECL_DECLARED_INLINE_P (newdecl
)
2480 || DECL_DECLARED_INLINE_P (olddecl
))
2481 && (!DECL_DECLARED_INLINE_P (newdecl
)
2482 || !DECL_DECLARED_INLINE_P (olddecl
)
2483 || !DECL_EXTERNAL (olddecl
))
2484 && DECL_EXTERNAL (newdecl
)
2485 && !lookup_attribute ("gnu_inline", DECL_ATTRIBUTES (newdecl
))
2486 && !current_function_decl
)
2487 DECL_EXTERNAL (newdecl
) = 0;
2489 /* An inline definition following a static declaration is not
2491 if (new_is_definition
2492 && (DECL_DECLARED_INLINE_P (newdecl
)
2493 || DECL_DECLARED_INLINE_P (olddecl
))
2494 && !TREE_PUBLIC (olddecl
))
2495 DECL_EXTERNAL (newdecl
) = 0;
2497 if (DECL_EXTERNAL (newdecl
))
2499 TREE_STATIC (newdecl
) = TREE_STATIC (olddecl
);
2500 DECL_EXTERNAL (newdecl
) = DECL_EXTERNAL (olddecl
);
2502 /* An extern decl does not override previous storage class. */
2503 TREE_PUBLIC (newdecl
) = TREE_PUBLIC (olddecl
);
2504 if (!DECL_EXTERNAL (newdecl
))
2506 DECL_CONTEXT (newdecl
) = DECL_CONTEXT (olddecl
);
2507 DECL_COMMON (newdecl
) = DECL_COMMON (olddecl
);
2512 TREE_STATIC (olddecl
) = TREE_STATIC (newdecl
);
2513 TREE_PUBLIC (olddecl
) = TREE_PUBLIC (newdecl
);
2516 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
2518 /* If we're redefining a function previously defined as extern
2519 inline, make sure we emit debug info for the inline before we
2520 throw it away, in case it was inlined into a function that
2521 hasn't been written out yet. */
2522 if (new_is_definition
&& DECL_INITIAL (olddecl
))
2523 /* The new defn must not be inline. */
2524 DECL_UNINLINABLE (newdecl
) = 1;
2527 /* If either decl says `inline', this fn is inline, unless
2528 its definition was passed already. */
2529 if (DECL_DECLARED_INLINE_P (newdecl
)
2530 || DECL_DECLARED_INLINE_P (olddecl
))
2531 DECL_DECLARED_INLINE_P (newdecl
) = 1;
2533 DECL_UNINLINABLE (newdecl
) = DECL_UNINLINABLE (olddecl
)
2534 = (DECL_UNINLINABLE (newdecl
) || DECL_UNINLINABLE (olddecl
));
2536 DECL_DISREGARD_INLINE_LIMITS (newdecl
)
2537 = DECL_DISREGARD_INLINE_LIMITS (olddecl
)
2538 = (DECL_DISREGARD_INLINE_LIMITS (newdecl
)
2539 || DECL_DISREGARD_INLINE_LIMITS (olddecl
));
2542 if (DECL_BUILT_IN (olddecl
))
2544 /* If redeclaring a builtin function, it stays built in.
2545 But it gets tagged as having been declared. */
2546 DECL_BUILT_IN_CLASS (newdecl
) = DECL_BUILT_IN_CLASS (olddecl
);
2547 DECL_FUNCTION_CODE (newdecl
) = DECL_FUNCTION_CODE (olddecl
);
2548 C_DECL_DECLARED_BUILTIN (newdecl
) = 1;
2549 if (new_is_prototype
)
2551 C_DECL_BUILTIN_PROTOTYPE (newdecl
) = 0;
2552 if (DECL_BUILT_IN_CLASS (newdecl
) == BUILT_IN_NORMAL
)
2554 enum built_in_function fncode
= DECL_FUNCTION_CODE (newdecl
);
2557 /* If a compatible prototype of these builtin functions
2558 is seen, assume the runtime implements it with the
2559 expected semantics. */
2560 case BUILT_IN_STPCPY
:
2561 if (builtin_decl_explicit_p (fncode
))
2562 set_builtin_decl_implicit_p (fncode
, true);
2565 if (builtin_decl_explicit_p (fncode
))
2566 set_builtin_decl_declared_p (fncode
, true);
2572 C_DECL_BUILTIN_PROTOTYPE (newdecl
)
2573 = C_DECL_BUILTIN_PROTOTYPE (olddecl
);
2576 /* Preserve function specific target and optimization options */
2577 if (DECL_FUNCTION_SPECIFIC_TARGET (olddecl
)
2578 && !DECL_FUNCTION_SPECIFIC_TARGET (newdecl
))
2579 DECL_FUNCTION_SPECIFIC_TARGET (newdecl
)
2580 = DECL_FUNCTION_SPECIFIC_TARGET (olddecl
);
2582 if (DECL_FUNCTION_SPECIFIC_OPTIMIZATION (olddecl
)
2583 && !DECL_FUNCTION_SPECIFIC_OPTIMIZATION (newdecl
))
2584 DECL_FUNCTION_SPECIFIC_OPTIMIZATION (newdecl
)
2585 = DECL_FUNCTION_SPECIFIC_OPTIMIZATION (olddecl
);
2587 /* Also preserve various other info from the definition. */
2588 if (!new_is_definition
)
2591 DECL_RESULT (newdecl
) = DECL_RESULT (olddecl
);
2592 DECL_INITIAL (newdecl
) = DECL_INITIAL (olddecl
);
2593 DECL_STRUCT_FUNCTION (newdecl
) = DECL_STRUCT_FUNCTION (olddecl
);
2594 DECL_SAVED_TREE (newdecl
) = DECL_SAVED_TREE (olddecl
);
2595 DECL_ARGUMENTS (newdecl
) = copy_list (DECL_ARGUMENTS (olddecl
));
2596 for (t
= DECL_ARGUMENTS (newdecl
); t
; t
= DECL_CHAIN (t
))
2597 DECL_CONTEXT (t
) = newdecl
;
2599 /* See if we've got a function to instantiate from. */
2600 if (DECL_SAVED_TREE (olddecl
))
2601 DECL_ABSTRACT_ORIGIN (newdecl
)
2602 = DECL_ABSTRACT_ORIGIN (olddecl
);
2606 /* Merge the USED information. */
2607 if (TREE_USED (olddecl
))
2608 TREE_USED (newdecl
) = 1;
2609 else if (TREE_USED (newdecl
))
2610 TREE_USED (olddecl
) = 1;
2611 if (VAR_P (olddecl
) || TREE_CODE (olddecl
) == PARM_DECL
)
2612 DECL_READ_P (newdecl
) |= DECL_READ_P (olddecl
);
2613 if (DECL_PRESERVE_P (olddecl
))
2614 DECL_PRESERVE_P (newdecl
) = 1;
2615 else if (DECL_PRESERVE_P (newdecl
))
2616 DECL_PRESERVE_P (olddecl
) = 1;
2618 /* Merge DECL_COMMON */
2619 if (VAR_P (olddecl
) && VAR_P (newdecl
)
2620 && !lookup_attribute ("common", DECL_ATTRIBUTES (newdecl
))
2621 && !lookup_attribute ("nocommon", DECL_ATTRIBUTES (newdecl
)))
2622 DECL_COMMON (newdecl
) = DECL_COMMON (newdecl
) && DECL_COMMON (olddecl
);
2624 /* Copy most of the decl-specific fields of NEWDECL into OLDDECL.
2625 But preserve OLDDECL's DECL_UID, DECL_CONTEXT and
2626 DECL_ARGUMENTS (if appropriate). */
2628 unsigned olddecl_uid
= DECL_UID (olddecl
);
2629 tree olddecl_context
= DECL_CONTEXT (olddecl
);
2630 tree olddecl_arguments
= NULL
;
2631 if (TREE_CODE (olddecl
) == FUNCTION_DECL
)
2632 olddecl_arguments
= DECL_ARGUMENTS (olddecl
);
2634 memcpy ((char *) olddecl
+ sizeof (struct tree_common
),
2635 (char *) newdecl
+ sizeof (struct tree_common
),
2636 sizeof (struct tree_decl_common
) - sizeof (struct tree_common
));
2637 DECL_USER_ALIGN (olddecl
) = DECL_USER_ALIGN (newdecl
);
2638 switch (TREE_CODE (olddecl
))
2643 struct symtab_node
*snode
= olddecl
->decl_with_vis
.symtab_node
;
2645 memcpy ((char *) olddecl
+ sizeof (struct tree_decl_common
),
2646 (char *) newdecl
+ sizeof (struct tree_decl_common
),
2647 tree_code_size (TREE_CODE (olddecl
)) - sizeof (struct tree_decl_common
));
2648 olddecl
->decl_with_vis
.symtab_node
= snode
;
2650 if ((DECL_EXTERNAL (olddecl
)
2651 || TREE_PUBLIC (olddecl
)
2652 || TREE_STATIC (olddecl
))
2653 && DECL_SECTION_NAME (newdecl
) != NULL
)
2654 set_decl_section_name (olddecl
, DECL_SECTION_NAME (newdecl
));
2656 /* This isn't quite correct for something like
2657 int __thread x attribute ((tls_model ("local-exec")));
2658 extern int __thread x;
2659 as we'll lose the "local-exec" model. */
2660 if (VAR_P (olddecl
) && DECL_THREAD_LOCAL_P (newdecl
))
2661 set_decl_tls_model (olddecl
, DECL_TLS_MODEL (newdecl
));
2671 memcpy ((char *) olddecl
+ sizeof (struct tree_decl_common
),
2672 (char *) newdecl
+ sizeof (struct tree_decl_common
),
2673 tree_code_size (TREE_CODE (olddecl
)) - sizeof (struct tree_decl_common
));
2678 memcpy ((char *) olddecl
+ sizeof (struct tree_decl_common
),
2679 (char *) newdecl
+ sizeof (struct tree_decl_common
),
2680 sizeof (struct tree_decl_non_common
) - sizeof (struct tree_decl_common
));
2682 DECL_UID (olddecl
) = olddecl_uid
;
2683 DECL_CONTEXT (olddecl
) = olddecl_context
;
2684 if (TREE_CODE (olddecl
) == FUNCTION_DECL
)
2685 DECL_ARGUMENTS (olddecl
) = olddecl_arguments
;
2688 /* If OLDDECL had its DECL_RTL instantiated, re-invoke make_decl_rtl
2689 so that encode_section_info has a chance to look at the new decl
2690 flags and attributes. */
2691 if (DECL_RTL_SET_P (olddecl
)
2692 && (TREE_CODE (olddecl
) == FUNCTION_DECL
2693 || (VAR_P (olddecl
) && TREE_STATIC (olddecl
))))
2694 make_decl_rtl (olddecl
);
2697 /* Handle when a new declaration NEWDECL has the same name as an old
2698 one OLDDECL in the same binding contour. Prints an error message
2701 If safely possible, alter OLDDECL to look like NEWDECL, and return
2702 true. Otherwise, return false. */
2705 duplicate_decls (tree newdecl
, tree olddecl
)
2707 tree newtype
= NULL
, oldtype
= NULL
;
2709 if (!diagnose_mismatched_decls (newdecl
, olddecl
, &newtype
, &oldtype
))
2711 /* Avoid `unused variable' and other warnings for OLDDECL. */
2712 TREE_NO_WARNING (olddecl
) = 1;
2716 merge_decls (newdecl
, olddecl
, newtype
, oldtype
);
2718 /* The NEWDECL will no longer be needed.
2720 Before releasing the node, be sure to remove function from symbol
2721 table that might have been inserted there to record comdat group.
2722 Be sure to however do not free DECL_STRUCT_FUNCTION because this
2723 structure is shared in between NEWDECL and OLDECL. */
2724 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
2725 DECL_STRUCT_FUNCTION (newdecl
) = NULL
;
2726 if (VAR_OR_FUNCTION_DECL_P (newdecl
))
2728 struct symtab_node
*snode
= symtab_node::get (newdecl
);
2737 /* Check whether decl-node NEW_DECL shadows an existing declaration. */
2739 warn_if_shadowing (tree new_decl
)
2741 struct c_binding
*b
;
2743 /* Shadow warnings wanted? */
2745 /* No shadow warnings for internally generated vars. */
2746 || DECL_IS_BUILTIN (new_decl
)
2747 /* No shadow warnings for vars made for inlining. */
2748 || DECL_FROM_INLINE (new_decl
))
2751 /* Is anything being shadowed? Invisible decls do not count. */
2752 for (b
= I_SYMBOL_BINDING (DECL_NAME (new_decl
)); b
; b
= b
->shadowed
)
2753 if (b
->decl
&& b
->decl
!= new_decl
&& !b
->invisible
2754 && (b
->decl
== error_mark_node
2755 || diagnostic_report_warnings_p (global_dc
,
2756 DECL_SOURCE_LOCATION (b
->decl
))))
2758 tree old_decl
= b
->decl
;
2759 bool warned
= false;
2761 if (old_decl
== error_mark_node
)
2763 warning (OPT_Wshadow
, "declaration of %q+D shadows previous "
2764 "non-variable", new_decl
);
2767 else if (TREE_CODE (old_decl
) == PARM_DECL
)
2768 warned
= warning (OPT_Wshadow
,
2769 "declaration of %q+D shadows a parameter",
2771 else if (DECL_FILE_SCOPE_P (old_decl
))
2773 /* Do not warn if a variable shadows a function, unless
2774 the variable is a function or a pointer-to-function. */
2775 if (TREE_CODE (old_decl
) == FUNCTION_DECL
2776 && TREE_CODE (new_decl
) != FUNCTION_DECL
2777 && !FUNCTION_POINTER_TYPE_P (TREE_TYPE (new_decl
)))
2780 warned
= warning_at (DECL_SOURCE_LOCATION (new_decl
), OPT_Wshadow
,
2781 "declaration of %qD shadows a global "
2785 else if (TREE_CODE (old_decl
) == FUNCTION_DECL
2786 && DECL_BUILT_IN (old_decl
))
2788 warning (OPT_Wshadow
, "declaration of %q+D shadows "
2789 "a built-in function", new_decl
);
2793 warned
= warning (OPT_Wshadow
, "declaration of %q+D shadows a "
2794 "previous local", new_decl
);
2797 inform (DECL_SOURCE_LOCATION (old_decl
),
2798 "shadowed declaration is here");
2804 /* Record a decl-node X as belonging to the current lexical scope.
2805 Check for errors (such as an incompatible declaration for the same
2806 name already seen in the same scope).
2808 Returns either X or an old decl for the same name.
2809 If an old decl is returned, it may have been smashed
2810 to agree with what X says. */
2815 tree name
= DECL_NAME (x
);
2816 struct c_scope
*scope
= current_scope
;
2817 struct c_binding
*b
;
2818 bool nested
= false;
2819 location_t locus
= DECL_SOURCE_LOCATION (x
);
2821 /* Must set DECL_CONTEXT for everything not at file scope or
2822 DECL_FILE_SCOPE_P won't work. Local externs don't count
2823 unless they have initializers (which generate code). */
2824 if (current_function_decl
2825 && (!VAR_OR_FUNCTION_DECL_P (x
)
2826 || DECL_INITIAL (x
) || !DECL_EXTERNAL (x
)))
2827 DECL_CONTEXT (x
) = current_function_decl
;
2829 /* Anonymous decls are just inserted in the scope. */
2832 bind (name
, x
, scope
, /*invisible=*/false, /*nested=*/false,
2837 /* First, see if there is another declaration with the same name in
2838 the current scope. If there is, duplicate_decls may do all the
2839 work for us. If duplicate_decls returns false, that indicates
2840 two incompatible decls in the same scope; we are to silently
2841 replace the old one (duplicate_decls has issued all appropriate
2842 diagnostics). In particular, we should not consider possible
2843 duplicates in the external scope, or shadowing. */
2844 b
= I_SYMBOL_BINDING (name
);
2845 if (b
&& B_IN_SCOPE (b
, scope
))
2847 struct c_binding
*b_ext
, *b_use
;
2848 tree type
= TREE_TYPE (x
);
2849 tree visdecl
= b
->decl
;
2850 tree vistype
= TREE_TYPE (visdecl
);
2851 if (TREE_CODE (TREE_TYPE (x
)) == ARRAY_TYPE
2852 && COMPLETE_TYPE_P (TREE_TYPE (x
)))
2853 b
->inner_comp
= false;
2856 /* If this is an external linkage declaration, we should check
2857 for compatibility with the type in the external scope before
2858 setting the type at this scope based on the visible
2859 information only. */
2860 if (TREE_PUBLIC (x
) && TREE_PUBLIC (visdecl
))
2862 while (b_ext
&& !B_IN_EXTERNAL_SCOPE (b_ext
))
2863 b_ext
= b_ext
->shadowed
;
2868 TREE_TYPE (b_use
->decl
) = b_use
->u
.type
;
2871 if (duplicate_decls (x
, b_use
->decl
))
2875 /* Save the updated type in the external scope and
2876 restore the proper type for this scope. */
2878 if (comptypes (vistype
, type
))
2879 thistype
= composite_type (vistype
, type
);
2881 thistype
= TREE_TYPE (b_use
->decl
);
2882 b_use
->u
.type
= TREE_TYPE (b_use
->decl
);
2883 if (TREE_CODE (b_use
->decl
) == FUNCTION_DECL
2884 && DECL_BUILT_IN (b_use
->decl
))
2886 = build_type_attribute_variant (thistype
,
2889 TREE_TYPE (b_use
->decl
) = thistype
;
2894 goto skip_external_and_shadow_checks
;
2897 /* All declarations with external linkage, and all external
2898 references, go in the external scope, no matter what scope is
2899 current. However, the binding in that scope is ignored for
2900 purposes of normal name lookup. A separate binding structure is
2901 created in the requested scope; this governs the normal
2902 visibility of the symbol.
2904 The binding in the externals scope is used exclusively for
2905 detecting duplicate declarations of the same object, no matter
2906 what scope they are in; this is what we do here. (C99 6.2.7p2:
2907 All declarations that refer to the same object or function shall
2908 have compatible type; otherwise, the behavior is undefined.) */
2909 if (DECL_EXTERNAL (x
) || scope
== file_scope
)
2911 tree type
= TREE_TYPE (x
);
2914 bool type_saved
= false;
2915 if (b
&& !B_IN_EXTERNAL_SCOPE (b
)
2916 && VAR_OR_FUNCTION_DECL_P (b
->decl
)
2917 && DECL_FILE_SCOPE_P (b
->decl
))
2920 vistype
= TREE_TYPE (visdecl
);
2922 if (scope
!= file_scope
2923 && !DECL_IN_SYSTEM_HEADER (x
))
2924 warning (OPT_Wnested_externs
, "nested extern declaration of %qD", x
);
2926 while (b
&& !B_IN_EXTERNAL_SCOPE (b
))
2928 /* If this decl might be modified, save its type. This is
2929 done here rather than when the decl is first bound
2930 because the type may change after first binding, through
2931 being completed or through attributes being added. If we
2932 encounter multiple such decls, only the first should have
2933 its type saved; the others will already have had their
2934 proper types saved and the types will not have changed as
2935 their scopes will not have been re-entered. */
2936 if (DECL_P (b
->decl
) && DECL_FILE_SCOPE_P (b
->decl
) && !type_saved
)
2938 b
->u
.type
= TREE_TYPE (b
->decl
);
2941 if (B_IN_FILE_SCOPE (b
)
2943 && TREE_STATIC (b
->decl
)
2944 && TREE_CODE (TREE_TYPE (b
->decl
)) == ARRAY_TYPE
2945 && !TYPE_DOMAIN (TREE_TYPE (b
->decl
))
2946 && TREE_CODE (type
) == ARRAY_TYPE
2947 && TYPE_DOMAIN (type
)
2948 && TYPE_MAX_VALUE (TYPE_DOMAIN (type
))
2949 && !integer_zerop (TYPE_MAX_VALUE (TYPE_DOMAIN (type
))))
2951 /* Array type completed in inner scope, which should be
2952 diagnosed if the completion does not have size 1 and
2953 it does not get completed in the file scope. */
2954 b
->inner_comp
= true;
2959 /* If a matching external declaration has been found, set its
2960 type to the composite of all the types of that declaration.
2961 After the consistency checks, it will be reset to the
2962 composite of the visible types only. */
2963 if (b
&& (TREE_PUBLIC (x
) || same_translation_unit_p (x
, b
->decl
))
2965 TREE_TYPE (b
->decl
) = b
->u
.type
;
2967 /* The point of the same_translation_unit_p check here is,
2968 we want to detect a duplicate decl for a construct like
2969 foo() { extern bar(); } ... static bar(); but not if
2970 they are in different translation units. In any case,
2971 the static does not go in the externals scope. */
2973 && (TREE_PUBLIC (x
) || same_translation_unit_p (x
, b
->decl
))
2974 && duplicate_decls (x
, b
->decl
))
2979 if (comptypes (vistype
, type
))
2980 thistype
= composite_type (vistype
, type
);
2982 thistype
= TREE_TYPE (b
->decl
);
2986 b
->u
.type
= TREE_TYPE (b
->decl
);
2987 if (TREE_CODE (b
->decl
) == FUNCTION_DECL
&& DECL_BUILT_IN (b
->decl
))
2989 = build_type_attribute_variant (thistype
,
2990 TYPE_ATTRIBUTES (b
->u
.type
));
2991 TREE_TYPE (b
->decl
) = thistype
;
2992 bind (name
, b
->decl
, scope
, /*invisible=*/false, /*nested=*/true,
2996 else if (TREE_PUBLIC (x
))
2998 if (visdecl
&& !b
&& duplicate_decls (x
, visdecl
))
3000 /* An external declaration at block scope referring to a
3001 visible entity with internal linkage. The composite
3002 type will already be correct for this scope, so we
3003 just need to fall through to make the declaration in
3010 bind (name
, x
, external_scope
, /*invisible=*/true,
3011 /*nested=*/false, locus
);
3017 if (TREE_CODE (x
) != PARM_DECL
)
3018 warn_if_shadowing (x
);
3020 skip_external_and_shadow_checks
:
3021 if (TREE_CODE (x
) == TYPE_DECL
)
3023 /* So this is a typedef, set its underlying type. */
3024 set_underlying_type (x
);
3026 /* If X is a typedef defined in the current function, record it
3027 for the purpose of implementing the -Wunused-local-typedefs
3029 record_locally_defined_typedef (x
);
3032 bind (name
, x
, scope
, /*invisible=*/false, nested
, locus
);
3034 /* If x's type is incomplete because it's based on a
3035 structure or union which has not yet been fully declared,
3036 attach it to that structure or union type, so we can go
3037 back and complete the variable declaration later, if the
3038 structure or union gets fully declared.
3040 If the input is erroneous, we can have error_mark in the type
3041 slot (e.g. "f(void a, ...)") - that doesn't count as an
3043 if (TREE_TYPE (x
) != error_mark_node
3044 && !COMPLETE_TYPE_P (TREE_TYPE (x
)))
3046 tree element
= TREE_TYPE (x
);
3048 while (TREE_CODE (element
) == ARRAY_TYPE
)
3049 element
= TREE_TYPE (element
);
3050 element
= TYPE_MAIN_VARIANT (element
);
3052 if ((TREE_CODE (element
) == RECORD_TYPE
3053 || TREE_CODE (element
) == UNION_TYPE
)
3054 && (TREE_CODE (x
) != TYPE_DECL
3055 || TREE_CODE (TREE_TYPE (x
)) == ARRAY_TYPE
)
3056 && !COMPLETE_TYPE_P (element
))
3057 C_TYPE_INCOMPLETE_VARS (element
)
3058 = tree_cons (NULL_TREE
, x
, C_TYPE_INCOMPLETE_VARS (element
));
3063 /* Record X as belonging to file scope.
3064 This is used only internally by the Objective-C front end,
3065 and is limited to its needs. duplicate_decls is not called;
3066 if there is any preexisting decl for this identifier, it is an ICE. */
3069 pushdecl_top_level (tree x
)
3072 bool nested
= false;
3073 gcc_assert (VAR_P (x
) || TREE_CODE (x
) == CONST_DECL
);
3075 name
= DECL_NAME (x
);
3077 gcc_assert (TREE_CODE (x
) == CONST_DECL
|| !I_SYMBOL_BINDING (name
));
3079 if (TREE_PUBLIC (x
))
3081 bind (name
, x
, external_scope
, /*invisible=*/true, /*nested=*/false,
3086 bind (name
, x
, file_scope
, /*invisible=*/false, nested
, UNKNOWN_LOCATION
);
3092 implicit_decl_warning (location_t loc
, tree id
, tree olddecl
)
3094 if (warn_implicit_function_declaration
)
3099 warned
= pedwarn (loc
, OPT_Wimplicit_function_declaration
,
3100 "implicit declaration of function %qE", id
);
3102 warned
= warning_at (loc
, OPT_Wimplicit_function_declaration
,
3103 G_("implicit declaration of function %qE"), id
);
3104 if (olddecl
&& warned
)
3105 locate_old_decl (olddecl
);
3109 /* This function represents mapping of a function code FCODE
3110 to its respective header. */
3113 header_for_builtin_fn (enum built_in_function fcode
)
3117 CASE_FLT_FN (BUILT_IN_ACOS
):
3118 CASE_FLT_FN (BUILT_IN_ACOSH
):
3119 CASE_FLT_FN (BUILT_IN_ASIN
):
3120 CASE_FLT_FN (BUILT_IN_ASINH
):
3121 CASE_FLT_FN (BUILT_IN_ATAN
):
3122 CASE_FLT_FN (BUILT_IN_ATANH
):
3123 CASE_FLT_FN (BUILT_IN_ATAN2
):
3124 CASE_FLT_FN (BUILT_IN_CBRT
):
3125 CASE_FLT_FN (BUILT_IN_CEIL
):
3126 CASE_FLT_FN (BUILT_IN_COPYSIGN
):
3127 CASE_FLT_FN (BUILT_IN_COS
):
3128 CASE_FLT_FN (BUILT_IN_COSH
):
3129 CASE_FLT_FN (BUILT_IN_ERF
):
3130 CASE_FLT_FN (BUILT_IN_ERFC
):
3131 CASE_FLT_FN (BUILT_IN_EXP
):
3132 CASE_FLT_FN (BUILT_IN_EXP2
):
3133 CASE_FLT_FN (BUILT_IN_EXPM1
):
3134 CASE_FLT_FN (BUILT_IN_FABS
):
3135 CASE_FLT_FN (BUILT_IN_FDIM
):
3136 CASE_FLT_FN (BUILT_IN_FLOOR
):
3137 CASE_FLT_FN (BUILT_IN_FMA
):
3138 CASE_FLT_FN (BUILT_IN_FMAX
):
3139 CASE_FLT_FN (BUILT_IN_FMIN
):
3140 CASE_FLT_FN (BUILT_IN_FMOD
):
3141 CASE_FLT_FN (BUILT_IN_FREXP
):
3142 CASE_FLT_FN (BUILT_IN_HYPOT
):
3143 CASE_FLT_FN (BUILT_IN_ILOGB
):
3144 CASE_FLT_FN (BUILT_IN_LDEXP
):
3145 CASE_FLT_FN (BUILT_IN_LGAMMA
):
3146 CASE_FLT_FN (BUILT_IN_LLRINT
):
3147 CASE_FLT_FN (BUILT_IN_LLROUND
):
3148 CASE_FLT_FN (BUILT_IN_LOG
):
3149 CASE_FLT_FN (BUILT_IN_LOG10
):
3150 CASE_FLT_FN (BUILT_IN_LOG1P
):
3151 CASE_FLT_FN (BUILT_IN_LOG2
):
3152 CASE_FLT_FN (BUILT_IN_LOGB
):
3153 CASE_FLT_FN (BUILT_IN_LRINT
):
3154 CASE_FLT_FN (BUILT_IN_LROUND
):
3155 CASE_FLT_FN (BUILT_IN_MODF
):
3156 CASE_FLT_FN (BUILT_IN_NAN
):
3157 CASE_FLT_FN (BUILT_IN_NEARBYINT
):
3158 CASE_FLT_FN (BUILT_IN_NEXTAFTER
):
3159 CASE_FLT_FN (BUILT_IN_NEXTTOWARD
):
3160 CASE_FLT_FN (BUILT_IN_POW
):
3161 CASE_FLT_FN (BUILT_IN_REMAINDER
):
3162 CASE_FLT_FN (BUILT_IN_REMQUO
):
3163 CASE_FLT_FN (BUILT_IN_RINT
):
3164 CASE_FLT_FN (BUILT_IN_ROUND
):
3165 CASE_FLT_FN (BUILT_IN_SCALBLN
):
3166 CASE_FLT_FN (BUILT_IN_SCALBN
):
3167 CASE_FLT_FN (BUILT_IN_SIN
):
3168 CASE_FLT_FN (BUILT_IN_SINH
):
3169 CASE_FLT_FN (BUILT_IN_SINCOS
):
3170 CASE_FLT_FN (BUILT_IN_SQRT
):
3171 CASE_FLT_FN (BUILT_IN_TAN
):
3172 CASE_FLT_FN (BUILT_IN_TANH
):
3173 CASE_FLT_FN (BUILT_IN_TGAMMA
):
3174 CASE_FLT_FN (BUILT_IN_TRUNC
):
3175 case BUILT_IN_ISINF
:
3176 case BUILT_IN_ISNAN
:
3178 CASE_FLT_FN (BUILT_IN_CABS
):
3179 CASE_FLT_FN (BUILT_IN_CACOS
):
3180 CASE_FLT_FN (BUILT_IN_CACOSH
):
3181 CASE_FLT_FN (BUILT_IN_CARG
):
3182 CASE_FLT_FN (BUILT_IN_CASIN
):
3183 CASE_FLT_FN (BUILT_IN_CASINH
):
3184 CASE_FLT_FN (BUILT_IN_CATAN
):
3185 CASE_FLT_FN (BUILT_IN_CATANH
):
3186 CASE_FLT_FN (BUILT_IN_CCOS
):
3187 CASE_FLT_FN (BUILT_IN_CCOSH
):
3188 CASE_FLT_FN (BUILT_IN_CEXP
):
3189 CASE_FLT_FN (BUILT_IN_CIMAG
):
3190 CASE_FLT_FN (BUILT_IN_CLOG
):
3191 CASE_FLT_FN (BUILT_IN_CONJ
):
3192 CASE_FLT_FN (BUILT_IN_CPOW
):
3193 CASE_FLT_FN (BUILT_IN_CPROJ
):
3194 CASE_FLT_FN (BUILT_IN_CREAL
):
3195 CASE_FLT_FN (BUILT_IN_CSIN
):
3196 CASE_FLT_FN (BUILT_IN_CSINH
):
3197 CASE_FLT_FN (BUILT_IN_CSQRT
):
3198 CASE_FLT_FN (BUILT_IN_CTAN
):
3199 CASE_FLT_FN (BUILT_IN_CTANH
):
3200 return "<complex.h>";
3201 case BUILT_IN_MEMCHR
:
3202 case BUILT_IN_MEMCMP
:
3203 case BUILT_IN_MEMCPY
:
3204 case BUILT_IN_MEMMOVE
:
3205 case BUILT_IN_MEMSET
:
3206 case BUILT_IN_STRCAT
:
3207 case BUILT_IN_STRCHR
:
3208 case BUILT_IN_STRCMP
:
3209 case BUILT_IN_STRCPY
:
3210 case BUILT_IN_STRCSPN
:
3211 case BUILT_IN_STRLEN
:
3212 case BUILT_IN_STRNCAT
:
3213 case BUILT_IN_STRNCMP
:
3214 case BUILT_IN_STRNCPY
:
3215 case BUILT_IN_STRPBRK
:
3216 case BUILT_IN_STRRCHR
:
3217 case BUILT_IN_STRSPN
:
3218 case BUILT_IN_STRSTR
:
3219 return "<string.h>";
3220 case BUILT_IN_FPRINTF
:
3222 case BUILT_IN_FPUTC
:
3223 case BUILT_IN_FPUTS
:
3224 case BUILT_IN_FSCANF
:
3225 case BUILT_IN_FWRITE
:
3226 case BUILT_IN_PRINTF
:
3227 case BUILT_IN_PUTCHAR
:
3229 case BUILT_IN_SCANF
:
3230 case BUILT_IN_SNPRINTF
:
3231 case BUILT_IN_SPRINTF
:
3232 case BUILT_IN_SSCANF
:
3233 case BUILT_IN_VFPRINTF
:
3234 case BUILT_IN_VFSCANF
:
3235 case BUILT_IN_VPRINTF
:
3236 case BUILT_IN_VSCANF
:
3237 case BUILT_IN_VSNPRINTF
:
3238 case BUILT_IN_VSPRINTF
:
3239 case BUILT_IN_VSSCANF
:
3241 case BUILT_IN_ISALNUM
:
3242 case BUILT_IN_ISALPHA
:
3243 case BUILT_IN_ISBLANK
:
3244 case BUILT_IN_ISCNTRL
:
3245 case BUILT_IN_ISDIGIT
:
3246 case BUILT_IN_ISGRAPH
:
3247 case BUILT_IN_ISLOWER
:
3248 case BUILT_IN_ISPRINT
:
3249 case BUILT_IN_ISPUNCT
:
3250 case BUILT_IN_ISSPACE
:
3251 case BUILT_IN_ISUPPER
:
3252 case BUILT_IN_ISXDIGIT
:
3253 case BUILT_IN_TOLOWER
:
3254 case BUILT_IN_TOUPPER
:
3256 case BUILT_IN_ISWALNUM
:
3257 case BUILT_IN_ISWALPHA
:
3258 case BUILT_IN_ISWBLANK
:
3259 case BUILT_IN_ISWCNTRL
:
3260 case BUILT_IN_ISWDIGIT
:
3261 case BUILT_IN_ISWGRAPH
:
3262 case BUILT_IN_ISWLOWER
:
3263 case BUILT_IN_ISWPRINT
:
3264 case BUILT_IN_ISWPUNCT
:
3265 case BUILT_IN_ISWSPACE
:
3266 case BUILT_IN_ISWUPPER
:
3267 case BUILT_IN_ISWXDIGIT
:
3268 case BUILT_IN_TOWLOWER
:
3269 case BUILT_IN_TOWUPPER
:
3270 return "<wctype.h>";
3271 case BUILT_IN_ABORT
:
3273 case BUILT_IN_CALLOC
:
3277 case BUILT_IN_LLABS
:
3278 case BUILT_IN_MALLOC
:
3279 case BUILT_IN_REALLOC
:
3280 case BUILT_IN__EXIT2
:
3281 case BUILT_IN_ALIGNED_ALLOC
:
3282 return "<stdlib.h>";
3283 case BUILT_IN_IMAXABS
:
3284 return "<inttypes.h>";
3285 case BUILT_IN_STRFTIME
:
3292 /* Generate an implicit declaration for identifier FUNCTIONID at LOC as a
3293 function of type int (). */
3296 implicitly_declare (location_t loc
, tree functionid
)
3298 struct c_binding
*b
;
3302 for (b
= I_SYMBOL_BINDING (functionid
); b
; b
= b
->shadowed
)
3304 if (B_IN_SCOPE (b
, external_scope
))
3313 if (decl
== error_mark_node
)
3316 /* FIXME: Objective-C has weird not-really-builtin functions
3317 which are supposed to be visible automatically. They wind up
3318 in the external scope because they're pushed before the file
3319 scope gets created. Catch this here and rebind them into the
3321 if (!DECL_BUILT_IN (decl
) && DECL_IS_BUILTIN (decl
))
3323 bind (functionid
, decl
, file_scope
,
3324 /*invisible=*/false, /*nested=*/true,
3325 DECL_SOURCE_LOCATION (decl
));
3330 tree newtype
= default_function_type
;
3332 TREE_TYPE (decl
) = b
->u
.type
;
3333 /* Implicit declaration of a function already declared
3334 (somehow) in a different scope, or as a built-in.
3335 If this is the first time this has happened, warn;
3336 then recycle the old declaration but with the new type. */
3337 if (!C_DECL_IMPLICIT (decl
))
3339 implicit_decl_warning (loc
, functionid
, decl
);
3340 C_DECL_IMPLICIT (decl
) = 1;
3342 if (DECL_BUILT_IN (decl
))
3344 newtype
= build_type_attribute_variant (newtype
,
3346 (TREE_TYPE (decl
)));
3347 if (!comptypes (newtype
, TREE_TYPE (decl
)))
3349 bool warned
= warning_at (loc
, 0, "incompatible implicit "
3350 "declaration of built-in "
3351 "function %qD", decl
);
3352 /* See if we can hint which header to include. */
3354 = header_for_builtin_fn (DECL_FUNCTION_CODE (decl
));
3355 if (header
!= NULL
&& warned
)
3356 inform (loc
, "include %qs or provide a declaration of %qD",
3358 newtype
= TREE_TYPE (decl
);
3363 if (!comptypes (newtype
, TREE_TYPE (decl
)))
3365 error_at (loc
, "incompatible implicit declaration of "
3366 "function %qD", decl
);
3367 locate_old_decl (decl
);
3370 b
->u
.type
= TREE_TYPE (decl
);
3371 TREE_TYPE (decl
) = newtype
;
3372 bind (functionid
, decl
, current_scope
,
3373 /*invisible=*/false, /*nested=*/true,
3374 DECL_SOURCE_LOCATION (decl
));
3379 /* Not seen before. */
3380 decl
= build_decl (loc
, FUNCTION_DECL
, functionid
, default_function_type
);
3381 DECL_EXTERNAL (decl
) = 1;
3382 TREE_PUBLIC (decl
) = 1;
3383 C_DECL_IMPLICIT (decl
) = 1;
3384 implicit_decl_warning (loc
, functionid
, 0);
3385 asmspec_tree
= maybe_apply_renaming_pragma (decl
, /*asmname=*/NULL
);
3387 set_user_assembler_name (decl
, TREE_STRING_POINTER (asmspec_tree
));
3389 /* C89 says implicit declarations are in the innermost block.
3390 So we record the decl in the standard fashion. */
3391 decl
= pushdecl (decl
);
3393 /* No need to call objc_check_decl here - it's a function type. */
3394 rest_of_decl_compilation (decl
, 0, 0);
3396 /* Write a record describing this implicit function declaration
3397 to the prototypes file (if requested). */
3398 gen_aux_info_record (decl
, 0, 1, 0);
3400 /* Possibly apply some default attributes to this implicit declaration. */
3401 decl_attributes (&decl
, NULL_TREE
, 0);
3406 /* Issue an error message for a reference to an undeclared variable
3407 ID, including a reference to a builtin outside of function-call
3408 context. Establish a binding of the identifier to error_mark_node
3409 in an appropriate scope, which will suppress further errors for the
3410 same identifier. The error message should be given location LOC. */
3412 undeclared_variable (location_t loc
, tree id
)
3414 static bool already
= false;
3415 struct c_scope
*scope
;
3417 if (current_function_decl
== 0)
3419 error_at (loc
, "%qE undeclared here (not in a function)", id
);
3420 scope
= current_scope
;
3424 if (!objc_diagnose_private_ivar (id
))
3425 error_at (loc
, "%qE undeclared (first use in this function)", id
);
3428 inform (loc
, "each undeclared identifier is reported only"
3429 " once for each function it appears in");
3433 /* If we are parsing old-style parameter decls, current_function_decl
3434 will be nonnull but current_function_scope will be null. */
3435 scope
= current_function_scope
? current_function_scope
: current_scope
;
3437 bind (id
, error_mark_node
, scope
, /*invisible=*/false, /*nested=*/false,
3441 /* Subroutine of lookup_label, declare_label, define_label: construct a
3442 LABEL_DECL with all the proper frills. Also create a struct
3443 c_label_vars initialized for the current scope. */
3446 make_label (location_t location
, tree name
, bool defining
,
3447 struct c_label_vars
**p_label_vars
)
3449 tree label
= build_decl (location
, LABEL_DECL
, name
, void_type_node
);
3450 DECL_CONTEXT (label
) = current_function_decl
;
3451 DECL_MODE (label
) = VOIDmode
;
3453 c_label_vars
*label_vars
= ggc_alloc
<c_label_vars
> ();
3454 label_vars
->shadowed
= NULL
;
3455 set_spot_bindings (&label_vars
->label_bindings
, defining
);
3456 label_vars
->decls_in_scope
= make_tree_vector ();
3457 label_vars
->gotos
= NULL
;
3458 *p_label_vars
= label_vars
;
3463 /* Get the LABEL_DECL corresponding to identifier NAME as a label.
3464 Create one if none exists so far for the current function.
3465 This is called when a label is used in a goto expression or
3466 has its address taken. */
3469 lookup_label (tree name
)
3472 struct c_label_vars
*label_vars
;
3474 if (current_function_scope
== 0)
3476 error ("label %qE referenced outside of any function", name
);
3480 /* Use a label already defined or ref'd with this name, but not if
3481 it is inherited from a containing function and wasn't declared
3483 label
= I_LABEL_DECL (name
);
3484 if (label
&& (DECL_CONTEXT (label
) == current_function_decl
3485 || C_DECLARED_LABEL_FLAG (label
)))
3487 /* If the label has only been declared, update its apparent
3488 location to point here, for better diagnostics if it
3489 turns out not to have been defined. */
3490 if (DECL_INITIAL (label
) == NULL_TREE
)
3491 DECL_SOURCE_LOCATION (label
) = input_location
;
3495 /* No label binding for that identifier; make one. */
3496 label
= make_label (input_location
, name
, false, &label_vars
);
3498 /* Ordinary labels go in the current function scope. */
3499 bind_label (name
, label
, current_function_scope
, label_vars
);
3504 /* Issue a warning about DECL for a goto statement at GOTO_LOC going
3508 warn_about_goto (location_t goto_loc
, tree label
, tree decl
)
3510 if (variably_modified_type_p (TREE_TYPE (decl
), NULL_TREE
))
3512 "jump into scope of identifier with variably modified type");
3514 warning_at (goto_loc
, OPT_Wjump_misses_init
,
3515 "jump skips variable initialization");
3516 inform (DECL_SOURCE_LOCATION (label
), "label %qD defined here", label
);
3517 inform (DECL_SOURCE_LOCATION (decl
), "%qD declared here", decl
);
3520 /* Look up a label because of a goto statement. This is like
3521 lookup_label, but also issues any appropriate warnings. */
3524 lookup_label_for_goto (location_t loc
, tree name
)
3527 struct c_label_vars
*label_vars
;
3531 label
= lookup_label (name
);
3532 if (label
== NULL_TREE
)
3535 /* If we are jumping to a different function, we can't issue any
3537 if (DECL_CONTEXT (label
) != current_function_decl
)
3539 gcc_assert (C_DECLARED_LABEL_FLAG (label
));
3543 label_vars
= I_LABEL_BINDING (name
)->u
.label
;
3545 /* If the label has not yet been defined, then push this goto on a
3546 list for possible later warnings. */
3547 if (label_vars
->label_bindings
.scope
== NULL
)
3549 c_goto_bindings
*g
= ggc_alloc
<c_goto_bindings
> ();
3552 set_spot_bindings (&g
->goto_bindings
, true);
3553 vec_safe_push (label_vars
->gotos
, g
);
3557 /* If there are any decls in label_vars->decls_in_scope, then this
3558 goto has missed the declaration of the decl. This happens for a
3564 Issue a warning or error. */
3565 FOR_EACH_VEC_SAFE_ELT (label_vars
->decls_in_scope
, ix
, decl
)
3566 warn_about_goto (loc
, label
, decl
);
3568 if (label_vars
->label_bindings
.left_stmt_expr
)
3570 error_at (loc
, "jump into statement expression");
3571 inform (DECL_SOURCE_LOCATION (label
), "label %qD defined here", label
);
3577 /* Make a label named NAME in the current function, shadowing silently
3578 any that may be inherited from containing functions or containing
3579 scopes. This is called for __label__ declarations. */
3582 declare_label (tree name
)
3584 struct c_binding
*b
= I_LABEL_BINDING (name
);
3586 struct c_label_vars
*label_vars
;
3588 /* Check to make sure that the label hasn't already been declared
3590 if (b
&& B_IN_CURRENT_SCOPE (b
))
3592 error ("duplicate label declaration %qE", name
);
3593 locate_old_decl (b
->decl
);
3595 /* Just use the previous declaration. */
3599 label
= make_label (input_location
, name
, false, &label_vars
);
3600 C_DECLARED_LABEL_FLAG (label
) = 1;
3602 /* Declared labels go in the current scope. */
3603 bind_label (name
, label
, current_scope
, label_vars
);
3608 /* When we define a label, issue any appropriate warnings if there are
3609 any gotos earlier in the function which jump to this label. */
3612 check_earlier_gotos (tree label
, struct c_label_vars
* label_vars
)
3615 struct c_goto_bindings
*g
;
3617 FOR_EACH_VEC_SAFE_ELT (label_vars
->gotos
, ix
, g
)
3619 struct c_binding
*b
;
3620 struct c_scope
*scope
;
3622 /* We have a goto to this label. The goto is going forward. In
3623 g->scope, the goto is going to skip any binding which was
3624 defined after g->bindings_in_scope. */
3625 if (g
->goto_bindings
.scope
->has_jump_unsafe_decl
)
3627 for (b
= g
->goto_bindings
.scope
->bindings
;
3628 b
!= g
->goto_bindings
.bindings_in_scope
;
3631 if (decl_jump_unsafe (b
->decl
))
3632 warn_about_goto (g
->loc
, label
, b
->decl
);
3636 /* We also need to warn about decls defined in any scopes
3637 between the scope of the label and the scope of the goto. */
3638 for (scope
= label_vars
->label_bindings
.scope
;
3639 scope
!= g
->goto_bindings
.scope
;
3640 scope
= scope
->outer
)
3642 gcc_assert (scope
!= NULL
);
3643 if (scope
->has_jump_unsafe_decl
)
3645 if (scope
== label_vars
->label_bindings
.scope
)
3646 b
= label_vars
->label_bindings
.bindings_in_scope
;
3648 b
= scope
->bindings
;
3649 for (; b
!= NULL
; b
= b
->prev
)
3651 if (decl_jump_unsafe (b
->decl
))
3652 warn_about_goto (g
->loc
, label
, b
->decl
);
3657 if (g
->goto_bindings
.stmt_exprs
> 0)
3659 error_at (g
->loc
, "jump into statement expression");
3660 inform (DECL_SOURCE_LOCATION (label
), "label %qD defined here",
3665 /* Now that the label is defined, we will issue warnings about
3666 subsequent gotos to this label when we see them. */
3667 vec_safe_truncate (label_vars
->gotos
, 0);
3668 label_vars
->gotos
= NULL
;
3671 /* Define a label, specifying the location in the source file.
3672 Return the LABEL_DECL node for the label, if the definition is valid.
3673 Otherwise return 0. */
3676 define_label (location_t location
, tree name
)
3678 /* Find any preexisting label with this name. It is an error
3679 if that label has already been defined in this function, or
3680 if there is a containing function with a declared label with
3682 tree label
= I_LABEL_DECL (name
);
3685 && ((DECL_CONTEXT (label
) == current_function_decl
3686 && DECL_INITIAL (label
) != 0)
3687 || (DECL_CONTEXT (label
) != current_function_decl
3688 && C_DECLARED_LABEL_FLAG (label
))))
3690 error_at (location
, "duplicate label %qD", label
);
3691 locate_old_decl (label
);
3694 else if (label
&& DECL_CONTEXT (label
) == current_function_decl
)
3696 struct c_label_vars
*label_vars
= I_LABEL_BINDING (name
)->u
.label
;
3698 /* The label has been used or declared already in this function,
3699 but not defined. Update its location to point to this
3701 DECL_SOURCE_LOCATION (label
) = location
;
3702 set_spot_bindings (&label_vars
->label_bindings
, true);
3704 /* Issue warnings as required about any goto statements from
3705 earlier in the function. */
3706 check_earlier_gotos (label
, label_vars
);
3710 struct c_label_vars
*label_vars
;
3712 /* No label binding for that identifier; make one. */
3713 label
= make_label (location
, name
, true, &label_vars
);
3715 /* Ordinary labels go in the current function scope. */
3716 bind_label (name
, label
, current_function_scope
, label_vars
);
3719 if (!in_system_header_at (input_location
) && lookup_name (name
))
3720 warning_at (location
, OPT_Wtraditional
,
3721 "traditional C lacks a separate namespace "
3722 "for labels, identifier %qE conflicts", name
);
3724 /* Mark label as having been defined. */
3725 DECL_INITIAL (label
) = error_mark_node
;
3729 /* Get the bindings for a new switch statement. This is used to issue
3730 warnings as appropriate for jumps from the switch to case or
3733 struct c_spot_bindings
*
3734 c_get_switch_bindings (void)
3736 struct c_spot_bindings
*switch_bindings
;
3738 switch_bindings
= XNEW (struct c_spot_bindings
);
3739 set_spot_bindings (switch_bindings
, true);
3740 return switch_bindings
;
3744 c_release_switch_bindings (struct c_spot_bindings
*bindings
)
3746 gcc_assert (bindings
->stmt_exprs
== 0 && !bindings
->left_stmt_expr
);
3750 /* This is called at the point of a case or default label to issue
3751 warnings about decls as needed. It returns true if it found an
3752 error, not just a warning. */
3755 c_check_switch_jump_warnings (struct c_spot_bindings
*switch_bindings
,
3756 location_t switch_loc
, location_t case_loc
)
3759 struct c_scope
*scope
;
3762 for (scope
= current_scope
;
3763 scope
!= switch_bindings
->scope
;
3764 scope
= scope
->outer
)
3766 struct c_binding
*b
;
3768 gcc_assert (scope
!= NULL
);
3770 if (!scope
->has_jump_unsafe_decl
)
3773 for (b
= scope
->bindings
; b
!= NULL
; b
= b
->prev
)
3775 if (decl_jump_unsafe (b
->decl
))
3777 if (variably_modified_type_p (TREE_TYPE (b
->decl
), NULL_TREE
))
3781 ("switch jumps into scope of identifier with "
3782 "variably modified type"));
3785 warning_at (case_loc
, OPT_Wjump_misses_init
,
3786 "switch jumps over variable initialization");
3787 inform (switch_loc
, "switch starts here");
3788 inform (DECL_SOURCE_LOCATION (b
->decl
), "%qD declared here",
3794 if (switch_bindings
->stmt_exprs
> 0)
3797 error_at (case_loc
, "switch jumps into statement expression");
3798 inform (switch_loc
, "switch starts here");
3804 /* Given NAME, an IDENTIFIER_NODE,
3805 return the structure (or union or enum) definition for that name.
3806 If THISLEVEL_ONLY is nonzero, searches only the current_scope.
3807 CODE says which kind of type the caller wants;
3808 it is RECORD_TYPE or UNION_TYPE or ENUMERAL_TYPE.
3809 If PLOC is not NULL and this returns non-null, it sets *PLOC to the
3810 location where the tag was defined.
3811 If the wrong kind of type is found, an error is reported. */
3814 lookup_tag (enum tree_code code
, tree name
, int thislevel_only
,
3817 struct c_binding
*b
= I_TAG_BINDING (name
);
3823 /* We only care about whether it's in this level if
3824 thislevel_only was set or it might be a type clash. */
3825 if (thislevel_only
|| TREE_CODE (b
->decl
) != code
)
3827 /* For our purposes, a tag in the external scope is the same as
3828 a tag in the file scope. (Primarily relevant to Objective-C
3829 and its builtin structure tags, which get pushed before the
3830 file scope is created.) */
3831 if (B_IN_CURRENT_SCOPE (b
)
3832 || (current_scope
== file_scope
&& B_IN_EXTERNAL_SCOPE (b
)))
3836 if (thislevel_only
&& !thislevel
)
3839 if (TREE_CODE (b
->decl
) != code
)
3841 /* Definition isn't the kind we were looking for. */
3842 pending_invalid_xref
= name
;
3843 pending_invalid_xref_location
= input_location
;
3845 /* If in the same binding level as a declaration as a tag
3846 of a different type, this must not be allowed to
3847 shadow that tag, so give the error immediately.
3848 (For example, "struct foo; union foo;" is invalid.) */
3850 pending_xref_error ();
3859 /* Print an error message now
3860 for a recent invalid struct, union or enum cross reference.
3861 We don't print them immediately because they are not invalid
3862 when used in the `struct foo;' construct for shadowing. */
3865 pending_xref_error (void)
3867 if (pending_invalid_xref
!= 0)
3868 error_at (pending_invalid_xref_location
, "%qE defined as wrong kind of tag",
3869 pending_invalid_xref
);
3870 pending_invalid_xref
= 0;
3874 /* Look up NAME in the current scope and its superiors
3875 in the namespace of variables, functions and typedefs.
3876 Return a ..._DECL node of some kind representing its definition,
3877 or return 0 if it is undefined. */
3880 lookup_name (tree name
)
3882 struct c_binding
*b
= I_SYMBOL_BINDING (name
);
3883 if (b
&& !b
->invisible
)
3885 maybe_record_typedef_use (b
->decl
);
3891 /* Similar to `lookup_name' but look only at the indicated scope. */
3894 lookup_name_in_scope (tree name
, struct c_scope
*scope
)
3896 struct c_binding
*b
;
3898 for (b
= I_SYMBOL_BINDING (name
); b
; b
= b
->shadowed
)
3899 if (B_IN_SCOPE (b
, scope
))
3904 /* Create the predefined scalar types of C,
3905 and some nodes representing standard constants (0, 1, (void *) 0).
3906 Initialize the global scope.
3907 Make definitions for built-in primitive functions. */
3910 c_init_decl_processing (void)
3912 location_t save_loc
= input_location
;
3914 /* Initialize reserved words for parser. */
3917 current_function_decl
= 0;
3919 gcc_obstack_init (&parser_obstack
);
3921 /* Make the externals scope. */
3923 external_scope
= current_scope
;
3925 /* Declarations from c_common_nodes_and_builtins must not be associated
3926 with this input file, lest we get differences between using and not
3927 using preprocessed headers. */
3928 input_location
= BUILTINS_LOCATION
;
3930 c_common_nodes_and_builtins ();
3932 /* In C, comparisons and TRUTH_* expressions have type int. */
3933 truthvalue_type_node
= integer_type_node
;
3934 truthvalue_true_node
= integer_one_node
;
3935 truthvalue_false_node
= integer_zero_node
;
3937 /* Even in C99, which has a real boolean type. */
3938 pushdecl (build_decl (UNKNOWN_LOCATION
, TYPE_DECL
, get_identifier ("_Bool"),
3939 boolean_type_node
));
3941 input_location
= save_loc
;
3943 make_fname_decl
= c_make_fname_decl
;
3944 start_fname_decls ();
3947 /* Create the VAR_DECL at LOC for __FUNCTION__ etc. ID is the name to
3948 give the decl, NAME is the initialization string and TYPE_DEP
3949 indicates whether NAME depended on the type of the function. As we
3950 don't yet implement delayed emission of static data, we mark the
3951 decl as emitted so it is not placed in the output. Anything using
3952 it must therefore pull out the STRING_CST initializer directly.
3956 c_make_fname_decl (location_t loc
, tree id
, int type_dep
)
3958 const char *name
= fname_as_string (type_dep
);
3959 tree decl
, type
, init
;
3960 size_t length
= strlen (name
);
3962 type
= build_array_type (char_type_node
,
3963 build_index_type (size_int (length
)));
3964 type
= c_build_qualified_type (type
, TYPE_QUAL_CONST
);
3966 decl
= build_decl (loc
, VAR_DECL
, id
, type
);
3968 TREE_STATIC (decl
) = 1;
3969 TREE_READONLY (decl
) = 1;
3970 DECL_ARTIFICIAL (decl
) = 1;
3972 init
= build_string (length
+ 1, name
);
3973 free (CONST_CAST (char *, name
));
3974 TREE_TYPE (init
) = type
;
3975 DECL_INITIAL (decl
) = init
;
3977 TREE_USED (decl
) = 1;
3979 if (current_function_decl
3980 /* For invalid programs like this:
3983 const char* p = __FUNCTION__;
3985 the __FUNCTION__ is believed to appear in K&R style function
3986 parameter declarator. In that case we still don't have
3988 && (!seen_error () || current_function_scope
))
3990 DECL_CONTEXT (decl
) = current_function_decl
;
3991 bind (id
, decl
, current_function_scope
,
3992 /*invisible=*/false, /*nested=*/false, UNKNOWN_LOCATION
);
3995 finish_decl (decl
, loc
, init
, NULL_TREE
, NULL_TREE
);
4001 c_builtin_function (tree decl
)
4003 tree type
= TREE_TYPE (decl
);
4004 tree id
= DECL_NAME (decl
);
4006 const char *name
= IDENTIFIER_POINTER (id
);
4007 C_DECL_BUILTIN_PROTOTYPE (decl
) = prototype_p (type
);
4009 /* Should never be called on a symbol with a preexisting meaning. */
4010 gcc_assert (!I_SYMBOL_BINDING (id
));
4012 bind (id
, decl
, external_scope
, /*invisible=*/true, /*nested=*/false,
4015 /* Builtins in the implementation namespace are made visible without
4016 needing to be explicitly declared. See push_file_scope. */
4017 if (name
[0] == '_' && (name
[1] == '_' || ISUPPER (name
[1])))
4019 DECL_CHAIN (decl
) = visible_builtins
;
4020 visible_builtins
= decl
;
4027 c_builtin_function_ext_scope (tree decl
)
4029 tree type
= TREE_TYPE (decl
);
4030 tree id
= DECL_NAME (decl
);
4032 const char *name
= IDENTIFIER_POINTER (id
);
4033 C_DECL_BUILTIN_PROTOTYPE (decl
) = prototype_p (type
);
4036 bind (id
, decl
, external_scope
, /*invisible=*/false, /*nested=*/false,
4039 /* Builtins in the implementation namespace are made visible without
4040 needing to be explicitly declared. See push_file_scope. */
4041 if (name
[0] == '_' && (name
[1] == '_' || ISUPPER (name
[1])))
4043 DECL_CHAIN (decl
) = visible_builtins
;
4044 visible_builtins
= decl
;
4050 /* Called when a declaration is seen that contains no names to declare.
4051 If its type is a reference to a structure, union or enum inherited
4052 from a containing scope, shadow that tag name for the current scope
4053 with a forward reference.
4054 If its type defines a new named structure or union
4055 or defines an enum, it is valid but we need not do anything here.
4056 Otherwise, it is an error. */
4059 shadow_tag (const struct c_declspecs
*declspecs
)
4061 shadow_tag_warned (declspecs
, 0);
4064 /* WARNED is 1 if we have done a pedwarn, 2 if we have done a warning,
4067 shadow_tag_warned (const struct c_declspecs
*declspecs
, int warned
)
4069 bool found_tag
= false;
4071 if (declspecs
->type
&& !declspecs
->default_int_p
&& !declspecs
->typedef_p
)
4073 tree value
= declspecs
->type
;
4074 enum tree_code code
= TREE_CODE (value
);
4076 if (code
== RECORD_TYPE
|| code
== UNION_TYPE
|| code
== ENUMERAL_TYPE
)
4077 /* Used to test also that TYPE_SIZE (value) != 0.
4078 That caused warning for `struct foo;' at top level in the file. */
4080 tree name
= TYPE_NAME (value
);
4085 if (declspecs
->restrict_p
)
4087 error ("invalid use of %<restrict%>");
4093 if (warned
!= 1 && code
!= ENUMERAL_TYPE
)
4094 /* Empty unnamed enum OK */
4096 pedwarn (input_location
, 0,
4097 "unnamed struct/union that defines no instances");
4101 else if (declspecs
->typespec_kind
!= ctsk_tagdef
4102 && declspecs
->typespec_kind
!= ctsk_tagfirstref
4103 && declspecs
->storage_class
!= csc_none
)
4106 pedwarn (input_location
, 0,
4107 "empty declaration with storage class specifier "
4108 "does not redeclare tag");
4110 pending_xref_error ();
4112 else if (declspecs
->typespec_kind
!= ctsk_tagdef
4113 && declspecs
->typespec_kind
!= ctsk_tagfirstref
4114 && (declspecs
->const_p
4115 || declspecs
->volatile_p
4116 || declspecs
->atomic_p
4117 || declspecs
->restrict_p
4118 || declspecs
->address_space
))
4121 pedwarn (input_location
, 0,
4122 "empty declaration with type qualifier "
4123 "does not redeclare tag");
4125 pending_xref_error ();
4127 else if (declspecs
->typespec_kind
!= ctsk_tagdef
4128 && declspecs
->typespec_kind
!= ctsk_tagfirstref
4129 && declspecs
->alignas_p
)
4132 pedwarn (input_location
, 0,
4133 "empty declaration with %<_Alignas%> "
4134 "does not redeclare tag");
4136 pending_xref_error ();
4140 pending_invalid_xref
= 0;
4141 t
= lookup_tag (code
, name
, 1, NULL
);
4145 t
= make_node (code
);
4146 pushtag (input_location
, name
, t
);
4152 if (warned
!= 1 && !in_system_header_at (input_location
))
4154 pedwarn (input_location
, 0,
4155 "useless type name in empty declaration");
4160 else if (warned
!= 1 && !in_system_header_at (input_location
)
4161 && declspecs
->typedef_p
)
4163 pedwarn (input_location
, 0, "useless type name in empty declaration");
4167 pending_invalid_xref
= 0;
4169 if (declspecs
->inline_p
)
4171 error ("%<inline%> in empty declaration");
4175 if (declspecs
->noreturn_p
)
4177 error ("%<_Noreturn%> in empty declaration");
4181 if (current_scope
== file_scope
&& declspecs
->storage_class
== csc_auto
)
4183 error ("%<auto%> in file-scope empty declaration");
4187 if (current_scope
== file_scope
&& declspecs
->storage_class
== csc_register
)
4189 error ("%<register%> in file-scope empty declaration");
4193 if (!warned
&& !in_system_header_at (input_location
)
4194 && declspecs
->storage_class
!= csc_none
)
4196 warning (0, "useless storage class specifier in empty declaration");
4200 if (!warned
&& !in_system_header_at (input_location
) && declspecs
->thread_p
)
4202 warning (0, "useless %qs in empty declaration",
4203 declspecs
->thread_gnu_p
? "__thread" : "_Thread_local");
4208 && !in_system_header_at (input_location
)
4209 && (declspecs
->const_p
4210 || declspecs
->volatile_p
4211 || declspecs
->atomic_p
4212 || declspecs
->restrict_p
4213 || declspecs
->address_space
))
4215 warning (0, "useless type qualifier in empty declaration");
4219 if (!warned
&& !in_system_header_at (input_location
)
4220 && declspecs
->alignas_p
)
4222 warning (0, "useless %<_Alignas%> in empty declaration");
4229 pedwarn (input_location
, 0, "empty declaration");
4234 /* Return the qualifiers from SPECS as a bitwise OR of TYPE_QUAL_*
4235 bits. SPECS represents declaration specifiers that the grammar
4236 only permits to contain type qualifiers and attributes. */
4239 quals_from_declspecs (const struct c_declspecs
*specs
)
4241 int quals
= ((specs
->const_p
? TYPE_QUAL_CONST
: 0)
4242 | (specs
->volatile_p
? TYPE_QUAL_VOLATILE
: 0)
4243 | (specs
->restrict_p
? TYPE_QUAL_RESTRICT
: 0)
4244 | (specs
->atomic_p
? TYPE_QUAL_ATOMIC
: 0)
4245 | (ENCODE_QUAL_ADDR_SPACE (specs
->address_space
)));
4246 gcc_assert (!specs
->type
4247 && !specs
->decl_attr
4248 && specs
->typespec_word
== cts_none
4249 && specs
->storage_class
== csc_none
4250 && !specs
->typedef_p
4251 && !specs
->explicit_signed_p
4252 && !specs
->deprecated_p
4254 && !specs
->long_long_p
4257 && !specs
->unsigned_p
4258 && !specs
->complex_p
4260 && !specs
->noreturn_p
4261 && !specs
->thread_p
);
4265 /* Construct an array declarator. LOC is the location of the
4266 beginning of the array (usually the opening brace). EXPR is the
4267 expression inside [], or NULL_TREE. QUALS are the type qualifiers
4268 inside the [] (to be applied to the pointer to which a parameter
4269 array is converted). STATIC_P is true if "static" is inside the
4270 [], false otherwise. VLA_UNSPEC_P is true if the array is [*], a
4271 VLA of unspecified length which is nevertheless a complete type,
4272 false otherwise. The field for the contained declarator is left to
4273 be filled in by set_array_declarator_inner. */
4275 struct c_declarator
*
4276 build_array_declarator (location_t loc
,
4277 tree expr
, struct c_declspecs
*quals
, bool static_p
,
4280 struct c_declarator
*declarator
= XOBNEW (&parser_obstack
,
4281 struct c_declarator
);
4282 declarator
->id_loc
= loc
;
4283 declarator
->kind
= cdk_array
;
4284 declarator
->declarator
= 0;
4285 declarator
->u
.array
.dimen
= expr
;
4288 declarator
->u
.array
.attrs
= quals
->attrs
;
4289 declarator
->u
.array
.quals
= quals_from_declspecs (quals
);
4293 declarator
->u
.array
.attrs
= NULL_TREE
;
4294 declarator
->u
.array
.quals
= 0;
4296 declarator
->u
.array
.static_p
= static_p
;
4297 declarator
->u
.array
.vla_unspec_p
= vla_unspec_p
;
4298 if (static_p
|| quals
!= NULL
)
4299 pedwarn_c90 (loc
, OPT_Wpedantic
,
4300 "ISO C90 does not support %<static%> or type "
4301 "qualifiers in parameter array declarators");
4303 pedwarn_c90 (loc
, OPT_Wpedantic
,
4304 "ISO C90 does not support %<[*]%> array declarators");
4307 if (!current_scope
->parm_flag
)
4310 error_at (loc
, "%<[*]%> not allowed in other than "
4311 "function prototype scope");
4312 declarator
->u
.array
.vla_unspec_p
= false;
4315 current_scope
->had_vla_unspec
= true;
4320 /* Set the contained declarator of an array declarator. DECL is the
4321 declarator, as constructed by build_array_declarator; INNER is what
4322 appears on the left of the []. */
4324 struct c_declarator
*
4325 set_array_declarator_inner (struct c_declarator
*decl
,
4326 struct c_declarator
*inner
)
4328 decl
->declarator
= inner
;
4332 /* INIT is a constructor that forms DECL's initializer. If the final
4333 element initializes a flexible array field, add the size of that
4334 initializer to DECL's size. */
4337 add_flexible_array_elts_to_size (tree decl
, tree init
)
4341 if (vec_safe_is_empty (CONSTRUCTOR_ELTS (init
)))
4344 elt
= CONSTRUCTOR_ELTS (init
)->last ().value
;
4345 type
= TREE_TYPE (elt
);
4346 if (TREE_CODE (type
) == ARRAY_TYPE
4347 && TYPE_SIZE (type
) == NULL_TREE
4348 && TYPE_DOMAIN (type
) != NULL_TREE
4349 && TYPE_MAX_VALUE (TYPE_DOMAIN (type
)) == NULL_TREE
)
4351 complete_array_type (&type
, elt
, false);
4353 = size_binop (PLUS_EXPR
, DECL_SIZE (decl
), TYPE_SIZE (type
));
4354 DECL_SIZE_UNIT (decl
)
4355 = size_binop (PLUS_EXPR
, DECL_SIZE_UNIT (decl
), TYPE_SIZE_UNIT (type
));
4359 /* Decode a "typename", such as "int **", returning a ..._TYPE node.
4360 Set *EXPR, if EXPR not NULL, to any expression to be evaluated
4361 before the type name, and set *EXPR_CONST_OPERANDS, if
4362 EXPR_CONST_OPERANDS not NULL, to indicate whether the type name may
4363 appear in a constant expression. */
4366 groktypename (struct c_type_name
*type_name
, tree
*expr
,
4367 bool *expr_const_operands
)
4370 tree attrs
= type_name
->specs
->attrs
;
4372 type_name
->specs
->attrs
= NULL_TREE
;
4374 type
= grokdeclarator (type_name
->declarator
, type_name
->specs
, TYPENAME
,
4375 false, NULL
, &attrs
, expr
, expr_const_operands
,
4378 /* Apply attributes. */
4379 decl_attributes (&type
, attrs
, 0);
4384 /* Wrapper for decl_attributes that adds some implicit attributes
4385 to VAR_DECLs or FUNCTION_DECLs. */
4388 c_decl_attributes (tree
*node
, tree attributes
, int flags
)
4390 /* Add implicit "omp declare target" attribute if requested. */
4391 if (current_omp_declare_target_attribute
4392 && ((VAR_P (*node
) && is_global_var (*node
))
4393 || TREE_CODE (*node
) == FUNCTION_DECL
))
4396 && ((DECL_CONTEXT (*node
)
4397 && TREE_CODE (DECL_CONTEXT (*node
)) == FUNCTION_DECL
)
4398 || (current_function_decl
&& !DECL_EXTERNAL (*node
))))
4399 error ("%q+D in block scope inside of declare target directive",
4401 else if (VAR_P (*node
)
4402 && !lang_hooks
.types
.omp_mappable_type (TREE_TYPE (*node
)))
4403 error ("%q+D in declare target directive does not have mappable type",
4406 attributes
= tree_cons (get_identifier ("omp declare target"),
4407 NULL_TREE
, attributes
);
4409 return decl_attributes (node
, attributes
, flags
);
4413 /* Decode a declarator in an ordinary declaration or data definition.
4414 This is called as soon as the type information and variable name
4415 have been parsed, before parsing the initializer if any.
4416 Here we create the ..._DECL node, fill in its type,
4417 and put it on the list of decls for the current context.
4418 The ..._DECL node is returned as the value.
4420 Exception: for arrays where the length is not specified,
4421 the type is left null, to be filled in by `finish_decl'.
4423 Function definitions do not come here; they go to start_function
4424 instead. However, external and forward declarations of functions
4425 do go through here. Structure field declarations are done by
4426 grokfield and not through here. */
4429 start_decl (struct c_declarator
*declarator
, struct c_declspecs
*declspecs
,
4430 bool initialized
, tree attributes
)
4434 tree expr
= NULL_TREE
;
4435 enum deprecated_states deprecated_state
= DEPRECATED_NORMAL
;
4437 /* An object declared as __attribute__((deprecated)) suppresses
4438 warnings of uses of other deprecated items. */
4439 if (lookup_attribute ("deprecated", attributes
))
4440 deprecated_state
= DEPRECATED_SUPPRESS
;
4442 decl
= grokdeclarator (declarator
, declspecs
,
4443 NORMAL
, initialized
, NULL
, &attributes
, &expr
, NULL
,
4445 if (!decl
|| decl
== error_mark_node
)
4449 add_stmt (fold_convert (void_type_node
, expr
));
4451 if (TREE_CODE (decl
) != FUNCTION_DECL
&& MAIN_NAME_P (DECL_NAME (decl
)))
4452 warning (OPT_Wmain
, "%q+D is usually a function", decl
);
4455 /* Is it valid for this decl to have an initializer at all?
4456 If not, set INITIALIZED to zero, which will indirectly
4457 tell 'finish_decl' to ignore the initializer once it is parsed. */
4458 switch (TREE_CODE (decl
))
4461 error ("typedef %qD is initialized (use __typeof__ instead)", decl
);
4466 error ("function %qD is initialized like a variable", decl
);
4471 /* DECL_INITIAL in a PARM_DECL is really DECL_ARG_TYPE. */
4472 error ("parameter %qD is initialized", decl
);
4477 /* Don't allow initializations for incomplete types except for
4478 arrays which might be completed by the initialization. */
4480 /* This can happen if the array size is an undefined macro.
4481 We already gave a warning, so we don't need another one. */
4482 if (TREE_TYPE (decl
) == error_mark_node
)
4484 else if (COMPLETE_TYPE_P (TREE_TYPE (decl
)))
4486 /* A complete type is ok if size is fixed. */
4488 if (TREE_CODE (TYPE_SIZE (TREE_TYPE (decl
))) != INTEGER_CST
4489 || C_DECL_VARIABLE_SIZE (decl
))
4491 error ("variable-sized object may not be initialized");
4495 else if (TREE_CODE (TREE_TYPE (decl
)) != ARRAY_TYPE
)
4497 error ("variable %qD has initializer but incomplete type", decl
);
4500 else if (C_DECL_VARIABLE_SIZE (decl
))
4502 /* Although C99 is unclear about whether incomplete arrays
4503 of VLAs themselves count as VLAs, it does not make
4504 sense to permit them to be initialized given that
4505 ordinary VLAs may not be initialized. */
4506 error ("variable-sized object may not be initialized");
4513 if (current_scope
== file_scope
)
4514 TREE_STATIC (decl
) = 1;
4516 /* Tell 'pushdecl' this is an initialized decl
4517 even though we don't yet have the initializer expression.
4518 Also tell 'finish_decl' it may store the real initializer. */
4519 DECL_INITIAL (decl
) = error_mark_node
;
4522 /* If this is a function declaration, write a record describing it to the
4523 prototypes file (if requested). */
4525 if (TREE_CODE (decl
) == FUNCTION_DECL
)
4526 gen_aux_info_record (decl
, 0, 0, prototype_p (TREE_TYPE (decl
)));
4528 /* ANSI specifies that a tentative definition which is not merged with
4529 a non-tentative definition behaves exactly like a definition with an
4530 initializer equal to zero. (Section 3.7.2)
4532 -fno-common gives strict ANSI behavior, though this tends to break
4533 a large body of code that grew up without this rule.
4535 Thread-local variables are never common, since there's no entrenched
4536 body of code to break, and it allows more efficient variable references
4537 in the presence of dynamic linking. */
4541 && TREE_PUBLIC (decl
)
4542 && !DECL_THREAD_LOCAL_P (decl
)
4544 DECL_COMMON (decl
) = 1;
4546 /* Set attributes here so if duplicate decl, will have proper attributes. */
4547 c_decl_attributes (&decl
, attributes
, 0);
4549 /* Handle gnu_inline attribute. */
4550 if (declspecs
->inline_p
4551 && !flag_gnu89_inline
4552 && TREE_CODE (decl
) == FUNCTION_DECL
4553 && (lookup_attribute ("gnu_inline", DECL_ATTRIBUTES (decl
))
4554 || current_function_decl
))
4556 if (declspecs
->storage_class
== csc_auto
&& current_scope
!= file_scope
)
4558 else if (declspecs
->storage_class
!= csc_static
)
4559 DECL_EXTERNAL (decl
) = !DECL_EXTERNAL (decl
);
4562 if (TREE_CODE (decl
) == FUNCTION_DECL
4563 && targetm
.calls
.promote_prototypes (TREE_TYPE (decl
)))
4565 struct c_declarator
*ce
= declarator
;
4567 if (ce
->kind
== cdk_pointer
)
4568 ce
= declarator
->declarator
;
4569 if (ce
->kind
== cdk_function
)
4571 tree args
= ce
->u
.arg_info
->parms
;
4572 for (; args
; args
= DECL_CHAIN (args
))
4574 tree type
= TREE_TYPE (args
);
4575 if (type
&& INTEGRAL_TYPE_P (type
)
4576 && TYPE_PRECISION (type
) < TYPE_PRECISION (integer_type_node
))
4577 DECL_ARG_TYPE (args
) = c_type_promotes_to (type
);
4582 if (TREE_CODE (decl
) == FUNCTION_DECL
4583 && DECL_DECLARED_INLINE_P (decl
)
4584 && DECL_UNINLINABLE (decl
)
4585 && lookup_attribute ("noinline", DECL_ATTRIBUTES (decl
)))
4586 warning (OPT_Wattributes
, "inline function %q+D given attribute noinline",
4589 /* C99 6.7.4p3: An inline definition of a function with external
4590 linkage shall not contain a definition of a modifiable object
4591 with static storage duration... */
4593 && current_scope
!= file_scope
4594 && TREE_STATIC (decl
)
4595 && !TREE_READONLY (decl
)
4596 && DECL_DECLARED_INLINE_P (current_function_decl
)
4597 && DECL_EXTERNAL (current_function_decl
))
4598 record_inline_static (input_location
, current_function_decl
,
4599 decl
, csi_modifiable
);
4601 if (c_dialect_objc ()
4602 && VAR_OR_FUNCTION_DECL_P (decl
))
4603 objc_check_global_decl (decl
);
4605 /* Add this decl to the current scope.
4606 TEM may equal DECL or it may be a previous decl of the same name. */
4607 tem
= pushdecl (decl
);
4609 if (initialized
&& DECL_EXTERNAL (tem
))
4611 DECL_EXTERNAL (tem
) = 0;
4612 TREE_STATIC (tem
) = 1;
4618 /* Subroutine of finish_decl. TYPE is the type of an uninitialized object
4619 DECL or the non-array element type if DECL is an uninitialized array.
4620 If that type has a const member, diagnose this. */
4623 diagnose_uninitialized_cst_member (tree decl
, tree type
)
4626 for (field
= TYPE_FIELDS (type
); field
; field
= TREE_CHAIN (field
))
4629 if (TREE_CODE (field
) != FIELD_DECL
)
4631 field_type
= strip_array_types (TREE_TYPE (field
));
4633 if (TYPE_QUALS (field_type
) & TYPE_QUAL_CONST
)
4635 warning_at (DECL_SOURCE_LOCATION (decl
), OPT_Wc___compat
,
4636 "uninitialized const member in %qT is invalid in C++",
4637 strip_array_types (TREE_TYPE (decl
)));
4638 inform (DECL_SOURCE_LOCATION (field
), "%qD should be initialized", field
);
4641 if (TREE_CODE (field_type
) == RECORD_TYPE
4642 || TREE_CODE (field_type
) == UNION_TYPE
)
4643 diagnose_uninitialized_cst_member (decl
, field_type
);
4647 /* Finish processing of a declaration;
4648 install its initial value.
4649 If ORIGTYPE is not NULL_TREE, it is the original type of INIT.
4650 If the length of an array type is not known before,
4651 it must be determined now, from the initial value, or it is an error.
4653 INIT_LOC is the location of the initial value. */
4656 finish_decl (tree decl
, location_t init_loc
, tree init
,
4657 tree origtype
, tree asmspec_tree
)
4660 bool was_incomplete
= (DECL_SIZE (decl
) == 0);
4661 const char *asmspec
= 0;
4663 /* If a name was specified, get the string. */
4664 if (VAR_OR_FUNCTION_DECL_P (decl
)
4665 && DECL_FILE_SCOPE_P (decl
))
4666 asmspec_tree
= maybe_apply_renaming_pragma (decl
, asmspec_tree
);
4668 asmspec
= TREE_STRING_POINTER (asmspec_tree
);
4671 && TREE_STATIC (decl
)
4672 && global_bindings_p ())
4673 /* So decl is a global variable. Record the types it uses
4674 so that we can decide later to emit debug info for them. */
4675 record_types_used_by_current_var_decl (decl
);
4677 /* If `start_decl' didn't like having an initialization, ignore it now. */
4678 if (init
!= 0 && DECL_INITIAL (decl
) == 0)
4681 /* Don't crash if parm is initialized. */
4682 if (TREE_CODE (decl
) == PARM_DECL
)
4686 store_init_value (init_loc
, decl
, init
, origtype
);
4688 if (c_dialect_objc () && (VAR_OR_FUNCTION_DECL_P (decl
)
4689 || TREE_CODE (decl
) == FIELD_DECL
))
4690 objc_check_decl (decl
);
4692 type
= TREE_TYPE (decl
);
4694 /* Deduce size of array from initialization, if not already known. */
4695 if (TREE_CODE (type
) == ARRAY_TYPE
4696 && TYPE_DOMAIN (type
) == 0
4697 && TREE_CODE (decl
) != TYPE_DECL
)
4700 = (TREE_STATIC (decl
)
4701 /* Even if pedantic, an external linkage array
4702 may have incomplete type at first. */
4703 ? pedantic
&& !TREE_PUBLIC (decl
)
4704 : !DECL_EXTERNAL (decl
));
4706 = complete_array_type (&TREE_TYPE (decl
), DECL_INITIAL (decl
),
4709 /* Get the completed type made by complete_array_type. */
4710 type
= TREE_TYPE (decl
);
4715 error ("initializer fails to determine size of %q+D", decl
);
4720 error ("array size missing in %q+D", decl
);
4721 /* If a `static' var's size isn't known,
4722 make it extern as well as static, so it does not get
4724 If it is not `static', then do not mark extern;
4725 finish_incomplete_decl will give it a default size
4726 and it will get allocated. */
4727 else if (!pedantic
&& TREE_STATIC (decl
) && !TREE_PUBLIC (decl
))
4728 DECL_EXTERNAL (decl
) = 1;
4732 error ("zero or negative size array %q+D", decl
);
4736 /* For global variables, update the copy of the type that
4737 exists in the binding. */
4738 if (TREE_PUBLIC (decl
))
4740 struct c_binding
*b_ext
= I_SYMBOL_BINDING (DECL_NAME (decl
));
4741 while (b_ext
&& !B_IN_EXTERNAL_SCOPE (b_ext
))
4742 b_ext
= b_ext
->shadowed
;
4745 if (b_ext
->u
.type
&& comptypes (b_ext
->u
.type
, type
))
4746 b_ext
->u
.type
= composite_type (b_ext
->u
.type
, type
);
4748 b_ext
->u
.type
= type
;
4757 if (DECL_INITIAL (decl
))
4758 TREE_TYPE (DECL_INITIAL (decl
)) = type
;
4760 relayout_decl (decl
);
4765 if (init
&& TREE_CODE (init
) == CONSTRUCTOR
)
4766 add_flexible_array_elts_to_size (decl
, init
);
4768 if (DECL_SIZE (decl
) == 0 && TREE_TYPE (decl
) != error_mark_node
4769 && COMPLETE_TYPE_P (TREE_TYPE (decl
)))
4770 layout_decl (decl
, 0);
4772 if (DECL_SIZE (decl
) == 0
4773 /* Don't give an error if we already gave one earlier. */
4774 && TREE_TYPE (decl
) != error_mark_node
4775 && (TREE_STATIC (decl
)
4776 /* A static variable with an incomplete type
4777 is an error if it is initialized.
4778 Also if it is not file scope.
4779 Otherwise, let it through, but if it is not `extern'
4780 then it may cause an error message later. */
4781 ? (DECL_INITIAL (decl
) != 0
4782 || !DECL_FILE_SCOPE_P (decl
))
4783 /* An automatic variable with an incomplete type
4785 : !DECL_EXTERNAL (decl
)))
4787 error ("storage size of %q+D isn%'t known", decl
);
4788 TREE_TYPE (decl
) = error_mark_node
;
4791 if (is_global_var (decl
) && DECL_SIZE (decl
) != 0)
4793 if (TREE_CODE (DECL_SIZE (decl
)) == INTEGER_CST
)
4794 constant_expression_warning (DECL_SIZE (decl
));
4797 error ("storage size of %q+D isn%'t constant", decl
);
4798 TREE_TYPE (decl
) = error_mark_node
;
4802 if (TREE_USED (type
))
4804 TREE_USED (decl
) = 1;
4805 DECL_READ_P (decl
) = 1;
4809 /* If this is a function and an assembler name is specified, reset DECL_RTL
4810 so we can give it its new name. Also, update builtin_decl if it
4811 was a normal built-in. */
4812 if (TREE_CODE (decl
) == FUNCTION_DECL
&& asmspec
)
4814 if (DECL_BUILT_IN_CLASS (decl
) == BUILT_IN_NORMAL
)
4815 set_builtin_user_assembler_name (decl
, asmspec
);
4816 set_user_assembler_name (decl
, asmspec
);
4819 /* If #pragma weak was used, mark the decl weak now. */
4820 maybe_apply_pragma_weak (decl
);
4822 /* Output the assembler code and/or RTL code for variables and functions,
4823 unless the type is an undefined structure or union.
4824 If not, it will get done when the type is completed. */
4826 if (VAR_OR_FUNCTION_DECL_P (decl
))
4828 /* Determine the ELF visibility. */
4829 if (TREE_PUBLIC (decl
))
4830 c_determine_visibility (decl
);
4832 /* This is a no-op in c-lang.c or something real in objc-act.c. */
4833 if (c_dialect_objc ())
4834 objc_check_decl (decl
);
4838 /* If this is not a static variable, issue a warning.
4839 It doesn't make any sense to give an ASMSPEC for an
4840 ordinary, non-register local variable. Historically,
4841 GCC has accepted -- but ignored -- the ASMSPEC in
4843 if (!DECL_FILE_SCOPE_P (decl
)
4845 && !C_DECL_REGISTER (decl
)
4846 && !TREE_STATIC (decl
))
4847 warning (0, "ignoring asm-specifier for non-static local "
4848 "variable %q+D", decl
);
4850 set_user_assembler_name (decl
, asmspec
);
4853 if (DECL_FILE_SCOPE_P (decl
))
4855 if (DECL_INITIAL (decl
) == NULL_TREE
4856 || DECL_INITIAL (decl
) == error_mark_node
)
4857 /* Don't output anything
4858 when a tentative file-scope definition is seen.
4859 But at end of compilation, do output code for them. */
4860 DECL_DEFER_OUTPUT (decl
) = 1;
4861 if (asmspec
&& C_DECL_REGISTER (decl
))
4862 DECL_HARD_REGISTER (decl
) = 1;
4863 rest_of_decl_compilation (decl
, true, 0);
4867 /* In conjunction with an ASMSPEC, the `register'
4868 keyword indicates that we should place the variable
4869 in a particular register. */
4870 if (asmspec
&& C_DECL_REGISTER (decl
))
4872 DECL_HARD_REGISTER (decl
) = 1;
4873 /* This cannot be done for a structure with volatile
4874 fields, on which DECL_REGISTER will have been
4876 if (!DECL_REGISTER (decl
))
4877 error ("cannot put object with volatile field into register");
4880 if (TREE_CODE (decl
) != FUNCTION_DECL
)
4882 /* If we're building a variable sized type, and we might be
4883 reachable other than via the top of the current binding
4884 level, then create a new BIND_EXPR so that we deallocate
4885 the object at the right time. */
4886 /* Note that DECL_SIZE can be null due to errors. */
4887 if (DECL_SIZE (decl
)
4888 && !TREE_CONSTANT (DECL_SIZE (decl
))
4889 && STATEMENT_LIST_HAS_LABEL (cur_stmt_list
))
4892 bind
= build3 (BIND_EXPR
, void_type_node
, NULL
, NULL
, NULL
);
4893 TREE_SIDE_EFFECTS (bind
) = 1;
4895 BIND_EXPR_BODY (bind
) = push_stmt_list ();
4897 add_stmt (build_stmt (DECL_SOURCE_LOCATION (decl
),
4903 if (!DECL_FILE_SCOPE_P (decl
))
4905 /* Recompute the RTL of a local array now
4906 if it used to be an incomplete type. */
4907 if (was_incomplete
&& !is_global_var (decl
))
4909 /* If we used it already as memory, it must stay in memory. */
4910 TREE_ADDRESSABLE (decl
) = TREE_USED (decl
);
4911 /* If it's still incomplete now, no init will save it. */
4912 if (DECL_SIZE (decl
) == 0)
4913 DECL_INITIAL (decl
) = 0;
4918 if (TREE_CODE (decl
) == TYPE_DECL
)
4920 if (!DECL_FILE_SCOPE_P (decl
)
4921 && variably_modified_type_p (TREE_TYPE (decl
), NULL_TREE
))
4922 add_stmt (build_stmt (DECL_SOURCE_LOCATION (decl
), DECL_EXPR
, decl
));
4924 rest_of_decl_compilation (decl
, DECL_FILE_SCOPE_P (decl
), 0);
4927 /* Install a cleanup (aka destructor) if one was given. */
4928 if (VAR_P (decl
) && !TREE_STATIC (decl
))
4930 tree attr
= lookup_attribute ("cleanup", DECL_ATTRIBUTES (decl
));
4933 tree cleanup_id
= TREE_VALUE (TREE_VALUE (attr
));
4934 tree cleanup_decl
= lookup_name (cleanup_id
);
4936 vec
<tree
, va_gc
> *v
;
4938 /* Build "cleanup(&decl)" for the destructor. */
4939 cleanup
= build_unary_op (input_location
, ADDR_EXPR
, decl
, 0);
4941 v
->quick_push (cleanup
);
4942 cleanup
= c_build_function_call_vec (DECL_SOURCE_LOCATION (decl
),
4943 vNULL
, cleanup_decl
, v
, NULL
);
4946 /* Don't warn about decl unused; the cleanup uses it. */
4947 TREE_USED (decl
) = 1;
4948 TREE_USED (cleanup_decl
) = 1;
4949 DECL_READ_P (decl
) = 1;
4951 push_cleanup (decl
, cleanup
, false);
4957 && !DECL_EXTERNAL (decl
)
4958 && DECL_INITIAL (decl
) == NULL_TREE
)
4960 type
= strip_array_types (type
);
4961 if (TREE_READONLY (decl
))
4962 warning_at (DECL_SOURCE_LOCATION (decl
), OPT_Wc___compat
,
4963 "uninitialized const %qD is invalid in C++", decl
);
4964 else if ((TREE_CODE (type
) == RECORD_TYPE
4965 || TREE_CODE (type
) == UNION_TYPE
)
4966 && C_TYPE_FIELDS_READONLY (type
))
4967 diagnose_uninitialized_cst_member (decl
, type
);
4970 invoke_plugin_callbacks (PLUGIN_FINISH_DECL
, decl
);
4973 /* Given a parsed parameter declaration, decode it into a PARM_DECL.
4974 EXPR is NULL or a pointer to an expression that needs to be
4975 evaluated for the side effects of array size expressions in the
4979 grokparm (const struct c_parm
*parm
, tree
*expr
)
4981 tree attrs
= parm
->attrs
;
4982 tree decl
= grokdeclarator (parm
->declarator
, parm
->specs
, PARM
, false,
4983 NULL
, &attrs
, expr
, NULL
, DEPRECATED_NORMAL
);
4985 decl_attributes (&decl
, attrs
, 0);
4990 /* Given a parsed parameter declaration, decode it into a PARM_DECL
4991 and push that on the current scope. EXPR is a pointer to an
4992 expression that needs to be evaluated for the side effects of array
4993 size expressions in the parameters. */
4996 push_parm_decl (const struct c_parm
*parm
, tree
*expr
)
4998 tree attrs
= parm
->attrs
;
5001 decl
= grokdeclarator (parm
->declarator
, parm
->specs
, PARM
, false, NULL
,
5002 &attrs
, expr
, NULL
, DEPRECATED_NORMAL
);
5003 decl_attributes (&decl
, attrs
, 0);
5005 decl
= pushdecl (decl
);
5007 finish_decl (decl
, input_location
, NULL_TREE
, NULL_TREE
, NULL_TREE
);
5010 /* Mark all the parameter declarations to date as forward decls.
5011 Also diagnose use of this extension. */
5014 mark_forward_parm_decls (void)
5016 struct c_binding
*b
;
5018 if (pedantic
&& !current_scope
->warned_forward_parm_decls
)
5020 pedwarn (input_location
, OPT_Wpedantic
,
5021 "ISO C forbids forward parameter declarations");
5022 current_scope
->warned_forward_parm_decls
= true;
5025 for (b
= current_scope
->bindings
; b
; b
= b
->prev
)
5026 if (TREE_CODE (b
->decl
) == PARM_DECL
)
5027 TREE_ASM_WRITTEN (b
->decl
) = 1;
5030 /* Build a COMPOUND_LITERAL_EXPR. TYPE is the type given in the compound
5031 literal, which may be an incomplete array type completed by the
5032 initializer; INIT is a CONSTRUCTOR at LOC that initializes the compound
5033 literal. NON_CONST is true if the initializers contain something
5034 that cannot occur in a constant expression. */
5037 build_compound_literal (location_t loc
, tree type
, tree init
, bool non_const
)
5039 /* We do not use start_decl here because we have a type, not a declarator;
5040 and do not use finish_decl because the decl should be stored inside
5041 the COMPOUND_LITERAL_EXPR rather than added elsewhere as a DECL_EXPR. */
5046 if (type
== error_mark_node
5047 || init
== error_mark_node
)
5048 return error_mark_node
;
5050 decl
= build_decl (loc
, VAR_DECL
, NULL_TREE
, type
);
5051 DECL_EXTERNAL (decl
) = 0;
5052 TREE_PUBLIC (decl
) = 0;
5053 TREE_STATIC (decl
) = (current_scope
== file_scope
);
5054 DECL_CONTEXT (decl
) = current_function_decl
;
5055 TREE_USED (decl
) = 1;
5056 DECL_READ_P (decl
) = 1;
5057 TREE_TYPE (decl
) = type
;
5058 TREE_READONLY (decl
) = (TYPE_READONLY (type
)
5059 || (TREE_CODE (type
) == ARRAY_TYPE
5060 && TYPE_READONLY (TREE_TYPE (type
))));
5061 store_init_value (loc
, decl
, init
, NULL_TREE
);
5063 if (TREE_CODE (type
) == ARRAY_TYPE
&& !COMPLETE_TYPE_P (type
))
5065 int failure
= complete_array_type (&TREE_TYPE (decl
),
5066 DECL_INITIAL (decl
), true);
5067 /* If complete_array_type returns 3, it means that the
5068 initial value of the compound literal is empty. Allow it. */
5069 gcc_assert (failure
== 0 || failure
== 3);
5071 type
= TREE_TYPE (decl
);
5072 TREE_TYPE (DECL_INITIAL (decl
)) = type
;
5075 if (type
== error_mark_node
|| !COMPLETE_TYPE_P (type
))
5077 c_incomplete_type_error (NULL_TREE
, type
);
5078 return error_mark_node
;
5081 stmt
= build_stmt (DECL_SOURCE_LOCATION (decl
), DECL_EXPR
, decl
);
5082 complit
= build1 (COMPOUND_LITERAL_EXPR
, type
, stmt
);
5083 TREE_SIDE_EFFECTS (complit
) = 1;
5085 layout_decl (decl
, 0);
5087 if (TREE_STATIC (decl
))
5089 /* This decl needs a name for the assembler output. */
5090 set_compound_literal_name (decl
);
5091 DECL_DEFER_OUTPUT (decl
) = 1;
5092 DECL_COMDAT (decl
) = 1;
5093 DECL_ARTIFICIAL (decl
) = 1;
5094 DECL_IGNORED_P (decl
) = 1;
5096 rest_of_decl_compilation (decl
, 1, 0);
5101 complit
= build2 (C_MAYBE_CONST_EXPR
, type
, NULL
, complit
);
5102 C_MAYBE_CONST_EXPR_NON_CONST (complit
) = 1;
5108 /* Check the type of a compound literal. Here we just check that it
5109 is valid for C++. */
5112 check_compound_literal_type (location_t loc
, struct c_type_name
*type_name
)
5115 && (type_name
->specs
->typespec_kind
== ctsk_tagdef
5116 || type_name
->specs
->typespec_kind
== ctsk_tagfirstref
))
5117 warning_at (loc
, OPT_Wc___compat
,
5118 "defining a type in a compound literal is invalid in C++");
5121 /* Determine whether TYPE is a structure with a flexible array member,
5122 or a union containing such a structure (possibly recursively). */
5125 flexible_array_type_p (tree type
)
5128 switch (TREE_CODE (type
))
5131 x
= TYPE_FIELDS (type
);
5134 while (DECL_CHAIN (x
) != NULL_TREE
)
5136 if (TREE_CODE (TREE_TYPE (x
)) == ARRAY_TYPE
5137 && TYPE_SIZE (TREE_TYPE (x
)) == NULL_TREE
5138 && TYPE_DOMAIN (TREE_TYPE (x
)) != NULL_TREE
5139 && TYPE_MAX_VALUE (TYPE_DOMAIN (TREE_TYPE (x
))) == NULL_TREE
)
5143 for (x
= TYPE_FIELDS (type
); x
!= NULL_TREE
; x
= DECL_CHAIN (x
))
5145 if (flexible_array_type_p (TREE_TYPE (x
)))
5154 /* Performs sanity checks on the TYPE and WIDTH of the bit-field NAME,
5155 replacing with appropriate values if they are invalid. */
5157 check_bitfield_type_and_width (tree
*type
, tree
*width
, tree orig_name
)
5160 unsigned int max_width
;
5161 unsigned HOST_WIDE_INT w
;
5162 const char *name
= (orig_name
5163 ? identifier_to_locale (IDENTIFIER_POINTER (orig_name
))
5164 : _("<anonymous>"));
5166 /* Detect and ignore out of range field width and process valid
5168 if (!INTEGRAL_TYPE_P (TREE_TYPE (*width
)))
5170 error ("bit-field %qs width not an integer constant", name
);
5171 *width
= integer_one_node
;
5175 if (TREE_CODE (*width
) != INTEGER_CST
)
5177 *width
= c_fully_fold (*width
, false, NULL
);
5178 if (TREE_CODE (*width
) == INTEGER_CST
)
5179 pedwarn (input_location
, OPT_Wpedantic
,
5180 "bit-field %qs width not an integer constant expression",
5183 if (TREE_CODE (*width
) != INTEGER_CST
)
5185 error ("bit-field %qs width not an integer constant", name
);
5186 *width
= integer_one_node
;
5188 constant_expression_warning (*width
);
5189 if (tree_int_cst_sgn (*width
) < 0)
5191 error ("negative width in bit-field %qs", name
);
5192 *width
= integer_one_node
;
5194 else if (integer_zerop (*width
) && orig_name
)
5196 error ("zero width for bit-field %qs", name
);
5197 *width
= integer_one_node
;
5201 /* Detect invalid bit-field type. */
5202 if (TREE_CODE (*type
) != INTEGER_TYPE
5203 && TREE_CODE (*type
) != BOOLEAN_TYPE
5204 && TREE_CODE (*type
) != ENUMERAL_TYPE
)
5206 error ("bit-field %qs has invalid type", name
);
5207 *type
= unsigned_type_node
;
5210 type_mv
= TYPE_MAIN_VARIANT (*type
);
5211 if (!in_system_header_at (input_location
)
5212 && type_mv
!= integer_type_node
5213 && type_mv
!= unsigned_type_node
5214 && type_mv
!= boolean_type_node
)
5215 pedwarn_c90 (input_location
, OPT_Wpedantic
,
5216 "type of bit-field %qs is a GCC extension", name
);
5218 max_width
= TYPE_PRECISION (*type
);
5220 if (0 < compare_tree_int (*width
, max_width
))
5222 error ("width of %qs exceeds its type", name
);
5224 *width
= build_int_cst (integer_type_node
, w
);
5227 w
= tree_to_uhwi (*width
);
5229 if (TREE_CODE (*type
) == ENUMERAL_TYPE
)
5231 struct lang_type
*lt
= TYPE_LANG_SPECIFIC (*type
);
5233 || w
< tree_int_cst_min_precision (lt
->enum_min
, TYPE_SIGN (*type
))
5234 || w
< tree_int_cst_min_precision (lt
->enum_max
, TYPE_SIGN (*type
)))
5235 warning (0, "%qs is narrower than values of its type", name
);
5241 /* Print warning about variable length array if necessary. */
5244 warn_variable_length_array (tree name
, tree size
)
5246 if (TREE_CONSTANT (size
))
5249 pedwarn_c90 (input_location
, OPT_Wvla
,
5250 "ISO C90 forbids array %qE whose size "
5251 "can%'t be evaluated", name
);
5253 pedwarn_c90 (input_location
, OPT_Wvla
, "ISO C90 forbids array "
5254 "whose size can%'t be evaluated");
5259 pedwarn_c90 (input_location
, OPT_Wvla
,
5260 "ISO C90 forbids variable length array %qE", name
);
5262 pedwarn_c90 (input_location
, OPT_Wvla
, "ISO C90 forbids variable "
5267 /* Print warning about defaulting to int if necessary. */
5270 warn_defaults_to (location_t location
, int opt
, const char *gmsgid
, ...)
5272 diagnostic_info diagnostic
;
5275 va_start (ap
, gmsgid
);
5276 diagnostic_set_info (&diagnostic
, gmsgid
, &ap
, location
,
5277 flag_isoc99
? DK_PEDWARN
: DK_WARNING
);
5278 diagnostic
.option_index
= opt
;
5279 report_diagnostic (&diagnostic
);
5283 /* Given declspecs and a declarator,
5284 determine the name and type of the object declared
5285 and construct a ..._DECL node for it.
5286 (In one case we can return a ..._TYPE node instead.
5287 For invalid input we sometimes return 0.)
5289 DECLSPECS is a c_declspecs structure for the declaration specifiers.
5291 DECL_CONTEXT says which syntactic context this declaration is in:
5292 NORMAL for most contexts. Make a VAR_DECL or FUNCTION_DECL or TYPE_DECL.
5293 FUNCDEF for a function definition. Like NORMAL but a few different
5294 error messages in each case. Return value may be zero meaning
5295 this definition is too screwy to try to parse.
5296 PARM for a parameter declaration (either within a function prototype
5297 or before a function body). Make a PARM_DECL, or return void_type_node.
5298 TYPENAME if for a typename (in a cast or sizeof).
5299 Don't make a DECL node; just return the ..._TYPE node.
5300 FIELD for a struct or union field; make a FIELD_DECL.
5301 INITIALIZED is true if the decl has an initializer.
5302 WIDTH is non-NULL for bit-fields, and is a pointer to an INTEGER_CST node
5303 representing the width of the bit-field.
5304 DECL_ATTRS points to the list of attributes that should be added to this
5305 decl. Any nested attributes that belong on the decl itself will be
5307 If EXPR is not NULL, any expressions that need to be evaluated as
5308 part of evaluating variably modified types will be stored in *EXPR.
5309 If EXPR_CONST_OPERANDS is not NULL, *EXPR_CONST_OPERANDS will be
5310 set to indicate whether operands in *EXPR can be used in constant
5312 DEPRECATED_STATE is a deprecated_states value indicating whether
5313 deprecation warnings should be suppressed.
5315 In the TYPENAME case, DECLARATOR is really an absolute declarator.
5316 It may also be so in the PARM case, for a prototype where the
5317 argument type is specified but not the name.
5319 This function is where the complicated C meanings of `static'
5320 and `extern' are interpreted. */
5323 grokdeclarator (const struct c_declarator
*declarator
,
5324 struct c_declspecs
*declspecs
,
5325 enum decl_context decl_context
, bool initialized
, tree
*width
,
5326 tree
*decl_attrs
, tree
*expr
, bool *expr_const_operands
,
5327 enum deprecated_states deprecated_state
)
5329 tree type
= declspecs
->type
;
5330 bool threadp
= declspecs
->thread_p
;
5331 enum c_storage_class storage_class
= declspecs
->storage_class
;
5336 int type_quals
= TYPE_UNQUALIFIED
;
5337 tree name
= NULL_TREE
;
5338 bool funcdef_flag
= false;
5339 bool funcdef_syntax
= false;
5340 bool size_varies
= false;
5341 tree decl_attr
= declspecs
->decl_attr
;
5342 int array_ptr_quals
= TYPE_UNQUALIFIED
;
5343 tree array_ptr_attrs
= NULL_TREE
;
5344 int array_parm_static
= 0;
5345 bool array_parm_vla_unspec_p
= false;
5346 tree returned_attrs
= NULL_TREE
;
5347 bool bitfield
= width
!= NULL
;
5349 struct c_arg_info
*arg_info
= 0;
5350 addr_space_t as1
, as2
, address_space
;
5351 location_t loc
= UNKNOWN_LOCATION
;
5354 bool expr_const_operands_dummy
;
5355 enum c_declarator_kind first_non_attr_kind
;
5356 unsigned int alignas_align
= 0;
5358 if (TREE_CODE (type
) == ERROR_MARK
)
5359 return error_mark_node
;
5362 if (expr_const_operands
== NULL
)
5363 expr_const_operands
= &expr_const_operands_dummy
;
5365 *expr
= declspecs
->expr
;
5366 *expr_const_operands
= declspecs
->expr_const_operands
;
5368 if (decl_context
== FUNCDEF
)
5369 funcdef_flag
= true, decl_context
= NORMAL
;
5371 /* Look inside a declarator for the name being declared
5372 and get it as an IDENTIFIER_NODE, for an error message. */
5374 const struct c_declarator
*decl
= declarator
;
5376 first_non_attr_kind
= cdk_attrs
;
5386 funcdef_syntax
= (decl
->kind
== cdk_function
);
5387 decl
= decl
->declarator
;
5388 if (first_non_attr_kind
== cdk_attrs
)
5389 first_non_attr_kind
= decl
->kind
;
5393 decl
= decl
->declarator
;
5400 if (first_non_attr_kind
== cdk_attrs
)
5401 first_non_attr_kind
= decl
->kind
;
5410 gcc_assert (decl_context
== PARM
5411 || decl_context
== TYPENAME
5412 || (decl_context
== FIELD
5413 && declarator
->kind
== cdk_id
));
5414 gcc_assert (!initialized
);
5418 /* A function definition's declarator must have the form of
5419 a function declarator. */
5421 if (funcdef_flag
&& !funcdef_syntax
)
5424 /* If this looks like a function definition, make it one,
5425 even if it occurs where parms are expected.
5426 Then store_parm_decls will reject it and not use it as a parm. */
5427 if (decl_context
== NORMAL
&& !funcdef_flag
&& current_scope
->parm_flag
)
5428 decl_context
= PARM
;
5430 if (declspecs
->deprecated_p
&& deprecated_state
!= DEPRECATED_SUPPRESS
)
5431 warn_deprecated_use (declspecs
->type
, declspecs
->decl_attr
);
5433 if ((decl_context
== NORMAL
|| decl_context
== FIELD
)
5434 && current_scope
== file_scope
5435 && variably_modified_type_p (type
, NULL_TREE
))
5438 error_at (loc
, "variably modified %qE at file scope", name
);
5440 error_at (loc
, "variably modified field at file scope");
5441 type
= integer_type_node
;
5444 size_varies
= C_TYPE_VARIABLE_SIZE (type
) != 0;
5446 /* Diagnose defaulting to "int". */
5448 if (declspecs
->default_int_p
&& !in_system_header_at (input_location
))
5450 /* Issue a warning if this is an ISO C 99 program or if
5451 -Wreturn-type and this is a function, or if -Wimplicit;
5452 prefer the former warning since it is more explicit. */
5453 if ((warn_implicit_int
|| warn_return_type
|| flag_isoc99
)
5455 warn_about_return_type
= 1;
5459 warn_defaults_to (loc
, OPT_Wimplicit_int
,
5460 "type defaults to %<int%> in declaration "
5463 warn_defaults_to (loc
, OPT_Wimplicit_int
,
5464 "type defaults to %<int%> in type name");
5468 /* Adjust the type if a bit-field is being declared,
5469 -funsigned-bitfields applied and the type is not explicitly
5471 if (bitfield
&& !flag_signed_bitfields
&& !declspecs
->explicit_signed_p
5472 && TREE_CODE (type
) == INTEGER_TYPE
)
5473 type
= unsigned_type_for (type
);
5475 /* Figure out the type qualifiers for the declaration. There are
5476 two ways a declaration can become qualified. One is something
5477 like `const int i' where the `const' is explicit. Another is
5478 something like `typedef const int CI; CI i' where the type of the
5479 declaration contains the `const'. A third possibility is that
5480 there is a type qualifier on the element type of a typedefed
5481 array type, in which case we should extract that qualifier so
5482 that c_apply_type_quals_to_decl receives the full list of
5483 qualifiers to work with (C90 is not entirely clear about whether
5484 duplicate qualifiers should be diagnosed in this case, but it
5485 seems most appropriate to do so). */
5486 element_type
= strip_array_types (type
);
5487 constp
= declspecs
->const_p
+ TYPE_READONLY (element_type
);
5488 restrictp
= declspecs
->restrict_p
+ TYPE_RESTRICT (element_type
);
5489 volatilep
= declspecs
->volatile_p
+ TYPE_VOLATILE (element_type
);
5490 atomicp
= declspecs
->atomic_p
+ TYPE_ATOMIC (element_type
);
5491 as1
= declspecs
->address_space
;
5492 as2
= TYPE_ADDR_SPACE (element_type
);
5493 address_space
= ADDR_SPACE_GENERIC_P (as1
)? as2
: as1
;
5496 pedwarn_c90 (loc
, OPT_Wpedantic
, "duplicate %<const%>");
5498 pedwarn_c90 (loc
, OPT_Wpedantic
, "duplicate %<restrict%>");
5500 pedwarn_c90 (loc
, OPT_Wpedantic
, "duplicate %<volatile%>");
5502 pedwarn_c90 (loc
, OPT_Wpedantic
, "duplicate %<_Atomic%>");
5504 if (!ADDR_SPACE_GENERIC_P (as1
) && !ADDR_SPACE_GENERIC_P (as2
) && as1
!= as2
)
5505 error_at (loc
, "conflicting named address spaces (%s vs %s)",
5506 c_addr_space_name (as1
), c_addr_space_name (as2
));
5508 if ((TREE_CODE (type
) == ARRAY_TYPE
5509 || first_non_attr_kind
== cdk_array
)
5510 && TYPE_QUALS (element_type
))
5511 type
= TYPE_MAIN_VARIANT (type
);
5512 type_quals
= ((constp
? TYPE_QUAL_CONST
: 0)
5513 | (restrictp
? TYPE_QUAL_RESTRICT
: 0)
5514 | (volatilep
? TYPE_QUAL_VOLATILE
: 0)
5515 | (atomicp
? TYPE_QUAL_ATOMIC
: 0)
5516 | ENCODE_QUAL_ADDR_SPACE (address_space
));
5518 /* Applying the _Atomic qualifier to an array type (through the use
5519 of typedefs or typeof) must be detected here. If the qualifier
5520 is introduced later, any appearance of applying it to an array is
5521 actually applying it to an element of that array. */
5522 if (atomicp
&& TREE_CODE (type
) == ARRAY_TYPE
)
5523 error_at (loc
, "%<_Atomic%>-qualified array type");
5525 /* Warn about storage classes that are invalid for certain
5526 kinds of declarations (parameters, typenames, etc.). */
5530 || storage_class
== csc_auto
5531 || storage_class
== csc_register
5532 || storage_class
== csc_typedef
))
5534 if (storage_class
== csc_auto
)
5536 (current_scope
== file_scope
) ? 0 : OPT_Wpedantic
,
5537 "function definition declared %<auto%>");
5538 if (storage_class
== csc_register
)
5539 error_at (loc
, "function definition declared %<register%>");
5540 if (storage_class
== csc_typedef
)
5541 error_at (loc
, "function definition declared %<typedef%>");
5543 error_at (loc
, "function definition declared %qs",
5544 declspecs
->thread_gnu_p
? "__thread" : "_Thread_local");
5546 if (storage_class
== csc_auto
5547 || storage_class
== csc_register
5548 || storage_class
== csc_typedef
)
5549 storage_class
= csc_none
;
5551 else if (decl_context
!= NORMAL
&& (storage_class
!= csc_none
|| threadp
))
5553 if (decl_context
== PARM
&& storage_class
== csc_register
)
5557 switch (decl_context
)
5561 error_at (loc
, "storage class specified for structure "
5564 error_at (loc
, "storage class specified for structure field");
5568 error_at (loc
, "storage class specified for parameter %qE",
5571 error_at (loc
, "storage class specified for unnamed parameter");
5574 error_at (loc
, "storage class specified for typename");
5577 storage_class
= csc_none
;
5581 else if (storage_class
== csc_extern
5585 /* 'extern' with initialization is invalid if not at file scope. */
5586 if (current_scope
== file_scope
)
5588 /* It is fine to have 'extern const' when compiling at C
5589 and C++ intersection. */
5590 if (!(warn_cxx_compat
&& constp
))
5591 warning_at (loc
, 0, "%qE initialized and declared %<extern%>",
5595 error_at (loc
, "%qE has both %<extern%> and initializer", name
);
5597 else if (current_scope
== file_scope
)
5599 if (storage_class
== csc_auto
)
5600 error_at (loc
, "file-scope declaration of %qE specifies %<auto%>",
5602 if (pedantic
&& storage_class
== csc_register
)
5603 pedwarn (input_location
, OPT_Wpedantic
,
5604 "file-scope declaration of %qE specifies %<register%>", name
);
5608 if (storage_class
== csc_extern
&& funcdef_flag
)
5609 error_at (loc
, "nested function %qE declared %<extern%>", name
);
5610 else if (threadp
&& storage_class
== csc_none
)
5612 error_at (loc
, "function-scope %qE implicitly auto and declared "
5614 declspecs
->thread_gnu_p
? "__thread" : "_Thread_local");
5619 /* Now figure out the structure of the declarator proper.
5620 Descend through it, creating more complex types, until we reach
5621 the declared identifier (or NULL_TREE, in an absolute declarator).
5622 At each stage we maintain an unqualified version of the type
5623 together with any qualifiers that should be applied to it with
5624 c_build_qualified_type; this way, array types including
5625 multidimensional array types are first built up in unqualified
5626 form and then the qualified form is created with
5627 TYPE_MAIN_VARIANT pointing to the unqualified form. */
5629 while (declarator
&& declarator
->kind
!= cdk_id
)
5631 if (type
== error_mark_node
)
5633 declarator
= declarator
->declarator
;
5637 /* Each level of DECLARATOR is either a cdk_array (for ...[..]),
5638 a cdk_pointer (for *...),
5639 a cdk_function (for ...(...)),
5640 a cdk_attrs (for nested attributes),
5641 or a cdk_id (for the name being declared
5642 or the place in an absolute declarator
5643 where the name was omitted).
5644 For the last case, we have just exited the loop.
5646 At this point, TYPE is the type of elements of an array,
5647 or for a function to return, or for a pointer to point to.
5648 After this sequence of ifs, TYPE is the type of the
5649 array or function or pointer, and DECLARATOR has had its
5650 outermost layer removed. */
5652 if (array_ptr_quals
!= TYPE_UNQUALIFIED
5653 || array_ptr_attrs
!= NULL_TREE
5654 || array_parm_static
)
5656 /* Only the innermost declarator (making a parameter be of
5657 array type which is converted to pointer type)
5658 may have static or type qualifiers. */
5659 error_at (loc
, "static or type qualifiers in non-parameter array declarator");
5660 array_ptr_quals
= TYPE_UNQUALIFIED
;
5661 array_ptr_attrs
= NULL_TREE
;
5662 array_parm_static
= 0;
5665 switch (declarator
->kind
)
5669 /* A declarator with embedded attributes. */
5670 tree attrs
= declarator
->u
.attrs
;
5671 const struct c_declarator
*inner_decl
;
5673 declarator
= declarator
->declarator
;
5674 inner_decl
= declarator
;
5675 while (inner_decl
->kind
== cdk_attrs
)
5676 inner_decl
= inner_decl
->declarator
;
5677 if (inner_decl
->kind
== cdk_id
)
5678 attr_flags
|= (int) ATTR_FLAG_DECL_NEXT
;
5679 else if (inner_decl
->kind
== cdk_function
)
5680 attr_flags
|= (int) ATTR_FLAG_FUNCTION_NEXT
;
5681 else if (inner_decl
->kind
== cdk_array
)
5682 attr_flags
|= (int) ATTR_FLAG_ARRAY_NEXT
;
5683 returned_attrs
= decl_attributes (&type
,
5684 chainon (returned_attrs
, attrs
),
5690 tree itype
= NULL_TREE
;
5691 tree size
= declarator
->u
.array
.dimen
;
5692 /* The index is a signed object `sizetype' bits wide. */
5693 tree index_type
= c_common_signed_type (sizetype
);
5695 array_ptr_quals
= declarator
->u
.array
.quals
;
5696 array_ptr_attrs
= declarator
->u
.array
.attrs
;
5697 array_parm_static
= declarator
->u
.array
.static_p
;
5698 array_parm_vla_unspec_p
= declarator
->u
.array
.vla_unspec_p
;
5700 declarator
= declarator
->declarator
;
5702 /* Check for some types that there cannot be arrays of. */
5704 if (VOID_TYPE_P (type
))
5707 error_at (loc
, "declaration of %qE as array of voids", name
);
5709 error_at (loc
, "declaration of type name as array of voids");
5710 type
= error_mark_node
;
5713 if (TREE_CODE (type
) == FUNCTION_TYPE
)
5716 error_at (loc
, "declaration of %qE as array of functions",
5719 error_at (loc
, "declaration of type name as array of "
5721 type
= error_mark_node
;
5724 if (pedantic
&& !in_system_header_at (input_location
)
5725 && flexible_array_type_p (type
))
5726 pedwarn (loc
, OPT_Wpedantic
,
5727 "invalid use of structure with flexible array member");
5729 if (size
== error_mark_node
)
5730 type
= error_mark_node
;
5732 if (type
== error_mark_node
)
5735 /* If size was specified, set ITYPE to a range-type for
5736 that size. Otherwise, ITYPE remains null. finish_decl
5737 may figure it out from an initial value. */
5741 bool size_maybe_const
= true;
5742 bool size_int_const
= (TREE_CODE (size
) == INTEGER_CST
5743 && !TREE_OVERFLOW (size
));
5744 bool this_size_varies
= false;
5746 /* Strip NON_LVALUE_EXPRs since we aren't using as an
5748 STRIP_TYPE_NOPS (size
);
5750 if (!INTEGRAL_TYPE_P (TREE_TYPE (size
)))
5753 error_at (loc
, "size of array %qE has non-integer type",
5757 "size of unnamed array has non-integer type");
5758 size
= integer_one_node
;
5761 size
= c_fully_fold (size
, false, &size_maybe_const
);
5763 if (pedantic
&& size_maybe_const
&& integer_zerop (size
))
5766 pedwarn (loc
, OPT_Wpedantic
,
5767 "ISO C forbids zero-size array %qE", name
);
5769 pedwarn (loc
, OPT_Wpedantic
,
5770 "ISO C forbids zero-size array");
5773 if (TREE_CODE (size
) == INTEGER_CST
&& size_maybe_const
)
5775 constant_expression_warning (size
);
5776 if (tree_int_cst_sgn (size
) < 0)
5779 error_at (loc
, "size of array %qE is negative", name
);
5781 error_at (loc
, "size of unnamed array is negative");
5782 size
= integer_one_node
;
5784 /* Handle a size folded to an integer constant but
5785 not an integer constant expression. */
5786 if (!size_int_const
)
5788 /* If this is a file scope declaration of an
5789 ordinary identifier, this is invalid code;
5790 diagnosing it here and not subsequently
5791 treating the type as variable-length avoids
5792 more confusing diagnostics later. */
5793 if ((decl_context
== NORMAL
|| decl_context
== FIELD
)
5794 && current_scope
== file_scope
)
5795 pedwarn (input_location
, 0,
5796 "variably modified %qE at file scope",
5799 this_size_varies
= size_varies
= true;
5800 warn_variable_length_array (name
, size
);
5803 else if ((decl_context
== NORMAL
|| decl_context
== FIELD
)
5804 && current_scope
== file_scope
)
5806 error_at (loc
, "variably modified %qE at file scope", name
);
5807 size
= integer_one_node
;
5811 /* Make sure the array size remains visibly
5812 nonconstant even if it is (eg) a const variable
5813 with known value. */
5814 this_size_varies
= size_varies
= true;
5815 warn_variable_length_array (name
, size
);
5816 if (flag_sanitize
& SANITIZE_VLA
5817 && decl_context
== NORMAL
5818 && do_ubsan_in_current_function ())
5820 /* Evaluate the array size only once. */
5821 size
= c_save_expr (size
);
5822 size
= c_fully_fold (size
, false, NULL
);
5823 size
= fold_build2 (COMPOUND_EXPR
, TREE_TYPE (size
),
5824 ubsan_instrument_vla (loc
, size
),
5829 if (integer_zerop (size
) && !this_size_varies
)
5831 /* A zero-length array cannot be represented with
5832 an unsigned index type, which is what we'll
5833 get with build_index_type. Create an
5834 open-ended range instead. */
5835 itype
= build_range_type (sizetype
, size
, NULL_TREE
);
5839 /* Arrange for the SAVE_EXPR on the inside of the
5840 MINUS_EXPR, which allows the -1 to get folded
5841 with the +1 that happens when building TYPE_SIZE. */
5843 size
= save_expr (size
);
5844 if (this_size_varies
&& TREE_CODE (size
) == INTEGER_CST
)
5845 size
= build2 (COMPOUND_EXPR
, TREE_TYPE (size
),
5846 integer_zero_node
, size
);
5848 /* Compute the maximum valid index, that is, size
5849 - 1. Do the calculation in index_type, so that
5850 if it is a variable the computations will be
5851 done in the proper mode. */
5852 itype
= fold_build2_loc (loc
, MINUS_EXPR
, index_type
,
5853 convert (index_type
, size
),
5854 convert (index_type
,
5857 /* The above overflows when size does not fit
5859 ??? While a size of INT_MAX+1 technically shouldn't
5860 cause an overflow (because we subtract 1), handling
5861 this case seems like an unnecessary complication. */
5862 if (TREE_CODE (size
) == INTEGER_CST
5863 && !int_fits_type_p (size
, index_type
))
5866 error_at (loc
, "size of array %qE is too large",
5869 error_at (loc
, "size of unnamed array is too large");
5870 type
= error_mark_node
;
5874 itype
= build_index_type (itype
);
5876 if (this_size_varies
)
5879 *expr
= build2 (COMPOUND_EXPR
, TREE_TYPE (size
),
5883 *expr_const_operands
&= size_maybe_const
;
5886 else if (decl_context
== FIELD
)
5888 bool flexible_array_member
= false;
5889 if (array_parm_vla_unspec_p
)
5890 /* Field names can in fact have function prototype
5891 scope so [*] is disallowed here through making
5892 the field variably modified, not through being
5893 something other than a declaration with function
5898 const struct c_declarator
*t
= declarator
;
5899 while (t
->kind
== cdk_attrs
)
5901 flexible_array_member
= (t
->kind
== cdk_id
);
5903 if (flexible_array_member
5904 && !in_system_header_at (input_location
))
5905 pedwarn_c90 (loc
, OPT_Wpedantic
, "ISO C90 does not "
5906 "support flexible array members");
5908 /* ISO C99 Flexible array members are effectively
5909 identical to GCC's zero-length array extension. */
5910 if (flexible_array_member
|| array_parm_vla_unspec_p
)
5911 itype
= build_range_type (sizetype
, size_zero_node
,
5914 else if (decl_context
== PARM
)
5916 if (array_parm_vla_unspec_p
)
5918 itype
= build_range_type (sizetype
, size_zero_node
, NULL_TREE
);
5922 else if (decl_context
== TYPENAME
)
5924 if (array_parm_vla_unspec_p
)
5927 warning (0, "%<[*]%> not in a declaration");
5928 /* We use this to avoid messing up with incomplete
5929 array types of the same type, that would
5930 otherwise be modified below. */
5931 itype
= build_range_type (sizetype
, size_zero_node
,
5937 /* Complain about arrays of incomplete types. */
5938 if (!COMPLETE_TYPE_P (type
))
5940 error_at (loc
, "array type has incomplete element type %qT",
5942 type
= error_mark_node
;
5945 /* When itype is NULL, a shared incomplete array type is
5946 returned for all array of a given type. Elsewhere we
5947 make sure we don't complete that type before copying
5948 it, but here we want to make sure we don't ever
5949 modify the shared type, so we gcc_assert (itype)
5952 addr_space_t as
= DECODE_QUAL_ADDR_SPACE (type_quals
);
5953 if (!ADDR_SPACE_GENERIC_P (as
) && as
!= TYPE_ADDR_SPACE (type
))
5954 type
= build_qualified_type (type
,
5955 ENCODE_QUAL_ADDR_SPACE (as
));
5957 type
= build_array_type (type
, itype
);
5960 if (type
!= error_mark_node
)
5964 /* It is ok to modify type here even if itype is
5965 NULL: if size_varies, we're in a
5966 multi-dimensional array and the inner type has
5967 variable size, so the enclosing shared array type
5969 if (size
&& TREE_CODE (size
) == INTEGER_CST
)
5971 = build_distinct_type_copy (TYPE_MAIN_VARIANT (type
));
5972 C_TYPE_VARIABLE_SIZE (type
) = 1;
5975 /* The GCC extension for zero-length arrays differs from
5976 ISO flexible array members in that sizeof yields
5978 if (size
&& integer_zerop (size
))
5981 type
= build_distinct_type_copy (TYPE_MAIN_VARIANT (type
));
5982 TYPE_SIZE (type
) = bitsize_zero_node
;
5983 TYPE_SIZE_UNIT (type
) = size_zero_node
;
5984 SET_TYPE_STRUCTURAL_EQUALITY (type
);
5986 if (array_parm_vla_unspec_p
)
5989 /* The type is complete. C99 6.7.5.2p4 */
5990 type
= build_distinct_type_copy (TYPE_MAIN_VARIANT (type
));
5991 TYPE_SIZE (type
) = bitsize_zero_node
;
5992 TYPE_SIZE_UNIT (type
) = size_zero_node
;
5993 SET_TYPE_STRUCTURAL_EQUALITY (type
);
5997 if (decl_context
!= PARM
5998 && (array_ptr_quals
!= TYPE_UNQUALIFIED
5999 || array_ptr_attrs
!= NULL_TREE
6000 || array_parm_static
))
6002 error_at (loc
, "static or type qualifiers in non-parameter array declarator");
6003 array_ptr_quals
= TYPE_UNQUALIFIED
;
6004 array_ptr_attrs
= NULL_TREE
;
6005 array_parm_static
= 0;
6011 /* Say it's a definition only for the declarator closest
6012 to the identifier, apart possibly from some
6014 bool really_funcdef
= false;
6018 const struct c_declarator
*t
= declarator
->declarator
;
6019 while (t
->kind
== cdk_attrs
)
6021 really_funcdef
= (t
->kind
== cdk_id
);
6024 /* Declaring a function type. Make sure we have a valid
6025 type for the function to return. */
6026 if (type
== error_mark_node
)
6029 size_varies
= false;
6031 /* Warn about some types functions can't return. */
6032 if (TREE_CODE (type
) == FUNCTION_TYPE
)
6035 error_at (loc
, "%qE declared as function returning a "
6038 error_at (loc
, "type name declared as function "
6039 "returning a function");
6040 type
= integer_type_node
;
6042 if (TREE_CODE (type
) == ARRAY_TYPE
)
6045 error_at (loc
, "%qE declared as function returning an array",
6048 error_at (loc
, "type name declared as function returning "
6050 type
= integer_type_node
;
6052 errmsg
= targetm
.invalid_return_type (type
);
6056 type
= integer_type_node
;
6059 /* Construct the function type and go to the next
6060 inner layer of declarator. */
6061 arg_info
= declarator
->u
.arg_info
;
6062 arg_types
= grokparms (arg_info
, really_funcdef
);
6064 /* Type qualifiers before the return type of the function
6065 qualify the return type, not the function type. */
6068 /* Type qualifiers on a function return type are
6069 normally permitted by the standard but have no
6070 effect, so give a warning at -Wreturn-type.
6071 Qualifiers on a void return type are banned on
6072 function definitions in ISO C; GCC used to used
6073 them for noreturn functions. */
6074 if (VOID_TYPE_P (type
) && really_funcdef
)
6076 "function definition has qualified void return type");
6078 warning_at (loc
, OPT_Wignored_qualifiers
,
6079 "type qualifiers ignored on function return type");
6081 type
= c_build_qualified_type (type
, type_quals
);
6083 type_quals
= TYPE_UNQUALIFIED
;
6085 type
= build_function_type (type
, arg_types
);
6086 declarator
= declarator
->declarator
;
6088 /* Set the TYPE_CONTEXTs for each tagged type which is local to
6089 the formal parameter list of this FUNCTION_TYPE to point to
6090 the FUNCTION_TYPE node itself. */
6095 FOR_EACH_VEC_SAFE_ELT_REVERSE (arg_info
->tags
, ix
, tag
)
6096 TYPE_CONTEXT (tag
->type
) = type
;
6102 /* Merge any constancy or volatility into the target type
6104 if ((type_quals
& TYPE_QUAL_ATOMIC
)
6105 && TREE_CODE (type
) == FUNCTION_TYPE
)
6108 "%<_Atomic%>-qualified function type");
6109 type_quals
&= ~TYPE_QUAL_ATOMIC
;
6111 else if (pedantic
&& TREE_CODE (type
) == FUNCTION_TYPE
6113 pedwarn (loc
, OPT_Wpedantic
,
6114 "ISO C forbids qualified function types");
6116 type
= c_build_qualified_type (type
, type_quals
);
6117 size_varies
= false;
6119 /* When the pointed-to type involves components of variable size,
6120 care must be taken to ensure that the size evaluation code is
6121 emitted early enough to dominate all the possible later uses
6122 and late enough for the variables on which it depends to have
6125 This is expected to happen automatically when the pointed-to
6126 type has a name/declaration of it's own, but special attention
6127 is required if the type is anonymous.
6129 We handle the NORMAL and FIELD contexts here by attaching an
6130 artificial TYPE_DECL to such pointed-to type. This forces the
6131 sizes evaluation at a safe point and ensures it is not deferred
6132 until e.g. within a deeper conditional context.
6134 We expect nothing to be needed here for PARM or TYPENAME.
6135 Pushing a TYPE_DECL at this point for TYPENAME would actually
6136 be incorrect, as we might be in the middle of an expression
6137 with side effects on the pointed-to type size "arguments" prior
6138 to the pointer declaration point and the fake TYPE_DECL in the
6139 enclosing context would force the size evaluation prior to the
6142 if (!TYPE_NAME (type
)
6143 && (decl_context
== NORMAL
|| decl_context
== FIELD
)
6144 && variably_modified_type_p (type
, NULL_TREE
))
6146 tree decl
= build_decl (loc
, TYPE_DECL
, NULL_TREE
, type
);
6147 DECL_ARTIFICIAL (decl
) = 1;
6149 finish_decl (decl
, loc
, NULL_TREE
, NULL_TREE
, NULL_TREE
);
6150 TYPE_NAME (type
) = decl
;
6153 type
= c_build_pointer_type (type
);
6155 /* Process type qualifiers (such as const or volatile)
6156 that were given inside the `*'. */
6157 type_quals
= declarator
->u
.pointer_quals
;
6159 declarator
= declarator
->declarator
;
6166 *decl_attrs
= chainon (returned_attrs
, *decl_attrs
);
6168 /* Now TYPE has the actual type, apart from any qualifiers in
6171 /* Warn about address space used for things other than static memory or
6173 address_space
= DECODE_QUAL_ADDR_SPACE (type_quals
);
6174 if (!ADDR_SPACE_GENERIC_P (address_space
))
6176 if (decl_context
== NORMAL
)
6178 switch (storage_class
)
6181 error ("%qs combined with %<auto%> qualifier for %qE",
6182 c_addr_space_name (address_space
), name
);
6185 error ("%qs combined with %<register%> qualifier for %qE",
6186 c_addr_space_name (address_space
), name
);
6189 if (current_function_scope
)
6191 error ("%qs specified for auto variable %qE",
6192 c_addr_space_name (address_space
), name
);
6204 else if (decl_context
== PARM
&& TREE_CODE (type
) != ARRAY_TYPE
)
6207 error ("%qs specified for parameter %qE",
6208 c_addr_space_name (address_space
), name
);
6210 error ("%qs specified for unnamed parameter",
6211 c_addr_space_name (address_space
));
6213 else if (decl_context
== FIELD
)
6216 error ("%qs specified for structure field %qE",
6217 c_addr_space_name (address_space
), name
);
6219 error ("%qs specified for structure field",
6220 c_addr_space_name (address_space
));
6224 /* Check the type and width of a bit-field. */
6227 check_bitfield_type_and_width (&type
, width
, name
);
6228 /* C11 makes it implementation-defined (6.7.2.1#5) whether
6229 atomic types are permitted for bit-fields; we have no code to
6230 make bit-field accesses atomic, so disallow them. */
6231 if (type_quals
& TYPE_QUAL_ATOMIC
)
6234 error ("bit-field %qE has atomic type", name
);
6236 error ("bit-field has atomic type");
6237 type_quals
&= ~TYPE_QUAL_ATOMIC
;
6241 /* Reject invalid uses of _Alignas. */
6242 if (declspecs
->alignas_p
)
6244 if (storage_class
== csc_typedef
)
6245 error_at (loc
, "alignment specified for typedef %qE", name
);
6246 else if (storage_class
== csc_register
)
6247 error_at (loc
, "alignment specified for %<register%> object %qE",
6249 else if (decl_context
== PARM
)
6252 error_at (loc
, "alignment specified for parameter %qE", name
);
6254 error_at (loc
, "alignment specified for unnamed parameter");
6259 error_at (loc
, "alignment specified for bit-field %qE", name
);
6261 error_at (loc
, "alignment specified for unnamed bit-field");
6263 else if (TREE_CODE (type
) == FUNCTION_TYPE
)
6264 error_at (loc
, "alignment specified for function %qE", name
);
6265 else if (declspecs
->align_log
!= -1)
6267 alignas_align
= 1U << declspecs
->align_log
;
6268 if (alignas_align
< min_align_of_type (type
))
6271 error_at (loc
, "%<_Alignas%> specifiers cannot reduce "
6272 "alignment of %qE", name
);
6274 error_at (loc
, "%<_Alignas%> specifiers cannot reduce "
6275 "alignment of unnamed field");
6281 /* Did array size calculations overflow or does the array cover more
6282 than half of the address-space? */
6283 if (TREE_CODE (type
) == ARRAY_TYPE
6284 && COMPLETE_TYPE_P (type
)
6285 && TREE_CODE (TYPE_SIZE_UNIT (type
)) == INTEGER_CST
6286 && ! valid_constant_size_p (TYPE_SIZE_UNIT (type
)))
6289 error_at (loc
, "size of array %qE is too large", name
);
6291 error_at (loc
, "size of unnamed array is too large");
6292 /* If we proceed with the array type as it is, we'll eventually
6293 crash in tree_to_[su]hwi(). */
6294 type
= error_mark_node
;
6297 /* If this is declaring a typedef name, return a TYPE_DECL. */
6299 if (storage_class
== csc_typedef
)
6302 if ((type_quals
& TYPE_QUAL_ATOMIC
)
6303 && TREE_CODE (type
) == FUNCTION_TYPE
)
6306 "%<_Atomic%>-qualified function type");
6307 type_quals
&= ~TYPE_QUAL_ATOMIC
;
6309 else if (pedantic
&& TREE_CODE (type
) == FUNCTION_TYPE
6311 pedwarn (loc
, OPT_Wpedantic
,
6312 "ISO C forbids qualified function types");
6314 type
= c_build_qualified_type (type
, type_quals
);
6315 decl
= build_decl (declarator
->id_loc
,
6316 TYPE_DECL
, declarator
->u
.id
, type
);
6317 if (declspecs
->explicit_signed_p
)
6318 C_TYPEDEF_EXPLICITLY_SIGNED (decl
) = 1;
6319 if (declspecs
->inline_p
)
6320 pedwarn (loc
, 0,"typedef %q+D declared %<inline%>", decl
);
6321 if (declspecs
->noreturn_p
)
6322 pedwarn (loc
, 0,"typedef %q+D declared %<_Noreturn%>", decl
);
6324 if (warn_cxx_compat
&& declarator
->u
.id
!= NULL_TREE
)
6326 struct c_binding
*b
= I_TAG_BINDING (declarator
->u
.id
);
6329 && b
->decl
!= NULL_TREE
6330 && (B_IN_CURRENT_SCOPE (b
)
6331 || (current_scope
== file_scope
&& B_IN_EXTERNAL_SCOPE (b
)))
6332 && TYPE_MAIN_VARIANT (b
->decl
) != TYPE_MAIN_VARIANT (type
))
6334 warning_at (declarator
->id_loc
, OPT_Wc___compat
,
6335 ("using %qD as both a typedef and a tag is "
6338 if (b
->locus
!= UNKNOWN_LOCATION
)
6339 inform (b
->locus
, "originally defined here");
6346 /* If this is a type name (such as, in a cast or sizeof),
6347 compute the type and return it now. */
6349 if (decl_context
== TYPENAME
)
6351 /* Note that the grammar rejects storage classes in typenames
6353 gcc_assert (storage_class
== csc_none
&& !threadp
6354 && !declspecs
->inline_p
&& !declspecs
->noreturn_p
);
6355 if ((type_quals
& TYPE_QUAL_ATOMIC
)
6356 && TREE_CODE (type
) == FUNCTION_TYPE
)
6359 "%<_Atomic%>-qualified function type");
6360 type_quals
&= ~TYPE_QUAL_ATOMIC
;
6362 else if (pedantic
&& TREE_CODE (type
) == FUNCTION_TYPE
6364 pedwarn (loc
, OPT_Wpedantic
,
6365 "ISO C forbids const or volatile function types");
6367 type
= c_build_qualified_type (type
, type_quals
);
6371 if (pedantic
&& decl_context
== FIELD
6372 && variably_modified_type_p (type
, NULL_TREE
))
6375 pedwarn (loc
, OPT_Wpedantic
, "a member of a structure or union cannot "
6376 "have a variably modified type");
6379 /* Aside from typedefs and type names (handle above),
6380 `void' at top level (not within pointer)
6381 is allowed only in public variables.
6382 We don't complain about parms either, but that is because
6383 a better error message can be made later. */
6385 if (VOID_TYPE_P (type
) && decl_context
!= PARM
6386 && !((decl_context
!= FIELD
&& TREE_CODE (type
) != FUNCTION_TYPE
)
6387 && (storage_class
== csc_extern
6388 || (current_scope
== file_scope
6389 && !(storage_class
== csc_static
6390 || storage_class
== csc_register
)))))
6392 error_at (loc
, "variable or field %qE declared void", name
);
6393 type
= integer_type_node
;
6396 /* Now create the decl, which may be a VAR_DECL, a PARM_DECL
6397 or a FUNCTION_DECL, depending on DECL_CONTEXT and TYPE. */
6402 if (decl_context
== PARM
)
6405 bool array_parameter_p
= false;
6407 /* A parameter declared as an array of T is really a pointer to T.
6408 One declared as a function is really a pointer to a function. */
6410 if (TREE_CODE (type
) == ARRAY_TYPE
)
6412 /* Transfer const-ness of array into that of type pointed to. */
6413 type
= TREE_TYPE (type
);
6415 type
= c_build_qualified_type (type
, type_quals
);
6416 type
= c_build_pointer_type (type
);
6417 type_quals
= array_ptr_quals
;
6419 type
= c_build_qualified_type (type
, type_quals
);
6421 /* We don't yet implement attributes in this context. */
6422 if (array_ptr_attrs
!= NULL_TREE
)
6423 warning_at (loc
, OPT_Wattributes
,
6424 "attributes in parameter array declarator ignored");
6426 size_varies
= false;
6427 array_parameter_p
= true;
6429 else if (TREE_CODE (type
) == FUNCTION_TYPE
)
6431 if (type_quals
& TYPE_QUAL_ATOMIC
)
6434 "%<_Atomic%>-qualified function type");
6435 type_quals
&= ~TYPE_QUAL_ATOMIC
;
6437 else if (type_quals
)
6438 pedwarn (loc
, OPT_Wpedantic
,
6439 "ISO C forbids qualified function types");
6441 type
= c_build_qualified_type (type
, type_quals
);
6442 type
= c_build_pointer_type (type
);
6443 type_quals
= TYPE_UNQUALIFIED
;
6445 else if (type_quals
)
6446 type
= c_build_qualified_type (type
, type_quals
);
6448 decl
= build_decl (declarator
->id_loc
,
6449 PARM_DECL
, declarator
->u
.id
, type
);
6451 C_DECL_VARIABLE_SIZE (decl
) = 1;
6452 C_ARRAY_PARAMETER (decl
) = array_parameter_p
;
6454 /* Compute the type actually passed in the parmlist,
6455 for the case where there is no prototype.
6456 (For example, shorts and chars are passed as ints.)
6457 When there is a prototype, this is overridden later. */
6459 if (type
== error_mark_node
)
6460 promoted_type
= type
;
6462 promoted_type
= c_type_promotes_to (type
);
6464 DECL_ARG_TYPE (decl
) = promoted_type
;
6465 if (declspecs
->inline_p
)
6466 pedwarn (loc
, 0, "parameter %q+D declared %<inline%>", decl
);
6467 if (declspecs
->noreturn_p
)
6468 pedwarn (loc
, 0, "parameter %q+D declared %<_Noreturn%>", decl
);
6470 else if (decl_context
== FIELD
)
6472 /* Note that the grammar rejects storage classes in typenames
6474 gcc_assert (storage_class
== csc_none
&& !threadp
6475 && !declspecs
->inline_p
&& !declspecs
->noreturn_p
);
6477 /* Structure field. It may not be a function. */
6479 if (TREE_CODE (type
) == FUNCTION_TYPE
)
6481 error_at (loc
, "field %qE declared as a function", name
);
6482 type
= build_pointer_type (type
);
6484 else if (TREE_CODE (type
) != ERROR_MARK
6485 && !COMPLETE_OR_UNBOUND_ARRAY_TYPE_P (type
))
6488 error_at (loc
, "field %qE has incomplete type", name
);
6490 error_at (loc
, "unnamed field has incomplete type");
6491 type
= error_mark_node
;
6493 else if (TREE_CODE (type
) == ARRAY_TYPE
6494 && TYPE_DOMAIN (type
) == NULL_TREE
)
6496 /* We have a flexible array member through a typedef.
6497 Set suitable range. Whether this is a correct position
6498 for a flexible array member will be determined elsewhere. */
6499 if (!in_system_header_at (input_location
))
6500 pedwarn_c90 (loc
, OPT_Wpedantic
, "ISO C90 does not "
6501 "support flexible array members");
6502 type
= build_distinct_type_copy (TYPE_MAIN_VARIANT (type
));
6503 TYPE_DOMAIN (type
) = build_range_type (sizetype
, size_zero_node
,
6506 type
= c_build_qualified_type (type
, type_quals
);
6507 decl
= build_decl (declarator
->id_loc
,
6508 FIELD_DECL
, declarator
->u
.id
, type
);
6509 DECL_NONADDRESSABLE_P (decl
) = bitfield
;
6510 if (bitfield
&& !declarator
->u
.id
)
6511 TREE_NO_WARNING (decl
) = 1;
6514 C_DECL_VARIABLE_SIZE (decl
) = 1;
6516 else if (TREE_CODE (type
) == FUNCTION_TYPE
)
6518 if (storage_class
== csc_register
|| threadp
)
6520 error_at (loc
, "invalid storage class for function %qE", name
);
6522 else if (current_scope
!= file_scope
)
6524 /* Function declaration not at file scope. Storage
6525 classes other than `extern' are not allowed, C99
6526 6.7.1p5, and `extern' makes no difference. However,
6527 GCC allows 'auto', perhaps with 'inline', to support
6528 nested functions. */
6529 if (storage_class
== csc_auto
)
6530 pedwarn (loc
, OPT_Wpedantic
,
6531 "invalid storage class for function %qE", name
);
6532 else if (storage_class
== csc_static
)
6534 error_at (loc
, "invalid storage class for function %qE", name
);
6536 storage_class
= declspecs
->storage_class
= csc_none
;
6542 decl
= build_decl (declarator
->id_loc
,
6543 FUNCTION_DECL
, declarator
->u
.id
, type
);
6544 decl
= build_decl_attribute_variant (decl
, decl_attr
);
6546 if (type_quals
& TYPE_QUAL_ATOMIC
)
6549 "%<_Atomic%>-qualified function type");
6550 type_quals
&= ~TYPE_QUAL_ATOMIC
;
6552 else if (pedantic
&& type_quals
&& !DECL_IN_SYSTEM_HEADER (decl
))
6553 pedwarn (loc
, OPT_Wpedantic
,
6554 "ISO C forbids qualified function types");
6556 /* Every function declaration is an external reference
6557 (DECL_EXTERNAL) except for those which are not at file
6558 scope and are explicitly declared "auto". This is
6559 forbidden by standard C (C99 6.7.1p5) and is interpreted by
6560 GCC to signify a forward declaration of a nested function. */
6561 if (storage_class
== csc_auto
&& current_scope
!= file_scope
)
6562 DECL_EXTERNAL (decl
) = 0;
6563 /* In C99, a function which is declared 'inline' with 'extern'
6564 is not an external reference (which is confusing). It
6565 means that the later definition of the function must be output
6566 in this file, C99 6.7.4p6. In GNU C89, a function declared
6567 'extern inline' is an external reference. */
6568 else if (declspecs
->inline_p
&& storage_class
!= csc_static
)
6569 DECL_EXTERNAL (decl
) = ((storage_class
== csc_extern
)
6570 == flag_gnu89_inline
);
6572 DECL_EXTERNAL (decl
) = !initialized
;
6574 /* Record absence of global scope for `static' or `auto'. */
6576 = !(storage_class
== csc_static
|| storage_class
== csc_auto
);
6578 /* For a function definition, record the argument information
6579 block where store_parm_decls will look for it. */
6581 current_function_arg_info
= arg_info
;
6583 if (declspecs
->default_int_p
)
6584 C_FUNCTION_IMPLICIT_INT (decl
) = 1;
6586 /* Record presence of `inline' and `_Noreturn', if it is
6588 if (flag_hosted
&& MAIN_NAME_P (declarator
->u
.id
))
6590 if (declspecs
->inline_p
)
6591 pedwarn (loc
, 0, "cannot inline function %<main%>");
6592 if (declspecs
->noreturn_p
)
6593 pedwarn (loc
, 0, "%<main%> declared %<_Noreturn%>");
6597 if (declspecs
->inline_p
)
6598 /* Record that the function is declared `inline'. */
6599 DECL_DECLARED_INLINE_P (decl
) = 1;
6600 if (declspecs
->noreturn_p
)
6603 pedwarn_c99 (loc
, OPT_Wpedantic
,
6604 "ISO C99 does not support %<_Noreturn%>");
6606 pedwarn_c99 (loc
, OPT_Wpedantic
,
6607 "ISO C90 does not support %<_Noreturn%>");
6608 TREE_THIS_VOLATILE (decl
) = 1;
6614 /* It's a variable. */
6615 /* An uninitialized decl with `extern' is a reference. */
6616 int extern_ref
= !initialized
&& storage_class
== csc_extern
;
6618 type
= c_build_qualified_type (type
, type_quals
);
6620 /* C99 6.2.2p7: It is invalid (compile-time undefined
6621 behavior) to create an 'extern' declaration for a
6622 variable if there is a global declaration that is
6623 'static' and the global declaration is not visible.
6624 (If the static declaration _is_ currently visible,
6625 the 'extern' declaration is taken to refer to that decl.) */
6626 if (extern_ref
&& current_scope
!= file_scope
)
6628 tree global_decl
= identifier_global_value (declarator
->u
.id
);
6629 tree visible_decl
= lookup_name (declarator
->u
.id
);
6632 && global_decl
!= visible_decl
6633 && VAR_P (global_decl
)
6634 && !TREE_PUBLIC (global_decl
))
6635 error_at (loc
, "variable previously declared %<static%> "
6636 "redeclared %<extern%>");
6639 decl
= build_decl (declarator
->id_loc
,
6640 VAR_DECL
, declarator
->u
.id
, type
);
6642 C_DECL_VARIABLE_SIZE (decl
) = 1;
6644 if (declspecs
->inline_p
)
6645 pedwarn (loc
, 0, "variable %q+D declared %<inline%>", decl
);
6646 if (declspecs
->noreturn_p
)
6647 pedwarn (loc
, 0, "variable %q+D declared %<_Noreturn%>", decl
);
6649 /* At file scope, an initialized extern declaration may follow
6650 a static declaration. In that case, DECL_EXTERNAL will be
6651 reset later in start_decl. */
6652 DECL_EXTERNAL (decl
) = (storage_class
== csc_extern
);
6654 /* At file scope, the presence of a `static' or `register' storage
6655 class specifier, or the absence of all storage class specifiers
6656 makes this declaration a definition (perhaps tentative). Also,
6657 the absence of `static' makes it public. */
6658 if (current_scope
== file_scope
)
6660 TREE_PUBLIC (decl
) = storage_class
!= csc_static
;
6661 TREE_STATIC (decl
) = !extern_ref
;
6663 /* Not at file scope, only `static' makes a static definition. */
6666 TREE_STATIC (decl
) = (storage_class
== csc_static
);
6667 TREE_PUBLIC (decl
) = extern_ref
;
6671 set_decl_tls_model (decl
, decl_default_tls_model (decl
));
6674 if ((storage_class
== csc_extern
6675 || (storage_class
== csc_none
6676 && TREE_CODE (type
) == FUNCTION_TYPE
6678 && variably_modified_type_p (type
, NULL_TREE
))
6681 if (TREE_CODE (type
) == FUNCTION_TYPE
)
6682 error_at (loc
, "non-nested function with variably modified type");
6684 error_at (loc
, "object with variably modified type must have "
6688 /* Record `register' declaration for warnings on &
6689 and in case doing stupid register allocation. */
6691 if (storage_class
== csc_register
)
6693 C_DECL_REGISTER (decl
) = 1;
6694 DECL_REGISTER (decl
) = 1;
6697 /* Record constancy and volatility. */
6698 c_apply_type_quals_to_decl (type_quals
, decl
);
6700 /* Apply _Alignas specifiers. */
6703 DECL_ALIGN (decl
) = alignas_align
* BITS_PER_UNIT
;
6704 DECL_USER_ALIGN (decl
) = 1;
6707 /* If a type has volatile components, it should be stored in memory.
6708 Otherwise, the fact that those components are volatile
6709 will be ignored, and would even crash the compiler.
6710 Of course, this only makes sense on VAR,PARM, and RESULT decl's. */
6711 if (C_TYPE_FIELDS_VOLATILE (TREE_TYPE (decl
))
6712 && (VAR_P (decl
) || TREE_CODE (decl
) == PARM_DECL
6713 || TREE_CODE (decl
) == RESULT_DECL
))
6715 /* It is not an error for a structure with volatile fields to
6716 be declared register, but reset DECL_REGISTER since it
6717 cannot actually go in a register. */
6718 int was_reg
= C_DECL_REGISTER (decl
);
6719 C_DECL_REGISTER (decl
) = 0;
6720 DECL_REGISTER (decl
) = 0;
6721 c_mark_addressable (decl
);
6722 C_DECL_REGISTER (decl
) = was_reg
;
6725 /* This is the earliest point at which we might know the assembler
6726 name of a variable. Thus, if it's known before this, die horribly. */
6727 gcc_assert (!DECL_ASSEMBLER_NAME_SET_P (decl
));
6731 && TREE_PUBLIC (decl
)
6732 && TREE_STATIC (decl
)
6733 && (TREE_CODE (TREE_TYPE (decl
)) == RECORD_TYPE
6734 || TREE_CODE (TREE_TYPE (decl
)) == UNION_TYPE
6735 || TREE_CODE (TREE_TYPE (decl
)) == ENUMERAL_TYPE
)
6736 && TYPE_NAME (TREE_TYPE (decl
)) == NULL_TREE
)
6737 warning_at (DECL_SOURCE_LOCATION (decl
), OPT_Wc___compat
,
6738 ("non-local variable %qD with anonymous type is "
6739 "questionable in C++"),
6746 /* Decode the parameter-list info for a function type or function definition.
6747 The argument is the value returned by `get_parm_info' (or made in c-parse.c
6748 if there is an identifier list instead of a parameter decl list).
6749 These two functions are separate because when a function returns
6750 or receives functions then each is called multiple times but the order
6751 of calls is different. The last call to `grokparms' is always the one
6752 that contains the formal parameter names of a function definition.
6754 Return a list of arg types to use in the FUNCTION_TYPE for this function.
6756 FUNCDEF_FLAG is true for a function definition, false for
6757 a mere declaration. A nonempty identifier-list gets an error message
6758 when FUNCDEF_FLAG is false. */
6761 grokparms (struct c_arg_info
*arg_info
, bool funcdef_flag
)
6763 tree arg_types
= arg_info
->types
;
6765 if (funcdef_flag
&& arg_info
->had_vla_unspec
)
6767 /* A function definition isn't function prototype scope C99 6.2.1p4. */
6769 error ("%<[*]%> not allowed in other than function prototype scope");
6772 if (arg_types
== 0 && !funcdef_flag
6773 && !in_system_header_at (input_location
))
6774 warning (OPT_Wstrict_prototypes
,
6775 "function declaration isn%'t a prototype");
6777 if (arg_types
== error_mark_node
)
6778 return 0; /* don't set TYPE_ARG_TYPES in this case */
6780 else if (arg_types
&& TREE_CODE (TREE_VALUE (arg_types
)) == IDENTIFIER_NODE
)
6784 pedwarn (input_location
, 0, "parameter names (without types) in function declaration");
6785 arg_info
->parms
= NULL_TREE
;
6788 arg_info
->parms
= arg_info
->types
;
6790 arg_info
->types
= 0;
6795 tree parm
, type
, typelt
;
6796 unsigned int parmno
;
6799 /* If there is a parameter of incomplete type in a definition,
6800 this is an error. In a declaration this is valid, and a
6801 struct or union type may be completed later, before any calls
6802 or definition of the function. In the case where the tag was
6803 first declared within the parameter list, a warning has
6804 already been given. If a parameter has void type, then
6805 however the function cannot be defined or called, so
6808 for (parm
= arg_info
->parms
, typelt
= arg_types
, parmno
= 1;
6810 parm
= DECL_CHAIN (parm
), typelt
= TREE_CHAIN (typelt
), parmno
++)
6812 type
= TREE_VALUE (typelt
);
6813 if (type
== error_mark_node
)
6816 if (!COMPLETE_TYPE_P (type
))
6820 if (DECL_NAME (parm
))
6821 error_at (input_location
,
6822 "parameter %u (%q+D) has incomplete type",
6825 error_at (DECL_SOURCE_LOCATION (parm
),
6826 "parameter %u has incomplete type",
6829 TREE_VALUE (typelt
) = error_mark_node
;
6830 TREE_TYPE (parm
) = error_mark_node
;
6831 arg_types
= NULL_TREE
;
6833 else if (VOID_TYPE_P (type
))
6835 if (DECL_NAME (parm
))
6836 warning_at (input_location
, 0,
6837 "parameter %u (%q+D) has void type",
6840 warning_at (DECL_SOURCE_LOCATION (parm
), 0,
6841 "parameter %u has void type",
6846 errmsg
= targetm
.invalid_parameter_type (type
);
6850 TREE_VALUE (typelt
) = error_mark_node
;
6851 TREE_TYPE (parm
) = error_mark_node
;
6852 arg_types
= NULL_TREE
;
6855 if (DECL_NAME (parm
) && TREE_USED (parm
))
6856 warn_if_shadowing (parm
);
6862 /* Allocate and initialize a c_arg_info structure from the parser's
6866 build_arg_info (void)
6868 struct c_arg_info
*ret
= XOBNEW (&parser_obstack
, struct c_arg_info
);
6869 ret
->parms
= NULL_TREE
;
6871 ret
->types
= NULL_TREE
;
6872 ret
->others
= NULL_TREE
;
6873 ret
->pending_sizes
= NULL
;
6874 ret
->had_vla_unspec
= 0;
6878 /* Take apart the current scope and return a c_arg_info structure with
6879 info on a parameter list just parsed.
6881 This structure is later fed to 'grokparms' and 'store_parm_decls'.
6883 ELLIPSIS being true means the argument list ended in '...' so don't
6884 append a sentinel (void_list_node) to the end of the type-list.
6886 EXPR is NULL or an expression that needs to be evaluated for the
6887 side effects of array size expressions in the parameters. */
6890 get_parm_info (bool ellipsis
, tree expr
)
6892 struct c_binding
*b
= current_scope
->bindings
;
6893 struct c_arg_info
*arg_info
= build_arg_info ();
6896 vec
<c_arg_tag
, va_gc
> *tags
= NULL
;
6900 static bool explained_incomplete_types
= false;
6901 bool gave_void_only_once_err
= false;
6903 arg_info
->had_vla_unspec
= current_scope
->had_vla_unspec
;
6905 /* The bindings in this scope must not get put into a block.
6906 We will take care of deleting the binding nodes. */
6907 current_scope
->bindings
= 0;
6909 /* This function is only called if there was *something* on the
6913 /* A parameter list consisting solely of 'void' indicates that the
6914 function takes no arguments. But if the 'void' is qualified
6915 (by 'const' or 'volatile'), or has a storage class specifier
6916 ('register'), then the behavior is undefined; issue an error.
6917 Typedefs for 'void' are OK (see DR#157). */
6918 if (b
->prev
== 0 /* one binding */
6919 && TREE_CODE (b
->decl
) == PARM_DECL
/* which is a parameter */
6920 && !DECL_NAME (b
->decl
) /* anonymous */
6921 && VOID_TYPE_P (TREE_TYPE (b
->decl
))) /* of void type */
6923 if (TYPE_QUALS (TREE_TYPE (b
->decl
)) != TYPE_UNQUALIFIED
6924 || C_DECL_REGISTER (b
->decl
))
6925 error ("%<void%> as only parameter may not be qualified");
6927 /* There cannot be an ellipsis. */
6929 error ("%<void%> must be the only parameter");
6931 arg_info
->types
= void_list_node
;
6936 types
= void_list_node
;
6938 /* Break up the bindings list into parms, tags, types, and others;
6939 apply sanity checks; purge the name-to-decl bindings. */
6942 tree decl
= b
->decl
;
6943 tree type
= TREE_TYPE (decl
);
6945 const char *keyword
;
6947 switch (TREE_CODE (decl
))
6952 gcc_assert (I_SYMBOL_BINDING (b
->id
) == b
);
6953 I_SYMBOL_BINDING (b
->id
) = b
->shadowed
;
6956 /* Check for forward decls that never got their actual decl. */
6957 if (TREE_ASM_WRITTEN (decl
))
6958 error ("parameter %q+D has just a forward declaration", decl
);
6959 /* Check for (..., void, ...) and issue an error. */
6960 else if (VOID_TYPE_P (type
) && !DECL_NAME (decl
))
6962 if (!gave_void_only_once_err
)
6964 error ("%<void%> must be the only parameter");
6965 gave_void_only_once_err
= true;
6970 /* Valid parameter, add it to the list. */
6971 DECL_CHAIN (decl
) = parms
;
6974 /* Since there is a prototype, args are passed in their
6975 declared types. The back end may override this later. */
6976 DECL_ARG_TYPE (decl
) = type
;
6977 types
= tree_cons (0, type
, types
);
6981 case ENUMERAL_TYPE
: keyword
= "enum"; goto tag
;
6982 case UNION_TYPE
: keyword
= "union"; goto tag
;
6983 case RECORD_TYPE
: keyword
= "struct"; goto tag
;
6985 /* Types may not have tag-names, in which case the type
6986 appears in the bindings list with b->id NULL. */
6989 gcc_assert (I_TAG_BINDING (b
->id
) == b
);
6990 I_TAG_BINDING (b
->id
) = b
->shadowed
;
6993 /* Warn about any struct, union or enum tags defined in a
6994 parameter list. The scope of such types is limited to
6995 the parameter list, which is rarely if ever desirable
6996 (it's impossible to call such a function with type-
6997 correct arguments). An anonymous union parm type is
6998 meaningful as a GNU extension, so don't warn for that. */
6999 if (TREE_CODE (decl
) != UNION_TYPE
|| b
->id
!= 0)
7002 /* The %s will be one of 'struct', 'union', or 'enum'. */
7003 warning (0, "%<%s %E%> declared inside parameter list",
7006 /* The %s will be one of 'struct', 'union', or 'enum'. */
7007 warning (0, "anonymous %s declared inside parameter list",
7010 if (!explained_incomplete_types
)
7012 warning (0, "its scope is only this definition or declaration,"
7013 " which is probably not what you want");
7014 explained_incomplete_types
= true;
7020 vec_safe_push (tags
, tag
);
7026 /* CONST_DECLs appear here when we have an embedded enum,
7027 and TYPE_DECLs appear here when we have an embedded struct
7028 or union. No warnings for this - we already warned about the
7029 type itself. FUNCTION_DECLs appear when there is an implicit
7030 function declaration in the parameter list. */
7032 /* When we reinsert this decl in the function body, we need
7033 to reconstruct whether it was marked as nested. */
7034 gcc_assert (TREE_CODE (decl
) == FUNCTION_DECL
7037 DECL_CHAIN (decl
) = others
;
7042 /* error_mark_node appears here when we have an undeclared
7043 variable. Just throw it away. */
7046 gcc_assert (I_SYMBOL_BINDING (b
->id
) == b
);
7047 I_SYMBOL_BINDING (b
->id
) = b
->shadowed
;
7051 /* Other things that might be encountered. */
7058 b
= free_binding_and_advance (b
);
7061 arg_info
->parms
= parms
;
7062 arg_info
->tags
= tags
;
7063 arg_info
->types
= types
;
7064 arg_info
->others
= others
;
7065 arg_info
->pending_sizes
= expr
;
7069 /* Get the struct, enum or union (CODE says which) with tag NAME.
7070 Define the tag as a forward-reference with location LOC if it is
7071 not defined. Return a c_typespec structure for the type
7075 parser_xref_tag (location_t loc
, enum tree_code code
, tree name
)
7077 struct c_typespec ret
;
7081 ret
.expr
= NULL_TREE
;
7082 ret
.expr_const_operands
= true;
7084 /* If a cross reference is requested, look up the type
7085 already defined for this tag and return it. */
7087 ref
= lookup_tag (code
, name
, 0, &refloc
);
7088 /* If this is the right type of tag, return what we found.
7089 (This reference will be shadowed by shadow_tag later if appropriate.)
7090 If this is the wrong type of tag, do not return it. If it was the
7091 wrong type in the same scope, we will have had an error
7092 message already; if in a different scope and declaring
7093 a name, pending_xref_error will give an error message; but if in a
7094 different scope and not declaring a name, this tag should
7095 shadow the previous declaration of a different type of tag, and
7096 this would not work properly if we return the reference found.
7097 (For example, with "struct foo" in an outer scope, "union foo;"
7098 must shadow that tag with a new one of union type.) */
7099 ret
.kind
= (ref
? ctsk_tagref
: ctsk_tagfirstref
);
7100 if (ref
&& TREE_CODE (ref
) == code
)
7102 if (C_TYPE_DEFINED_IN_STRUCT (ref
)
7103 && loc
!= UNKNOWN_LOCATION
7109 warning_at (loc
, OPT_Wc___compat
,
7110 ("enum type defined in struct or union "
7111 "is not visible in C++"));
7112 inform (refloc
, "enum type defined here");
7115 warning_at (loc
, OPT_Wc___compat
,
7116 ("struct defined in struct or union "
7117 "is not visible in C++"));
7118 inform (refloc
, "struct defined here");
7121 warning_at (loc
, OPT_Wc___compat
,
7122 ("union defined in struct or union "
7123 "is not visible in C++"));
7124 inform (refloc
, "union defined here");
7135 /* If no such tag is yet defined, create a forward-reference node
7136 and record it as the "definition".
7137 When a real declaration of this type is found,
7138 the forward-reference will be altered into a real type. */
7140 ref
= make_node (code
);
7141 if (code
== ENUMERAL_TYPE
)
7143 /* Give the type a default layout like unsigned int
7144 to avoid crashing if it does not get defined. */
7145 SET_TYPE_MODE (ref
, TYPE_MODE (unsigned_type_node
));
7146 TYPE_ALIGN (ref
) = TYPE_ALIGN (unsigned_type_node
);
7147 TYPE_USER_ALIGN (ref
) = 0;
7148 TYPE_UNSIGNED (ref
) = 1;
7149 TYPE_PRECISION (ref
) = TYPE_PRECISION (unsigned_type_node
);
7150 TYPE_MIN_VALUE (ref
) = TYPE_MIN_VALUE (unsigned_type_node
);
7151 TYPE_MAX_VALUE (ref
) = TYPE_MAX_VALUE (unsigned_type_node
);
7154 pushtag (loc
, name
, ref
);
7160 /* Get the struct, enum or union (CODE says which) with tag NAME.
7161 Define the tag as a forward-reference if it is not defined.
7162 Return a tree for the type. */
7165 xref_tag (enum tree_code code
, tree name
)
7167 return parser_xref_tag (input_location
, code
, name
).spec
;
7170 /* Make sure that the tag NAME is defined *in the current scope*
7171 at least as a forward reference.
7172 LOC is the location of the struct's definition.
7173 CODE says which kind of tag NAME ought to be.
7175 This stores the current value of the file static STRUCT_PARSE_INFO
7176 in *ENCLOSING_STRUCT_PARSE_INFO, and points STRUCT_PARSE_INFO at a
7177 new c_struct_parse_info structure. The old value of
7178 STRUCT_PARSE_INFO is restored in finish_struct. */
7181 start_struct (location_t loc
, enum tree_code code
, tree name
,
7182 struct c_struct_parse_info
**enclosing_struct_parse_info
)
7184 /* If there is already a tag defined at this scope
7185 (as a forward reference), just return it. */
7187 tree ref
= NULL_TREE
;
7188 location_t refloc
= UNKNOWN_LOCATION
;
7190 if (name
!= NULL_TREE
)
7191 ref
= lookup_tag (code
, name
, 1, &refloc
);
7192 if (ref
&& TREE_CODE (ref
) == code
)
7194 if (TYPE_SIZE (ref
))
7196 if (code
== UNION_TYPE
)
7197 error_at (loc
, "redefinition of %<union %E%>", name
);
7199 error_at (loc
, "redefinition of %<struct %E%>", name
);
7200 if (refloc
!= UNKNOWN_LOCATION
)
7201 inform (refloc
, "originally defined here");
7202 /* Don't create structures using a name already in use. */
7205 else if (C_TYPE_BEING_DEFINED (ref
))
7207 if (code
== UNION_TYPE
)
7208 error_at (loc
, "nested redefinition of %<union %E%>", name
);
7210 error_at (loc
, "nested redefinition of %<struct %E%>", name
);
7211 /* Don't bother to report "originally defined here" for a
7212 nested redefinition; the original definition should be
7214 /* Don't create structures that contain themselves. */
7219 /* Otherwise create a forward-reference just so the tag is in scope. */
7221 if (ref
== NULL_TREE
|| TREE_CODE (ref
) != code
)
7223 ref
= make_node (code
);
7224 pushtag (loc
, name
, ref
);
7227 C_TYPE_BEING_DEFINED (ref
) = 1;
7228 TYPE_PACKED (ref
) = flag_pack_struct
;
7230 *enclosing_struct_parse_info
= struct_parse_info
;
7231 struct_parse_info
= XNEW (struct c_struct_parse_info
);
7232 struct_parse_info
->struct_types
.create (0);
7233 struct_parse_info
->fields
.create (0);
7234 struct_parse_info
->typedefs_seen
.create (0);
7236 /* FIXME: This will issue a warning for a use of a type defined
7237 within a statement expr used within sizeof, et. al. This is not
7238 terribly serious as C++ doesn't permit statement exprs within
7240 if (warn_cxx_compat
&& (in_sizeof
|| in_typeof
|| in_alignof
))
7241 warning_at (loc
, OPT_Wc___compat
,
7242 "defining type in %qs expression is invalid in C++",
7245 : (in_typeof
? "typeof" : "alignof")));
7250 /* Process the specs, declarator and width (NULL if omitted)
7251 of a structure component, returning a FIELD_DECL node.
7252 WIDTH is non-NULL for bit-fields only, and is an INTEGER_CST node.
7253 DECL_ATTRS is as for grokdeclarator.
7255 LOC is the location of the structure component.
7257 This is done during the parsing of the struct declaration.
7258 The FIELD_DECL nodes are chained together and the lot of them
7259 are ultimately passed to `build_struct' to make the RECORD_TYPE node. */
7262 grokfield (location_t loc
,
7263 struct c_declarator
*declarator
, struct c_declspecs
*declspecs
,
7264 tree width
, tree
*decl_attrs
)
7268 if (declarator
->kind
== cdk_id
&& declarator
->u
.id
== NULL_TREE
7269 && width
== NULL_TREE
)
7271 /* This is an unnamed decl.
7273 If we have something of the form "union { list } ;" then this
7274 is the anonymous union extension. Similarly for struct.
7276 If this is something of the form "struct foo;", then
7277 If MS or Plan 9 extensions are enabled, this is handled as
7278 an anonymous struct.
7279 Otherwise this is a forward declaration of a structure tag.
7281 If this is something of the form "foo;" and foo is a TYPE_DECL, then
7282 If foo names a structure or union without a tag, then this
7283 is an anonymous struct (this is permitted by C11).
7284 If MS or Plan 9 extensions are enabled and foo names a
7285 structure, then again this is an anonymous struct.
7286 Otherwise this is an error.
7288 Oh what a horrid tangled web we weave. I wonder if MS consciously
7289 took this from Plan 9 or if it was an accident of implementation
7290 that took root before someone noticed the bug... */
7292 tree type
= declspecs
->type
;
7293 bool type_ok
= (TREE_CODE (type
) == RECORD_TYPE
7294 || TREE_CODE (type
) == UNION_TYPE
);
7298 && (flag_ms_extensions
7299 || flag_plan9_extensions
7300 || !declspecs
->typedef_p
))
7302 if (flag_ms_extensions
|| flag_plan9_extensions
)
7304 else if (TYPE_NAME (type
) == NULL
)
7311 pedwarn (loc
, 0, "declaration does not declare anything");
7315 pedwarn_c99 (loc
, OPT_Wpedantic
,
7316 "ISO C99 doesn%'t support unnamed structs/unions");
7318 pedwarn_c99 (loc
, OPT_Wpedantic
,
7319 "ISO C90 doesn%'t support unnamed structs/unions");
7322 value
= grokdeclarator (declarator
, declspecs
, FIELD
, false,
7323 width
? &width
: NULL
, decl_attrs
, NULL
, NULL
,
7326 finish_decl (value
, loc
, NULL_TREE
, NULL_TREE
, NULL_TREE
);
7327 DECL_INITIAL (value
) = width
;
7329 if (warn_cxx_compat
&& DECL_NAME (value
) != NULL_TREE
)
7331 /* If we currently have a binding for this field, set the
7332 in_struct field in the binding, so that we warn about lookups
7334 struct c_binding
*b
= I_SYMBOL_BINDING (DECL_NAME (value
));
7337 /* If the in_struct field is not yet set, push it on a list
7338 to be cleared when this struct is finished. */
7341 struct_parse_info
->fields
.safe_push (b
);
7350 /* Subroutine of detect_field_duplicates: return whether X and Y,
7351 which are both fields in the same struct, have duplicate field
7355 is_duplicate_field (tree x
, tree y
)
7357 if (DECL_NAME (x
) != NULL_TREE
&& DECL_NAME (x
) == DECL_NAME (y
))
7360 /* When using -fplan9-extensions, an anonymous field whose name is a
7361 typedef can duplicate a field name. */
7362 if (flag_plan9_extensions
7363 && (DECL_NAME (x
) == NULL_TREE
|| DECL_NAME (y
) == NULL_TREE
))
7365 tree xt
, xn
, yt
, yn
;
7368 if (DECL_NAME (x
) != NULL_TREE
)
7370 else if ((TREE_CODE (xt
) == RECORD_TYPE
|| TREE_CODE (xt
) == UNION_TYPE
)
7371 && TYPE_NAME (xt
) != NULL_TREE
7372 && TREE_CODE (TYPE_NAME (xt
)) == TYPE_DECL
)
7373 xn
= DECL_NAME (TYPE_NAME (xt
));
7378 if (DECL_NAME (y
) != NULL_TREE
)
7380 else if ((TREE_CODE (yt
) == RECORD_TYPE
|| TREE_CODE (yt
) == UNION_TYPE
)
7381 && TYPE_NAME (yt
) != NULL_TREE
7382 && TREE_CODE (TYPE_NAME (yt
)) == TYPE_DECL
)
7383 yn
= DECL_NAME (TYPE_NAME (yt
));
7387 if (xn
!= NULL_TREE
&& xn
== yn
)
7394 /* Subroutine of detect_field_duplicates: add the fields of FIELDLIST
7395 to HTAB, giving errors for any duplicates. */
7398 detect_field_duplicates_hash (tree fieldlist
,
7399 hash_table
<nofree_ptr_hash
<tree_node
> > *htab
)
7404 for (x
= fieldlist
; x
; x
= DECL_CHAIN (x
))
7405 if ((y
= DECL_NAME (x
)) != 0)
7407 slot
= htab
->find_slot (y
, INSERT
);
7410 error ("duplicate member %q+D", x
);
7411 DECL_NAME (x
) = NULL_TREE
;
7415 else if (TREE_CODE (TREE_TYPE (x
)) == RECORD_TYPE
7416 || TREE_CODE (TREE_TYPE (x
)) == UNION_TYPE
)
7418 detect_field_duplicates_hash (TYPE_FIELDS (TREE_TYPE (x
)), htab
);
7420 /* When using -fplan9-extensions, an anonymous field whose
7421 name is a typedef can duplicate a field name. */
7422 if (flag_plan9_extensions
7423 && TYPE_NAME (TREE_TYPE (x
)) != NULL_TREE
7424 && TREE_CODE (TYPE_NAME (TREE_TYPE (x
))) == TYPE_DECL
)
7426 tree xn
= DECL_NAME (TYPE_NAME (TREE_TYPE (x
)));
7427 slot
= htab
->find_slot (xn
, INSERT
);
7429 error ("duplicate member %q+D", TYPE_NAME (TREE_TYPE (x
)));
7435 /* Generate an error for any duplicate field names in FIELDLIST. Munge
7436 the list such that this does not present a problem later. */
7439 detect_field_duplicates (tree fieldlist
)
7444 /* If the struct is the list of instance variables of an Objective-C
7445 class, then we need to check all the instance variables of
7446 superclasses when checking for duplicates (since you can't have
7447 an instance variable in a subclass with the same name as an
7448 instance variable in a superclass). We pass on this job to the
7449 Objective-C compiler. objc_detect_field_duplicates() will return
7450 false if we are not checking the list of instance variables and
7451 the C frontend should proceed with the standard field duplicate
7452 checks. If we are checking the list of instance variables, the
7453 ObjC frontend will do the check, emit the errors if needed, and
7454 then return true. */
7455 if (c_dialect_objc ())
7456 if (objc_detect_field_duplicates (false))
7459 /* First, see if there are more than "a few" fields.
7460 This is trivially true if there are zero or one fields. */
7461 if (!fieldlist
|| !DECL_CHAIN (fieldlist
))
7466 if (DECL_NAME (x
) == NULL_TREE
7467 && (TREE_CODE (TREE_TYPE (x
)) == RECORD_TYPE
7468 || TREE_CODE (TREE_TYPE (x
)) == UNION_TYPE
))
7471 } while (timeout
> 0 && x
);
7473 /* If there were "few" fields and no anonymous structures or unions,
7474 avoid the overhead of allocating a hash table. Instead just do
7475 the nested traversal thing. */
7478 for (x
= DECL_CHAIN (fieldlist
); x
; x
= DECL_CHAIN (x
))
7479 /* When using -fplan9-extensions, we can have duplicates
7480 between typedef names and fields. */
7482 || (flag_plan9_extensions
7483 && DECL_NAME (x
) == NULL_TREE
7484 && (TREE_CODE (TREE_TYPE (x
)) == RECORD_TYPE
7485 || TREE_CODE (TREE_TYPE (x
)) == UNION_TYPE
)
7486 && TYPE_NAME (TREE_TYPE (x
)) != NULL_TREE
7487 && TREE_CODE (TYPE_NAME (TREE_TYPE (x
))) == TYPE_DECL
))
7489 for (y
= fieldlist
; y
!= x
; y
= TREE_CHAIN (y
))
7490 if (is_duplicate_field (y
, x
))
7492 error ("duplicate member %q+D", x
);
7493 DECL_NAME (x
) = NULL_TREE
;
7499 hash_table
<nofree_ptr_hash
<tree_node
> > htab (37);
7500 detect_field_duplicates_hash (fieldlist
, &htab
);
7504 /* Finish up struct info used by -Wc++-compat. */
7507 warn_cxx_compat_finish_struct (tree fieldlist
, enum tree_code code
,
7508 location_t record_loc
)
7512 struct c_binding
*b
;
7514 if (fieldlist
== NULL_TREE
)
7516 if (code
== RECORD_TYPE
)
7517 warning_at (record_loc
, OPT_Wc___compat
,
7518 "empty struct has size 0 in C, size 1 in C++");
7520 warning_at (record_loc
, OPT_Wc___compat
,
7521 "empty union has size 0 in C, size 1 in C++");
7524 /* Set the C_TYPE_DEFINED_IN_STRUCT flag for each type defined in
7525 the current struct. We do this now at the end of the struct
7526 because the flag is used to issue visibility warnings, and we
7527 only want to issue those warnings if the type is referenced
7528 outside of the struct declaration. */
7529 FOR_EACH_VEC_ELT (struct_parse_info
->struct_types
, ix
, x
)
7530 C_TYPE_DEFINED_IN_STRUCT (x
) = 1;
7532 /* The TYPEDEFS_SEEN field of STRUCT_PARSE_INFO is a list of
7533 typedefs used when declaring fields in this struct. If the name
7534 of any of the fields is also a typedef name then the struct would
7535 not parse in C++, because the C++ lookup rules say that the
7536 typedef name would be looked up in the context of the struct, and
7537 would thus be the field rather than the typedef. */
7538 if (!struct_parse_info
->typedefs_seen
.is_empty ()
7539 && fieldlist
!= NULL_TREE
)
7541 /* Use a hash_set<tree> using the name of the typedef. We can use
7542 a hash_set<tree> because identifiers are interned. */
7543 hash_set
<tree
> tset
;
7545 FOR_EACH_VEC_ELT (struct_parse_info
->typedefs_seen
, ix
, x
)
7546 tset
.add (DECL_NAME (x
));
7548 for (x
= fieldlist
; x
!= NULL_TREE
; x
= DECL_CHAIN (x
))
7550 if (DECL_NAME (x
) != NULL_TREE
7551 && tset
.contains (DECL_NAME (x
)))
7553 warning_at (DECL_SOURCE_LOCATION (x
), OPT_Wc___compat
,
7554 ("using %qD as both field and typedef name is "
7557 /* FIXME: It would be nice to report the location where
7558 the typedef name is used. */
7563 /* For each field which has a binding and which was not defined in
7564 an enclosing struct, clear the in_struct field. */
7565 FOR_EACH_VEC_ELT (struct_parse_info
->fields
, ix
, b
)
7569 /* Fill in the fields of a RECORD_TYPE or UNION_TYPE node, T.
7570 LOC is the location of the RECORD_TYPE or UNION_TYPE's definition.
7571 FIELDLIST is a chain of FIELD_DECL nodes for the fields.
7572 ATTRIBUTES are attributes to be applied to the structure.
7574 ENCLOSING_STRUCT_PARSE_INFO is the value of STRUCT_PARSE_INFO when
7575 the struct was started. */
7578 finish_struct (location_t loc
, tree t
, tree fieldlist
, tree attributes
,
7579 struct c_struct_parse_info
*enclosing_struct_parse_info
)
7582 bool toplevel
= file_scope
== current_scope
;
7583 int saw_named_field
;
7585 /* If this type was previously laid out as a forward reference,
7586 make sure we lay it out again. */
7590 decl_attributes (&t
, attributes
, (int) ATTR_FLAG_TYPE_IN_PLACE
);
7594 for (x
= fieldlist
; x
; x
= DECL_CHAIN (x
))
7596 if (DECL_NAME (x
) != 0)
7599 && (TREE_CODE (TREE_TYPE (x
)) == RECORD_TYPE
7600 || TREE_CODE (TREE_TYPE (x
)) == UNION_TYPE
))
7606 if (TREE_CODE (t
) == UNION_TYPE
)
7609 pedwarn (loc
, OPT_Wpedantic
, "union has no named members");
7611 pedwarn (loc
, OPT_Wpedantic
, "union has no members");
7616 pedwarn (loc
, OPT_Wpedantic
, "struct has no named members");
7618 pedwarn (loc
, OPT_Wpedantic
, "struct has no members");
7623 /* Install struct as DECL_CONTEXT of each field decl.
7624 Also process specified field sizes, found in the DECL_INITIAL,
7625 storing 0 there after the type has been changed to precision equal
7626 to its width, rather than the precision of the specified standard
7627 type. (Correct layout requires the original type to have been preserved
7630 saw_named_field
= 0;
7631 for (x
= fieldlist
; x
; x
= DECL_CHAIN (x
))
7633 if (TREE_TYPE (x
) == error_mark_node
)
7636 DECL_CONTEXT (x
) = t
;
7638 /* If any field is const, the structure type is pseudo-const. */
7639 if (TREE_READONLY (x
))
7640 C_TYPE_FIELDS_READONLY (t
) = 1;
7643 /* A field that is pseudo-const makes the structure likewise. */
7644 tree t1
= strip_array_types (TREE_TYPE (x
));
7645 if ((TREE_CODE (t1
) == RECORD_TYPE
|| TREE_CODE (t1
) == UNION_TYPE
)
7646 && C_TYPE_FIELDS_READONLY (t1
))
7647 C_TYPE_FIELDS_READONLY (t
) = 1;
7650 /* Any field that is volatile means variables of this type must be
7651 treated in some ways as volatile. */
7652 if (TREE_THIS_VOLATILE (x
))
7653 C_TYPE_FIELDS_VOLATILE (t
) = 1;
7655 /* Any field of nominal variable size implies structure is too. */
7656 if (C_DECL_VARIABLE_SIZE (x
))
7657 C_TYPE_VARIABLE_SIZE (t
) = 1;
7659 if (DECL_INITIAL (x
))
7661 unsigned HOST_WIDE_INT width
= tree_to_uhwi (DECL_INITIAL (x
));
7662 DECL_SIZE (x
) = bitsize_int (width
);
7663 DECL_BIT_FIELD (x
) = 1;
7664 SET_DECL_C_BIT_FIELD (x
);
7668 && (DECL_BIT_FIELD (x
)
7669 || TYPE_ALIGN (TREE_TYPE (x
)) > BITS_PER_UNIT
))
7670 DECL_PACKED (x
) = 1;
7672 /* Detect flexible array member in an invalid context. */
7673 if (TREE_CODE (TREE_TYPE (x
)) == ARRAY_TYPE
7674 && TYPE_SIZE (TREE_TYPE (x
)) == NULL_TREE
7675 && TYPE_DOMAIN (TREE_TYPE (x
)) != NULL_TREE
7676 && TYPE_MAX_VALUE (TYPE_DOMAIN (TREE_TYPE (x
))) == NULL_TREE
)
7678 if (TREE_CODE (t
) == UNION_TYPE
)
7680 error_at (DECL_SOURCE_LOCATION (x
),
7681 "flexible array member in union");
7682 TREE_TYPE (x
) = error_mark_node
;
7684 else if (DECL_CHAIN (x
) != NULL_TREE
)
7686 error_at (DECL_SOURCE_LOCATION (x
),
7687 "flexible array member not at end of struct");
7688 TREE_TYPE (x
) = error_mark_node
;
7690 else if (!saw_named_field
)
7692 error_at (DECL_SOURCE_LOCATION (x
),
7693 "flexible array member in otherwise empty struct");
7694 TREE_TYPE (x
) = error_mark_node
;
7698 if (pedantic
&& TREE_CODE (t
) == RECORD_TYPE
7699 && flexible_array_type_p (TREE_TYPE (x
)))
7700 pedwarn (DECL_SOURCE_LOCATION (x
), OPT_Wpedantic
,
7701 "invalid use of structure with flexible array member");
7704 || TREE_CODE (TREE_TYPE (x
)) == RECORD_TYPE
7705 || TREE_CODE (TREE_TYPE (x
)) == UNION_TYPE
)
7706 saw_named_field
= 1;
7709 detect_field_duplicates (fieldlist
);
7711 /* Now we have the nearly final fieldlist. Record it,
7712 then lay out the structure or union (including the fields). */
7714 TYPE_FIELDS (t
) = fieldlist
;
7718 if (TYPE_SIZE_UNIT (t
)
7719 && TREE_CODE (TYPE_SIZE_UNIT (t
)) == INTEGER_CST
7720 && !TREE_OVERFLOW (TYPE_SIZE_UNIT (t
))
7721 && !valid_constant_size_p (TYPE_SIZE_UNIT (t
)))
7722 error ("type %qT is too large", t
);
7724 /* Give bit-fields their proper types. */
7726 tree
*fieldlistp
= &fieldlist
;
7728 if (TREE_CODE (*fieldlistp
) == FIELD_DECL
&& DECL_INITIAL (*fieldlistp
)
7729 && TREE_TYPE (*fieldlistp
) != error_mark_node
)
7731 unsigned HOST_WIDE_INT width
7732 = tree_to_uhwi (DECL_INITIAL (*fieldlistp
));
7733 tree type
= TREE_TYPE (*fieldlistp
);
7734 if (width
!= TYPE_PRECISION (type
))
7736 TREE_TYPE (*fieldlistp
)
7737 = c_build_bitfield_integer_type (width
, TYPE_UNSIGNED (type
));
7738 DECL_MODE (*fieldlistp
) = TYPE_MODE (TREE_TYPE (*fieldlistp
));
7740 DECL_INITIAL (*fieldlistp
) = 0;
7743 fieldlistp
= &DECL_CHAIN (*fieldlistp
);
7746 /* Now we have the truly final field list.
7747 Store it in this type and in the variants. */
7749 TYPE_FIELDS (t
) = fieldlist
;
7751 /* If there are lots of fields, sort so we can look through them fast.
7752 We arbitrarily consider 16 or more elts to be "a lot". */
7757 for (x
= fieldlist
; x
; x
= DECL_CHAIN (x
))
7759 if (len
> 15 || DECL_NAME (x
) == NULL
)
7767 struct lang_type
*space
;
7768 struct sorted_fields_type
*space2
;
7770 len
+= list_length (x
);
7772 /* Use the same allocation policy here that make_node uses, to
7773 ensure that this lives as long as the rest of the struct decl.
7774 All decls in an inline function need to be saved. */
7776 space
= ggc_cleared_alloc
<struct lang_type
> ();
7777 space2
= (sorted_fields_type
*) ggc_internal_alloc
7778 (sizeof (struct sorted_fields_type
) + len
* sizeof (tree
));
7782 field_array
= &space2
->elts
[0];
7783 for (x
= fieldlist
; x
; x
= DECL_CHAIN (x
))
7785 field_array
[len
++] = x
;
7787 /* If there is anonymous struct or union, break out of the loop. */
7788 if (DECL_NAME (x
) == NULL
)
7791 /* Found no anonymous struct/union. Add the TYPE_LANG_SPECIFIC. */
7794 TYPE_LANG_SPECIFIC (t
) = space
;
7795 TYPE_LANG_SPECIFIC (t
)->s
->len
= len
;
7796 field_array
= TYPE_LANG_SPECIFIC (t
)->s
->elts
;
7797 qsort (field_array
, len
, sizeof (tree
), field_decl_cmp
);
7802 for (x
= TYPE_MAIN_VARIANT (t
); x
; x
= TYPE_NEXT_VARIANT (x
))
7804 TYPE_FIELDS (x
) = TYPE_FIELDS (t
);
7805 TYPE_LANG_SPECIFIC (x
) = TYPE_LANG_SPECIFIC (t
);
7806 C_TYPE_FIELDS_READONLY (x
) = C_TYPE_FIELDS_READONLY (t
);
7807 C_TYPE_FIELDS_VOLATILE (x
) = C_TYPE_FIELDS_VOLATILE (t
);
7808 C_TYPE_VARIABLE_SIZE (x
) = C_TYPE_VARIABLE_SIZE (t
);
7811 /* If this was supposed to be a transparent union, but we can't
7812 make it one, warn and turn off the flag. */
7813 if (TREE_CODE (t
) == UNION_TYPE
7814 && TYPE_TRANSPARENT_AGGR (t
)
7815 && (!TYPE_FIELDS (t
) || TYPE_MODE (t
) != DECL_MODE (TYPE_FIELDS (t
))))
7817 TYPE_TRANSPARENT_AGGR (t
) = 0;
7818 warning_at (loc
, 0, "union cannot be made transparent");
7821 /* If this structure or union completes the type of any previous
7822 variable declaration, lay it out and output its rtl.
7824 Note: C_TYPE_INCOMPLETE_VARS overloads TYPE_VFIELD which is used
7825 in dwarf2out via rest_of_decl_compilation below and means
7826 something totally different. Since we will be clearing
7827 C_TYPE_INCOMPLETE_VARS shortly after we iterate through them,
7828 clear it ahead of time and avoid problems in dwarf2out. Ideally,
7829 C_TYPE_INCOMPLETE_VARS should use some language specific
7831 tree incomplete_vars
= C_TYPE_INCOMPLETE_VARS (TYPE_MAIN_VARIANT (t
));
7832 C_TYPE_INCOMPLETE_VARS (TYPE_MAIN_VARIANT (t
)) = 0;
7833 for (x
= incomplete_vars
; x
; x
= TREE_CHAIN (x
))
7835 tree decl
= TREE_VALUE (x
);
7836 if (TREE_CODE (TREE_TYPE (decl
)) == ARRAY_TYPE
)
7837 layout_array_type (TREE_TYPE (decl
));
7838 if (TREE_CODE (decl
) != TYPE_DECL
)
7840 layout_decl (decl
, 0);
7841 if (c_dialect_objc ())
7842 objc_check_decl (decl
);
7843 rest_of_decl_compilation (decl
, toplevel
, 0);
7847 /* Update type location to the one of the definition, instead of e.g.
7848 a forward declaration. */
7849 if (TYPE_STUB_DECL (t
))
7850 DECL_SOURCE_LOCATION (TYPE_STUB_DECL (t
)) = loc
;
7852 /* Finish debugging output for this type. */
7853 rest_of_type_compilation (t
, toplevel
);
7855 /* If we're inside a function proper, i.e. not file-scope and not still
7856 parsing parameters, then arrange for the size of a variable sized type
7858 if (building_stmt_list_p () && variably_modified_type_p (t
, NULL_TREE
))
7859 add_stmt (build_stmt (loc
,
7860 DECL_EXPR
, build_decl (loc
, TYPE_DECL
, NULL
, t
)));
7862 if (warn_cxx_compat
)
7863 warn_cxx_compat_finish_struct (fieldlist
, TREE_CODE (t
), loc
);
7865 struct_parse_info
->struct_types
.release ();
7866 struct_parse_info
->fields
.release ();
7867 struct_parse_info
->typedefs_seen
.release ();
7868 XDELETE (struct_parse_info
);
7870 struct_parse_info
= enclosing_struct_parse_info
;
7872 /* If this struct is defined inside a struct, add it to
7875 && struct_parse_info
!= NULL
7876 && !in_sizeof
&& !in_typeof
&& !in_alignof
)
7877 struct_parse_info
->struct_types
.safe_push (t
);
7882 /* Lay out the type T, and its element type, and so on. */
7885 layout_array_type (tree t
)
7887 if (TREE_CODE (TREE_TYPE (t
)) == ARRAY_TYPE
)
7888 layout_array_type (TREE_TYPE (t
));
7892 /* Begin compiling the definition of an enumeration type.
7893 NAME is its name (or null if anonymous).
7894 LOC is the enum's location.
7895 Returns the type object, as yet incomplete.
7896 Also records info about it so that build_enumerator
7897 may be used to declare the individual values as they are read. */
7900 start_enum (location_t loc
, struct c_enum_contents
*the_enum
, tree name
)
7902 tree enumtype
= NULL_TREE
;
7903 location_t enumloc
= UNKNOWN_LOCATION
;
7905 /* If this is the real definition for a previous forward reference,
7906 fill in the contents in the same object that used to be the
7907 forward reference. */
7909 if (name
!= NULL_TREE
)
7910 enumtype
= lookup_tag (ENUMERAL_TYPE
, name
, 1, &enumloc
);
7912 if (enumtype
== 0 || TREE_CODE (enumtype
) != ENUMERAL_TYPE
)
7914 enumtype
= make_node (ENUMERAL_TYPE
);
7915 pushtag (loc
, name
, enumtype
);
7918 if (C_TYPE_BEING_DEFINED (enumtype
))
7919 error_at (loc
, "nested redefinition of %<enum %E%>", name
);
7921 C_TYPE_BEING_DEFINED (enumtype
) = 1;
7923 if (TYPE_VALUES (enumtype
) != 0)
7925 /* This enum is a named one that has been declared already. */
7926 error_at (loc
, "redeclaration of %<enum %E%>", name
);
7927 if (enumloc
!= UNKNOWN_LOCATION
)
7928 inform (enumloc
, "originally defined here");
7930 /* Completely replace its old definition.
7931 The old enumerators remain defined, however. */
7932 TYPE_VALUES (enumtype
) = 0;
7935 the_enum
->enum_next_value
= integer_zero_node
;
7936 the_enum
->enum_overflow
= 0;
7938 if (flag_short_enums
)
7939 for (tree v
= TYPE_MAIN_VARIANT (enumtype
); v
; v
= TYPE_NEXT_VARIANT (v
))
7940 TYPE_PACKED (v
) = 1;
7942 /* FIXME: This will issue a warning for a use of a type defined
7943 within sizeof in a statement expr. This is not terribly serious
7944 as C++ doesn't permit statement exprs within sizeof anyhow. */
7945 if (warn_cxx_compat
&& (in_sizeof
|| in_typeof
|| in_alignof
))
7946 warning_at (loc
, OPT_Wc___compat
,
7947 "defining type in %qs expression is invalid in C++",
7950 : (in_typeof
? "typeof" : "alignof")));
7955 /* After processing and defining all the values of an enumeration type,
7956 install their decls in the enumeration type and finish it off.
7957 ENUMTYPE is the type object, VALUES a list of decl-value pairs,
7958 and ATTRIBUTES are the specified attributes.
7959 Returns ENUMTYPE. */
7962 finish_enum (tree enumtype
, tree values
, tree attributes
)
7965 tree minnode
= 0, maxnode
= 0;
7968 bool toplevel
= (file_scope
== current_scope
);
7969 struct lang_type
*lt
;
7971 decl_attributes (&enumtype
, attributes
, (int) ATTR_FLAG_TYPE_IN_PLACE
);
7973 /* Calculate the maximum value of any enumerator in this type. */
7975 if (values
== error_mark_node
)
7976 minnode
= maxnode
= integer_zero_node
;
7979 minnode
= maxnode
= TREE_VALUE (values
);
7980 for (pair
= TREE_CHAIN (values
); pair
; pair
= TREE_CHAIN (pair
))
7982 tree value
= TREE_VALUE (pair
);
7983 if (tree_int_cst_lt (maxnode
, value
))
7985 if (tree_int_cst_lt (value
, minnode
))
7990 /* Construct the final type of this enumeration. It is the same
7991 as one of the integral types - the narrowest one that fits, except
7992 that normally we only go as narrow as int - and signed iff any of
7993 the values are negative. */
7994 sign
= (tree_int_cst_sgn (minnode
) >= 0) ? UNSIGNED
: SIGNED
;
7995 precision
= MAX (tree_int_cst_min_precision (minnode
, sign
),
7996 tree_int_cst_min_precision (maxnode
, sign
));
7998 if (TYPE_PACKED (enumtype
) || precision
> TYPE_PRECISION (integer_type_node
))
8000 tem
= c_common_type_for_size (precision
, sign
== UNSIGNED
? 1 : 0);
8003 warning (0, "enumeration values exceed range of largest integer");
8004 tem
= long_long_integer_type_node
;
8008 tem
= sign
== UNSIGNED
? unsigned_type_node
: integer_type_node
;
8010 TYPE_MIN_VALUE (enumtype
) = TYPE_MIN_VALUE (tem
);
8011 TYPE_MAX_VALUE (enumtype
) = TYPE_MAX_VALUE (tem
);
8012 TYPE_UNSIGNED (enumtype
) = TYPE_UNSIGNED (tem
);
8013 TYPE_ALIGN (enumtype
) = TYPE_ALIGN (tem
);
8014 TYPE_SIZE (enumtype
) = 0;
8016 /* If the precision of the type was specified with an attribute and it
8017 was too small, give an error. Otherwise, use it. */
8018 if (TYPE_PRECISION (enumtype
)
8019 && lookup_attribute ("mode", attributes
))
8021 if (precision
> TYPE_PRECISION (enumtype
))
8022 error ("specified mode too small for enumeral values");
8025 TYPE_PRECISION (enumtype
) = TYPE_PRECISION (tem
);
8027 layout_type (enumtype
);
8029 if (values
!= error_mark_node
)
8031 /* Change the type of the enumerators to be the enum type. We
8032 need to do this irrespective of the size of the enum, for
8033 proper type checking. Replace the DECL_INITIALs of the
8034 enumerators, and the value slots of the list, with copies
8035 that have the enum type; they cannot be modified in place
8036 because they may be shared (e.g. integer_zero_node) Finally,
8037 change the purpose slots to point to the names of the decls. */
8038 for (pair
= values
; pair
; pair
= TREE_CHAIN (pair
))
8040 tree enu
= TREE_PURPOSE (pair
);
8041 tree ini
= DECL_INITIAL (enu
);
8043 TREE_TYPE (enu
) = enumtype
;
8045 /* The ISO C Standard mandates enumerators to have type int,
8046 even though the underlying type of an enum type is
8047 unspecified. However, GCC allows enumerators of any
8048 integer type as an extensions. build_enumerator()
8049 converts any enumerators that fit in an int to type int,
8050 to avoid promotions to unsigned types when comparing
8051 integers with enumerators that fit in the int range.
8052 When -pedantic is given, build_enumerator() would have
8053 already warned about those that don't fit. Here we
8054 convert the rest to the enumerator type. */
8055 if (TREE_TYPE (ini
) != integer_type_node
)
8056 ini
= convert (enumtype
, ini
);
8058 DECL_INITIAL (enu
) = ini
;
8059 TREE_PURPOSE (pair
) = DECL_NAME (enu
);
8060 TREE_VALUE (pair
) = ini
;
8063 TYPE_VALUES (enumtype
) = values
;
8066 /* Record the min/max values so that we can warn about bit-field
8067 enumerations that are too small for the values. */
8068 lt
= ggc_cleared_alloc
<struct lang_type
> ();
8069 lt
->enum_min
= minnode
;
8070 lt
->enum_max
= maxnode
;
8071 TYPE_LANG_SPECIFIC (enumtype
) = lt
;
8073 /* Fix up all variant types of this enum type. */
8074 for (tem
= TYPE_MAIN_VARIANT (enumtype
); tem
; tem
= TYPE_NEXT_VARIANT (tem
))
8076 if (tem
== enumtype
)
8078 TYPE_VALUES (tem
) = TYPE_VALUES (enumtype
);
8079 TYPE_MIN_VALUE (tem
) = TYPE_MIN_VALUE (enumtype
);
8080 TYPE_MAX_VALUE (tem
) = TYPE_MAX_VALUE (enumtype
);
8081 TYPE_SIZE (tem
) = TYPE_SIZE (enumtype
);
8082 TYPE_SIZE_UNIT (tem
) = TYPE_SIZE_UNIT (enumtype
);
8083 SET_TYPE_MODE (tem
, TYPE_MODE (enumtype
));
8084 TYPE_PRECISION (tem
) = TYPE_PRECISION (enumtype
);
8085 TYPE_ALIGN (tem
) = TYPE_ALIGN (enumtype
);
8086 TYPE_USER_ALIGN (tem
) = TYPE_USER_ALIGN (enumtype
);
8087 TYPE_UNSIGNED (tem
) = TYPE_UNSIGNED (enumtype
);
8088 TYPE_LANG_SPECIFIC (tem
) = TYPE_LANG_SPECIFIC (enumtype
);
8091 /* Finish debugging output for this type. */
8092 rest_of_type_compilation (enumtype
, toplevel
);
8094 /* If this enum is defined inside a struct, add it to
8097 && struct_parse_info
!= NULL
8098 && !in_sizeof
&& !in_typeof
&& !in_alignof
)
8099 struct_parse_info
->struct_types
.safe_push (enumtype
);
8104 /* Build and install a CONST_DECL for one value of the
8105 current enumeration type (one that was begun with start_enum).
8106 DECL_LOC is the location of the enumerator.
8107 LOC is the location of the '=' operator if any, DECL_LOC otherwise.
8108 Return a tree-list containing the CONST_DECL and its value.
8109 Assignment of sequential values by default is handled here. */
8112 build_enumerator (location_t decl_loc
, location_t loc
,
8113 struct c_enum_contents
*the_enum
, tree name
, tree value
)
8117 /* Validate and default VALUE. */
8121 /* Don't issue more errors for error_mark_node (i.e. an
8122 undeclared identifier) - just ignore the value expression. */
8123 if (value
== error_mark_node
)
8125 else if (!INTEGRAL_TYPE_P (TREE_TYPE (value
)))
8127 error_at (loc
, "enumerator value for %qE is not an integer constant",
8133 if (TREE_CODE (value
) != INTEGER_CST
)
8135 value
= c_fully_fold (value
, false, NULL
);
8136 if (TREE_CODE (value
) == INTEGER_CST
)
8137 pedwarn (loc
, OPT_Wpedantic
,
8138 "enumerator value for %qE is not an integer "
8139 "constant expression", name
);
8141 if (TREE_CODE (value
) != INTEGER_CST
)
8143 error ("enumerator value for %qE is not an integer constant",
8149 value
= default_conversion (value
);
8150 constant_expression_warning (value
);
8155 /* Default based on previous value. */
8156 /* It should no longer be possible to have NON_LVALUE_EXPR
8160 value
= the_enum
->enum_next_value
;
8161 if (the_enum
->enum_overflow
)
8162 error_at (loc
, "overflow in enumeration values");
8164 /* Even though the underlying type of an enum is unspecified, the
8165 type of enumeration constants is explicitly defined as int
8166 (6.4.4.3/2 in the C99 Standard). GCC allows any integer type as
8168 else if (!int_fits_type_p (value
, integer_type_node
))
8169 pedwarn (loc
, OPT_Wpedantic
,
8170 "ISO C restricts enumerator values to range of %<int%>");
8172 /* The ISO C Standard mandates enumerators to have type int, even
8173 though the underlying type of an enum type is unspecified.
8174 However, GCC allows enumerators of any integer type as an
8175 extensions. Here we convert any enumerators that fit in an int
8176 to type int, to avoid promotions to unsigned types when comparing
8177 integers with enumerators that fit in the int range. When
8178 -pedantic is given, we would have already warned about those that
8179 don't fit. We have to do this here rather than in finish_enum
8180 because this value may be used to define more enumerators. */
8181 if (int_fits_type_p (value
, integer_type_node
))
8182 value
= convert (integer_type_node
, value
);
8184 /* Set basis for default for next value. */
8185 the_enum
->enum_next_value
8186 = build_binary_op (EXPR_LOC_OR_LOC (value
, input_location
),
8187 PLUS_EXPR
, value
, integer_one_node
, 0);
8188 the_enum
->enum_overflow
= tree_int_cst_lt (the_enum
->enum_next_value
, value
);
8190 /* Now create a declaration for the enum value name. */
8192 type
= TREE_TYPE (value
);
8193 type
= c_common_type_for_size (MAX (TYPE_PRECISION (type
),
8194 TYPE_PRECISION (integer_type_node
)),
8195 (TYPE_PRECISION (type
)
8196 >= TYPE_PRECISION (integer_type_node
)
8197 && TYPE_UNSIGNED (type
)));
8199 decl
= build_decl (decl_loc
, CONST_DECL
, name
, type
);
8200 DECL_INITIAL (decl
) = convert (type
, value
);
8203 return tree_cons (decl
, value
, NULL_TREE
);
8207 /* Create the FUNCTION_DECL for a function definition.
8208 DECLSPECS, DECLARATOR and ATTRIBUTES are the parts of
8209 the declaration; they describe the function's name and the type it returns,
8210 but twisted together in a fashion that parallels the syntax of C.
8212 This function creates a binding context for the function body
8213 as well as setting up the FUNCTION_DECL in current_function_decl.
8215 Returns 1 on success. If the DECLARATOR is not suitable for a function
8216 (it defines a datum instead), we return 0, which tells
8217 yyparse to report a parse error. */
8220 start_function (struct c_declspecs
*declspecs
, struct c_declarator
*declarator
,
8223 tree decl1
, old_decl
;
8224 tree restype
, resdecl
;
8227 current_function_returns_value
= 0; /* Assume, until we see it does. */
8228 current_function_returns_null
= 0;
8229 current_function_returns_abnormally
= 0;
8230 warn_about_return_type
= 0;
8231 c_switch_stack
= NULL
;
8233 /* Indicate no valid break/continue context by setting these variables
8234 to some non-null, non-label value. We'll notice and emit the proper
8235 error message in c_finish_bc_stmt. */
8236 c_break_label
= c_cont_label
= size_zero_node
;
8238 decl1
= grokdeclarator (declarator
, declspecs
, FUNCDEF
, true, NULL
,
8239 &attributes
, NULL
, NULL
, DEPRECATED_NORMAL
);
8240 invoke_plugin_callbacks (PLUGIN_START_PARSE_FUNCTION
, decl1
);
8242 /* If the declarator is not suitable for a function definition,
8243 cause a syntax error. */
8245 || TREE_CODE (decl1
) != FUNCTION_DECL
)
8248 loc
= DECL_SOURCE_LOCATION (decl1
);
8250 c_decl_attributes (&decl1
, attributes
, 0);
8252 if (DECL_DECLARED_INLINE_P (decl1
)
8253 && DECL_UNINLINABLE (decl1
)
8254 && lookup_attribute ("noinline", DECL_ATTRIBUTES (decl1
)))
8255 warning_at (loc
, OPT_Wattributes
,
8256 "inline function %qD given attribute noinline",
8259 /* Handle gnu_inline attribute. */
8260 if (declspecs
->inline_p
8261 && !flag_gnu89_inline
8262 && TREE_CODE (decl1
) == FUNCTION_DECL
8263 && (lookup_attribute ("gnu_inline", DECL_ATTRIBUTES (decl1
))
8264 || current_function_decl
))
8266 if (declspecs
->storage_class
!= csc_static
)
8267 DECL_EXTERNAL (decl1
) = !DECL_EXTERNAL (decl1
);
8270 announce_function (decl1
);
8272 if (!COMPLETE_OR_VOID_TYPE_P (TREE_TYPE (TREE_TYPE (decl1
))))
8274 error_at (loc
, "return type is an incomplete type");
8275 /* Make it return void instead. */
8277 = build_function_type (void_type_node
,
8278 TYPE_ARG_TYPES (TREE_TYPE (decl1
)));
8281 if (warn_about_return_type
)
8282 warn_defaults_to (loc
, flag_isoc99
? OPT_Wimplicit_int
8283 : (warn_return_type
? OPT_Wreturn_type
8284 : OPT_Wimplicit_int
),
8285 "return type defaults to %<int%>");
8287 /* Make the init_value nonzero so pushdecl knows this is not tentative.
8288 error_mark_node is replaced below (in pop_scope) with the BLOCK. */
8289 DECL_INITIAL (decl1
) = error_mark_node
;
8291 /* A nested function is not global. */
8292 if (current_function_decl
!= 0)
8293 TREE_PUBLIC (decl1
) = 0;
8295 /* If this definition isn't a prototype and we had a prototype declaration
8296 before, copy the arg type info from that prototype. */
8297 old_decl
= lookup_name_in_scope (DECL_NAME (decl1
), current_scope
);
8298 if (old_decl
&& TREE_CODE (old_decl
) != FUNCTION_DECL
)
8300 current_function_prototype_locus
= UNKNOWN_LOCATION
;
8301 current_function_prototype_built_in
= false;
8302 current_function_prototype_arg_types
= NULL_TREE
;
8303 if (!prototype_p (TREE_TYPE (decl1
)))
8305 if (old_decl
!= 0 && TREE_CODE (TREE_TYPE (old_decl
)) == FUNCTION_TYPE
8306 && comptypes (TREE_TYPE (TREE_TYPE (decl1
)),
8307 TREE_TYPE (TREE_TYPE (old_decl
))))
8309 TREE_TYPE (decl1
) = composite_type (TREE_TYPE (old_decl
),
8311 current_function_prototype_locus
= DECL_SOURCE_LOCATION (old_decl
);
8312 current_function_prototype_built_in
8313 = C_DECL_BUILTIN_PROTOTYPE (old_decl
);
8314 current_function_prototype_arg_types
8315 = TYPE_ARG_TYPES (TREE_TYPE (decl1
));
8317 if (TREE_PUBLIC (decl1
))
8319 /* If there is an external prototype declaration of this
8320 function, record its location but do not copy information
8321 to this decl. This may be an invisible declaration
8322 (built-in or in a scope which has finished) or simply
8323 have more refined argument types than any declaration
8325 struct c_binding
*b
;
8326 for (b
= I_SYMBOL_BINDING (DECL_NAME (decl1
)); b
; b
= b
->shadowed
)
8327 if (B_IN_SCOPE (b
, external_scope
))
8331 tree ext_decl
, ext_type
;
8333 ext_type
= b
->u
.type
? b
->u
.type
: TREE_TYPE (ext_decl
);
8334 if (TREE_CODE (ext_type
) == FUNCTION_TYPE
8335 && comptypes (TREE_TYPE (TREE_TYPE (decl1
)),
8336 TREE_TYPE (ext_type
)))
8338 current_function_prototype_locus
8339 = DECL_SOURCE_LOCATION (ext_decl
);
8340 current_function_prototype_built_in
8341 = C_DECL_BUILTIN_PROTOTYPE (ext_decl
);
8342 current_function_prototype_arg_types
8343 = TYPE_ARG_TYPES (ext_type
);
8349 /* Optionally warn of old-fashioned def with no previous prototype. */
8350 if (warn_strict_prototypes
8351 && old_decl
!= error_mark_node
8352 && !prototype_p (TREE_TYPE (decl1
))
8353 && C_DECL_ISNT_PROTOTYPE (old_decl
))
8354 warning_at (loc
, OPT_Wstrict_prototypes
,
8355 "function declaration isn%'t a prototype");
8356 /* Optionally warn of any global def with no previous prototype. */
8357 else if (warn_missing_prototypes
8358 && old_decl
!= error_mark_node
8359 && TREE_PUBLIC (decl1
)
8360 && !MAIN_NAME_P (DECL_NAME (decl1
))
8361 && C_DECL_ISNT_PROTOTYPE (old_decl
)
8362 && !DECL_DECLARED_INLINE_P (decl1
))
8363 warning_at (loc
, OPT_Wmissing_prototypes
,
8364 "no previous prototype for %qD", decl1
);
8365 /* Optionally warn of any def with no previous prototype
8366 if the function has already been used. */
8367 else if (warn_missing_prototypes
8369 && old_decl
!= error_mark_node
8370 && TREE_USED (old_decl
)
8371 && !prototype_p (TREE_TYPE (old_decl
)))
8372 warning_at (loc
, OPT_Wmissing_prototypes
,
8373 "%qD was used with no prototype before its definition", decl1
);
8374 /* Optionally warn of any global def with no previous declaration. */
8375 else if (warn_missing_declarations
8376 && TREE_PUBLIC (decl1
)
8378 && !MAIN_NAME_P (DECL_NAME (decl1
))
8379 && !DECL_DECLARED_INLINE_P (decl1
))
8380 warning_at (loc
, OPT_Wmissing_declarations
,
8381 "no previous declaration for %qD",
8383 /* Optionally warn of any def with no previous declaration
8384 if the function has already been used. */
8385 else if (warn_missing_declarations
8387 && old_decl
!= error_mark_node
8388 && TREE_USED (old_decl
)
8389 && C_DECL_IMPLICIT (old_decl
))
8390 warning_at (loc
, OPT_Wmissing_declarations
,
8391 "%qD was used with no declaration before its definition", decl1
);
8393 /* This function exists in static storage.
8394 (This does not mean `static' in the C sense!) */
8395 TREE_STATIC (decl1
) = 1;
8397 /* This is the earliest point at which we might know the assembler
8398 name of the function. Thus, if it's set before this, die horribly. */
8399 gcc_assert (!DECL_ASSEMBLER_NAME_SET_P (decl1
));
8401 /* If #pragma weak was used, mark the decl weak now. */
8402 if (current_scope
== file_scope
)
8403 maybe_apply_pragma_weak (decl1
);
8405 /* Warn for unlikely, improbable, or stupid declarations of `main'. */
8406 if (warn_main
&& MAIN_NAME_P (DECL_NAME (decl1
)))
8408 if (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (decl1
)))
8409 != integer_type_node
)
8410 pedwarn (loc
, OPT_Wmain
, "return type of %qD is not %<int%>", decl1
);
8411 else if (TYPE_ATOMIC (TREE_TYPE (TREE_TYPE (decl1
))))
8412 pedwarn (loc
, OPT_Wmain
, "%<_Atomic%>-qualified return type of %qD",
8415 check_main_parameter_types (decl1
);
8417 if (!TREE_PUBLIC (decl1
))
8418 pedwarn (loc
, OPT_Wmain
,
8419 "%qD is normally a non-static function", decl1
);
8422 /* Record the decl so that the function name is defined.
8423 If we already have a decl for this name, and it is a FUNCTION_DECL,
8424 use the old decl. */
8426 current_function_decl
= pushdecl (decl1
);
8429 declare_parm_level ();
8431 restype
= TREE_TYPE (TREE_TYPE (current_function_decl
));
8432 resdecl
= build_decl (loc
, RESULT_DECL
, NULL_TREE
, restype
);
8433 DECL_ARTIFICIAL (resdecl
) = 1;
8434 DECL_IGNORED_P (resdecl
) = 1;
8435 DECL_RESULT (current_function_decl
) = resdecl
;
8437 start_fname_decls ();
8442 /* Subroutine of store_parm_decls which handles new-style function
8443 definitions (prototype format). The parms already have decls, so we
8444 need only record them as in effect and complain if any redundant
8445 old-style parm decls were written. */
8447 store_parm_decls_newstyle (tree fndecl
, const struct c_arg_info
*arg_info
)
8453 if (current_scope
->bindings
)
8455 error_at (DECL_SOURCE_LOCATION (fndecl
),
8456 "old-style parameter declarations in prototyped "
8457 "function definition");
8459 /* Get rid of the old-style declarations. */
8463 /* Don't issue this warning for nested functions, and don't issue this
8464 warning if we got here because ARG_INFO_TYPES was error_mark_node
8465 (this happens when a function definition has just an ellipsis in
8466 its parameter list). */
8467 else if (!in_system_header_at (input_location
)
8468 && !current_function_scope
8469 && arg_info
->types
!= error_mark_node
)
8470 warning_at (DECL_SOURCE_LOCATION (fndecl
), OPT_Wtraditional
,
8471 "traditional C rejects ISO C style function definitions");
8473 /* Now make all the parameter declarations visible in the function body.
8474 We can bypass most of the grunt work of pushdecl. */
8475 for (decl
= arg_info
->parms
; decl
; decl
= DECL_CHAIN (decl
))
8477 DECL_CONTEXT (decl
) = current_function_decl
;
8478 if (DECL_NAME (decl
))
8480 bind (DECL_NAME (decl
), decl
, current_scope
,
8481 /*invisible=*/false, /*nested=*/false,
8483 if (!TREE_USED (decl
))
8484 warn_if_shadowing (decl
);
8487 error_at (DECL_SOURCE_LOCATION (decl
), "parameter name omitted");
8490 /* Record the parameter list in the function declaration. */
8491 DECL_ARGUMENTS (fndecl
) = arg_info
->parms
;
8493 /* Now make all the ancillary declarations visible, likewise. */
8494 for (decl
= arg_info
->others
; decl
; decl
= DECL_CHAIN (decl
))
8496 DECL_CONTEXT (decl
) = current_function_decl
;
8497 if (DECL_NAME (decl
))
8498 bind (DECL_NAME (decl
), decl
, current_scope
,
8499 /*invisible=*/false,
8500 /*nested=*/(TREE_CODE (decl
) == FUNCTION_DECL
),
8504 /* And all the tag declarations. */
8505 FOR_EACH_VEC_SAFE_ELT_REVERSE (arg_info
->tags
, ix
, tag
)
8507 bind (tag
->id
, tag
->type
, current_scope
,
8508 /*invisible=*/false, /*nested=*/false, UNKNOWN_LOCATION
);
8511 /* Subroutine of store_parm_decls which handles old-style function
8512 definitions (separate parameter list and declarations). */
8515 store_parm_decls_oldstyle (tree fndecl
, const struct c_arg_info
*arg_info
)
8517 struct c_binding
*b
;
8518 tree parm
, decl
, last
;
8519 tree parmids
= arg_info
->parms
;
8520 hash_set
<tree
> seen_args
;
8522 if (!in_system_header_at (input_location
))
8523 warning_at (DECL_SOURCE_LOCATION (fndecl
),
8524 OPT_Wold_style_definition
, "old-style function definition");
8526 /* Match each formal parameter name with its declaration. Save each
8527 decl in the appropriate TREE_PURPOSE slot of the parmids chain. */
8528 for (parm
= parmids
; parm
; parm
= TREE_CHAIN (parm
))
8530 if (TREE_VALUE (parm
) == 0)
8532 error_at (DECL_SOURCE_LOCATION (fndecl
),
8533 "parameter name missing from parameter list");
8534 TREE_PURPOSE (parm
) = 0;
8538 b
= I_SYMBOL_BINDING (TREE_VALUE (parm
));
8539 if (b
&& B_IN_CURRENT_SCOPE (b
))
8542 /* Skip erroneous parameters. */
8543 if (decl
== error_mark_node
)
8545 /* If we got something other than a PARM_DECL it is an error. */
8546 if (TREE_CODE (decl
) != PARM_DECL
)
8547 error_at (DECL_SOURCE_LOCATION (decl
),
8548 "%qD declared as a non-parameter", decl
);
8549 /* If the declaration is already marked, we have a duplicate
8550 name. Complain and ignore the duplicate. */
8551 else if (seen_args
.contains (decl
))
8553 error_at (DECL_SOURCE_LOCATION (decl
),
8554 "multiple parameters named %qD", decl
);
8555 TREE_PURPOSE (parm
) = 0;
8558 /* If the declaration says "void", complain and turn it into
8560 else if (VOID_TYPE_P (TREE_TYPE (decl
)))
8562 error_at (DECL_SOURCE_LOCATION (decl
),
8563 "parameter %qD declared with void type", decl
);
8564 TREE_TYPE (decl
) = integer_type_node
;
8565 DECL_ARG_TYPE (decl
) = integer_type_node
;
8566 layout_decl (decl
, 0);
8568 warn_if_shadowing (decl
);
8570 /* If no declaration found, default to int. */
8573 /* FIXME diagnostics: This should be the location of the argument,
8574 not the FNDECL. E.g., for an old-style declaration
8576 int f10(v) { blah; }
8578 We should use the location of the V, not the F10.
8579 Unfortunately, the V is an IDENTIFIER_NODE which has no
8580 location. In the future we need locations for c_arg_info
8583 See gcc.dg/Wshadow-3.c for an example of this problem. */
8584 decl
= build_decl (DECL_SOURCE_LOCATION (fndecl
),
8585 PARM_DECL
, TREE_VALUE (parm
), integer_type_node
);
8586 DECL_ARG_TYPE (decl
) = TREE_TYPE (decl
);
8588 warn_if_shadowing (decl
);
8591 pedwarn (DECL_SOURCE_LOCATION (decl
),
8592 OPT_Wimplicit_int
, "type of %qD defaults to %<int%>",
8595 warning_at (DECL_SOURCE_LOCATION (decl
),
8596 OPT_Wmissing_parameter_type
,
8597 "type of %qD defaults to %<int%>", decl
);
8600 TREE_PURPOSE (parm
) = decl
;
8601 seen_args
.add (decl
);
8604 /* Now examine the parms chain for incomplete declarations
8605 and declarations with no corresponding names. */
8607 for (b
= current_scope
->bindings
; b
; b
= b
->prev
)
8610 if (TREE_CODE (parm
) != PARM_DECL
)
8613 if (TREE_TYPE (parm
) != error_mark_node
8614 && !COMPLETE_TYPE_P (TREE_TYPE (parm
)))
8616 error_at (DECL_SOURCE_LOCATION (parm
),
8617 "parameter %qD has incomplete type", parm
);
8618 TREE_TYPE (parm
) = error_mark_node
;
8621 if (!seen_args
.contains (parm
))
8623 error_at (DECL_SOURCE_LOCATION (parm
),
8624 "declaration for parameter %qD but no such parameter",
8627 /* Pretend the parameter was not missing.
8628 This gets us to a standard state and minimizes
8629 further error messages. */
8630 parmids
= chainon (parmids
, tree_cons (parm
, 0, 0));
8634 /* Chain the declarations together in the order of the list of
8635 names. Store that chain in the function decl, replacing the
8636 list of names. Update the current scope to match. */
8637 DECL_ARGUMENTS (fndecl
) = 0;
8639 for (parm
= parmids
; parm
; parm
= TREE_CHAIN (parm
))
8640 if (TREE_PURPOSE (parm
))
8642 if (parm
&& TREE_PURPOSE (parm
))
8644 last
= TREE_PURPOSE (parm
);
8645 DECL_ARGUMENTS (fndecl
) = last
;
8647 for (parm
= TREE_CHAIN (parm
); parm
; parm
= TREE_CHAIN (parm
))
8648 if (TREE_PURPOSE (parm
))
8650 DECL_CHAIN (last
) = TREE_PURPOSE (parm
);
8651 last
= TREE_PURPOSE (parm
);
8653 DECL_CHAIN (last
) = 0;
8656 /* If there was a previous prototype,
8657 set the DECL_ARG_TYPE of each argument according to
8658 the type previously specified, and report any mismatches. */
8660 if (current_function_prototype_arg_types
)
8663 for (parm
= DECL_ARGUMENTS (fndecl
),
8664 type
= current_function_prototype_arg_types
;
8665 parm
|| (type
&& TREE_VALUE (type
) != error_mark_node
8666 && (TYPE_MAIN_VARIANT (TREE_VALUE (type
)) != void_type_node
));
8667 parm
= DECL_CHAIN (parm
), type
= TREE_CHAIN (type
))
8669 if (parm
== 0 || type
== 0
8670 || TYPE_MAIN_VARIANT (TREE_VALUE (type
)) == void_type_node
)
8672 if (current_function_prototype_built_in
)
8673 warning_at (DECL_SOURCE_LOCATION (fndecl
),
8674 0, "number of arguments doesn%'t match "
8675 "built-in prototype");
8678 /* FIXME diagnostics: This should be the location of
8679 FNDECL, but there is bug when a prototype is
8680 declared inside function context, but defined
8681 outside of it (e.g., gcc.dg/pr15698-2.c). In
8682 which case FNDECL gets the location of the
8683 prototype, not the definition. */
8684 error_at (input_location
,
8685 "number of arguments doesn%'t match prototype");
8687 error_at (current_function_prototype_locus
,
8688 "prototype declaration");
8692 /* Type for passing arg must be consistent with that
8693 declared for the arg. ISO C says we take the unqualified
8694 type for parameters declared with qualified type. */
8695 if (TREE_TYPE (parm
) != error_mark_node
8696 && TREE_TYPE (type
) != error_mark_node
8697 && ((TYPE_ATOMIC (DECL_ARG_TYPE (parm
))
8698 != TYPE_ATOMIC (TREE_VALUE (type
)))
8699 || !comptypes (TYPE_MAIN_VARIANT (DECL_ARG_TYPE (parm
)),
8700 TYPE_MAIN_VARIANT (TREE_VALUE (type
)))))
8702 if ((TYPE_ATOMIC (DECL_ARG_TYPE (parm
))
8703 == TYPE_ATOMIC (TREE_VALUE (type
)))
8704 && (TYPE_MAIN_VARIANT (TREE_TYPE (parm
))
8705 == TYPE_MAIN_VARIANT (TREE_VALUE (type
))))
8707 /* Adjust argument to match prototype. E.g. a previous
8708 `int foo(float);' prototype causes
8709 `int foo(x) float x; {...}' to be treated like
8710 `int foo(float x) {...}'. This is particularly
8711 useful for argument types like uid_t. */
8712 DECL_ARG_TYPE (parm
) = TREE_TYPE (parm
);
8714 if (targetm
.calls
.promote_prototypes (TREE_TYPE (current_function_decl
))
8715 && INTEGRAL_TYPE_P (TREE_TYPE (parm
))
8716 && TYPE_PRECISION (TREE_TYPE (parm
))
8717 < TYPE_PRECISION (integer_type_node
))
8718 DECL_ARG_TYPE (parm
)
8719 = c_type_promotes_to (TREE_TYPE (parm
));
8721 /* ??? Is it possible to get here with a
8722 built-in prototype or will it always have
8723 been diagnosed as conflicting with an
8724 old-style definition and discarded? */
8725 if (current_function_prototype_built_in
)
8726 warning_at (DECL_SOURCE_LOCATION (parm
),
8727 OPT_Wpedantic
, "promoted argument %qD "
8728 "doesn%'t match built-in prototype", parm
);
8731 pedwarn (DECL_SOURCE_LOCATION (parm
),
8732 OPT_Wpedantic
, "promoted argument %qD "
8733 "doesn%'t match prototype", parm
);
8734 pedwarn (current_function_prototype_locus
, OPT_Wpedantic
,
8735 "prototype declaration");
8740 if (current_function_prototype_built_in
)
8741 warning_at (DECL_SOURCE_LOCATION (parm
),
8742 0, "argument %qD doesn%'t match "
8743 "built-in prototype", parm
);
8746 error_at (DECL_SOURCE_LOCATION (parm
),
8747 "argument %qD doesn%'t match prototype", parm
);
8748 error_at (current_function_prototype_locus
,
8749 "prototype declaration");
8754 TYPE_ACTUAL_ARG_TYPES (TREE_TYPE (fndecl
)) = 0;
8757 /* Otherwise, create a prototype that would match. */
8761 tree actual
= 0, last
= 0, type
;
8763 for (parm
= DECL_ARGUMENTS (fndecl
); parm
; parm
= DECL_CHAIN (parm
))
8765 type
= tree_cons (NULL_TREE
, DECL_ARG_TYPE (parm
), NULL_TREE
);
8767 TREE_CHAIN (last
) = type
;
8772 type
= tree_cons (NULL_TREE
, void_type_node
, NULL_TREE
);
8774 TREE_CHAIN (last
) = type
;
8778 /* We are going to assign a new value for the TYPE_ACTUAL_ARG_TYPES
8779 of the type of this function, but we need to avoid having this
8780 affect the types of other similarly-typed functions, so we must
8781 first force the generation of an identical (but separate) type
8782 node for the relevant function type. The new node we create
8783 will be a variant of the main variant of the original function
8786 TREE_TYPE (fndecl
) = build_variant_type_copy (TREE_TYPE (fndecl
));
8788 TYPE_ACTUAL_ARG_TYPES (TREE_TYPE (fndecl
)) = actual
;
8792 /* Store parameter declarations passed in ARG_INFO into the current
8793 function declaration. */
8796 store_parm_decls_from (struct c_arg_info
*arg_info
)
8798 current_function_arg_info
= arg_info
;
8799 store_parm_decls ();
8802 /* Called by walk_tree to look for and update context-less labels. */
8805 set_labels_context_r (tree
*tp
, int *walk_subtrees
, void *data
)
8807 if (TREE_CODE (*tp
) == LABEL_EXPR
8808 && DECL_CONTEXT (LABEL_EXPR_LABEL (*tp
)) == NULL_TREE
)
8810 DECL_CONTEXT (LABEL_EXPR_LABEL (*tp
)) = static_cast<tree
>(data
);
8817 /* Store the parameter declarations into the current function declaration.
8818 This is called after parsing the parameter declarations, before
8819 digesting the body of the function.
8821 For an old-style definition, construct a prototype out of the old-style
8822 parameter declarations and inject it into the function's type. */
8825 store_parm_decls (void)
8827 tree fndecl
= current_function_decl
;
8830 /* The argument information block for FNDECL. */
8831 struct c_arg_info
*arg_info
= current_function_arg_info
;
8832 current_function_arg_info
= 0;
8834 /* True if this definition is written with a prototype. Note:
8835 despite C99 6.7.5.3p14, we can *not* treat an empty argument
8836 list in a function definition as equivalent to (void) -- an
8837 empty argument list specifies the function has no parameters,
8838 but only (void) sets up a prototype for future calls. */
8839 proto
= arg_info
->types
!= 0;
8842 store_parm_decls_newstyle (fndecl
, arg_info
);
8844 store_parm_decls_oldstyle (fndecl
, arg_info
);
8846 /* The next call to push_scope will be a function body. */
8848 next_is_function_body
= true;
8850 /* Write a record describing this function definition to the prototypes
8851 file (if requested). */
8853 gen_aux_info_record (fndecl
, 1, 0, proto
);
8855 /* Initialize the RTL code for the function. */
8856 allocate_struct_function (fndecl
, false);
8858 if (warn_unused_local_typedefs
)
8859 cfun
->language
= ggc_cleared_alloc
<language_function
> ();
8861 /* Begin the statement tree for this function. */
8862 DECL_SAVED_TREE (fndecl
) = push_stmt_list ();
8864 /* ??? Insert the contents of the pending sizes list into the function
8865 to be evaluated. The only reason left to have this is
8866 void foo(int n, int array[n++])
8867 because we throw away the array type in favor of a pointer type, and
8868 thus won't naturally see the SAVE_EXPR containing the increment. All
8869 other pending sizes would be handled by gimplify_parameters. */
8870 if (arg_info
->pending_sizes
)
8872 /* In very special circumstances, e.g. for code like
8874 void f (int a[i += 2]) {}
8875 we need to execute the atomic assignment on function entry.
8876 But in this case, it is not just a straight store, it has the
8877 op= form, which means that build_atomic_assign has generated
8878 gotos, labels, etc. Because at that time the function decl
8879 for F has not been created yet, those labels do not have any
8880 function context. But we have the fndecl now, so update the
8881 labels accordingly. gimplify_expr would crash otherwise. */
8882 walk_tree_without_duplicates (&arg_info
->pending_sizes
,
8883 set_labels_context_r
, fndecl
);
8884 add_stmt (arg_info
->pending_sizes
);
8888 /* Store PARM_DECLs in PARMS into scope temporarily. Used for
8889 c_finish_omp_declare_simd for function prototypes. No diagnostics
8893 temp_store_parm_decls (tree fndecl
, tree parms
)
8896 for (tree p
= parms
; p
; p
= DECL_CHAIN (p
))
8898 DECL_CONTEXT (p
) = fndecl
;
8900 bind (DECL_NAME (p
), p
, current_scope
,
8901 /*invisible=*/false, /*nested=*/false,
8906 /* Undo what temp_store_parm_decls did. */
8909 temp_pop_parm_decls (void)
8911 /* Clear all bindings in this temporary scope, so that
8912 pop_scope doesn't create a BLOCK. */
8913 struct c_binding
*b
= current_scope
->bindings
;
8914 current_scope
->bindings
= NULL
;
8915 for (; b
; b
= free_binding_and_advance (b
))
8917 gcc_assert (TREE_CODE (b
->decl
) == PARM_DECL
);
8918 gcc_assert (I_SYMBOL_BINDING (b
->id
) == b
);
8919 I_SYMBOL_BINDING (b
->id
) = b
->shadowed
;
8920 if (b
->shadowed
&& b
->shadowed
->u
.type
)
8921 TREE_TYPE (b
->shadowed
->decl
) = b
->shadowed
->u
.type
;
8927 /* Finish up a function declaration and compile that function
8928 all the way to assembler language output. Then free the storage
8929 for the function definition.
8931 This is called after parsing the body of the function definition. */
8934 finish_function (void)
8936 tree fndecl
= current_function_decl
;
8938 if (c_dialect_objc ())
8939 objc_finish_function ();
8941 if (TREE_CODE (fndecl
) == FUNCTION_DECL
8942 && targetm
.calls
.promote_prototypes (TREE_TYPE (fndecl
)))
8944 tree args
= DECL_ARGUMENTS (fndecl
);
8945 for (; args
; args
= DECL_CHAIN (args
))
8947 tree type
= TREE_TYPE (args
);
8948 if (INTEGRAL_TYPE_P (type
)
8949 && TYPE_PRECISION (type
) < TYPE_PRECISION (integer_type_node
))
8950 DECL_ARG_TYPE (args
) = c_type_promotes_to (type
);
8954 if (DECL_INITIAL (fndecl
) && DECL_INITIAL (fndecl
) != error_mark_node
)
8955 BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl
)) = fndecl
;
8957 /* Must mark the RESULT_DECL as being in this function. */
8959 if (DECL_RESULT (fndecl
) && DECL_RESULT (fndecl
) != error_mark_node
)
8960 DECL_CONTEXT (DECL_RESULT (fndecl
)) = fndecl
;
8962 if (MAIN_NAME_P (DECL_NAME (fndecl
)) && flag_hosted
8963 && TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (fndecl
)))
8964 == integer_type_node
&& flag_isoc99
)
8966 /* Hack. We don't want the middle-end to warn that this return
8967 is unreachable, so we mark its location as special. Using
8968 UNKNOWN_LOCATION has the problem that it gets clobbered in
8969 annotate_one_with_locus. A cleaner solution might be to
8970 ensure ! should_carry_locus_p (stmt), but that needs a flag.
8972 c_finish_return (BUILTINS_LOCATION
, integer_zero_node
, NULL_TREE
);
8975 /* Tie off the statement tree for this function. */
8976 DECL_SAVED_TREE (fndecl
) = pop_stmt_list (DECL_SAVED_TREE (fndecl
));
8978 /* If the function has _Cilk_spawn in front of a function call inside it
8979 i.e. it is a spawning function, then add the appropriate Cilk plus
8980 functions inside. */
8981 if (fn_contains_cilk_spawn_p (cfun
))
8982 cfun
->cilk_frame_decl
= insert_cilk_frame (fndecl
);
8984 finish_fname_decls ();
8986 /* Complain if there's just no return statement. */
8987 if (warn_return_type
8988 && TREE_CODE (TREE_TYPE (TREE_TYPE (fndecl
))) != VOID_TYPE
8989 && !current_function_returns_value
&& !current_function_returns_null
8990 /* Don't complain if we are no-return. */
8991 && !current_function_returns_abnormally
8992 /* Don't complain if we are declared noreturn. */
8993 && !TREE_THIS_VOLATILE (fndecl
)
8994 /* Don't warn for main(). */
8995 && !MAIN_NAME_P (DECL_NAME (fndecl
))
8996 /* Or if they didn't actually specify a return type. */
8997 && !C_FUNCTION_IMPLICIT_INT (fndecl
)
8998 /* Normally, with -Wreturn-type, flow will complain, but we might
8999 optimize out static functions. */
9000 && !TREE_PUBLIC (fndecl
))
9002 warning (OPT_Wreturn_type
,
9003 "no return statement in function returning non-void");
9004 TREE_NO_WARNING (fndecl
) = 1;
9007 /* Complain about parameters that are only set, but never otherwise used. */
9008 if (warn_unused_but_set_parameter
)
9012 for (decl
= DECL_ARGUMENTS (fndecl
);
9014 decl
= DECL_CHAIN (decl
))
9015 if (TREE_USED (decl
)
9016 && TREE_CODE (decl
) == PARM_DECL
9017 && !DECL_READ_P (decl
)
9019 && !DECL_ARTIFICIAL (decl
)
9020 && !TREE_NO_WARNING (decl
))
9021 warning_at (DECL_SOURCE_LOCATION (decl
),
9022 OPT_Wunused_but_set_parameter
,
9023 "parameter %qD set but not used", decl
);
9026 /* Complain about locally defined typedefs that are not used in this
9028 maybe_warn_unused_local_typedefs ();
9030 /* Possibly warn about unused parameters. */
9031 if (warn_unused_parameter
)
9032 do_warn_unused_parameter (fndecl
);
9034 /* Store the end of the function, so that we get good line number
9035 info for the epilogue. */
9036 cfun
->function_end_locus
= input_location
;
9038 /* Finalize the ELF visibility for the function. */
9039 c_determine_visibility (fndecl
);
9041 /* For GNU C extern inline functions disregard inline limits. */
9042 if (DECL_EXTERNAL (fndecl
)
9043 && DECL_DECLARED_INLINE_P (fndecl
))
9044 DECL_DISREGARD_INLINE_LIMITS (fndecl
) = 1;
9046 /* Genericize before inlining. Delay genericizing nested functions
9047 until their parent function is genericized. Since finalizing
9048 requires GENERIC, delay that as well. */
9050 if (DECL_INITIAL (fndecl
) && DECL_INITIAL (fndecl
) != error_mark_node
9051 && !undef_nested_function
)
9053 if (!decl_function_context (fndecl
))
9055 invoke_plugin_callbacks (PLUGIN_PRE_GENERICIZE
, fndecl
);
9056 c_genericize (fndecl
);
9058 /* ??? Objc emits functions after finalizing the compilation unit.
9059 This should be cleaned up later and this conditional removed. */
9060 if (symtab
->global_info_ready
)
9062 cgraph_node::add_new_function (fndecl
, false);
9065 cgraph_node::finalize_function (fndecl
, false);
9069 /* Register this function with cgraph just far enough to get it
9070 added to our parent's nested function list. Handy, since the
9071 C front end doesn't have such a list. */
9072 (void) cgraph_node::get_create (fndecl
);
9076 if (!decl_function_context (fndecl
))
9077 undef_nested_function
= false;
9079 if (cfun
->language
!= NULL
)
9081 ggc_free (cfun
->language
);
9082 cfun
->language
= NULL
;
9085 /* We're leaving the context of this function, so zap cfun.
9086 It's still in DECL_STRUCT_FUNCTION, and we'll restore it in
9087 tree_rest_of_compilation. */
9089 invoke_plugin_callbacks (PLUGIN_FINISH_PARSE_FUNCTION
, current_function_decl
);
9090 current_function_decl
= NULL
;
9093 /* Check the declarations given in a for-loop for satisfying the C99
9094 constraints. If exactly one such decl is found, return it. LOC is
9095 the location of the opening parenthesis of the for loop. The last
9096 parameter allows you to control the "for loop initial declarations
9097 are only allowed in C99 mode". Normally, you should pass
9098 flag_isoc99 as that parameter. But in some cases (Objective-C
9099 foreach loop, for example) we want to run the checks in this
9100 function even if not in C99 mode, so we allow the caller to turn
9101 off the error about not being in C99 mode.
9105 check_for_loop_decls (location_t loc
, bool turn_off_iso_c99_error
)
9107 struct c_binding
*b
;
9108 tree one_decl
= NULL_TREE
;
9111 if (!turn_off_iso_c99_error
)
9113 static bool hint
= true;
9114 /* If we get here, declarations have been used in a for loop without
9115 the C99 for loop scope. This doesn't make much sense, so don't
9117 error_at (loc
, "%<for%> loop initial declarations "
9118 "are only allowed in C99 or C11 mode");
9122 "use option -std=c99, -std=gnu99, -std=c11 or -std=gnu11 "
9123 "to compile your code");
9128 /* C99 subclause 6.8.5 paragraph 3:
9130 [#3] The declaration part of a for statement shall only
9131 declare identifiers for objects having storage class auto or
9134 It isn't clear whether, in this sentence, "identifiers" binds to
9135 "shall only declare" or to "objects" - that is, whether all identifiers
9136 declared must be identifiers for objects, or whether the restriction
9137 only applies to those that are. (A question on this in comp.std.c
9138 in November 2000 received no answer.) We implement the strictest
9139 interpretation, to avoid creating an extension which later causes
9142 for (b
= current_scope
->bindings
; b
; b
= b
->prev
)
9145 tree decl
= b
->decl
;
9150 switch (TREE_CODE (decl
))
9154 location_t decl_loc
= DECL_SOURCE_LOCATION (decl
);
9155 if (TREE_STATIC (decl
))
9157 "declaration of static variable %qD in %<for%> loop "
9158 "initial declaration", decl
);
9159 else if (DECL_EXTERNAL (decl
))
9161 "declaration of %<extern%> variable %qD in %<for%> loop "
9162 "initial declaration", decl
);
9168 "%<struct %E%> declared in %<for%> loop initial "
9173 "%<union %E%> declared in %<for%> loop initial declaration",
9177 error_at (loc
, "%<enum %E%> declared in %<for%> loop "
9178 "initial declaration", id
);
9181 error_at (loc
, "declaration of non-variable "
9182 "%qD in %<for%> loop initial declaration", decl
);
9189 return n_decls
== 1 ? one_decl
: NULL_TREE
;
9192 /* Save and reinitialize the variables
9193 used during compilation of a C function. */
9196 c_push_function_context (void)
9198 struct language_function
*p
= cfun
->language
;
9199 /* cfun->language might have been already allocated by the use of
9200 -Wunused-local-typedefs. In that case, just re-use it. */
9202 cfun
->language
= p
= ggc_cleared_alloc
<language_function
> ();
9204 p
->base
.x_stmt_tree
= c_stmt_tree
;
9205 c_stmt_tree
.x_cur_stmt_list
= vec_safe_copy (c_stmt_tree
.x_cur_stmt_list
);
9206 p
->x_break_label
= c_break_label
;
9207 p
->x_cont_label
= c_cont_label
;
9208 p
->x_switch_stack
= c_switch_stack
;
9209 p
->arg_info
= current_function_arg_info
;
9210 p
->returns_value
= current_function_returns_value
;
9211 p
->returns_null
= current_function_returns_null
;
9212 p
->returns_abnormally
= current_function_returns_abnormally
;
9213 p
->warn_about_return_type
= warn_about_return_type
;
9215 push_function_context ();
9218 /* Restore the variables used during compilation of a C function. */
9221 c_pop_function_context (void)
9223 struct language_function
*p
;
9225 pop_function_context ();
9228 /* When -Wunused-local-typedefs is in effect, cfun->languages is
9229 used to store data throughout the life time of the current cfun,
9230 So don't deallocate it. */
9231 if (!warn_unused_local_typedefs
)
9232 cfun
->language
= NULL
;
9234 if (DECL_STRUCT_FUNCTION (current_function_decl
) == 0
9235 && DECL_SAVED_TREE (current_function_decl
) == NULL_TREE
)
9237 /* Stop pointing to the local nodes about to be freed. */
9238 /* But DECL_INITIAL must remain nonzero so we know this
9239 was an actual function definition. */
9240 DECL_INITIAL (current_function_decl
) = error_mark_node
;
9241 DECL_ARGUMENTS (current_function_decl
) = 0;
9244 c_stmt_tree
= p
->base
.x_stmt_tree
;
9245 p
->base
.x_stmt_tree
.x_cur_stmt_list
= NULL
;
9246 c_break_label
= p
->x_break_label
;
9247 c_cont_label
= p
->x_cont_label
;
9248 c_switch_stack
= p
->x_switch_stack
;
9249 current_function_arg_info
= p
->arg_info
;
9250 current_function_returns_value
= p
->returns_value
;
9251 current_function_returns_null
= p
->returns_null
;
9252 current_function_returns_abnormally
= p
->returns_abnormally
;
9253 warn_about_return_type
= p
->warn_about_return_type
;
9256 /* The functions below are required for functionality of doing
9257 function at once processing in the C front end. Currently these
9258 functions are not called from anywhere in the C front end, but as
9259 these changes continue, that will change. */
9261 /* Returns the stmt_tree (if any) to which statements are currently
9262 being added. If there is no active statement-tree, NULL is
9266 current_stmt_tree (void)
9268 return &c_stmt_tree
;
9271 /* Return the global value of T as a symbol. */
9274 identifier_global_value (tree t
)
9276 struct c_binding
*b
;
9278 for (b
= I_SYMBOL_BINDING (t
); b
; b
= b
->shadowed
)
9279 if (B_IN_FILE_SCOPE (b
) || B_IN_EXTERNAL_SCOPE (b
))
9285 /* In C, the only C-linkage public declaration is at file scope. */
9288 c_linkage_bindings (tree name
)
9290 return identifier_global_value (name
);
9293 /* Record a builtin type for C. If NAME is non-NULL, it is the name used;
9294 otherwise the name is found in ridpointers from RID_INDEX. */
9297 record_builtin_type (enum rid rid_index
, const char *name
, tree type
)
9301 id
= ridpointers
[(int) rid_index
];
9303 id
= get_identifier (name
);
9304 decl
= build_decl (UNKNOWN_LOCATION
, TYPE_DECL
, id
, type
);
9306 if (debug_hooks
->type_decl
)
9307 debug_hooks
->type_decl (decl
, false);
9310 /* Build the void_list_node (void_type_node having been created). */
9312 build_void_list_node (void)
9314 tree t
= build_tree_list (NULL_TREE
, void_type_node
);
9318 /* Return a c_parm structure with the given SPECS, ATTRS and DECLARATOR. */
9321 build_c_parm (struct c_declspecs
*specs
, tree attrs
,
9322 struct c_declarator
*declarator
)
9324 struct c_parm
*ret
= XOBNEW (&parser_obstack
, struct c_parm
);
9327 ret
->declarator
= declarator
;
9331 /* Return a declarator with nested attributes. TARGET is the inner
9332 declarator to which these attributes apply. ATTRS are the
9335 struct c_declarator
*
9336 build_attrs_declarator (tree attrs
, struct c_declarator
*target
)
9338 struct c_declarator
*ret
= XOBNEW (&parser_obstack
, struct c_declarator
);
9339 ret
->kind
= cdk_attrs
;
9340 ret
->declarator
= target
;
9341 ret
->u
.attrs
= attrs
;
9345 /* Return a declarator for a function with arguments specified by ARGS
9346 and return type specified by TARGET. */
9348 struct c_declarator
*
9349 build_function_declarator (struct c_arg_info
*args
,
9350 struct c_declarator
*target
)
9352 struct c_declarator
*ret
= XOBNEW (&parser_obstack
, struct c_declarator
);
9353 ret
->kind
= cdk_function
;
9354 ret
->declarator
= target
;
9355 ret
->u
.arg_info
= args
;
9359 /* Return a declarator for the identifier IDENT (which may be
9360 NULL_TREE for an abstract declarator). */
9362 struct c_declarator
*
9363 build_id_declarator (tree ident
)
9365 struct c_declarator
*ret
= XOBNEW (&parser_obstack
, struct c_declarator
);
9367 ret
->declarator
= 0;
9369 /* Default value - may get reset to a more precise location. */
9370 ret
->id_loc
= input_location
;
9374 /* Return something to represent absolute declarators containing a *.
9375 TARGET is the absolute declarator that the * contains.
9376 TYPE_QUALS_ATTRS is a structure for type qualifiers and attributes
9377 to apply to the pointer type. */
9379 struct c_declarator
*
9380 make_pointer_declarator (struct c_declspecs
*type_quals_attrs
,
9381 struct c_declarator
*target
)
9385 struct c_declarator
*itarget
= target
;
9386 struct c_declarator
*ret
= XOBNEW (&parser_obstack
, struct c_declarator
);
9387 if (type_quals_attrs
)
9389 attrs
= type_quals_attrs
->attrs
;
9390 quals
= quals_from_declspecs (type_quals_attrs
);
9391 if (attrs
!= NULL_TREE
)
9392 itarget
= build_attrs_declarator (attrs
, target
);
9394 ret
->kind
= cdk_pointer
;
9395 ret
->declarator
= itarget
;
9396 ret
->u
.pointer_quals
= quals
;
9400 /* Return a pointer to a structure for an empty list of declaration
9403 struct c_declspecs
*
9404 build_null_declspecs (void)
9406 struct c_declspecs
*ret
= XOBNEW (&parser_obstack
, struct c_declspecs
);
9407 memset (&ret
->locations
, 0, cdw_number_of_elements
);
9412 ret
->align_log
= -1;
9413 ret
->typespec_word
= cts_none
;
9414 ret
->storage_class
= csc_none
;
9415 ret
->expr_const_operands
= true;
9416 ret
->declspecs_seen_p
= false;
9417 ret
->typespec_kind
= ctsk_none
;
9418 ret
->non_sc_seen_p
= false;
9419 ret
->typedef_p
= false;
9420 ret
->explicit_signed_p
= false;
9421 ret
->deprecated_p
= false;
9422 ret
->default_int_p
= false;
9423 ret
->long_p
= false;
9424 ret
->long_long_p
= false;
9425 ret
->short_p
= false;
9426 ret
->signed_p
= false;
9427 ret
->unsigned_p
= false;
9428 ret
->complex_p
= false;
9429 ret
->inline_p
= false;
9430 ret
->noreturn_p
= false;
9431 ret
->thread_p
= false;
9432 ret
->thread_gnu_p
= false;
9433 ret
->const_p
= false;
9434 ret
->volatile_p
= false;
9435 ret
->atomic_p
= false;
9436 ret
->restrict_p
= false;
9437 ret
->saturating_p
= false;
9438 ret
->alignas_p
= false;
9439 ret
->address_space
= ADDR_SPACE_GENERIC
;
9443 /* Add the address space ADDRSPACE to the declaration specifiers
9444 SPECS, returning SPECS. */
9446 struct c_declspecs
*
9447 declspecs_add_addrspace (source_location location
,
9448 struct c_declspecs
*specs
, addr_space_t as
)
9450 specs
->non_sc_seen_p
= true;
9451 specs
->declspecs_seen_p
= true;
9453 if (!ADDR_SPACE_GENERIC_P (specs
->address_space
)
9454 && specs
->address_space
!= as
)
9455 error ("incompatible address space qualifiers %qs and %qs",
9456 c_addr_space_name (as
),
9457 c_addr_space_name (specs
->address_space
));
9460 specs
->address_space
= as
;
9461 specs
->locations
[cdw_address_space
] = location
;
9466 /* Add the type qualifier QUAL to the declaration specifiers SPECS,
9469 struct c_declspecs
*
9470 declspecs_add_qual (source_location loc
,
9471 struct c_declspecs
*specs
, tree qual
)
9475 specs
->non_sc_seen_p
= true;
9476 specs
->declspecs_seen_p
= true;
9477 gcc_assert (TREE_CODE (qual
) == IDENTIFIER_NODE
9478 && C_IS_RESERVED_WORD (qual
));
9479 i
= C_RID_CODE (qual
);
9483 dupe
= specs
->const_p
;
9484 specs
->const_p
= true;
9485 specs
->locations
[cdw_const
] = loc
;
9488 dupe
= specs
->volatile_p
;
9489 specs
->volatile_p
= true;
9490 specs
->locations
[cdw_volatile
] = loc
;
9493 dupe
= specs
->restrict_p
;
9494 specs
->restrict_p
= true;
9495 specs
->locations
[cdw_restrict
] = loc
;
9498 dupe
= specs
->atomic_p
;
9499 specs
->atomic_p
= true;
9505 pedwarn_c90 (loc
, OPT_Wpedantic
, "duplicate %qE", qual
);
9509 /* Add the type specifier TYPE to the declaration specifiers SPECS,
9512 struct c_declspecs
*
9513 declspecs_add_type (location_t loc
, struct c_declspecs
*specs
,
9514 struct c_typespec spec
)
9516 tree type
= spec
.spec
;
9517 specs
->non_sc_seen_p
= true;
9518 specs
->declspecs_seen_p
= true;
9519 specs
->typespec_kind
= spec
.kind
;
9520 if (TREE_DEPRECATED (type
))
9521 specs
->deprecated_p
= true;
9523 /* Handle type specifier keywords. */
9524 if (TREE_CODE (type
) == IDENTIFIER_NODE
9525 && C_IS_RESERVED_WORD (type
)
9526 && C_RID_CODE (type
) != RID_CXX_COMPAT_WARN
)
9528 enum rid i
= C_RID_CODE (type
);
9531 error_at (loc
, "two or more data types in declaration specifiers");
9534 if ((int) i
<= (int) RID_LAST_MODIFIER
)
9536 /* "long", "short", "signed", "unsigned", "_Complex" or "_Sat". */
9541 if (specs
->long_long_p
)
9543 error_at (loc
, "%<long long long%> is too long for GCC");
9548 if (specs
->typespec_word
== cts_double
)
9551 ("both %<long long%> and %<double%> in "
9552 "declaration specifiers"));
9555 pedwarn_c90 (loc
, OPT_Wlong_long
,
9556 "ISO C90 does not support %<long long%>");
9557 specs
->long_long_p
= 1;
9558 specs
->locations
[cdw_long_long
] = loc
;
9563 ("both %<long%> and %<short%> in "
9564 "declaration specifiers"));
9565 else if (specs
->typespec_word
== cts_auto_type
)
9567 ("both %<long%> and %<__auto_type%> in "
9568 "declaration specifiers"));
9569 else if (specs
->typespec_word
== cts_void
)
9571 ("both %<long%> and %<void%> in "
9572 "declaration specifiers"));
9573 else if (specs
->typespec_word
== cts_int_n
)
9575 ("both %<long%> and %<__int%d%> in "
9576 "declaration specifiers"),
9577 int_n_data
[specs
->int_n_idx
].bitsize
);
9578 else if (specs
->typespec_word
== cts_bool
)
9580 ("both %<long%> and %<_Bool%> in "
9581 "declaration specifiers"));
9582 else if (specs
->typespec_word
== cts_char
)
9584 ("both %<long%> and %<char%> in "
9585 "declaration specifiers"));
9586 else if (specs
->typespec_word
== cts_float
)
9588 ("both %<long%> and %<float%> in "
9589 "declaration specifiers"));
9590 else if (specs
->typespec_word
== cts_dfloat32
)
9592 ("both %<long%> and %<_Decimal32%> in "
9593 "declaration specifiers"));
9594 else if (specs
->typespec_word
== cts_dfloat64
)
9596 ("both %<long%> and %<_Decimal64%> in "
9597 "declaration specifiers"));
9598 else if (specs
->typespec_word
== cts_dfloat128
)
9600 ("both %<long%> and %<_Decimal128%> in "
9601 "declaration specifiers"));
9604 specs
->long_p
= true;
9605 specs
->locations
[cdw_long
] = loc
;
9609 dupe
= specs
->short_p
;
9612 ("both %<long%> and %<short%> in "
9613 "declaration specifiers"));
9614 else if (specs
->typespec_word
== cts_auto_type
)
9616 ("both %<short%> and %<__auto_type%> in "
9617 "declaration specifiers"));
9618 else if (specs
->typespec_word
== cts_void
)
9620 ("both %<short%> and %<void%> in "
9621 "declaration specifiers"));
9622 else if (specs
->typespec_word
== cts_int_n
)
9624 ("both %<short%> and %<__int%d%> in "
9625 "declaration specifiers"),
9626 int_n_data
[specs
->int_n_idx
].bitsize
);
9627 else if (specs
->typespec_word
== cts_bool
)
9629 ("both %<short%> and %<_Bool%> in "
9630 "declaration specifiers"));
9631 else if (specs
->typespec_word
== cts_char
)
9633 ("both %<short%> and %<char%> in "
9634 "declaration specifiers"));
9635 else if (specs
->typespec_word
== cts_float
)
9637 ("both %<short%> and %<float%> in "
9638 "declaration specifiers"));
9639 else if (specs
->typespec_word
== cts_double
)
9641 ("both %<short%> and %<double%> in "
9642 "declaration specifiers"));
9643 else if (specs
->typespec_word
== cts_dfloat32
)
9645 ("both %<short%> and %<_Decimal32%> in "
9646 "declaration specifiers"));
9647 else if (specs
->typespec_word
== cts_dfloat64
)
9649 ("both %<short%> and %<_Decimal64%> in "
9650 "declaration specifiers"));
9651 else if (specs
->typespec_word
== cts_dfloat128
)
9653 ("both %<short%> and %<_Decimal128%> in "
9654 "declaration specifiers"));
9657 specs
->short_p
= true;
9658 specs
->locations
[cdw_short
] = loc
;
9662 dupe
= specs
->signed_p
;
9663 if (specs
->unsigned_p
)
9665 ("both %<signed%> and %<unsigned%> in "
9666 "declaration specifiers"));
9667 else if (specs
->typespec_word
== cts_auto_type
)
9669 ("both %<signed%> and %<__auto_type%> in "
9670 "declaration specifiers"));
9671 else if (specs
->typespec_word
== cts_void
)
9673 ("both %<signed%> and %<void%> in "
9674 "declaration specifiers"));
9675 else if (specs
->typespec_word
== cts_bool
)
9677 ("both %<signed%> and %<_Bool%> in "
9678 "declaration specifiers"));
9679 else if (specs
->typespec_word
== cts_float
)
9681 ("both %<signed%> and %<float%> in "
9682 "declaration specifiers"));
9683 else if (specs
->typespec_word
== cts_double
)
9685 ("both %<signed%> and %<double%> in "
9686 "declaration specifiers"));
9687 else if (specs
->typespec_word
== cts_dfloat32
)
9689 ("both %<signed%> and %<_Decimal32%> in "
9690 "declaration specifiers"));
9691 else if (specs
->typespec_word
== cts_dfloat64
)
9693 ("both %<signed%> and %<_Decimal64%> in "
9694 "declaration specifiers"));
9695 else if (specs
->typespec_word
== cts_dfloat128
)
9697 ("both %<signed%> and %<_Decimal128%> in "
9698 "declaration specifiers"));
9701 specs
->signed_p
= true;
9702 specs
->locations
[cdw_signed
] = loc
;
9706 dupe
= specs
->unsigned_p
;
9707 if (specs
->signed_p
)
9709 ("both %<signed%> and %<unsigned%> in "
9710 "declaration specifiers"));
9711 else if (specs
->typespec_word
== cts_auto_type
)
9713 ("both %<unsigned%> and %<__auto_type%> in "
9714 "declaration specifiers"));
9715 else if (specs
->typespec_word
== cts_void
)
9717 ("both %<unsigned%> and %<void%> in "
9718 "declaration specifiers"));
9719 else if (specs
->typespec_word
== cts_bool
)
9721 ("both %<unsigned%> and %<_Bool%> in "
9722 "declaration specifiers"));
9723 else if (specs
->typespec_word
== cts_float
)
9725 ("both %<unsigned%> and %<float%> in "
9726 "declaration specifiers"));
9727 else if (specs
->typespec_word
== cts_double
)
9729 ("both %<unsigned%> and %<double%> in "
9730 "declaration specifiers"));
9731 else if (specs
->typespec_word
== cts_dfloat32
)
9733 ("both %<unsigned%> and %<_Decimal32%> in "
9734 "declaration specifiers"));
9735 else if (specs
->typespec_word
== cts_dfloat64
)
9737 ("both %<unsigned%> and %<_Decimal64%> in "
9738 "declaration specifiers"));
9739 else if (specs
->typespec_word
== cts_dfloat128
)
9741 ("both %<unsigned%> and %<_Decimal128%> in "
9742 "declaration specifiers"));
9745 specs
->unsigned_p
= true;
9746 specs
->locations
[cdw_unsigned
] = loc
;
9750 dupe
= specs
->complex_p
;
9751 if (!in_system_header_at (loc
))
9752 pedwarn_c90 (loc
, OPT_Wpedantic
,
9753 "ISO C90 does not support complex types");
9754 if (specs
->typespec_word
== cts_auto_type
)
9756 ("both %<complex%> and %<__auto_type%> in "
9757 "declaration specifiers"));
9758 else if (specs
->typespec_word
== cts_void
)
9760 ("both %<complex%> and %<void%> in "
9761 "declaration specifiers"));
9762 else if (specs
->typespec_word
== cts_bool
)
9764 ("both %<complex%> and %<_Bool%> in "
9765 "declaration specifiers"));
9766 else if (specs
->typespec_word
== cts_dfloat32
)
9768 ("both %<complex%> and %<_Decimal32%> in "
9769 "declaration specifiers"));
9770 else if (specs
->typespec_word
== cts_dfloat64
)
9772 ("both %<complex%> and %<_Decimal64%> in "
9773 "declaration specifiers"));
9774 else if (specs
->typespec_word
== cts_dfloat128
)
9776 ("both %<complex%> and %<_Decimal128%> in "
9777 "declaration specifiers"));
9778 else if (specs
->typespec_word
== cts_fract
)
9780 ("both %<complex%> and %<_Fract%> in "
9781 "declaration specifiers"));
9782 else if (specs
->typespec_word
== cts_accum
)
9784 ("both %<complex%> and %<_Accum%> in "
9785 "declaration specifiers"));
9786 else if (specs
->saturating_p
)
9788 ("both %<complex%> and %<_Sat%> in "
9789 "declaration specifiers"));
9792 specs
->complex_p
= true;
9793 specs
->locations
[cdw_complex
] = loc
;
9797 dupe
= specs
->saturating_p
;
9798 pedwarn (loc
, OPT_Wpedantic
,
9799 "ISO C does not support saturating types");
9800 if (specs
->typespec_word
== cts_int_n
)
9803 ("both %<_Sat%> and %<__int%d%> in "
9804 "declaration specifiers"),
9805 int_n_data
[specs
->int_n_idx
].bitsize
);
9807 else if (specs
->typespec_word
== cts_auto_type
)
9809 ("both %<_Sat%> and %<__auto_type%> in "
9810 "declaration specifiers"));
9811 else if (specs
->typespec_word
== cts_void
)
9813 ("both %<_Sat%> and %<void%> in "
9814 "declaration specifiers"));
9815 else if (specs
->typespec_word
== cts_bool
)
9817 ("both %<_Sat%> and %<_Bool%> in "
9818 "declaration specifiers"));
9819 else if (specs
->typespec_word
== cts_char
)
9821 ("both %<_Sat%> and %<char%> in "
9822 "declaration specifiers"));
9823 else if (specs
->typespec_word
== cts_int
)
9825 ("both %<_Sat%> and %<int%> in "
9826 "declaration specifiers"));
9827 else if (specs
->typespec_word
== cts_float
)
9829 ("both %<_Sat%> and %<float%> in "
9830 "declaration specifiers"));
9831 else if (specs
->typespec_word
== cts_double
)
9833 ("both %<_Sat%> and %<double%> in "
9834 "declaration specifiers"));
9835 else if (specs
->typespec_word
== cts_dfloat32
)
9837 ("both %<_Sat%> and %<_Decimal32%> in "
9838 "declaration specifiers"));
9839 else if (specs
->typespec_word
== cts_dfloat64
)
9841 ("both %<_Sat%> and %<_Decimal64%> in "
9842 "declaration specifiers"));
9843 else if (specs
->typespec_word
== cts_dfloat128
)
9845 ("both %<_Sat%> and %<_Decimal128%> in "
9846 "declaration specifiers"));
9847 else if (specs
->complex_p
)
9849 ("both %<_Sat%> and %<complex%> in "
9850 "declaration specifiers"));
9853 specs
->saturating_p
= true;
9854 specs
->locations
[cdw_saturating
] = loc
;
9862 error_at (loc
, "duplicate %qE", type
);
9868 /* "void", "_Bool", "char", "int", "float", "double", "_Decimal32",
9869 "__intN", "_Decimal64", "_Decimal128", "_Fract", "_Accum" or
9871 if (specs
->typespec_word
!= cts_none
)
9874 "two or more data types in declaration specifiers");
9882 ("both %<long%> and %<__auto_type%> in "
9883 "declaration specifiers"));
9884 else if (specs
->short_p
)
9886 ("both %<short%> and %<__auto_type%> in "
9887 "declaration specifiers"));
9888 else if (specs
->signed_p
)
9890 ("both %<signed%> and %<__auto_type%> in "
9891 "declaration specifiers"));
9892 else if (specs
->unsigned_p
)
9894 ("both %<unsigned%> and %<__auto_type%> in "
9895 "declaration specifiers"));
9896 else if (specs
->complex_p
)
9898 ("both %<complex%> and %<__auto_type%> in "
9899 "declaration specifiers"));
9900 else if (specs
->saturating_p
)
9902 ("both %<_Sat%> and %<__auto_type%> in "
9903 "declaration specifiers"));
9906 specs
->typespec_word
= cts_auto_type
;
9907 specs
->locations
[cdw_typespec
] = loc
;
9914 specs
->int_n_idx
= i
- RID_INT_N_0
;
9915 if (!in_system_header_at (input_location
))
9916 pedwarn (loc
, OPT_Wpedantic
,
9917 "ISO C does not support %<__int%d%> types",
9918 int_n_data
[specs
->int_n_idx
].bitsize
);
9922 ("both %<__int%d%> and %<long%> in "
9923 "declaration specifiers"),
9924 int_n_data
[specs
->int_n_idx
].bitsize
);
9925 else if (specs
->saturating_p
)
9927 ("both %<_Sat%> and %<__int%d%> in "
9928 "declaration specifiers"),
9929 int_n_data
[specs
->int_n_idx
].bitsize
);
9930 else if (specs
->short_p
)
9932 ("both %<__int%d%> and %<short%> in "
9933 "declaration specifiers"),
9934 int_n_data
[specs
->int_n_idx
].bitsize
);
9935 else if (! int_n_enabled_p
[specs
->int_n_idx
])
9937 "%<__int%d%> is not supported on this target",
9938 int_n_data
[specs
->int_n_idx
].bitsize
);
9941 specs
->typespec_word
= cts_int_n
;
9942 specs
->locations
[cdw_typespec
] = loc
;
9948 ("both %<long%> and %<void%> in "
9949 "declaration specifiers"));
9950 else if (specs
->short_p
)
9952 ("both %<short%> and %<void%> in "
9953 "declaration specifiers"));
9954 else if (specs
->signed_p
)
9956 ("both %<signed%> and %<void%> in "
9957 "declaration specifiers"));
9958 else if (specs
->unsigned_p
)
9960 ("both %<unsigned%> and %<void%> in "
9961 "declaration specifiers"));
9962 else if (specs
->complex_p
)
9964 ("both %<complex%> and %<void%> in "
9965 "declaration specifiers"));
9966 else if (specs
->saturating_p
)
9968 ("both %<_Sat%> and %<void%> in "
9969 "declaration specifiers"));
9972 specs
->typespec_word
= cts_void
;
9973 specs
->locations
[cdw_typespec
] = loc
;
9977 if (!in_system_header_at (loc
))
9978 pedwarn_c90 (loc
, OPT_Wpedantic
,
9979 "ISO C90 does not support boolean types");
9982 ("both %<long%> and %<_Bool%> in "
9983 "declaration specifiers"));
9984 else if (specs
->short_p
)
9986 ("both %<short%> and %<_Bool%> in "
9987 "declaration specifiers"));
9988 else if (specs
->signed_p
)
9990 ("both %<signed%> and %<_Bool%> in "
9991 "declaration specifiers"));
9992 else if (specs
->unsigned_p
)
9994 ("both %<unsigned%> and %<_Bool%> in "
9995 "declaration specifiers"));
9996 else if (specs
->complex_p
)
9998 ("both %<complex%> and %<_Bool%> in "
9999 "declaration specifiers"));
10000 else if (specs
->saturating_p
)
10002 ("both %<_Sat%> and %<_Bool%> in "
10003 "declaration specifiers"));
10006 specs
->typespec_word
= cts_bool
;
10007 specs
->locations
[cdw_typespec
] = loc
;
10013 ("both %<long%> and %<char%> in "
10014 "declaration specifiers"));
10015 else if (specs
->short_p
)
10017 ("both %<short%> and %<char%> in "
10018 "declaration specifiers"));
10019 else if (specs
->saturating_p
)
10021 ("both %<_Sat%> and %<char%> in "
10022 "declaration specifiers"));
10025 specs
->typespec_word
= cts_char
;
10026 specs
->locations
[cdw_typespec
] = loc
;
10030 if (specs
->saturating_p
)
10032 ("both %<_Sat%> and %<int%> in "
10033 "declaration specifiers"));
10036 specs
->typespec_word
= cts_int
;
10037 specs
->locations
[cdw_typespec
] = loc
;
10043 ("both %<long%> and %<float%> in "
10044 "declaration specifiers"));
10045 else if (specs
->short_p
)
10047 ("both %<short%> and %<float%> in "
10048 "declaration specifiers"));
10049 else if (specs
->signed_p
)
10051 ("both %<signed%> and %<float%> in "
10052 "declaration specifiers"));
10053 else if (specs
->unsigned_p
)
10055 ("both %<unsigned%> and %<float%> in "
10056 "declaration specifiers"));
10057 else if (specs
->saturating_p
)
10059 ("both %<_Sat%> and %<float%> in "
10060 "declaration specifiers"));
10063 specs
->typespec_word
= cts_float
;
10064 specs
->locations
[cdw_typespec
] = loc
;
10068 if (specs
->long_long_p
)
10070 ("both %<long long%> and %<double%> in "
10071 "declaration specifiers"));
10072 else if (specs
->short_p
)
10074 ("both %<short%> and %<double%> in "
10075 "declaration specifiers"));
10076 else if (specs
->signed_p
)
10078 ("both %<signed%> and %<double%> in "
10079 "declaration specifiers"));
10080 else if (specs
->unsigned_p
)
10082 ("both %<unsigned%> and %<double%> in "
10083 "declaration specifiers"));
10084 else if (specs
->saturating_p
)
10086 ("both %<_Sat%> and %<double%> in "
10087 "declaration specifiers"));
10090 specs
->typespec_word
= cts_double
;
10091 specs
->locations
[cdw_typespec
] = loc
;
10096 case RID_DFLOAT128
:
10099 if (i
== RID_DFLOAT32
)
10100 str
= "_Decimal32";
10101 else if (i
== RID_DFLOAT64
)
10102 str
= "_Decimal64";
10104 str
= "_Decimal128";
10105 if (specs
->long_long_p
)
10107 ("both %<long long%> and %<%s%> in "
10108 "declaration specifiers"),
10112 ("both %<long%> and %<%s%> in "
10113 "declaration specifiers"),
10115 else if (specs
->short_p
)
10117 ("both %<short%> and %<%s%> in "
10118 "declaration specifiers"),
10120 else if (specs
->signed_p
)
10122 ("both %<signed%> and %<%s%> in "
10123 "declaration specifiers"),
10125 else if (specs
->unsigned_p
)
10127 ("both %<unsigned%> and %<%s%> in "
10128 "declaration specifiers"),
10130 else if (specs
->complex_p
)
10132 ("both %<complex%> and %<%s%> in "
10133 "declaration specifiers"),
10135 else if (specs
->saturating_p
)
10137 ("both %<_Sat%> and %<%s%> in "
10138 "declaration specifiers"),
10140 else if (i
== RID_DFLOAT32
)
10141 specs
->typespec_word
= cts_dfloat32
;
10142 else if (i
== RID_DFLOAT64
)
10143 specs
->typespec_word
= cts_dfloat64
;
10145 specs
->typespec_word
= cts_dfloat128
;
10146 specs
->locations
[cdw_typespec
] = loc
;
10148 if (!targetm
.decimal_float_supported_p ())
10150 ("decimal floating point not supported "
10151 "for this target"));
10152 pedwarn (loc
, OPT_Wpedantic
,
10153 "ISO C does not support decimal floating point");
10159 if (i
== RID_FRACT
)
10163 if (specs
->complex_p
)
10165 ("both %<complex%> and %<%s%> in "
10166 "declaration specifiers"),
10168 else if (i
== RID_FRACT
)
10169 specs
->typespec_word
= cts_fract
;
10171 specs
->typespec_word
= cts_accum
;
10172 specs
->locations
[cdw_typespec
] = loc
;
10174 if (!targetm
.fixed_point_supported_p ())
10176 "fixed-point types not supported for this target");
10177 pedwarn (loc
, OPT_Wpedantic
,
10178 "ISO C does not support fixed-point types");
10181 /* ObjC reserved word "id", handled below. */
10187 /* Now we have a typedef (a TYPE_DECL node), an identifier (some
10188 form of ObjC type, cases such as "int" and "long" being handled
10189 above), a TYPE (struct, union, enum and typeof specifiers) or an
10190 ERROR_MARK. In none of these cases may there have previously
10191 been any type specifiers. */
10192 if (specs
->type
|| specs
->typespec_word
!= cts_none
10193 || specs
->long_p
|| specs
->short_p
|| specs
->signed_p
10194 || specs
->unsigned_p
|| specs
->complex_p
)
10195 error_at (loc
, "two or more data types in declaration specifiers");
10196 else if (TREE_CODE (type
) == TYPE_DECL
)
10198 if (TREE_TYPE (type
) == error_mark_node
)
10199 ; /* Allow the type to default to int to avoid cascading errors. */
10202 specs
->type
= TREE_TYPE (type
);
10203 specs
->decl_attr
= DECL_ATTRIBUTES (type
);
10204 specs
->typedef_p
= true;
10205 specs
->explicit_signed_p
= C_TYPEDEF_EXPLICITLY_SIGNED (type
);
10206 specs
->locations
[cdw_typedef
] = loc
;
10208 /* If this typedef name is defined in a struct, then a C++
10209 lookup would return a different value. */
10210 if (warn_cxx_compat
10211 && I_SYMBOL_BINDING (DECL_NAME (type
))->in_struct
)
10212 warning_at (loc
, OPT_Wc___compat
,
10213 "C++ lookup of %qD would return a field, not a type",
10216 /* If we are parsing a struct, record that a struct field
10218 if (warn_cxx_compat
&& struct_parse_info
!= NULL
)
10219 struct_parse_info
->typedefs_seen
.safe_push (type
);
10222 else if (TREE_CODE (type
) == IDENTIFIER_NODE
)
10224 tree t
= lookup_name (type
);
10225 if (!t
|| TREE_CODE (t
) != TYPE_DECL
)
10226 error_at (loc
, "%qE fails to be a typedef or built in type", type
);
10227 else if (TREE_TYPE (t
) == error_mark_node
)
10231 specs
->type
= TREE_TYPE (t
);
10232 specs
->locations
[cdw_typespec
] = loc
;
10237 if (TREE_CODE (type
) != ERROR_MARK
&& spec
.kind
== ctsk_typeof
)
10239 specs
->typedef_p
= true;
10240 specs
->locations
[cdw_typedef
] = loc
;
10244 specs
->expr
= build2 (COMPOUND_EXPR
, TREE_TYPE (spec
.expr
),
10245 specs
->expr
, spec
.expr
);
10247 specs
->expr
= spec
.expr
;
10248 specs
->expr_const_operands
&= spec
.expr_const_operands
;
10251 specs
->type
= type
;
10257 /* Add the storage class specifier or function specifier SCSPEC to the
10258 declaration specifiers SPECS, returning SPECS. */
10260 struct c_declspecs
*
10261 declspecs_add_scspec (source_location loc
,
10262 struct c_declspecs
*specs
,
10266 enum c_storage_class n
= csc_none
;
10268 specs
->declspecs_seen_p
= true;
10269 gcc_assert (TREE_CODE (scspec
) == IDENTIFIER_NODE
10270 && C_IS_RESERVED_WORD (scspec
));
10271 i
= C_RID_CODE (scspec
);
10272 if (specs
->non_sc_seen_p
)
10273 warning (OPT_Wold_style_declaration
,
10274 "%qE is not at beginning of declaration", scspec
);
10278 /* C99 permits duplicate inline. Although of doubtful utility,
10279 it seems simplest to permit it in gnu89 mode as well, as
10280 there is also little utility in maintaining this as a
10281 difference between gnu89 and C99 inline. */
10283 specs
->inline_p
= true;
10284 specs
->locations
[cdw_inline
] = loc
;
10287 /* Duplicate _Noreturn is permitted. */
10289 specs
->noreturn_p
= true;
10290 specs
->locations
[cdw_noreturn
] = loc
;
10293 dupe
= specs
->thread_p
;
10294 if (specs
->storage_class
== csc_auto
)
10295 error ("%qE used with %<auto%>", scspec
);
10296 else if (specs
->storage_class
== csc_register
)
10297 error ("%qE used with %<register%>", scspec
);
10298 else if (specs
->storage_class
== csc_typedef
)
10299 error ("%qE used with %<typedef%>", scspec
);
10302 specs
->thread_p
= true;
10303 specs
->thread_gnu_p
= (strcmp (IDENTIFIER_POINTER (scspec
),
10305 /* A diagnostic is not required for the use of this
10306 identifier in the implementation namespace; only diagnose
10307 it for the C11 spelling because of existing code using
10308 the other spelling. */
10309 if (!specs
->thread_gnu_p
)
10312 pedwarn_c99 (loc
, OPT_Wpedantic
,
10313 "ISO C99 does not support %qE", scspec
);
10315 pedwarn_c99 (loc
, OPT_Wpedantic
,
10316 "ISO C90 does not support %qE", scspec
);
10318 specs
->locations
[cdw_thread
] = loc
;
10326 /* Diagnose "__thread extern". */
10327 if (specs
->thread_p
&& specs
->thread_gnu_p
)
10328 error ("%<__thread%> before %<extern%>");
10335 /* Diagnose "__thread static". */
10336 if (specs
->thread_p
&& specs
->thread_gnu_p
)
10337 error ("%<__thread%> before %<static%>");
10343 gcc_unreachable ();
10345 if (n
!= csc_none
&& n
== specs
->storage_class
)
10349 if (i
== RID_THREAD
)
10350 error ("duplicate %<_Thread_local%> or %<__thread%>");
10352 error ("duplicate %qE", scspec
);
10356 if (specs
->storage_class
!= csc_none
&& n
!= specs
->storage_class
)
10358 error ("multiple storage classes in declaration specifiers");
10362 specs
->storage_class
= n
;
10363 specs
->locations
[cdw_storage_class
] = loc
;
10364 if (n
!= csc_extern
&& n
!= csc_static
&& specs
->thread_p
)
10366 error ("%qs used with %qE",
10367 specs
->thread_gnu_p
? "__thread" : "_Thread_local",
10369 specs
->thread_p
= false;
10376 /* Add the attributes ATTRS to the declaration specifiers SPECS,
10377 returning SPECS. */
10379 struct c_declspecs
*
10380 declspecs_add_attrs (source_location loc
, struct c_declspecs
*specs
, tree attrs
)
10382 specs
->attrs
= chainon (attrs
, specs
->attrs
);
10383 specs
->locations
[cdw_attributes
] = loc
;
10384 specs
->declspecs_seen_p
= true;
10388 /* Add an _Alignas specifier (expression ALIGN, or type whose
10389 alignment is ALIGN) to the declaration specifiers SPECS, returning
10391 struct c_declspecs
*
10392 declspecs_add_alignas (source_location loc
,
10393 struct c_declspecs
*specs
, tree align
)
10396 specs
->alignas_p
= true;
10397 specs
->locations
[cdw_alignas
] = loc
;
10398 if (align
== error_mark_node
)
10400 align_log
= check_user_alignment (align
, true);
10401 if (align_log
> specs
->align_log
)
10402 specs
->align_log
= align_log
;
10406 /* Combine "long", "short", "signed", "unsigned" and "_Complex" type
10407 specifiers with any other type specifier to determine the resulting
10408 type. This is where ISO C checks on complex types are made, since
10409 "_Complex long" is a prefix of the valid ISO C type "_Complex long
10412 struct c_declspecs
*
10413 finish_declspecs (struct c_declspecs
*specs
)
10415 /* If a type was specified as a whole, we have no modifiers and are
10417 if (specs
->type
!= NULL_TREE
)
10419 gcc_assert (!specs
->long_p
&& !specs
->long_long_p
&& !specs
->short_p
10420 && !specs
->signed_p
&& !specs
->unsigned_p
10421 && !specs
->complex_p
);
10423 /* Set a dummy type. */
10424 if (TREE_CODE (specs
->type
) == ERROR_MARK
)
10425 specs
->type
= integer_type_node
;
10429 /* If none of "void", "_Bool", "char", "int", "float" or "double"
10430 has been specified, treat it as "int" unless "_Complex" is
10431 present and there are no other specifiers. If we just have
10432 "_Complex", it is equivalent to "_Complex double", but e.g.
10433 "_Complex short" is equivalent to "_Complex short int". */
10434 if (specs
->typespec_word
== cts_none
)
10436 if (specs
->saturating_p
)
10438 error_at (specs
->locations
[cdw_saturating
],
10439 "%<_Sat%> is used without %<_Fract%> or %<_Accum%>");
10440 if (!targetm
.fixed_point_supported_p ())
10441 error_at (specs
->locations
[cdw_saturating
],
10442 "fixed-point types not supported for this target");
10443 specs
->typespec_word
= cts_fract
;
10445 else if (specs
->long_p
|| specs
->short_p
10446 || specs
->signed_p
|| specs
->unsigned_p
)
10448 specs
->typespec_word
= cts_int
;
10450 else if (specs
->complex_p
)
10452 specs
->typespec_word
= cts_double
;
10453 pedwarn (specs
->locations
[cdw_complex
], OPT_Wpedantic
,
10454 "ISO C does not support plain %<complex%> meaning "
10455 "%<double complex%>");
10459 specs
->typespec_word
= cts_int
;
10460 specs
->default_int_p
= true;
10461 /* We don't diagnose this here because grokdeclarator will
10462 give more specific diagnostics according to whether it is
10463 a function definition. */
10467 /* If "signed" was specified, record this to distinguish "int" and
10468 "signed int" in the case of a bit-field with
10469 -funsigned-bitfields. */
10470 specs
->explicit_signed_p
= specs
->signed_p
;
10472 /* Now compute the actual type. */
10473 switch (specs
->typespec_word
)
10475 case cts_auto_type
:
10476 gcc_assert (!specs
->long_p
&& !specs
->short_p
10477 && !specs
->signed_p
&& !specs
->unsigned_p
10478 && !specs
->complex_p
);
10479 /* Type to be filled in later. */
10482 gcc_assert (!specs
->long_p
&& !specs
->short_p
10483 && !specs
->signed_p
&& !specs
->unsigned_p
10484 && !specs
->complex_p
);
10485 specs
->type
= void_type_node
;
10488 gcc_assert (!specs
->long_p
&& !specs
->short_p
10489 && !specs
->signed_p
&& !specs
->unsigned_p
10490 && !specs
->complex_p
);
10491 specs
->type
= boolean_type_node
;
10494 gcc_assert (!specs
->long_p
&& !specs
->short_p
);
10495 gcc_assert (!(specs
->signed_p
&& specs
->unsigned_p
));
10496 if (specs
->signed_p
)
10497 specs
->type
= signed_char_type_node
;
10498 else if (specs
->unsigned_p
)
10499 specs
->type
= unsigned_char_type_node
;
10501 specs
->type
= char_type_node
;
10502 if (specs
->complex_p
)
10504 pedwarn (specs
->locations
[cdw_complex
], OPT_Wpedantic
,
10505 "ISO C does not support complex integer types");
10506 specs
->type
= build_complex_type (specs
->type
);
10510 gcc_assert (!specs
->long_p
&& !specs
->short_p
&& !specs
->long_long_p
);
10511 gcc_assert (!(specs
->signed_p
&& specs
->unsigned_p
));
10512 specs
->type
= (specs
->unsigned_p
10513 ? int_n_trees
[specs
->int_n_idx
].unsigned_type
10514 : int_n_trees
[specs
->int_n_idx
].signed_type
);
10515 if (specs
->complex_p
)
10517 pedwarn (specs
->locations
[cdw_complex
], OPT_Wpedantic
,
10518 "ISO C does not support complex integer types");
10519 specs
->type
= build_complex_type (specs
->type
);
10523 gcc_assert (!(specs
->long_p
&& specs
->short_p
));
10524 gcc_assert (!(specs
->signed_p
&& specs
->unsigned_p
));
10525 if (specs
->long_long_p
)
10526 specs
->type
= (specs
->unsigned_p
10527 ? long_long_unsigned_type_node
10528 : long_long_integer_type_node
);
10529 else if (specs
->long_p
)
10530 specs
->type
= (specs
->unsigned_p
10531 ? long_unsigned_type_node
10532 : long_integer_type_node
);
10533 else if (specs
->short_p
)
10534 specs
->type
= (specs
->unsigned_p
10535 ? short_unsigned_type_node
10536 : short_integer_type_node
);
10538 specs
->type
= (specs
->unsigned_p
10539 ? unsigned_type_node
10540 : integer_type_node
);
10541 if (specs
->complex_p
)
10543 pedwarn (specs
->locations
[cdw_complex
], OPT_Wpedantic
,
10544 "ISO C does not support complex integer types");
10545 specs
->type
= build_complex_type (specs
->type
);
10549 gcc_assert (!specs
->long_p
&& !specs
->short_p
10550 && !specs
->signed_p
&& !specs
->unsigned_p
);
10551 specs
->type
= (specs
->complex_p
10552 ? complex_float_type_node
10553 : float_type_node
);
10556 gcc_assert (!specs
->long_long_p
&& !specs
->short_p
10557 && !specs
->signed_p
&& !specs
->unsigned_p
);
10560 specs
->type
= (specs
->complex_p
10561 ? complex_long_double_type_node
10562 : long_double_type_node
);
10566 specs
->type
= (specs
->complex_p
10567 ? complex_double_type_node
10568 : double_type_node
);
10573 case cts_dfloat128
:
10574 gcc_assert (!specs
->long_p
&& !specs
->long_long_p
&& !specs
->short_p
10575 && !specs
->signed_p
&& !specs
->unsigned_p
&& !specs
->complex_p
);
10576 if (specs
->typespec_word
== cts_dfloat32
)
10577 specs
->type
= dfloat32_type_node
;
10578 else if (specs
->typespec_word
== cts_dfloat64
)
10579 specs
->type
= dfloat64_type_node
;
10581 specs
->type
= dfloat128_type_node
;
10584 gcc_assert (!specs
->complex_p
);
10585 if (!targetm
.fixed_point_supported_p ())
10586 specs
->type
= integer_type_node
;
10587 else if (specs
->saturating_p
)
10589 if (specs
->long_long_p
)
10590 specs
->type
= specs
->unsigned_p
10591 ? sat_unsigned_long_long_fract_type_node
10592 : sat_long_long_fract_type_node
;
10593 else if (specs
->long_p
)
10594 specs
->type
= specs
->unsigned_p
10595 ? sat_unsigned_long_fract_type_node
10596 : sat_long_fract_type_node
;
10597 else if (specs
->short_p
)
10598 specs
->type
= specs
->unsigned_p
10599 ? sat_unsigned_short_fract_type_node
10600 : sat_short_fract_type_node
;
10602 specs
->type
= specs
->unsigned_p
10603 ? sat_unsigned_fract_type_node
10604 : sat_fract_type_node
;
10608 if (specs
->long_long_p
)
10609 specs
->type
= specs
->unsigned_p
10610 ? unsigned_long_long_fract_type_node
10611 : long_long_fract_type_node
;
10612 else if (specs
->long_p
)
10613 specs
->type
= specs
->unsigned_p
10614 ? unsigned_long_fract_type_node
10615 : long_fract_type_node
;
10616 else if (specs
->short_p
)
10617 specs
->type
= specs
->unsigned_p
10618 ? unsigned_short_fract_type_node
10619 : short_fract_type_node
;
10621 specs
->type
= specs
->unsigned_p
10622 ? unsigned_fract_type_node
10627 gcc_assert (!specs
->complex_p
);
10628 if (!targetm
.fixed_point_supported_p ())
10629 specs
->type
= integer_type_node
;
10630 else if (specs
->saturating_p
)
10632 if (specs
->long_long_p
)
10633 specs
->type
= specs
->unsigned_p
10634 ? sat_unsigned_long_long_accum_type_node
10635 : sat_long_long_accum_type_node
;
10636 else if (specs
->long_p
)
10637 specs
->type
= specs
->unsigned_p
10638 ? sat_unsigned_long_accum_type_node
10639 : sat_long_accum_type_node
;
10640 else if (specs
->short_p
)
10641 specs
->type
= specs
->unsigned_p
10642 ? sat_unsigned_short_accum_type_node
10643 : sat_short_accum_type_node
;
10645 specs
->type
= specs
->unsigned_p
10646 ? sat_unsigned_accum_type_node
10647 : sat_accum_type_node
;
10651 if (specs
->long_long_p
)
10652 specs
->type
= specs
->unsigned_p
10653 ? unsigned_long_long_accum_type_node
10654 : long_long_accum_type_node
;
10655 else if (specs
->long_p
)
10656 specs
->type
= specs
->unsigned_p
10657 ? unsigned_long_accum_type_node
10658 : long_accum_type_node
;
10659 else if (specs
->short_p
)
10660 specs
->type
= specs
->unsigned_p
10661 ? unsigned_short_accum_type_node
10662 : short_accum_type_node
;
10664 specs
->type
= specs
->unsigned_p
10665 ? unsigned_accum_type_node
10670 gcc_unreachable ();
10676 /* Perform final processing on one file scope's declarations (or the
10677 external scope's declarations), GLOBALS. */
10680 c_write_global_declarations_1 (tree globals
)
10685 /* Process the decls in the order they were written. */
10686 for (decl
= globals
; decl
; decl
= DECL_CHAIN (decl
))
10688 /* Check for used but undefined static functions using the C
10689 standard's definition of "used", and set TREE_NO_WARNING so
10690 that check_global_declaration doesn't repeat the check. */
10691 if (TREE_CODE (decl
) == FUNCTION_DECL
10692 && DECL_INITIAL (decl
) == 0
10693 && DECL_EXTERNAL (decl
)
10694 && !TREE_PUBLIC (decl
)
10695 && C_DECL_USED (decl
))
10697 pedwarn (input_location
, 0, "%q+F used but never defined", decl
);
10698 TREE_NO_WARNING (decl
) = 1;
10701 wrapup_global_declaration_1 (decl
);
10706 reconsider
= false;
10707 for (decl
= globals
; decl
; decl
= DECL_CHAIN (decl
))
10708 reconsider
|= wrapup_global_declaration_2 (decl
);
10710 while (reconsider
);
10713 /* Callback to collect a source_ref from a DECL. */
10716 collect_source_ref_cb (tree decl
)
10718 if (!DECL_IS_BUILTIN (decl
))
10719 collect_source_ref (LOCATION_FILE (decl_sloc (decl
, false)));
10722 /* Preserve the external declarations scope across a garbage collect. */
10723 static GTY(()) tree ext_block
;
10725 /* Collect all references relevant to SOURCE_FILE. */
10728 collect_all_refs (const char *source_file
)
10733 FOR_EACH_VEC_ELT (*all_translation_units
, i
, t
)
10734 collect_ada_nodes (BLOCK_VARS (DECL_INITIAL (t
)), source_file
);
10736 collect_ada_nodes (BLOCK_VARS (ext_block
), source_file
);
10739 /* Iterate over all global declarations and call CALLBACK. */
10742 for_each_global_decl (void (*callback
) (tree decl
))
10749 FOR_EACH_VEC_ELT (*all_translation_units
, i
, t
)
10751 decls
= DECL_INITIAL (t
);
10752 for (decl
= BLOCK_VARS (decls
); decl
; decl
= TREE_CHAIN (decl
))
10756 for (decl
= BLOCK_VARS (ext_block
); decl
; decl
= TREE_CHAIN (decl
))
10760 /* Perform any final parser cleanups and generate initial debugging
10764 c_parse_final_cleanups (void)
10769 /* We don't want to do this if generating a PCH. */
10773 timevar_stop (TV_PHASE_PARSING
);
10774 timevar_start (TV_PHASE_DEFERRED
);
10776 /* Do the Objective-C stuff. This is where all the Objective-C
10777 module stuff gets generated (symtab, class/protocol/selector
10779 if (c_dialect_objc ())
10780 objc_write_global_declarations ();
10782 /* Close the external scope. */
10783 ext_block
= pop_scope ();
10784 external_scope
= 0;
10785 gcc_assert (!current_scope
);
10787 /* Handle -fdump-ada-spec[-slim]. */
10788 if (flag_dump_ada_spec
|| flag_dump_ada_spec_slim
)
10790 /* Build a table of files to generate specs for */
10791 if (flag_dump_ada_spec_slim
)
10792 collect_source_ref (main_input_filename
);
10794 for_each_global_decl (collect_source_ref_cb
);
10796 dump_ada_specs (collect_all_refs
, NULL
);
10801 tree tmp
= BLOCK_VARS (ext_block
);
10803 FILE * stream
= dump_begin (TDI_tu
, &flags
);
10806 dump_node (tmp
, flags
& ~TDF_SLIM
, stream
);
10807 dump_end (TDI_tu
, stream
);
10811 /* Process all file scopes in this compilation, and the external_scope,
10812 through wrapup_global_declarations. */
10813 FOR_EACH_VEC_ELT (*all_translation_units
, i
, t
)
10814 c_write_global_declarations_1 (BLOCK_VARS (DECL_INITIAL (t
)));
10815 c_write_global_declarations_1 (BLOCK_VARS (ext_block
));
10817 timevar_stop (TV_PHASE_DEFERRED
);
10818 timevar_start (TV_PHASE_PARSING
);
10823 /* Register reserved keyword WORD as qualifier for address space AS. */
10826 c_register_addr_space (const char *word
, addr_space_t as
)
10828 int rid
= RID_FIRST_ADDR_SPACE
+ as
;
10831 /* Address space qualifiers are only supported
10832 in C with GNU extensions enabled. */
10833 if (c_dialect_objc () || flag_no_asm
)
10836 id
= get_identifier (word
);
10837 C_SET_RID_CODE (id
, rid
);
10838 C_IS_RESERVED_WORD (id
) = 1;
10839 ridpointers
[rid
] = id
;
10842 /* Return identifier to look up for omp declare reduction. */
10845 c_omp_reduction_id (enum tree_code reduction_code
, tree reduction_id
)
10847 const char *p
= NULL
;
10848 switch (reduction_code
)
10850 case PLUS_EXPR
: p
= "+"; break;
10851 case MULT_EXPR
: p
= "*"; break;
10852 case MINUS_EXPR
: p
= "-"; break;
10853 case BIT_AND_EXPR
: p
= "&"; break;
10854 case BIT_XOR_EXPR
: p
= "^"; break;
10855 case BIT_IOR_EXPR
: p
= "|"; break;
10856 case TRUTH_ANDIF_EXPR
: p
= "&&"; break;
10857 case TRUTH_ORIF_EXPR
: p
= "||"; break;
10858 case MIN_EXPR
: p
= "min"; break;
10859 case MAX_EXPR
: p
= "max"; break;
10866 if (TREE_CODE (reduction_id
) != IDENTIFIER_NODE
)
10867 return error_mark_node
;
10868 p
= IDENTIFIER_POINTER (reduction_id
);
10871 const char prefix
[] = "omp declare reduction ";
10872 size_t lenp
= sizeof (prefix
);
10873 size_t len
= strlen (p
);
10874 char *name
= XALLOCAVEC (char, lenp
+ len
);
10875 memcpy (name
, prefix
, lenp
- 1);
10876 memcpy (name
+ lenp
- 1, p
, len
+ 1);
10877 return get_identifier (name
);
10880 /* Lookup REDUCTION_ID in the current scope, or create an artificial
10881 VAR_DECL, bind it into the current scope and return it. */
10884 c_omp_reduction_decl (tree reduction_id
)
10886 struct c_binding
*b
= I_SYMBOL_BINDING (reduction_id
);
10887 if (b
!= NULL
&& B_IN_CURRENT_SCOPE (b
))
10890 tree decl
= build_decl (BUILTINS_LOCATION
, VAR_DECL
,
10891 reduction_id
, integer_type_node
);
10892 DECL_ARTIFICIAL (decl
) = 1;
10893 DECL_EXTERNAL (decl
) = 1;
10894 TREE_STATIC (decl
) = 1;
10895 TREE_PUBLIC (decl
) = 0;
10896 bind (reduction_id
, decl
, current_scope
, true, false, BUILTINS_LOCATION
);
10900 /* Lookup REDUCTION_ID in the first scope where it has entry for TYPE. */
10903 c_omp_reduction_lookup (tree reduction_id
, tree type
)
10905 struct c_binding
*b
= I_SYMBOL_BINDING (reduction_id
);
10909 for (t
= DECL_INITIAL (b
->decl
); t
; t
= TREE_CHAIN (t
))
10910 if (comptypes (TREE_PURPOSE (t
), type
))
10911 return TREE_VALUE (t
);
10914 return error_mark_node
;
10917 /* Helper function called via walk_tree, to diagnose invalid
10918 #pragma omp declare reduction combiners or initializers. */
10921 c_check_omp_declare_reduction_r (tree
*tp
, int *, void *data
)
10923 tree
*vars
= (tree
*) data
;
10924 if (SSA_VAR_P (*tp
)
10925 && !DECL_ARTIFICIAL (*tp
)
10929 location_t loc
= DECL_SOURCE_LOCATION (vars
[0]);
10930 if (strcmp (IDENTIFIER_POINTER (DECL_NAME (vars
[0])), "omp_out") == 0)
10931 error_at (loc
, "%<#pragma omp declare reduction%> combiner refers to "
10932 "variable %qD which is not %<omp_out%> nor %<omp_in%>",
10935 error_at (loc
, "%<#pragma omp declare reduction%> initializer refers "
10936 "to variable %qD which is not %<omp_priv%> nor "
10944 #include "gt-c-c-decl.h"