1 /* Process declarations and variables for C compiler.
2 Copyright (C) 1988-2017 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 "stringpool.h"
37 #include "print-tree.h"
38 #include "stor-layout.h"
43 #include "c-family/c-objc.h"
44 #include "c-family/c-pragma.h"
45 #include "c-family/c-ubsan.h"
47 #include "langhooks.h"
48 #include "tree-iterator.h"
51 #include "c-family/c-ada-spec.h"
54 #include "spellcheck-tree.h"
55 #include "gcc-rich-location.h"
58 /* In grokdeclarator, distinguish syntactic contexts of declarators. */
60 { NORMAL
, /* Ordinary declaration */
61 FUNCDEF
, /* Function definition */
62 PARM
, /* Declaration of parm before function body */
63 FIELD
, /* Declaration inside struct or union */
64 TYPENAME
}; /* Typename (inside cast or sizeof) */
66 /* States indicating how grokdeclarator() should handle declspecs marked
67 with __attribute__((deprecated)). An object declared as
68 __attribute__((deprecated)) suppresses warnings of uses of other
71 enum deprecated_states
{
77 /* Nonzero if we have seen an invalid cross reference
78 to a struct, union, or enum, but not yet printed the message. */
79 tree pending_invalid_xref
;
81 /* File and line to appear in the eventual error message. */
82 location_t pending_invalid_xref_location
;
84 /* The file and line that the prototype came from if this is an
85 old-style definition; used for diagnostics in
86 store_parm_decls_oldstyle. */
88 static location_t current_function_prototype_locus
;
90 /* Whether this prototype was built-in. */
92 static bool current_function_prototype_built_in
;
94 /* The argument type information of this prototype. */
96 static tree current_function_prototype_arg_types
;
98 /* The argument information structure for the function currently being
101 static struct c_arg_info
*current_function_arg_info
;
103 /* The obstack on which parser and related data structures, which are
104 not live beyond their top-level declaration or definition, are
106 struct obstack parser_obstack
;
108 /* The current statement tree. */
110 static GTY(()) struct stmt_tree_s c_stmt_tree
;
112 /* State saving variables. */
116 /* A list of decls to be made automatically visible in each file scope. */
117 static GTY(()) tree visible_builtins
;
119 /* Set to 0 at beginning of a function definition, set to 1 if
120 a return statement that specifies a return value is seen. */
122 int current_function_returns_value
;
124 /* Set to 0 at beginning of a function definition, set to 1 if
125 a return statement with no argument is seen. */
127 int current_function_returns_null
;
129 /* Set to 0 at beginning of a function definition, set to 1 if
130 a call to a noreturn function is seen. */
132 int current_function_returns_abnormally
;
134 /* Set to nonzero by `grokdeclarator' for a function
135 whose return type is defaulted, if warnings for this are desired. */
137 static int warn_about_return_type
;
139 /* Nonzero when the current toplevel function contains a declaration
140 of a nested function which is never defined. */
142 static bool undef_nested_function
;
144 /* If non-zero, implicit "omp declare target" attribute is added into the
146 int current_omp_declare_target_attribute
;
148 /* Each c_binding structure describes one binding of an identifier to
149 a decl. All the decls in a scope - irrespective of namespace - are
150 chained together by the ->prev field, which (as the name implies)
151 runs in reverse order. All the decls in a given namespace bound to
152 a given identifier are chained by the ->shadowed field, which runs
153 from inner to outer scopes.
155 The ->decl field usually points to a DECL node, but there are two
156 exceptions. In the namespace of type tags, the bound entity is a
157 RECORD_TYPE, UNION_TYPE, or ENUMERAL_TYPE node. If an undeclared
158 identifier is encountered, it is bound to error_mark_node to
159 suppress further errors about that identifier in the current
162 The ->u.type field stores the type of the declaration in this scope;
163 if NULL, the type is the type of the ->decl field. This is only of
164 relevance for objects with external or internal linkage which may
165 be redeclared in inner scopes, forming composite types that only
166 persist for the duration of those scopes. In the external scope,
167 this stores the composite of all the types declared for this
168 object, visible or not. The ->inner_comp field (used only at file
169 scope) stores whether an incomplete array type at file scope was
170 completed at an inner scope to an array size other than 1.
172 The ->u.label field is used for labels. It points to a structure
173 which stores additional information used for warnings.
175 The depth field is copied from the scope structure that holds this
176 decl. It is used to preserve the proper ordering of the ->shadowed
177 field (see bind()) and also for a handful of special-case checks.
178 Finally, the invisible bit is true for a decl which should be
179 ignored for purposes of normal name lookup, and the nested bit is
180 true for a decl that's been bound a second time in an inner scope;
181 in all such cases, the binding in the outer scope will have its
182 invisible bit true. */
184 struct GTY((chain_next ("%h.prev"))) c_binding
{
185 union GTY(()) { /* first so GTY desc can use decl */
186 tree
GTY((tag ("0"))) type
; /* the type in this scope */
187 struct c_label_vars
* GTY((tag ("1"))) label
; /* for warnings */
188 } GTY((desc ("TREE_CODE (%0.decl) == LABEL_DECL"))) u
;
189 tree decl
; /* the decl bound */
190 tree id
; /* the identifier it's bound to */
191 struct c_binding
*prev
; /* the previous decl in this scope */
192 struct c_binding
*shadowed
; /* the innermost decl shadowed by this one */
193 unsigned int depth
: 28; /* depth of this scope */
194 BOOL_BITFIELD invisible
: 1; /* normal lookup should ignore this binding */
195 BOOL_BITFIELD nested
: 1; /* do not set DECL_CONTEXT when popping */
196 BOOL_BITFIELD inner_comp
: 1; /* incomplete array completed in inner scope */
197 BOOL_BITFIELD in_struct
: 1; /* currently defined as struct field */
198 location_t locus
; /* location for nested bindings */
200 #define B_IN_SCOPE(b1, b2) ((b1)->depth == (b2)->depth)
201 #define B_IN_CURRENT_SCOPE(b) ((b)->depth == current_scope->depth)
202 #define B_IN_FILE_SCOPE(b) ((b)->depth == 1 /*file_scope->depth*/)
203 #define B_IN_EXTERNAL_SCOPE(b) ((b)->depth == 0 /*external_scope->depth*/)
205 /* Each C symbol points to three linked lists of c_binding structures.
206 These describe the values of the identifier in the three different
207 namespaces defined by the language. */
209 struct GTY(()) lang_identifier
{
210 struct c_common_identifier common_id
;
211 struct c_binding
*symbol_binding
; /* vars, funcs, constants, typedefs */
212 struct c_binding
*tag_binding
; /* struct/union/enum tags */
213 struct c_binding
*label_binding
; /* labels */
216 /* Validate c-lang.c's assumptions. */
217 extern char C_SIZEOF_STRUCT_LANG_IDENTIFIER_isnt_accurate
218 [(sizeof(struct lang_identifier
) == C_SIZEOF_STRUCT_LANG_IDENTIFIER
) ? 1 : -1];
220 /* The binding oracle; see c-tree.h. */
221 void (*c_binding_oracle
) (enum c_oracle_request
, tree identifier
);
223 /* This flag is set on an identifier if we have previously asked the
224 binding oracle for this identifier's symbol binding. */
225 #define I_SYMBOL_CHECKED(node) \
226 (TREE_LANG_FLAG_4 (IDENTIFIER_NODE_CHECK (node)))
228 static inline struct c_binding
* *
229 i_symbol_binding (tree node
)
231 struct lang_identifier
*lid
232 = (struct lang_identifier
*) IDENTIFIER_NODE_CHECK (node
);
234 if (lid
->symbol_binding
== NULL
235 && c_binding_oracle
!= NULL
236 && !I_SYMBOL_CHECKED (node
))
238 /* Set the "checked" flag first, to avoid infinite recursion
239 when the binding oracle calls back into gcc. */
240 I_SYMBOL_CHECKED (node
) = 1;
241 c_binding_oracle (C_ORACLE_SYMBOL
, node
);
244 return &lid
->symbol_binding
;
247 #define I_SYMBOL_BINDING(node) (*i_symbol_binding (node))
249 #define I_SYMBOL_DECL(node) \
250 (I_SYMBOL_BINDING(node) ? I_SYMBOL_BINDING(node)->decl : 0)
252 /* This flag is set on an identifier if we have previously asked the
253 binding oracle for this identifier's tag binding. */
254 #define I_TAG_CHECKED(node) \
255 (TREE_LANG_FLAG_5 (IDENTIFIER_NODE_CHECK (node)))
257 static inline struct c_binding
**
258 i_tag_binding (tree node
)
260 struct lang_identifier
*lid
261 = (struct lang_identifier
*) IDENTIFIER_NODE_CHECK (node
);
263 if (lid
->tag_binding
== NULL
264 && c_binding_oracle
!= NULL
265 && !I_TAG_CHECKED (node
))
267 /* Set the "checked" flag first, to avoid infinite recursion
268 when the binding oracle calls back into gcc. */
269 I_TAG_CHECKED (node
) = 1;
270 c_binding_oracle (C_ORACLE_TAG
, node
);
273 return &lid
->tag_binding
;
276 #define I_TAG_BINDING(node) (*i_tag_binding (node))
278 #define I_TAG_DECL(node) \
279 (I_TAG_BINDING(node) ? I_TAG_BINDING(node)->decl : 0)
281 /* This flag is set on an identifier if we have previously asked the
282 binding oracle for this identifier's label binding. */
283 #define I_LABEL_CHECKED(node) \
284 (TREE_LANG_FLAG_6 (IDENTIFIER_NODE_CHECK (node)))
286 static inline struct c_binding
**
287 i_label_binding (tree node
)
289 struct lang_identifier
*lid
290 = (struct lang_identifier
*) IDENTIFIER_NODE_CHECK (node
);
292 if (lid
->label_binding
== NULL
293 && c_binding_oracle
!= NULL
294 && !I_LABEL_CHECKED (node
))
296 /* Set the "checked" flag first, to avoid infinite recursion
297 when the binding oracle calls back into gcc. */
298 I_LABEL_CHECKED (node
) = 1;
299 c_binding_oracle (C_ORACLE_LABEL
, node
);
302 return &lid
->label_binding
;
305 #define I_LABEL_BINDING(node) (*i_label_binding (node))
307 #define I_LABEL_DECL(node) \
308 (I_LABEL_BINDING(node) ? I_LABEL_BINDING(node)->decl : 0)
310 /* The resulting tree type. */
312 union GTY((desc ("TREE_CODE (&%h.generic) == IDENTIFIER_NODE"),
313 chain_next ("(union lang_tree_node *) c_tree_chain_next (&%h.generic)"))) lang_tree_node
315 union tree_node
GTY ((tag ("0"),
316 desc ("tree_node_structure (&%h)")))
318 struct lang_identifier
GTY ((tag ("1"))) identifier
;
321 /* Track bindings and other things that matter for goto warnings. For
322 efficiency, we do not gather all the decls at the point of
323 definition. Instead, we point into the bindings structure. As
324 scopes are popped, we update these structures and gather the decls
325 that matter at that time. */
327 struct GTY(()) c_spot_bindings
{
328 /* The currently open scope which holds bindings defined when the
329 label was defined or the goto statement was found. */
330 struct c_scope
*scope
;
331 /* The bindings in the scope field which were defined at the point
332 of the label or goto. This lets us look at older or newer
333 bindings in the scope, as appropriate. */
334 struct c_binding
*bindings_in_scope
;
335 /* The number of statement expressions that have started since this
336 label or goto statement was defined. This is zero if we are at
337 the same statement expression level. It is positive if we are in
338 a statement expression started since this spot. It is negative
339 if this spot was in a statement expression and we have left
342 /* Whether we started in a statement expression but are no longer in
343 it. This is set to true if stmt_exprs ever goes negative. */
347 /* This structure is used to keep track of bindings seen when a goto
348 statement is defined. This is only used if we see the goto
349 statement before we see the label. */
351 struct GTY(()) c_goto_bindings
{
352 /* The location of the goto statement. */
354 /* The bindings of the goto statement. */
355 struct c_spot_bindings goto_bindings
;
358 typedef struct c_goto_bindings
*c_goto_bindings_p
;
360 /* The additional information we keep track of for a label binding.
361 These fields are updated as scopes are popped. */
363 struct GTY(()) c_label_vars
{
364 /* The shadowed c_label_vars, when one label shadows another (which
365 can only happen using a __label__ declaration). */
366 struct c_label_vars
*shadowed
;
367 /* The bindings when the label was defined. */
368 struct c_spot_bindings label_bindings
;
369 /* A list of decls that we care about: decls about which we should
370 warn if a goto branches to this label from later in the function.
371 Decls are added to this list as scopes are popped. We only add
372 the decls that matter. */
373 vec
<tree
, va_gc
> *decls_in_scope
;
374 /* A list of goto statements to this label. This is only used for
375 goto statements seen before the label was defined, so that we can
376 issue appropriate warnings for them. */
377 vec
<c_goto_bindings_p
, va_gc
> *gotos
;
380 /* Each c_scope structure describes the complete contents of one
381 scope. Four scopes are distinguished specially: the innermost or
382 current scope, the innermost function scope, the file scope (always
383 the second to outermost) and the outermost or external scope.
385 Most declarations are recorded in the current scope.
387 All normal label declarations are recorded in the innermost
388 function scope, as are bindings of undeclared identifiers to
389 error_mark_node. (GCC permits nested functions as an extension,
390 hence the 'innermost' qualifier.) Explicitly declared labels
391 (using the __label__ extension) appear in the current scope.
393 Being in the file scope (current_scope == file_scope) causes
394 special behavior in several places below. Also, under some
395 conditions the Objective-C front end records declarations in the
396 file scope even though that isn't the current scope.
398 All declarations with external linkage are recorded in the external
399 scope, even if they aren't visible there; this models the fact that
400 such declarations are visible to the entire program, and (with a
401 bit of cleverness, see pushdecl) allows diagnosis of some violations
402 of C99 6.2.2p7 and 6.2.7p2:
404 If, within the same translation unit, the same identifier appears
405 with both internal and external linkage, the behavior is
408 All declarations that refer to the same object or function shall
409 have compatible type; otherwise, the behavior is undefined.
411 Initially only the built-in declarations, which describe compiler
412 intrinsic functions plus a subset of the standard library, are in
415 The order of the blocks list matters, and it is frequently appended
416 to. To avoid having to walk all the way to the end of the list on
417 each insertion, or reverse the list later, we maintain a pointer to
418 the last list entry. (FIXME: It should be feasible to use a reversed
421 The bindings list is strictly in reverse order of declarations;
422 pop_scope relies on this. */
425 struct GTY((chain_next ("%h.outer"))) c_scope
{
426 /* The scope containing this one. */
427 struct c_scope
*outer
;
429 /* The next outermost function scope. */
430 struct c_scope
*outer_function
;
432 /* All bindings in this scope. */
433 struct c_binding
*bindings
;
435 /* For each scope (except the global one), a chain of BLOCK nodes
436 for all the scopes that were entered and exited one level down. */
440 /* The depth of this scope. Used to keep the ->shadowed chain of
441 bindings sorted innermost to outermost. */
442 unsigned int depth
: 28;
444 /* True if we are currently filling this scope with parameter
446 BOOL_BITFIELD parm_flag
: 1;
448 /* True if we saw [*] in this scope. Used to give an error messages
449 if these appears in a function definition. */
450 BOOL_BITFIELD had_vla_unspec
: 1;
452 /* True if we already complained about forward parameter decls
453 in this scope. This prevents double warnings on
454 foo (int a; int b; ...) */
455 BOOL_BITFIELD warned_forward_parm_decls
: 1;
457 /* True if this is the outermost block scope of a function body.
458 This scope contains the parameters, the local variables declared
459 in the outermost block, and all the labels (except those in
460 nested functions, or declared at block scope with __label__). */
461 BOOL_BITFIELD function_body
: 1;
463 /* True means make a BLOCK for this scope no matter what. */
464 BOOL_BITFIELD keep
: 1;
466 /* True means that an unsuffixed float constant is _Decimal64. */
467 BOOL_BITFIELD float_const_decimal64
: 1;
469 /* True if this scope has any label bindings. This is used to speed
470 up searching for labels when popping scopes, particularly since
471 labels are normally only found at function scope. */
472 BOOL_BITFIELD has_label_bindings
: 1;
474 /* True if we should issue a warning if a goto statement crosses any
475 of the bindings. We still need to check the list of bindings to
476 find the specific ones we need to warn about. This is true if
477 decl_jump_unsafe would return true for any of the bindings. This
478 is used to avoid looping over all the bindings unnecessarily. */
479 BOOL_BITFIELD has_jump_unsafe_decl
: 1;
482 /* The scope currently in effect. */
484 static GTY(()) struct c_scope
*current_scope
;
486 /* The innermost function scope. Ordinary (not explicitly declared)
487 labels, bindings to error_mark_node, and the lazily-created
488 bindings of __func__ and its friends get this scope. */
490 static GTY(()) struct c_scope
*current_function_scope
;
492 /* The C file scope. This is reset for each input translation unit. */
494 static GTY(()) struct c_scope
*file_scope
;
496 /* The outermost scope. This is used for all declarations with
497 external linkage, and only these, hence the name. */
499 static GTY(()) struct c_scope
*external_scope
;
501 /* A chain of c_scope structures awaiting reuse. */
503 static GTY((deletable
)) struct c_scope
*scope_freelist
;
505 /* A chain of c_binding structures awaiting reuse. */
507 static GTY((deletable
)) struct c_binding
*binding_freelist
;
509 /* Append VAR to LIST in scope SCOPE. */
510 #define SCOPE_LIST_APPEND(scope, list, decl) do { \
511 struct c_scope *s_ = (scope); \
513 if (s_->list##_last) \
514 BLOCK_CHAIN (s_->list##_last) = d_; \
517 s_->list##_last = d_; \
520 /* Concatenate FROM in scope FSCOPE onto TO in scope TSCOPE. */
521 #define SCOPE_LIST_CONCAT(tscope, to, fscope, from) do { \
522 struct c_scope *t_ = (tscope); \
523 struct c_scope *f_ = (fscope); \
525 BLOCK_CHAIN (t_->to##_last) = f_->from; \
528 t_->to##_last = f_->from##_last; \
531 /* A c_inline_static structure stores details of a static identifier
532 referenced in a definition of a function that may be an inline
533 definition if no subsequent declaration of that function uses
534 "extern" or does not use "inline". */
536 struct GTY((chain_next ("%h.next"))) c_inline_static
{
537 /* The location for a diagnostic. */
540 /* The function that may be an inline definition. */
543 /* The object or function referenced. */
546 /* What sort of reference this is. */
547 enum c_inline_static_type type
;
549 /* The next such structure or NULL. */
550 struct c_inline_static
*next
;
553 /* List of static identifiers used or referenced in functions that may
554 be inline definitions. */
555 static GTY(()) struct c_inline_static
*c_inline_statics
;
557 /* True means unconditionally make a BLOCK for the next scope pushed. */
559 static bool keep_next_level_flag
;
561 /* True means the next call to push_scope will be the outermost scope
562 of a function body, so do not push a new scope, merely cease
563 expecting parameter decls. */
565 static bool next_is_function_body
;
567 /* A vector of pointers to c_binding structures. */
569 typedef struct c_binding
*c_binding_ptr
;
571 /* Information that we keep for a struct or union while it is being
574 struct c_struct_parse_info
576 /* If warn_cxx_compat, a list of types defined within this
578 auto_vec
<tree
> struct_types
;
579 /* If warn_cxx_compat, a list of field names which have bindings,
580 and which are defined in this struct, but which are not defined
581 in any enclosing struct. This is used to clear the in_struct
582 field of the c_bindings structure. */
583 auto_vec
<c_binding_ptr
> fields
;
584 /* If warn_cxx_compat, a list of typedef names used when defining
585 fields in this struct. */
586 auto_vec
<tree
> typedefs_seen
;
589 /* Information for the struct or union currently being parsed, or
590 NULL if not parsing a struct or union. */
591 static struct c_struct_parse_info
*struct_parse_info
;
593 /* Forward declarations. */
594 static tree
lookup_name_in_scope (tree
, struct c_scope
*);
595 static tree
c_make_fname_decl (location_t
, tree
, int);
596 static tree
grokdeclarator (const struct c_declarator
*,
597 struct c_declspecs
*,
598 enum decl_context
, bool, tree
*, tree
*, tree
*,
599 bool *, enum deprecated_states
);
600 static tree
grokparms (struct c_arg_info
*, bool);
601 static void layout_array_type (tree
);
602 static void warn_defaults_to (location_t
, int, const char *, ...)
603 ATTRIBUTE_GCC_DIAG(3,4);
605 /* T is a statement. Add it to the statement-tree. This is the
606 C/ObjC version--C++ has a slightly different version of this
612 enum tree_code code
= TREE_CODE (t
);
614 if (CAN_HAVE_LOCATION_P (t
) && code
!= LABEL_EXPR
)
616 if (!EXPR_HAS_LOCATION (t
))
617 SET_EXPR_LOCATION (t
, input_location
);
620 if (code
== LABEL_EXPR
|| code
== CASE_LABEL_EXPR
)
621 STATEMENT_LIST_HAS_LABEL (cur_stmt_list
) = 1;
623 /* Add T to the statement-tree. Non-side-effect statements need to be
624 recorded during statement expressions. */
625 if (!building_stmt_list_p ())
627 append_to_statement_list_force (t
, &cur_stmt_list
);
632 /* Build a pointer type using the default pointer mode. */
635 c_build_pointer_type (tree to_type
)
637 addr_space_t as
= to_type
== error_mark_node
? ADDR_SPACE_GENERIC
638 : TYPE_ADDR_SPACE (to_type
);
639 machine_mode pointer_mode
;
641 if (as
!= ADDR_SPACE_GENERIC
|| c_default_pointer_mode
== VOIDmode
)
642 pointer_mode
= targetm
.addr_space
.pointer_mode (as
);
644 pointer_mode
= c_default_pointer_mode
;
645 return build_pointer_type_for_mode (to_type
, pointer_mode
, false);
649 /* Return true if we will want to say something if a goto statement
653 decl_jump_unsafe (tree decl
)
655 if (error_operand_p (decl
))
658 /* Always warn about crossing variably modified types. */
659 if ((VAR_P (decl
) || TREE_CODE (decl
) == TYPE_DECL
)
660 && variably_modified_type_p (TREE_TYPE (decl
), NULL_TREE
))
663 /* Otherwise, only warn if -Wgoto-misses-init and this is an
664 initialized automatic decl. */
665 if (warn_jump_misses_init
667 && !TREE_STATIC (decl
)
668 && DECL_INITIAL (decl
) != NULL_TREE
)
676 c_print_identifier (FILE *file
, tree node
, int indent
)
678 void (*save
) (enum c_oracle_request
, tree identifier
);
680 /* Temporarily hide any binding oracle. Without this, calls to
681 debug_tree from the debugger will end up calling into the oracle,
682 making for a confusing debug session. As the oracle isn't needed
683 here for normal operation, it's simplest to suppress it. */
684 save
= c_binding_oracle
;
685 c_binding_oracle
= NULL
;
687 print_node (file
, "symbol", I_SYMBOL_DECL (node
), indent
+ 4);
688 print_node (file
, "tag", I_TAG_DECL (node
), indent
+ 4);
689 print_node (file
, "label", I_LABEL_DECL (node
), indent
+ 4);
690 if (C_IS_RESERVED_WORD (node
) && C_RID_CODE (node
) != RID_CXX_COMPAT_WARN
)
692 tree rid
= ridpointers
[C_RID_CODE (node
)];
693 indent_to (file
, indent
+ 4);
694 fprintf (file
, "rid " HOST_PTR_PRINTF
" \"%s\"",
695 (void *) rid
, IDENTIFIER_POINTER (rid
));
698 c_binding_oracle
= save
;
701 /* Establish a binding between NAME, an IDENTIFIER_NODE, and DECL,
702 which may be any of several kinds of DECL or TYPE or error_mark_node,
703 in the scope SCOPE. */
705 bind (tree name
, tree decl
, struct c_scope
*scope
, bool invisible
,
706 bool nested
, location_t locus
)
708 struct c_binding
*b
, **here
;
710 if (binding_freelist
)
712 b
= binding_freelist
;
713 binding_freelist
= b
->prev
;
716 b
= ggc_alloc
<c_binding
> ();
721 b
->depth
= scope
->depth
;
722 b
->invisible
= invisible
;
730 b
->prev
= scope
->bindings
;
733 if (decl_jump_unsafe (decl
))
734 scope
->has_jump_unsafe_decl
= 1;
739 switch (TREE_CODE (decl
))
741 case LABEL_DECL
: here
= &I_LABEL_BINDING (name
); break;
744 case RECORD_TYPE
: here
= &I_TAG_BINDING (name
); break;
750 case ERROR_MARK
: here
= &I_SYMBOL_BINDING (name
); break;
756 /* Locate the appropriate place in the chain of shadowed decls
757 to insert this binding. Normally, scope == current_scope and
758 this does nothing. */
759 while (*here
&& (*here
)->depth
> scope
->depth
)
760 here
= &(*here
)->shadowed
;
766 /* Clear the binding structure B, stick it on the binding_freelist,
767 and return the former value of b->prev. This is used by pop_scope
768 and get_parm_info to iterate destructively over all the bindings
769 from a given scope. */
770 static struct c_binding
*
771 free_binding_and_advance (struct c_binding
*b
)
773 struct c_binding
*prev
= b
->prev
;
775 memset (b
, 0, sizeof (struct c_binding
));
776 b
->prev
= binding_freelist
;
777 binding_freelist
= b
;
782 /* Bind a label. Like bind, but skip fields which aren't used for
783 labels, and add the LABEL_VARS value. */
785 bind_label (tree name
, tree label
, struct c_scope
*scope
,
786 struct c_label_vars
*label_vars
)
790 bind (name
, label
, scope
, /*invisible=*/false, /*nested=*/false,
793 scope
->has_label_bindings
= true;
796 gcc_assert (b
->decl
== label
);
797 label_vars
->shadowed
= b
->u
.label
;
798 b
->u
.label
= label_vars
;
801 /* Hook called at end of compilation to assume 1 elt
802 for a file-scope tentative array defn that wasn't complete before. */
805 c_finish_incomplete_decl (tree decl
)
809 tree type
= TREE_TYPE (decl
);
810 if (type
!= error_mark_node
811 && TREE_CODE (type
) == ARRAY_TYPE
812 && !DECL_EXTERNAL (decl
)
813 && TYPE_DOMAIN (type
) == NULL_TREE
)
815 warning_at (DECL_SOURCE_LOCATION (decl
),
816 0, "array %q+D assumed to have one element", decl
);
818 complete_array_type (&TREE_TYPE (decl
), NULL_TREE
, true);
820 relayout_decl (decl
);
825 /* Record that inline function FUNC contains a reference (location
826 LOC) to static DECL (file-scope or function-local according to
830 record_inline_static (location_t loc
, tree func
, tree decl
,
831 enum c_inline_static_type type
)
833 c_inline_static
*csi
= ggc_alloc
<c_inline_static
> ();
835 csi
->function
= func
;
836 csi
->static_decl
= decl
;
838 csi
->next
= c_inline_statics
;
839 c_inline_statics
= csi
;
842 /* Check for references to static declarations in inline functions at
843 the end of the translation unit and diagnose them if the functions
844 are still inline definitions. */
847 check_inline_statics (void)
849 struct c_inline_static
*csi
;
850 for (csi
= c_inline_statics
; csi
; csi
= csi
->next
)
852 if (DECL_EXTERNAL (csi
->function
))
856 pedwarn (csi
->location
, 0,
857 "%qD is static but used in inline function %qD "
858 "which is not static", csi
->static_decl
, csi
->function
);
861 pedwarn (csi
->location
, 0,
862 "%q+D is static but declared in inline function %qD "
863 "which is not static", csi
->static_decl
, csi
->function
);
869 c_inline_statics
= NULL
;
872 /* Fill in a c_spot_bindings structure. If DEFINING is true, set it
873 for the current state, otherwise set it to uninitialized. */
876 set_spot_bindings (struct c_spot_bindings
*p
, bool defining
)
880 p
->scope
= current_scope
;
881 p
->bindings_in_scope
= current_scope
->bindings
;
886 p
->bindings_in_scope
= NULL
;
889 p
->left_stmt_expr
= false;
892 /* Update spot bindings P as we pop out of SCOPE. Return true if we
893 should push decls for a label. */
896 update_spot_bindings (struct c_scope
*scope
, struct c_spot_bindings
*p
)
898 if (p
->scope
!= scope
)
900 /* This label or goto is defined in some other scope, or it is a
901 label which is not yet defined. There is nothing to
906 /* Adjust the spot bindings to refer to the bindings already defined
907 in the enclosing scope. */
908 p
->scope
= scope
->outer
;
909 p
->bindings_in_scope
= p
->scope
->bindings
;
914 /* The Objective-C front-end often needs to determine the current scope. */
917 objc_get_current_scope (void)
919 return current_scope
;
922 /* The following function is used only by Objective-C. It needs to live here
923 because it accesses the innards of c_scope. */
926 objc_mark_locals_volatile (void *enclosing_blk
)
928 struct c_scope
*scope
;
931 for (scope
= current_scope
;
932 scope
&& scope
!= enclosing_blk
;
933 scope
= scope
->outer
)
935 for (b
= scope
->bindings
; b
; b
= b
->prev
)
936 objc_volatilize_decl (b
->decl
);
938 /* Do not climb up past the current function. */
939 if (scope
->function_body
)
944 /* Return true if we are in the global binding level. */
947 global_bindings_p (void)
949 return current_scope
== file_scope
;
953 keep_next_level (void)
955 keep_next_level_flag
= true;
958 /* Set the flag for the FLOAT_CONST_DECIMAL64 pragma being ON. */
961 set_float_const_decimal64 (void)
963 current_scope
->float_const_decimal64
= true;
966 /* Clear the flag for the FLOAT_CONST_DECIMAL64 pragma. */
969 clear_float_const_decimal64 (void)
971 current_scope
->float_const_decimal64
= false;
974 /* Return nonzero if an unsuffixed float constant is _Decimal64. */
977 float_const_decimal64_p (void)
979 return current_scope
->float_const_decimal64
;
982 /* Identify this scope as currently being filled with parameters. */
985 declare_parm_level (void)
987 current_scope
->parm_flag
= true;
993 if (next_is_function_body
)
995 /* This is the transition from the parameters to the top level
996 of the function body. These are the same scope
997 (C99 6.2.1p4,6) so we do not push another scope structure.
998 next_is_function_body is set only by store_parm_decls, which
999 in turn is called when and only when we are about to
1000 encounter the opening curly brace for the function body.
1002 The outermost block of a function always gets a BLOCK node,
1003 because the debugging output routines expect that each
1004 function has at least one BLOCK. */
1005 current_scope
->parm_flag
= false;
1006 current_scope
->function_body
= true;
1007 current_scope
->keep
= true;
1008 current_scope
->outer_function
= current_function_scope
;
1009 current_function_scope
= current_scope
;
1011 keep_next_level_flag
= false;
1012 next_is_function_body
= false;
1014 /* The FLOAT_CONST_DECIMAL64 pragma applies to nested scopes. */
1015 if (current_scope
->outer
)
1016 current_scope
->float_const_decimal64
1017 = current_scope
->outer
->float_const_decimal64
;
1019 current_scope
->float_const_decimal64
= false;
1023 struct c_scope
*scope
;
1026 scope
= scope_freelist
;
1027 scope_freelist
= scope
->outer
;
1030 scope
= ggc_cleared_alloc
<c_scope
> ();
1032 /* The FLOAT_CONST_DECIMAL64 pragma applies to nested scopes. */
1034 scope
->float_const_decimal64
= current_scope
->float_const_decimal64
;
1036 scope
->float_const_decimal64
= false;
1038 scope
->keep
= keep_next_level_flag
;
1039 scope
->outer
= current_scope
;
1040 scope
->depth
= current_scope
? (current_scope
->depth
+ 1) : 0;
1042 /* Check for scope depth overflow. Unlikely (2^28 == 268,435,456) but
1044 if (current_scope
&& scope
->depth
== 0)
1047 sorry ("GCC supports only %u nested scopes", scope
->depth
);
1050 current_scope
= scope
;
1051 keep_next_level_flag
= false;
1055 /* This is called when we are leaving SCOPE. For each label defined
1056 in SCOPE, add any appropriate decls to its decls_in_scope fields.
1057 These are the decls whose initialization will be skipped by a goto
1058 later in the function. */
1061 update_label_decls (struct c_scope
*scope
)
1068 if (s
->has_label_bindings
)
1070 struct c_binding
*b
;
1072 for (b
= s
->bindings
; b
!= NULL
; b
= b
->prev
)
1074 struct c_label_vars
*label_vars
;
1075 struct c_binding
*b1
;
1078 struct c_goto_bindings
*g
;
1080 if (TREE_CODE (b
->decl
) != LABEL_DECL
)
1082 label_vars
= b
->u
.label
;
1084 b1
= label_vars
->label_bindings
.bindings_in_scope
;
1085 if (label_vars
->label_bindings
.scope
== NULL
)
1088 hjud
= label_vars
->label_bindings
.scope
->has_jump_unsafe_decl
;
1089 if (update_spot_bindings (scope
, &label_vars
->label_bindings
))
1091 /* This label is defined in this scope. */
1094 for (; b1
!= NULL
; b1
= b1
->prev
)
1096 /* A goto from later in the function to this
1097 label will never see the initialization
1098 of B1, if any. Save it to issue a
1099 warning if needed. */
1100 if (decl_jump_unsafe (b1
->decl
))
1101 vec_safe_push(label_vars
->decls_in_scope
, b1
->decl
);
1106 /* Update the bindings of any goto statements associated
1108 FOR_EACH_VEC_SAFE_ELT (label_vars
->gotos
, ix
, g
)
1109 update_spot_bindings (scope
, &g
->goto_bindings
);
1113 /* Don't search beyond the current function. */
1114 if (s
== current_function_scope
)
1121 /* Set the TYPE_CONTEXT of all of TYPE's variants to CONTEXT. */
1124 set_type_context (tree type
, tree context
)
1126 for (type
= TYPE_MAIN_VARIANT (type
); type
;
1127 type
= TYPE_NEXT_VARIANT (type
))
1128 TYPE_CONTEXT (type
) = context
;
1131 /* Exit a scope. Restore the state of the identifier-decl mappings
1132 that were in effect when this scope was entered. Return a BLOCK
1133 node containing all the DECLs in this scope that are of interest
1134 to debug info generation. */
1139 struct c_scope
*scope
= current_scope
;
1140 tree block
, context
, p
;
1141 struct c_binding
*b
;
1143 bool functionbody
= scope
->function_body
;
1144 bool keep
= functionbody
|| scope
->keep
|| scope
->bindings
;
1146 update_label_decls (scope
);
1148 /* If appropriate, create a BLOCK to record the decls for the life
1149 of this function. */
1153 block
= make_node (BLOCK
);
1154 BLOCK_SUBBLOCKS (block
) = scope
->blocks
;
1155 TREE_USED (block
) = 1;
1157 /* In each subblock, record that this is its superior. */
1158 for (p
= scope
->blocks
; p
; p
= BLOCK_CHAIN (p
))
1159 BLOCK_SUPERCONTEXT (p
) = block
;
1161 BLOCK_VARS (block
) = NULL_TREE
;
1164 /* The TYPE_CONTEXTs for all of the tagged types belonging to this
1165 scope must be set so that they point to the appropriate
1166 construct, i.e. either to the current FUNCTION_DECL node, or
1167 else to the BLOCK node we just constructed.
1169 Note that for tagged types whose scope is just the formal
1170 parameter list for some function type specification, we can't
1171 properly set their TYPE_CONTEXTs here, because we don't have a
1172 pointer to the appropriate FUNCTION_TYPE node readily available
1173 to us. For those cases, the TYPE_CONTEXTs of the relevant tagged
1174 type nodes get set in `grokdeclarator' as soon as we have created
1175 the FUNCTION_TYPE node which will represent the "scope" for these
1176 "parameter list local" tagged types. */
1177 if (scope
->function_body
)
1178 context
= current_function_decl
;
1179 else if (scope
== file_scope
)
1182 = build_translation_unit_decl (get_identifier (main_input_filename
));
1183 context
= file_decl
;
1184 debug_hooks
->register_main_translation_unit (file_decl
);
1189 /* Clear all bindings in this scope. */
1190 for (b
= scope
->bindings
; b
; b
= free_binding_and_advance (b
))
1193 switch (TREE_CODE (p
))
1196 /* Warnings for unused labels, errors for undefined labels. */
1197 if (TREE_USED (p
) && !DECL_INITIAL (p
))
1199 error ("label %q+D used but not defined", p
);
1200 DECL_INITIAL (p
) = error_mark_node
;
1203 warn_for_unused_label (p
);
1205 /* Labels go in BLOCK_VARS. */
1206 DECL_CHAIN (p
) = BLOCK_VARS (block
);
1207 BLOCK_VARS (block
) = p
;
1208 gcc_assert (I_LABEL_BINDING (b
->id
) == b
);
1209 I_LABEL_BINDING (b
->id
) = b
->shadowed
;
1211 /* Also pop back to the shadowed label_vars. */
1212 release_tree_vector (b
->u
.label
->decls_in_scope
);
1213 b
->u
.label
= b
->u
.label
->shadowed
;
1219 set_type_context (p
, context
);
1221 /* Types may not have tag-names, in which case the type
1222 appears in the bindings list with b->id NULL. */
1225 gcc_assert (I_TAG_BINDING (b
->id
) == b
);
1226 I_TAG_BINDING (b
->id
) = b
->shadowed
;
1231 /* Propagate TREE_ADDRESSABLE from nested functions to their
1232 containing functions. */
1233 if (!TREE_ASM_WRITTEN (p
)
1234 && DECL_INITIAL (p
) != NULL_TREE
1235 && TREE_ADDRESSABLE (p
)
1236 && DECL_ABSTRACT_ORIGIN (p
) != NULL_TREE
1237 && DECL_ABSTRACT_ORIGIN (p
) != p
)
1238 TREE_ADDRESSABLE (DECL_ABSTRACT_ORIGIN (p
)) = 1;
1239 if (!DECL_EXTERNAL (p
)
1240 && !DECL_INITIAL (p
)
1241 && scope
!= file_scope
1242 && scope
!= external_scope
)
1244 error ("nested function %q+D declared but never defined", p
);
1245 undef_nested_function
= true;
1247 else if (DECL_DECLARED_INLINE_P (p
)
1249 && !DECL_INITIAL (p
))
1251 /* C99 6.7.4p6: "a function with external linkage... declared
1252 with an inline function specifier ... shall also be defined
1253 in the same translation unit." */
1254 if (!flag_gnu89_inline
1255 && !lookup_attribute ("gnu_inline", DECL_ATTRIBUTES (p
))
1256 && scope
!= external_scope
)
1257 pedwarn (input_location
, 0,
1258 "inline function %q+D declared but never defined", p
);
1259 DECL_EXTERNAL (p
) = 1;
1265 /* Warnings for unused variables. */
1266 if ((!TREE_USED (p
) || !DECL_READ_P (p
))
1267 && !TREE_NO_WARNING (p
)
1268 && !DECL_IN_SYSTEM_HEADER (p
)
1270 && !DECL_ARTIFICIAL (p
)
1271 && scope
!= file_scope
1272 && scope
!= external_scope
)
1275 warning (OPT_Wunused_variable
, "unused variable %q+D", p
);
1276 else if (DECL_CONTEXT (p
) == current_function_decl
)
1277 warning_at (DECL_SOURCE_LOCATION (p
),
1278 OPT_Wunused_but_set_variable
,
1279 "variable %qD set but not used", p
);
1284 error ("type of array %q+D completed incompatibly with"
1285 " implicit initialization", p
);
1292 /* All of these go in BLOCK_VARS, but only if this is the
1293 binding in the home scope. */
1296 DECL_CHAIN (p
) = BLOCK_VARS (block
);
1297 BLOCK_VARS (block
) = p
;
1299 else if (VAR_OR_FUNCTION_DECL_P (p
) && scope
!= file_scope
)
1301 /* For block local externs add a special
1302 DECL_EXTERNAL decl for debug info generation. */
1303 tree extp
= copy_node (p
);
1305 DECL_EXTERNAL (extp
) = 1;
1306 TREE_STATIC (extp
) = 0;
1307 TREE_PUBLIC (extp
) = 1;
1308 DECL_INITIAL (extp
) = NULL_TREE
;
1309 DECL_LANG_SPECIFIC (extp
) = NULL
;
1310 DECL_CONTEXT (extp
) = current_function_decl
;
1311 if (TREE_CODE (p
) == FUNCTION_DECL
)
1313 DECL_RESULT (extp
) = NULL_TREE
;
1314 DECL_SAVED_TREE (extp
) = NULL_TREE
;
1315 DECL_STRUCT_FUNCTION (extp
) = NULL
;
1317 if (b
->locus
!= UNKNOWN_LOCATION
)
1318 DECL_SOURCE_LOCATION (extp
) = b
->locus
;
1319 DECL_CHAIN (extp
) = BLOCK_VARS (block
);
1320 BLOCK_VARS (block
) = extp
;
1322 /* If this is the file scope set DECL_CONTEXT of each decl to
1323 the TRANSLATION_UNIT_DECL. This makes same_translation_unit_p
1325 if (scope
== file_scope
)
1327 DECL_CONTEXT (p
) = context
;
1328 if (TREE_CODE (p
) == TYPE_DECL
1329 && TREE_TYPE (p
) != error_mark_node
)
1330 set_type_context (TREE_TYPE (p
), context
);
1334 /* Parameters go in DECL_ARGUMENTS, not BLOCK_VARS, and have
1335 already been put there by store_parm_decls. Unused-
1336 parameter warnings are handled by function.c.
1337 error_mark_node obviously does not go in BLOCK_VARS and
1338 does not get unused-variable warnings. */
1341 /* It is possible for a decl not to have a name. We get
1342 here with b->id NULL in this case. */
1345 gcc_assert (I_SYMBOL_BINDING (b
->id
) == b
);
1346 I_SYMBOL_BINDING (b
->id
) = b
->shadowed
;
1347 if (b
->shadowed
&& b
->shadowed
->u
.type
)
1348 TREE_TYPE (b
->shadowed
->decl
) = b
->shadowed
->u
.type
;
1358 /* Dispose of the block that we just made inside some higher level. */
1359 if ((scope
->function_body
|| scope
== file_scope
) && context
)
1361 DECL_INITIAL (context
) = block
;
1362 BLOCK_SUPERCONTEXT (block
) = context
;
1364 else if (scope
->outer
)
1367 SCOPE_LIST_APPEND (scope
->outer
, blocks
, block
);
1368 /* If we did not make a block for the scope just exited, any
1369 blocks made for inner scopes must be carried forward so they
1370 will later become subblocks of something else. */
1371 else if (scope
->blocks
)
1372 SCOPE_LIST_CONCAT (scope
->outer
, blocks
, scope
, blocks
);
1375 /* Pop the current scope, and free the structure for reuse. */
1376 current_scope
= scope
->outer
;
1377 if (scope
->function_body
)
1378 current_function_scope
= scope
->outer_function
;
1380 memset (scope
, 0, sizeof (struct c_scope
));
1381 scope
->outer
= scope_freelist
;
1382 scope_freelist
= scope
;
1388 push_file_scope (void)
1396 file_scope
= current_scope
;
1398 start_fname_decls ();
1400 for (decl
= visible_builtins
; decl
; decl
= DECL_CHAIN (decl
))
1401 bind (DECL_NAME (decl
), decl
, file_scope
,
1402 /*invisible=*/false, /*nested=*/true, DECL_SOURCE_LOCATION (decl
));
1406 pop_file_scope (void)
1408 /* In case there were missing closebraces, get us back to the global
1410 while (current_scope
!= file_scope
)
1413 /* __FUNCTION__ is defined at file scope (""). This
1414 call may not be necessary as my tests indicate it
1415 still works without it. */
1416 finish_fname_decls ();
1418 check_inline_statics ();
1420 /* This is the point to write out a PCH if we're doing that.
1421 In that case we do not want to do anything else. */
1424 c_common_write_pch ();
1425 /* Ensure even the callers don't try to finalize the CU. */
1426 flag_syntax_only
= 1;
1430 /* Pop off the file scope and close this translation unit. */
1434 maybe_apply_pending_pragma_weaks ();
1437 /* Adjust the bindings for the start of a statement expression. */
1440 c_bindings_start_stmt_expr (struct c_spot_bindings
* switch_bindings
)
1442 struct c_scope
*scope
;
1444 for (scope
= current_scope
; scope
!= NULL
; scope
= scope
->outer
)
1446 struct c_binding
*b
;
1448 if (!scope
->has_label_bindings
)
1451 for (b
= scope
->bindings
; b
!= NULL
; b
= b
->prev
)
1453 struct c_label_vars
*label_vars
;
1455 struct c_goto_bindings
*g
;
1457 if (TREE_CODE (b
->decl
) != LABEL_DECL
)
1459 label_vars
= b
->u
.label
;
1460 ++label_vars
->label_bindings
.stmt_exprs
;
1461 FOR_EACH_VEC_SAFE_ELT (label_vars
->gotos
, ix
, g
)
1462 ++g
->goto_bindings
.stmt_exprs
;
1466 if (switch_bindings
!= NULL
)
1467 ++switch_bindings
->stmt_exprs
;
1470 /* Adjust the bindings for the end of a statement expression. */
1473 c_bindings_end_stmt_expr (struct c_spot_bindings
*switch_bindings
)
1475 struct c_scope
*scope
;
1477 for (scope
= current_scope
; scope
!= NULL
; scope
= scope
->outer
)
1479 struct c_binding
*b
;
1481 if (!scope
->has_label_bindings
)
1484 for (b
= scope
->bindings
; b
!= NULL
; b
= b
->prev
)
1486 struct c_label_vars
*label_vars
;
1488 struct c_goto_bindings
*g
;
1490 if (TREE_CODE (b
->decl
) != LABEL_DECL
)
1492 label_vars
= b
->u
.label
;
1493 --label_vars
->label_bindings
.stmt_exprs
;
1494 if (label_vars
->label_bindings
.stmt_exprs
< 0)
1496 label_vars
->label_bindings
.left_stmt_expr
= true;
1497 label_vars
->label_bindings
.stmt_exprs
= 0;
1499 FOR_EACH_VEC_SAFE_ELT (label_vars
->gotos
, ix
, g
)
1501 --g
->goto_bindings
.stmt_exprs
;
1502 if (g
->goto_bindings
.stmt_exprs
< 0)
1504 g
->goto_bindings
.left_stmt_expr
= true;
1505 g
->goto_bindings
.stmt_exprs
= 0;
1511 if (switch_bindings
!= NULL
)
1513 --switch_bindings
->stmt_exprs
;
1514 gcc_assert (switch_bindings
->stmt_exprs
>= 0);
1518 /* Push a definition or a declaration of struct, union or enum tag "name".
1519 "type" should be the type node.
1520 We assume that the tag "name" is not already defined, and has a location
1523 Note that the definition may really be just a forward reference.
1524 In that case, the TYPE_SIZE will be zero. */
1527 pushtag (location_t loc
, tree name
, tree type
)
1529 /* Record the identifier as the type's name if it has none. */
1530 if (name
&& !TYPE_NAME (type
))
1531 TYPE_NAME (type
) = name
;
1532 bind (name
, type
, current_scope
, /*invisible=*/false, /*nested=*/false, loc
);
1534 /* Create a fake NULL-named TYPE_DECL node whose TREE_TYPE will be the
1535 tagged type we just added to the current scope. This fake
1536 NULL-named TYPE_DECL node helps dwarfout.c to know when it needs
1537 to output a representation of a tagged type, and it also gives
1538 us a convenient place to record the "scope start" address for the
1541 TYPE_STUB_DECL (type
) = pushdecl (build_decl (loc
,
1542 TYPE_DECL
, NULL_TREE
, type
));
1544 /* An approximation for now, so we can tell this is a function-scope tag.
1545 This will be updated in pop_scope. */
1546 TYPE_CONTEXT (type
) = DECL_CONTEXT (TYPE_STUB_DECL (type
));
1548 if (warn_cxx_compat
&& name
!= NULL_TREE
)
1550 struct c_binding
*b
= I_SYMBOL_BINDING (name
);
1553 && b
->decl
!= NULL_TREE
1554 && TREE_CODE (b
->decl
) == TYPE_DECL
1555 && (B_IN_CURRENT_SCOPE (b
)
1556 || (current_scope
== file_scope
&& B_IN_EXTERNAL_SCOPE (b
)))
1557 && (TYPE_MAIN_VARIANT (TREE_TYPE (b
->decl
))
1558 != TYPE_MAIN_VARIANT (type
)))
1560 if (warning_at (loc
, OPT_Wc___compat
,
1561 ("using %qD as both a typedef and a tag is "
1562 "invalid in C++"), b
->decl
)
1563 && b
->locus
!= UNKNOWN_LOCATION
)
1564 inform (b
->locus
, "originally defined here");
1569 /* An exported interface to pushtag. This is used by the gdb plugin's
1570 binding oracle to introduce a new tag binding. */
1573 c_pushtag (location_t loc
, tree name
, tree type
)
1575 pushtag (loc
, name
, type
);
1578 /* An exported interface to bind a declaration. LOC is the location
1579 to use. DECL is the declaration to bind. The decl's name is used
1580 to determine how it is bound. If DECL is a VAR_DECL, then
1581 IS_GLOBAL determines whether the decl is put into the global (file
1582 and external) scope or the current function's scope; if DECL is not
1583 a VAR_DECL then it is always put into the file scope. */
1586 c_bind (location_t loc
, tree decl
, bool is_global
)
1588 struct c_scope
*scope
;
1589 bool nested
= false;
1591 if (!VAR_P (decl
) || current_function_scope
== NULL
)
1593 /* Types and functions are always considered to be global. */
1595 DECL_EXTERNAL (decl
) = 1;
1596 TREE_PUBLIC (decl
) = 1;
1600 /* Also bind it into the external scope. */
1601 bind (DECL_NAME (decl
), decl
, external_scope
, true, false, loc
);
1604 DECL_EXTERNAL (decl
) = 1;
1605 TREE_PUBLIC (decl
) = 1;
1609 DECL_CONTEXT (decl
) = current_function_decl
;
1610 TREE_PUBLIC (decl
) = 0;
1611 scope
= current_function_scope
;
1614 bind (DECL_NAME (decl
), decl
, scope
, false, nested
, loc
);
1617 /* Subroutine of compare_decls. Allow harmless mismatches in return
1618 and argument types provided that the type modes match. This function
1619 return a unified type given a suitable match, and 0 otherwise. */
1622 match_builtin_function_types (tree newtype
, tree oldtype
)
1624 tree newrettype
, oldrettype
;
1625 tree newargs
, oldargs
;
1626 tree trytype
, tryargs
;
1628 /* Accept the return type of the new declaration if same modes. */
1629 oldrettype
= TREE_TYPE (oldtype
);
1630 newrettype
= TREE_TYPE (newtype
);
1632 if (TYPE_MODE (oldrettype
) != TYPE_MODE (newrettype
))
1635 oldargs
= TYPE_ARG_TYPES (oldtype
);
1636 newargs
= TYPE_ARG_TYPES (newtype
);
1639 while (oldargs
|| newargs
)
1643 || !TREE_VALUE (oldargs
)
1644 || !TREE_VALUE (newargs
)
1645 || TYPE_MODE (TREE_VALUE (oldargs
))
1646 != TYPE_MODE (TREE_VALUE (newargs
)))
1649 oldargs
= TREE_CHAIN (oldargs
);
1650 newargs
= TREE_CHAIN (newargs
);
1653 trytype
= build_function_type (newrettype
, tryargs
);
1655 /* Allow declaration to change transaction_safe attribute. */
1656 tree oldattrs
= TYPE_ATTRIBUTES (oldtype
);
1657 tree oldtsafe
= lookup_attribute ("transaction_safe", oldattrs
);
1658 tree newattrs
= TYPE_ATTRIBUTES (newtype
);
1659 tree newtsafe
= lookup_attribute ("transaction_safe", newattrs
);
1660 if (oldtsafe
&& !newtsafe
)
1661 oldattrs
= remove_attribute ("transaction_safe", oldattrs
);
1662 else if (newtsafe
&& !oldtsafe
)
1663 oldattrs
= tree_cons (get_identifier ("transaction_safe"),
1664 NULL_TREE
, oldattrs
);
1666 return build_type_attribute_variant (trytype
, oldattrs
);
1669 /* Subroutine of diagnose_mismatched_decls. Check for function type
1670 mismatch involving an empty arglist vs a nonempty one and give clearer
1673 diagnose_arglist_conflict (tree newdecl
, tree olddecl
,
1674 tree newtype
, tree oldtype
)
1678 if (TREE_CODE (olddecl
) != FUNCTION_DECL
1679 || !comptypes (TREE_TYPE (oldtype
), TREE_TYPE (newtype
))
1680 || !((!prototype_p (oldtype
) && DECL_INITIAL (olddecl
) == NULL_TREE
)
1681 || (!prototype_p (newtype
) && DECL_INITIAL (newdecl
) == NULL_TREE
)))
1684 t
= TYPE_ARG_TYPES (oldtype
);
1686 t
= TYPE_ARG_TYPES (newtype
);
1687 for (; t
; t
= TREE_CHAIN (t
))
1689 tree type
= TREE_VALUE (t
);
1691 if (TREE_CHAIN (t
) == NULL_TREE
1692 && TYPE_MAIN_VARIANT (type
) != void_type_node
)
1694 inform (input_location
, "a parameter list with an ellipsis can%'t match "
1695 "an empty parameter name list declaration");
1699 if (c_type_promotes_to (type
) != type
)
1701 inform (input_location
, "an argument type that has a default promotion can%'t match "
1702 "an empty parameter name list declaration");
1708 /* Another subroutine of diagnose_mismatched_decls. OLDDECL is an
1709 old-style function definition, NEWDECL is a prototype declaration.
1710 Diagnose inconsistencies in the argument list. Returns TRUE if
1711 the prototype is compatible, FALSE if not. */
1713 validate_proto_after_old_defn (tree newdecl
, tree newtype
, tree oldtype
)
1715 tree newargs
, oldargs
;
1718 #define END_OF_ARGLIST(t) ((t) == void_type_node)
1720 oldargs
= TYPE_ACTUAL_ARG_TYPES (oldtype
);
1721 newargs
= TYPE_ARG_TYPES (newtype
);
1726 tree oldargtype
= TREE_VALUE (oldargs
);
1727 tree newargtype
= TREE_VALUE (newargs
);
1729 if (oldargtype
== error_mark_node
|| newargtype
== error_mark_node
)
1732 oldargtype
= (TYPE_ATOMIC (oldargtype
)
1733 ? c_build_qualified_type (TYPE_MAIN_VARIANT (oldargtype
),
1735 : TYPE_MAIN_VARIANT (oldargtype
));
1736 newargtype
= (TYPE_ATOMIC (newargtype
)
1737 ? c_build_qualified_type (TYPE_MAIN_VARIANT (newargtype
),
1739 : TYPE_MAIN_VARIANT (newargtype
));
1741 if (END_OF_ARGLIST (oldargtype
) && END_OF_ARGLIST (newargtype
))
1744 /* Reaching the end of just one list means the two decls don't
1745 agree on the number of arguments. */
1746 if (END_OF_ARGLIST (oldargtype
))
1748 error ("prototype for %q+D declares more arguments "
1749 "than previous old-style definition", newdecl
);
1752 else if (END_OF_ARGLIST (newargtype
))
1754 error ("prototype for %q+D declares fewer arguments "
1755 "than previous old-style definition", newdecl
);
1759 /* Type for passing arg must be consistent with that declared
1761 else if (!comptypes (oldargtype
, newargtype
))
1763 error ("prototype for %q+D declares argument %d"
1764 " with incompatible type",
1769 oldargs
= TREE_CHAIN (oldargs
);
1770 newargs
= TREE_CHAIN (newargs
);
1774 /* If we get here, no errors were found, but do issue a warning
1775 for this poor-style construct. */
1776 warning (0, "prototype for %q+D follows non-prototype definition",
1779 #undef END_OF_ARGLIST
1782 /* Subroutine of diagnose_mismatched_decls. Report the location of DECL,
1783 first in a pair of mismatched declarations, using the diagnostic
1786 locate_old_decl (tree decl
)
1788 if (TREE_CODE (decl
) == FUNCTION_DECL
&& DECL_BUILT_IN (decl
)
1789 && !C_DECL_DECLARED_BUILTIN (decl
))
1791 else if (DECL_INITIAL (decl
))
1792 inform (input_location
, "previous definition of %q+D was here", decl
);
1793 else if (C_DECL_IMPLICIT (decl
))
1794 inform (input_location
, "previous implicit declaration of %q+D was here", decl
);
1796 inform (input_location
, "previous declaration of %q+D was here", decl
);
1799 /* Subroutine of duplicate_decls. Compare NEWDECL to OLDDECL.
1800 Returns true if the caller should proceed to merge the two, false
1801 if OLDDECL should simply be discarded. As a side effect, issues
1802 all necessary diagnostics for invalid or poor-style combinations.
1803 If it returns true, writes the types of NEWDECL and OLDDECL to
1804 *NEWTYPEP and *OLDTYPEP - these may have been adjusted from
1805 TREE_TYPE (NEWDECL, OLDDECL) respectively. */
1808 diagnose_mismatched_decls (tree newdecl
, tree olddecl
,
1809 tree
*newtypep
, tree
*oldtypep
)
1811 tree newtype
, oldtype
;
1812 bool pedwarned
= false;
1813 bool warned
= false;
1816 #define DECL_EXTERN_INLINE(DECL) (DECL_DECLARED_INLINE_P (DECL) \
1817 && DECL_EXTERNAL (DECL))
1819 /* If we have error_mark_node for either decl or type, just discard
1820 the previous decl - we're in an error cascade already. */
1821 if (olddecl
== error_mark_node
|| newdecl
== error_mark_node
)
1823 *oldtypep
= oldtype
= TREE_TYPE (olddecl
);
1824 *newtypep
= newtype
= TREE_TYPE (newdecl
);
1825 if (oldtype
== error_mark_node
|| newtype
== error_mark_node
)
1828 /* Two different categories of symbol altogether. This is an error
1829 unless OLDDECL is a builtin. OLDDECL will be discarded in any case. */
1830 if (TREE_CODE (olddecl
) != TREE_CODE (newdecl
))
1832 if (!(TREE_CODE (olddecl
) == FUNCTION_DECL
1833 && DECL_BUILT_IN (olddecl
)
1834 && !C_DECL_DECLARED_BUILTIN (olddecl
)))
1836 error ("%q+D redeclared as different kind of symbol", newdecl
);
1837 locate_old_decl (olddecl
);
1839 else if (TREE_PUBLIC (newdecl
))
1840 warning (0, "built-in function %q+D declared as non-function",
1843 warning (OPT_Wshadow
, "declaration of %q+D shadows "
1844 "a built-in function", newdecl
);
1848 /* Enumerators have no linkage, so may only be declared once in a
1850 if (TREE_CODE (olddecl
) == CONST_DECL
)
1852 error ("redeclaration of enumerator %q+D", newdecl
);
1853 locate_old_decl (olddecl
);
1857 if (!comptypes (oldtype
, newtype
))
1859 if (TREE_CODE (olddecl
) == FUNCTION_DECL
1860 && DECL_BUILT_IN (olddecl
) && !C_DECL_DECLARED_BUILTIN (olddecl
))
1862 /* Accept harmless mismatch in function types.
1863 This is for the ffs and fprintf builtins. */
1864 tree trytype
= match_builtin_function_types (newtype
, oldtype
);
1866 if (trytype
&& comptypes (newtype
, trytype
))
1867 *oldtypep
= oldtype
= trytype
;
1870 /* If types don't match for a built-in, throw away the
1871 built-in. No point in calling locate_old_decl here, it
1872 won't print anything. */
1873 warning (OPT_Wbuiltin_declaration_mismatch
,
1874 "conflicting types for built-in function %q+D",
1879 else if (TREE_CODE (olddecl
) == FUNCTION_DECL
1880 && DECL_IS_BUILTIN (olddecl
))
1882 /* A conflicting function declaration for a predeclared
1883 function that isn't actually built in. Objective C uses
1884 these. The new declaration silently overrides everything
1885 but the volatility (i.e. noreturn) indication. See also
1886 below. FIXME: Make Objective C use normal builtins. */
1887 TREE_THIS_VOLATILE (newdecl
) |= TREE_THIS_VOLATILE (olddecl
);
1890 /* Permit void foo (...) to match int foo (...) if the latter is
1891 the definition and implicit int was used. See
1892 c-torture/compile/920625-2.c. */
1893 else if (TREE_CODE (newdecl
) == FUNCTION_DECL
&& DECL_INITIAL (newdecl
)
1894 && TYPE_MAIN_VARIANT (TREE_TYPE (oldtype
)) == void_type_node
1895 && TYPE_MAIN_VARIANT (TREE_TYPE (newtype
)) == integer_type_node
1896 && C_FUNCTION_IMPLICIT_INT (newdecl
) && !DECL_INITIAL (olddecl
))
1898 pedwarned
= pedwarn (input_location
, 0,
1899 "conflicting types for %q+D", newdecl
);
1900 /* Make sure we keep void as the return type. */
1901 TREE_TYPE (newdecl
) = *newtypep
= newtype
= oldtype
;
1902 C_FUNCTION_IMPLICIT_INT (newdecl
) = 0;
1904 /* Permit void foo (...) to match an earlier call to foo (...) with
1905 no declared type (thus, implicitly int). */
1906 else if (TREE_CODE (newdecl
) == FUNCTION_DECL
1907 && TYPE_MAIN_VARIANT (TREE_TYPE (newtype
)) == void_type_node
1908 && TYPE_MAIN_VARIANT (TREE_TYPE (oldtype
)) == integer_type_node
1909 && C_DECL_IMPLICIT (olddecl
) && !DECL_INITIAL (olddecl
))
1911 pedwarned
= pedwarn (input_location
, 0,
1912 "conflicting types for %q+D", newdecl
);
1913 /* Make sure we keep void as the return type. */
1914 TREE_TYPE (olddecl
) = *oldtypep
= oldtype
= newtype
;
1918 int new_quals
= TYPE_QUALS (newtype
);
1919 int old_quals
= TYPE_QUALS (oldtype
);
1921 if (new_quals
!= old_quals
)
1923 addr_space_t new_addr
= DECODE_QUAL_ADDR_SPACE (new_quals
);
1924 addr_space_t old_addr
= DECODE_QUAL_ADDR_SPACE (old_quals
);
1925 if (new_addr
!= old_addr
)
1927 if (ADDR_SPACE_GENERIC_P (new_addr
))
1928 error ("conflicting named address spaces (generic vs %s) "
1930 c_addr_space_name (old_addr
), newdecl
);
1931 else if (ADDR_SPACE_GENERIC_P (old_addr
))
1932 error ("conflicting named address spaces (%s vs generic) "
1934 c_addr_space_name (new_addr
), newdecl
);
1936 error ("conflicting named address spaces (%s vs %s) "
1938 c_addr_space_name (new_addr
),
1939 c_addr_space_name (old_addr
),
1943 if (CLEAR_QUAL_ADDR_SPACE (new_quals
)
1944 != CLEAR_QUAL_ADDR_SPACE (old_quals
))
1945 error ("conflicting type qualifiers for %q+D", newdecl
);
1948 error ("conflicting types for %q+D", newdecl
);
1949 diagnose_arglist_conflict (newdecl
, olddecl
, newtype
, oldtype
);
1950 locate_old_decl (olddecl
);
1955 /* Redeclaration of a type is a constraint violation (6.7.2.3p1),
1956 but silently ignore the redeclaration if either is in a system
1957 header. (Conflicting redeclarations were handled above.) This
1958 is allowed for C11 if the types are the same, not just
1960 if (TREE_CODE (newdecl
) == TYPE_DECL
)
1962 bool types_different
= false;
1963 int comptypes_result
;
1966 = comptypes_check_different_types (oldtype
, newtype
, &types_different
);
1968 if (comptypes_result
!= 1 || types_different
)
1970 error ("redefinition of typedef %q+D with different type", newdecl
);
1971 locate_old_decl (olddecl
);
1975 if (DECL_IN_SYSTEM_HEADER (newdecl
)
1976 || DECL_IN_SYSTEM_HEADER (olddecl
)
1977 || TREE_NO_WARNING (newdecl
)
1978 || TREE_NO_WARNING (olddecl
))
1979 return true; /* Allow OLDDECL to continue in use. */
1981 if (variably_modified_type_p (newtype
, NULL
))
1983 error ("redefinition of typedef %q+D with variably modified type",
1985 locate_old_decl (olddecl
);
1987 else if (pedwarn_c99 (input_location
, OPT_Wpedantic
,
1988 "redefinition of typedef %q+D", newdecl
))
1989 locate_old_decl (olddecl
);
1994 /* Function declarations can either be 'static' or 'extern' (no
1995 qualifier is equivalent to 'extern' - C99 6.2.2p5) and therefore
1996 can never conflict with each other on account of linkage
1997 (6.2.2p4). Multiple definitions are not allowed (6.9p3,5) but
1998 gnu89 mode permits two definitions if one is 'extern inline' and
1999 one is not. The non- extern-inline definition supersedes the
2000 extern-inline definition. */
2002 else if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
2004 /* If you declare a built-in function name as static, or
2005 define the built-in with an old-style definition (so we
2006 can't validate the argument list) the built-in definition is
2007 overridden, but optionally warn this was a bad choice of name. */
2008 if (DECL_BUILT_IN (olddecl
)
2009 && !C_DECL_DECLARED_BUILTIN (olddecl
)
2010 && (!TREE_PUBLIC (newdecl
)
2011 || (DECL_INITIAL (newdecl
)
2012 && !prototype_p (TREE_TYPE (newdecl
)))))
2014 warning (OPT_Wshadow
, "declaration of %q+D shadows "
2015 "a built-in function", newdecl
);
2016 /* Discard the old built-in function. */
2020 if (DECL_INITIAL (newdecl
))
2022 if (DECL_INITIAL (olddecl
))
2024 /* If both decls are in the same TU and the new declaration
2025 isn't overriding an extern inline reject the new decl.
2026 In c99, no overriding is allowed in the same translation
2028 if ((!DECL_EXTERN_INLINE (olddecl
)
2029 || DECL_EXTERN_INLINE (newdecl
)
2030 || (!flag_gnu89_inline
2031 && (!DECL_DECLARED_INLINE_P (olddecl
)
2032 || !lookup_attribute ("gnu_inline",
2033 DECL_ATTRIBUTES (olddecl
)))
2034 && (!DECL_DECLARED_INLINE_P (newdecl
)
2035 || !lookup_attribute ("gnu_inline",
2036 DECL_ATTRIBUTES (newdecl
))))
2038 && same_translation_unit_p (newdecl
, olddecl
))
2040 error ("redefinition of %q+D", newdecl
);
2041 locate_old_decl (olddecl
);
2046 /* If we have a prototype after an old-style function definition,
2047 the argument types must be checked specially. */
2048 else if (DECL_INITIAL (olddecl
)
2049 && !prototype_p (oldtype
) && prototype_p (newtype
)
2050 && TYPE_ACTUAL_ARG_TYPES (oldtype
)
2051 && !validate_proto_after_old_defn (newdecl
, newtype
, oldtype
))
2053 locate_old_decl (olddecl
);
2056 /* A non-static declaration (even an "extern") followed by a
2057 static declaration is undefined behavior per C99 6.2.2p3-5,7.
2058 The same is true for a static forward declaration at block
2059 scope followed by a non-static declaration/definition at file
2060 scope. Static followed by non-static at the same scope is
2061 not undefined behavior, and is the most convenient way to get
2062 some effects (see e.g. what unwind-dw2-fde-glibc.c does to
2063 the definition of _Unwind_Find_FDE in unwind-dw2-fde.c), but
2064 we do diagnose it if -Wtraditional. */
2065 if (TREE_PUBLIC (olddecl
) && !TREE_PUBLIC (newdecl
))
2067 /* Two exceptions to the rule. If olddecl is an extern
2068 inline, or a predeclared function that isn't actually
2069 built in, newdecl silently overrides olddecl. The latter
2070 occur only in Objective C; see also above. (FIXME: Make
2071 Objective C use normal builtins.) */
2072 if (!DECL_IS_BUILTIN (olddecl
)
2073 && !DECL_EXTERN_INLINE (olddecl
))
2075 error ("static declaration of %q+D follows "
2076 "non-static declaration", newdecl
);
2077 locate_old_decl (olddecl
);
2081 else if (TREE_PUBLIC (newdecl
) && !TREE_PUBLIC (olddecl
))
2083 if (DECL_CONTEXT (olddecl
))
2085 error ("non-static declaration of %q+D follows "
2086 "static declaration", newdecl
);
2087 locate_old_decl (olddecl
);
2090 else if (warn_traditional
)
2092 warned
|= warning (OPT_Wtraditional
,
2093 "non-static declaration of %q+D "
2094 "follows static declaration", newdecl
);
2098 /* Make sure gnu_inline attribute is either not present, or
2099 present on all inline decls. */
2100 if (DECL_DECLARED_INLINE_P (olddecl
)
2101 && DECL_DECLARED_INLINE_P (newdecl
))
2103 bool newa
= lookup_attribute ("gnu_inline",
2104 DECL_ATTRIBUTES (newdecl
)) != NULL
;
2105 bool olda
= lookup_attribute ("gnu_inline",
2106 DECL_ATTRIBUTES (olddecl
)) != NULL
;
2109 error_at (input_location
, "%<gnu_inline%> attribute present on %q+D",
2110 newa
? newdecl
: olddecl
);
2111 error_at (DECL_SOURCE_LOCATION (newa
? olddecl
: newdecl
),
2116 else if (VAR_P (newdecl
))
2118 /* Only variables can be thread-local, and all declarations must
2119 agree on this property. */
2120 if (C_DECL_THREADPRIVATE_P (olddecl
) && !DECL_THREAD_LOCAL_P (newdecl
))
2122 /* Nothing to check. Since OLDDECL is marked threadprivate
2123 and NEWDECL does not have a thread-local attribute, we
2124 will merge the threadprivate attribute into NEWDECL. */
2127 else if (DECL_THREAD_LOCAL_P (newdecl
) != DECL_THREAD_LOCAL_P (olddecl
))
2129 if (DECL_THREAD_LOCAL_P (newdecl
))
2130 error ("thread-local declaration of %q+D follows "
2131 "non-thread-local declaration", newdecl
);
2133 error ("non-thread-local declaration of %q+D follows "
2134 "thread-local declaration", newdecl
);
2136 locate_old_decl (olddecl
);
2140 /* Multiple initialized definitions are not allowed (6.9p3,5). */
2141 if (DECL_INITIAL (newdecl
) && DECL_INITIAL (olddecl
))
2143 error ("redefinition of %q+D", newdecl
);
2144 locate_old_decl (olddecl
);
2148 /* Objects declared at file scope: if the first declaration had
2149 external linkage (even if it was an external reference) the
2150 second must have external linkage as well, or the behavior is
2151 undefined. If the first declaration had internal linkage, then
2152 the second must too, or else be an external reference (in which
2153 case the composite declaration still has internal linkage).
2154 As for function declarations, we warn about the static-then-
2155 extern case only for -Wtraditional. See generally 6.2.2p3-5,7. */
2156 if (DECL_FILE_SCOPE_P (newdecl
)
2157 && TREE_PUBLIC (newdecl
) != TREE_PUBLIC (olddecl
))
2159 if (DECL_EXTERNAL (newdecl
))
2161 if (!DECL_FILE_SCOPE_P (olddecl
))
2163 error ("extern declaration of %q+D follows "
2164 "declaration with no linkage", newdecl
);
2165 locate_old_decl (olddecl
);
2168 else if (warn_traditional
)
2170 warned
|= warning (OPT_Wtraditional
,
2171 "non-static declaration of %q+D "
2172 "follows static declaration", newdecl
);
2177 if (TREE_PUBLIC (newdecl
))
2178 error ("non-static declaration of %q+D follows "
2179 "static declaration", newdecl
);
2181 error ("static declaration of %q+D follows "
2182 "non-static declaration", newdecl
);
2184 locate_old_decl (olddecl
);
2188 /* Two objects with the same name declared at the same block
2189 scope must both be external references (6.7p3). */
2190 else if (!DECL_FILE_SCOPE_P (newdecl
))
2192 if (DECL_EXTERNAL (newdecl
))
2194 /* Extern with initializer at block scope, which will
2195 already have received an error. */
2197 else if (DECL_EXTERNAL (olddecl
))
2199 error ("declaration of %q+D with no linkage follows "
2200 "extern declaration", newdecl
);
2201 locate_old_decl (olddecl
);
2205 error ("redeclaration of %q+D with no linkage", newdecl
);
2206 locate_old_decl (olddecl
);
2212 /* C++ does not permit a decl to appear multiple times at file
2215 && DECL_FILE_SCOPE_P (newdecl
)
2216 && !DECL_EXTERNAL (newdecl
)
2217 && !DECL_EXTERNAL (olddecl
))
2218 warned
|= warning_at (DECL_SOURCE_LOCATION (newdecl
),
2220 ("duplicate declaration of %qD is "
2226 /* All decls must agree on a visibility. */
2227 if (CODE_CONTAINS_STRUCT (TREE_CODE (newdecl
), TS_DECL_WITH_VIS
)
2228 && DECL_VISIBILITY_SPECIFIED (newdecl
) && DECL_VISIBILITY_SPECIFIED (olddecl
)
2229 && DECL_VISIBILITY (newdecl
) != DECL_VISIBILITY (olddecl
))
2231 warned
|= warning (0, "redeclaration of %q+D with different visibility "
2232 "(old visibility preserved)", newdecl
);
2235 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
2236 warned
|= diagnose_mismatched_attributes (olddecl
, newdecl
);
2237 else /* PARM_DECL, VAR_DECL */
2239 /* Redeclaration of a parameter is a constraint violation (this is
2240 not explicitly stated, but follows from C99 6.7p3 [no more than
2241 one declaration of the same identifier with no linkage in the
2242 same scope, except type tags] and 6.2.2p6 [parameters have no
2243 linkage]). We must check for a forward parameter declaration,
2244 indicated by TREE_ASM_WRITTEN on the old declaration - this is
2245 an extension, the mandatory diagnostic for which is handled by
2246 mark_forward_parm_decls. */
2248 if (TREE_CODE (newdecl
) == PARM_DECL
2249 && (!TREE_ASM_WRITTEN (olddecl
) || TREE_ASM_WRITTEN (newdecl
)))
2251 error ("redefinition of parameter %q+D", newdecl
);
2252 locate_old_decl (olddecl
);
2257 /* Optional warning for completely redundant decls. */
2258 if (!warned
&& !pedwarned
2259 && warn_redundant_decls
2260 /* Don't warn about a function declaration followed by a
2262 && !(TREE_CODE (newdecl
) == FUNCTION_DECL
2263 && DECL_INITIAL (newdecl
) && !DECL_INITIAL (olddecl
))
2264 /* Don't warn about redundant redeclarations of builtins. */
2265 && !(TREE_CODE (newdecl
) == FUNCTION_DECL
2266 && !DECL_BUILT_IN (newdecl
)
2267 && DECL_BUILT_IN (olddecl
)
2268 && !C_DECL_DECLARED_BUILTIN (olddecl
))
2269 /* Don't warn about an extern followed by a definition. */
2270 && !(DECL_EXTERNAL (olddecl
) && !DECL_EXTERNAL (newdecl
))
2271 /* Don't warn about forward parameter decls. */
2272 && !(TREE_CODE (newdecl
) == PARM_DECL
2273 && TREE_ASM_WRITTEN (olddecl
) && !TREE_ASM_WRITTEN (newdecl
))
2274 /* Don't warn about a variable definition following a declaration. */
2275 && !(VAR_P (newdecl
)
2276 && DECL_INITIAL (newdecl
) && !DECL_INITIAL (olddecl
)))
2278 warned
= warning (OPT_Wredundant_decls
, "redundant redeclaration of %q+D",
2282 /* Report location of previous decl/defn. */
2283 if (warned
|| pedwarned
)
2284 locate_old_decl (olddecl
);
2286 #undef DECL_EXTERN_INLINE
2291 /* Subroutine of duplicate_decls. NEWDECL has been found to be
2292 consistent with OLDDECL, but carries new information. Merge the
2293 new information into OLDDECL. This function issues no
2297 merge_decls (tree newdecl
, tree olddecl
, tree newtype
, tree oldtype
)
2299 bool new_is_definition
= (TREE_CODE (newdecl
) == FUNCTION_DECL
2300 && DECL_INITIAL (newdecl
) != NULL_TREE
);
2301 bool new_is_prototype
= (TREE_CODE (newdecl
) == FUNCTION_DECL
2302 && prototype_p (TREE_TYPE (newdecl
)));
2303 bool old_is_prototype
= (TREE_CODE (olddecl
) == FUNCTION_DECL
2304 && prototype_p (TREE_TYPE (olddecl
)));
2306 /* For real parm decl following a forward decl, rechain the old decl
2307 in its new location and clear TREE_ASM_WRITTEN (it's not a
2308 forward decl anymore). */
2309 if (TREE_CODE (newdecl
) == PARM_DECL
2310 && TREE_ASM_WRITTEN (olddecl
) && !TREE_ASM_WRITTEN (newdecl
))
2312 struct c_binding
*b
, **here
;
2314 for (here
= ¤t_scope
->bindings
; *here
; here
= &(*here
)->prev
)
2315 if ((*here
)->decl
== olddecl
)
2322 b
->prev
= current_scope
->bindings
;
2323 current_scope
->bindings
= b
;
2325 TREE_ASM_WRITTEN (olddecl
) = 0;
2328 DECL_ATTRIBUTES (newdecl
)
2329 = targetm
.merge_decl_attributes (olddecl
, newdecl
);
2331 /* For typedefs use the old type, as the new type's DECL_NAME points
2332 at newdecl, which will be ggc_freed. */
2333 if (TREE_CODE (newdecl
) == TYPE_DECL
)
2335 /* But NEWTYPE might have an attribute, honor that. */
2339 if (TYPE_USER_ALIGN (tem
))
2341 if (TYPE_ALIGN (tem
) > TYPE_ALIGN (newtype
))
2342 SET_TYPE_ALIGN (newtype
, TYPE_ALIGN (tem
));
2343 TYPE_USER_ALIGN (newtype
) = true;
2346 /* And remove the new type from the variants list. */
2347 if (TYPE_NAME (TREE_TYPE (newdecl
)) == newdecl
)
2349 tree remove
= TREE_TYPE (newdecl
);
2350 for (tree t
= TYPE_MAIN_VARIANT (remove
); ;
2351 t
= TYPE_NEXT_VARIANT (t
))
2352 if (TYPE_NEXT_VARIANT (t
) == remove
)
2354 TYPE_NEXT_VARIANT (t
) = TYPE_NEXT_VARIANT (remove
);
2360 /* Merge the data types specified in the two decls. */
2362 = TREE_TYPE (olddecl
)
2363 = composite_type (newtype
, oldtype
);
2365 /* Lay the type out, unless already done. */
2366 if (!comptypes (oldtype
, TREE_TYPE (newdecl
)))
2368 if (TREE_TYPE (newdecl
) != error_mark_node
)
2369 layout_type (TREE_TYPE (newdecl
));
2370 if (TREE_CODE (newdecl
) != FUNCTION_DECL
2371 && TREE_CODE (newdecl
) != TYPE_DECL
2372 && TREE_CODE (newdecl
) != CONST_DECL
)
2373 layout_decl (newdecl
, 0);
2377 /* Since the type is OLDDECL's, make OLDDECL's size go with. */
2378 DECL_SIZE (newdecl
) = DECL_SIZE (olddecl
);
2379 DECL_SIZE_UNIT (newdecl
) = DECL_SIZE_UNIT (olddecl
);
2380 SET_DECL_MODE (newdecl
, DECL_MODE (olddecl
));
2381 if (DECL_ALIGN (olddecl
) > DECL_ALIGN (newdecl
))
2383 SET_DECL_ALIGN (newdecl
, DECL_ALIGN (olddecl
));
2384 DECL_USER_ALIGN (newdecl
) |= DECL_USER_ALIGN (olddecl
);
2388 /* Keep the old rtl since we can safely use it. */
2389 if (HAS_RTL_P (olddecl
))
2390 COPY_DECL_RTL (olddecl
, newdecl
);
2392 /* Merge the type qualifiers. */
2393 if (TREE_READONLY (newdecl
))
2394 TREE_READONLY (olddecl
) = 1;
2396 if (TREE_THIS_VOLATILE (newdecl
))
2397 TREE_THIS_VOLATILE (olddecl
) = 1;
2399 /* Merge deprecatedness. */
2400 if (TREE_DEPRECATED (newdecl
))
2401 TREE_DEPRECATED (olddecl
) = 1;
2403 /* If a decl is in a system header and the other isn't, keep the one on the
2404 system header. Otherwise, keep source location of definition rather than
2405 declaration and of prototype rather than non-prototype unless that
2406 prototype is built-in. */
2407 if (CODE_CONTAINS_STRUCT (TREE_CODE (olddecl
), TS_DECL_WITH_VIS
)
2408 && DECL_IN_SYSTEM_HEADER (olddecl
)
2409 && !DECL_IN_SYSTEM_HEADER (newdecl
) )
2410 DECL_SOURCE_LOCATION (newdecl
) = DECL_SOURCE_LOCATION (olddecl
);
2411 else if (CODE_CONTAINS_STRUCT (TREE_CODE (olddecl
), TS_DECL_WITH_VIS
)
2412 && DECL_IN_SYSTEM_HEADER (newdecl
)
2413 && !DECL_IN_SYSTEM_HEADER (olddecl
))
2414 DECL_SOURCE_LOCATION (olddecl
) = DECL_SOURCE_LOCATION (newdecl
);
2415 else if ((DECL_INITIAL (newdecl
) == NULL_TREE
2416 && DECL_INITIAL (olddecl
) != NULL_TREE
)
2417 || (old_is_prototype
&& !new_is_prototype
2418 && !C_DECL_BUILTIN_PROTOTYPE (olddecl
)))
2419 DECL_SOURCE_LOCATION (newdecl
) = DECL_SOURCE_LOCATION (olddecl
);
2421 /* Merge the initialization information. */
2422 if (DECL_INITIAL (newdecl
) == NULL_TREE
)
2423 DECL_INITIAL (newdecl
) = DECL_INITIAL (olddecl
);
2425 /* Merge the threadprivate attribute. */
2426 if (VAR_P (olddecl
) && C_DECL_THREADPRIVATE_P (olddecl
))
2427 C_DECL_THREADPRIVATE_P (newdecl
) = 1;
2429 if (CODE_CONTAINS_STRUCT (TREE_CODE (olddecl
), TS_DECL_WITH_VIS
))
2431 /* Copy the assembler name.
2432 Currently, it can only be defined in the prototype. */
2433 COPY_DECL_ASSEMBLER_NAME (olddecl
, newdecl
);
2435 /* Use visibility of whichever declaration had it specified */
2436 if (DECL_VISIBILITY_SPECIFIED (olddecl
))
2438 DECL_VISIBILITY (newdecl
) = DECL_VISIBILITY (olddecl
);
2439 DECL_VISIBILITY_SPECIFIED (newdecl
) = 1;
2442 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
2444 DECL_STATIC_CONSTRUCTOR(newdecl
) |= DECL_STATIC_CONSTRUCTOR(olddecl
);
2445 DECL_STATIC_DESTRUCTOR (newdecl
) |= DECL_STATIC_DESTRUCTOR (olddecl
);
2446 DECL_NO_LIMIT_STACK (newdecl
) |= DECL_NO_LIMIT_STACK (olddecl
);
2447 DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (newdecl
)
2448 |= DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (olddecl
);
2449 TREE_THIS_VOLATILE (newdecl
) |= TREE_THIS_VOLATILE (olddecl
);
2450 DECL_IS_MALLOC (newdecl
) |= DECL_IS_MALLOC (olddecl
);
2451 DECL_IS_OPERATOR_NEW (newdecl
) |= DECL_IS_OPERATOR_NEW (olddecl
);
2452 TREE_READONLY (newdecl
) |= TREE_READONLY (olddecl
);
2453 DECL_PURE_P (newdecl
) |= DECL_PURE_P (olddecl
);
2454 DECL_IS_NOVOPS (newdecl
) |= DECL_IS_NOVOPS (olddecl
);
2457 /* Merge the storage class information. */
2458 merge_weak (newdecl
, olddecl
);
2460 /* For functions, static overrides non-static. */
2461 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
2463 TREE_PUBLIC (newdecl
) &= TREE_PUBLIC (olddecl
);
2464 /* This is since we don't automatically
2465 copy the attributes of NEWDECL into OLDDECL. */
2466 TREE_PUBLIC (olddecl
) = TREE_PUBLIC (newdecl
);
2467 /* If this clears `static', clear it in the identifier too. */
2468 if (!TREE_PUBLIC (olddecl
))
2469 TREE_PUBLIC (DECL_NAME (olddecl
)) = 0;
2473 /* In c99, 'extern' declaration before (or after) 'inline' means this
2474 function is not DECL_EXTERNAL, unless 'gnu_inline' attribute
2476 if (TREE_CODE (newdecl
) == FUNCTION_DECL
2477 && !flag_gnu89_inline
2478 && (DECL_DECLARED_INLINE_P (newdecl
)
2479 || DECL_DECLARED_INLINE_P (olddecl
))
2480 && (!DECL_DECLARED_INLINE_P (newdecl
)
2481 || !DECL_DECLARED_INLINE_P (olddecl
)
2482 || !DECL_EXTERNAL (olddecl
))
2483 && DECL_EXTERNAL (newdecl
)
2484 && !lookup_attribute ("gnu_inline", DECL_ATTRIBUTES (newdecl
))
2485 && !current_function_decl
)
2486 DECL_EXTERNAL (newdecl
) = 0;
2488 /* An inline definition following a static declaration is not
2490 if (new_is_definition
2491 && (DECL_DECLARED_INLINE_P (newdecl
)
2492 || DECL_DECLARED_INLINE_P (olddecl
))
2493 && !TREE_PUBLIC (olddecl
))
2494 DECL_EXTERNAL (newdecl
) = 0;
2496 if (DECL_EXTERNAL (newdecl
))
2498 TREE_STATIC (newdecl
) = TREE_STATIC (olddecl
);
2499 DECL_EXTERNAL (newdecl
) = DECL_EXTERNAL (olddecl
);
2501 /* An extern decl does not override previous storage class. */
2502 TREE_PUBLIC (newdecl
) = TREE_PUBLIC (olddecl
);
2503 if (!DECL_EXTERNAL (newdecl
))
2505 DECL_CONTEXT (newdecl
) = DECL_CONTEXT (olddecl
);
2506 DECL_COMMON (newdecl
) = DECL_COMMON (olddecl
);
2511 TREE_STATIC (olddecl
) = TREE_STATIC (newdecl
);
2512 TREE_PUBLIC (olddecl
) = TREE_PUBLIC (newdecl
);
2515 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
2517 /* If we're redefining a function previously defined as extern
2518 inline, make sure we emit debug info for the inline before we
2519 throw it away, in case it was inlined into a function that
2520 hasn't been written out yet. */
2521 if (new_is_definition
&& DECL_INITIAL (olddecl
))
2522 /* The new defn must not be inline. */
2523 DECL_UNINLINABLE (newdecl
) = 1;
2526 /* If either decl says `inline', this fn is inline, unless
2527 its definition was passed already. */
2528 if (DECL_DECLARED_INLINE_P (newdecl
)
2529 || DECL_DECLARED_INLINE_P (olddecl
))
2530 DECL_DECLARED_INLINE_P (newdecl
) = 1;
2532 DECL_UNINLINABLE (newdecl
) = DECL_UNINLINABLE (olddecl
)
2533 = (DECL_UNINLINABLE (newdecl
) || DECL_UNINLINABLE (olddecl
));
2535 DECL_DISREGARD_INLINE_LIMITS (newdecl
)
2536 = DECL_DISREGARD_INLINE_LIMITS (olddecl
)
2537 = (DECL_DISREGARD_INLINE_LIMITS (newdecl
)
2538 || DECL_DISREGARD_INLINE_LIMITS (olddecl
));
2541 if (DECL_BUILT_IN (olddecl
))
2543 /* If redeclaring a builtin function, it stays built in.
2544 But it gets tagged as having been declared. */
2545 DECL_BUILT_IN_CLASS (newdecl
) = DECL_BUILT_IN_CLASS (olddecl
);
2546 DECL_FUNCTION_CODE (newdecl
) = DECL_FUNCTION_CODE (olddecl
);
2547 C_DECL_DECLARED_BUILTIN (newdecl
) = 1;
2548 if (new_is_prototype
)
2550 C_DECL_BUILTIN_PROTOTYPE (newdecl
) = 0;
2551 if (DECL_BUILT_IN_CLASS (newdecl
) == BUILT_IN_NORMAL
)
2553 enum built_in_function fncode
= DECL_FUNCTION_CODE (newdecl
);
2556 /* If a compatible prototype of these builtin functions
2557 is seen, assume the runtime implements it with the
2558 expected semantics. */
2559 case BUILT_IN_STPCPY
:
2560 if (builtin_decl_explicit_p (fncode
))
2561 set_builtin_decl_implicit_p (fncode
, true);
2564 if (builtin_decl_explicit_p (fncode
))
2565 set_builtin_decl_declared_p (fncode
, true);
2571 C_DECL_BUILTIN_PROTOTYPE (newdecl
)
2572 = C_DECL_BUILTIN_PROTOTYPE (olddecl
);
2575 /* Preserve function specific target and optimization options */
2576 if (DECL_FUNCTION_SPECIFIC_TARGET (olddecl
)
2577 && !DECL_FUNCTION_SPECIFIC_TARGET (newdecl
))
2578 DECL_FUNCTION_SPECIFIC_TARGET (newdecl
)
2579 = DECL_FUNCTION_SPECIFIC_TARGET (olddecl
);
2581 if (DECL_FUNCTION_SPECIFIC_OPTIMIZATION (olddecl
)
2582 && !DECL_FUNCTION_SPECIFIC_OPTIMIZATION (newdecl
))
2583 DECL_FUNCTION_SPECIFIC_OPTIMIZATION (newdecl
)
2584 = DECL_FUNCTION_SPECIFIC_OPTIMIZATION (olddecl
);
2586 /* Also preserve various other info from the definition. */
2587 if (!new_is_definition
)
2590 DECL_RESULT (newdecl
) = DECL_RESULT (olddecl
);
2591 DECL_INITIAL (newdecl
) = DECL_INITIAL (olddecl
);
2592 DECL_STRUCT_FUNCTION (newdecl
) = DECL_STRUCT_FUNCTION (olddecl
);
2593 DECL_SAVED_TREE (newdecl
) = DECL_SAVED_TREE (olddecl
);
2594 DECL_ARGUMENTS (newdecl
) = copy_list (DECL_ARGUMENTS (olddecl
));
2595 for (t
= DECL_ARGUMENTS (newdecl
); t
; t
= DECL_CHAIN (t
))
2596 DECL_CONTEXT (t
) = newdecl
;
2598 /* See if we've got a function to instantiate from. */
2599 if (DECL_SAVED_TREE (olddecl
))
2600 DECL_ABSTRACT_ORIGIN (newdecl
)
2601 = DECL_ABSTRACT_ORIGIN (olddecl
);
2605 /* Merge the USED information. */
2606 if (TREE_USED (olddecl
))
2607 TREE_USED (newdecl
) = 1;
2608 else if (TREE_USED (newdecl
))
2609 TREE_USED (olddecl
) = 1;
2610 if (VAR_P (olddecl
) || TREE_CODE (olddecl
) == PARM_DECL
)
2611 DECL_READ_P (newdecl
) |= DECL_READ_P (olddecl
);
2612 if (DECL_PRESERVE_P (olddecl
))
2613 DECL_PRESERVE_P (newdecl
) = 1;
2614 else if (DECL_PRESERVE_P (newdecl
))
2615 DECL_PRESERVE_P (olddecl
) = 1;
2617 /* Merge DECL_COMMON */
2618 if (VAR_P (olddecl
) && VAR_P (newdecl
)
2619 && !lookup_attribute ("common", DECL_ATTRIBUTES (newdecl
))
2620 && !lookup_attribute ("nocommon", DECL_ATTRIBUTES (newdecl
)))
2621 DECL_COMMON (newdecl
) = DECL_COMMON (newdecl
) && DECL_COMMON (olddecl
);
2623 /* Copy most of the decl-specific fields of NEWDECL into OLDDECL.
2624 But preserve OLDDECL's DECL_UID, DECL_CONTEXT and
2625 DECL_ARGUMENTS (if appropriate). */
2627 unsigned olddecl_uid
= DECL_UID (olddecl
);
2628 tree olddecl_context
= DECL_CONTEXT (olddecl
);
2629 tree olddecl_arguments
= NULL
;
2630 if (TREE_CODE (olddecl
) == FUNCTION_DECL
)
2631 olddecl_arguments
= DECL_ARGUMENTS (olddecl
);
2633 memcpy ((char *) olddecl
+ sizeof (struct tree_common
),
2634 (char *) newdecl
+ sizeof (struct tree_common
),
2635 sizeof (struct tree_decl_common
) - sizeof (struct tree_common
));
2636 DECL_USER_ALIGN (olddecl
) = DECL_USER_ALIGN (newdecl
);
2637 switch (TREE_CODE (olddecl
))
2642 struct symtab_node
*snode
= olddecl
->decl_with_vis
.symtab_node
;
2644 memcpy ((char *) olddecl
+ sizeof (struct tree_decl_common
),
2645 (char *) newdecl
+ sizeof (struct tree_decl_common
),
2646 tree_code_size (TREE_CODE (olddecl
)) - sizeof (struct tree_decl_common
));
2647 olddecl
->decl_with_vis
.symtab_node
= snode
;
2649 if ((DECL_EXTERNAL (olddecl
)
2650 || TREE_PUBLIC (olddecl
)
2651 || TREE_STATIC (olddecl
))
2652 && DECL_SECTION_NAME (newdecl
) != NULL
)
2653 set_decl_section_name (olddecl
, DECL_SECTION_NAME (newdecl
));
2655 /* This isn't quite correct for something like
2656 int __thread x attribute ((tls_model ("local-exec")));
2657 extern int __thread x;
2658 as we'll lose the "local-exec" model. */
2659 if (VAR_P (olddecl
) && DECL_THREAD_LOCAL_P (newdecl
))
2660 set_decl_tls_model (olddecl
, DECL_TLS_MODEL (newdecl
));
2670 memcpy ((char *) olddecl
+ sizeof (struct tree_decl_common
),
2671 (char *) newdecl
+ sizeof (struct tree_decl_common
),
2672 tree_code_size (TREE_CODE (olddecl
)) - sizeof (struct tree_decl_common
));
2677 memcpy ((char *) olddecl
+ sizeof (struct tree_decl_common
),
2678 (char *) newdecl
+ sizeof (struct tree_decl_common
),
2679 sizeof (struct tree_decl_non_common
) - sizeof (struct tree_decl_common
));
2681 DECL_UID (olddecl
) = olddecl_uid
;
2682 DECL_CONTEXT (olddecl
) = olddecl_context
;
2683 if (TREE_CODE (olddecl
) == FUNCTION_DECL
)
2684 DECL_ARGUMENTS (olddecl
) = olddecl_arguments
;
2687 /* If OLDDECL had its DECL_RTL instantiated, re-invoke make_decl_rtl
2688 so that encode_section_info has a chance to look at the new decl
2689 flags and attributes. */
2690 if (DECL_RTL_SET_P (olddecl
)
2691 && (TREE_CODE (olddecl
) == FUNCTION_DECL
2692 || (VAR_P (olddecl
) && TREE_STATIC (olddecl
))))
2693 make_decl_rtl (olddecl
);
2696 /* Handle when a new declaration NEWDECL has the same name as an old
2697 one OLDDECL in the same binding contour. Prints an error message
2700 If safely possible, alter OLDDECL to look like NEWDECL, and return
2701 true. Otherwise, return false. */
2704 duplicate_decls (tree newdecl
, tree olddecl
)
2706 tree newtype
= NULL
, oldtype
= NULL
;
2708 if (!diagnose_mismatched_decls (newdecl
, olddecl
, &newtype
, &oldtype
))
2710 /* Avoid `unused variable' and other warnings for OLDDECL. */
2711 TREE_NO_WARNING (olddecl
) = 1;
2715 merge_decls (newdecl
, olddecl
, newtype
, oldtype
);
2717 /* The NEWDECL will no longer be needed.
2719 Before releasing the node, be sure to remove function from symbol
2720 table that might have been inserted there to record comdat group.
2721 Be sure to however do not free DECL_STRUCT_FUNCTION because this
2722 structure is shared in between NEWDECL and OLDECL. */
2723 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
2724 DECL_STRUCT_FUNCTION (newdecl
) = NULL
;
2725 if (VAR_OR_FUNCTION_DECL_P (newdecl
))
2727 struct symtab_node
*snode
= symtab_node::get (newdecl
);
2736 /* Check whether decl-node NEW_DECL shadows an existing declaration. */
2738 warn_if_shadowing (tree new_decl
)
2740 struct c_binding
*b
;
2742 /* Shadow warnings wanted? */
2744 || warn_shadow_local
2745 || warn_shadow_compatible_local
)
2746 /* No shadow warnings for internally generated vars. */
2747 || DECL_IS_BUILTIN (new_decl
)
2748 /* No shadow warnings for vars made for inlining. */
2749 || DECL_FROM_INLINE (new_decl
))
2752 /* Is anything being shadowed? Invisible decls do not count. */
2753 for (b
= I_SYMBOL_BINDING (DECL_NAME (new_decl
)); b
; b
= b
->shadowed
)
2754 if (b
->decl
&& b
->decl
!= new_decl
&& !b
->invisible
2755 && (b
->decl
== error_mark_node
2756 || diagnostic_report_warnings_p (global_dc
,
2757 DECL_SOURCE_LOCATION (b
->decl
))))
2759 tree old_decl
= b
->decl
;
2760 bool warned
= false;
2762 if (old_decl
== error_mark_node
)
2764 warning (OPT_Wshadow
, "declaration of %q+D shadows previous "
2765 "non-variable", new_decl
);
2768 else if (TREE_CODE (old_decl
) == PARM_DECL
)
2770 enum opt_code warning_code
;
2772 /* If '-Wshadow=compatible-local' is specified without other
2773 -Wshadow= flags, we will warn only when the types of the
2774 shadowing variable (i.e. new_decl) and the shadowed variable
2775 (old_decl) are compatible. */
2777 warning_code
= OPT_Wshadow
;
2778 else if (comptypes (TREE_TYPE (old_decl
), TREE_TYPE (new_decl
)))
2779 warning_code
= OPT_Wshadow_compatible_local
;
2781 warning_code
= OPT_Wshadow_local
;
2782 warned
= warning_at (DECL_SOURCE_LOCATION (new_decl
), warning_code
,
2783 "declaration of %qD shadows a parameter",
2786 else if (DECL_FILE_SCOPE_P (old_decl
))
2788 /* Do not warn if a variable shadows a function, unless
2789 the variable is a function or a pointer-to-function. */
2790 if (TREE_CODE (old_decl
) == FUNCTION_DECL
2791 && TREE_CODE (new_decl
) != FUNCTION_DECL
2792 && !FUNCTION_POINTER_TYPE_P (TREE_TYPE (new_decl
)))
2795 warned
= warning_at (DECL_SOURCE_LOCATION (new_decl
), OPT_Wshadow
,
2796 "declaration of %qD shadows a global "
2800 else if (TREE_CODE (old_decl
) == FUNCTION_DECL
2801 && DECL_BUILT_IN (old_decl
))
2803 warning (OPT_Wshadow
, "declaration of %q+D shadows "
2804 "a built-in function", new_decl
);
2809 enum opt_code warning_code
;
2811 /* If '-Wshadow=compatible-local' is specified without other
2812 -Wshadow= flags, we will warn only when the types of the
2813 shadowing variable (i.e. new_decl) and the shadowed variable
2814 (old_decl) are compatible. */
2816 warning_code
= OPT_Wshadow
;
2817 else if (comptypes (TREE_TYPE (old_decl
), TREE_TYPE (new_decl
)))
2818 warning_code
= OPT_Wshadow_compatible_local
;
2820 warning_code
= OPT_Wshadow_local
;
2821 warned
= warning_at (DECL_SOURCE_LOCATION (new_decl
), warning_code
,
2822 "declaration of %qD shadows a previous local",
2827 inform (DECL_SOURCE_LOCATION (old_decl
),
2828 "shadowed declaration is here");
2834 /* Record a decl-node X as belonging to the current lexical scope.
2835 Check for errors (such as an incompatible declaration for the same
2836 name already seen in the same scope).
2838 Returns either X or an old decl for the same name.
2839 If an old decl is returned, it may have been smashed
2840 to agree with what X says. */
2845 tree name
= DECL_NAME (x
);
2846 struct c_scope
*scope
= current_scope
;
2847 struct c_binding
*b
;
2848 bool nested
= false;
2849 location_t locus
= DECL_SOURCE_LOCATION (x
);
2851 /* Must set DECL_CONTEXT for everything not at file scope or
2852 DECL_FILE_SCOPE_P won't work. Local externs don't count
2853 unless they have initializers (which generate code). */
2854 if (current_function_decl
2855 && (!VAR_OR_FUNCTION_DECL_P (x
)
2856 || DECL_INITIAL (x
) || !DECL_EXTERNAL (x
)))
2857 DECL_CONTEXT (x
) = current_function_decl
;
2859 /* Anonymous decls are just inserted in the scope. */
2862 bind (name
, x
, scope
, /*invisible=*/false, /*nested=*/false,
2867 /* First, see if there is another declaration with the same name in
2868 the current scope. If there is, duplicate_decls may do all the
2869 work for us. If duplicate_decls returns false, that indicates
2870 two incompatible decls in the same scope; we are to silently
2871 replace the old one (duplicate_decls has issued all appropriate
2872 diagnostics). In particular, we should not consider possible
2873 duplicates in the external scope, or shadowing. */
2874 b
= I_SYMBOL_BINDING (name
);
2875 if (b
&& B_IN_SCOPE (b
, scope
))
2877 struct c_binding
*b_ext
, *b_use
;
2878 tree type
= TREE_TYPE (x
);
2879 tree visdecl
= b
->decl
;
2880 tree vistype
= TREE_TYPE (visdecl
);
2881 if (TREE_CODE (TREE_TYPE (x
)) == ARRAY_TYPE
2882 && COMPLETE_TYPE_P (TREE_TYPE (x
)))
2883 b
->inner_comp
= false;
2886 /* If this is an external linkage declaration, we should check
2887 for compatibility with the type in the external scope before
2888 setting the type at this scope based on the visible
2889 information only. */
2890 if (TREE_PUBLIC (x
) && TREE_PUBLIC (visdecl
))
2892 while (b_ext
&& !B_IN_EXTERNAL_SCOPE (b_ext
))
2893 b_ext
= b_ext
->shadowed
;
2898 TREE_TYPE (b_use
->decl
) = b_use
->u
.type
;
2901 if (duplicate_decls (x
, b_use
->decl
))
2905 /* Save the updated type in the external scope and
2906 restore the proper type for this scope. */
2908 if (comptypes (vistype
, type
))
2909 thistype
= composite_type (vistype
, type
);
2911 thistype
= TREE_TYPE (b_use
->decl
);
2912 b_use
->u
.type
= TREE_TYPE (b_use
->decl
);
2913 if (TREE_CODE (b_use
->decl
) == FUNCTION_DECL
2914 && DECL_BUILT_IN (b_use
->decl
))
2916 = build_type_attribute_variant (thistype
,
2919 TREE_TYPE (b_use
->decl
) = thistype
;
2924 goto skip_external_and_shadow_checks
;
2927 /* All declarations with external linkage, and all external
2928 references, go in the external scope, no matter what scope is
2929 current. However, the binding in that scope is ignored for
2930 purposes of normal name lookup. A separate binding structure is
2931 created in the requested scope; this governs the normal
2932 visibility of the symbol.
2934 The binding in the externals scope is used exclusively for
2935 detecting duplicate declarations of the same object, no matter
2936 what scope they are in; this is what we do here. (C99 6.2.7p2:
2937 All declarations that refer to the same object or function shall
2938 have compatible type; otherwise, the behavior is undefined.) */
2939 if (DECL_EXTERNAL (x
) || scope
== file_scope
)
2941 tree type
= TREE_TYPE (x
);
2942 tree vistype
= NULL_TREE
;
2943 tree visdecl
= NULL_TREE
;
2944 bool type_saved
= false;
2945 if (b
&& !B_IN_EXTERNAL_SCOPE (b
)
2946 && VAR_OR_FUNCTION_DECL_P (b
->decl
)
2947 && DECL_FILE_SCOPE_P (b
->decl
))
2950 vistype
= TREE_TYPE (visdecl
);
2952 if (scope
!= file_scope
2953 && !DECL_IN_SYSTEM_HEADER (x
))
2954 warning_at (locus
, OPT_Wnested_externs
,
2955 "nested extern declaration of %qD", x
);
2957 while (b
&& !B_IN_EXTERNAL_SCOPE (b
))
2959 /* If this decl might be modified, save its type. This is
2960 done here rather than when the decl is first bound
2961 because the type may change after first binding, through
2962 being completed or through attributes being added. If we
2963 encounter multiple such decls, only the first should have
2964 its type saved; the others will already have had their
2965 proper types saved and the types will not have changed as
2966 their scopes will not have been re-entered. */
2967 if (DECL_P (b
->decl
) && DECL_FILE_SCOPE_P (b
->decl
) && !type_saved
)
2969 b
->u
.type
= TREE_TYPE (b
->decl
);
2972 if (B_IN_FILE_SCOPE (b
)
2974 && TREE_STATIC (b
->decl
)
2975 && TREE_CODE (TREE_TYPE (b
->decl
)) == ARRAY_TYPE
2976 && !TYPE_DOMAIN (TREE_TYPE (b
->decl
))
2977 && TREE_CODE (type
) == ARRAY_TYPE
2978 && TYPE_DOMAIN (type
)
2979 && TYPE_MAX_VALUE (TYPE_DOMAIN (type
))
2980 && !integer_zerop (TYPE_MAX_VALUE (TYPE_DOMAIN (type
))))
2982 /* Array type completed in inner scope, which should be
2983 diagnosed if the completion does not have size 1 and
2984 it does not get completed in the file scope. */
2985 b
->inner_comp
= true;
2990 /* If a matching external declaration has been found, set its
2991 type to the composite of all the types of that declaration.
2992 After the consistency checks, it will be reset to the
2993 composite of the visible types only. */
2994 if (b
&& (TREE_PUBLIC (x
) || same_translation_unit_p (x
, b
->decl
))
2996 TREE_TYPE (b
->decl
) = b
->u
.type
;
2998 /* The point of the same_translation_unit_p check here is,
2999 we want to detect a duplicate decl for a construct like
3000 foo() { extern bar(); } ... static bar(); but not if
3001 they are in different translation units. In any case,
3002 the static does not go in the externals scope. */
3004 && (TREE_PUBLIC (x
) || same_translation_unit_p (x
, b
->decl
))
3005 && duplicate_decls (x
, b
->decl
))
3010 if (comptypes (vistype
, type
))
3011 thistype
= composite_type (vistype
, type
);
3013 thistype
= TREE_TYPE (b
->decl
);
3017 b
->u
.type
= TREE_TYPE (b
->decl
);
3018 if (TREE_CODE (b
->decl
) == FUNCTION_DECL
&& DECL_BUILT_IN (b
->decl
))
3020 = build_type_attribute_variant (thistype
,
3021 TYPE_ATTRIBUTES (b
->u
.type
));
3022 TREE_TYPE (b
->decl
) = thistype
;
3023 bind (name
, b
->decl
, scope
, /*invisible=*/false, /*nested=*/true,
3027 else if (TREE_PUBLIC (x
))
3029 if (visdecl
&& !b
&& duplicate_decls (x
, visdecl
))
3031 /* An external declaration at block scope referring to a
3032 visible entity with internal linkage. The composite
3033 type will already be correct for this scope, so we
3034 just need to fall through to make the declaration in
3041 bind (name
, x
, external_scope
, /*invisible=*/true,
3042 /*nested=*/false, locus
);
3048 if (TREE_CODE (x
) != PARM_DECL
)
3049 warn_if_shadowing (x
);
3051 skip_external_and_shadow_checks
:
3052 if (TREE_CODE (x
) == TYPE_DECL
)
3054 /* So this is a typedef, set its underlying type. */
3055 set_underlying_type (x
);
3057 /* If X is a typedef defined in the current function, record it
3058 for the purpose of implementing the -Wunused-local-typedefs
3060 record_locally_defined_typedef (x
);
3063 bind (name
, x
, scope
, /*invisible=*/false, nested
, locus
);
3065 /* If x's type is incomplete because it's based on a
3066 structure or union which has not yet been fully declared,
3067 attach it to that structure or union type, so we can go
3068 back and complete the variable declaration later, if the
3069 structure or union gets fully declared.
3071 If the input is erroneous, we can have error_mark in the type
3072 slot (e.g. "f(void a, ...)") - that doesn't count as an
3074 if (TREE_TYPE (x
) != error_mark_node
3075 && !COMPLETE_TYPE_P (TREE_TYPE (x
)))
3077 tree element
= TREE_TYPE (x
);
3079 while (TREE_CODE (element
) == ARRAY_TYPE
)
3080 element
= TREE_TYPE (element
);
3081 element
= TYPE_MAIN_VARIANT (element
);
3083 if (RECORD_OR_UNION_TYPE_P (element
)
3084 && (TREE_CODE (x
) != TYPE_DECL
3085 || TREE_CODE (TREE_TYPE (x
)) == ARRAY_TYPE
)
3086 && !COMPLETE_TYPE_P (element
))
3087 C_TYPE_INCOMPLETE_VARS (element
)
3088 = tree_cons (NULL_TREE
, x
, C_TYPE_INCOMPLETE_VARS (element
));
3094 /* Issue a warning about implicit function declaration. ID is the function
3095 identifier, OLDDECL is a declaration of the function in a different scope,
3099 implicit_decl_warning (location_t loc
, tree id
, tree olddecl
)
3101 if (!warn_implicit_function_declaration
)
3105 const char *hint
= NULL
;
3107 hint
= lookup_name_fuzzy (id
, FUZZY_LOOKUP_FUNCTION_NAME
);
3113 gcc_rich_location
richloc (loc
);
3114 richloc
.add_fixit_replace (hint
);
3115 warned
= pedwarn_at_rich_loc
3116 (&richloc
, OPT_Wimplicit_function_declaration
,
3117 "implicit declaration of function %qE; did you mean %qs?",
3121 warned
= pedwarn (loc
, OPT_Wimplicit_function_declaration
,
3122 "implicit declaration of function %qE", id
);
3126 gcc_rich_location
richloc (loc
);
3127 richloc
.add_fixit_replace (hint
);
3128 warned
= warning_at_rich_loc
3129 (&richloc
, OPT_Wimplicit_function_declaration
,
3130 G_("implicit declaration of function %qE; did you mean %qs?"),
3134 warned
= warning_at (loc
, OPT_Wimplicit_function_declaration
,
3135 G_("implicit declaration of function %qE"), id
);
3137 if (olddecl
&& warned
)
3138 locate_old_decl (olddecl
);
3141 /* This function represents mapping of a function code FCODE
3142 to its respective header. */
3145 header_for_builtin_fn (enum built_in_function fcode
)
3149 CASE_FLT_FN (BUILT_IN_ACOS
):
3150 CASE_FLT_FN (BUILT_IN_ACOSH
):
3151 CASE_FLT_FN (BUILT_IN_ASIN
):
3152 CASE_FLT_FN (BUILT_IN_ASINH
):
3153 CASE_FLT_FN (BUILT_IN_ATAN
):
3154 CASE_FLT_FN (BUILT_IN_ATANH
):
3155 CASE_FLT_FN (BUILT_IN_ATAN2
):
3156 CASE_FLT_FN (BUILT_IN_CBRT
):
3157 CASE_FLT_FN (BUILT_IN_CEIL
):
3158 CASE_FLT_FN (BUILT_IN_COPYSIGN
):
3159 CASE_FLT_FN (BUILT_IN_COS
):
3160 CASE_FLT_FN (BUILT_IN_COSH
):
3161 CASE_FLT_FN (BUILT_IN_ERF
):
3162 CASE_FLT_FN (BUILT_IN_ERFC
):
3163 CASE_FLT_FN (BUILT_IN_EXP
):
3164 CASE_FLT_FN (BUILT_IN_EXP2
):
3165 CASE_FLT_FN (BUILT_IN_EXPM1
):
3166 CASE_FLT_FN (BUILT_IN_FABS
):
3167 CASE_FLT_FN (BUILT_IN_FDIM
):
3168 CASE_FLT_FN (BUILT_IN_FLOOR
):
3169 CASE_FLT_FN (BUILT_IN_FMA
):
3170 CASE_FLT_FN (BUILT_IN_FMAX
):
3171 CASE_FLT_FN (BUILT_IN_FMIN
):
3172 CASE_FLT_FN (BUILT_IN_FMOD
):
3173 CASE_FLT_FN (BUILT_IN_FREXP
):
3174 CASE_FLT_FN (BUILT_IN_HYPOT
):
3175 CASE_FLT_FN (BUILT_IN_ILOGB
):
3176 CASE_FLT_FN (BUILT_IN_LDEXP
):
3177 CASE_FLT_FN (BUILT_IN_LGAMMA
):
3178 CASE_FLT_FN (BUILT_IN_LLRINT
):
3179 CASE_FLT_FN (BUILT_IN_LLROUND
):
3180 CASE_FLT_FN (BUILT_IN_LOG
):
3181 CASE_FLT_FN (BUILT_IN_LOG10
):
3182 CASE_FLT_FN (BUILT_IN_LOG1P
):
3183 CASE_FLT_FN (BUILT_IN_LOG2
):
3184 CASE_FLT_FN (BUILT_IN_LOGB
):
3185 CASE_FLT_FN (BUILT_IN_LRINT
):
3186 CASE_FLT_FN (BUILT_IN_LROUND
):
3187 CASE_FLT_FN (BUILT_IN_MODF
):
3188 CASE_FLT_FN (BUILT_IN_NAN
):
3189 CASE_FLT_FN (BUILT_IN_NEARBYINT
):
3190 CASE_FLT_FN (BUILT_IN_NEXTAFTER
):
3191 CASE_FLT_FN (BUILT_IN_NEXTTOWARD
):
3192 CASE_FLT_FN (BUILT_IN_POW
):
3193 CASE_FLT_FN (BUILT_IN_REMAINDER
):
3194 CASE_FLT_FN (BUILT_IN_REMQUO
):
3195 CASE_FLT_FN (BUILT_IN_RINT
):
3196 CASE_FLT_FN (BUILT_IN_ROUND
):
3197 CASE_FLT_FN (BUILT_IN_SCALBLN
):
3198 CASE_FLT_FN (BUILT_IN_SCALBN
):
3199 CASE_FLT_FN (BUILT_IN_SIN
):
3200 CASE_FLT_FN (BUILT_IN_SINH
):
3201 CASE_FLT_FN (BUILT_IN_SINCOS
):
3202 CASE_FLT_FN (BUILT_IN_SQRT
):
3203 CASE_FLT_FN (BUILT_IN_TAN
):
3204 CASE_FLT_FN (BUILT_IN_TANH
):
3205 CASE_FLT_FN (BUILT_IN_TGAMMA
):
3206 CASE_FLT_FN (BUILT_IN_TRUNC
):
3207 case BUILT_IN_ISINF
:
3208 case BUILT_IN_ISNAN
:
3210 CASE_FLT_FN (BUILT_IN_CABS
):
3211 CASE_FLT_FN (BUILT_IN_CACOS
):
3212 CASE_FLT_FN (BUILT_IN_CACOSH
):
3213 CASE_FLT_FN (BUILT_IN_CARG
):
3214 CASE_FLT_FN (BUILT_IN_CASIN
):
3215 CASE_FLT_FN (BUILT_IN_CASINH
):
3216 CASE_FLT_FN (BUILT_IN_CATAN
):
3217 CASE_FLT_FN (BUILT_IN_CATANH
):
3218 CASE_FLT_FN (BUILT_IN_CCOS
):
3219 CASE_FLT_FN (BUILT_IN_CCOSH
):
3220 CASE_FLT_FN (BUILT_IN_CEXP
):
3221 CASE_FLT_FN (BUILT_IN_CIMAG
):
3222 CASE_FLT_FN (BUILT_IN_CLOG
):
3223 CASE_FLT_FN (BUILT_IN_CONJ
):
3224 CASE_FLT_FN (BUILT_IN_CPOW
):
3225 CASE_FLT_FN (BUILT_IN_CPROJ
):
3226 CASE_FLT_FN (BUILT_IN_CREAL
):
3227 CASE_FLT_FN (BUILT_IN_CSIN
):
3228 CASE_FLT_FN (BUILT_IN_CSINH
):
3229 CASE_FLT_FN (BUILT_IN_CSQRT
):
3230 CASE_FLT_FN (BUILT_IN_CTAN
):
3231 CASE_FLT_FN (BUILT_IN_CTANH
):
3232 return "<complex.h>";
3233 case BUILT_IN_MEMCHR
:
3234 case BUILT_IN_MEMCMP
:
3235 case BUILT_IN_MEMCPY
:
3236 case BUILT_IN_MEMMOVE
:
3237 case BUILT_IN_MEMSET
:
3238 case BUILT_IN_STRCAT
:
3239 case BUILT_IN_STRCHR
:
3240 case BUILT_IN_STRCMP
:
3241 case BUILT_IN_STRCPY
:
3242 case BUILT_IN_STRCSPN
:
3243 case BUILT_IN_STRLEN
:
3244 case BUILT_IN_STRNCAT
:
3245 case BUILT_IN_STRNCMP
:
3246 case BUILT_IN_STRNCPY
:
3247 case BUILT_IN_STRPBRK
:
3248 case BUILT_IN_STRRCHR
:
3249 case BUILT_IN_STRSPN
:
3250 case BUILT_IN_STRSTR
:
3251 return "<string.h>";
3252 case BUILT_IN_FPRINTF
:
3254 case BUILT_IN_FPUTC
:
3255 case BUILT_IN_FPUTS
:
3256 case BUILT_IN_FSCANF
:
3257 case BUILT_IN_FWRITE
:
3258 case BUILT_IN_PRINTF
:
3259 case BUILT_IN_PUTCHAR
:
3261 case BUILT_IN_SCANF
:
3262 case BUILT_IN_SNPRINTF
:
3263 case BUILT_IN_SPRINTF
:
3264 case BUILT_IN_SSCANF
:
3265 case BUILT_IN_VFPRINTF
:
3266 case BUILT_IN_VFSCANF
:
3267 case BUILT_IN_VPRINTF
:
3268 case BUILT_IN_VSCANF
:
3269 case BUILT_IN_VSNPRINTF
:
3270 case BUILT_IN_VSPRINTF
:
3271 case BUILT_IN_VSSCANF
:
3273 case BUILT_IN_ISALNUM
:
3274 case BUILT_IN_ISALPHA
:
3275 case BUILT_IN_ISBLANK
:
3276 case BUILT_IN_ISCNTRL
:
3277 case BUILT_IN_ISDIGIT
:
3278 case BUILT_IN_ISGRAPH
:
3279 case BUILT_IN_ISLOWER
:
3280 case BUILT_IN_ISPRINT
:
3281 case BUILT_IN_ISPUNCT
:
3282 case BUILT_IN_ISSPACE
:
3283 case BUILT_IN_ISUPPER
:
3284 case BUILT_IN_ISXDIGIT
:
3285 case BUILT_IN_TOLOWER
:
3286 case BUILT_IN_TOUPPER
:
3288 case BUILT_IN_ISWALNUM
:
3289 case BUILT_IN_ISWALPHA
:
3290 case BUILT_IN_ISWBLANK
:
3291 case BUILT_IN_ISWCNTRL
:
3292 case BUILT_IN_ISWDIGIT
:
3293 case BUILT_IN_ISWGRAPH
:
3294 case BUILT_IN_ISWLOWER
:
3295 case BUILT_IN_ISWPRINT
:
3296 case BUILT_IN_ISWPUNCT
:
3297 case BUILT_IN_ISWSPACE
:
3298 case BUILT_IN_ISWUPPER
:
3299 case BUILT_IN_ISWXDIGIT
:
3300 case BUILT_IN_TOWLOWER
:
3301 case BUILT_IN_TOWUPPER
:
3302 return "<wctype.h>";
3303 case BUILT_IN_ABORT
:
3305 case BUILT_IN_CALLOC
:
3309 case BUILT_IN_LLABS
:
3310 case BUILT_IN_MALLOC
:
3311 case BUILT_IN_REALLOC
:
3312 case BUILT_IN__EXIT2
:
3313 case BUILT_IN_ALIGNED_ALLOC
:
3314 return "<stdlib.h>";
3315 case BUILT_IN_IMAXABS
:
3316 return "<inttypes.h>";
3317 case BUILT_IN_STRFTIME
:
3324 /* Generate an implicit declaration for identifier FUNCTIONID at LOC as a
3325 function of type int (). */
3328 implicitly_declare (location_t loc
, tree functionid
)
3330 struct c_binding
*b
;
3331 tree decl
= NULL_TREE
;
3334 for (b
= I_SYMBOL_BINDING (functionid
); b
; b
= b
->shadowed
)
3336 if (B_IN_SCOPE (b
, external_scope
))
3345 if (TREE_CODE (decl
) != FUNCTION_DECL
)
3348 /* FIXME: Objective-C has weird not-really-builtin functions
3349 which are supposed to be visible automatically. They wind up
3350 in the external scope because they're pushed before the file
3351 scope gets created. Catch this here and rebind them into the
3353 if (!DECL_BUILT_IN (decl
) && DECL_IS_BUILTIN (decl
))
3355 bind (functionid
, decl
, file_scope
,
3356 /*invisible=*/false, /*nested=*/true,
3357 DECL_SOURCE_LOCATION (decl
));
3362 tree newtype
= default_function_type
;
3364 TREE_TYPE (decl
) = b
->u
.type
;
3365 /* Implicit declaration of a function already declared
3366 (somehow) in a different scope, or as a built-in.
3367 If this is the first time this has happened, warn;
3368 then recycle the old declaration but with the new type. */
3369 if (!C_DECL_IMPLICIT (decl
))
3371 implicit_decl_warning (loc
, functionid
, decl
);
3372 C_DECL_IMPLICIT (decl
) = 1;
3374 if (DECL_BUILT_IN (decl
))
3376 newtype
= build_type_attribute_variant (newtype
,
3378 (TREE_TYPE (decl
)));
3379 if (!comptypes (newtype
, TREE_TYPE (decl
)))
3381 bool warned
= warning_at (loc
, 0, "incompatible implicit "
3382 "declaration of built-in "
3383 "function %qD", decl
);
3384 /* See if we can hint which header to include. */
3386 = header_for_builtin_fn (DECL_FUNCTION_CODE (decl
));
3387 if (header
!= NULL
&& warned
)
3389 rich_location
richloc (line_table
, loc
);
3390 maybe_add_include_fixit (&richloc
, header
);
3393 "include %qs or provide a declaration of %qD",
3396 newtype
= TREE_TYPE (decl
);
3401 if (!comptypes (newtype
, TREE_TYPE (decl
)))
3403 error_at (loc
, "incompatible implicit declaration of "
3404 "function %qD", decl
);
3405 locate_old_decl (decl
);
3408 b
->u
.type
= TREE_TYPE (decl
);
3409 TREE_TYPE (decl
) = newtype
;
3410 bind (functionid
, decl
, current_scope
,
3411 /*invisible=*/false, /*nested=*/true,
3412 DECL_SOURCE_LOCATION (decl
));
3417 /* Not seen before. */
3418 decl
= build_decl (loc
, FUNCTION_DECL
, functionid
, default_function_type
);
3419 DECL_EXTERNAL (decl
) = 1;
3420 TREE_PUBLIC (decl
) = 1;
3421 C_DECL_IMPLICIT (decl
) = 1;
3422 implicit_decl_warning (loc
, functionid
, 0);
3423 asmspec_tree
= maybe_apply_renaming_pragma (decl
, /*asmname=*/NULL
);
3425 set_user_assembler_name (decl
, TREE_STRING_POINTER (asmspec_tree
));
3427 /* C89 says implicit declarations are in the innermost block.
3428 So we record the decl in the standard fashion. */
3429 decl
= pushdecl (decl
);
3431 /* No need to call objc_check_decl here - it's a function type. */
3432 rest_of_decl_compilation (decl
, 0, 0);
3434 /* Write a record describing this implicit function declaration
3435 to the prototypes file (if requested). */
3436 gen_aux_info_record (decl
, 0, 1, 0);
3438 /* Possibly apply some default attributes to this implicit declaration. */
3439 decl_attributes (&decl
, NULL_TREE
, 0);
3444 /* Issue an error message for a reference to an undeclared variable
3445 ID, including a reference to a builtin outside of function-call
3446 context. Establish a binding of the identifier to error_mark_node
3447 in an appropriate scope, which will suppress further errors for the
3448 same identifier. The error message should be given location LOC. */
3450 undeclared_variable (location_t loc
, tree id
)
3452 static bool already
= false;
3453 struct c_scope
*scope
;
3455 if (current_function_decl
== NULL_TREE
)
3457 const char *guessed_id
= lookup_name_fuzzy (id
, FUZZY_LOOKUP_NAME
);
3460 gcc_rich_location
richloc (loc
);
3461 richloc
.add_fixit_replace (guessed_id
);
3462 error_at_rich_loc (&richloc
,
3463 "%qE undeclared here (not in a function);"
3464 " did you mean %qs?",
3468 error_at (loc
, "%qE undeclared here (not in a function)", id
);
3469 scope
= current_scope
;
3473 if (!objc_diagnose_private_ivar (id
))
3475 const char *guessed_id
= lookup_name_fuzzy (id
, FUZZY_LOOKUP_NAME
);
3478 gcc_rich_location
richloc (loc
);
3479 richloc
.add_fixit_replace (guessed_id
);
3482 "%qE undeclared (first use in this function);"
3483 " did you mean %qs?",
3487 error_at (loc
, "%qE undeclared (first use in this function)", id
);
3491 inform (loc
, "each undeclared identifier is reported only"
3492 " once for each function it appears in");
3496 /* If we are parsing old-style parameter decls, current_function_decl
3497 will be nonnull but current_function_scope will be null. */
3498 scope
= current_function_scope
? current_function_scope
: current_scope
;
3500 bind (id
, error_mark_node
, scope
, /*invisible=*/false, /*nested=*/false,
3504 /* Subroutine of lookup_label, declare_label, define_label: construct a
3505 LABEL_DECL with all the proper frills. Also create a struct
3506 c_label_vars initialized for the current scope. */
3509 make_label (location_t location
, tree name
, bool defining
,
3510 struct c_label_vars
**p_label_vars
)
3512 tree label
= build_decl (location
, LABEL_DECL
, name
, void_type_node
);
3513 DECL_CONTEXT (label
) = current_function_decl
;
3514 SET_DECL_MODE (label
, VOIDmode
);
3516 c_label_vars
*label_vars
= ggc_alloc
<c_label_vars
> ();
3517 label_vars
->shadowed
= NULL
;
3518 set_spot_bindings (&label_vars
->label_bindings
, defining
);
3519 label_vars
->decls_in_scope
= make_tree_vector ();
3520 label_vars
->gotos
= NULL
;
3521 *p_label_vars
= label_vars
;
3526 /* Get the LABEL_DECL corresponding to identifier NAME as a label.
3527 Create one if none exists so far for the current function.
3528 This is called when a label is used in a goto expression or
3529 has its address taken. */
3532 lookup_label (tree name
)
3535 struct c_label_vars
*label_vars
;
3537 if (current_function_scope
== 0)
3539 error ("label %qE referenced outside of any function", name
);
3543 /* Use a label already defined or ref'd with this name, but not if
3544 it is inherited from a containing function and wasn't declared
3546 label
= I_LABEL_DECL (name
);
3547 if (label
&& (DECL_CONTEXT (label
) == current_function_decl
3548 || C_DECLARED_LABEL_FLAG (label
)))
3550 /* If the label has only been declared, update its apparent
3551 location to point here, for better diagnostics if it
3552 turns out not to have been defined. */
3553 if (DECL_INITIAL (label
) == NULL_TREE
)
3554 DECL_SOURCE_LOCATION (label
) = input_location
;
3558 /* No label binding for that identifier; make one. */
3559 label
= make_label (input_location
, name
, false, &label_vars
);
3561 /* Ordinary labels go in the current function scope. */
3562 bind_label (name
, label
, current_function_scope
, label_vars
);
3567 /* Issue a warning about DECL for a goto statement at GOTO_LOC going
3571 warn_about_goto (location_t goto_loc
, tree label
, tree decl
)
3573 if (variably_modified_type_p (TREE_TYPE (decl
), NULL_TREE
))
3575 "jump into scope of identifier with variably modified type");
3577 warning_at (goto_loc
, OPT_Wjump_misses_init
,
3578 "jump skips variable initialization");
3579 inform (DECL_SOURCE_LOCATION (label
), "label %qD defined here", label
);
3580 inform (DECL_SOURCE_LOCATION (decl
), "%qD declared here", decl
);
3583 /* Look up a label because of a goto statement. This is like
3584 lookup_label, but also issues any appropriate warnings. */
3587 lookup_label_for_goto (location_t loc
, tree name
)
3590 struct c_label_vars
*label_vars
;
3594 label
= lookup_label (name
);
3595 if (label
== NULL_TREE
)
3598 /* If we are jumping to a different function, we can't issue any
3600 if (DECL_CONTEXT (label
) != current_function_decl
)
3602 gcc_assert (C_DECLARED_LABEL_FLAG (label
));
3606 label_vars
= I_LABEL_BINDING (name
)->u
.label
;
3608 /* If the label has not yet been defined, then push this goto on a
3609 list for possible later warnings. */
3610 if (label_vars
->label_bindings
.scope
== NULL
)
3612 c_goto_bindings
*g
= ggc_alloc
<c_goto_bindings
> ();
3615 set_spot_bindings (&g
->goto_bindings
, true);
3616 vec_safe_push (label_vars
->gotos
, g
);
3620 /* If there are any decls in label_vars->decls_in_scope, then this
3621 goto has missed the declaration of the decl. This happens for a
3627 Issue a warning or error. */
3628 FOR_EACH_VEC_SAFE_ELT (label_vars
->decls_in_scope
, ix
, decl
)
3629 warn_about_goto (loc
, label
, decl
);
3631 if (label_vars
->label_bindings
.left_stmt_expr
)
3633 error_at (loc
, "jump into statement expression");
3634 inform (DECL_SOURCE_LOCATION (label
), "label %qD defined here", label
);
3640 /* Make a label named NAME in the current function, shadowing silently
3641 any that may be inherited from containing functions or containing
3642 scopes. This is called for __label__ declarations. */
3645 declare_label (tree name
)
3647 struct c_binding
*b
= I_LABEL_BINDING (name
);
3649 struct c_label_vars
*label_vars
;
3651 /* Check to make sure that the label hasn't already been declared
3653 if (b
&& B_IN_CURRENT_SCOPE (b
))
3655 error ("duplicate label declaration %qE", name
);
3656 locate_old_decl (b
->decl
);
3658 /* Just use the previous declaration. */
3662 label
= make_label (input_location
, name
, false, &label_vars
);
3663 C_DECLARED_LABEL_FLAG (label
) = 1;
3665 /* Declared labels go in the current scope. */
3666 bind_label (name
, label
, current_scope
, label_vars
);
3671 /* When we define a label, issue any appropriate warnings if there are
3672 any gotos earlier in the function which jump to this label. */
3675 check_earlier_gotos (tree label
, struct c_label_vars
* label_vars
)
3678 struct c_goto_bindings
*g
;
3680 FOR_EACH_VEC_SAFE_ELT (label_vars
->gotos
, ix
, g
)
3682 struct c_binding
*b
;
3683 struct c_scope
*scope
;
3685 /* We have a goto to this label. The goto is going forward. In
3686 g->scope, the goto is going to skip any binding which was
3687 defined after g->bindings_in_scope. */
3688 if (g
->goto_bindings
.scope
->has_jump_unsafe_decl
)
3690 for (b
= g
->goto_bindings
.scope
->bindings
;
3691 b
!= g
->goto_bindings
.bindings_in_scope
;
3694 if (decl_jump_unsafe (b
->decl
))
3695 warn_about_goto (g
->loc
, label
, b
->decl
);
3699 /* We also need to warn about decls defined in any scopes
3700 between the scope of the label and the scope of the goto. */
3701 for (scope
= label_vars
->label_bindings
.scope
;
3702 scope
!= g
->goto_bindings
.scope
;
3703 scope
= scope
->outer
)
3705 gcc_assert (scope
!= NULL
);
3706 if (scope
->has_jump_unsafe_decl
)
3708 if (scope
== label_vars
->label_bindings
.scope
)
3709 b
= label_vars
->label_bindings
.bindings_in_scope
;
3711 b
= scope
->bindings
;
3712 for (; b
!= NULL
; b
= b
->prev
)
3714 if (decl_jump_unsafe (b
->decl
))
3715 warn_about_goto (g
->loc
, label
, b
->decl
);
3720 if (g
->goto_bindings
.stmt_exprs
> 0)
3722 error_at (g
->loc
, "jump into statement expression");
3723 inform (DECL_SOURCE_LOCATION (label
), "label %qD defined here",
3728 /* Now that the label is defined, we will issue warnings about
3729 subsequent gotos to this label when we see them. */
3730 vec_safe_truncate (label_vars
->gotos
, 0);
3731 label_vars
->gotos
= NULL
;
3734 /* Define a label, specifying the location in the source file.
3735 Return the LABEL_DECL node for the label, if the definition is valid.
3736 Otherwise return NULL_TREE. */
3739 define_label (location_t location
, tree name
)
3741 /* Find any preexisting label with this name. It is an error
3742 if that label has already been defined in this function, or
3743 if there is a containing function with a declared label with
3745 tree label
= I_LABEL_DECL (name
);
3748 && ((DECL_CONTEXT (label
) == current_function_decl
3749 && DECL_INITIAL (label
) != NULL_TREE
)
3750 || (DECL_CONTEXT (label
) != current_function_decl
3751 && C_DECLARED_LABEL_FLAG (label
))))
3753 error_at (location
, "duplicate label %qD", label
);
3754 locate_old_decl (label
);
3757 else if (label
&& DECL_CONTEXT (label
) == current_function_decl
)
3759 struct c_label_vars
*label_vars
= I_LABEL_BINDING (name
)->u
.label
;
3761 /* The label has been used or declared already in this function,
3762 but not defined. Update its location to point to this
3764 DECL_SOURCE_LOCATION (label
) = location
;
3765 set_spot_bindings (&label_vars
->label_bindings
, true);
3767 /* Issue warnings as required about any goto statements from
3768 earlier in the function. */
3769 check_earlier_gotos (label
, label_vars
);
3773 struct c_label_vars
*label_vars
;
3775 /* No label binding for that identifier; make one. */
3776 label
= make_label (location
, name
, true, &label_vars
);
3778 /* Ordinary labels go in the current function scope. */
3779 bind_label (name
, label
, current_function_scope
, label_vars
);
3782 if (!in_system_header_at (input_location
) && lookup_name (name
))
3783 warning_at (location
, OPT_Wtraditional
,
3784 "traditional C lacks a separate namespace "
3785 "for labels, identifier %qE conflicts", name
);
3787 /* Mark label as having been defined. */
3788 DECL_INITIAL (label
) = error_mark_node
;
3792 /* Get the bindings for a new switch statement. This is used to issue
3793 warnings as appropriate for jumps from the switch to case or
3796 struct c_spot_bindings
*
3797 c_get_switch_bindings (void)
3799 struct c_spot_bindings
*switch_bindings
;
3801 switch_bindings
= XNEW (struct c_spot_bindings
);
3802 set_spot_bindings (switch_bindings
, true);
3803 return switch_bindings
;
3807 c_release_switch_bindings (struct c_spot_bindings
*bindings
)
3809 gcc_assert (bindings
->stmt_exprs
== 0 && !bindings
->left_stmt_expr
);
3813 /* This is called at the point of a case or default label to issue
3814 warnings about decls as needed. It returns true if it found an
3815 error, not just a warning. */
3818 c_check_switch_jump_warnings (struct c_spot_bindings
*switch_bindings
,
3819 location_t switch_loc
, location_t case_loc
)
3822 struct c_scope
*scope
;
3825 for (scope
= current_scope
;
3826 scope
!= switch_bindings
->scope
;
3827 scope
= scope
->outer
)
3829 struct c_binding
*b
;
3831 gcc_assert (scope
!= NULL
);
3833 if (!scope
->has_jump_unsafe_decl
)
3836 for (b
= scope
->bindings
; b
!= NULL
; b
= b
->prev
)
3838 if (decl_jump_unsafe (b
->decl
))
3840 if (variably_modified_type_p (TREE_TYPE (b
->decl
), NULL_TREE
))
3844 ("switch jumps into scope of identifier with "
3845 "variably modified type"));
3848 warning_at (case_loc
, OPT_Wjump_misses_init
,
3849 "switch jumps over variable initialization");
3850 inform (switch_loc
, "switch starts here");
3851 inform (DECL_SOURCE_LOCATION (b
->decl
), "%qD declared here",
3857 if (switch_bindings
->stmt_exprs
> 0)
3860 error_at (case_loc
, "switch jumps into statement expression");
3861 inform (switch_loc
, "switch starts here");
3867 /* Given NAME, an IDENTIFIER_NODE,
3868 return the structure (or union or enum) definition for that name.
3869 If THISLEVEL_ONLY is nonzero, searches only the current_scope.
3870 CODE says which kind of type the caller wants;
3871 it is RECORD_TYPE or UNION_TYPE or ENUMERAL_TYPE.
3872 If PLOC is not NULL and this returns non-null, it sets *PLOC to the
3873 location where the tag was defined.
3874 If the wrong kind of type is found, an error is reported. */
3877 lookup_tag (enum tree_code code
, tree name
, bool thislevel_only
,
3880 struct c_binding
*b
= I_TAG_BINDING (name
);
3881 bool thislevel
= false;
3886 /* We only care about whether it's in this level if
3887 thislevel_only was set or it might be a type clash. */
3888 if (thislevel_only
|| TREE_CODE (b
->decl
) != code
)
3890 /* For our purposes, a tag in the external scope is the same as
3891 a tag in the file scope. (Primarily relevant to Objective-C
3892 and its builtin structure tags, which get pushed before the
3893 file scope is created.) */
3894 if (B_IN_CURRENT_SCOPE (b
)
3895 || (current_scope
== file_scope
&& B_IN_EXTERNAL_SCOPE (b
)))
3899 if (thislevel_only
&& !thislevel
)
3902 if (TREE_CODE (b
->decl
) != code
)
3904 /* Definition isn't the kind we were looking for. */
3905 pending_invalid_xref
= name
;
3906 pending_invalid_xref_location
= input_location
;
3908 /* If in the same binding level as a declaration as a tag
3909 of a different type, this must not be allowed to
3910 shadow that tag, so give the error immediately.
3911 (For example, "struct foo; union foo;" is invalid.) */
3913 pending_xref_error ();
3922 /* Return true if a definition exists for NAME with code CODE. */
3925 tag_exists_p (enum tree_code code
, tree name
)
3927 struct c_binding
*b
= I_TAG_BINDING (name
);
3929 if (b
== NULL
|| b
->decl
== NULL_TREE
)
3931 return TREE_CODE (b
->decl
) == code
;
3934 /* Print an error message now
3935 for a recent invalid struct, union or enum cross reference.
3936 We don't print them immediately because they are not invalid
3937 when used in the `struct foo;' construct for shadowing. */
3940 pending_xref_error (void)
3942 if (pending_invalid_xref
!= NULL_TREE
)
3943 error_at (pending_invalid_xref_location
, "%qE defined as wrong kind of tag",
3944 pending_invalid_xref
);
3945 pending_invalid_xref
= NULL_TREE
;
3949 /* Look up NAME in the current scope and its superiors
3950 in the namespace of variables, functions and typedefs.
3951 Return a ..._DECL node of some kind representing its definition,
3952 or return NULL_TREE if it is undefined. */
3955 lookup_name (tree name
)
3957 struct c_binding
*b
= I_SYMBOL_BINDING (name
);
3958 if (b
&& !b
->invisible
)
3960 maybe_record_typedef_use (b
->decl
);
3966 /* Similar to `lookup_name' but look only at the indicated scope. */
3969 lookup_name_in_scope (tree name
, struct c_scope
*scope
)
3971 struct c_binding
*b
;
3973 for (b
= I_SYMBOL_BINDING (name
); b
; b
= b
->shadowed
)
3974 if (B_IN_SCOPE (b
, scope
))
3979 /* Look for the closest match for NAME within the currently valid
3982 This finds the identifier with the lowest Levenshtein distance to
3983 NAME. If there are multiple candidates with equal minimal distance,
3984 the first one found is returned. Scopes are searched from innermost
3985 outwards, and within a scope in reverse order of declaration, thus
3986 benefiting candidates "near" to the current scope.
3988 The function also looks for similar macro names to NAME, since a
3989 misspelled macro name will not be expanded, and hence looks like an
3990 identifier to the C frontend.
3992 It also looks for start_typename keywords, to detect "singed" vs "signed"
3996 lookup_name_fuzzy (tree name
, enum lookup_name_fuzzy_kind kind
)
3998 gcc_assert (TREE_CODE (name
) == IDENTIFIER_NODE
);
4000 best_match
<tree
, tree
> bm (name
);
4002 /* Look within currently valid scopes. */
4003 for (c_scope
*scope
= current_scope
; scope
; scope
= scope
->outer
)
4004 for (c_binding
*binding
= scope
->bindings
; binding
; binding
= binding
->prev
)
4006 if (!binding
->id
|| binding
->invisible
)
4008 /* Don't use bindings from implicitly declared functions,
4009 as they were likely misspellings themselves. */
4010 if (TREE_CODE (binding
->decl
) == FUNCTION_DECL
)
4011 if (C_DECL_IMPLICIT (binding
->decl
))
4015 case FUZZY_LOOKUP_TYPENAME
:
4016 if (TREE_CODE (binding
->decl
) != TYPE_DECL
)
4020 case FUZZY_LOOKUP_FUNCTION_NAME
:
4021 if (TREE_CODE (binding
->decl
) != FUNCTION_DECL
)
4023 /* Allow function pointers. */
4024 if ((VAR_P (binding
->decl
)
4025 || TREE_CODE (binding
->decl
) == PARM_DECL
)
4026 && TREE_CODE (TREE_TYPE (binding
->decl
)) == POINTER_TYPE
4027 && (TREE_CODE (TREE_TYPE (TREE_TYPE (binding
->decl
)))
4037 bm
.consider (binding
->id
);
4040 /* Consider macros: if the user misspelled a macro name e.g. "SOME_MACRO"
4042 x = SOME_OTHER_MACRO (y);
4043 then "SOME_OTHER_MACRO" will survive to the frontend and show up
4044 as a misspelled identifier.
4046 Use the best distance so far so that a candidate is only set if
4047 a macro is better than anything so far. This allows early rejection
4048 (without calculating the edit distance) of macro names that must have
4049 distance >= bm.get_best_distance (), and means that we only get a
4050 non-NULL result for best_macro_match if it's better than any of
4051 the identifiers already checked, which avoids needless creation
4052 of identifiers for macro hashnodes. */
4053 best_macro_match
bmm (name
, bm
.get_best_distance (), parse_in
);
4054 cpp_hashnode
*best_macro
= bmm
.get_best_meaningful_candidate ();
4055 /* If a macro is the closest so far to NAME, use it, creating an
4056 identifier tree node for it. */
4059 const char *id
= (const char *)best_macro
->ident
.str
;
4060 tree macro_as_identifier
4061 = get_identifier_with_length (id
, best_macro
->ident
.len
);
4062 bm
.set_best_so_far (macro_as_identifier
,
4063 bmm
.get_best_distance (),
4064 bmm
.get_best_candidate_length ());
4067 /* Try the "start_typename" keywords to detect
4068 "singed" vs "signed" typos. */
4069 if (kind
== FUZZY_LOOKUP_TYPENAME
)
4071 for (unsigned i
= 0; i
< num_c_common_reswords
; i
++)
4073 const c_common_resword
*resword
= &c_common_reswords
[i
];
4074 if (!c_keyword_starts_typename (resword
->rid
))
4076 tree resword_identifier
= ridpointers
[resword
->rid
];
4077 if (!resword_identifier
)
4079 gcc_assert (TREE_CODE (resword_identifier
) == IDENTIFIER_NODE
);
4080 bm
.consider (resword_identifier
);
4084 tree best
= bm
.get_best_meaningful_candidate ();
4086 return IDENTIFIER_POINTER (best
);
4092 /* Create the predefined scalar types of C,
4093 and some nodes representing standard constants (0, 1, (void *) 0).
4094 Initialize the global scope.
4095 Make definitions for built-in primitive functions. */
4098 c_init_decl_processing (void)
4100 location_t save_loc
= input_location
;
4102 /* Initialize reserved words for parser. */
4105 current_function_decl
= NULL_TREE
;
4107 gcc_obstack_init (&parser_obstack
);
4109 /* Make the externals scope. */
4111 external_scope
= current_scope
;
4113 /* Declarations from c_common_nodes_and_builtins must not be associated
4114 with this input file, lest we get differences between using and not
4115 using preprocessed headers. */
4116 input_location
= BUILTINS_LOCATION
;
4118 c_common_nodes_and_builtins ();
4120 /* In C, comparisons and TRUTH_* expressions have type int. */
4121 truthvalue_type_node
= integer_type_node
;
4122 truthvalue_true_node
= integer_one_node
;
4123 truthvalue_false_node
= integer_zero_node
;
4125 /* Even in C99, which has a real boolean type. */
4126 pushdecl (build_decl (UNKNOWN_LOCATION
, TYPE_DECL
, get_identifier ("_Bool"),
4127 boolean_type_node
));
4129 input_location
= save_loc
;
4131 make_fname_decl
= c_make_fname_decl
;
4132 start_fname_decls ();
4135 /* Create the VAR_DECL at LOC for __FUNCTION__ etc. ID is the name to
4136 give the decl, NAME is the initialization string and TYPE_DEP
4137 indicates whether NAME depended on the type of the function. As we
4138 don't yet implement delayed emission of static data, we mark the
4139 decl as emitted so it is not placed in the output. Anything using
4140 it must therefore pull out the STRING_CST initializer directly.
4144 c_make_fname_decl (location_t loc
, tree id
, int type_dep
)
4146 const char *name
= fname_as_string (type_dep
);
4147 tree decl
, type
, init
;
4148 size_t length
= strlen (name
);
4150 type
= build_array_type (char_type_node
,
4151 build_index_type (size_int (length
)));
4152 type
= c_build_qualified_type (type
, TYPE_QUAL_CONST
);
4154 decl
= build_decl (loc
, VAR_DECL
, id
, type
);
4156 TREE_STATIC (decl
) = 1;
4157 TREE_READONLY (decl
) = 1;
4158 DECL_ARTIFICIAL (decl
) = 1;
4160 init
= build_string (length
+ 1, name
);
4161 free (CONST_CAST (char *, name
));
4162 TREE_TYPE (init
) = type
;
4163 DECL_INITIAL (decl
) = init
;
4165 TREE_USED (decl
) = 1;
4167 if (current_function_decl
4168 /* For invalid programs like this:
4171 const char* p = __FUNCTION__;
4173 the __FUNCTION__ is believed to appear in K&R style function
4174 parameter declarator. In that case we still don't have
4176 && current_function_scope
)
4178 DECL_CONTEXT (decl
) = current_function_decl
;
4179 bind (id
, decl
, current_function_scope
,
4180 /*invisible=*/false, /*nested=*/false, UNKNOWN_LOCATION
);
4183 finish_decl (decl
, loc
, init
, NULL_TREE
, NULL_TREE
);
4189 c_builtin_function (tree decl
)
4191 tree type
= TREE_TYPE (decl
);
4192 tree id
= DECL_NAME (decl
);
4194 const char *name
= IDENTIFIER_POINTER (id
);
4195 C_DECL_BUILTIN_PROTOTYPE (decl
) = prototype_p (type
);
4197 /* Should never be called on a symbol with a preexisting meaning. */
4198 gcc_assert (!I_SYMBOL_BINDING (id
));
4200 bind (id
, decl
, external_scope
, /*invisible=*/true, /*nested=*/false,
4203 /* Builtins in the implementation namespace are made visible without
4204 needing to be explicitly declared. See push_file_scope. */
4205 if (name
[0] == '_' && (name
[1] == '_' || ISUPPER (name
[1])))
4207 DECL_CHAIN (decl
) = visible_builtins
;
4208 visible_builtins
= decl
;
4215 c_builtin_function_ext_scope (tree decl
)
4217 tree type
= TREE_TYPE (decl
);
4218 tree id
= DECL_NAME (decl
);
4220 const char *name
= IDENTIFIER_POINTER (id
);
4221 C_DECL_BUILTIN_PROTOTYPE (decl
) = prototype_p (type
);
4224 bind (id
, decl
, external_scope
, /*invisible=*/false, /*nested=*/false,
4227 /* Builtins in the implementation namespace are made visible without
4228 needing to be explicitly declared. See push_file_scope. */
4229 if (name
[0] == '_' && (name
[1] == '_' || ISUPPER (name
[1])))
4231 DECL_CHAIN (decl
) = visible_builtins
;
4232 visible_builtins
= decl
;
4238 /* Called when a declaration is seen that contains no names to declare.
4239 If its type is a reference to a structure, union or enum inherited
4240 from a containing scope, shadow that tag name for the current scope
4241 with a forward reference.
4242 If its type defines a new named structure or union
4243 or defines an enum, it is valid but we need not do anything here.
4244 Otherwise, it is an error. */
4247 shadow_tag (const struct c_declspecs
*declspecs
)
4249 shadow_tag_warned (declspecs
, 0);
4252 /* WARNED is 1 if we have done a pedwarn, 2 if we have done a warning,
4255 shadow_tag_warned (const struct c_declspecs
*declspecs
, int warned
)
4257 bool found_tag
= false;
4259 if (declspecs
->type
&& !declspecs
->default_int_p
&& !declspecs
->typedef_p
)
4261 tree value
= declspecs
->type
;
4262 enum tree_code code
= TREE_CODE (value
);
4264 if (code
== RECORD_TYPE
|| code
== UNION_TYPE
|| code
== ENUMERAL_TYPE
)
4265 /* Used to test also that TYPE_SIZE (value) != 0.
4266 That caused warning for `struct foo;' at top level in the file. */
4268 tree name
= TYPE_NAME (value
);
4273 if (declspecs
->restrict_p
)
4275 error ("invalid use of %<restrict%>");
4279 if (name
== NULL_TREE
)
4281 if (warned
!= 1 && code
!= ENUMERAL_TYPE
)
4282 /* Empty unnamed enum OK */
4284 pedwarn (input_location
, 0,
4285 "unnamed struct/union that defines no instances");
4289 else if (declspecs
->typespec_kind
!= ctsk_tagdef
4290 && declspecs
->typespec_kind
!= ctsk_tagfirstref
4291 && declspecs
->storage_class
!= csc_none
)
4294 pedwarn (input_location
, 0,
4295 "empty declaration with storage class specifier "
4296 "does not redeclare tag");
4298 pending_xref_error ();
4300 else if (declspecs
->typespec_kind
!= ctsk_tagdef
4301 && declspecs
->typespec_kind
!= ctsk_tagfirstref
4302 && (declspecs
->const_p
4303 || declspecs
->volatile_p
4304 || declspecs
->atomic_p
4305 || declspecs
->restrict_p
4306 || declspecs
->address_space
))
4309 pedwarn (input_location
, 0,
4310 "empty declaration with type qualifier "
4311 "does not redeclare tag");
4313 pending_xref_error ();
4315 else if (declspecs
->typespec_kind
!= ctsk_tagdef
4316 && declspecs
->typespec_kind
!= ctsk_tagfirstref
4317 && declspecs
->alignas_p
)
4320 pedwarn (input_location
, 0,
4321 "empty declaration with %<_Alignas%> "
4322 "does not redeclare tag");
4324 pending_xref_error ();
4328 pending_invalid_xref
= NULL_TREE
;
4329 t
= lookup_tag (code
, name
, true, NULL
);
4333 t
= make_node (code
);
4334 pushtag (input_location
, name
, t
);
4340 if (warned
!= 1 && !in_system_header_at (input_location
))
4342 pedwarn (input_location
, 0,
4343 "useless type name in empty declaration");
4348 else if (warned
!= 1 && !in_system_header_at (input_location
)
4349 && declspecs
->typedef_p
)
4351 pedwarn (input_location
, 0, "useless type name in empty declaration");
4355 pending_invalid_xref
= NULL_TREE
;
4357 if (declspecs
->inline_p
)
4359 error ("%<inline%> in empty declaration");
4363 if (declspecs
->noreturn_p
)
4365 error ("%<_Noreturn%> in empty declaration");
4369 if (current_scope
== file_scope
&& declspecs
->storage_class
== csc_auto
)
4371 error ("%<auto%> in file-scope empty declaration");
4375 if (current_scope
== file_scope
&& declspecs
->storage_class
== csc_register
)
4377 error ("%<register%> in file-scope empty declaration");
4381 if (!warned
&& !in_system_header_at (input_location
)
4382 && declspecs
->storage_class
!= csc_none
)
4384 warning (0, "useless storage class specifier in empty declaration");
4388 if (!warned
&& !in_system_header_at (input_location
) && declspecs
->thread_p
)
4390 warning (0, "useless %qs in empty declaration",
4391 declspecs
->thread_gnu_p
? "__thread" : "_Thread_local");
4396 && !in_system_header_at (input_location
)
4397 && (declspecs
->const_p
4398 || declspecs
->volatile_p
4399 || declspecs
->atomic_p
4400 || declspecs
->restrict_p
4401 || declspecs
->address_space
))
4403 warning (0, "useless type qualifier in empty declaration");
4407 if (!warned
&& !in_system_header_at (input_location
)
4408 && declspecs
->alignas_p
)
4410 warning (0, "useless %<_Alignas%> in empty declaration");
4417 pedwarn (input_location
, 0, "empty declaration");
4422 /* Return the qualifiers from SPECS as a bitwise OR of TYPE_QUAL_*
4423 bits. SPECS represents declaration specifiers that the grammar
4424 only permits to contain type qualifiers and attributes. */
4427 quals_from_declspecs (const struct c_declspecs
*specs
)
4429 int quals
= ((specs
->const_p
? TYPE_QUAL_CONST
: 0)
4430 | (specs
->volatile_p
? TYPE_QUAL_VOLATILE
: 0)
4431 | (specs
->restrict_p
? TYPE_QUAL_RESTRICT
: 0)
4432 | (specs
->atomic_p
? TYPE_QUAL_ATOMIC
: 0)
4433 | (ENCODE_QUAL_ADDR_SPACE (specs
->address_space
)));
4434 gcc_assert (!specs
->type
4435 && !specs
->decl_attr
4436 && specs
->typespec_word
== cts_none
4437 && specs
->storage_class
== csc_none
4438 && !specs
->typedef_p
4439 && !specs
->explicit_signed_p
4440 && !specs
->deprecated_p
4442 && !specs
->long_long_p
4445 && !specs
->unsigned_p
4446 && !specs
->complex_p
4448 && !specs
->noreturn_p
4449 && !specs
->thread_p
);
4453 /* Construct an array declarator. LOC is the location of the
4454 beginning of the array (usually the opening brace). EXPR is the
4455 expression inside [], or NULL_TREE. QUALS are the type qualifiers
4456 inside the [] (to be applied to the pointer to which a parameter
4457 array is converted). STATIC_P is true if "static" is inside the
4458 [], false otherwise. VLA_UNSPEC_P is true if the array is [*], a
4459 VLA of unspecified length which is nevertheless a complete type,
4460 false otherwise. The field for the contained declarator is left to
4461 be filled in by set_array_declarator_inner. */
4463 struct c_declarator
*
4464 build_array_declarator (location_t loc
,
4465 tree expr
, struct c_declspecs
*quals
, bool static_p
,
4468 struct c_declarator
*declarator
= XOBNEW (&parser_obstack
,
4469 struct c_declarator
);
4470 declarator
->id_loc
= loc
;
4471 declarator
->kind
= cdk_array
;
4472 declarator
->declarator
= 0;
4473 declarator
->u
.array
.dimen
= expr
;
4476 declarator
->u
.array
.attrs
= quals
->attrs
;
4477 declarator
->u
.array
.quals
= quals_from_declspecs (quals
);
4481 declarator
->u
.array
.attrs
= NULL_TREE
;
4482 declarator
->u
.array
.quals
= 0;
4484 declarator
->u
.array
.static_p
= static_p
;
4485 declarator
->u
.array
.vla_unspec_p
= vla_unspec_p
;
4486 if (static_p
|| quals
!= NULL
)
4487 pedwarn_c90 (loc
, OPT_Wpedantic
,
4488 "ISO C90 does not support %<static%> or type "
4489 "qualifiers in parameter array declarators");
4491 pedwarn_c90 (loc
, OPT_Wpedantic
,
4492 "ISO C90 does not support %<[*]%> array declarators");
4495 if (!current_scope
->parm_flag
)
4498 error_at (loc
, "%<[*]%> not allowed in other than "
4499 "function prototype scope");
4500 declarator
->u
.array
.vla_unspec_p
= false;
4503 current_scope
->had_vla_unspec
= true;
4508 /* Set the contained declarator of an array declarator. DECL is the
4509 declarator, as constructed by build_array_declarator; INNER is what
4510 appears on the left of the []. */
4512 struct c_declarator
*
4513 set_array_declarator_inner (struct c_declarator
*decl
,
4514 struct c_declarator
*inner
)
4516 decl
->declarator
= inner
;
4520 /* INIT is a constructor that forms DECL's initializer. If the final
4521 element initializes a flexible array field, add the size of that
4522 initializer to DECL's size. */
4525 add_flexible_array_elts_to_size (tree decl
, tree init
)
4529 if (vec_safe_is_empty (CONSTRUCTOR_ELTS (init
)))
4532 elt
= CONSTRUCTOR_ELTS (init
)->last ().value
;
4533 type
= TREE_TYPE (elt
);
4534 if (TREE_CODE (type
) == ARRAY_TYPE
4535 && TYPE_SIZE (type
) == NULL_TREE
4536 && TYPE_DOMAIN (type
) != NULL_TREE
4537 && TYPE_MAX_VALUE (TYPE_DOMAIN (type
)) == NULL_TREE
)
4539 complete_array_type (&type
, elt
, false);
4541 = size_binop (PLUS_EXPR
, DECL_SIZE (decl
), TYPE_SIZE (type
));
4542 DECL_SIZE_UNIT (decl
)
4543 = size_binop (PLUS_EXPR
, DECL_SIZE_UNIT (decl
), TYPE_SIZE_UNIT (type
));
4547 /* Decode a "typename", such as "int **", returning a ..._TYPE node.
4548 Set *EXPR, if EXPR not NULL, to any expression to be evaluated
4549 before the type name, and set *EXPR_CONST_OPERANDS, if
4550 EXPR_CONST_OPERANDS not NULL, to indicate whether the type name may
4551 appear in a constant expression. */
4554 groktypename (struct c_type_name
*type_name
, tree
*expr
,
4555 bool *expr_const_operands
)
4558 tree attrs
= type_name
->specs
->attrs
;
4560 type_name
->specs
->attrs
= NULL_TREE
;
4562 type
= grokdeclarator (type_name
->declarator
, type_name
->specs
, TYPENAME
,
4563 false, NULL
, &attrs
, expr
, expr_const_operands
,
4566 /* Apply attributes. */
4567 decl_attributes (&type
, attrs
, 0);
4572 /* Wrapper for decl_attributes that adds some implicit attributes
4573 to VAR_DECLs or FUNCTION_DECLs. */
4576 c_decl_attributes (tree
*node
, tree attributes
, int flags
)
4578 /* Add implicit "omp declare target" attribute if requested. */
4579 if (current_omp_declare_target_attribute
4580 && ((VAR_P (*node
) && is_global_var (*node
))
4581 || TREE_CODE (*node
) == FUNCTION_DECL
))
4584 && !lang_hooks
.types
.omp_mappable_type (TREE_TYPE (*node
)))
4585 error ("%q+D in declare target directive does not have mappable type",
4588 attributes
= tree_cons (get_identifier ("omp declare target"),
4589 NULL_TREE
, attributes
);
4591 return decl_attributes (node
, attributes
, flags
);
4595 /* Decode a declarator in an ordinary declaration or data definition.
4596 This is called as soon as the type information and variable name
4597 have been parsed, before parsing the initializer if any.
4598 Here we create the ..._DECL node, fill in its type,
4599 and put it on the list of decls for the current context.
4600 The ..._DECL node is returned as the value.
4602 Exception: for arrays where the length is not specified,
4603 the type is left null, to be filled in by `finish_decl'.
4605 Function definitions do not come here; they go to start_function
4606 instead. However, external and forward declarations of functions
4607 do go through here. Structure field declarations are done by
4608 grokfield and not through here. */
4611 start_decl (struct c_declarator
*declarator
, struct c_declspecs
*declspecs
,
4612 bool initialized
, tree attributes
)
4616 tree expr
= NULL_TREE
;
4617 enum deprecated_states deprecated_state
= DEPRECATED_NORMAL
;
4619 /* An object declared as __attribute__((deprecated)) suppresses
4620 warnings of uses of other deprecated items. */
4621 if (lookup_attribute ("deprecated", attributes
))
4622 deprecated_state
= DEPRECATED_SUPPRESS
;
4624 decl
= grokdeclarator (declarator
, declspecs
,
4625 NORMAL
, initialized
, NULL
, &attributes
, &expr
, NULL
,
4627 if (!decl
|| decl
== error_mark_node
)
4631 add_stmt (fold_convert (void_type_node
, expr
));
4633 if (TREE_CODE (decl
) != FUNCTION_DECL
&& MAIN_NAME_P (DECL_NAME (decl
)))
4634 warning (OPT_Wmain
, "%q+D is usually a function", decl
);
4637 /* Is it valid for this decl to have an initializer at all?
4638 If not, set INITIALIZED to zero, which will indirectly
4639 tell 'finish_decl' to ignore the initializer once it is parsed. */
4640 switch (TREE_CODE (decl
))
4643 error ("typedef %qD is initialized (use __typeof__ instead)", decl
);
4644 initialized
= false;
4648 error ("function %qD is initialized like a variable", decl
);
4649 initialized
= false;
4653 /* DECL_INITIAL in a PARM_DECL is really DECL_ARG_TYPE. */
4654 error ("parameter %qD is initialized", decl
);
4655 initialized
= false;
4659 /* Don't allow initializations for incomplete types except for
4660 arrays which might be completed by the initialization. */
4662 /* This can happen if the array size is an undefined macro.
4663 We already gave a warning, so we don't need another one. */
4664 if (TREE_TYPE (decl
) == error_mark_node
)
4665 initialized
= false;
4666 else if (COMPLETE_TYPE_P (TREE_TYPE (decl
)))
4668 /* A complete type is ok if size is fixed. */
4670 if (TREE_CODE (TYPE_SIZE (TREE_TYPE (decl
))) != INTEGER_CST
4671 || C_DECL_VARIABLE_SIZE (decl
))
4673 error ("variable-sized object may not be initialized");
4674 initialized
= false;
4677 else if (TREE_CODE (TREE_TYPE (decl
)) != ARRAY_TYPE
)
4679 error ("variable %qD has initializer but incomplete type", decl
);
4680 initialized
= false;
4682 else if (C_DECL_VARIABLE_SIZE (decl
))
4684 /* Although C99 is unclear about whether incomplete arrays
4685 of VLAs themselves count as VLAs, it does not make
4686 sense to permit them to be initialized given that
4687 ordinary VLAs may not be initialized. */
4688 error ("variable-sized object may not be initialized");
4689 initialized
= false;
4695 if (current_scope
== file_scope
)
4696 TREE_STATIC (decl
) = 1;
4698 /* Tell 'pushdecl' this is an initialized decl
4699 even though we don't yet have the initializer expression.
4700 Also tell 'finish_decl' it may store the real initializer. */
4701 DECL_INITIAL (decl
) = error_mark_node
;
4704 /* If this is a function declaration, write a record describing it to the
4705 prototypes file (if requested). */
4707 if (TREE_CODE (decl
) == FUNCTION_DECL
)
4708 gen_aux_info_record (decl
, 0, 0, prototype_p (TREE_TYPE (decl
)));
4710 /* ANSI specifies that a tentative definition which is not merged with
4711 a non-tentative definition behaves exactly like a definition with an
4712 initializer equal to zero. (Section 3.7.2)
4714 -fno-common gives strict ANSI behavior, though this tends to break
4715 a large body of code that grew up without this rule.
4717 Thread-local variables are never common, since there's no entrenched
4718 body of code to break, and it allows more efficient variable references
4719 in the presence of dynamic linking. */
4723 && TREE_PUBLIC (decl
)
4724 && !DECL_THREAD_LOCAL_P (decl
)
4726 DECL_COMMON (decl
) = 1;
4728 /* Set attributes here so if duplicate decl, will have proper attributes. */
4729 c_decl_attributes (&decl
, attributes
, 0);
4731 /* Handle gnu_inline attribute. */
4732 if (declspecs
->inline_p
4733 && !flag_gnu89_inline
4734 && TREE_CODE (decl
) == FUNCTION_DECL
4735 && (lookup_attribute ("gnu_inline", DECL_ATTRIBUTES (decl
))
4736 || current_function_decl
))
4738 if (declspecs
->storage_class
== csc_auto
&& current_scope
!= file_scope
)
4740 else if (declspecs
->storage_class
!= csc_static
)
4741 DECL_EXTERNAL (decl
) = !DECL_EXTERNAL (decl
);
4744 if (TREE_CODE (decl
) == FUNCTION_DECL
4745 && targetm
.calls
.promote_prototypes (TREE_TYPE (decl
)))
4747 struct c_declarator
*ce
= declarator
;
4749 if (ce
->kind
== cdk_pointer
)
4750 ce
= declarator
->declarator
;
4751 if (ce
->kind
== cdk_function
)
4753 tree args
= ce
->u
.arg_info
->parms
;
4754 for (; args
; args
= DECL_CHAIN (args
))
4756 tree type
= TREE_TYPE (args
);
4757 if (type
&& INTEGRAL_TYPE_P (type
)
4758 && TYPE_PRECISION (type
) < TYPE_PRECISION (integer_type_node
))
4759 DECL_ARG_TYPE (args
) = c_type_promotes_to (type
);
4764 if (TREE_CODE (decl
) == FUNCTION_DECL
4765 && DECL_DECLARED_INLINE_P (decl
)
4766 && DECL_UNINLINABLE (decl
)
4767 && lookup_attribute ("noinline", DECL_ATTRIBUTES (decl
)))
4768 warning (OPT_Wattributes
, "inline function %q+D given attribute noinline",
4771 /* C99 6.7.4p3: An inline definition of a function with external
4772 linkage shall not contain a definition of a modifiable object
4773 with static storage duration... */
4775 && current_scope
!= file_scope
4776 && TREE_STATIC (decl
)
4777 && !TREE_READONLY (decl
)
4778 && DECL_DECLARED_INLINE_P (current_function_decl
)
4779 && DECL_EXTERNAL (current_function_decl
))
4780 record_inline_static (input_location
, current_function_decl
,
4781 decl
, csi_modifiable
);
4783 if (c_dialect_objc ()
4784 && VAR_OR_FUNCTION_DECL_P (decl
))
4785 objc_check_global_decl (decl
);
4787 /* Add this decl to the current scope.
4788 TEM may equal DECL or it may be a previous decl of the same name. */
4789 tem
= pushdecl (decl
);
4791 if (initialized
&& DECL_EXTERNAL (tem
))
4793 DECL_EXTERNAL (tem
) = 0;
4794 TREE_STATIC (tem
) = 1;
4800 /* Subroutine of finish_decl. TYPE is the type of an uninitialized object
4801 DECL or the non-array element type if DECL is an uninitialized array.
4802 If that type has a const member, diagnose this. */
4805 diagnose_uninitialized_cst_member (tree decl
, tree type
)
4808 for (field
= TYPE_FIELDS (type
); field
; field
= TREE_CHAIN (field
))
4811 if (TREE_CODE (field
) != FIELD_DECL
)
4813 field_type
= strip_array_types (TREE_TYPE (field
));
4815 if (TYPE_QUALS (field_type
) & TYPE_QUAL_CONST
)
4817 warning_at (DECL_SOURCE_LOCATION (decl
), OPT_Wc___compat
,
4818 "uninitialized const member in %qT is invalid in C++",
4819 strip_array_types (TREE_TYPE (decl
)));
4820 inform (DECL_SOURCE_LOCATION (field
), "%qD should be initialized", field
);
4823 if (RECORD_OR_UNION_TYPE_P (field_type
))
4824 diagnose_uninitialized_cst_member (decl
, field_type
);
4828 /* Finish processing of a declaration;
4829 install its initial value.
4830 If ORIGTYPE is not NULL_TREE, it is the original type of INIT.
4831 If the length of an array type is not known before,
4832 it must be determined now, from the initial value, or it is an error.
4834 INIT_LOC is the location of the initial value. */
4837 finish_decl (tree decl
, location_t init_loc
, tree init
,
4838 tree origtype
, tree asmspec_tree
)
4841 bool was_incomplete
= (DECL_SIZE (decl
) == NULL_TREE
);
4842 const char *asmspec
= 0;
4844 /* If a name was specified, get the string. */
4845 if (VAR_OR_FUNCTION_DECL_P (decl
)
4846 && DECL_FILE_SCOPE_P (decl
))
4847 asmspec_tree
= maybe_apply_renaming_pragma (decl
, asmspec_tree
);
4849 asmspec
= TREE_STRING_POINTER (asmspec_tree
);
4852 && TREE_STATIC (decl
)
4853 && global_bindings_p ())
4854 /* So decl is a global variable. Record the types it uses
4855 so that we can decide later to emit debug info for them. */
4856 record_types_used_by_current_var_decl (decl
);
4858 /* If `start_decl' didn't like having an initialization, ignore it now. */
4859 if (init
!= NULL_TREE
&& DECL_INITIAL (decl
) == NULL_TREE
)
4862 /* Don't crash if parm is initialized. */
4863 if (TREE_CODE (decl
) == PARM_DECL
)
4867 store_init_value (init_loc
, decl
, init
, origtype
);
4869 if (c_dialect_objc () && (VAR_OR_FUNCTION_DECL_P (decl
)
4870 || TREE_CODE (decl
) == FIELD_DECL
))
4871 objc_check_decl (decl
);
4873 type
= TREE_TYPE (decl
);
4875 /* Deduce size of array from initialization, if not already known. */
4876 if (TREE_CODE (type
) == ARRAY_TYPE
4877 && TYPE_DOMAIN (type
) == NULL_TREE
4878 && TREE_CODE (decl
) != TYPE_DECL
)
4881 = (TREE_STATIC (decl
)
4882 /* Even if pedantic, an external linkage array
4883 may have incomplete type at first. */
4884 ? pedantic
&& !TREE_PUBLIC (decl
)
4885 : !DECL_EXTERNAL (decl
));
4887 = complete_array_type (&TREE_TYPE (decl
), DECL_INITIAL (decl
),
4890 /* Get the completed type made by complete_array_type. */
4891 type
= TREE_TYPE (decl
);
4896 error ("initializer fails to determine size of %q+D", decl
);
4901 error ("array size missing in %q+D", decl
);
4902 /* If a `static' var's size isn't known,
4903 make it extern as well as static, so it does not get
4905 If it is not `static', then do not mark extern;
4906 finish_incomplete_decl will give it a default size
4907 and it will get allocated. */
4908 else if (!pedantic
&& TREE_STATIC (decl
) && !TREE_PUBLIC (decl
))
4909 DECL_EXTERNAL (decl
) = 1;
4913 error ("zero or negative size array %q+D", decl
);
4917 /* For global variables, update the copy of the type that
4918 exists in the binding. */
4919 if (TREE_PUBLIC (decl
))
4921 struct c_binding
*b_ext
= I_SYMBOL_BINDING (DECL_NAME (decl
));
4922 while (b_ext
&& !B_IN_EXTERNAL_SCOPE (b_ext
))
4923 b_ext
= b_ext
->shadowed
;
4924 if (b_ext
&& TREE_CODE (decl
) == TREE_CODE (b_ext
->decl
))
4926 if (b_ext
->u
.type
&& comptypes (b_ext
->u
.type
, type
))
4927 b_ext
->u
.type
= composite_type (b_ext
->u
.type
, type
);
4929 b_ext
->u
.type
= type
;
4938 if (DECL_INITIAL (decl
))
4939 TREE_TYPE (DECL_INITIAL (decl
)) = type
;
4941 relayout_decl (decl
);
4946 if (init
&& TREE_CODE (init
) == CONSTRUCTOR
)
4947 add_flexible_array_elts_to_size (decl
, init
);
4949 if (DECL_SIZE (decl
) == NULL_TREE
&& TREE_TYPE (decl
) != error_mark_node
4950 && COMPLETE_TYPE_P (TREE_TYPE (decl
)))
4951 layout_decl (decl
, 0);
4953 if (DECL_SIZE (decl
) == NULL_TREE
4954 /* Don't give an error if we already gave one earlier. */
4955 && TREE_TYPE (decl
) != error_mark_node
4956 && (TREE_STATIC (decl
)
4957 /* A static variable with an incomplete type
4958 is an error if it is initialized.
4959 Also if it is not file scope.
4960 Otherwise, let it through, but if it is not `extern'
4961 then it may cause an error message later. */
4962 ? (DECL_INITIAL (decl
) != NULL_TREE
4963 || !DECL_FILE_SCOPE_P (decl
))
4964 /* An automatic variable with an incomplete type
4966 : !DECL_EXTERNAL (decl
)))
4968 error ("storage size of %q+D isn%'t known", decl
);
4969 TREE_TYPE (decl
) = error_mark_node
;
4972 if ((RECORD_OR_UNION_TYPE_P (TREE_TYPE (decl
))
4973 || TREE_CODE (TREE_TYPE (decl
)) == ENUMERAL_TYPE
)
4974 && DECL_SIZE (decl
) == NULL_TREE
4975 && TREE_STATIC (decl
))
4976 incomplete_record_decls
.safe_push (decl
);
4978 if (is_global_var (decl
) && DECL_SIZE (decl
) != NULL_TREE
)
4980 if (TREE_CODE (DECL_SIZE (decl
)) == INTEGER_CST
)
4981 constant_expression_warning (DECL_SIZE (decl
));
4984 error ("storage size of %q+D isn%'t constant", decl
);
4985 TREE_TYPE (decl
) = error_mark_node
;
4989 if (TREE_USED (type
))
4991 TREE_USED (decl
) = 1;
4992 DECL_READ_P (decl
) = 1;
4996 /* If this is a function and an assembler name is specified, reset DECL_RTL
4997 so we can give it its new name. Also, update builtin_decl if it
4998 was a normal built-in. */
4999 if (TREE_CODE (decl
) == FUNCTION_DECL
&& asmspec
)
5001 if (DECL_BUILT_IN_CLASS (decl
) == BUILT_IN_NORMAL
)
5002 set_builtin_user_assembler_name (decl
, asmspec
);
5003 set_user_assembler_name (decl
, asmspec
);
5006 /* If #pragma weak was used, mark the decl weak now. */
5007 maybe_apply_pragma_weak (decl
);
5009 /* Output the assembler code and/or RTL code for variables and functions,
5010 unless the type is an undefined structure or union.
5011 If not, it will get done when the type is completed. */
5013 if (VAR_OR_FUNCTION_DECL_P (decl
))
5015 /* Determine the ELF visibility. */
5016 if (TREE_PUBLIC (decl
))
5017 c_determine_visibility (decl
);
5019 /* This is a no-op in c-lang.c or something real in objc-act.c. */
5020 if (c_dialect_objc ())
5021 objc_check_decl (decl
);
5025 /* If this is not a static variable, issue a warning.
5026 It doesn't make any sense to give an ASMSPEC for an
5027 ordinary, non-register local variable. Historically,
5028 GCC has accepted -- but ignored -- the ASMSPEC in
5030 if (!DECL_FILE_SCOPE_P (decl
)
5032 && !C_DECL_REGISTER (decl
)
5033 && !TREE_STATIC (decl
))
5034 warning (0, "ignoring asm-specifier for non-static local "
5035 "variable %q+D", decl
);
5037 set_user_assembler_name (decl
, asmspec
);
5040 if (DECL_FILE_SCOPE_P (decl
))
5042 if (DECL_INITIAL (decl
) == NULL_TREE
5043 || DECL_INITIAL (decl
) == error_mark_node
)
5044 /* Don't output anything
5045 when a tentative file-scope definition is seen.
5046 But at end of compilation, do output code for them. */
5047 DECL_DEFER_OUTPUT (decl
) = 1;
5048 if (asmspec
&& VAR_P (decl
) && C_DECL_REGISTER (decl
))
5049 DECL_HARD_REGISTER (decl
) = 1;
5050 rest_of_decl_compilation (decl
, true, 0);
5054 /* In conjunction with an ASMSPEC, the `register'
5055 keyword indicates that we should place the variable
5056 in a particular register. */
5057 if (asmspec
&& C_DECL_REGISTER (decl
))
5059 DECL_HARD_REGISTER (decl
) = 1;
5060 /* This cannot be done for a structure with volatile
5061 fields, on which DECL_REGISTER will have been
5063 if (!DECL_REGISTER (decl
))
5064 error ("cannot put object with volatile field into register");
5067 if (TREE_CODE (decl
) != FUNCTION_DECL
)
5069 /* If we're building a variable sized type, and we might be
5070 reachable other than via the top of the current binding
5071 level, then create a new BIND_EXPR so that we deallocate
5072 the object at the right time. */
5073 /* Note that DECL_SIZE can be null due to errors. */
5074 if (DECL_SIZE (decl
)
5075 && !TREE_CONSTANT (DECL_SIZE (decl
))
5076 && STATEMENT_LIST_HAS_LABEL (cur_stmt_list
))
5079 bind
= build3 (BIND_EXPR
, void_type_node
, NULL
, NULL
, NULL
);
5080 TREE_SIDE_EFFECTS (bind
) = 1;
5082 BIND_EXPR_BODY (bind
) = push_stmt_list ();
5084 add_stmt (build_stmt (DECL_SOURCE_LOCATION (decl
),
5090 if (!DECL_FILE_SCOPE_P (decl
))
5092 /* Recompute the RTL of a local array now
5093 if it used to be an incomplete type. */
5094 if (was_incomplete
&& !is_global_var (decl
))
5096 /* If we used it already as memory, it must stay in memory. */
5097 TREE_ADDRESSABLE (decl
) = TREE_USED (decl
);
5098 /* If it's still incomplete now, no init will save it. */
5099 if (DECL_SIZE (decl
) == NULL_TREE
)
5100 DECL_INITIAL (decl
) = NULL_TREE
;
5105 if (TREE_CODE (decl
) == TYPE_DECL
)
5107 if (!DECL_FILE_SCOPE_P (decl
)
5108 && variably_modified_type_p (TREE_TYPE (decl
), NULL_TREE
))
5109 add_stmt (build_stmt (DECL_SOURCE_LOCATION (decl
), DECL_EXPR
, decl
));
5111 rest_of_decl_compilation (decl
, DECL_FILE_SCOPE_P (decl
), 0);
5114 /* Install a cleanup (aka destructor) if one was given. */
5115 if (VAR_P (decl
) && !TREE_STATIC (decl
))
5117 tree attr
= lookup_attribute ("cleanup", DECL_ATTRIBUTES (decl
));
5120 tree cleanup_id
= TREE_VALUE (TREE_VALUE (attr
));
5121 tree cleanup_decl
= lookup_name (cleanup_id
);
5123 vec
<tree
, va_gc
> *v
;
5125 /* Build "cleanup(&decl)" for the destructor. */
5126 cleanup
= build_unary_op (input_location
, ADDR_EXPR
, decl
, false);
5128 v
->quick_push (cleanup
);
5129 cleanup
= c_build_function_call_vec (DECL_SOURCE_LOCATION (decl
),
5130 vNULL
, cleanup_decl
, v
, NULL
);
5133 /* Don't warn about decl unused; the cleanup uses it. */
5134 TREE_USED (decl
) = 1;
5135 TREE_USED (cleanup_decl
) = 1;
5136 DECL_READ_P (decl
) = 1;
5138 push_cleanup (decl
, cleanup
, false);
5144 && !DECL_EXTERNAL (decl
)
5145 && DECL_INITIAL (decl
) == NULL_TREE
)
5147 type
= strip_array_types (type
);
5148 if (TREE_READONLY (decl
))
5149 warning_at (DECL_SOURCE_LOCATION (decl
), OPT_Wc___compat
,
5150 "uninitialized const %qD is invalid in C++", decl
);
5151 else if (RECORD_OR_UNION_TYPE_P (type
)
5152 && C_TYPE_FIELDS_READONLY (type
))
5153 diagnose_uninitialized_cst_member (decl
, type
);
5156 invoke_plugin_callbacks (PLUGIN_FINISH_DECL
, decl
);
5159 /* Given a parsed parameter declaration, decode it into a PARM_DECL.
5160 EXPR is NULL or a pointer to an expression that needs to be
5161 evaluated for the side effects of array size expressions in the
5165 grokparm (const struct c_parm
*parm
, tree
*expr
)
5167 tree attrs
= parm
->attrs
;
5168 tree decl
= grokdeclarator (parm
->declarator
, parm
->specs
, PARM
, false,
5169 NULL
, &attrs
, expr
, NULL
, DEPRECATED_NORMAL
);
5171 decl_attributes (&decl
, attrs
, 0);
5176 /* Given a parsed parameter declaration, decode it into a PARM_DECL
5177 and push that on the current scope. EXPR is a pointer to an
5178 expression that needs to be evaluated for the side effects of array
5179 size expressions in the parameters. */
5182 push_parm_decl (const struct c_parm
*parm
, tree
*expr
)
5184 tree attrs
= parm
->attrs
;
5187 decl
= grokdeclarator (parm
->declarator
, parm
->specs
, PARM
, false, NULL
,
5188 &attrs
, expr
, NULL
, DEPRECATED_NORMAL
);
5189 decl_attributes (&decl
, attrs
, 0);
5191 decl
= pushdecl (decl
);
5193 finish_decl (decl
, input_location
, NULL_TREE
, NULL_TREE
, NULL_TREE
);
5196 /* Mark all the parameter declarations to date as forward decls.
5197 Also diagnose use of this extension. */
5200 mark_forward_parm_decls (void)
5202 struct c_binding
*b
;
5204 if (pedantic
&& !current_scope
->warned_forward_parm_decls
)
5206 pedwarn (input_location
, OPT_Wpedantic
,
5207 "ISO C forbids forward parameter declarations");
5208 current_scope
->warned_forward_parm_decls
= true;
5211 for (b
= current_scope
->bindings
; b
; b
= b
->prev
)
5212 if (TREE_CODE (b
->decl
) == PARM_DECL
)
5213 TREE_ASM_WRITTEN (b
->decl
) = 1;
5216 /* Build a COMPOUND_LITERAL_EXPR. TYPE is the type given in the compound
5217 literal, which may be an incomplete array type completed by the
5218 initializer; INIT is a CONSTRUCTOR at LOC that initializes the compound
5219 literal. NON_CONST is true if the initializers contain something
5220 that cannot occur in a constant expression. */
5223 build_compound_literal (location_t loc
, tree type
, tree init
, bool non_const
)
5225 /* We do not use start_decl here because we have a type, not a declarator;
5226 and do not use finish_decl because the decl should be stored inside
5227 the COMPOUND_LITERAL_EXPR rather than added elsewhere as a DECL_EXPR. */
5232 if (type
== error_mark_node
5233 || init
== error_mark_node
)
5234 return error_mark_node
;
5236 decl
= build_decl (loc
, VAR_DECL
, NULL_TREE
, type
);
5237 DECL_EXTERNAL (decl
) = 0;
5238 TREE_PUBLIC (decl
) = 0;
5239 TREE_STATIC (decl
) = (current_scope
== file_scope
);
5240 DECL_CONTEXT (decl
) = current_function_decl
;
5241 TREE_USED (decl
) = 1;
5242 DECL_READ_P (decl
) = 1;
5243 DECL_ARTIFICIAL (decl
) = 1;
5244 DECL_IGNORED_P (decl
) = 1;
5245 TREE_TYPE (decl
) = type
;
5246 TREE_READONLY (decl
) = (TYPE_READONLY (type
)
5247 || (TREE_CODE (type
) == ARRAY_TYPE
5248 && TYPE_READONLY (TREE_TYPE (type
))));
5249 store_init_value (loc
, decl
, init
, NULL_TREE
);
5251 if (TREE_CODE (type
) == ARRAY_TYPE
&& !COMPLETE_TYPE_P (type
))
5253 int failure
= complete_array_type (&TREE_TYPE (decl
),
5254 DECL_INITIAL (decl
), true);
5255 /* If complete_array_type returns 3, it means that the
5256 initial value of the compound literal is empty. Allow it. */
5257 gcc_assert (failure
== 0 || failure
== 3);
5259 type
= TREE_TYPE (decl
);
5260 TREE_TYPE (DECL_INITIAL (decl
)) = type
;
5263 if (type
== error_mark_node
|| !COMPLETE_TYPE_P (type
))
5265 c_incomplete_type_error (loc
, NULL_TREE
, type
);
5266 return error_mark_node
;
5269 stmt
= build_stmt (DECL_SOURCE_LOCATION (decl
), DECL_EXPR
, decl
);
5270 complit
= build1 (COMPOUND_LITERAL_EXPR
, type
, stmt
);
5271 TREE_SIDE_EFFECTS (complit
) = 1;
5273 layout_decl (decl
, 0);
5275 if (TREE_STATIC (decl
))
5277 /* This decl needs a name for the assembler output. */
5278 set_compound_literal_name (decl
);
5279 DECL_DEFER_OUTPUT (decl
) = 1;
5280 DECL_COMDAT (decl
) = 1;
5282 rest_of_decl_compilation (decl
, 1, 0);
5287 complit
= build2 (C_MAYBE_CONST_EXPR
, type
, NULL
, complit
);
5288 C_MAYBE_CONST_EXPR_NON_CONST (complit
) = 1;
5294 /* Check the type of a compound literal. Here we just check that it
5295 is valid for C++. */
5298 check_compound_literal_type (location_t loc
, struct c_type_name
*type_name
)
5301 && (type_name
->specs
->typespec_kind
== ctsk_tagdef
5302 || type_name
->specs
->typespec_kind
== ctsk_tagfirstref
))
5303 warning_at (loc
, OPT_Wc___compat
,
5304 "defining a type in a compound literal is invalid in C++");
5307 /* Determine whether TYPE is a structure with a flexible array member,
5308 or a union containing such a structure (possibly recursively). */
5311 flexible_array_type_p (tree type
)
5314 switch (TREE_CODE (type
))
5317 x
= TYPE_FIELDS (type
);
5320 while (DECL_CHAIN (x
) != NULL_TREE
)
5322 if (TREE_CODE (TREE_TYPE (x
)) == ARRAY_TYPE
5323 && TYPE_SIZE (TREE_TYPE (x
)) == NULL_TREE
5324 && TYPE_DOMAIN (TREE_TYPE (x
)) != NULL_TREE
5325 && TYPE_MAX_VALUE (TYPE_DOMAIN (TREE_TYPE (x
))) == NULL_TREE
)
5329 for (x
= TYPE_FIELDS (type
); x
!= NULL_TREE
; x
= DECL_CHAIN (x
))
5331 if (flexible_array_type_p (TREE_TYPE (x
)))
5340 /* Performs sanity checks on the TYPE and WIDTH of the bit-field NAME,
5341 replacing with appropriate values if they are invalid. */
5344 check_bitfield_type_and_width (location_t loc
, tree
*type
, tree
*width
,
5348 unsigned int max_width
;
5349 unsigned HOST_WIDE_INT w
;
5350 const char *name
= (orig_name
5351 ? identifier_to_locale (IDENTIFIER_POINTER (orig_name
))
5352 : _("<anonymous>"));
5354 /* Detect and ignore out of range field width and process valid
5356 if (!INTEGRAL_TYPE_P (TREE_TYPE (*width
)))
5358 error_at (loc
, "bit-field %qs width not an integer constant", name
);
5359 *width
= integer_one_node
;
5363 if (TREE_CODE (*width
) != INTEGER_CST
)
5365 *width
= c_fully_fold (*width
, false, NULL
);
5366 if (TREE_CODE (*width
) == INTEGER_CST
)
5367 pedwarn (loc
, OPT_Wpedantic
,
5368 "bit-field %qs width not an integer constant expression",
5371 if (TREE_CODE (*width
) != INTEGER_CST
)
5373 error_at (loc
, "bit-field %qs width not an integer constant", name
);
5374 *width
= integer_one_node
;
5376 constant_expression_warning (*width
);
5377 if (tree_int_cst_sgn (*width
) < 0)
5379 error_at (loc
, "negative width in bit-field %qs", name
);
5380 *width
= integer_one_node
;
5382 else if (integer_zerop (*width
) && orig_name
)
5384 error_at (loc
, "zero width for bit-field %qs", name
);
5385 *width
= integer_one_node
;
5389 /* Detect invalid bit-field type. */
5390 if (TREE_CODE (*type
) != INTEGER_TYPE
5391 && TREE_CODE (*type
) != BOOLEAN_TYPE
5392 && TREE_CODE (*type
) != ENUMERAL_TYPE
)
5394 error_at (loc
, "bit-field %qs has invalid type", name
);
5395 *type
= unsigned_type_node
;
5398 type_mv
= TYPE_MAIN_VARIANT (*type
);
5399 if (!in_system_header_at (input_location
)
5400 && type_mv
!= integer_type_node
5401 && type_mv
!= unsigned_type_node
5402 && type_mv
!= boolean_type_node
)
5403 pedwarn_c90 (loc
, OPT_Wpedantic
,
5404 "type of bit-field %qs is a GCC extension", name
);
5406 max_width
= TYPE_PRECISION (*type
);
5408 if (0 < compare_tree_int (*width
, max_width
))
5410 error_at (loc
, "width of %qs exceeds its type", name
);
5412 *width
= build_int_cst (integer_type_node
, w
);
5415 w
= tree_to_uhwi (*width
);
5417 if (TREE_CODE (*type
) == ENUMERAL_TYPE
)
5419 struct lang_type
*lt
= TYPE_LANG_SPECIFIC (*type
);
5421 || w
< tree_int_cst_min_precision (lt
->enum_min
, TYPE_SIGN (*type
))
5422 || w
< tree_int_cst_min_precision (lt
->enum_max
, TYPE_SIGN (*type
)))
5423 warning_at (loc
, 0, "%qs is narrower than values of its type", name
);
5429 /* Print warning about variable length array if necessary. */
5432 warn_variable_length_array (tree name
, tree size
)
5434 if (TREE_CONSTANT (size
))
5437 pedwarn_c90 (input_location
, OPT_Wvla
,
5438 "ISO C90 forbids array %qE whose size "
5439 "can%'t be evaluated", name
);
5441 pedwarn_c90 (input_location
, OPT_Wvla
, "ISO C90 forbids array "
5442 "whose size can%'t be evaluated");
5447 pedwarn_c90 (input_location
, OPT_Wvla
,
5448 "ISO C90 forbids variable length array %qE", name
);
5450 pedwarn_c90 (input_location
, OPT_Wvla
, "ISO C90 forbids variable "
5455 /* Print warning about defaulting to int if necessary. */
5458 warn_defaults_to (location_t location
, int opt
, const char *gmsgid
, ...)
5460 diagnostic_info diagnostic
;
5462 rich_location
richloc (line_table
, location
);
5464 va_start (ap
, gmsgid
);
5465 diagnostic_set_info (&diagnostic
, gmsgid
, &ap
, &richloc
,
5466 flag_isoc99
? DK_PEDWARN
: DK_WARNING
);
5467 diagnostic
.option_index
= opt
;
5468 diagnostic_report_diagnostic (global_dc
, &diagnostic
);
5472 /* Returns the smallest location != UNKNOWN_LOCATION in LOCATIONS,
5473 considering only those c_declspec_words found in LIST, which
5474 must be terminated by cdw_number_of_elements. */
5477 smallest_type_quals_location (const location_t
*locations
,
5478 const c_declspec_word
*list
)
5480 location_t loc
= UNKNOWN_LOCATION
;
5481 while (*list
!= cdw_number_of_elements
)
5483 location_t newloc
= locations
[*list
];
5484 if (loc
== UNKNOWN_LOCATION
5485 || (newloc
!= UNKNOWN_LOCATION
&& newloc
< loc
))
5493 /* Given declspecs and a declarator,
5494 determine the name and type of the object declared
5495 and construct a ..._DECL node for it.
5496 (In one case we can return a ..._TYPE node instead.
5497 For invalid input we sometimes return NULL_TREE.)
5499 DECLSPECS is a c_declspecs structure for the declaration specifiers.
5501 DECL_CONTEXT says which syntactic context this declaration is in:
5502 NORMAL for most contexts. Make a VAR_DECL or FUNCTION_DECL or TYPE_DECL.
5503 FUNCDEF for a function definition. Like NORMAL but a few different
5504 error messages in each case. Return value may be zero meaning
5505 this definition is too screwy to try to parse.
5506 PARM for a parameter declaration (either within a function prototype
5507 or before a function body). Make a PARM_DECL, or return void_type_node.
5508 TYPENAME if for a typename (in a cast or sizeof).
5509 Don't make a DECL node; just return the ..._TYPE node.
5510 FIELD for a struct or union field; make a FIELD_DECL.
5511 INITIALIZED is true if the decl has an initializer.
5512 WIDTH is non-NULL for bit-fields, and is a pointer to an INTEGER_CST node
5513 representing the width of the bit-field.
5514 DECL_ATTRS points to the list of attributes that should be added to this
5515 decl. Any nested attributes that belong on the decl itself will be
5517 If EXPR is not NULL, any expressions that need to be evaluated as
5518 part of evaluating variably modified types will be stored in *EXPR.
5519 If EXPR_CONST_OPERANDS is not NULL, *EXPR_CONST_OPERANDS will be
5520 set to indicate whether operands in *EXPR can be used in constant
5522 DEPRECATED_STATE is a deprecated_states value indicating whether
5523 deprecation warnings should be suppressed.
5525 In the TYPENAME case, DECLARATOR is really an absolute declarator.
5526 It may also be so in the PARM case, for a prototype where the
5527 argument type is specified but not the name.
5529 This function is where the complicated C meanings of `static'
5530 and `extern' are interpreted. */
5533 grokdeclarator (const struct c_declarator
*declarator
,
5534 struct c_declspecs
*declspecs
,
5535 enum decl_context decl_context
, bool initialized
, tree
*width
,
5536 tree
*decl_attrs
, tree
*expr
, bool *expr_const_operands
,
5537 enum deprecated_states deprecated_state
)
5539 tree type
= declspecs
->type
;
5540 bool threadp
= declspecs
->thread_p
;
5541 enum c_storage_class storage_class
= declspecs
->storage_class
;
5546 int type_quals
= TYPE_UNQUALIFIED
;
5547 tree name
= NULL_TREE
;
5548 bool funcdef_flag
= false;
5549 bool funcdef_syntax
= false;
5550 bool size_varies
= false;
5551 tree decl_attr
= declspecs
->decl_attr
;
5552 int array_ptr_quals
= TYPE_UNQUALIFIED
;
5553 tree array_ptr_attrs
= NULL_TREE
;
5554 bool array_parm_static
= false;
5555 bool array_parm_vla_unspec_p
= false;
5556 tree returned_attrs
= NULL_TREE
;
5557 bool bitfield
= width
!= NULL
;
5559 tree orig_qual_type
= NULL
;
5560 size_t orig_qual_indirect
= 0;
5561 struct c_arg_info
*arg_info
= 0;
5562 addr_space_t as1
, as2
, address_space
;
5563 location_t loc
= UNKNOWN_LOCATION
;
5565 bool expr_const_operands_dummy
;
5566 enum c_declarator_kind first_non_attr_kind
;
5567 unsigned int alignas_align
= 0;
5569 if (TREE_CODE (type
) == ERROR_MARK
)
5570 return error_mark_node
;
5574 expr_dummy
= NULL_TREE
;
5576 if (expr_const_operands
== NULL
)
5577 expr_const_operands
= &expr_const_operands_dummy
;
5579 if (declspecs
->expr
)
5582 *expr
= build2 (COMPOUND_EXPR
, TREE_TYPE (declspecs
->expr
), *expr
,
5585 *expr
= declspecs
->expr
;
5587 *expr_const_operands
= declspecs
->expr_const_operands
;
5589 if (decl_context
== FUNCDEF
)
5590 funcdef_flag
= true, decl_context
= NORMAL
;
5592 /* Look inside a declarator for the name being declared
5593 and get it as an IDENTIFIER_NODE, for an error message. */
5595 const struct c_declarator
*decl
= declarator
;
5597 first_non_attr_kind
= cdk_attrs
;
5607 funcdef_syntax
= (decl
->kind
== cdk_function
);
5608 if (first_non_attr_kind
== cdk_attrs
)
5609 first_non_attr_kind
= decl
->kind
;
5610 decl
= decl
->declarator
;
5614 decl
= decl
->declarator
;
5621 if (first_non_attr_kind
== cdk_attrs
)
5622 first_non_attr_kind
= decl
->kind
;
5629 if (name
== NULL_TREE
)
5631 gcc_assert (decl_context
== PARM
5632 || decl_context
== TYPENAME
5633 || (decl_context
== FIELD
5634 && declarator
->kind
== cdk_id
));
5635 gcc_assert (!initialized
);
5639 /* A function definition's declarator must have the form of
5640 a function declarator. */
5642 if (funcdef_flag
&& !funcdef_syntax
)
5645 /* If this looks like a function definition, make it one,
5646 even if it occurs where parms are expected.
5647 Then store_parm_decls will reject it and not use it as a parm. */
5648 if (decl_context
== NORMAL
&& !funcdef_flag
&& current_scope
->parm_flag
)
5649 decl_context
= PARM
;
5651 if (declspecs
->deprecated_p
&& deprecated_state
!= DEPRECATED_SUPPRESS
)
5652 warn_deprecated_use (declspecs
->type
, declspecs
->decl_attr
);
5654 if ((decl_context
== NORMAL
|| decl_context
== FIELD
)
5655 && current_scope
== file_scope
5656 && variably_modified_type_p (type
, NULL_TREE
))
5659 error_at (loc
, "variably modified %qE at file scope", name
);
5661 error_at (loc
, "variably modified field at file scope");
5662 type
= integer_type_node
;
5665 size_varies
= C_TYPE_VARIABLE_SIZE (type
) != 0;
5667 /* Diagnose defaulting to "int". */
5669 if (declspecs
->default_int_p
&& !in_system_header_at (input_location
))
5671 /* Issue a warning if this is an ISO C 99 program or if
5672 -Wreturn-type and this is a function, or if -Wimplicit;
5673 prefer the former warning since it is more explicit. */
5674 if ((warn_implicit_int
|| warn_return_type
|| flag_isoc99
)
5676 warn_about_return_type
= 1;
5680 warn_defaults_to (loc
, OPT_Wimplicit_int
,
5681 "type defaults to %<int%> in declaration "
5684 warn_defaults_to (loc
, OPT_Wimplicit_int
,
5685 "type defaults to %<int%> in type name");
5689 /* Adjust the type if a bit-field is being declared,
5690 -funsigned-bitfields applied and the type is not explicitly
5692 if (bitfield
&& !flag_signed_bitfields
&& !declspecs
->explicit_signed_p
5693 && TREE_CODE (type
) == INTEGER_TYPE
)
5694 type
= unsigned_type_for (type
);
5696 /* Figure out the type qualifiers for the declaration. There are
5697 two ways a declaration can become qualified. One is something
5698 like `const int i' where the `const' is explicit. Another is
5699 something like `typedef const int CI; CI i' where the type of the
5700 declaration contains the `const'. A third possibility is that
5701 there is a type qualifier on the element type of a typedefed
5702 array type, in which case we should extract that qualifier so
5703 that c_apply_type_quals_to_decl receives the full list of
5704 qualifiers to work with (C90 is not entirely clear about whether
5705 duplicate qualifiers should be diagnosed in this case, but it
5706 seems most appropriate to do so). */
5707 element_type
= strip_array_types (type
);
5708 constp
= declspecs
->const_p
+ TYPE_READONLY (element_type
);
5709 restrictp
= declspecs
->restrict_p
+ TYPE_RESTRICT (element_type
);
5710 volatilep
= declspecs
->volatile_p
+ TYPE_VOLATILE (element_type
);
5711 atomicp
= declspecs
->atomic_p
+ TYPE_ATOMIC (element_type
);
5712 as1
= declspecs
->address_space
;
5713 as2
= TYPE_ADDR_SPACE (element_type
);
5714 address_space
= ADDR_SPACE_GENERIC_P (as1
)? as2
: as1
;
5717 pedwarn_c90 (loc
, OPT_Wpedantic
, "duplicate %<const%>");
5719 pedwarn_c90 (loc
, OPT_Wpedantic
, "duplicate %<restrict%>");
5721 pedwarn_c90 (loc
, OPT_Wpedantic
, "duplicate %<volatile%>");
5723 pedwarn_c90 (loc
, OPT_Wpedantic
, "duplicate %<_Atomic%>");
5725 if (!ADDR_SPACE_GENERIC_P (as1
) && !ADDR_SPACE_GENERIC_P (as2
) && as1
!= as2
)
5726 error_at (loc
, "conflicting named address spaces (%s vs %s)",
5727 c_addr_space_name (as1
), c_addr_space_name (as2
));
5729 if ((TREE_CODE (type
) == ARRAY_TYPE
5730 || first_non_attr_kind
== cdk_array
)
5731 && TYPE_QUALS (element_type
))
5733 orig_qual_type
= type
;
5734 type
= TYPE_MAIN_VARIANT (type
);
5736 type_quals
= ((constp
? TYPE_QUAL_CONST
: 0)
5737 | (restrictp
? TYPE_QUAL_RESTRICT
: 0)
5738 | (volatilep
? TYPE_QUAL_VOLATILE
: 0)
5739 | (atomicp
? TYPE_QUAL_ATOMIC
: 0)
5740 | ENCODE_QUAL_ADDR_SPACE (address_space
));
5741 if (type_quals
!= TYPE_QUALS (element_type
))
5742 orig_qual_type
= NULL_TREE
;
5744 /* Applying the _Atomic qualifier to an array type (through the use
5745 of typedefs or typeof) must be detected here. If the qualifier
5746 is introduced later, any appearance of applying it to an array is
5747 actually applying it to an element of that array. */
5748 if (atomicp
&& TREE_CODE (type
) == ARRAY_TYPE
)
5749 error_at (loc
, "%<_Atomic%>-qualified array type");
5751 /* Warn about storage classes that are invalid for certain
5752 kinds of declarations (parameters, typenames, etc.). */
5756 || storage_class
== csc_auto
5757 || storage_class
== csc_register
5758 || storage_class
== csc_typedef
))
5760 if (storage_class
== csc_auto
)
5762 (current_scope
== file_scope
) ? 0 : OPT_Wpedantic
,
5763 "function definition declared %<auto%>");
5764 if (storage_class
== csc_register
)
5765 error_at (loc
, "function definition declared %<register%>");
5766 if (storage_class
== csc_typedef
)
5767 error_at (loc
, "function definition declared %<typedef%>");
5769 error_at (loc
, "function definition declared %qs",
5770 declspecs
->thread_gnu_p
? "__thread" : "_Thread_local");
5772 if (storage_class
== csc_auto
5773 || storage_class
== csc_register
5774 || storage_class
== csc_typedef
)
5775 storage_class
= csc_none
;
5777 else if (decl_context
!= NORMAL
&& (storage_class
!= csc_none
|| threadp
))
5779 if (decl_context
== PARM
&& storage_class
== csc_register
)
5783 switch (decl_context
)
5787 error_at (loc
, "storage class specified for structure "
5790 error_at (loc
, "storage class specified for structure field");
5794 error_at (loc
, "storage class specified for parameter %qE",
5797 error_at (loc
, "storage class specified for unnamed parameter");
5800 error_at (loc
, "storage class specified for typename");
5803 storage_class
= csc_none
;
5807 else if (storage_class
== csc_extern
5811 /* 'extern' with initialization is invalid if not at file scope. */
5812 if (current_scope
== file_scope
)
5814 /* It is fine to have 'extern const' when compiling at C
5815 and C++ intersection. */
5816 if (!(warn_cxx_compat
&& constp
))
5817 warning_at (loc
, 0, "%qE initialized and declared %<extern%>",
5821 error_at (loc
, "%qE has both %<extern%> and initializer", name
);
5823 else if (current_scope
== file_scope
)
5825 if (storage_class
== csc_auto
)
5826 error_at (loc
, "file-scope declaration of %qE specifies %<auto%>",
5828 if (pedantic
&& storage_class
== csc_register
)
5829 pedwarn (input_location
, OPT_Wpedantic
,
5830 "file-scope declaration of %qE specifies %<register%>", name
);
5834 if (storage_class
== csc_extern
&& funcdef_flag
)
5835 error_at (loc
, "nested function %qE declared %<extern%>", name
);
5836 else if (threadp
&& storage_class
== csc_none
)
5838 error_at (loc
, "function-scope %qE implicitly auto and declared "
5840 declspecs
->thread_gnu_p
? "__thread" : "_Thread_local");
5845 /* Now figure out the structure of the declarator proper.
5846 Descend through it, creating more complex types, until we reach
5847 the declared identifier (or NULL_TREE, in an absolute declarator).
5848 At each stage we maintain an unqualified version of the type
5849 together with any qualifiers that should be applied to it with
5850 c_build_qualified_type; this way, array types including
5851 multidimensional array types are first built up in unqualified
5852 form and then the qualified form is created with
5853 TYPE_MAIN_VARIANT pointing to the unqualified form. */
5855 while (declarator
&& declarator
->kind
!= cdk_id
)
5857 if (type
== error_mark_node
)
5859 declarator
= declarator
->declarator
;
5863 /* Each level of DECLARATOR is either a cdk_array (for ...[..]),
5864 a cdk_pointer (for *...),
5865 a cdk_function (for ...(...)),
5866 a cdk_attrs (for nested attributes),
5867 or a cdk_id (for the name being declared
5868 or the place in an absolute declarator
5869 where the name was omitted).
5870 For the last case, we have just exited the loop.
5872 At this point, TYPE is the type of elements of an array,
5873 or for a function to return, or for a pointer to point to.
5874 After this sequence of ifs, TYPE is the type of the
5875 array or function or pointer, and DECLARATOR has had its
5876 outermost layer removed. */
5878 if (array_ptr_quals
!= TYPE_UNQUALIFIED
5879 || array_ptr_attrs
!= NULL_TREE
5880 || array_parm_static
)
5882 /* Only the innermost declarator (making a parameter be of
5883 array type which is converted to pointer type)
5884 may have static or type qualifiers. */
5885 error_at (loc
, "static or type qualifiers in non-parameter array declarator");
5886 array_ptr_quals
= TYPE_UNQUALIFIED
;
5887 array_ptr_attrs
= NULL_TREE
;
5888 array_parm_static
= false;
5891 switch (declarator
->kind
)
5895 /* A declarator with embedded attributes. */
5896 tree attrs
= declarator
->u
.attrs
;
5897 const struct c_declarator
*inner_decl
;
5899 declarator
= declarator
->declarator
;
5900 inner_decl
= declarator
;
5901 while (inner_decl
->kind
== cdk_attrs
)
5902 inner_decl
= inner_decl
->declarator
;
5903 if (inner_decl
->kind
== cdk_id
)
5904 attr_flags
|= (int) ATTR_FLAG_DECL_NEXT
;
5905 else if (inner_decl
->kind
== cdk_function
)
5906 attr_flags
|= (int) ATTR_FLAG_FUNCTION_NEXT
;
5907 else if (inner_decl
->kind
== cdk_array
)
5908 attr_flags
|= (int) ATTR_FLAG_ARRAY_NEXT
;
5909 returned_attrs
= decl_attributes (&type
,
5910 chainon (returned_attrs
, attrs
),
5916 tree itype
= NULL_TREE
;
5917 tree size
= declarator
->u
.array
.dimen
;
5918 /* The index is a signed object `sizetype' bits wide. */
5919 tree index_type
= c_common_signed_type (sizetype
);
5921 array_ptr_quals
= declarator
->u
.array
.quals
;
5922 array_ptr_attrs
= declarator
->u
.array
.attrs
;
5923 array_parm_static
= declarator
->u
.array
.static_p
;
5924 array_parm_vla_unspec_p
= declarator
->u
.array
.vla_unspec_p
;
5926 declarator
= declarator
->declarator
;
5928 /* Check for some types that there cannot be arrays of. */
5930 if (VOID_TYPE_P (type
))
5933 error_at (loc
, "declaration of %qE as array of voids", name
);
5935 error_at (loc
, "declaration of type name as array of voids");
5936 type
= error_mark_node
;
5939 if (TREE_CODE (type
) == FUNCTION_TYPE
)
5942 error_at (loc
, "declaration of %qE as array of functions",
5945 error_at (loc
, "declaration of type name as array of "
5947 type
= error_mark_node
;
5950 if (pedantic
&& !in_system_header_at (input_location
)
5951 && flexible_array_type_p (type
))
5952 pedwarn (loc
, OPT_Wpedantic
,
5953 "invalid use of structure with flexible array member");
5955 if (size
== error_mark_node
)
5956 type
= error_mark_node
;
5958 if (type
== error_mark_node
)
5961 /* If size was specified, set ITYPE to a range-type for
5962 that size. Otherwise, ITYPE remains null. finish_decl
5963 may figure it out from an initial value. */
5967 bool size_maybe_const
= true;
5968 bool size_int_const
= (TREE_CODE (size
) == INTEGER_CST
5969 && !TREE_OVERFLOW (size
));
5970 bool this_size_varies
= false;
5972 /* Strip NON_LVALUE_EXPRs since we aren't using as an
5974 STRIP_TYPE_NOPS (size
);
5976 if (!INTEGRAL_TYPE_P (TREE_TYPE (size
)))
5979 error_at (loc
, "size of array %qE has non-integer type",
5983 "size of unnamed array has non-integer type");
5984 size
= integer_one_node
;
5986 /* This can happen with enum forward declaration. */
5987 else if (!COMPLETE_TYPE_P (TREE_TYPE (size
)))
5990 error_at (loc
, "size of array %qE has incomplete type",
5993 error_at (loc
, "size of unnamed array has incomplete "
5995 size
= integer_one_node
;
5998 size
= c_fully_fold (size
, false, &size_maybe_const
);
6000 if (pedantic
&& size_maybe_const
&& integer_zerop (size
))
6003 pedwarn (loc
, OPT_Wpedantic
,
6004 "ISO C forbids zero-size array %qE", name
);
6006 pedwarn (loc
, OPT_Wpedantic
,
6007 "ISO C forbids zero-size array");
6010 if (TREE_CODE (size
) == INTEGER_CST
&& size_maybe_const
)
6012 constant_expression_warning (size
);
6013 if (tree_int_cst_sgn (size
) < 0)
6016 error_at (loc
, "size of array %qE is negative", name
);
6018 error_at (loc
, "size of unnamed array is negative");
6019 size
= integer_one_node
;
6021 /* Handle a size folded to an integer constant but
6022 not an integer constant expression. */
6023 if (!size_int_const
)
6025 /* If this is a file scope declaration of an
6026 ordinary identifier, this is invalid code;
6027 diagnosing it here and not subsequently
6028 treating the type as variable-length avoids
6029 more confusing diagnostics later. */
6030 if ((decl_context
== NORMAL
|| decl_context
== FIELD
)
6031 && current_scope
== file_scope
)
6032 pedwarn (input_location
, 0,
6033 "variably modified %qE at file scope",
6036 this_size_varies
= size_varies
= true;
6037 warn_variable_length_array (name
, size
);
6040 else if ((decl_context
== NORMAL
|| decl_context
== FIELD
)
6041 && current_scope
== file_scope
)
6043 error_at (loc
, "variably modified %qE at file scope", name
);
6044 size
= integer_one_node
;
6048 /* Make sure the array size remains visibly
6049 nonconstant even if it is (eg) a const variable
6050 with known value. */
6051 this_size_varies
= size_varies
= true;
6052 warn_variable_length_array (name
, size
);
6053 if (sanitize_flags_p (SANITIZE_VLA
)
6054 && current_function_decl
!= NULL_TREE
6055 && decl_context
== NORMAL
)
6057 /* Evaluate the array size only once. */
6058 size
= save_expr (size
);
6059 size
= c_fully_fold (size
, false, NULL
);
6060 size
= fold_build2 (COMPOUND_EXPR
, TREE_TYPE (size
),
6061 ubsan_instrument_vla (loc
, size
),
6066 if (integer_zerop (size
) && !this_size_varies
)
6068 /* A zero-length array cannot be represented with
6069 an unsigned index type, which is what we'll
6070 get with build_index_type. Create an
6071 open-ended range instead. */
6072 itype
= build_range_type (sizetype
, size
, NULL_TREE
);
6076 /* Arrange for the SAVE_EXPR on the inside of the
6077 MINUS_EXPR, which allows the -1 to get folded
6078 with the +1 that happens when building TYPE_SIZE. */
6080 size
= save_expr (size
);
6081 if (this_size_varies
&& TREE_CODE (size
) == INTEGER_CST
)
6082 size
= build2 (COMPOUND_EXPR
, TREE_TYPE (size
),
6083 integer_zero_node
, size
);
6085 /* Compute the maximum valid index, that is, size
6086 - 1. Do the calculation in index_type, so that
6087 if it is a variable the computations will be
6088 done in the proper mode. */
6089 itype
= fold_build2_loc (loc
, MINUS_EXPR
, index_type
,
6090 convert (index_type
, size
),
6091 convert (index_type
,
6094 /* The above overflows when size does not fit
6096 ??? While a size of INT_MAX+1 technically shouldn't
6097 cause an overflow (because we subtract 1), handling
6098 this case seems like an unnecessary complication. */
6099 if (TREE_CODE (size
) == INTEGER_CST
6100 && !int_fits_type_p (size
, index_type
))
6103 error_at (loc
, "size of array %qE is too large",
6106 error_at (loc
, "size of unnamed array is too large");
6107 type
= error_mark_node
;
6111 itype
= build_index_type (itype
);
6113 if (this_size_varies
)
6116 *expr
= build2 (COMPOUND_EXPR
, TREE_TYPE (size
),
6120 *expr_const_operands
&= size_maybe_const
;
6123 else if (decl_context
== FIELD
)
6125 bool flexible_array_member
= false;
6126 if (array_parm_vla_unspec_p
)
6127 /* Field names can in fact have function prototype
6128 scope so [*] is disallowed here through making
6129 the field variably modified, not through being
6130 something other than a declaration with function
6135 const struct c_declarator
*t
= declarator
;
6136 while (t
->kind
== cdk_attrs
)
6138 flexible_array_member
= (t
->kind
== cdk_id
);
6140 if (flexible_array_member
6141 && !in_system_header_at (input_location
))
6142 pedwarn_c90 (loc
, OPT_Wpedantic
, "ISO C90 does not "
6143 "support flexible array members");
6145 /* ISO C99 Flexible array members are effectively
6146 identical to GCC's zero-length array extension. */
6147 if (flexible_array_member
|| array_parm_vla_unspec_p
)
6148 itype
= build_range_type (sizetype
, size_zero_node
,
6151 else if (decl_context
== PARM
)
6153 if (array_parm_vla_unspec_p
)
6155 itype
= build_range_type (sizetype
, size_zero_node
, NULL_TREE
);
6159 else if (decl_context
== TYPENAME
)
6161 if (array_parm_vla_unspec_p
)
6164 warning (0, "%<[*]%> not in a declaration");
6165 /* We use this to avoid messing up with incomplete
6166 array types of the same type, that would
6167 otherwise be modified below. */
6168 itype
= build_range_type (sizetype
, size_zero_node
,
6174 /* Complain about arrays of incomplete types. */
6175 if (!COMPLETE_TYPE_P (type
))
6177 error_at (loc
, "array type has incomplete element type %qT",
6179 /* See if we can be more helpful. */
6180 if (TREE_CODE (type
) == ARRAY_TYPE
)
6183 inform (loc
, "declaration of %qE as multidimensional "
6184 "array must have bounds for all dimensions "
6185 "except the first", name
);
6187 inform (loc
, "declaration of multidimensional array "
6188 "must have bounds for all dimensions except "
6191 type
= error_mark_node
;
6194 /* When itype is NULL, a shared incomplete array type is
6195 returned for all array of a given type. Elsewhere we
6196 make sure we don't complete that type before copying
6197 it, but here we want to make sure we don't ever
6198 modify the shared type, so we gcc_assert (itype)
6201 addr_space_t as
= DECODE_QUAL_ADDR_SPACE (type_quals
);
6202 if (!ADDR_SPACE_GENERIC_P (as
) && as
!= TYPE_ADDR_SPACE (type
))
6203 type
= build_qualified_type (type
,
6204 ENCODE_QUAL_ADDR_SPACE (as
));
6206 type
= build_array_type (type
, itype
);
6209 if (type
!= error_mark_node
)
6213 /* It is ok to modify type here even if itype is
6214 NULL: if size_varies, we're in a
6215 multi-dimensional array and the inner type has
6216 variable size, so the enclosing shared array type
6218 if (size
&& TREE_CODE (size
) == INTEGER_CST
)
6220 = build_distinct_type_copy (TYPE_MAIN_VARIANT (type
));
6221 C_TYPE_VARIABLE_SIZE (type
) = 1;
6224 /* The GCC extension for zero-length arrays differs from
6225 ISO flexible array members in that sizeof yields
6227 if (size
&& integer_zerop (size
))
6230 type
= build_distinct_type_copy (TYPE_MAIN_VARIANT (type
));
6231 TYPE_SIZE (type
) = bitsize_zero_node
;
6232 TYPE_SIZE_UNIT (type
) = size_zero_node
;
6233 SET_TYPE_STRUCTURAL_EQUALITY (type
);
6235 if (array_parm_vla_unspec_p
)
6238 /* The type is complete. C99 6.7.5.2p4 */
6239 type
= build_distinct_type_copy (TYPE_MAIN_VARIANT (type
));
6240 TYPE_SIZE (type
) = bitsize_zero_node
;
6241 TYPE_SIZE_UNIT (type
) = size_zero_node
;
6242 SET_TYPE_STRUCTURAL_EQUALITY (type
);
6245 if (!valid_array_size_p (loc
, type
, name
))
6246 type
= error_mark_node
;
6249 if (decl_context
!= PARM
6250 && (array_ptr_quals
!= TYPE_UNQUALIFIED
6251 || array_ptr_attrs
!= NULL_TREE
6252 || array_parm_static
))
6254 error_at (loc
, "static or type qualifiers in non-parameter "
6255 "array declarator");
6256 array_ptr_quals
= TYPE_UNQUALIFIED
;
6257 array_ptr_attrs
= NULL_TREE
;
6258 array_parm_static
= false;
6260 orig_qual_indirect
++;
6265 /* Say it's a definition only for the declarator closest
6266 to the identifier, apart possibly from some
6268 bool really_funcdef
= false;
6270 orig_qual_type
= NULL_TREE
;
6273 const struct c_declarator
*t
= declarator
->declarator
;
6274 while (t
->kind
== cdk_attrs
)
6276 really_funcdef
= (t
->kind
== cdk_id
);
6279 /* Declaring a function type. Make sure we have a valid
6280 type for the function to return. */
6281 if (type
== error_mark_node
)
6284 size_varies
= false;
6286 /* Warn about some types functions can't return. */
6287 if (TREE_CODE (type
) == FUNCTION_TYPE
)
6290 error_at (loc
, "%qE declared as function returning a "
6293 error_at (loc
, "type name declared as function "
6294 "returning a function");
6295 type
= integer_type_node
;
6297 if (TREE_CODE (type
) == ARRAY_TYPE
)
6300 error_at (loc
, "%qE declared as function returning an array",
6303 error_at (loc
, "type name declared as function returning "
6305 type
= integer_type_node
;
6308 /* Construct the function type and go to the next
6309 inner layer of declarator. */
6310 arg_info
= declarator
->u
.arg_info
;
6311 arg_types
= grokparms (arg_info
, really_funcdef
);
6313 /* Type qualifiers before the return type of the function
6314 qualify the return type, not the function type. */
6317 const enum c_declspec_word ignored_quals_list
[] =
6319 cdw_const
, cdw_volatile
, cdw_restrict
, cdw_address_space
,
6320 cdw_atomic
, cdw_number_of_elements
6322 location_t specs_loc
6323 = smallest_type_quals_location (declspecs
->locations
,
6324 ignored_quals_list
);
6325 if (specs_loc
== UNKNOWN_LOCATION
)
6326 specs_loc
= declspecs
->locations
[cdw_typedef
];
6327 if (specs_loc
== UNKNOWN_LOCATION
)
6330 /* Type qualifiers on a function return type are
6331 normally permitted by the standard but have no
6332 effect, so give a warning at -Wreturn-type.
6333 Qualifiers on a void return type are banned on
6334 function definitions in ISO C; GCC used to used
6335 them for noreturn functions. The resolution of C11
6336 DR#423 means qualifiers (other than _Atomic) are
6337 actually removed from the return type when
6338 determining the function type. */
6339 int quals_used
= type_quals
;
6341 quals_used
&= TYPE_QUAL_ATOMIC
;
6342 if (quals_used
&& VOID_TYPE_P (type
) && really_funcdef
)
6343 pedwarn (specs_loc
, 0,
6344 "function definition has qualified void return type");
6346 warning_at (specs_loc
, OPT_Wignored_qualifiers
,
6347 "type qualifiers ignored on function return type");
6349 /* Ensure an error for restrict on invalid types; the
6350 DR#423 resolution is not entirely clear about
6353 && (type_quals
& TYPE_QUAL_RESTRICT
)
6354 && (!POINTER_TYPE_P (type
)
6355 || !C_TYPE_OBJECT_OR_INCOMPLETE_P (TREE_TYPE (type
))))
6356 error_at (loc
, "invalid use of %<restrict%>");
6358 type
= c_build_qualified_type (type
, quals_used
);
6360 type_quals
= TYPE_UNQUALIFIED
;
6362 type
= build_function_type (type
, arg_types
);
6363 declarator
= declarator
->declarator
;
6365 /* Set the TYPE_CONTEXTs for each tagged type which is local to
6366 the formal parameter list of this FUNCTION_TYPE to point to
6367 the FUNCTION_TYPE node itself. */
6372 FOR_EACH_VEC_SAFE_ELT_REVERSE (arg_info
->tags
, ix
, tag
)
6373 TYPE_CONTEXT (tag
->type
) = type
;
6379 /* Merge any constancy or volatility into the target type
6381 if ((type_quals
& TYPE_QUAL_ATOMIC
)
6382 && TREE_CODE (type
) == FUNCTION_TYPE
)
6385 "%<_Atomic%>-qualified function type");
6386 type_quals
&= ~TYPE_QUAL_ATOMIC
;
6388 else if (pedantic
&& TREE_CODE (type
) == FUNCTION_TYPE
6390 pedwarn (loc
, OPT_Wpedantic
,
6391 "ISO C forbids qualified function types");
6393 type
= c_build_qualified_type (type
, type_quals
, orig_qual_type
,
6394 orig_qual_indirect
);
6395 orig_qual_type
= NULL_TREE
;
6396 size_varies
= false;
6398 /* When the pointed-to type involves components of variable size,
6399 care must be taken to ensure that the size evaluation code is
6400 emitted early enough to dominate all the possible later uses
6401 and late enough for the variables on which it depends to have
6404 This is expected to happen automatically when the pointed-to
6405 type has a name/declaration of it's own, but special attention
6406 is required if the type is anonymous.
6408 We handle the NORMAL and FIELD contexts here by attaching an
6409 artificial TYPE_DECL to such pointed-to type. This forces the
6410 sizes evaluation at a safe point and ensures it is not deferred
6411 until e.g. within a deeper conditional context.
6413 We expect nothing to be needed here for PARM or TYPENAME.
6414 Pushing a TYPE_DECL at this point for TYPENAME would actually
6415 be incorrect, as we might be in the middle of an expression
6416 with side effects on the pointed-to type size "arguments" prior
6417 to the pointer declaration point and the fake TYPE_DECL in the
6418 enclosing context would force the size evaluation prior to the
6421 if (!TYPE_NAME (type
)
6422 && (decl_context
== NORMAL
|| decl_context
== FIELD
)
6423 && variably_modified_type_p (type
, NULL_TREE
))
6425 tree decl
= build_decl (loc
, TYPE_DECL
, NULL_TREE
, type
);
6426 DECL_ARTIFICIAL (decl
) = 1;
6428 finish_decl (decl
, loc
, NULL_TREE
, NULL_TREE
, NULL_TREE
);
6429 TYPE_NAME (type
) = decl
;
6432 type
= c_build_pointer_type (type
);
6434 /* Process type qualifiers (such as const or volatile)
6435 that were given inside the `*'. */
6436 type_quals
= declarator
->u
.pointer_quals
;
6438 declarator
= declarator
->declarator
;
6445 *decl_attrs
= chainon (returned_attrs
, *decl_attrs
);
6447 /* Now TYPE has the actual type, apart from any qualifiers in
6450 /* Warn about address space used for things other than static memory or
6452 address_space
= DECODE_QUAL_ADDR_SPACE (type_quals
);
6453 if (!ADDR_SPACE_GENERIC_P (address_space
))
6455 if (decl_context
== NORMAL
)
6457 switch (storage_class
)
6460 error ("%qs combined with %<auto%> qualifier for %qE",
6461 c_addr_space_name (address_space
), name
);
6464 error ("%qs combined with %<register%> qualifier for %qE",
6465 c_addr_space_name (address_space
), name
);
6468 if (current_function_scope
)
6470 error ("%qs specified for auto variable %qE",
6471 c_addr_space_name (address_space
), name
);
6483 else if (decl_context
== PARM
&& TREE_CODE (type
) != ARRAY_TYPE
)
6486 error ("%qs specified for parameter %qE",
6487 c_addr_space_name (address_space
), name
);
6489 error ("%qs specified for unnamed parameter",
6490 c_addr_space_name (address_space
));
6492 else if (decl_context
== FIELD
)
6495 error ("%qs specified for structure field %qE",
6496 c_addr_space_name (address_space
), name
);
6498 error ("%qs specified for structure field",
6499 c_addr_space_name (address_space
));
6503 /* Check the type and width of a bit-field. */
6506 check_bitfield_type_and_width (loc
, &type
, width
, name
);
6507 /* C11 makes it implementation-defined (6.7.2.1#5) whether
6508 atomic types are permitted for bit-fields; we have no code to
6509 make bit-field accesses atomic, so disallow them. */
6510 if (type_quals
& TYPE_QUAL_ATOMIC
)
6513 error_at (loc
, "bit-field %qE has atomic type", name
);
6515 error_at (loc
, "bit-field has atomic type");
6516 type_quals
&= ~TYPE_QUAL_ATOMIC
;
6520 /* Reject invalid uses of _Alignas. */
6521 if (declspecs
->alignas_p
)
6523 if (storage_class
== csc_typedef
)
6524 error_at (loc
, "alignment specified for typedef %qE", name
);
6525 else if (storage_class
== csc_register
)
6526 error_at (loc
, "alignment specified for %<register%> object %qE",
6528 else if (decl_context
== PARM
)
6531 error_at (loc
, "alignment specified for parameter %qE", name
);
6533 error_at (loc
, "alignment specified for unnamed parameter");
6538 error_at (loc
, "alignment specified for bit-field %qE", name
);
6540 error_at (loc
, "alignment specified for unnamed bit-field");
6542 else if (TREE_CODE (type
) == FUNCTION_TYPE
)
6543 error_at (loc
, "alignment specified for function %qE", name
);
6544 else if (declspecs
->align_log
!= -1 && TYPE_P (type
))
6546 alignas_align
= 1U << declspecs
->align_log
;
6547 if (alignas_align
< min_align_of_type (type
))
6550 error_at (loc
, "%<_Alignas%> specifiers cannot reduce "
6551 "alignment of %qE", name
);
6553 error_at (loc
, "%<_Alignas%> specifiers cannot reduce "
6554 "alignment of unnamed field");
6560 /* If this is declaring a typedef name, return a TYPE_DECL. */
6562 if (storage_class
== csc_typedef
)
6565 if ((type_quals
& TYPE_QUAL_ATOMIC
)
6566 && TREE_CODE (type
) == FUNCTION_TYPE
)
6569 "%<_Atomic%>-qualified function type");
6570 type_quals
&= ~TYPE_QUAL_ATOMIC
;
6572 else if (pedantic
&& TREE_CODE (type
) == FUNCTION_TYPE
6574 pedwarn (loc
, OPT_Wpedantic
,
6575 "ISO C forbids qualified function types");
6577 type
= c_build_qualified_type (type
, type_quals
, orig_qual_type
,
6578 orig_qual_indirect
);
6579 decl
= build_decl (declarator
->id_loc
,
6580 TYPE_DECL
, declarator
->u
.id
, type
);
6581 if (declspecs
->explicit_signed_p
)
6582 C_TYPEDEF_EXPLICITLY_SIGNED (decl
) = 1;
6583 if (declspecs
->inline_p
)
6584 pedwarn (loc
, 0,"typedef %q+D declared %<inline%>", decl
);
6585 if (declspecs
->noreturn_p
)
6586 pedwarn (loc
, 0,"typedef %q+D declared %<_Noreturn%>", decl
);
6588 if (warn_cxx_compat
&& declarator
->u
.id
!= NULL_TREE
)
6590 struct c_binding
*b
= I_TAG_BINDING (declarator
->u
.id
);
6593 && b
->decl
!= NULL_TREE
6594 && (B_IN_CURRENT_SCOPE (b
)
6595 || (current_scope
== file_scope
&& B_IN_EXTERNAL_SCOPE (b
)))
6596 && TYPE_MAIN_VARIANT (b
->decl
) != TYPE_MAIN_VARIANT (type
))
6598 if (warning_at (declarator
->id_loc
, OPT_Wc___compat
,
6599 ("using %qD as both a typedef and a tag is "
6600 "invalid in C++"), decl
)
6601 && b
->locus
!= UNKNOWN_LOCATION
)
6602 inform (b
->locus
, "originally defined here");
6609 /* If this is a type name (such as, in a cast or sizeof),
6610 compute the type and return it now. */
6612 if (decl_context
== TYPENAME
)
6614 /* Note that the grammar rejects storage classes in typenames
6616 gcc_assert (storage_class
== csc_none
&& !threadp
6617 && !declspecs
->inline_p
&& !declspecs
->noreturn_p
);
6618 if ((type_quals
& TYPE_QUAL_ATOMIC
)
6619 && TREE_CODE (type
) == FUNCTION_TYPE
)
6622 "%<_Atomic%>-qualified function type");
6623 type_quals
&= ~TYPE_QUAL_ATOMIC
;
6625 else if (pedantic
&& TREE_CODE (type
) == FUNCTION_TYPE
6627 pedwarn (loc
, OPT_Wpedantic
,
6628 "ISO C forbids const or volatile function types");
6630 type
= c_build_qualified_type (type
, type_quals
, orig_qual_type
,
6631 orig_qual_indirect
);
6635 if (pedantic
&& decl_context
== FIELD
6636 && variably_modified_type_p (type
, NULL_TREE
))
6639 pedwarn (loc
, OPT_Wpedantic
, "a member of a structure or union cannot "
6640 "have a variably modified type");
6643 /* Aside from typedefs and type names (handle above),
6644 `void' at top level (not within pointer)
6645 is allowed only in public variables.
6646 We don't complain about parms either, but that is because
6647 a better error message can be made later. */
6649 if (VOID_TYPE_P (type
) && decl_context
!= PARM
6650 && !((decl_context
!= FIELD
&& TREE_CODE (type
) != FUNCTION_TYPE
)
6651 && (storage_class
== csc_extern
6652 || (current_scope
== file_scope
6653 && !(storage_class
== csc_static
6654 || storage_class
== csc_register
)))))
6656 error_at (loc
, "variable or field %qE declared void", name
);
6657 type
= integer_type_node
;
6660 /* Now create the decl, which may be a VAR_DECL, a PARM_DECL
6661 or a FUNCTION_DECL, depending on DECL_CONTEXT and TYPE. */
6666 if (decl_context
== PARM
)
6669 bool array_parameter_p
= false;
6671 /* A parameter declared as an array of T is really a pointer to T.
6672 One declared as a function is really a pointer to a function. */
6674 if (TREE_CODE (type
) == ARRAY_TYPE
)
6676 /* Transfer const-ness of array into that of type pointed to. */
6677 type
= TREE_TYPE (type
);
6678 if (orig_qual_type
!= NULL_TREE
)
6680 if (orig_qual_indirect
== 0)
6681 orig_qual_type
= TREE_TYPE (orig_qual_type
);
6683 orig_qual_indirect
--;
6686 type
= c_build_qualified_type (type
, type_quals
, orig_qual_type
,
6687 orig_qual_indirect
);
6688 type
= c_build_pointer_type (type
);
6689 type_quals
= array_ptr_quals
;
6691 type
= c_build_qualified_type (type
, type_quals
);
6693 /* We don't yet implement attributes in this context. */
6694 if (array_ptr_attrs
!= NULL_TREE
)
6695 warning_at (loc
, OPT_Wattributes
,
6696 "attributes in parameter array declarator ignored");
6698 size_varies
= false;
6699 array_parameter_p
= true;
6701 else if (TREE_CODE (type
) == FUNCTION_TYPE
)
6703 if (type_quals
& TYPE_QUAL_ATOMIC
)
6706 "%<_Atomic%>-qualified function type");
6707 type_quals
&= ~TYPE_QUAL_ATOMIC
;
6709 else if (type_quals
)
6710 pedwarn (loc
, OPT_Wpedantic
,
6711 "ISO C forbids qualified function types");
6713 type
= c_build_qualified_type (type
, type_quals
);
6714 type
= c_build_pointer_type (type
);
6715 type_quals
= TYPE_UNQUALIFIED
;
6717 else if (type_quals
)
6718 type
= c_build_qualified_type (type
, type_quals
);
6720 decl
= build_decl (declarator
->id_loc
,
6721 PARM_DECL
, declarator
->u
.id
, type
);
6723 C_DECL_VARIABLE_SIZE (decl
) = 1;
6724 C_ARRAY_PARAMETER (decl
) = array_parameter_p
;
6726 /* Compute the type actually passed in the parmlist,
6727 for the case where there is no prototype.
6728 (For example, shorts and chars are passed as ints.)
6729 When there is a prototype, this is overridden later. */
6731 if (type
== error_mark_node
)
6732 promoted_type
= type
;
6734 promoted_type
= c_type_promotes_to (type
);
6736 DECL_ARG_TYPE (decl
) = promoted_type
;
6737 if (declspecs
->inline_p
)
6738 pedwarn (loc
, 0, "parameter %q+D declared %<inline%>", decl
);
6739 if (declspecs
->noreturn_p
)
6740 pedwarn (loc
, 0, "parameter %q+D declared %<_Noreturn%>", decl
);
6742 else if (decl_context
== FIELD
)
6744 /* Note that the grammar rejects storage classes in typenames
6746 gcc_assert (storage_class
== csc_none
&& !threadp
6747 && !declspecs
->inline_p
&& !declspecs
->noreturn_p
);
6749 /* Structure field. It may not be a function. */
6751 if (TREE_CODE (type
) == FUNCTION_TYPE
)
6753 error_at (loc
, "field %qE declared as a function", name
);
6754 type
= build_pointer_type (type
);
6756 else if (TREE_CODE (type
) != ERROR_MARK
6757 && !COMPLETE_OR_UNBOUND_ARRAY_TYPE_P (type
))
6760 error_at (loc
, "field %qE has incomplete type", name
);
6762 error_at (loc
, "unnamed field has incomplete type");
6763 type
= error_mark_node
;
6765 else if (TREE_CODE (type
) == ARRAY_TYPE
6766 && TYPE_DOMAIN (type
) == NULL_TREE
)
6768 /* We have a flexible array member through a typedef.
6769 Set suitable range. Whether this is a correct position
6770 for a flexible array member will be determined elsewhere. */
6771 if (!in_system_header_at (input_location
))
6772 pedwarn_c90 (loc
, OPT_Wpedantic
, "ISO C90 does not "
6773 "support flexible array members");
6774 type
= build_distinct_type_copy (TYPE_MAIN_VARIANT (type
));
6775 TYPE_DOMAIN (type
) = build_range_type (sizetype
, size_zero_node
,
6777 if (orig_qual_indirect
== 0)
6778 orig_qual_type
= NULL_TREE
;
6780 type
= c_build_qualified_type (type
, type_quals
, orig_qual_type
,
6781 orig_qual_indirect
);
6782 decl
= build_decl (declarator
->id_loc
,
6783 FIELD_DECL
, declarator
->u
.id
, type
);
6784 DECL_NONADDRESSABLE_P (decl
) = bitfield
;
6785 if (bitfield
&& !declarator
->u
.id
)
6786 TREE_NO_WARNING (decl
) = 1;
6789 C_DECL_VARIABLE_SIZE (decl
) = 1;
6791 else if (TREE_CODE (type
) == FUNCTION_TYPE
)
6793 if (storage_class
== csc_register
|| threadp
)
6795 error_at (loc
, "invalid storage class for function %qE", name
);
6797 else if (current_scope
!= file_scope
)
6799 /* Function declaration not at file scope. Storage
6800 classes other than `extern' are not allowed, C99
6801 6.7.1p5, and `extern' makes no difference. However,
6802 GCC allows 'auto', perhaps with 'inline', to support
6803 nested functions. */
6804 if (storage_class
== csc_auto
)
6805 pedwarn (loc
, OPT_Wpedantic
,
6806 "invalid storage class for function %qE", name
);
6807 else if (storage_class
== csc_static
)
6809 error_at (loc
, "invalid storage class for function %qE", name
);
6811 storage_class
= declspecs
->storage_class
= csc_none
;
6817 decl
= build_decl (declarator
->id_loc
,
6818 FUNCTION_DECL
, declarator
->u
.id
, type
);
6819 decl
= build_decl_attribute_variant (decl
, decl_attr
);
6821 if (type_quals
& TYPE_QUAL_ATOMIC
)
6824 "%<_Atomic%>-qualified function type");
6825 type_quals
&= ~TYPE_QUAL_ATOMIC
;
6827 else if (pedantic
&& type_quals
&& !DECL_IN_SYSTEM_HEADER (decl
))
6828 pedwarn (loc
, OPT_Wpedantic
,
6829 "ISO C forbids qualified function types");
6831 /* Every function declaration is an external reference
6832 (DECL_EXTERNAL) except for those which are not at file
6833 scope and are explicitly declared "auto". This is
6834 forbidden by standard C (C99 6.7.1p5) and is interpreted by
6835 GCC to signify a forward declaration of a nested function. */
6836 if (storage_class
== csc_auto
&& current_scope
!= file_scope
)
6837 DECL_EXTERNAL (decl
) = 0;
6838 /* In C99, a function which is declared 'inline' with 'extern'
6839 is not an external reference (which is confusing). It
6840 means that the later definition of the function must be output
6841 in this file, C99 6.7.4p6. In GNU C89, a function declared
6842 'extern inline' is an external reference. */
6843 else if (declspecs
->inline_p
&& storage_class
!= csc_static
)
6844 DECL_EXTERNAL (decl
) = ((storage_class
== csc_extern
)
6845 == flag_gnu89_inline
);
6847 DECL_EXTERNAL (decl
) = !initialized
;
6849 /* Record absence of global scope for `static' or `auto'. */
6851 = !(storage_class
== csc_static
|| storage_class
== csc_auto
);
6853 /* For a function definition, record the argument information
6854 block where store_parm_decls will look for it. */
6856 current_function_arg_info
= arg_info
;
6858 if (declspecs
->default_int_p
)
6859 C_FUNCTION_IMPLICIT_INT (decl
) = 1;
6861 /* Record presence of `inline' and `_Noreturn', if it is
6863 if (flag_hosted
&& MAIN_NAME_P (declarator
->u
.id
))
6865 if (declspecs
->inline_p
)
6866 pedwarn (loc
, 0, "cannot inline function %<main%>");
6867 if (declspecs
->noreturn_p
)
6868 pedwarn (loc
, 0, "%<main%> declared %<_Noreturn%>");
6872 if (declspecs
->inline_p
)
6873 /* Record that the function is declared `inline'. */
6874 DECL_DECLARED_INLINE_P (decl
) = 1;
6875 if (declspecs
->noreturn_p
)
6878 pedwarn_c99 (loc
, OPT_Wpedantic
,
6879 "ISO C99 does not support %<_Noreturn%>");
6881 pedwarn_c99 (loc
, OPT_Wpedantic
,
6882 "ISO C90 does not support %<_Noreturn%>");
6883 TREE_THIS_VOLATILE (decl
) = 1;
6889 /* It's a variable. */
6890 /* An uninitialized decl with `extern' is a reference. */
6891 int extern_ref
= !initialized
&& storage_class
== csc_extern
;
6893 type
= c_build_qualified_type (type
, type_quals
, orig_qual_type
,
6894 orig_qual_indirect
);
6896 /* C99 6.2.2p7: It is invalid (compile-time undefined
6897 behavior) to create an 'extern' declaration for a
6898 variable if there is a global declaration that is
6899 'static' and the global declaration is not visible.
6900 (If the static declaration _is_ currently visible,
6901 the 'extern' declaration is taken to refer to that decl.) */
6902 if (extern_ref
&& current_scope
!= file_scope
)
6904 tree global_decl
= identifier_global_value (declarator
->u
.id
);
6905 tree visible_decl
= lookup_name (declarator
->u
.id
);
6908 && global_decl
!= visible_decl
6909 && VAR_P (global_decl
)
6910 && !TREE_PUBLIC (global_decl
))
6911 error_at (loc
, "variable previously declared %<static%> "
6912 "redeclared %<extern%>");
6915 decl
= build_decl (declarator
->id_loc
,
6916 VAR_DECL
, declarator
->u
.id
, type
);
6918 C_DECL_VARIABLE_SIZE (decl
) = 1;
6920 if (declspecs
->inline_p
)
6921 pedwarn (loc
, 0, "variable %q+D declared %<inline%>", decl
);
6922 if (declspecs
->noreturn_p
)
6923 pedwarn (loc
, 0, "variable %q+D declared %<_Noreturn%>", decl
);
6925 /* At file scope, an initialized extern declaration may follow
6926 a static declaration. In that case, DECL_EXTERNAL will be
6927 reset later in start_decl. */
6928 DECL_EXTERNAL (decl
) = (storage_class
== csc_extern
);
6930 /* At file scope, the presence of a `static' or `register' storage
6931 class specifier, or the absence of all storage class specifiers
6932 makes this declaration a definition (perhaps tentative). Also,
6933 the absence of `static' makes it public. */
6934 if (current_scope
== file_scope
)
6936 TREE_PUBLIC (decl
) = storage_class
!= csc_static
;
6937 TREE_STATIC (decl
) = !extern_ref
;
6939 /* Not at file scope, only `static' makes a static definition. */
6942 TREE_STATIC (decl
) = (storage_class
== csc_static
);
6943 TREE_PUBLIC (decl
) = extern_ref
;
6947 set_decl_tls_model (decl
, decl_default_tls_model (decl
));
6950 if ((storage_class
== csc_extern
6951 || (storage_class
== csc_none
6952 && TREE_CODE (type
) == FUNCTION_TYPE
6954 && variably_modified_type_p (type
, NULL_TREE
))
6957 if (TREE_CODE (type
) == FUNCTION_TYPE
)
6958 error_at (loc
, "non-nested function with variably modified type");
6960 error_at (loc
, "object with variably modified type must have "
6964 /* Record `register' declaration for warnings on &
6965 and in case doing stupid register allocation. */
6967 if (storage_class
== csc_register
)
6969 C_DECL_REGISTER (decl
) = 1;
6970 DECL_REGISTER (decl
) = 1;
6973 /* Record constancy and volatility. */
6974 c_apply_type_quals_to_decl (type_quals
, decl
);
6976 /* Apply _Alignas specifiers. */
6979 SET_DECL_ALIGN (decl
, alignas_align
* BITS_PER_UNIT
);
6980 DECL_USER_ALIGN (decl
) = 1;
6983 /* If a type has volatile components, it should be stored in memory.
6984 Otherwise, the fact that those components are volatile
6985 will be ignored, and would even crash the compiler.
6986 Of course, this only makes sense on VAR,PARM, and RESULT decl's. */
6987 if (C_TYPE_FIELDS_VOLATILE (TREE_TYPE (decl
))
6988 && (VAR_P (decl
) || TREE_CODE (decl
) == PARM_DECL
6989 || TREE_CODE (decl
) == RESULT_DECL
))
6991 /* It is not an error for a structure with volatile fields to
6992 be declared register, but reset DECL_REGISTER since it
6993 cannot actually go in a register. */
6994 int was_reg
= C_DECL_REGISTER (decl
);
6995 C_DECL_REGISTER (decl
) = 0;
6996 DECL_REGISTER (decl
) = 0;
6997 c_mark_addressable (decl
);
6998 C_DECL_REGISTER (decl
) = was_reg
;
7001 /* This is the earliest point at which we might know the assembler
7002 name of a variable. Thus, if it's known before this, die horribly. */
7003 gcc_assert (!DECL_ASSEMBLER_NAME_SET_P (decl
));
7007 && TREE_PUBLIC (decl
)
7008 && TREE_STATIC (decl
)
7009 && (RECORD_OR_UNION_TYPE_P (TREE_TYPE (decl
))
7010 || TREE_CODE (TREE_TYPE (decl
)) == ENUMERAL_TYPE
)
7011 && TYPE_NAME (TREE_TYPE (decl
)) == NULL_TREE
)
7012 warning_at (DECL_SOURCE_LOCATION (decl
), OPT_Wc___compat
,
7013 ("non-local variable %qD with anonymous type is "
7014 "questionable in C++"),
7021 /* Decode the parameter-list info for a function type or function definition.
7022 The argument is the value returned by `get_parm_info' (or made in c-parse.c
7023 if there is an identifier list instead of a parameter decl list).
7024 These two functions are separate because when a function returns
7025 or receives functions then each is called multiple times but the order
7026 of calls is different. The last call to `grokparms' is always the one
7027 that contains the formal parameter names of a function definition.
7029 Return a list of arg types to use in the FUNCTION_TYPE for this function.
7031 FUNCDEF_FLAG is true for a function definition, false for
7032 a mere declaration. A nonempty identifier-list gets an error message
7033 when FUNCDEF_FLAG is false. */
7036 grokparms (struct c_arg_info
*arg_info
, bool funcdef_flag
)
7038 tree arg_types
= arg_info
->types
;
7040 if (funcdef_flag
&& arg_info
->had_vla_unspec
)
7042 /* A function definition isn't function prototype scope C99 6.2.1p4. */
7044 error ("%<[*]%> not allowed in other than function prototype scope");
7047 if (arg_types
== NULL_TREE
&& !funcdef_flag
7048 && !in_system_header_at (input_location
))
7049 warning (OPT_Wstrict_prototypes
,
7050 "function declaration isn%'t a prototype");
7052 if (arg_types
== error_mark_node
)
7053 /* Don't set TYPE_ARG_TYPES in this case. */
7056 else if (arg_types
&& TREE_CODE (TREE_VALUE (arg_types
)) == IDENTIFIER_NODE
)
7060 pedwarn (input_location
, 0, "parameter names (without types) in "
7061 "function declaration");
7062 arg_info
->parms
= NULL_TREE
;
7065 arg_info
->parms
= arg_info
->types
;
7067 arg_info
->types
= NULL_TREE
;
7072 tree parm
, type
, typelt
;
7073 unsigned int parmno
;
7075 /* If there is a parameter of incomplete type in a definition,
7076 this is an error. In a declaration this is valid, and a
7077 struct or union type may be completed later, before any calls
7078 or definition of the function. In the case where the tag was
7079 first declared within the parameter list, a warning has
7080 already been given. If a parameter has void type, then
7081 however the function cannot be defined or called, so
7084 for (parm
= arg_info
->parms
, typelt
= arg_types
, parmno
= 1;
7086 parm
= DECL_CHAIN (parm
), typelt
= TREE_CHAIN (typelt
), parmno
++)
7088 type
= TREE_VALUE (typelt
);
7089 if (type
== error_mark_node
)
7092 if (!COMPLETE_TYPE_P (type
))
7096 if (DECL_NAME (parm
))
7097 error_at (input_location
,
7098 "parameter %u (%q+D) has incomplete type",
7101 error_at (DECL_SOURCE_LOCATION (parm
),
7102 "parameter %u has incomplete type",
7105 TREE_VALUE (typelt
) = error_mark_node
;
7106 TREE_TYPE (parm
) = error_mark_node
;
7107 arg_types
= NULL_TREE
;
7109 else if (VOID_TYPE_P (type
))
7111 if (DECL_NAME (parm
))
7112 warning_at (input_location
, 0,
7113 "parameter %u (%q+D) has void type",
7116 warning_at (DECL_SOURCE_LOCATION (parm
), 0,
7117 "parameter %u has void type",
7122 if (DECL_NAME (parm
) && TREE_USED (parm
))
7123 warn_if_shadowing (parm
);
7129 /* Allocate and initialize a c_arg_info structure from the parser's
7133 build_arg_info (void)
7135 struct c_arg_info
*ret
= XOBNEW (&parser_obstack
, struct c_arg_info
);
7136 ret
->parms
= NULL_TREE
;
7138 ret
->types
= NULL_TREE
;
7139 ret
->others
= NULL_TREE
;
7140 ret
->pending_sizes
= NULL
;
7141 ret
->had_vla_unspec
= 0;
7145 /* Take apart the current scope and return a c_arg_info structure with
7146 info on a parameter list just parsed.
7148 This structure is later fed to 'grokparms' and 'store_parm_decls'.
7150 ELLIPSIS being true means the argument list ended in '...' so don't
7151 append a sentinel (void_list_node) to the end of the type-list.
7153 EXPR is NULL or an expression that needs to be evaluated for the
7154 side effects of array size expressions in the parameters. */
7157 get_parm_info (bool ellipsis
, tree expr
)
7159 struct c_binding
*b
= current_scope
->bindings
;
7160 struct c_arg_info
*arg_info
= build_arg_info ();
7162 tree parms
= NULL_TREE
;
7163 vec
<c_arg_tag
, va_gc
> *tags
= NULL
;
7164 tree types
= NULL_TREE
;
7165 tree others
= NULL_TREE
;
7167 bool gave_void_only_once_err
= false;
7169 arg_info
->had_vla_unspec
= current_scope
->had_vla_unspec
;
7171 /* The bindings in this scope must not get put into a block.
7172 We will take care of deleting the binding nodes. */
7173 current_scope
->bindings
= 0;
7175 /* This function is only called if there was *something* on the
7179 /* A parameter list consisting solely of 'void' indicates that the
7180 function takes no arguments. But if the 'void' is qualified
7181 (by 'const' or 'volatile'), or has a storage class specifier
7182 ('register'), then the behavior is undefined; issue an error.
7183 Typedefs for 'void' are OK (see DR#157). */
7184 if (b
->prev
== 0 /* one binding */
7185 && TREE_CODE (b
->decl
) == PARM_DECL
/* which is a parameter */
7186 && !DECL_NAME (b
->decl
) /* anonymous */
7187 && VOID_TYPE_P (TREE_TYPE (b
->decl
))) /* of void type */
7189 if (TYPE_QUALS (TREE_TYPE (b
->decl
)) != TYPE_UNQUALIFIED
7190 || C_DECL_REGISTER (b
->decl
))
7191 error_at (b
->locus
, "%<void%> as only parameter may not be qualified");
7193 /* There cannot be an ellipsis. */
7195 error_at (b
->locus
, "%<void%> must be the only parameter");
7197 arg_info
->types
= void_list_node
;
7202 types
= void_list_node
;
7204 /* Break up the bindings list into parms, tags, types, and others;
7205 apply sanity checks; purge the name-to-decl bindings. */
7208 tree decl
= b
->decl
;
7209 tree type
= TREE_TYPE (decl
);
7211 const char *keyword
;
7213 switch (TREE_CODE (decl
))
7218 gcc_assert (I_SYMBOL_BINDING (b
->id
) == b
);
7219 I_SYMBOL_BINDING (b
->id
) = b
->shadowed
;
7222 /* Check for forward decls that never got their actual decl. */
7223 if (TREE_ASM_WRITTEN (decl
))
7225 "parameter %q+D has just a forward declaration", decl
);
7226 /* Check for (..., void, ...) and issue an error. */
7227 else if (VOID_TYPE_P (type
) && !DECL_NAME (decl
))
7229 if (!gave_void_only_once_err
)
7231 error_at (b
->locus
, "%<void%> must be the only parameter");
7232 gave_void_only_once_err
= true;
7237 /* Valid parameter, add it to the list. */
7238 DECL_CHAIN (decl
) = parms
;
7241 /* Since there is a prototype, args are passed in their
7242 declared types. The back end may override this later. */
7243 DECL_ARG_TYPE (decl
) = type
;
7244 types
= tree_cons (0, type
, types
);
7248 case ENUMERAL_TYPE
: keyword
= "enum"; goto tag
;
7249 case UNION_TYPE
: keyword
= "union"; goto tag
;
7250 case RECORD_TYPE
: keyword
= "struct"; goto tag
;
7252 /* Types may not have tag-names, in which case the type
7253 appears in the bindings list with b->id NULL. */
7256 gcc_assert (I_TAG_BINDING (b
->id
) == b
);
7257 I_TAG_BINDING (b
->id
) = b
->shadowed
;
7260 /* Warn about any struct, union or enum tags defined in a
7261 parameter list. The scope of such types is limited to
7262 the parameter list, which is rarely if ever desirable
7263 (it's impossible to call such a function with type-
7264 correct arguments). An anonymous union parm type is
7265 meaningful as a GNU extension, so don't warn for that. */
7266 if (TREE_CODE (decl
) != UNION_TYPE
|| b
->id
!= NULL_TREE
)
7269 /* The %s will be one of 'struct', 'union', or 'enum'. */
7270 warning_at (b
->locus
, 0,
7271 "%<%s %E%> declared inside parameter list"
7272 " will not be visible outside of this definition or"
7273 " declaration", keyword
, b
->id
);
7275 /* The %s will be one of 'struct', 'union', or 'enum'. */
7276 warning_at (b
->locus
, 0,
7277 "anonymous %s declared inside parameter list"
7278 " will not be visible outside of this definition or"
7279 " declaration", keyword
);
7284 vec_safe_push (tags
, tag
);
7288 /* FUNCTION_DECLs appear when there is an implicit function
7289 declaration in the parameter list. */
7290 gcc_assert (b
->nested
|| seen_error ());
7295 /* CONST_DECLs appear here when we have an embedded enum,
7296 and TYPE_DECLs appear here when we have an embedded struct
7297 or union. No warnings for this - we already warned about the
7300 /* When we reinsert this decl in the function body, we need
7301 to reconstruct whether it was marked as nested. */
7302 gcc_assert (!b
->nested
);
7303 DECL_CHAIN (decl
) = others
;
7309 /* error_mark_node appears here when we have an undeclared
7310 variable. Just throw it away. */
7313 gcc_assert (I_SYMBOL_BINDING (b
->id
) == b
);
7314 I_SYMBOL_BINDING (b
->id
) = b
->shadowed
;
7318 /* Other things that might be encountered. */
7325 b
= free_binding_and_advance (b
);
7328 arg_info
->parms
= parms
;
7329 arg_info
->tags
= tags
;
7330 arg_info
->types
= types
;
7331 arg_info
->others
= others
;
7332 arg_info
->pending_sizes
= expr
;
7336 /* Get the struct, enum or union (CODE says which) with tag NAME.
7337 Define the tag as a forward-reference with location LOC if it is
7338 not defined. Return a c_typespec structure for the type
7342 parser_xref_tag (location_t loc
, enum tree_code code
, tree name
)
7344 struct c_typespec ret
;
7348 ret
.expr
= NULL_TREE
;
7349 ret
.expr_const_operands
= true;
7351 /* If a cross reference is requested, look up the type
7352 already defined for this tag and return it. */
7354 ref
= lookup_tag (code
, name
, false, &refloc
);
7355 /* If this is the right type of tag, return what we found.
7356 (This reference will be shadowed by shadow_tag later if appropriate.)
7357 If this is the wrong type of tag, do not return it. If it was the
7358 wrong type in the same scope, we will have had an error
7359 message already; if in a different scope and declaring
7360 a name, pending_xref_error will give an error message; but if in a
7361 different scope and not declaring a name, this tag should
7362 shadow the previous declaration of a different type of tag, and
7363 this would not work properly if we return the reference found.
7364 (For example, with "struct foo" in an outer scope, "union foo;"
7365 must shadow that tag with a new one of union type.) */
7366 ret
.kind
= (ref
? ctsk_tagref
: ctsk_tagfirstref
);
7367 if (ref
&& TREE_CODE (ref
) == code
)
7369 if (C_TYPE_DEFINED_IN_STRUCT (ref
)
7370 && loc
!= UNKNOWN_LOCATION
7376 warning_at (loc
, OPT_Wc___compat
,
7377 ("enum type defined in struct or union "
7378 "is not visible in C++"));
7379 inform (refloc
, "enum type defined here");
7382 warning_at (loc
, OPT_Wc___compat
,
7383 ("struct defined in struct or union "
7384 "is not visible in C++"));
7385 inform (refloc
, "struct defined here");
7388 warning_at (loc
, OPT_Wc___compat
,
7389 ("union defined in struct or union "
7390 "is not visible in C++"));
7391 inform (refloc
, "union defined here");
7402 /* If no such tag is yet defined, create a forward-reference node
7403 and record it as the "definition".
7404 When a real declaration of this type is found,
7405 the forward-reference will be altered into a real type. */
7407 ref
= make_node (code
);
7408 if (code
== ENUMERAL_TYPE
)
7410 /* Give the type a default layout like unsigned int
7411 to avoid crashing if it does not get defined. */
7412 SET_TYPE_MODE (ref
, TYPE_MODE (unsigned_type_node
));
7413 SET_TYPE_ALIGN (ref
, TYPE_ALIGN (unsigned_type_node
));
7414 TYPE_USER_ALIGN (ref
) = 0;
7415 TYPE_UNSIGNED (ref
) = 1;
7416 TYPE_PRECISION (ref
) = TYPE_PRECISION (unsigned_type_node
);
7417 TYPE_MIN_VALUE (ref
) = TYPE_MIN_VALUE (unsigned_type_node
);
7418 TYPE_MAX_VALUE (ref
) = TYPE_MAX_VALUE (unsigned_type_node
);
7421 pushtag (loc
, name
, ref
);
7427 /* Get the struct, enum or union (CODE says which) with tag NAME.
7428 Define the tag as a forward-reference if it is not defined.
7429 Return a tree for the type. */
7432 xref_tag (enum tree_code code
, tree name
)
7434 return parser_xref_tag (input_location
, code
, name
).spec
;
7437 /* Make sure that the tag NAME is defined *in the current scope*
7438 at least as a forward reference.
7439 LOC is the location of the struct's definition.
7440 CODE says which kind of tag NAME ought to be.
7442 This stores the current value of the file static STRUCT_PARSE_INFO
7443 in *ENCLOSING_STRUCT_PARSE_INFO, and points STRUCT_PARSE_INFO at a
7444 new c_struct_parse_info structure. The old value of
7445 STRUCT_PARSE_INFO is restored in finish_struct. */
7448 start_struct (location_t loc
, enum tree_code code
, tree name
,
7449 struct c_struct_parse_info
**enclosing_struct_parse_info
)
7451 /* If there is already a tag defined at this scope
7452 (as a forward reference), just return it. */
7454 tree ref
= NULL_TREE
;
7455 location_t refloc
= UNKNOWN_LOCATION
;
7457 if (name
!= NULL_TREE
)
7458 ref
= lookup_tag (code
, name
, true, &refloc
);
7459 if (ref
&& TREE_CODE (ref
) == code
)
7461 if (TYPE_STUB_DECL (ref
))
7462 refloc
= DECL_SOURCE_LOCATION (TYPE_STUB_DECL (ref
));
7464 if (TYPE_SIZE (ref
))
7466 if (code
== UNION_TYPE
)
7467 error_at (loc
, "redefinition of %<union %E%>", name
);
7469 error_at (loc
, "redefinition of %<struct %E%>", name
);
7470 if (refloc
!= UNKNOWN_LOCATION
)
7471 inform (refloc
, "originally defined here");
7472 /* Don't create structures using a name already in use. */
7475 else if (C_TYPE_BEING_DEFINED (ref
))
7477 if (code
== UNION_TYPE
)
7478 error_at (loc
, "nested redefinition of %<union %E%>", name
);
7480 error_at (loc
, "nested redefinition of %<struct %E%>", name
);
7481 /* Don't bother to report "originally defined here" for a
7482 nested redefinition; the original definition should be
7484 /* Don't create structures that contain themselves. */
7489 /* Otherwise create a forward-reference just so the tag is in scope. */
7491 if (ref
== NULL_TREE
|| TREE_CODE (ref
) != code
)
7493 ref
= make_node (code
);
7494 pushtag (loc
, name
, ref
);
7497 C_TYPE_BEING_DEFINED (ref
) = 1;
7498 for (tree v
= TYPE_MAIN_VARIANT (ref
); v
; v
= TYPE_NEXT_VARIANT (v
))
7499 TYPE_PACKED (v
) = flag_pack_struct
;
7501 *enclosing_struct_parse_info
= struct_parse_info
;
7502 struct_parse_info
= new c_struct_parse_info ();
7504 /* FIXME: This will issue a warning for a use of a type defined
7505 within a statement expr used within sizeof, et. al. This is not
7506 terribly serious as C++ doesn't permit statement exprs within
7508 if (warn_cxx_compat
&& (in_sizeof
|| in_typeof
|| in_alignof
))
7509 warning_at (loc
, OPT_Wc___compat
,
7510 "defining type in %qs expression is invalid in C++",
7513 : (in_typeof
? "typeof" : "alignof")));
7518 /* Process the specs, declarator and width (NULL if omitted)
7519 of a structure component, returning a FIELD_DECL node.
7520 WIDTH is non-NULL for bit-fields only, and is an INTEGER_CST node.
7521 DECL_ATTRS is as for grokdeclarator.
7523 LOC is the location of the structure component.
7525 This is done during the parsing of the struct declaration.
7526 The FIELD_DECL nodes are chained together and the lot of them
7527 are ultimately passed to `build_struct' to make the RECORD_TYPE node. */
7530 grokfield (location_t loc
,
7531 struct c_declarator
*declarator
, struct c_declspecs
*declspecs
,
7532 tree width
, tree
*decl_attrs
)
7536 if (declarator
->kind
== cdk_id
&& declarator
->u
.id
== NULL_TREE
7537 && width
== NULL_TREE
)
7539 /* This is an unnamed decl.
7541 If we have something of the form "union { list } ;" then this
7542 is the anonymous union extension. Similarly for struct.
7544 If this is something of the form "struct foo;", then
7545 If MS or Plan 9 extensions are enabled, this is handled as
7546 an anonymous struct.
7547 Otherwise this is a forward declaration of a structure tag.
7549 If this is something of the form "foo;" and foo is a TYPE_DECL, then
7550 If foo names a structure or union without a tag, then this
7551 is an anonymous struct (this is permitted by C11).
7552 If MS or Plan 9 extensions are enabled and foo names a
7553 structure, then again this is an anonymous struct.
7554 Otherwise this is an error.
7556 Oh what a horrid tangled web we weave. I wonder if MS consciously
7557 took this from Plan 9 or if it was an accident of implementation
7558 that took root before someone noticed the bug... */
7560 tree type
= declspecs
->type
;
7563 if (RECORD_OR_UNION_TYPE_P (type
)
7564 && (flag_ms_extensions
7565 || flag_plan9_extensions
7566 || !declspecs
->typedef_p
))
7568 if (flag_ms_extensions
|| flag_plan9_extensions
)
7570 else if (TYPE_NAME (type
) == NULL
)
7577 pedwarn (loc
, 0, "declaration does not declare anything");
7581 pedwarn_c99 (loc
, OPT_Wpedantic
,
7582 "ISO C99 doesn%'t support unnamed structs/unions");
7584 pedwarn_c99 (loc
, OPT_Wpedantic
,
7585 "ISO C90 doesn%'t support unnamed structs/unions");
7588 value
= grokdeclarator (declarator
, declspecs
, FIELD
, false,
7589 width
? &width
: NULL
, decl_attrs
, NULL
, NULL
,
7592 finish_decl (value
, loc
, NULL_TREE
, NULL_TREE
, NULL_TREE
);
7593 DECL_INITIAL (value
) = width
;
7595 if (warn_cxx_compat
&& DECL_NAME (value
) != NULL_TREE
)
7597 /* If we currently have a binding for this field, set the
7598 in_struct field in the binding, so that we warn about lookups
7600 struct c_binding
*b
= I_SYMBOL_BINDING (DECL_NAME (value
));
7603 /* If the in_struct field is not yet set, push it on a list
7604 to be cleared when this struct is finished. */
7607 struct_parse_info
->fields
.safe_push (b
);
7616 /* Subroutine of detect_field_duplicates: return whether X and Y,
7617 which are both fields in the same struct, have duplicate field
7621 is_duplicate_field (tree x
, tree y
)
7623 if (DECL_NAME (x
) != NULL_TREE
&& DECL_NAME (x
) == DECL_NAME (y
))
7626 /* When using -fplan9-extensions, an anonymous field whose name is a
7627 typedef can duplicate a field name. */
7628 if (flag_plan9_extensions
7629 && (DECL_NAME (x
) == NULL_TREE
|| DECL_NAME (y
) == NULL_TREE
))
7631 tree xt
, xn
, yt
, yn
;
7634 if (DECL_NAME (x
) != NULL_TREE
)
7636 else if (RECORD_OR_UNION_TYPE_P (xt
)
7637 && TYPE_NAME (xt
) != NULL_TREE
7638 && TREE_CODE (TYPE_NAME (xt
)) == TYPE_DECL
)
7639 xn
= DECL_NAME (TYPE_NAME (xt
));
7644 if (DECL_NAME (y
) != NULL_TREE
)
7646 else if (RECORD_OR_UNION_TYPE_P (yt
)
7647 && TYPE_NAME (yt
) != NULL_TREE
7648 && TREE_CODE (TYPE_NAME (yt
)) == TYPE_DECL
)
7649 yn
= DECL_NAME (TYPE_NAME (yt
));
7653 if (xn
!= NULL_TREE
&& xn
== yn
)
7660 /* Subroutine of detect_field_duplicates: add the fields of FIELDLIST
7661 to HTAB, giving errors for any duplicates. */
7664 detect_field_duplicates_hash (tree fieldlist
,
7665 hash_table
<nofree_ptr_hash
<tree_node
> > *htab
)
7670 for (x
= fieldlist
; x
; x
= DECL_CHAIN (x
))
7671 if ((y
= DECL_NAME (x
)) != NULL_TREE
)
7673 slot
= htab
->find_slot (y
, INSERT
);
7676 error ("duplicate member %q+D", x
);
7677 DECL_NAME (x
) = NULL_TREE
;
7681 else if (RECORD_OR_UNION_TYPE_P (TREE_TYPE (x
)))
7683 detect_field_duplicates_hash (TYPE_FIELDS (TREE_TYPE (x
)), htab
);
7685 /* When using -fplan9-extensions, an anonymous field whose
7686 name is a typedef can duplicate a field name. */
7687 if (flag_plan9_extensions
7688 && TYPE_NAME (TREE_TYPE (x
)) != NULL_TREE
7689 && TREE_CODE (TYPE_NAME (TREE_TYPE (x
))) == TYPE_DECL
)
7691 tree xn
= DECL_NAME (TYPE_NAME (TREE_TYPE (x
)));
7692 slot
= htab
->find_slot (xn
, INSERT
);
7694 error ("duplicate member %q+D", TYPE_NAME (TREE_TYPE (x
)));
7700 /* Generate an error for any duplicate field names in FIELDLIST. Munge
7701 the list such that this does not present a problem later. */
7704 detect_field_duplicates (tree fieldlist
)
7709 /* If the struct is the list of instance variables of an Objective-C
7710 class, then we need to check all the instance variables of
7711 superclasses when checking for duplicates (since you can't have
7712 an instance variable in a subclass with the same name as an
7713 instance variable in a superclass). We pass on this job to the
7714 Objective-C compiler. objc_detect_field_duplicates() will return
7715 false if we are not checking the list of instance variables and
7716 the C frontend should proceed with the standard field duplicate
7717 checks. If we are checking the list of instance variables, the
7718 ObjC frontend will do the check, emit the errors if needed, and
7719 then return true. */
7720 if (c_dialect_objc ())
7721 if (objc_detect_field_duplicates (false))
7724 /* First, see if there are more than "a few" fields.
7725 This is trivially true if there are zero or one fields. */
7726 if (!fieldlist
|| !DECL_CHAIN (fieldlist
))
7731 if (DECL_NAME (x
) == NULL_TREE
7732 && RECORD_OR_UNION_TYPE_P (TREE_TYPE (x
)))
7735 } while (timeout
> 0 && x
);
7737 /* If there were "few" fields and no anonymous structures or unions,
7738 avoid the overhead of allocating a hash table. Instead just do
7739 the nested traversal thing. */
7742 for (x
= DECL_CHAIN (fieldlist
); x
; x
= DECL_CHAIN (x
))
7743 /* When using -fplan9-extensions, we can have duplicates
7744 between typedef names and fields. */
7746 || (flag_plan9_extensions
7747 && DECL_NAME (x
) == NULL_TREE
7748 && RECORD_OR_UNION_TYPE_P (TREE_TYPE (x
))
7749 && TYPE_NAME (TREE_TYPE (x
)) != NULL_TREE
7750 && TREE_CODE (TYPE_NAME (TREE_TYPE (x
))) == TYPE_DECL
))
7752 for (y
= fieldlist
; y
!= x
; y
= TREE_CHAIN (y
))
7753 if (is_duplicate_field (y
, x
))
7755 error ("duplicate member %q+D", x
);
7756 DECL_NAME (x
) = NULL_TREE
;
7762 hash_table
<nofree_ptr_hash
<tree_node
> > htab (37);
7763 detect_field_duplicates_hash (fieldlist
, &htab
);
7767 /* Finish up struct info used by -Wc++-compat. */
7770 warn_cxx_compat_finish_struct (tree fieldlist
, enum tree_code code
,
7771 location_t record_loc
)
7775 struct c_binding
*b
;
7777 if (fieldlist
== NULL_TREE
)
7779 if (code
== RECORD_TYPE
)
7780 warning_at (record_loc
, OPT_Wc___compat
,
7781 "empty struct has size 0 in C, size 1 in C++");
7783 warning_at (record_loc
, OPT_Wc___compat
,
7784 "empty union has size 0 in C, size 1 in C++");
7787 /* Set the C_TYPE_DEFINED_IN_STRUCT flag for each type defined in
7788 the current struct. We do this now at the end of the struct
7789 because the flag is used to issue visibility warnings, and we
7790 only want to issue those warnings if the type is referenced
7791 outside of the struct declaration. */
7792 FOR_EACH_VEC_ELT (struct_parse_info
->struct_types
, ix
, x
)
7793 C_TYPE_DEFINED_IN_STRUCT (x
) = 1;
7795 /* The TYPEDEFS_SEEN field of STRUCT_PARSE_INFO is a list of
7796 typedefs used when declaring fields in this struct. If the name
7797 of any of the fields is also a typedef name then the struct would
7798 not parse in C++, because the C++ lookup rules say that the
7799 typedef name would be looked up in the context of the struct, and
7800 would thus be the field rather than the typedef. */
7801 if (!struct_parse_info
->typedefs_seen
.is_empty ()
7802 && fieldlist
!= NULL_TREE
)
7804 /* Use a hash_set<tree> using the name of the typedef. We can use
7805 a hash_set<tree> because identifiers are interned. */
7806 hash_set
<tree
> tset
;
7808 FOR_EACH_VEC_ELT (struct_parse_info
->typedefs_seen
, ix
, x
)
7809 tset
.add (DECL_NAME (x
));
7811 for (x
= fieldlist
; x
!= NULL_TREE
; x
= DECL_CHAIN (x
))
7813 if (DECL_NAME (x
) != NULL_TREE
7814 && tset
.contains (DECL_NAME (x
)))
7816 warning_at (DECL_SOURCE_LOCATION (x
), OPT_Wc___compat
,
7817 ("using %qD as both field and typedef name is "
7820 /* FIXME: It would be nice to report the location where
7821 the typedef name is used. */
7826 /* For each field which has a binding and which was not defined in
7827 an enclosing struct, clear the in_struct field. */
7828 FOR_EACH_VEC_ELT (struct_parse_info
->fields
, ix
, b
)
7832 /* Fill in the fields of a RECORD_TYPE or UNION_TYPE node, T.
7833 LOC is the location of the RECORD_TYPE or UNION_TYPE's definition.
7834 FIELDLIST is a chain of FIELD_DECL nodes for the fields.
7835 ATTRIBUTES are attributes to be applied to the structure.
7837 ENCLOSING_STRUCT_PARSE_INFO is the value of STRUCT_PARSE_INFO when
7838 the struct was started. */
7841 finish_struct (location_t loc
, tree t
, tree fieldlist
, tree attributes
,
7842 struct c_struct_parse_info
*enclosing_struct_parse_info
)
7845 bool toplevel
= file_scope
== current_scope
;
7847 /* If this type was previously laid out as a forward reference,
7848 make sure we lay it out again. */
7850 TYPE_SIZE (t
) = NULL_TREE
;
7852 decl_attributes (&t
, attributes
, (int) ATTR_FLAG_TYPE_IN_PLACE
);
7856 for (x
= fieldlist
; x
; x
= DECL_CHAIN (x
))
7858 if (DECL_NAME (x
) != NULL_TREE
)
7860 if (flag_isoc11
&& RECORD_OR_UNION_TYPE_P (TREE_TYPE (x
)))
7866 if (TREE_CODE (t
) == UNION_TYPE
)
7869 pedwarn (loc
, OPT_Wpedantic
, "union has no named members");
7871 pedwarn (loc
, OPT_Wpedantic
, "union has no members");
7876 pedwarn (loc
, OPT_Wpedantic
, "struct has no named members");
7878 pedwarn (loc
, OPT_Wpedantic
, "struct has no members");
7883 /* Install struct as DECL_CONTEXT of each field decl.
7884 Also process specified field sizes, found in the DECL_INITIAL,
7885 storing 0 there after the type has been changed to precision equal
7886 to its width, rather than the precision of the specified standard
7887 type. (Correct layout requires the original type to have been preserved
7890 bool saw_named_field
= false;
7891 for (x
= fieldlist
; x
; x
= DECL_CHAIN (x
))
7893 if (TREE_TYPE (x
) == error_mark_node
)
7896 DECL_CONTEXT (x
) = t
;
7898 /* If any field is const, the structure type is pseudo-const. */
7899 if (TREE_READONLY (x
))
7900 C_TYPE_FIELDS_READONLY (t
) = 1;
7903 /* A field that is pseudo-const makes the structure likewise. */
7904 tree t1
= strip_array_types (TREE_TYPE (x
));
7905 if (RECORD_OR_UNION_TYPE_P (t1
) && C_TYPE_FIELDS_READONLY (t1
))
7906 C_TYPE_FIELDS_READONLY (t
) = 1;
7909 /* Any field that is volatile means variables of this type must be
7910 treated in some ways as volatile. */
7911 if (TREE_THIS_VOLATILE (x
))
7912 C_TYPE_FIELDS_VOLATILE (t
) = 1;
7914 /* Any field of nominal variable size implies structure is too. */
7915 if (C_DECL_VARIABLE_SIZE (x
))
7916 C_TYPE_VARIABLE_SIZE (t
) = 1;
7918 if (DECL_INITIAL (x
))
7920 unsigned HOST_WIDE_INT width
= tree_to_uhwi (DECL_INITIAL (x
));
7921 DECL_SIZE (x
) = bitsize_int (width
);
7922 DECL_BIT_FIELD (x
) = 1;
7923 SET_DECL_C_BIT_FIELD (x
);
7927 && (DECL_BIT_FIELD (x
)
7928 || TYPE_ALIGN (TREE_TYPE (x
)) > BITS_PER_UNIT
))
7929 DECL_PACKED (x
) = 1;
7931 /* Detect flexible array member in an invalid context. */
7932 if (TREE_CODE (TREE_TYPE (x
)) == ARRAY_TYPE
7933 && TYPE_SIZE (TREE_TYPE (x
)) == NULL_TREE
7934 && TYPE_DOMAIN (TREE_TYPE (x
)) != NULL_TREE
7935 && TYPE_MAX_VALUE (TYPE_DOMAIN (TREE_TYPE (x
))) == NULL_TREE
)
7937 if (TREE_CODE (t
) == UNION_TYPE
)
7939 error_at (DECL_SOURCE_LOCATION (x
),
7940 "flexible array member in union");
7941 TREE_TYPE (x
) = error_mark_node
;
7943 else if (DECL_CHAIN (x
) != NULL_TREE
)
7945 error_at (DECL_SOURCE_LOCATION (x
),
7946 "flexible array member not at end of struct");
7947 TREE_TYPE (x
) = error_mark_node
;
7949 else if (!saw_named_field
)
7951 error_at (DECL_SOURCE_LOCATION (x
),
7952 "flexible array member in a struct with no named "
7954 TREE_TYPE (x
) = error_mark_node
;
7958 if (pedantic
&& TREE_CODE (t
) == RECORD_TYPE
7959 && flexible_array_type_p (TREE_TYPE (x
)))
7960 pedwarn (DECL_SOURCE_LOCATION (x
), OPT_Wpedantic
,
7961 "invalid use of structure with flexible array member");
7964 || RECORD_OR_UNION_TYPE_P (TREE_TYPE (x
)))
7965 saw_named_field
= true;
7968 detect_field_duplicates (fieldlist
);
7970 /* Now we have the nearly final fieldlist. Record it,
7971 then lay out the structure or union (including the fields). */
7973 TYPE_FIELDS (t
) = fieldlist
;
7975 maybe_apply_pragma_scalar_storage_order (t
);
7979 if (TYPE_SIZE_UNIT (t
)
7980 && TREE_CODE (TYPE_SIZE_UNIT (t
)) == INTEGER_CST
7981 && !TREE_OVERFLOW (TYPE_SIZE_UNIT (t
))
7982 && !valid_constant_size_p (TYPE_SIZE_UNIT (t
)))
7983 error ("type %qT is too large", t
);
7985 /* Give bit-fields their proper types and rewrite the type of array fields
7986 with scalar component if the enclosing type has reverse storage order. */
7987 for (tree field
= fieldlist
; field
; field
= DECL_CHAIN (field
))
7989 if (TREE_CODE (field
) == FIELD_DECL
7990 && DECL_INITIAL (field
)
7991 && TREE_TYPE (field
) != error_mark_node
)
7993 unsigned HOST_WIDE_INT width
7994 = tree_to_uhwi (DECL_INITIAL (field
));
7995 tree type
= TREE_TYPE (field
);
7996 if (width
!= TYPE_PRECISION (type
))
7999 = c_build_bitfield_integer_type (width
, TYPE_UNSIGNED (type
));
8000 SET_DECL_MODE (field
, TYPE_MODE (TREE_TYPE (field
)));
8002 DECL_INITIAL (field
) = NULL_TREE
;
8004 else if (TYPE_REVERSE_STORAGE_ORDER (t
)
8005 && TREE_CODE (field
) == FIELD_DECL
8006 && TREE_CODE (TREE_TYPE (field
)) == ARRAY_TYPE
)
8008 tree ftype
= TREE_TYPE (field
);
8009 tree ctype
= strip_array_types (ftype
);
8010 if (!RECORD_OR_UNION_TYPE_P (ctype
) && TYPE_MODE (ctype
) != QImode
)
8012 tree fmain_type
= TYPE_MAIN_VARIANT (ftype
);
8013 tree
*typep
= &fmain_type
;
8015 *typep
= build_distinct_type_copy (*typep
);
8016 TYPE_REVERSE_STORAGE_ORDER (*typep
) = 1;
8017 typep
= &TREE_TYPE (*typep
);
8018 } while (TREE_CODE (*typep
) == ARRAY_TYPE
);
8020 = c_build_qualified_type (fmain_type
, TYPE_QUALS (ftype
));
8025 /* Now we have the truly final field list.
8026 Store it in this type and in the variants. */
8028 TYPE_FIELDS (t
) = fieldlist
;
8030 /* If there are lots of fields, sort so we can look through them fast.
8031 We arbitrarily consider 16 or more elts to be "a lot". */
8036 for (x
= fieldlist
; x
; x
= DECL_CHAIN (x
))
8038 if (len
> 15 || DECL_NAME (x
) == NULL
)
8046 struct lang_type
*space
;
8047 struct sorted_fields_type
*space2
;
8049 len
+= list_length (x
);
8051 /* Use the same allocation policy here that make_node uses, to
8052 ensure that this lives as long as the rest of the struct decl.
8053 All decls in an inline function need to be saved. */
8055 space
= ggc_cleared_alloc
<struct lang_type
> ();
8056 space2
= (sorted_fields_type
*) ggc_internal_alloc
8057 (sizeof (struct sorted_fields_type
) + len
* sizeof (tree
));
8061 field_array
= &space2
->elts
[0];
8062 for (x
= fieldlist
; x
; x
= DECL_CHAIN (x
))
8064 field_array
[len
++] = x
;
8066 /* If there is anonymous struct or union, break out of the loop. */
8067 if (DECL_NAME (x
) == NULL
)
8070 /* Found no anonymous struct/union. Add the TYPE_LANG_SPECIFIC. */
8073 TYPE_LANG_SPECIFIC (t
) = space
;
8074 TYPE_LANG_SPECIFIC (t
)->s
->len
= len
;
8075 field_array
= TYPE_LANG_SPECIFIC (t
)->s
->elts
;
8076 qsort (field_array
, len
, sizeof (tree
), field_decl_cmp
);
8081 /* Note: C_TYPE_INCOMPLETE_VARS overloads TYPE_VFIELD which is used
8082 in dwarf2out via rest_of_decl_compilation below and means
8083 something totally different. Since we will be clearing
8084 C_TYPE_INCOMPLETE_VARS shortly after we iterate through them,
8085 clear it ahead of time and avoid problems in dwarf2out. Ideally,
8086 C_TYPE_INCOMPLETE_VARS should use some language specific
8088 tree incomplete_vars
= C_TYPE_INCOMPLETE_VARS (TYPE_MAIN_VARIANT (t
));
8089 for (x
= TYPE_MAIN_VARIANT (t
); x
; x
= TYPE_NEXT_VARIANT (x
))
8091 TYPE_FIELDS (x
) = TYPE_FIELDS (t
);
8092 TYPE_LANG_SPECIFIC (x
) = TYPE_LANG_SPECIFIC (t
);
8093 C_TYPE_FIELDS_READONLY (x
) = C_TYPE_FIELDS_READONLY (t
);
8094 C_TYPE_FIELDS_VOLATILE (x
) = C_TYPE_FIELDS_VOLATILE (t
);
8095 C_TYPE_VARIABLE_SIZE (x
) = C_TYPE_VARIABLE_SIZE (t
);
8096 C_TYPE_INCOMPLETE_VARS (x
) = NULL_TREE
;
8099 /* If this was supposed to be a transparent union, but we can't
8100 make it one, warn and turn off the flag. */
8101 if (TREE_CODE (t
) == UNION_TYPE
8102 && TYPE_TRANSPARENT_AGGR (t
)
8103 && (!TYPE_FIELDS (t
) || TYPE_MODE (t
) != DECL_MODE (TYPE_FIELDS (t
))))
8105 TYPE_TRANSPARENT_AGGR (t
) = 0;
8106 warning_at (loc
, 0, "union cannot be made transparent");
8109 /* If this structure or union completes the type of any previous
8110 variable declaration, lay it out and output its rtl. */
8111 for (x
= incomplete_vars
; x
; x
= TREE_CHAIN (x
))
8113 tree decl
= TREE_VALUE (x
);
8114 if (TREE_CODE (TREE_TYPE (decl
)) == ARRAY_TYPE
)
8115 layout_array_type (TREE_TYPE (decl
));
8116 if (TREE_CODE (decl
) != TYPE_DECL
)
8118 layout_decl (decl
, 0);
8119 if (c_dialect_objc ())
8120 objc_check_decl (decl
);
8121 rest_of_decl_compilation (decl
, toplevel
, 0);
8125 /* Update type location to the one of the definition, instead of e.g.
8126 a forward declaration. */
8127 if (TYPE_STUB_DECL (t
))
8128 DECL_SOURCE_LOCATION (TYPE_STUB_DECL (t
)) = loc
;
8130 /* Finish debugging output for this type. */
8131 rest_of_type_compilation (t
, toplevel
);
8133 /* If we're inside a function proper, i.e. not file-scope and not still
8134 parsing parameters, then arrange for the size of a variable sized type
8136 if (building_stmt_list_p () && variably_modified_type_p (t
, NULL_TREE
))
8137 add_stmt (build_stmt (loc
,
8138 DECL_EXPR
, build_decl (loc
, TYPE_DECL
, NULL
, t
)));
8140 if (warn_cxx_compat
)
8141 warn_cxx_compat_finish_struct (fieldlist
, TREE_CODE (t
), loc
);
8143 delete struct_parse_info
;
8145 struct_parse_info
= enclosing_struct_parse_info
;
8147 /* If this struct is defined inside a struct, add it to
8150 && struct_parse_info
!= NULL
8151 && !in_sizeof
&& !in_typeof
&& !in_alignof
)
8152 struct_parse_info
->struct_types
.safe_push (t
);
8157 /* Lay out the type T, and its element type, and so on. */
8160 layout_array_type (tree t
)
8162 if (TREE_CODE (TREE_TYPE (t
)) == ARRAY_TYPE
)
8163 layout_array_type (TREE_TYPE (t
));
8167 /* Begin compiling the definition of an enumeration type.
8168 NAME is its name (or null if anonymous).
8169 LOC is the enum's location.
8170 Returns the type object, as yet incomplete.
8171 Also records info about it so that build_enumerator
8172 may be used to declare the individual values as they are read. */
8175 start_enum (location_t loc
, struct c_enum_contents
*the_enum
, tree name
)
8177 tree enumtype
= NULL_TREE
;
8178 location_t enumloc
= UNKNOWN_LOCATION
;
8180 /* If this is the real definition for a previous forward reference,
8181 fill in the contents in the same object that used to be the
8182 forward reference. */
8184 if (name
!= NULL_TREE
)
8185 enumtype
= lookup_tag (ENUMERAL_TYPE
, name
, true, &enumloc
);
8187 if (enumtype
== NULL_TREE
|| TREE_CODE (enumtype
) != ENUMERAL_TYPE
)
8189 enumtype
= make_node (ENUMERAL_TYPE
);
8190 pushtag (loc
, name
, enumtype
);
8192 /* Update type location to the one of the definition, instead of e.g.
8193 a forward declaration. */
8194 else if (TYPE_STUB_DECL (enumtype
))
8196 enumloc
= DECL_SOURCE_LOCATION (TYPE_STUB_DECL (enumtype
));
8197 DECL_SOURCE_LOCATION (TYPE_STUB_DECL (enumtype
)) = loc
;
8200 if (C_TYPE_BEING_DEFINED (enumtype
))
8201 error_at (loc
, "nested redefinition of %<enum %E%>", name
);
8203 C_TYPE_BEING_DEFINED (enumtype
) = 1;
8205 if (TYPE_VALUES (enumtype
) != NULL_TREE
)
8207 /* This enum is a named one that has been declared already. */
8208 error_at (loc
, "redeclaration of %<enum %E%>", name
);
8209 if (enumloc
!= UNKNOWN_LOCATION
)
8210 inform (enumloc
, "originally defined here");
8212 /* Completely replace its old definition.
8213 The old enumerators remain defined, however. */
8214 TYPE_VALUES (enumtype
) = NULL_TREE
;
8217 the_enum
->enum_next_value
= integer_zero_node
;
8218 the_enum
->enum_overflow
= 0;
8220 if (flag_short_enums
)
8221 for (tree v
= TYPE_MAIN_VARIANT (enumtype
); v
; v
= TYPE_NEXT_VARIANT (v
))
8222 TYPE_PACKED (v
) = 1;
8224 /* FIXME: This will issue a warning for a use of a type defined
8225 within sizeof in a statement expr. This is not terribly serious
8226 as C++ doesn't permit statement exprs within sizeof anyhow. */
8227 if (warn_cxx_compat
&& (in_sizeof
|| in_typeof
|| in_alignof
))
8228 warning_at (loc
, OPT_Wc___compat
,
8229 "defining type in %qs expression is invalid in C++",
8232 : (in_typeof
? "typeof" : "alignof")));
8237 /* After processing and defining all the values of an enumeration type,
8238 install their decls in the enumeration type and finish it off.
8239 ENUMTYPE is the type object, VALUES a list of decl-value pairs,
8240 and ATTRIBUTES are the specified attributes.
8241 Returns ENUMTYPE. */
8244 finish_enum (tree enumtype
, tree values
, tree attributes
)
8247 tree minnode
= NULL_TREE
, maxnode
= NULL_TREE
;
8250 bool toplevel
= (file_scope
== current_scope
);
8251 struct lang_type
*lt
;
8253 decl_attributes (&enumtype
, attributes
, (int) ATTR_FLAG_TYPE_IN_PLACE
);
8255 /* Calculate the maximum value of any enumerator in this type. */
8257 if (values
== error_mark_node
)
8258 minnode
= maxnode
= integer_zero_node
;
8261 minnode
= maxnode
= TREE_VALUE (values
);
8262 for (pair
= TREE_CHAIN (values
); pair
; pair
= TREE_CHAIN (pair
))
8264 tree value
= TREE_VALUE (pair
);
8265 if (tree_int_cst_lt (maxnode
, value
))
8267 if (tree_int_cst_lt (value
, minnode
))
8272 /* Construct the final type of this enumeration. It is the same
8273 as one of the integral types - the narrowest one that fits, except
8274 that normally we only go as narrow as int - and signed iff any of
8275 the values are negative. */
8276 sign
= (tree_int_cst_sgn (minnode
) >= 0) ? UNSIGNED
: SIGNED
;
8277 precision
= MAX (tree_int_cst_min_precision (minnode
, sign
),
8278 tree_int_cst_min_precision (maxnode
, sign
));
8280 /* If the precision of the type was specified with an attribute and it
8281 was too small, give an error. Otherwise, use it. */
8282 if (TYPE_PRECISION (enumtype
) && lookup_attribute ("mode", attributes
))
8284 if (precision
> TYPE_PRECISION (enumtype
))
8286 TYPE_PRECISION (enumtype
) = 0;
8287 error ("specified mode too small for enumeral values");
8290 precision
= TYPE_PRECISION (enumtype
);
8293 TYPE_PRECISION (enumtype
) = 0;
8295 if (TYPE_PACKED (enumtype
)
8296 || precision
> TYPE_PRECISION (integer_type_node
)
8297 || TYPE_PRECISION (enumtype
))
8299 tem
= c_common_type_for_size (precision
, sign
== UNSIGNED
? 1 : 0);
8302 warning (0, "enumeration values exceed range of largest integer");
8303 tem
= long_long_integer_type_node
;
8307 tem
= sign
== UNSIGNED
? unsigned_type_node
: integer_type_node
;
8309 TYPE_MIN_VALUE (enumtype
) = TYPE_MIN_VALUE (tem
);
8310 TYPE_MAX_VALUE (enumtype
) = TYPE_MAX_VALUE (tem
);
8311 TYPE_UNSIGNED (enumtype
) = TYPE_UNSIGNED (tem
);
8312 SET_TYPE_ALIGN (enumtype
, TYPE_ALIGN (tem
));
8313 TYPE_SIZE (enumtype
) = NULL_TREE
;
8314 TYPE_PRECISION (enumtype
) = TYPE_PRECISION (tem
);
8316 layout_type (enumtype
);
8318 if (values
!= error_mark_node
)
8320 /* Change the type of the enumerators to be the enum type. We
8321 need to do this irrespective of the size of the enum, for
8322 proper type checking. Replace the DECL_INITIALs of the
8323 enumerators, and the value slots of the list, with copies
8324 that have the enum type; they cannot be modified in place
8325 because they may be shared (e.g. integer_zero_node) Finally,
8326 change the purpose slots to point to the names of the decls. */
8327 for (pair
= values
; pair
; pair
= TREE_CHAIN (pair
))
8329 tree enu
= TREE_PURPOSE (pair
);
8330 tree ini
= DECL_INITIAL (enu
);
8332 TREE_TYPE (enu
) = enumtype
;
8334 /* The ISO C Standard mandates enumerators to have type int,
8335 even though the underlying type of an enum type is
8336 unspecified. However, GCC allows enumerators of any
8337 integer type as an extensions. build_enumerator()
8338 converts any enumerators that fit in an int to type int,
8339 to avoid promotions to unsigned types when comparing
8340 integers with enumerators that fit in the int range.
8341 When -pedantic is given, build_enumerator() would have
8342 already warned about those that don't fit. Here we
8343 convert the rest to the enumerator type. */
8344 if (TREE_TYPE (ini
) != integer_type_node
)
8345 ini
= convert (enumtype
, ini
);
8347 DECL_INITIAL (enu
) = ini
;
8348 TREE_PURPOSE (pair
) = DECL_NAME (enu
);
8349 TREE_VALUE (pair
) = ini
;
8352 TYPE_VALUES (enumtype
) = values
;
8355 /* Record the min/max values so that we can warn about bit-field
8356 enumerations that are too small for the values. */
8357 lt
= ggc_cleared_alloc
<struct lang_type
> ();
8358 lt
->enum_min
= minnode
;
8359 lt
->enum_max
= maxnode
;
8360 TYPE_LANG_SPECIFIC (enumtype
) = lt
;
8362 /* Fix up all variant types of this enum type. */
8363 for (tem
= TYPE_MAIN_VARIANT (enumtype
); tem
; tem
= TYPE_NEXT_VARIANT (tem
))
8365 if (tem
== enumtype
)
8367 TYPE_VALUES (tem
) = TYPE_VALUES (enumtype
);
8368 TYPE_MIN_VALUE (tem
) = TYPE_MIN_VALUE (enumtype
);
8369 TYPE_MAX_VALUE (tem
) = TYPE_MAX_VALUE (enumtype
);
8370 TYPE_SIZE (tem
) = TYPE_SIZE (enumtype
);
8371 TYPE_SIZE_UNIT (tem
) = TYPE_SIZE_UNIT (enumtype
);
8372 SET_TYPE_MODE (tem
, TYPE_MODE (enumtype
));
8373 TYPE_PRECISION (tem
) = TYPE_PRECISION (enumtype
);
8374 SET_TYPE_ALIGN (tem
, TYPE_ALIGN (enumtype
));
8375 TYPE_USER_ALIGN (tem
) = TYPE_USER_ALIGN (enumtype
);
8376 TYPE_UNSIGNED (tem
) = TYPE_UNSIGNED (enumtype
);
8377 TYPE_LANG_SPECIFIC (tem
) = TYPE_LANG_SPECIFIC (enumtype
);
8380 /* Finish debugging output for this type. */
8381 rest_of_type_compilation (enumtype
, toplevel
);
8383 /* If this enum is defined inside a struct, add it to
8386 && struct_parse_info
!= NULL
8387 && !in_sizeof
&& !in_typeof
&& !in_alignof
)
8388 struct_parse_info
->struct_types
.safe_push (enumtype
);
8393 /* Build and install a CONST_DECL for one value of the
8394 current enumeration type (one that was begun with start_enum).
8395 DECL_LOC is the location of the enumerator.
8396 LOC is the location of the '=' operator if any, DECL_LOC otherwise.
8397 Return a tree-list containing the CONST_DECL and its value.
8398 Assignment of sequential values by default is handled here. */
8401 build_enumerator (location_t decl_loc
, location_t loc
,
8402 struct c_enum_contents
*the_enum
, tree name
, tree value
)
8406 /* Validate and default VALUE. */
8408 if (value
!= NULL_TREE
)
8410 /* Don't issue more errors for error_mark_node (i.e. an
8411 undeclared identifier) - just ignore the value expression. */
8412 if (value
== error_mark_node
)
8414 else if (!INTEGRAL_TYPE_P (TREE_TYPE (value
)))
8416 error_at (loc
, "enumerator value for %qE is not an integer constant",
8422 if (TREE_CODE (value
) != INTEGER_CST
)
8424 value
= c_fully_fold (value
, false, NULL
);
8425 if (TREE_CODE (value
) == INTEGER_CST
)
8426 pedwarn (loc
, OPT_Wpedantic
,
8427 "enumerator value for %qE is not an integer "
8428 "constant expression", name
);
8430 if (TREE_CODE (value
) != INTEGER_CST
)
8432 error ("enumerator value for %qE is not an integer constant",
8438 value
= default_conversion (value
);
8439 constant_expression_warning (value
);
8444 /* Default based on previous value. */
8445 /* It should no longer be possible to have NON_LVALUE_EXPR
8447 if (value
== NULL_TREE
)
8449 value
= the_enum
->enum_next_value
;
8450 if (the_enum
->enum_overflow
)
8451 error_at (loc
, "overflow in enumeration values");
8453 /* Even though the underlying type of an enum is unspecified, the
8454 type of enumeration constants is explicitly defined as int
8455 (6.4.4.3/2 in the C99 Standard). GCC allows any integer type as
8457 else if (!int_fits_type_p (value
, integer_type_node
))
8458 pedwarn (loc
, OPT_Wpedantic
,
8459 "ISO C restricts enumerator values to range of %<int%>");
8461 /* The ISO C Standard mandates enumerators to have type int, even
8462 though the underlying type of an enum type is unspecified.
8463 However, GCC allows enumerators of any integer type as an
8464 extensions. Here we convert any enumerators that fit in an int
8465 to type int, to avoid promotions to unsigned types when comparing
8466 integers with enumerators that fit in the int range. When
8467 -pedantic is given, we would have already warned about those that
8468 don't fit. We have to do this here rather than in finish_enum
8469 because this value may be used to define more enumerators. */
8470 if (int_fits_type_p (value
, integer_type_node
))
8471 value
= convert (integer_type_node
, value
);
8473 /* Set basis for default for next value. */
8474 the_enum
->enum_next_value
8475 = build_binary_op (EXPR_LOC_OR_LOC (value
, input_location
),
8476 PLUS_EXPR
, value
, integer_one_node
, false);
8477 the_enum
->enum_overflow
= tree_int_cst_lt (the_enum
->enum_next_value
, value
);
8479 /* Now create a declaration for the enum value name. */
8481 type
= TREE_TYPE (value
);
8482 type
= c_common_type_for_size (MAX (TYPE_PRECISION (type
),
8483 TYPE_PRECISION (integer_type_node
)),
8484 (TYPE_PRECISION (type
)
8485 >= TYPE_PRECISION (integer_type_node
)
8486 && TYPE_UNSIGNED (type
)));
8488 decl
= build_decl (decl_loc
, CONST_DECL
, name
, type
);
8489 DECL_INITIAL (decl
) = convert (type
, value
);
8492 return tree_cons (decl
, value
, NULL_TREE
);
8496 /* Create the FUNCTION_DECL for a function definition.
8497 DECLSPECS, DECLARATOR and ATTRIBUTES are the parts of
8498 the declaration; they describe the function's name and the type it returns,
8499 but twisted together in a fashion that parallels the syntax of C.
8501 This function creates a binding context for the function body
8502 as well as setting up the FUNCTION_DECL in current_function_decl.
8504 Returns true on success. If the DECLARATOR is not suitable for a function
8505 (it defines a datum instead), we return false to report a parse error. */
8508 start_function (struct c_declspecs
*declspecs
, struct c_declarator
*declarator
,
8511 tree decl1
, old_decl
;
8512 tree restype
, resdecl
;
8515 current_function_returns_value
= 0; /* Assume, until we see it does. */
8516 current_function_returns_null
= 0;
8517 current_function_returns_abnormally
= 0;
8518 warn_about_return_type
= 0;
8519 c_switch_stack
= NULL
;
8521 /* Indicate no valid break/continue context by setting these variables
8522 to some non-null, non-label value. We'll notice and emit the proper
8523 error message in c_finish_bc_stmt. */
8524 c_break_label
= c_cont_label
= size_zero_node
;
8526 decl1
= grokdeclarator (declarator
, declspecs
, FUNCDEF
, true, NULL
,
8527 &attributes
, NULL
, NULL
, DEPRECATED_NORMAL
);
8528 invoke_plugin_callbacks (PLUGIN_START_PARSE_FUNCTION
, decl1
);
8530 /* If the declarator is not suitable for a function definition,
8531 cause a syntax error. */
8532 if (decl1
== NULL_TREE
8533 || TREE_CODE (decl1
) != FUNCTION_DECL
)
8536 loc
= DECL_SOURCE_LOCATION (decl1
);
8538 c_decl_attributes (&decl1
, attributes
, 0);
8540 if (DECL_DECLARED_INLINE_P (decl1
)
8541 && DECL_UNINLINABLE (decl1
)
8542 && lookup_attribute ("noinline", DECL_ATTRIBUTES (decl1
)))
8543 warning_at (loc
, OPT_Wattributes
,
8544 "inline function %qD given attribute noinline",
8547 /* Handle gnu_inline attribute. */
8548 if (declspecs
->inline_p
8549 && !flag_gnu89_inline
8550 && TREE_CODE (decl1
) == FUNCTION_DECL
8551 && (lookup_attribute ("gnu_inline", DECL_ATTRIBUTES (decl1
))
8552 || current_function_decl
))
8554 if (declspecs
->storage_class
!= csc_static
)
8555 DECL_EXTERNAL (decl1
) = !DECL_EXTERNAL (decl1
);
8558 announce_function (decl1
);
8560 if (!COMPLETE_OR_VOID_TYPE_P (TREE_TYPE (TREE_TYPE (decl1
))))
8562 error_at (loc
, "return type is an incomplete type");
8563 /* Make it return void instead. */
8565 = build_function_type (void_type_node
,
8566 TYPE_ARG_TYPES (TREE_TYPE (decl1
)));
8569 if (warn_about_return_type
)
8570 warn_defaults_to (loc
, flag_isoc99
? OPT_Wimplicit_int
8571 : (warn_return_type
? OPT_Wreturn_type
8572 : OPT_Wimplicit_int
),
8573 "return type defaults to %<int%>");
8575 /* Make the init_value nonzero so pushdecl knows this is not tentative.
8576 error_mark_node is replaced below (in pop_scope) with the BLOCK. */
8577 DECL_INITIAL (decl1
) = error_mark_node
;
8579 /* A nested function is not global. */
8580 if (current_function_decl
!= NULL_TREE
)
8581 TREE_PUBLIC (decl1
) = 0;
8583 /* If this definition isn't a prototype and we had a prototype declaration
8584 before, copy the arg type info from that prototype. */
8585 old_decl
= lookup_name_in_scope (DECL_NAME (decl1
), current_scope
);
8586 if (old_decl
&& TREE_CODE (old_decl
) != FUNCTION_DECL
)
8587 old_decl
= NULL_TREE
;
8588 current_function_prototype_locus
= UNKNOWN_LOCATION
;
8589 current_function_prototype_built_in
= false;
8590 current_function_prototype_arg_types
= NULL_TREE
;
8591 if (!prototype_p (TREE_TYPE (decl1
)))
8593 if (old_decl
!= NULL_TREE
8594 && TREE_CODE (TREE_TYPE (old_decl
)) == FUNCTION_TYPE
8595 && comptypes (TREE_TYPE (TREE_TYPE (decl1
)),
8596 TREE_TYPE (TREE_TYPE (old_decl
))))
8598 if (stdarg_p (TREE_TYPE (old_decl
)))
8600 warning_at (loc
, 0, "%q+D defined as variadic function "
8601 "without prototype", decl1
);
8602 locate_old_decl (old_decl
);
8604 TREE_TYPE (decl1
) = composite_type (TREE_TYPE (old_decl
),
8606 current_function_prototype_locus
= DECL_SOURCE_LOCATION (old_decl
);
8607 current_function_prototype_built_in
8608 = C_DECL_BUILTIN_PROTOTYPE (old_decl
);
8609 current_function_prototype_arg_types
8610 = TYPE_ARG_TYPES (TREE_TYPE (decl1
));
8612 if (TREE_PUBLIC (decl1
))
8614 /* If there is an external prototype declaration of this
8615 function, record its location but do not copy information
8616 to this decl. This may be an invisible declaration
8617 (built-in or in a scope which has finished) or simply
8618 have more refined argument types than any declaration
8620 struct c_binding
*b
;
8621 for (b
= I_SYMBOL_BINDING (DECL_NAME (decl1
)); b
; b
= b
->shadowed
)
8622 if (B_IN_SCOPE (b
, external_scope
))
8626 tree ext_decl
, ext_type
;
8628 ext_type
= b
->u
.type
? b
->u
.type
: TREE_TYPE (ext_decl
);
8629 if (TREE_CODE (ext_type
) == FUNCTION_TYPE
8630 && comptypes (TREE_TYPE (TREE_TYPE (decl1
)),
8631 TREE_TYPE (ext_type
)))
8633 current_function_prototype_locus
8634 = DECL_SOURCE_LOCATION (ext_decl
);
8635 current_function_prototype_built_in
8636 = C_DECL_BUILTIN_PROTOTYPE (ext_decl
);
8637 current_function_prototype_arg_types
8638 = TYPE_ARG_TYPES (ext_type
);
8644 /* Optionally warn of old-fashioned def with no previous prototype. */
8645 if (warn_strict_prototypes
8646 && old_decl
!= error_mark_node
8647 && !prototype_p (TREE_TYPE (decl1
))
8648 && C_DECL_ISNT_PROTOTYPE (old_decl
))
8649 warning_at (loc
, OPT_Wstrict_prototypes
,
8650 "function declaration isn%'t a prototype");
8651 /* Optionally warn of any global def with no previous prototype. */
8652 else if (warn_missing_prototypes
8653 && old_decl
!= error_mark_node
8654 && TREE_PUBLIC (decl1
)
8655 && !MAIN_NAME_P (DECL_NAME (decl1
))
8656 && C_DECL_ISNT_PROTOTYPE (old_decl
)
8657 && !DECL_DECLARED_INLINE_P (decl1
))
8658 warning_at (loc
, OPT_Wmissing_prototypes
,
8659 "no previous prototype for %qD", decl1
);
8660 /* Optionally warn of any def with no previous prototype
8661 if the function has already been used. */
8662 else if (warn_missing_prototypes
8663 && old_decl
!= NULL_TREE
8664 && old_decl
!= error_mark_node
8665 && TREE_USED (old_decl
)
8666 && !prototype_p (TREE_TYPE (old_decl
)))
8667 warning_at (loc
, OPT_Wmissing_prototypes
,
8668 "%qD was used with no prototype before its definition", decl1
);
8669 /* Optionally warn of any global def with no previous declaration. */
8670 else if (warn_missing_declarations
8671 && TREE_PUBLIC (decl1
)
8672 && old_decl
== NULL_TREE
8673 && !MAIN_NAME_P (DECL_NAME (decl1
))
8674 && !DECL_DECLARED_INLINE_P (decl1
))
8675 warning_at (loc
, OPT_Wmissing_declarations
,
8676 "no previous declaration for %qD",
8678 /* Optionally warn of any def with no previous declaration
8679 if the function has already been used. */
8680 else if (warn_missing_declarations
8681 && old_decl
!= NULL_TREE
8682 && old_decl
!= error_mark_node
8683 && TREE_USED (old_decl
)
8684 && C_DECL_IMPLICIT (old_decl
))
8685 warning_at (loc
, OPT_Wmissing_declarations
,
8686 "%qD was used with no declaration before its definition", decl1
);
8688 /* This function exists in static storage.
8689 (This does not mean `static' in the C sense!) */
8690 TREE_STATIC (decl1
) = 1;
8692 /* This is the earliest point at which we might know the assembler
8693 name of the function. Thus, if it's set before this, die horribly. */
8694 gcc_assert (!DECL_ASSEMBLER_NAME_SET_P (decl1
));
8696 /* If #pragma weak was used, mark the decl weak now. */
8697 if (current_scope
== file_scope
)
8698 maybe_apply_pragma_weak (decl1
);
8700 /* Warn for unlikely, improbable, or stupid declarations of `main'. */
8701 if (warn_main
&& MAIN_NAME_P (DECL_NAME (decl1
)))
8703 if (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (decl1
)))
8704 != integer_type_node
)
8705 pedwarn (loc
, OPT_Wmain
, "return type of %qD is not %<int%>", decl1
);
8706 else if (TYPE_ATOMIC (TREE_TYPE (TREE_TYPE (decl1
))))
8707 pedwarn (loc
, OPT_Wmain
, "%<_Atomic%>-qualified return type of %qD",
8710 check_main_parameter_types (decl1
);
8712 if (!TREE_PUBLIC (decl1
))
8713 pedwarn (loc
, OPT_Wmain
,
8714 "%qD is normally a non-static function", decl1
);
8717 /* Record the decl so that the function name is defined.
8718 If we already have a decl for this name, and it is a FUNCTION_DECL,
8719 use the old decl. */
8721 current_function_decl
= pushdecl (decl1
);
8724 declare_parm_level ();
8726 restype
= TREE_TYPE (TREE_TYPE (current_function_decl
));
8727 resdecl
= build_decl (loc
, RESULT_DECL
, NULL_TREE
, restype
);
8728 DECL_ARTIFICIAL (resdecl
) = 1;
8729 DECL_IGNORED_P (resdecl
) = 1;
8730 DECL_RESULT (current_function_decl
) = resdecl
;
8732 start_fname_decls ();
8737 /* Subroutine of store_parm_decls which handles new-style function
8738 definitions (prototype format). The parms already have decls, so we
8739 need only record them as in effect and complain if any redundant
8740 old-style parm decls were written. */
8742 store_parm_decls_newstyle (tree fndecl
, const struct c_arg_info
*arg_info
)
8748 if (current_scope
->bindings
)
8750 error_at (DECL_SOURCE_LOCATION (fndecl
),
8751 "old-style parameter declarations in prototyped "
8752 "function definition");
8754 /* Get rid of the old-style declarations. */
8758 /* Don't issue this warning for nested functions, and don't issue this
8759 warning if we got here because ARG_INFO_TYPES was error_mark_node
8760 (this happens when a function definition has just an ellipsis in
8761 its parameter list). */
8762 else if (!in_system_header_at (input_location
)
8763 && !current_function_scope
8764 && arg_info
->types
!= error_mark_node
)
8765 warning_at (DECL_SOURCE_LOCATION (fndecl
), OPT_Wtraditional
,
8766 "traditional C rejects ISO C style function definitions");
8768 /* Now make all the parameter declarations visible in the function body.
8769 We can bypass most of the grunt work of pushdecl. */
8770 for (decl
= arg_info
->parms
; decl
; decl
= DECL_CHAIN (decl
))
8772 DECL_CONTEXT (decl
) = current_function_decl
;
8773 if (DECL_NAME (decl
))
8775 bind (DECL_NAME (decl
), decl
, current_scope
,
8776 /*invisible=*/false, /*nested=*/false,
8778 if (!TREE_USED (decl
))
8779 warn_if_shadowing (decl
);
8782 error_at (DECL_SOURCE_LOCATION (decl
), "parameter name omitted");
8785 /* Record the parameter list in the function declaration. */
8786 DECL_ARGUMENTS (fndecl
) = arg_info
->parms
;
8788 /* Now make all the ancillary declarations visible, likewise. */
8789 for (decl
= arg_info
->others
; decl
; decl
= DECL_CHAIN (decl
))
8791 DECL_CONTEXT (decl
) = current_function_decl
;
8792 if (DECL_NAME (decl
))
8793 bind (DECL_NAME (decl
), decl
, current_scope
,
8794 /*invisible=*/false,
8795 /*nested=*/(TREE_CODE (decl
) == FUNCTION_DECL
),
8799 /* And all the tag declarations. */
8800 FOR_EACH_VEC_SAFE_ELT_REVERSE (arg_info
->tags
, ix
, tag
)
8802 bind (tag
->id
, tag
->type
, current_scope
,
8803 /*invisible=*/false, /*nested=*/false, UNKNOWN_LOCATION
);
8806 /* Subroutine of store_parm_decls which handles old-style function
8807 definitions (separate parameter list and declarations). */
8810 store_parm_decls_oldstyle (tree fndecl
, const struct c_arg_info
*arg_info
)
8812 struct c_binding
*b
;
8813 tree parm
, decl
, last
;
8814 tree parmids
= arg_info
->parms
;
8815 hash_set
<tree
> seen_args
;
8817 if (!in_system_header_at (input_location
))
8818 warning_at (DECL_SOURCE_LOCATION (fndecl
),
8819 OPT_Wold_style_definition
, "old-style function definition");
8821 /* Match each formal parameter name with its declaration. Save each
8822 decl in the appropriate TREE_PURPOSE slot of the parmids chain. */
8823 for (parm
= parmids
; parm
; parm
= TREE_CHAIN (parm
))
8825 if (TREE_VALUE (parm
) == NULL_TREE
)
8827 error_at (DECL_SOURCE_LOCATION (fndecl
),
8828 "parameter name missing from parameter list");
8829 TREE_PURPOSE (parm
) = NULL_TREE
;
8833 b
= I_SYMBOL_BINDING (TREE_VALUE (parm
));
8834 if (b
&& B_IN_CURRENT_SCOPE (b
))
8837 /* Skip erroneous parameters. */
8838 if (decl
== error_mark_node
)
8840 /* If we got something other than a PARM_DECL it is an error. */
8841 if (TREE_CODE (decl
) != PARM_DECL
)
8843 error_at (DECL_SOURCE_LOCATION (decl
),
8844 "%qD declared as a non-parameter", decl
);
8847 /* If the declaration is already marked, we have a duplicate
8848 name. Complain and ignore the duplicate. */
8849 else if (seen_args
.contains (decl
))
8851 error_at (DECL_SOURCE_LOCATION (decl
),
8852 "multiple parameters named %qD", decl
);
8853 TREE_PURPOSE (parm
) = NULL_TREE
;
8856 /* If the declaration says "void", complain and turn it into
8858 else if (VOID_TYPE_P (TREE_TYPE (decl
)))
8860 error_at (DECL_SOURCE_LOCATION (decl
),
8861 "parameter %qD declared with void type", decl
);
8862 TREE_TYPE (decl
) = integer_type_node
;
8863 DECL_ARG_TYPE (decl
) = integer_type_node
;
8864 layout_decl (decl
, 0);
8866 warn_if_shadowing (decl
);
8868 /* If no declaration found, default to int. */
8871 /* FIXME diagnostics: This should be the location of the argument,
8872 not the FNDECL. E.g., for an old-style declaration
8874 int f10(v) { blah; }
8876 We should use the location of the V, not the F10.
8877 Unfortunately, the V is an IDENTIFIER_NODE which has no
8878 location. In the future we need locations for c_arg_info
8881 See gcc.dg/Wshadow-3.c for an example of this problem. */
8882 decl
= build_decl (DECL_SOURCE_LOCATION (fndecl
),
8883 PARM_DECL
, TREE_VALUE (parm
), integer_type_node
);
8884 DECL_ARG_TYPE (decl
) = TREE_TYPE (decl
);
8886 warn_if_shadowing (decl
);
8889 pedwarn (DECL_SOURCE_LOCATION (decl
),
8890 OPT_Wimplicit_int
, "type of %qD defaults to %<int%>",
8893 warning_at (DECL_SOURCE_LOCATION (decl
),
8894 OPT_Wmissing_parameter_type
,
8895 "type of %qD defaults to %<int%>", decl
);
8898 TREE_PURPOSE (parm
) = decl
;
8899 seen_args
.add (decl
);
8902 /* Now examine the parms chain for incomplete declarations
8903 and declarations with no corresponding names. */
8905 for (b
= current_scope
->bindings
; b
; b
= b
->prev
)
8908 if (TREE_CODE (parm
) != PARM_DECL
)
8911 if (TREE_TYPE (parm
) != error_mark_node
8912 && !COMPLETE_TYPE_P (TREE_TYPE (parm
)))
8914 error_at (DECL_SOURCE_LOCATION (parm
),
8915 "parameter %qD has incomplete type", parm
);
8916 TREE_TYPE (parm
) = error_mark_node
;
8919 if (!seen_args
.contains (parm
))
8921 error_at (DECL_SOURCE_LOCATION (parm
),
8922 "declaration for parameter %qD but no such parameter",
8925 /* Pretend the parameter was not missing.
8926 This gets us to a standard state and minimizes
8927 further error messages. */
8928 parmids
= chainon (parmids
, tree_cons (parm
, 0, 0));
8932 /* Chain the declarations together in the order of the list of
8933 names. Store that chain in the function decl, replacing the
8934 list of names. Update the current scope to match. */
8935 DECL_ARGUMENTS (fndecl
) = NULL_TREE
;
8937 for (parm
= parmids
; parm
; parm
= TREE_CHAIN (parm
))
8938 if (TREE_PURPOSE (parm
))
8940 if (parm
&& TREE_PURPOSE (parm
))
8942 last
= TREE_PURPOSE (parm
);
8943 DECL_ARGUMENTS (fndecl
) = last
;
8945 for (parm
= TREE_CHAIN (parm
); parm
; parm
= TREE_CHAIN (parm
))
8946 if (TREE_PURPOSE (parm
))
8948 DECL_CHAIN (last
) = TREE_PURPOSE (parm
);
8949 last
= TREE_PURPOSE (parm
);
8951 DECL_CHAIN (last
) = NULL_TREE
;
8954 /* If there was a previous prototype,
8955 set the DECL_ARG_TYPE of each argument according to
8956 the type previously specified, and report any mismatches. */
8958 if (current_function_prototype_arg_types
)
8961 for (parm
= DECL_ARGUMENTS (fndecl
),
8962 type
= current_function_prototype_arg_types
;
8963 parm
|| (type
!= NULL_TREE
8964 && TREE_VALUE (type
) != error_mark_node
8965 && TYPE_MAIN_VARIANT (TREE_VALUE (type
)) != void_type_node
);
8966 parm
= DECL_CHAIN (parm
), type
= TREE_CHAIN (type
))
8968 if (parm
== NULL_TREE
8969 || type
== NULL_TREE
8970 || (TREE_VALUE (type
) != error_mark_node
8971 && TYPE_MAIN_VARIANT (TREE_VALUE (type
)) == void_type_node
))
8973 if (current_function_prototype_built_in
)
8974 warning_at (DECL_SOURCE_LOCATION (fndecl
),
8975 0, "number of arguments doesn%'t match "
8976 "built-in prototype");
8979 /* FIXME diagnostics: This should be the location of
8980 FNDECL, but there is bug when a prototype is
8981 declared inside function context, but defined
8982 outside of it (e.g., gcc.dg/pr15698-2.c). In
8983 which case FNDECL gets the location of the
8984 prototype, not the definition. */
8985 error_at (input_location
,
8986 "number of arguments doesn%'t match prototype");
8988 error_at (current_function_prototype_locus
,
8989 "prototype declaration");
8993 /* Type for passing arg must be consistent with that
8994 declared for the arg. ISO C says we take the unqualified
8995 type for parameters declared with qualified type. */
8996 if (TREE_TYPE (parm
) != error_mark_node
8997 && TREE_VALUE (type
) != error_mark_node
8998 && ((TYPE_ATOMIC (DECL_ARG_TYPE (parm
))
8999 != TYPE_ATOMIC (TREE_VALUE (type
)))
9000 || !comptypes (TYPE_MAIN_VARIANT (DECL_ARG_TYPE (parm
)),
9001 TYPE_MAIN_VARIANT (TREE_VALUE (type
)))))
9003 if ((TYPE_ATOMIC (DECL_ARG_TYPE (parm
))
9004 == TYPE_ATOMIC (TREE_VALUE (type
)))
9005 && (TYPE_MAIN_VARIANT (TREE_TYPE (parm
))
9006 == TYPE_MAIN_VARIANT (TREE_VALUE (type
))))
9008 /* Adjust argument to match prototype. E.g. a previous
9009 `int foo(float);' prototype causes
9010 `int foo(x) float x; {...}' to be treated like
9011 `int foo(float x) {...}'. This is particularly
9012 useful for argument types like uid_t. */
9013 DECL_ARG_TYPE (parm
) = TREE_TYPE (parm
);
9015 if (targetm
.calls
.promote_prototypes (TREE_TYPE (current_function_decl
))
9016 && INTEGRAL_TYPE_P (TREE_TYPE (parm
))
9017 && (TYPE_PRECISION (TREE_TYPE (parm
))
9018 < TYPE_PRECISION (integer_type_node
)))
9019 DECL_ARG_TYPE (parm
)
9020 = c_type_promotes_to (TREE_TYPE (parm
));
9022 /* ??? Is it possible to get here with a
9023 built-in prototype or will it always have
9024 been diagnosed as conflicting with an
9025 old-style definition and discarded? */
9026 if (current_function_prototype_built_in
)
9027 warning_at (DECL_SOURCE_LOCATION (parm
),
9028 OPT_Wpedantic
, "promoted argument %qD "
9029 "doesn%'t match built-in prototype", parm
);
9032 pedwarn (DECL_SOURCE_LOCATION (parm
),
9033 OPT_Wpedantic
, "promoted argument %qD "
9034 "doesn%'t match prototype", parm
);
9035 pedwarn (current_function_prototype_locus
, OPT_Wpedantic
,
9036 "prototype declaration");
9041 if (current_function_prototype_built_in
)
9042 warning_at (DECL_SOURCE_LOCATION (parm
),
9043 0, "argument %qD doesn%'t match "
9044 "built-in prototype", parm
);
9047 error_at (DECL_SOURCE_LOCATION (parm
),
9048 "argument %qD doesn%'t match prototype", parm
);
9049 error_at (current_function_prototype_locus
,
9050 "prototype declaration");
9055 TYPE_ACTUAL_ARG_TYPES (TREE_TYPE (fndecl
)) = NULL_TREE
;
9058 /* Otherwise, create a prototype that would match. */
9062 tree actual
= NULL_TREE
, last
= NULL_TREE
, type
;
9064 for (parm
= DECL_ARGUMENTS (fndecl
); parm
; parm
= DECL_CHAIN (parm
))
9066 type
= tree_cons (NULL_TREE
, DECL_ARG_TYPE (parm
), NULL_TREE
);
9068 TREE_CHAIN (last
) = type
;
9073 type
= tree_cons (NULL_TREE
, void_type_node
, NULL_TREE
);
9075 TREE_CHAIN (last
) = type
;
9079 /* We are going to assign a new value for the TYPE_ACTUAL_ARG_TYPES
9080 of the type of this function, but we need to avoid having this
9081 affect the types of other similarly-typed functions, so we must
9082 first force the generation of an identical (but separate) type
9083 node for the relevant function type. The new node we create
9084 will be a variant of the main variant of the original function
9087 TREE_TYPE (fndecl
) = build_variant_type_copy (TREE_TYPE (fndecl
));
9089 TYPE_ACTUAL_ARG_TYPES (TREE_TYPE (fndecl
)) = actual
;
9093 /* Store parameter declarations passed in ARG_INFO into the current
9094 function declaration. */
9097 store_parm_decls_from (struct c_arg_info
*arg_info
)
9099 current_function_arg_info
= arg_info
;
9100 store_parm_decls ();
9103 /* Called by walk_tree to look for and update context-less labels. */
9106 set_labels_context_r (tree
*tp
, int *walk_subtrees
, void *data
)
9108 if (TREE_CODE (*tp
) == LABEL_EXPR
9109 && DECL_CONTEXT (LABEL_EXPR_LABEL (*tp
)) == NULL_TREE
)
9111 DECL_CONTEXT (LABEL_EXPR_LABEL (*tp
)) = static_cast<tree
>(data
);
9118 /* Store the parameter declarations into the current function declaration.
9119 This is called after parsing the parameter declarations, before
9120 digesting the body of the function.
9122 For an old-style definition, construct a prototype out of the old-style
9123 parameter declarations and inject it into the function's type. */
9126 store_parm_decls (void)
9128 tree fndecl
= current_function_decl
;
9131 /* The argument information block for FNDECL. */
9132 struct c_arg_info
*arg_info
= current_function_arg_info
;
9133 current_function_arg_info
= 0;
9135 /* True if this definition is written with a prototype. Note:
9136 despite C99 6.7.5.3p14, we can *not* treat an empty argument
9137 list in a function definition as equivalent to (void) -- an
9138 empty argument list specifies the function has no parameters,
9139 but only (void) sets up a prototype for future calls. */
9140 proto
= arg_info
->types
!= 0;
9143 store_parm_decls_newstyle (fndecl
, arg_info
);
9145 store_parm_decls_oldstyle (fndecl
, arg_info
);
9147 /* The next call to push_scope will be a function body. */
9149 next_is_function_body
= true;
9151 /* Write a record describing this function definition to the prototypes
9152 file (if requested). */
9154 gen_aux_info_record (fndecl
, 1, 0, proto
);
9156 /* Initialize the RTL code for the function. */
9157 allocate_struct_function (fndecl
, false);
9159 if (warn_unused_local_typedefs
)
9160 cfun
->language
= ggc_cleared_alloc
<language_function
> ();
9162 /* Begin the statement tree for this function. */
9163 DECL_SAVED_TREE (fndecl
) = push_stmt_list ();
9165 /* ??? Insert the contents of the pending sizes list into the function
9166 to be evaluated. The only reason left to have this is
9167 void foo(int n, int array[n++])
9168 because we throw away the array type in favor of a pointer type, and
9169 thus won't naturally see the SAVE_EXPR containing the increment. All
9170 other pending sizes would be handled by gimplify_parameters. */
9171 if (arg_info
->pending_sizes
)
9173 /* In very special circumstances, e.g. for code like
9175 void f (int a[i += 2]) {}
9176 we need to execute the atomic assignment on function entry.
9177 But in this case, it is not just a straight store, it has the
9178 op= form, which means that build_atomic_assign has generated
9179 gotos, labels, etc. Because at that time the function decl
9180 for F has not been created yet, those labels do not have any
9181 function context. But we have the fndecl now, so update the
9182 labels accordingly. gimplify_expr would crash otherwise. */
9183 walk_tree_without_duplicates (&arg_info
->pending_sizes
,
9184 set_labels_context_r
, fndecl
);
9185 add_stmt (arg_info
->pending_sizes
);
9189 /* Store PARM_DECLs in PARMS into scope temporarily. Used for
9190 c_finish_omp_declare_simd for function prototypes. No diagnostics
9194 temp_store_parm_decls (tree fndecl
, tree parms
)
9197 for (tree p
= parms
; p
; p
= DECL_CHAIN (p
))
9199 DECL_CONTEXT (p
) = fndecl
;
9201 bind (DECL_NAME (p
), p
, current_scope
,
9202 /*invisible=*/false, /*nested=*/false,
9207 /* Undo what temp_store_parm_decls did. */
9210 temp_pop_parm_decls (void)
9212 /* Clear all bindings in this temporary scope, so that
9213 pop_scope doesn't create a BLOCK. */
9214 struct c_binding
*b
= current_scope
->bindings
;
9215 current_scope
->bindings
= NULL
;
9216 for (; b
; b
= free_binding_and_advance (b
))
9218 gcc_assert (TREE_CODE (b
->decl
) == PARM_DECL
9219 || b
->decl
== error_mark_node
);
9220 gcc_assert (I_SYMBOL_BINDING (b
->id
) == b
);
9221 I_SYMBOL_BINDING (b
->id
) = b
->shadowed
;
9222 if (b
->shadowed
&& b
->shadowed
->u
.type
)
9223 TREE_TYPE (b
->shadowed
->decl
) = b
->shadowed
->u
.type
;
9229 /* Finish up a function declaration and compile that function
9230 all the way to assembler language output. Then free the storage
9231 for the function definition.
9233 This is called after parsing the body of the function definition. */
9236 finish_function (void)
9238 tree fndecl
= current_function_decl
;
9240 if (c_dialect_objc ())
9241 objc_finish_function ();
9243 if (TREE_CODE (fndecl
) == FUNCTION_DECL
9244 && targetm
.calls
.promote_prototypes (TREE_TYPE (fndecl
)))
9246 tree args
= DECL_ARGUMENTS (fndecl
);
9247 for (; args
; args
= DECL_CHAIN (args
))
9249 tree type
= TREE_TYPE (args
);
9250 if (INTEGRAL_TYPE_P (type
)
9251 && TYPE_PRECISION (type
) < TYPE_PRECISION (integer_type_node
))
9252 DECL_ARG_TYPE (args
) = c_type_promotes_to (type
);
9256 if (DECL_INITIAL (fndecl
) && DECL_INITIAL (fndecl
) != error_mark_node
)
9257 BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl
)) = fndecl
;
9259 /* Must mark the RESULT_DECL as being in this function. */
9261 if (DECL_RESULT (fndecl
) && DECL_RESULT (fndecl
) != error_mark_node
)
9262 DECL_CONTEXT (DECL_RESULT (fndecl
)) = fndecl
;
9264 if (MAIN_NAME_P (DECL_NAME (fndecl
)) && flag_hosted
9265 && TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (fndecl
)))
9266 == integer_type_node
&& flag_isoc99
)
9268 /* Hack. We don't want the middle-end to warn that this return
9269 is unreachable, so we mark its location as special. Using
9270 UNKNOWN_LOCATION has the problem that it gets clobbered in
9271 annotate_one_with_locus. A cleaner solution might be to
9272 ensure ! should_carry_locus_p (stmt), but that needs a flag.
9274 c_finish_return (BUILTINS_LOCATION
, integer_zero_node
, NULL_TREE
);
9277 /* Tie off the statement tree for this function. */
9278 DECL_SAVED_TREE (fndecl
) = pop_stmt_list (DECL_SAVED_TREE (fndecl
));
9280 /* If the function has _Cilk_spawn in front of a function call inside it
9281 i.e. it is a spawning function, then add the appropriate Cilk plus
9282 functions inside. */
9283 if (fn_contains_cilk_spawn_p (cfun
))
9284 cfun
->cilk_frame_decl
= insert_cilk_frame (fndecl
);
9286 finish_fname_decls ();
9288 /* Complain if there's just no return statement. */
9289 if (warn_return_type
9290 && TREE_CODE (TREE_TYPE (TREE_TYPE (fndecl
))) != VOID_TYPE
9291 && !current_function_returns_value
&& !current_function_returns_null
9292 /* Don't complain if we are no-return. */
9293 && !current_function_returns_abnormally
9294 /* Don't complain if we are declared noreturn. */
9295 && !TREE_THIS_VOLATILE (fndecl
)
9296 /* Don't warn for main(). */
9297 && !MAIN_NAME_P (DECL_NAME (fndecl
))
9298 /* Or if they didn't actually specify a return type. */
9299 && !C_FUNCTION_IMPLICIT_INT (fndecl
)
9300 /* Normally, with -Wreturn-type, flow will complain, but we might
9301 optimize out static functions. */
9302 && !TREE_PUBLIC (fndecl
))
9304 warning (OPT_Wreturn_type
,
9305 "no return statement in function returning non-void");
9306 TREE_NO_WARNING (fndecl
) = 1;
9309 /* Complain about parameters that are only set, but never otherwise used. */
9310 if (warn_unused_but_set_parameter
)
9314 for (decl
= DECL_ARGUMENTS (fndecl
);
9316 decl
= DECL_CHAIN (decl
))
9317 if (TREE_USED (decl
)
9318 && TREE_CODE (decl
) == PARM_DECL
9319 && !DECL_READ_P (decl
)
9321 && !DECL_ARTIFICIAL (decl
)
9322 && !TREE_NO_WARNING (decl
))
9323 warning_at (DECL_SOURCE_LOCATION (decl
),
9324 OPT_Wunused_but_set_parameter
,
9325 "parameter %qD set but not used", decl
);
9328 /* Complain about locally defined typedefs that are not used in this
9330 maybe_warn_unused_local_typedefs ();
9332 /* Possibly warn about unused parameters. */
9333 if (warn_unused_parameter
)
9334 do_warn_unused_parameter (fndecl
);
9336 /* Store the end of the function, so that we get good line number
9337 info for the epilogue. */
9338 cfun
->function_end_locus
= input_location
;
9340 /* Finalize the ELF visibility for the function. */
9341 c_determine_visibility (fndecl
);
9343 /* For GNU C extern inline functions disregard inline limits. */
9344 if (DECL_EXTERNAL (fndecl
)
9345 && DECL_DECLARED_INLINE_P (fndecl
)
9346 && (flag_gnu89_inline
9347 || lookup_attribute ("gnu_inline", DECL_ATTRIBUTES (fndecl
))))
9348 DECL_DISREGARD_INLINE_LIMITS (fndecl
) = 1;
9350 /* Genericize before inlining. Delay genericizing nested functions
9351 until their parent function is genericized. Since finalizing
9352 requires GENERIC, delay that as well. */
9354 if (DECL_INITIAL (fndecl
) && DECL_INITIAL (fndecl
) != error_mark_node
9355 && !undef_nested_function
)
9357 if (!decl_function_context (fndecl
))
9359 invoke_plugin_callbacks (PLUGIN_PRE_GENERICIZE
, fndecl
);
9360 c_genericize (fndecl
);
9362 /* ??? Objc emits functions after finalizing the compilation unit.
9363 This should be cleaned up later and this conditional removed. */
9364 if (symtab
->global_info_ready
)
9366 cgraph_node::add_new_function (fndecl
, false);
9369 cgraph_node::finalize_function (fndecl
, false);
9373 /* Register this function with cgraph just far enough to get it
9374 added to our parent's nested function list. Handy, since the
9375 C front end doesn't have such a list. */
9376 (void) cgraph_node::get_create (fndecl
);
9380 if (!decl_function_context (fndecl
))
9381 undef_nested_function
= false;
9383 if (cfun
->language
!= NULL
)
9385 ggc_free (cfun
->language
);
9386 cfun
->language
= NULL
;
9389 /* We're leaving the context of this function, so zap cfun.
9390 It's still in DECL_STRUCT_FUNCTION, and we'll restore it in
9391 tree_rest_of_compilation. */
9393 invoke_plugin_callbacks (PLUGIN_FINISH_PARSE_FUNCTION
, current_function_decl
);
9394 current_function_decl
= NULL
;
9397 /* Check the declarations given in a for-loop for satisfying the C99
9398 constraints. If exactly one such decl is found, return it. LOC is
9399 the location of the opening parenthesis of the for loop. The last
9400 parameter allows you to control the "for loop initial declarations
9401 are only allowed in C99 mode". Normally, you should pass
9402 flag_isoc99 as that parameter. But in some cases (Objective-C
9403 foreach loop, for example) we want to run the checks in this
9404 function even if not in C99 mode, so we allow the caller to turn
9405 off the error about not being in C99 mode.
9409 check_for_loop_decls (location_t loc
, bool turn_off_iso_c99_error
)
9411 struct c_binding
*b
;
9412 tree one_decl
= NULL_TREE
;
9415 if (!turn_off_iso_c99_error
)
9417 static bool hint
= true;
9418 /* If we get here, declarations have been used in a for loop without
9419 the C99 for loop scope. This doesn't make much sense, so don't
9421 error_at (loc
, "%<for%> loop initial declarations "
9422 "are only allowed in C99 or C11 mode");
9426 "use option -std=c99, -std=gnu99, -std=c11 or -std=gnu11 "
9427 "to compile your code");
9432 /* C99 subclause 6.8.5 paragraph 3:
9434 [#3] The declaration part of a for statement shall only
9435 declare identifiers for objects having storage class auto or
9438 It isn't clear whether, in this sentence, "identifiers" binds to
9439 "shall only declare" or to "objects" - that is, whether all identifiers
9440 declared must be identifiers for objects, or whether the restriction
9441 only applies to those that are. (A question on this in comp.std.c
9442 in November 2000 received no answer.) We implement the strictest
9443 interpretation, to avoid creating an extension which later causes
9446 for (b
= current_scope
->bindings
; b
; b
= b
->prev
)
9449 tree decl
= b
->decl
;
9454 switch (TREE_CODE (decl
))
9458 location_t decl_loc
= DECL_SOURCE_LOCATION (decl
);
9459 if (TREE_STATIC (decl
))
9461 "declaration of static variable %qD in %<for%> loop "
9462 "initial declaration", decl
);
9463 else if (DECL_EXTERNAL (decl
))
9465 "declaration of %<extern%> variable %qD in %<for%> loop "
9466 "initial declaration", decl
);
9472 "%<struct %E%> declared in %<for%> loop initial "
9477 "%<union %E%> declared in %<for%> loop initial declaration",
9481 error_at (loc
, "%<enum %E%> declared in %<for%> loop "
9482 "initial declaration", id
);
9485 error_at (loc
, "declaration of non-variable "
9486 "%qD in %<for%> loop initial declaration", decl
);
9493 return n_decls
== 1 ? one_decl
: NULL_TREE
;
9496 /* Save and reinitialize the variables
9497 used during compilation of a C function. */
9500 c_push_function_context (void)
9502 struct language_function
*p
= cfun
->language
;
9503 /* cfun->language might have been already allocated by the use of
9504 -Wunused-local-typedefs. In that case, just re-use it. */
9506 cfun
->language
= p
= ggc_cleared_alloc
<language_function
> ();
9508 p
->base
.x_stmt_tree
= c_stmt_tree
;
9509 c_stmt_tree
.x_cur_stmt_list
= vec_safe_copy (c_stmt_tree
.x_cur_stmt_list
);
9510 p
->x_break_label
= c_break_label
;
9511 p
->x_cont_label
= c_cont_label
;
9512 p
->x_switch_stack
= c_switch_stack
;
9513 p
->arg_info
= current_function_arg_info
;
9514 p
->returns_value
= current_function_returns_value
;
9515 p
->returns_null
= current_function_returns_null
;
9516 p
->returns_abnormally
= current_function_returns_abnormally
;
9517 p
->warn_about_return_type
= warn_about_return_type
;
9519 push_function_context ();
9522 /* Restore the variables used during compilation of a C function. */
9525 c_pop_function_context (void)
9527 struct language_function
*p
;
9529 pop_function_context ();
9532 /* When -Wunused-local-typedefs is in effect, cfun->languages is
9533 used to store data throughout the life time of the current cfun,
9534 So don't deallocate it. */
9535 if (!warn_unused_local_typedefs
)
9536 cfun
->language
= NULL
;
9538 if (DECL_STRUCT_FUNCTION (current_function_decl
) == 0
9539 && DECL_SAVED_TREE (current_function_decl
) == NULL_TREE
)
9541 /* Stop pointing to the local nodes about to be freed. */
9542 /* But DECL_INITIAL must remain nonzero so we know this
9543 was an actual function definition. */
9544 DECL_INITIAL (current_function_decl
) = error_mark_node
;
9545 DECL_ARGUMENTS (current_function_decl
) = NULL_TREE
;
9548 c_stmt_tree
= p
->base
.x_stmt_tree
;
9549 p
->base
.x_stmt_tree
.x_cur_stmt_list
= NULL
;
9550 c_break_label
= p
->x_break_label
;
9551 c_cont_label
= p
->x_cont_label
;
9552 c_switch_stack
= p
->x_switch_stack
;
9553 current_function_arg_info
= p
->arg_info
;
9554 current_function_returns_value
= p
->returns_value
;
9555 current_function_returns_null
= p
->returns_null
;
9556 current_function_returns_abnormally
= p
->returns_abnormally
;
9557 warn_about_return_type
= p
->warn_about_return_type
;
9560 /* The functions below are required for functionality of doing
9561 function at once processing in the C front end. Currently these
9562 functions are not called from anywhere in the C front end, but as
9563 these changes continue, that will change. */
9565 /* Returns the stmt_tree (if any) to which statements are currently
9566 being added. If there is no active statement-tree, NULL is
9570 current_stmt_tree (void)
9572 return &c_stmt_tree
;
9575 /* Return the global value of T as a symbol. */
9578 identifier_global_value (tree t
)
9580 struct c_binding
*b
;
9582 for (b
= I_SYMBOL_BINDING (t
); b
; b
= b
->shadowed
)
9583 if (B_IN_FILE_SCOPE (b
) || B_IN_EXTERNAL_SCOPE (b
))
9589 /* In C, the only C-linkage public declaration is at file scope. */
9592 c_linkage_bindings (tree name
)
9594 return identifier_global_value (name
);
9597 /* Record a builtin type for C. If NAME is non-NULL, it is the name used;
9598 otherwise the name is found in ridpointers from RID_INDEX. */
9601 record_builtin_type (enum rid rid_index
, const char *name
, tree type
)
9605 id
= ridpointers
[(int) rid_index
];
9607 id
= get_identifier (name
);
9608 decl
= build_decl (UNKNOWN_LOCATION
, TYPE_DECL
, id
, type
);
9610 if (debug_hooks
->type_decl
)
9611 debug_hooks
->type_decl (decl
, false);
9614 /* Build the void_list_node (void_type_node having been created). */
9616 build_void_list_node (void)
9618 tree t
= build_tree_list (NULL_TREE
, void_type_node
);
9622 /* Return a c_parm structure with the given SPECS, ATTRS and DECLARATOR. */
9625 build_c_parm (struct c_declspecs
*specs
, tree attrs
,
9626 struct c_declarator
*declarator
)
9628 struct c_parm
*ret
= XOBNEW (&parser_obstack
, struct c_parm
);
9631 ret
->declarator
= declarator
;
9635 /* Return a declarator with nested attributes. TARGET is the inner
9636 declarator to which these attributes apply. ATTRS are the
9639 struct c_declarator
*
9640 build_attrs_declarator (tree attrs
, struct c_declarator
*target
)
9642 struct c_declarator
*ret
= XOBNEW (&parser_obstack
, struct c_declarator
);
9643 ret
->kind
= cdk_attrs
;
9644 ret
->declarator
= target
;
9645 ret
->u
.attrs
= attrs
;
9649 /* Return a declarator for a function with arguments specified by ARGS
9650 and return type specified by TARGET. */
9652 struct c_declarator
*
9653 build_function_declarator (struct c_arg_info
*args
,
9654 struct c_declarator
*target
)
9656 struct c_declarator
*ret
= XOBNEW (&parser_obstack
, struct c_declarator
);
9657 ret
->kind
= cdk_function
;
9658 ret
->declarator
= target
;
9659 ret
->u
.arg_info
= args
;
9663 /* Return a declarator for the identifier IDENT (which may be
9664 NULL_TREE for an abstract declarator). */
9666 struct c_declarator
*
9667 build_id_declarator (tree ident
)
9669 struct c_declarator
*ret
= XOBNEW (&parser_obstack
, struct c_declarator
);
9671 ret
->declarator
= 0;
9673 /* Default value - may get reset to a more precise location. */
9674 ret
->id_loc
= input_location
;
9678 /* Return something to represent absolute declarators containing a *.
9679 TARGET is the absolute declarator that the * contains.
9680 TYPE_QUALS_ATTRS is a structure for type qualifiers and attributes
9681 to apply to the pointer type. */
9683 struct c_declarator
*
9684 make_pointer_declarator (struct c_declspecs
*type_quals_attrs
,
9685 struct c_declarator
*target
)
9689 struct c_declarator
*itarget
= target
;
9690 struct c_declarator
*ret
= XOBNEW (&parser_obstack
, struct c_declarator
);
9691 if (type_quals_attrs
)
9693 attrs
= type_quals_attrs
->attrs
;
9694 quals
= quals_from_declspecs (type_quals_attrs
);
9695 if (attrs
!= NULL_TREE
)
9696 itarget
= build_attrs_declarator (attrs
, target
);
9698 ret
->kind
= cdk_pointer
;
9699 ret
->declarator
= itarget
;
9700 ret
->u
.pointer_quals
= quals
;
9704 /* Return a pointer to a structure for an empty list of declaration
9707 struct c_declspecs
*
9708 build_null_declspecs (void)
9710 struct c_declspecs
*ret
= XOBNEW (&parser_obstack
, struct c_declspecs
);
9711 memset (ret
, 0, sizeof *ret
);
9712 ret
->align_log
= -1;
9713 ret
->typespec_word
= cts_none
;
9714 ret
->storage_class
= csc_none
;
9715 ret
->expr_const_operands
= true;
9716 ret
->typespec_kind
= ctsk_none
;
9717 ret
->address_space
= ADDR_SPACE_GENERIC
;
9721 /* Add the address space ADDRSPACE to the declaration specifiers
9722 SPECS, returning SPECS. */
9724 struct c_declspecs
*
9725 declspecs_add_addrspace (source_location location
,
9726 struct c_declspecs
*specs
, addr_space_t as
)
9728 specs
->non_sc_seen_p
= true;
9729 specs
->declspecs_seen_p
= true;
9731 if (!ADDR_SPACE_GENERIC_P (specs
->address_space
)
9732 && specs
->address_space
!= as
)
9733 error ("incompatible address space qualifiers %qs and %qs",
9734 c_addr_space_name (as
),
9735 c_addr_space_name (specs
->address_space
));
9738 specs
->address_space
= as
;
9739 specs
->locations
[cdw_address_space
] = location
;
9744 /* Add the type qualifier QUAL to the declaration specifiers SPECS,
9747 struct c_declspecs
*
9748 declspecs_add_qual (source_location loc
,
9749 struct c_declspecs
*specs
, tree qual
)
9753 specs
->non_sc_seen_p
= true;
9754 specs
->declspecs_seen_p
= true;
9755 gcc_assert (TREE_CODE (qual
) == IDENTIFIER_NODE
9756 && C_IS_RESERVED_WORD (qual
));
9757 i
= C_RID_CODE (qual
);
9758 location_t prev_loc
= UNKNOWN_LOCATION
;
9762 dupe
= specs
->const_p
;
9763 specs
->const_p
= true;
9764 prev_loc
= specs
->locations
[cdw_const
];
9765 specs
->locations
[cdw_const
] = loc
;
9768 dupe
= specs
->volatile_p
;
9769 specs
->volatile_p
= true;
9770 prev_loc
= specs
->locations
[cdw_volatile
];
9771 specs
->locations
[cdw_volatile
] = loc
;
9774 dupe
= specs
->restrict_p
;
9775 specs
->restrict_p
= true;
9776 prev_loc
= specs
->locations
[cdw_restrict
];
9777 specs
->locations
[cdw_restrict
] = loc
;
9780 dupe
= specs
->atomic_p
;
9781 specs
->atomic_p
= true;
9782 prev_loc
= specs
->locations
[cdw_atomic
];
9783 specs
->locations
[cdw_atomic
] = loc
;
9790 bool warned
= pedwarn_c90 (loc
, OPT_Wpedantic
,
9791 "duplicate %qE declaration specifier", qual
);
9793 && warn_duplicate_decl_specifier
9794 && prev_loc
>= RESERVED_LOCATION_COUNT
9795 && !from_macro_expansion_at (prev_loc
)
9796 && !from_macro_expansion_at (loc
))
9797 warning_at (loc
, OPT_Wduplicate_decl_specifier
,
9798 "duplicate %qE declaration specifier", qual
);
9803 /* Add the type specifier TYPE to the declaration specifiers SPECS,
9806 struct c_declspecs
*
9807 declspecs_add_type (location_t loc
, struct c_declspecs
*specs
,
9808 struct c_typespec spec
)
9810 tree type
= spec
.spec
;
9811 specs
->non_sc_seen_p
= true;
9812 specs
->declspecs_seen_p
= true;
9813 specs
->typespec_kind
= spec
.kind
;
9814 if (TREE_DEPRECATED (type
))
9815 specs
->deprecated_p
= true;
9817 /* Handle type specifier keywords. */
9818 if (TREE_CODE (type
) == IDENTIFIER_NODE
9819 && C_IS_RESERVED_WORD (type
)
9820 && C_RID_CODE (type
) != RID_CXX_COMPAT_WARN
)
9822 enum rid i
= C_RID_CODE (type
);
9825 error_at (loc
, "two or more data types in declaration specifiers");
9828 if ((int) i
<= (int) RID_LAST_MODIFIER
)
9830 /* "long", "short", "signed", "unsigned", "_Complex" or "_Sat". */
9835 if (specs
->long_long_p
)
9837 error_at (loc
, "%<long long long%> is too long for GCC");
9842 if (specs
->typespec_word
== cts_double
)
9845 ("both %<long long%> and %<double%> in "
9846 "declaration specifiers"));
9849 pedwarn_c90 (loc
, OPT_Wlong_long
,
9850 "ISO C90 does not support %<long long%>");
9851 specs
->long_long_p
= 1;
9852 specs
->locations
[cdw_long_long
] = loc
;
9857 ("both %<long%> and %<short%> in "
9858 "declaration specifiers"));
9859 else if (specs
->typespec_word
== cts_auto_type
)
9861 ("both %<long%> and %<__auto_type%> in "
9862 "declaration specifiers"));
9863 else if (specs
->typespec_word
== cts_void
)
9865 ("both %<long%> and %<void%> in "
9866 "declaration specifiers"));
9867 else if (specs
->typespec_word
== cts_int_n
)
9869 ("both %<long%> and %<__int%d%> in "
9870 "declaration specifiers"),
9871 int_n_data
[specs
->int_n_idx
].bitsize
);
9872 else if (specs
->typespec_word
== cts_bool
)
9874 ("both %<long%> and %<_Bool%> in "
9875 "declaration specifiers"));
9876 else if (specs
->typespec_word
== cts_char
)
9878 ("both %<long%> and %<char%> in "
9879 "declaration specifiers"));
9880 else if (specs
->typespec_word
== cts_float
)
9882 ("both %<long%> and %<float%> in "
9883 "declaration specifiers"));
9884 else if (specs
->typespec_word
== cts_floatn_nx
)
9886 ("both %<long%> and %<_Float%d%s%> in "
9887 "declaration specifiers"),
9888 floatn_nx_types
[specs
->floatn_nx_idx
].n
,
9889 (floatn_nx_types
[specs
->floatn_nx_idx
].extended
9892 else if (specs
->typespec_word
== cts_dfloat32
)
9894 ("both %<long%> and %<_Decimal32%> in "
9895 "declaration specifiers"));
9896 else if (specs
->typespec_word
== cts_dfloat64
)
9898 ("both %<long%> and %<_Decimal64%> in "
9899 "declaration specifiers"));
9900 else if (specs
->typespec_word
== cts_dfloat128
)
9902 ("both %<long%> and %<_Decimal128%> in "
9903 "declaration specifiers"));
9906 specs
->long_p
= true;
9907 specs
->locations
[cdw_long
] = loc
;
9911 dupe
= specs
->short_p
;
9914 ("both %<long%> and %<short%> in "
9915 "declaration specifiers"));
9916 else if (specs
->typespec_word
== cts_auto_type
)
9918 ("both %<short%> and %<__auto_type%> in "
9919 "declaration specifiers"));
9920 else if (specs
->typespec_word
== cts_void
)
9922 ("both %<short%> and %<void%> in "
9923 "declaration specifiers"));
9924 else if (specs
->typespec_word
== cts_int_n
)
9926 ("both %<short%> and %<__int%d%> in "
9927 "declaration specifiers"),
9928 int_n_data
[specs
->int_n_idx
].bitsize
);
9929 else if (specs
->typespec_word
== cts_bool
)
9931 ("both %<short%> and %<_Bool%> in "
9932 "declaration specifiers"));
9933 else if (specs
->typespec_word
== cts_char
)
9935 ("both %<short%> and %<char%> in "
9936 "declaration specifiers"));
9937 else if (specs
->typespec_word
== cts_float
)
9939 ("both %<short%> and %<float%> in "
9940 "declaration specifiers"));
9941 else if (specs
->typespec_word
== cts_double
)
9943 ("both %<short%> and %<double%> in "
9944 "declaration specifiers"));
9945 else if (specs
->typespec_word
== cts_floatn_nx
)
9947 ("both %<short%> and %<_Float%d%s%> in "
9948 "declaration specifiers"),
9949 floatn_nx_types
[specs
->floatn_nx_idx
].n
,
9950 (floatn_nx_types
[specs
->floatn_nx_idx
].extended
9953 else if (specs
->typespec_word
== cts_dfloat32
)
9955 ("both %<short%> and %<_Decimal32%> in "
9956 "declaration specifiers"));
9957 else if (specs
->typespec_word
== cts_dfloat64
)
9959 ("both %<short%> and %<_Decimal64%> in "
9960 "declaration specifiers"));
9961 else if (specs
->typespec_word
== cts_dfloat128
)
9963 ("both %<short%> and %<_Decimal128%> in "
9964 "declaration specifiers"));
9967 specs
->short_p
= true;
9968 specs
->locations
[cdw_short
] = loc
;
9972 dupe
= specs
->signed_p
;
9973 if (specs
->unsigned_p
)
9975 ("both %<signed%> and %<unsigned%> in "
9976 "declaration specifiers"));
9977 else if (specs
->typespec_word
== cts_auto_type
)
9979 ("both %<signed%> and %<__auto_type%> in "
9980 "declaration specifiers"));
9981 else if (specs
->typespec_word
== cts_void
)
9983 ("both %<signed%> and %<void%> in "
9984 "declaration specifiers"));
9985 else if (specs
->typespec_word
== cts_bool
)
9987 ("both %<signed%> and %<_Bool%> in "
9988 "declaration specifiers"));
9989 else if (specs
->typespec_word
== cts_float
)
9991 ("both %<signed%> and %<float%> in "
9992 "declaration specifiers"));
9993 else if (specs
->typespec_word
== cts_double
)
9995 ("both %<signed%> and %<double%> in "
9996 "declaration specifiers"));
9997 else if (specs
->typespec_word
== cts_floatn_nx
)
9999 ("both %<signed%> and %<_Float%d%s%> in "
10000 "declaration specifiers"),
10001 floatn_nx_types
[specs
->floatn_nx_idx
].n
,
10002 (floatn_nx_types
[specs
->floatn_nx_idx
].extended
10005 else if (specs
->typespec_word
== cts_dfloat32
)
10007 ("both %<signed%> and %<_Decimal32%> in "
10008 "declaration specifiers"));
10009 else if (specs
->typespec_word
== cts_dfloat64
)
10011 ("both %<signed%> and %<_Decimal64%> in "
10012 "declaration specifiers"));
10013 else if (specs
->typespec_word
== cts_dfloat128
)
10015 ("both %<signed%> and %<_Decimal128%> in "
10016 "declaration specifiers"));
10019 specs
->signed_p
= true;
10020 specs
->locations
[cdw_signed
] = loc
;
10024 dupe
= specs
->unsigned_p
;
10025 if (specs
->signed_p
)
10027 ("both %<signed%> and %<unsigned%> in "
10028 "declaration specifiers"));
10029 else if (specs
->typespec_word
== cts_auto_type
)
10031 ("both %<unsigned%> and %<__auto_type%> in "
10032 "declaration specifiers"));
10033 else if (specs
->typespec_word
== cts_void
)
10035 ("both %<unsigned%> and %<void%> in "
10036 "declaration specifiers"));
10037 else if (specs
->typespec_word
== cts_bool
)
10039 ("both %<unsigned%> and %<_Bool%> in "
10040 "declaration specifiers"));
10041 else if (specs
->typespec_word
== cts_float
)
10043 ("both %<unsigned%> and %<float%> in "
10044 "declaration specifiers"));
10045 else if (specs
->typespec_word
== cts_double
)
10047 ("both %<unsigned%> and %<double%> in "
10048 "declaration specifiers"));
10049 else if (specs
->typespec_word
== cts_floatn_nx
)
10051 ("both %<unsigned%> and %<_Float%d%s%> in "
10052 "declaration specifiers"),
10053 floatn_nx_types
[specs
->floatn_nx_idx
].n
,
10054 (floatn_nx_types
[specs
->floatn_nx_idx
].extended
10057 else if (specs
->typespec_word
== cts_dfloat32
)
10059 ("both %<unsigned%> and %<_Decimal32%> in "
10060 "declaration specifiers"));
10061 else if (specs
->typespec_word
== cts_dfloat64
)
10063 ("both %<unsigned%> and %<_Decimal64%> in "
10064 "declaration specifiers"));
10065 else if (specs
->typespec_word
== cts_dfloat128
)
10067 ("both %<unsigned%> and %<_Decimal128%> in "
10068 "declaration specifiers"));
10071 specs
->unsigned_p
= true;
10072 specs
->locations
[cdw_unsigned
] = loc
;
10076 dupe
= specs
->complex_p
;
10077 if (!in_system_header_at (loc
))
10078 pedwarn_c90 (loc
, OPT_Wpedantic
,
10079 "ISO C90 does not support complex types");
10080 if (specs
->typespec_word
== cts_auto_type
)
10082 ("both %<complex%> and %<__auto_type%> in "
10083 "declaration specifiers"));
10084 else if (specs
->typespec_word
== cts_void
)
10086 ("both %<complex%> and %<void%> in "
10087 "declaration specifiers"));
10088 else if (specs
->typespec_word
== cts_bool
)
10090 ("both %<complex%> and %<_Bool%> in "
10091 "declaration specifiers"));
10092 else if (specs
->typespec_word
== cts_dfloat32
)
10094 ("both %<complex%> and %<_Decimal32%> in "
10095 "declaration specifiers"));
10096 else if (specs
->typespec_word
== cts_dfloat64
)
10098 ("both %<complex%> and %<_Decimal64%> in "
10099 "declaration specifiers"));
10100 else if (specs
->typespec_word
== cts_dfloat128
)
10102 ("both %<complex%> and %<_Decimal128%> in "
10103 "declaration specifiers"));
10104 else if (specs
->typespec_word
== cts_fract
)
10106 ("both %<complex%> and %<_Fract%> in "
10107 "declaration specifiers"));
10108 else if (specs
->typespec_word
== cts_accum
)
10110 ("both %<complex%> and %<_Accum%> in "
10111 "declaration specifiers"));
10112 else if (specs
->saturating_p
)
10114 ("both %<complex%> and %<_Sat%> in "
10115 "declaration specifiers"));
10118 specs
->complex_p
= true;
10119 specs
->locations
[cdw_complex
] = loc
;
10123 dupe
= specs
->saturating_p
;
10124 pedwarn (loc
, OPT_Wpedantic
,
10125 "ISO C does not support saturating types");
10126 if (specs
->typespec_word
== cts_int_n
)
10129 ("both %<_Sat%> and %<__int%d%> in "
10130 "declaration specifiers"),
10131 int_n_data
[specs
->int_n_idx
].bitsize
);
10133 else if (specs
->typespec_word
== cts_auto_type
)
10135 ("both %<_Sat%> and %<__auto_type%> in "
10136 "declaration specifiers"));
10137 else if (specs
->typespec_word
== cts_void
)
10139 ("both %<_Sat%> and %<void%> in "
10140 "declaration specifiers"));
10141 else if (specs
->typespec_word
== cts_bool
)
10143 ("both %<_Sat%> and %<_Bool%> in "
10144 "declaration specifiers"));
10145 else if (specs
->typespec_word
== cts_char
)
10147 ("both %<_Sat%> and %<char%> in "
10148 "declaration specifiers"));
10149 else if (specs
->typespec_word
== cts_int
)
10151 ("both %<_Sat%> and %<int%> in "
10152 "declaration specifiers"));
10153 else if (specs
->typespec_word
== cts_float
)
10155 ("both %<_Sat%> and %<float%> in "
10156 "declaration specifiers"));
10157 else if (specs
->typespec_word
== cts_double
)
10159 ("both %<_Sat%> and %<double%> in "
10160 "declaration specifiers"));
10161 else if (specs
->typespec_word
== cts_floatn_nx
)
10163 ("both %<_Sat%> and %<_Float%d%s%> in "
10164 "declaration specifiers"),
10165 floatn_nx_types
[specs
->floatn_nx_idx
].n
,
10166 (floatn_nx_types
[specs
->floatn_nx_idx
].extended
10169 else if (specs
->typespec_word
== cts_dfloat32
)
10171 ("both %<_Sat%> and %<_Decimal32%> in "
10172 "declaration specifiers"));
10173 else if (specs
->typespec_word
== cts_dfloat64
)
10175 ("both %<_Sat%> and %<_Decimal64%> in "
10176 "declaration specifiers"));
10177 else if (specs
->typespec_word
== cts_dfloat128
)
10179 ("both %<_Sat%> and %<_Decimal128%> in "
10180 "declaration specifiers"));
10181 else if (specs
->complex_p
)
10183 ("both %<_Sat%> and %<complex%> in "
10184 "declaration specifiers"));
10187 specs
->saturating_p
= true;
10188 specs
->locations
[cdw_saturating
] = loc
;
10192 gcc_unreachable ();
10196 error_at (loc
, "duplicate %qE", type
);
10202 /* "void", "_Bool", "char", "int", "float", "double",
10203 "_FloatN", "_FloatNx", "_Decimal32", "__intN",
10204 "_Decimal64", "_Decimal128", "_Fract", "_Accum" or
10206 if (specs
->typespec_word
!= cts_none
)
10209 "two or more data types in declaration specifiers");
10214 case RID_AUTO_TYPE
:
10217 ("both %<long%> and %<__auto_type%> in "
10218 "declaration specifiers"));
10219 else if (specs
->short_p
)
10221 ("both %<short%> and %<__auto_type%> in "
10222 "declaration specifiers"));
10223 else if (specs
->signed_p
)
10225 ("both %<signed%> and %<__auto_type%> in "
10226 "declaration specifiers"));
10227 else if (specs
->unsigned_p
)
10229 ("both %<unsigned%> and %<__auto_type%> in "
10230 "declaration specifiers"));
10231 else if (specs
->complex_p
)
10233 ("both %<complex%> and %<__auto_type%> in "
10234 "declaration specifiers"));
10235 else if (specs
->saturating_p
)
10237 ("both %<_Sat%> and %<__auto_type%> in "
10238 "declaration specifiers"));
10241 specs
->typespec_word
= cts_auto_type
;
10242 specs
->locations
[cdw_typespec
] = loc
;
10249 specs
->int_n_idx
= i
- RID_INT_N_0
;
10250 if (!in_system_header_at (input_location
))
10251 pedwarn (loc
, OPT_Wpedantic
,
10252 "ISO C does not support %<__int%d%> types",
10253 int_n_data
[specs
->int_n_idx
].bitsize
);
10257 ("both %<__int%d%> and %<long%> in "
10258 "declaration specifiers"),
10259 int_n_data
[specs
->int_n_idx
].bitsize
);
10260 else if (specs
->saturating_p
)
10262 ("both %<_Sat%> and %<__int%d%> in "
10263 "declaration specifiers"),
10264 int_n_data
[specs
->int_n_idx
].bitsize
);
10265 else if (specs
->short_p
)
10267 ("both %<__int%d%> and %<short%> in "
10268 "declaration specifiers"),
10269 int_n_data
[specs
->int_n_idx
].bitsize
);
10270 else if (! int_n_enabled_p
[specs
->int_n_idx
])
10272 specs
->typespec_word
= cts_int_n
;
10274 "%<__int%d%> is not supported on this target",
10275 int_n_data
[specs
->int_n_idx
].bitsize
);
10279 specs
->typespec_word
= cts_int_n
;
10280 specs
->locations
[cdw_typespec
] = loc
;
10286 ("both %<long%> and %<void%> in "
10287 "declaration specifiers"));
10288 else if (specs
->short_p
)
10290 ("both %<short%> and %<void%> in "
10291 "declaration specifiers"));
10292 else if (specs
->signed_p
)
10294 ("both %<signed%> and %<void%> in "
10295 "declaration specifiers"));
10296 else if (specs
->unsigned_p
)
10298 ("both %<unsigned%> and %<void%> in "
10299 "declaration specifiers"));
10300 else if (specs
->complex_p
)
10302 ("both %<complex%> and %<void%> in "
10303 "declaration specifiers"));
10304 else if (specs
->saturating_p
)
10306 ("both %<_Sat%> and %<void%> in "
10307 "declaration specifiers"));
10310 specs
->typespec_word
= cts_void
;
10311 specs
->locations
[cdw_typespec
] = loc
;
10315 if (!in_system_header_at (loc
))
10316 pedwarn_c90 (loc
, OPT_Wpedantic
,
10317 "ISO C90 does not support boolean types");
10320 ("both %<long%> and %<_Bool%> in "
10321 "declaration specifiers"));
10322 else if (specs
->short_p
)
10324 ("both %<short%> and %<_Bool%> in "
10325 "declaration specifiers"));
10326 else if (specs
->signed_p
)
10328 ("both %<signed%> and %<_Bool%> in "
10329 "declaration specifiers"));
10330 else if (specs
->unsigned_p
)
10332 ("both %<unsigned%> and %<_Bool%> in "
10333 "declaration specifiers"));
10334 else if (specs
->complex_p
)
10336 ("both %<complex%> and %<_Bool%> in "
10337 "declaration specifiers"));
10338 else if (specs
->saturating_p
)
10340 ("both %<_Sat%> and %<_Bool%> in "
10341 "declaration specifiers"));
10344 specs
->typespec_word
= cts_bool
;
10345 specs
->locations
[cdw_typespec
] = loc
;
10351 ("both %<long%> and %<char%> in "
10352 "declaration specifiers"));
10353 else if (specs
->short_p
)
10355 ("both %<short%> and %<char%> in "
10356 "declaration specifiers"));
10357 else if (specs
->saturating_p
)
10359 ("both %<_Sat%> and %<char%> in "
10360 "declaration specifiers"));
10363 specs
->typespec_word
= cts_char
;
10364 specs
->locations
[cdw_typespec
] = loc
;
10368 if (specs
->saturating_p
)
10370 ("both %<_Sat%> and %<int%> in "
10371 "declaration specifiers"));
10374 specs
->typespec_word
= cts_int
;
10375 specs
->locations
[cdw_typespec
] = loc
;
10381 ("both %<long%> and %<float%> in "
10382 "declaration specifiers"));
10383 else if (specs
->short_p
)
10385 ("both %<short%> and %<float%> in "
10386 "declaration specifiers"));
10387 else if (specs
->signed_p
)
10389 ("both %<signed%> and %<float%> in "
10390 "declaration specifiers"));
10391 else if (specs
->unsigned_p
)
10393 ("both %<unsigned%> and %<float%> in "
10394 "declaration specifiers"));
10395 else if (specs
->saturating_p
)
10397 ("both %<_Sat%> and %<float%> in "
10398 "declaration specifiers"));
10401 specs
->typespec_word
= cts_float
;
10402 specs
->locations
[cdw_typespec
] = loc
;
10406 if (specs
->long_long_p
)
10408 ("both %<long long%> and %<double%> in "
10409 "declaration specifiers"));
10410 else if (specs
->short_p
)
10412 ("both %<short%> and %<double%> in "
10413 "declaration specifiers"));
10414 else if (specs
->signed_p
)
10416 ("both %<signed%> and %<double%> in "
10417 "declaration specifiers"));
10418 else if (specs
->unsigned_p
)
10420 ("both %<unsigned%> and %<double%> in "
10421 "declaration specifiers"));
10422 else if (specs
->saturating_p
)
10424 ("both %<_Sat%> and %<double%> in "
10425 "declaration specifiers"));
10428 specs
->typespec_word
= cts_double
;
10429 specs
->locations
[cdw_typespec
] = loc
;
10432 CASE_RID_FLOATN_NX
:
10433 specs
->floatn_nx_idx
= i
- RID_FLOATN_NX_FIRST
;
10434 if (!in_system_header_at (input_location
))
10435 pedwarn (loc
, OPT_Wpedantic
,
10436 "ISO C does not support the %<_Float%d%s%> type",
10437 floatn_nx_types
[specs
->floatn_nx_idx
].n
,
10438 (floatn_nx_types
[specs
->floatn_nx_idx
].extended
10444 ("both %<long%> and %<_Float%d%s%> in "
10445 "declaration specifiers"),
10446 floatn_nx_types
[specs
->floatn_nx_idx
].n
,
10447 (floatn_nx_types
[specs
->floatn_nx_idx
].extended
10450 else if (specs
->short_p
)
10452 ("both %<short%> and %<_Float%d%s%> in "
10453 "declaration specifiers"),
10454 floatn_nx_types
[specs
->floatn_nx_idx
].n
,
10455 (floatn_nx_types
[specs
->floatn_nx_idx
].extended
10458 else if (specs
->signed_p
)
10460 ("both %<signed%> and %<_Float%d%s%> in "
10461 "declaration specifiers"),
10462 floatn_nx_types
[specs
->floatn_nx_idx
].n
,
10463 (floatn_nx_types
[specs
->floatn_nx_idx
].extended
10466 else if (specs
->unsigned_p
)
10468 ("both %<unsigned%> and %<_Float%d%s%> in "
10469 "declaration specifiers"),
10470 floatn_nx_types
[specs
->floatn_nx_idx
].n
,
10471 (floatn_nx_types
[specs
->floatn_nx_idx
].extended
10474 else if (specs
->saturating_p
)
10476 ("both %<_Sat%> and %<_Float%d%s%> in "
10477 "declaration specifiers"),
10478 floatn_nx_types
[specs
->floatn_nx_idx
].n
,
10479 (floatn_nx_types
[specs
->floatn_nx_idx
].extended
10482 else if (FLOATN_NX_TYPE_NODE (specs
->floatn_nx_idx
) == NULL_TREE
)
10484 specs
->typespec_word
= cts_floatn_nx
;
10486 "%<_Float%d%s%> is not supported on this target",
10487 floatn_nx_types
[specs
->floatn_nx_idx
].n
,
10488 (floatn_nx_types
[specs
->floatn_nx_idx
].extended
10494 specs
->typespec_word
= cts_floatn_nx
;
10495 specs
->locations
[cdw_typespec
] = loc
;
10500 case RID_DFLOAT128
:
10503 if (i
== RID_DFLOAT32
)
10504 str
= "_Decimal32";
10505 else if (i
== RID_DFLOAT64
)
10506 str
= "_Decimal64";
10508 str
= "_Decimal128";
10509 if (specs
->long_long_p
)
10511 ("both %<long long%> and %qs in "
10512 "declaration specifiers"),
10516 ("both %<long%> and %qs in "
10517 "declaration specifiers"),
10519 else if (specs
->short_p
)
10521 ("both %<short%> and %qs in "
10522 "declaration specifiers"),
10524 else if (specs
->signed_p
)
10526 ("both %<signed%> and %qs in "
10527 "declaration specifiers"),
10529 else if (specs
->unsigned_p
)
10531 ("both %<unsigned%> and %qs in "
10532 "declaration specifiers"),
10534 else if (specs
->complex_p
)
10536 ("both %<complex%> and %qs in "
10537 "declaration specifiers"),
10539 else if (specs
->saturating_p
)
10541 ("both %<_Sat%> and %qs in "
10542 "declaration specifiers"),
10544 else if (i
== RID_DFLOAT32
)
10545 specs
->typespec_word
= cts_dfloat32
;
10546 else if (i
== RID_DFLOAT64
)
10547 specs
->typespec_word
= cts_dfloat64
;
10549 specs
->typespec_word
= cts_dfloat128
;
10550 specs
->locations
[cdw_typespec
] = loc
;
10552 if (!targetm
.decimal_float_supported_p ())
10554 ("decimal floating point not supported "
10555 "for this target"));
10556 pedwarn (loc
, OPT_Wpedantic
,
10557 "ISO C does not support decimal floating point");
10563 if (i
== RID_FRACT
)
10567 if (specs
->complex_p
)
10569 ("both %<complex%> and %qs in "
10570 "declaration specifiers"),
10572 else if (i
== RID_FRACT
)
10573 specs
->typespec_word
= cts_fract
;
10575 specs
->typespec_word
= cts_accum
;
10576 specs
->locations
[cdw_typespec
] = loc
;
10578 if (!targetm
.fixed_point_supported_p ())
10580 "fixed-point types not supported for this target");
10581 pedwarn (loc
, OPT_Wpedantic
,
10582 "ISO C does not support fixed-point types");
10585 /* ObjC reserved word "id", handled below. */
10591 /* Now we have a typedef (a TYPE_DECL node), an identifier (some
10592 form of ObjC type, cases such as "int" and "long" being handled
10593 above), a TYPE (struct, union, enum and typeof specifiers) or an
10594 ERROR_MARK. In none of these cases may there have previously
10595 been any type specifiers. */
10596 if (specs
->type
|| specs
->typespec_word
!= cts_none
10597 || specs
->long_p
|| specs
->short_p
|| specs
->signed_p
10598 || specs
->unsigned_p
|| specs
->complex_p
)
10599 error_at (loc
, "two or more data types in declaration specifiers");
10600 else if (TREE_CODE (type
) == TYPE_DECL
)
10602 if (TREE_TYPE (type
) == error_mark_node
)
10603 ; /* Allow the type to default to int to avoid cascading errors. */
10606 specs
->type
= TREE_TYPE (type
);
10607 specs
->decl_attr
= DECL_ATTRIBUTES (type
);
10608 specs
->typedef_p
= true;
10609 specs
->explicit_signed_p
= C_TYPEDEF_EXPLICITLY_SIGNED (type
);
10610 specs
->locations
[cdw_typedef
] = loc
;
10612 /* If this typedef name is defined in a struct, then a C++
10613 lookup would return a different value. */
10614 if (warn_cxx_compat
10615 && I_SYMBOL_BINDING (DECL_NAME (type
))->in_struct
)
10616 warning_at (loc
, OPT_Wc___compat
,
10617 "C++ lookup of %qD would return a field, not a type",
10620 /* If we are parsing a struct, record that a struct field
10622 if (warn_cxx_compat
&& struct_parse_info
!= NULL
)
10623 struct_parse_info
->typedefs_seen
.safe_push (type
);
10626 else if (TREE_CODE (type
) == IDENTIFIER_NODE
)
10628 tree t
= lookup_name (type
);
10629 if (!t
|| TREE_CODE (t
) != TYPE_DECL
)
10630 error_at (loc
, "%qE fails to be a typedef or built in type", type
);
10631 else if (TREE_TYPE (t
) == error_mark_node
)
10635 specs
->type
= TREE_TYPE (t
);
10636 specs
->locations
[cdw_typespec
] = loc
;
10641 if (TREE_CODE (type
) != ERROR_MARK
&& spec
.kind
== ctsk_typeof
)
10643 specs
->typedef_p
= true;
10644 specs
->locations
[cdw_typedef
] = loc
;
10648 specs
->expr
= build2 (COMPOUND_EXPR
, TREE_TYPE (spec
.expr
),
10649 specs
->expr
, spec
.expr
);
10651 specs
->expr
= spec
.expr
;
10652 specs
->expr_const_operands
&= spec
.expr_const_operands
;
10655 specs
->type
= type
;
10661 /* Add the storage class specifier or function specifier SCSPEC to the
10662 declaration specifiers SPECS, returning SPECS. */
10664 struct c_declspecs
*
10665 declspecs_add_scspec (source_location loc
,
10666 struct c_declspecs
*specs
,
10670 enum c_storage_class n
= csc_none
;
10672 specs
->declspecs_seen_p
= true;
10673 gcc_assert (TREE_CODE (scspec
) == IDENTIFIER_NODE
10674 && C_IS_RESERVED_WORD (scspec
));
10675 i
= C_RID_CODE (scspec
);
10676 if (specs
->non_sc_seen_p
)
10677 warning (OPT_Wold_style_declaration
,
10678 "%qE is not at beginning of declaration", scspec
);
10682 /* C99 permits duplicate inline. Although of doubtful utility,
10683 it seems simplest to permit it in gnu89 mode as well, as
10684 there is also little utility in maintaining this as a
10685 difference between gnu89 and C99 inline. */
10687 specs
->inline_p
= true;
10688 specs
->locations
[cdw_inline
] = loc
;
10691 /* Duplicate _Noreturn is permitted. */
10693 specs
->noreturn_p
= true;
10694 specs
->locations
[cdw_noreturn
] = loc
;
10697 dupe
= specs
->thread_p
;
10698 if (specs
->storage_class
== csc_auto
)
10699 error ("%qE used with %<auto%>", scspec
);
10700 else if (specs
->storage_class
== csc_register
)
10701 error ("%qE used with %<register%>", scspec
);
10702 else if (specs
->storage_class
== csc_typedef
)
10703 error ("%qE used with %<typedef%>", scspec
);
10706 specs
->thread_p
= true;
10707 specs
->thread_gnu_p
= (strcmp (IDENTIFIER_POINTER (scspec
),
10709 /* A diagnostic is not required for the use of this
10710 identifier in the implementation namespace; only diagnose
10711 it for the C11 spelling because of existing code using
10712 the other spelling. */
10713 if (!specs
->thread_gnu_p
)
10716 pedwarn_c99 (loc
, OPT_Wpedantic
,
10717 "ISO C99 does not support %qE", scspec
);
10719 pedwarn_c99 (loc
, OPT_Wpedantic
,
10720 "ISO C90 does not support %qE", scspec
);
10722 specs
->locations
[cdw_thread
] = loc
;
10730 /* Diagnose "__thread extern". */
10731 if (specs
->thread_p
&& specs
->thread_gnu_p
)
10732 error ("%<__thread%> before %<extern%>");
10739 /* Diagnose "__thread static". */
10740 if (specs
->thread_p
&& specs
->thread_gnu_p
)
10741 error ("%<__thread%> before %<static%>");
10747 gcc_unreachable ();
10749 if (n
!= csc_none
&& n
== specs
->storage_class
)
10753 if (i
== RID_THREAD
)
10754 error ("duplicate %<_Thread_local%> or %<__thread%>");
10756 error ("duplicate %qE", scspec
);
10760 if (specs
->storage_class
!= csc_none
&& n
!= specs
->storage_class
)
10762 error ("multiple storage classes in declaration specifiers");
10766 specs
->storage_class
= n
;
10767 specs
->locations
[cdw_storage_class
] = loc
;
10768 if (n
!= csc_extern
&& n
!= csc_static
&& specs
->thread_p
)
10770 error ("%qs used with %qE",
10771 specs
->thread_gnu_p
? "__thread" : "_Thread_local",
10773 specs
->thread_p
= false;
10780 /* Add the attributes ATTRS to the declaration specifiers SPECS,
10781 returning SPECS. */
10783 struct c_declspecs
*
10784 declspecs_add_attrs (source_location loc
, struct c_declspecs
*specs
, tree attrs
)
10786 specs
->attrs
= chainon (attrs
, specs
->attrs
);
10787 specs
->locations
[cdw_attributes
] = loc
;
10788 specs
->declspecs_seen_p
= true;
10792 /* Add an _Alignas specifier (expression ALIGN, or type whose
10793 alignment is ALIGN) to the declaration specifiers SPECS, returning
10795 struct c_declspecs
*
10796 declspecs_add_alignas (source_location loc
,
10797 struct c_declspecs
*specs
, tree align
)
10800 specs
->alignas_p
= true;
10801 specs
->locations
[cdw_alignas
] = loc
;
10802 if (align
== error_mark_node
)
10804 align_log
= check_user_alignment (align
, true);
10805 if (align_log
> specs
->align_log
)
10806 specs
->align_log
= align_log
;
10810 /* Combine "long", "short", "signed", "unsigned" and "_Complex" type
10811 specifiers with any other type specifier to determine the resulting
10812 type. This is where ISO C checks on complex types are made, since
10813 "_Complex long" is a prefix of the valid ISO C type "_Complex long
10816 struct c_declspecs
*
10817 finish_declspecs (struct c_declspecs
*specs
)
10819 /* If a type was specified as a whole, we have no modifiers and are
10821 if (specs
->type
!= NULL_TREE
)
10823 gcc_assert (!specs
->long_p
&& !specs
->long_long_p
&& !specs
->short_p
10824 && !specs
->signed_p
&& !specs
->unsigned_p
10825 && !specs
->complex_p
);
10827 /* Set a dummy type. */
10828 if (TREE_CODE (specs
->type
) == ERROR_MARK
)
10829 specs
->type
= integer_type_node
;
10833 /* If none of "void", "_Bool", "char", "int", "float" or "double"
10834 has been specified, treat it as "int" unless "_Complex" is
10835 present and there are no other specifiers. If we just have
10836 "_Complex", it is equivalent to "_Complex double", but e.g.
10837 "_Complex short" is equivalent to "_Complex short int". */
10838 if (specs
->typespec_word
== cts_none
)
10840 if (specs
->saturating_p
)
10842 error_at (specs
->locations
[cdw_saturating
],
10843 "%<_Sat%> is used without %<_Fract%> or %<_Accum%>");
10844 if (!targetm
.fixed_point_supported_p ())
10845 error_at (specs
->locations
[cdw_saturating
],
10846 "fixed-point types not supported for this target");
10847 specs
->typespec_word
= cts_fract
;
10849 else if (specs
->long_p
|| specs
->short_p
10850 || specs
->signed_p
|| specs
->unsigned_p
)
10852 specs
->typespec_word
= cts_int
;
10854 else if (specs
->complex_p
)
10856 specs
->typespec_word
= cts_double
;
10857 pedwarn (specs
->locations
[cdw_complex
], OPT_Wpedantic
,
10858 "ISO C does not support plain %<complex%> meaning "
10859 "%<double complex%>");
10863 specs
->typespec_word
= cts_int
;
10864 specs
->default_int_p
= true;
10865 /* We don't diagnose this here because grokdeclarator will
10866 give more specific diagnostics according to whether it is
10867 a function definition. */
10871 /* If "signed" was specified, record this to distinguish "int" and
10872 "signed int" in the case of a bit-field with
10873 -funsigned-bitfields. */
10874 specs
->explicit_signed_p
= specs
->signed_p
;
10876 /* Now compute the actual type. */
10877 switch (specs
->typespec_word
)
10879 case cts_auto_type
:
10880 gcc_assert (!specs
->long_p
&& !specs
->short_p
10881 && !specs
->signed_p
&& !specs
->unsigned_p
10882 && !specs
->complex_p
);
10883 /* Type to be filled in later. */
10886 gcc_assert (!specs
->long_p
&& !specs
->short_p
10887 && !specs
->signed_p
&& !specs
->unsigned_p
10888 && !specs
->complex_p
);
10889 specs
->type
= void_type_node
;
10892 gcc_assert (!specs
->long_p
&& !specs
->short_p
10893 && !specs
->signed_p
&& !specs
->unsigned_p
10894 && !specs
->complex_p
);
10895 specs
->type
= boolean_type_node
;
10898 gcc_assert (!specs
->long_p
&& !specs
->short_p
);
10899 gcc_assert (!(specs
->signed_p
&& specs
->unsigned_p
));
10900 if (specs
->signed_p
)
10901 specs
->type
= signed_char_type_node
;
10902 else if (specs
->unsigned_p
)
10903 specs
->type
= unsigned_char_type_node
;
10905 specs
->type
= char_type_node
;
10906 if (specs
->complex_p
)
10908 pedwarn (specs
->locations
[cdw_complex
], OPT_Wpedantic
,
10909 "ISO C does not support complex integer types");
10910 specs
->type
= build_complex_type (specs
->type
);
10914 gcc_assert (!specs
->long_p
&& !specs
->short_p
&& !specs
->long_long_p
);
10915 gcc_assert (!(specs
->signed_p
&& specs
->unsigned_p
));
10916 if (! int_n_enabled_p
[specs
->int_n_idx
])
10917 specs
->type
= integer_type_node
;
10919 specs
->type
= (specs
->unsigned_p
10920 ? int_n_trees
[specs
->int_n_idx
].unsigned_type
10921 : int_n_trees
[specs
->int_n_idx
].signed_type
);
10922 if (specs
->complex_p
)
10924 pedwarn (specs
->locations
[cdw_complex
], OPT_Wpedantic
,
10925 "ISO C does not support complex integer types");
10926 specs
->type
= build_complex_type (specs
->type
);
10930 gcc_assert (!(specs
->long_p
&& specs
->short_p
));
10931 gcc_assert (!(specs
->signed_p
&& specs
->unsigned_p
));
10932 if (specs
->long_long_p
)
10933 specs
->type
= (specs
->unsigned_p
10934 ? long_long_unsigned_type_node
10935 : long_long_integer_type_node
);
10936 else if (specs
->long_p
)
10937 specs
->type
= (specs
->unsigned_p
10938 ? long_unsigned_type_node
10939 : long_integer_type_node
);
10940 else if (specs
->short_p
)
10941 specs
->type
= (specs
->unsigned_p
10942 ? short_unsigned_type_node
10943 : short_integer_type_node
);
10945 specs
->type
= (specs
->unsigned_p
10946 ? unsigned_type_node
10947 : integer_type_node
);
10948 if (specs
->complex_p
)
10950 pedwarn (specs
->locations
[cdw_complex
], OPT_Wpedantic
,
10951 "ISO C does not support complex integer types");
10952 specs
->type
= build_complex_type (specs
->type
);
10956 gcc_assert (!specs
->long_p
&& !specs
->short_p
10957 && !specs
->signed_p
&& !specs
->unsigned_p
);
10958 specs
->type
= (specs
->complex_p
10959 ? complex_float_type_node
10960 : float_type_node
);
10963 gcc_assert (!specs
->long_long_p
&& !specs
->short_p
10964 && !specs
->signed_p
&& !specs
->unsigned_p
);
10967 specs
->type
= (specs
->complex_p
10968 ? complex_long_double_type_node
10969 : long_double_type_node
);
10973 specs
->type
= (specs
->complex_p
10974 ? complex_double_type_node
10975 : double_type_node
);
10978 case cts_floatn_nx
:
10979 gcc_assert (!specs
->long_p
&& !specs
->short_p
10980 && !specs
->signed_p
&& !specs
->unsigned_p
);
10981 if (FLOATN_NX_TYPE_NODE (specs
->floatn_nx_idx
) == NULL_TREE
)
10982 specs
->type
= integer_type_node
;
10983 else if (specs
->complex_p
)
10984 specs
->type
= COMPLEX_FLOATN_NX_TYPE_NODE (specs
->floatn_nx_idx
);
10986 specs
->type
= FLOATN_NX_TYPE_NODE (specs
->floatn_nx_idx
);
10990 case cts_dfloat128
:
10991 gcc_assert (!specs
->long_p
&& !specs
->long_long_p
&& !specs
->short_p
10992 && !specs
->signed_p
&& !specs
->unsigned_p
&& !specs
->complex_p
);
10993 if (specs
->typespec_word
== cts_dfloat32
)
10994 specs
->type
= dfloat32_type_node
;
10995 else if (specs
->typespec_word
== cts_dfloat64
)
10996 specs
->type
= dfloat64_type_node
;
10998 specs
->type
= dfloat128_type_node
;
11001 gcc_assert (!specs
->complex_p
);
11002 if (!targetm
.fixed_point_supported_p ())
11003 specs
->type
= integer_type_node
;
11004 else if (specs
->saturating_p
)
11006 if (specs
->long_long_p
)
11007 specs
->type
= specs
->unsigned_p
11008 ? sat_unsigned_long_long_fract_type_node
11009 : sat_long_long_fract_type_node
;
11010 else if (specs
->long_p
)
11011 specs
->type
= specs
->unsigned_p
11012 ? sat_unsigned_long_fract_type_node
11013 : sat_long_fract_type_node
;
11014 else if (specs
->short_p
)
11015 specs
->type
= specs
->unsigned_p
11016 ? sat_unsigned_short_fract_type_node
11017 : sat_short_fract_type_node
;
11019 specs
->type
= specs
->unsigned_p
11020 ? sat_unsigned_fract_type_node
11021 : sat_fract_type_node
;
11025 if (specs
->long_long_p
)
11026 specs
->type
= specs
->unsigned_p
11027 ? unsigned_long_long_fract_type_node
11028 : long_long_fract_type_node
;
11029 else if (specs
->long_p
)
11030 specs
->type
= specs
->unsigned_p
11031 ? unsigned_long_fract_type_node
11032 : long_fract_type_node
;
11033 else if (specs
->short_p
)
11034 specs
->type
= specs
->unsigned_p
11035 ? unsigned_short_fract_type_node
11036 : short_fract_type_node
;
11038 specs
->type
= specs
->unsigned_p
11039 ? unsigned_fract_type_node
11044 gcc_assert (!specs
->complex_p
);
11045 if (!targetm
.fixed_point_supported_p ())
11046 specs
->type
= integer_type_node
;
11047 else if (specs
->saturating_p
)
11049 if (specs
->long_long_p
)
11050 specs
->type
= specs
->unsigned_p
11051 ? sat_unsigned_long_long_accum_type_node
11052 : sat_long_long_accum_type_node
;
11053 else if (specs
->long_p
)
11054 specs
->type
= specs
->unsigned_p
11055 ? sat_unsigned_long_accum_type_node
11056 : sat_long_accum_type_node
;
11057 else if (specs
->short_p
)
11058 specs
->type
= specs
->unsigned_p
11059 ? sat_unsigned_short_accum_type_node
11060 : sat_short_accum_type_node
;
11062 specs
->type
= specs
->unsigned_p
11063 ? sat_unsigned_accum_type_node
11064 : sat_accum_type_node
;
11068 if (specs
->long_long_p
)
11069 specs
->type
= specs
->unsigned_p
11070 ? unsigned_long_long_accum_type_node
11071 : long_long_accum_type_node
;
11072 else if (specs
->long_p
)
11073 specs
->type
= specs
->unsigned_p
11074 ? unsigned_long_accum_type_node
11075 : long_accum_type_node
;
11076 else if (specs
->short_p
)
11077 specs
->type
= specs
->unsigned_p
11078 ? unsigned_short_accum_type_node
11079 : short_accum_type_node
;
11081 specs
->type
= specs
->unsigned_p
11082 ? unsigned_accum_type_node
11087 gcc_unreachable ();
11093 /* Perform final processing on one file scope's declarations (or the
11094 external scope's declarations), GLOBALS. */
11097 c_write_global_declarations_1 (tree globals
)
11102 /* Process the decls in the order they were written. */
11103 for (decl
= globals
; decl
; decl
= DECL_CHAIN (decl
))
11105 /* Check for used but undefined static functions using the C
11106 standard's definition of "used", and set TREE_NO_WARNING so
11107 that check_global_declaration doesn't repeat the check. */
11108 if (TREE_CODE (decl
) == FUNCTION_DECL
11109 && DECL_INITIAL (decl
) == NULL_TREE
11110 && DECL_EXTERNAL (decl
)
11111 && !TREE_PUBLIC (decl
))
11113 if (C_DECL_USED (decl
))
11115 pedwarn (input_location
, 0, "%q+F used but never defined", decl
);
11116 TREE_NO_WARNING (decl
) = 1;
11118 /* For -Wunused-function warn about unused static prototypes. */
11119 else if (warn_unused_function
11120 && ! DECL_ARTIFICIAL (decl
)
11121 && ! TREE_NO_WARNING (decl
))
11123 warning (OPT_Wunused_function
,
11124 "%q+F declared %<static%> but never defined", decl
);
11125 TREE_NO_WARNING (decl
) = 1;
11129 wrapup_global_declaration_1 (decl
);
11134 reconsider
= false;
11135 for (decl
= globals
; decl
; decl
= DECL_CHAIN (decl
))
11136 reconsider
|= wrapup_global_declaration_2 (decl
);
11138 while (reconsider
);
11141 /* Callback to collect a source_ref from a DECL. */
11144 collect_source_ref_cb (tree decl
)
11146 if (!DECL_IS_BUILTIN (decl
))
11147 collect_source_ref (LOCATION_FILE (decl_sloc (decl
, false)));
11150 /* Preserve the external declarations scope across a garbage collect. */
11151 static GTY(()) tree ext_block
;
11153 /* Collect all references relevant to SOURCE_FILE. */
11156 collect_all_refs (const char *source_file
)
11161 FOR_EACH_VEC_ELT (*all_translation_units
, i
, t
)
11162 collect_ada_nodes (BLOCK_VARS (DECL_INITIAL (t
)), source_file
);
11164 collect_ada_nodes (BLOCK_VARS (ext_block
), source_file
);
11167 /* Iterate over all global declarations and call CALLBACK. */
11170 for_each_global_decl (void (*callback
) (tree decl
))
11177 FOR_EACH_VEC_ELT (*all_translation_units
, i
, t
)
11179 decls
= DECL_INITIAL (t
);
11180 for (decl
= BLOCK_VARS (decls
); decl
; decl
= TREE_CHAIN (decl
))
11184 for (decl
= BLOCK_VARS (ext_block
); decl
; decl
= TREE_CHAIN (decl
))
11188 /* Perform any final parser cleanups and generate initial debugging
11192 c_parse_final_cleanups (void)
11197 /* We don't want to do this if generating a PCH. */
11201 timevar_stop (TV_PHASE_PARSING
);
11202 timevar_start (TV_PHASE_DEFERRED
);
11204 /* Do the Objective-C stuff. This is where all the Objective-C
11205 module stuff gets generated (symtab, class/protocol/selector
11207 if (c_dialect_objc ())
11208 objc_write_global_declarations ();
11210 /* Close the external scope. */
11211 ext_block
= pop_scope ();
11212 external_scope
= 0;
11213 gcc_assert (!current_scope
);
11215 /* Handle -fdump-ada-spec[-slim]. */
11216 if (flag_dump_ada_spec
|| flag_dump_ada_spec_slim
)
11218 /* Build a table of files to generate specs for */
11219 if (flag_dump_ada_spec_slim
)
11220 collect_source_ref (main_input_filename
);
11222 for_each_global_decl (collect_source_ref_cb
);
11224 dump_ada_specs (collect_all_refs
, NULL
);
11227 /* Process all file scopes in this compilation, and the external_scope,
11228 through wrapup_global_declarations. */
11229 FOR_EACH_VEC_ELT (*all_translation_units
, i
, t
)
11230 c_write_global_declarations_1 (BLOCK_VARS (DECL_INITIAL (t
)));
11231 c_write_global_declarations_1 (BLOCK_VARS (ext_block
));
11233 timevar_stop (TV_PHASE_DEFERRED
);
11234 timevar_start (TV_PHASE_PARSING
);
11239 /* Register reserved keyword WORD as qualifier for address space AS. */
11242 c_register_addr_space (const char *word
, addr_space_t as
)
11244 int rid
= RID_FIRST_ADDR_SPACE
+ as
;
11247 /* Address space qualifiers are only supported
11248 in C with GNU extensions enabled. */
11249 if (c_dialect_objc () || flag_no_asm
)
11252 id
= get_identifier (word
);
11253 C_SET_RID_CODE (id
, rid
);
11254 C_IS_RESERVED_WORD (id
) = 1;
11255 ridpointers
[rid
] = id
;
11258 /* Return identifier to look up for omp declare reduction. */
11261 c_omp_reduction_id (enum tree_code reduction_code
, tree reduction_id
)
11263 const char *p
= NULL
;
11264 switch (reduction_code
)
11266 case PLUS_EXPR
: p
= "+"; break;
11267 case MULT_EXPR
: p
= "*"; break;
11268 case MINUS_EXPR
: p
= "-"; break;
11269 case BIT_AND_EXPR
: p
= "&"; break;
11270 case BIT_XOR_EXPR
: p
= "^"; break;
11271 case BIT_IOR_EXPR
: p
= "|"; break;
11272 case TRUTH_ANDIF_EXPR
: p
= "&&"; break;
11273 case TRUTH_ORIF_EXPR
: p
= "||"; break;
11274 case MIN_EXPR
: p
= "min"; break;
11275 case MAX_EXPR
: p
= "max"; break;
11282 if (TREE_CODE (reduction_id
) != IDENTIFIER_NODE
)
11283 return error_mark_node
;
11284 p
= IDENTIFIER_POINTER (reduction_id
);
11287 const char prefix
[] = "omp declare reduction ";
11288 size_t lenp
= sizeof (prefix
);
11289 size_t len
= strlen (p
);
11290 char *name
= XALLOCAVEC (char, lenp
+ len
);
11291 memcpy (name
, prefix
, lenp
- 1);
11292 memcpy (name
+ lenp
- 1, p
, len
+ 1);
11293 return get_identifier (name
);
11296 /* Lookup REDUCTION_ID in the current scope, or create an artificial
11297 VAR_DECL, bind it into the current scope and return it. */
11300 c_omp_reduction_decl (tree reduction_id
)
11302 struct c_binding
*b
= I_SYMBOL_BINDING (reduction_id
);
11303 if (b
!= NULL
&& B_IN_CURRENT_SCOPE (b
))
11306 tree decl
= build_decl (BUILTINS_LOCATION
, VAR_DECL
,
11307 reduction_id
, integer_type_node
);
11308 DECL_ARTIFICIAL (decl
) = 1;
11309 DECL_EXTERNAL (decl
) = 1;
11310 TREE_STATIC (decl
) = 1;
11311 TREE_PUBLIC (decl
) = 0;
11312 bind (reduction_id
, decl
, current_scope
, true, false, BUILTINS_LOCATION
);
11316 /* Lookup REDUCTION_ID in the first scope where it has entry for TYPE. */
11319 c_omp_reduction_lookup (tree reduction_id
, tree type
)
11321 struct c_binding
*b
= I_SYMBOL_BINDING (reduction_id
);
11325 for (t
= DECL_INITIAL (b
->decl
); t
; t
= TREE_CHAIN (t
))
11326 if (comptypes (TREE_PURPOSE (t
), type
))
11327 return TREE_VALUE (t
);
11330 return error_mark_node
;
11333 /* Helper function called via walk_tree, to diagnose invalid
11334 #pragma omp declare reduction combiners or initializers. */
11337 c_check_omp_declare_reduction_r (tree
*tp
, int *, void *data
)
11339 tree
*vars
= (tree
*) data
;
11340 if (SSA_VAR_P (*tp
)
11341 && !DECL_ARTIFICIAL (*tp
)
11345 location_t loc
= DECL_SOURCE_LOCATION (vars
[0]);
11346 if (strcmp (IDENTIFIER_POINTER (DECL_NAME (vars
[0])), "omp_out") == 0)
11347 error_at (loc
, "%<#pragma omp declare reduction%> combiner refers to "
11348 "variable %qD which is not %<omp_out%> nor %<omp_in%>",
11351 error_at (loc
, "%<#pragma omp declare reduction%> initializer refers "
11352 "to variable %qD which is not %<omp_priv%> nor "
11360 #include "gt-c-c-decl.h"