1 /* Process declarations and variables for C++ compiler.
2 Copyright (C) 1988-2017 Free Software Foundation, Inc.
3 Contributed by Michael Tiemann (tiemann@cygnus.com)
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3, or (at your option)
12 GCC is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING3. If not see
19 <http://www.gnu.org/licenses/>. */
22 /* Process declarations and symbol lookup for C++ front end.
23 Also constructs types; the standard scalar types at initialization,
24 and structure, union, array and enum types when they are declared. */
26 /* ??? not all decl nodes are given the most useful possible
27 line numbers. For example, the CONST_DECLs for enum values. */
31 #include "coretypes.h"
33 #include "c-family/c-target.h"
36 #include "stringpool.h"
38 #include "stor-layout.h"
42 #include "tree-iterator.h"
46 #include "c-family/c-objc.h"
47 #include "c-family/c-pragma.h"
48 #include "c-family/c-ubsan.h"
56 /* Possible cases of bad specifiers type used by bad_specifiers. */
58 BSP_VAR
, /* variable */
59 BSP_PARM
, /* parameter */
64 static const char *redeclaration_error_message (tree
, tree
);
66 static int decl_jump_unsafe (tree
);
67 static void require_complete_types_for_parms (tree
);
68 static void push_local_name (tree
);
69 static tree
grok_reference_init (tree
, tree
, tree
, int);
70 static tree
grokvardecl (tree
, tree
, tree
, const cp_decl_specifier_seq
*,
71 int, int, int, bool, int, tree
);
72 static int check_static_variable_definition (tree
, tree
);
73 static void record_unknown_type (tree
, const char *);
74 static tree
builtin_function_1 (tree
, tree
, bool);
75 static int member_function_or_else (tree
, tree
, enum overload_flags
);
76 static void check_for_uninitialized_const_var (tree
);
77 static tree
local_variable_p_walkfn (tree
*, int *, void *);
78 static const char *tag_name (enum tag_types
);
79 static tree
lookup_and_check_tag (enum tag_types
, tree
, tag_scope
, bool);
80 static void maybe_deduce_size_from_array_init (tree
, tree
);
81 static void layout_var_decl (tree
);
82 static tree
check_initializer (tree
, tree
, int, vec
<tree
, va_gc
> **);
83 static void make_rtl_for_nonlocal_decl (tree
, tree
, const char *);
84 static void save_function_data (tree
);
85 static void copy_type_enum (tree
, tree
);
86 static void check_function_type (tree
, tree
);
87 static void finish_constructor_body (void);
88 static void begin_destructor_body (void);
89 static void finish_destructor_body (void);
90 static void record_key_method_defined (tree
);
91 static tree
create_array_type_for_decl (tree
, tree
, tree
);
92 static tree
get_atexit_node (void);
93 static tree
get_dso_handle_node (void);
94 static tree
start_cleanup_fn (void);
95 static void end_cleanup_fn (void);
96 static tree
cp_make_fname_decl (location_t
, tree
, int);
97 static void initialize_predefined_identifiers (void);
98 static tree check_special_function_return_type
99 (special_function_kind
, tree
, tree
, int, const location_t
*);
100 static tree
push_cp_library_fn (enum tree_code
, tree
, int);
101 static tree
build_cp_library_fn (tree
, enum tree_code
, tree
, int);
102 static void store_parm_decls (tree
);
103 static void initialize_local_var (tree
, tree
);
104 static void expand_static_init (tree
, tree
);
106 /* The following symbols are subsumed in the cp_global_trees array, and
107 listed here individually for documentation purposes.
110 tree wchar_decl_node;
112 tree vtable_entry_type;
113 tree delta_type_node;
114 tree __t_desc_type_node;
116 tree class_type_node;
117 tree unknown_type_node;
119 Array type `vtable_entry_type[]'
122 tree vtbl_ptr_type_node;
129 A FUNCTION_DECL which can call `abort'. Not necessarily the
130 one that the user will declare, but sufficient to be called
131 by routines that want to abort the program.
136 tree type_info_type_node, tinfo_decl_id, tinfo_decl_type;
137 tree tinfo_var_id; */
139 tree cp_global_trees
[CPTI_MAX
];
141 #define local_names cp_function_chain->x_local_names
143 /* A list of objects which have constructors or destructors
144 which reside in the global scope. The decl is stored in
145 the TREE_VALUE slot and the initializer is stored
146 in the TREE_PURPOSE slot. */
147 tree static_aggregates
;
149 /* Like static_aggregates, but for thread_local variables. */
154 /* A node for the integer constant 2. */
156 tree integer_two_node
;
158 /* vector of static decls. */
159 vec
<tree
, va_gc
> *static_decls
;
161 /* vector of keyed classes. */
162 vec
<tree
, va_gc
> *keyed_classes
;
164 /* Used only for jumps to as-yet undefined labels, since jumps to
165 defined labels can have their validity checked immediately. */
167 struct GTY((chain_next ("%h.next"))) named_label_use_entry
{
168 struct named_label_use_entry
*next
;
169 /* The binding level to which this entry is *currently* attached.
170 This is initially the binding level in which the goto appeared,
171 but is modified as scopes are closed. */
172 cp_binding_level
*binding_level
;
173 /* The head of the names list that was current when the goto appeared,
174 or the inner scope popped. These are the decls that will *not* be
175 skipped when jumping to the label. */
177 /* The location of the goto, for error reporting. */
178 location_t o_goto_locus
;
179 /* True if an OpenMP structured block scope has been closed since
180 the goto appeared. This means that the branch from the label will
181 illegally exit an OpenMP scope. */
185 /* A list of all LABEL_DECLs in the function that have names. Here so
186 we can clear out their names' definitions at the end of the
187 function, and so we can check the validity of jumps to these labels. */
189 struct GTY((for_user
)) named_label_entry
{
191 tree name
; /* Name of decl. */
193 tree label_decl
; /* LABEL_DECL, unless deleted local label. */
195 named_label_entry
*outer
; /* Outer shadowed chain. */
197 /* The binding level to which the label is *currently* attached.
198 This is initially set to the binding level in which the label
199 is defined, but is modified as scopes are closed. */
200 cp_binding_level
*binding_level
;
202 /* The head of the names list that was current when the label was
203 defined, or the inner scope popped. These are the decls that will
204 be skipped when jumping to the label. */
207 /* A vector of all decls from all binding levels that would be
208 crossed by a backward branch to the label. */
209 vec
<tree
, va_gc
> *bad_decls
;
211 /* A list of uses of the label, before the label is defined. */
212 named_label_use_entry
*uses
;
214 /* The following bits are set after the label is defined, and are
215 updated as scopes are popped. They indicate that a jump to the
216 label will illegally enter a scope of the given flavor. */
220 bool in_transaction_scope
;
221 bool in_constexpr_if
;
224 #define named_labels cp_function_chain->x_named_labels
226 /* The number of function bodies which we are currently processing.
227 (Zero if we are at namespace scope, one inside the body of a
228 function, two inside the body of a function in a local class, etc.) */
231 /* Whether the exception-specifier is part of a function type (i.e. C++17). */
232 bool flag_noexcept_type
;
234 /* States indicating how grokdeclarator() should handle declspecs marked
235 with __attribute__((deprecated)). An object declared as
236 __attribute__((deprecated)) suppresses warnings of uses of other
238 enum deprecated_states deprecated_state
= DEPRECATED_NORMAL
;
241 /* A list of VAR_DECLs whose type was incomplete at the time the
242 variable was declared. */
244 struct GTY(()) incomplete_var
{
246 tree incomplete_type
;
250 static GTY(()) vec
<incomplete_var
, va_gc
> *incomplete_vars
;
252 /* Returns the kind of template specialization we are currently
253 processing, given that it's declaration contained N_CLASS_SCOPES
254 explicit scope qualifications. */
257 current_tmpl_spec_kind (int n_class_scopes
)
259 int n_template_parm_scopes
= 0;
260 int seen_specialization_p
= 0;
261 int innermost_specialization_p
= 0;
264 /* Scan through the template parameter scopes. */
265 for (b
= current_binding_level
;
266 b
->kind
== sk_template_parms
;
269 /* If we see a specialization scope inside a parameter scope,
270 then something is wrong. That corresponds to a declaration
273 template <class T> template <> ...
275 which is always invalid since [temp.expl.spec] forbids the
276 specialization of a class member template if the enclosing
277 class templates are not explicitly specialized as well. */
278 if (b
->explicit_spec_p
)
280 if (n_template_parm_scopes
== 0)
281 innermost_specialization_p
= 1;
283 seen_specialization_p
= 1;
285 else if (seen_specialization_p
== 1)
286 return tsk_invalid_member_spec
;
288 ++n_template_parm_scopes
;
291 /* Handle explicit instantiations. */
292 if (processing_explicit_instantiation
)
294 if (n_template_parm_scopes
!= 0)
295 /* We've seen a template parameter list during an explicit
296 instantiation. For example:
298 template <class T> template void f(int);
300 This is erroneous. */
301 return tsk_invalid_expl_inst
;
303 return tsk_expl_inst
;
306 if (n_template_parm_scopes
< n_class_scopes
)
307 /* We've not seen enough template headers to match all the
308 specialized classes present. For example:
310 template <class T> void R<T>::S<T>::f(int);
312 This is invalid; there needs to be one set of template
313 parameters for each class. */
314 return tsk_insufficient_parms
;
315 else if (n_template_parm_scopes
== n_class_scopes
)
316 /* We're processing a non-template declaration (even though it may
317 be a member of a template class.) For example:
319 template <class T> void S<T>::f(int);
321 The `class T' matches the `S<T>', leaving no template headers
322 corresponding to the `f'. */
324 else if (n_template_parm_scopes
> n_class_scopes
+ 1)
325 /* We've got too many template headers. For example:
327 template <> template <class T> void f (T);
329 There need to be more enclosing classes. */
330 return tsk_excessive_parms
;
332 /* This must be a template. It's of the form:
334 template <class T> template <class U> void S<T>::f(U);
336 This is a specialization if the innermost level was a
337 specialization; otherwise it's just a definition of the
339 return innermost_specialization_p
? tsk_expl_spec
: tsk_template
;
342 /* Exit the current scope. */
350 /* When a label goes out of scope, check to see if that label was used
351 in a valid manner, and issue any appropriate warnings or errors. */
354 check_label_used (tree label
)
356 if (!processing_template_decl
)
358 if (DECL_INITIAL (label
) == NULL_TREE
)
362 error ("label %q+D used but not defined", label
);
363 location
= input_location
;
364 /* FIXME want (LOCATION_FILE (input_location), (line)0) */
365 /* Avoid crashing later. */
366 define_label (location
, DECL_NAME (label
));
369 warn_for_unused_label (label
);
373 /* Helper function to sort named label entries in a vector by DECL_UID. */
376 sort_labels (const void *a
, const void *b
)
378 tree label1
= *(tree
const *) a
;
379 tree label2
= *(tree
const *) b
;
381 /* DECL_UIDs can never be equal. */
382 return DECL_UID (label1
) > DECL_UID (label2
) ? -1 : +1;
385 /* At the end of a function, all labels declared within the function
386 go out of scope. BLOCK is the top-level block for the
390 pop_labels (tree block
)
395 /* We need to add the labels to the block chain, so debug
396 information is emitted. But, we want the order to be stable so
397 need to sort them first. Otherwise the debug output could be
398 randomly ordered. I guess it's mostly stable, unless the hash
399 table implementation changes. */
400 auto_vec
<tree
, 32> labels (named_labels
->elements ());
401 hash_table
<named_label_hash
>::iterator
end (named_labels
->end ());
402 for (hash_table
<named_label_hash
>::iterator iter
403 (named_labels
->begin ()); iter
!= end
; ++iter
)
405 named_label_entry
*ent
= *iter
;
407 gcc_checking_assert (!ent
->outer
);
409 labels
.quick_push (ent
->label_decl
);
413 labels
.qsort (sort_labels
);
415 while (labels
.length ())
417 tree label
= labels
.pop ();
419 DECL_CHAIN (label
) = BLOCK_VARS (block
);
420 BLOCK_VARS (block
) = label
;
422 check_label_used (label
);
426 /* At the end of a block with local labels, restore the outer definition. */
429 pop_local_label (tree id
, tree label
)
431 check_label_used (label
);
432 named_label_entry
**slot
= named_labels
->find_slot_with_hash
433 (id
, IDENTIFIER_HASH_VALUE (id
), NO_INSERT
);
434 named_label_entry
*ent
= *slot
;
440 ent
= ggc_cleared_alloc
<named_label_entry
> ();
446 /* The following two routines are used to interface to Objective-C++.
447 The binding level is purposely treated as an opaque type. */
450 objc_get_current_scope (void)
452 return current_binding_level
;
455 /* The following routine is used by the NeXT-style SJLJ exceptions;
456 variables get marked 'volatile' so as to not be clobbered by
457 _setjmp()/_longjmp() calls. All variables in the current scope,
458 as well as parent scopes up to (but not including) ENCLOSING_BLK
459 shall be thusly marked. */
462 objc_mark_locals_volatile (void *enclosing_blk
)
464 cp_binding_level
*scope
;
466 for (scope
= current_binding_level
;
467 scope
&& scope
!= enclosing_blk
;
468 scope
= scope
->level_chain
)
472 for (decl
= scope
->names
; decl
; decl
= TREE_CHAIN (decl
))
473 objc_volatilize_decl (decl
);
475 /* Do not climb up past the current function. */
476 if (scope
->kind
== sk_function_parms
)
481 /* True if B is the level for the condition of a constexpr if. */
484 level_for_constexpr_if (cp_binding_level
*b
)
486 return (b
->kind
== sk_cond
&& b
->this_entity
487 && TREE_CODE (b
->this_entity
) == IF_STMT
488 && IF_STMT_CONSTEXPR_P (b
->this_entity
));
491 /* Update data for defined and undefined labels when leaving a scope. */
494 poplevel_named_label_1 (named_label_entry
**slot
, cp_binding_level
*bl
)
496 named_label_entry
*ent
= *slot
;
497 cp_binding_level
*obl
= bl
->level_chain
;
499 if (ent
->binding_level
== bl
)
503 /* ENT->NAMES_IN_SCOPE may contain a mixture of DECLs and
504 TREE_LISTs representing OVERLOADs, so be careful. */
505 for (decl
= ent
->names_in_scope
; decl
; decl
= (DECL_P (decl
)
507 : TREE_CHAIN (decl
)))
508 if (decl_jump_unsafe (decl
))
509 vec_safe_push (ent
->bad_decls
, decl
);
511 ent
->binding_level
= obl
;
512 ent
->names_in_scope
= obl
->names
;
516 ent
->in_try_scope
= true;
519 ent
->in_catch_scope
= true;
522 ent
->in_omp_scope
= true;
525 ent
->in_transaction_scope
= true;
528 if (level_for_constexpr_if (bl
->level_chain
))
529 ent
->in_constexpr_if
= true;
537 struct named_label_use_entry
*use
;
539 for (use
= ent
->uses
; use
; use
= use
->next
)
540 if (use
->binding_level
== bl
)
542 use
->binding_level
= obl
;
543 use
->names_in_scope
= obl
->names
;
544 if (bl
->kind
== sk_omp
)
545 use
->in_omp_scope
= true;
552 /* Saved errorcount to avoid -Wunused-but-set-{parameter,variable} warnings
553 when errors were reported, except for -Werror-unused-but-set-*. */
554 static int unused_but_set_errorcount
;
556 /* Exit a binding level.
557 Pop the level off, and restore the state of the identifier-decl mappings
558 that were in effect when this level was entered.
560 If KEEP == 1, this level had explicit declarations, so
561 and create a "block" (a BLOCK node) for the level
562 to record its declarations and subblocks for symbol table output.
564 If FUNCTIONBODY is nonzero, this level is the body of a function,
565 so create a block as if KEEP were set and also clear out all
568 If REVERSE is nonzero, reverse the order of decls before putting
569 them into the BLOCK. */
572 poplevel (int keep
, int reverse
, int functionbody
)
575 /* The chain of decls was accumulated in reverse order.
576 Put it into forward order, just for cleanliness. */
581 int leaving_for_scope
;
585 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
590 gcc_assert (current_binding_level
->kind
!= sk_class
591 && current_binding_level
->kind
!= sk_namespace
);
593 if (current_binding_level
->kind
== sk_cleanup
)
595 subblocks
= functionbody
>= 0 ? current_binding_level
->blocks
: 0;
597 gcc_assert (!vec_safe_length (current_binding_level
->class_shadowed
));
599 /* We used to use KEEP == 2 to indicate that the new block should go
600 at the beginning of the list of blocks at this binding level,
601 rather than the end. This hack is no longer used. */
602 gcc_assert (keep
== 0 || keep
== 1);
604 if (current_binding_level
->keep
)
607 /* Any uses of undefined labels, and any defined labels, now operate
608 under constraints of next binding contour. */
609 if (cfun
&& !functionbody
&& named_labels
)
610 named_labels
->traverse
<cp_binding_level
*, poplevel_named_label_1
>
611 (current_binding_level
);
613 /* Get the decls in the order they were written.
614 Usually current_binding_level->names is in reverse order.
615 But parameter decls were previously put in forward order. */
617 decls
= current_binding_level
->names
;
620 decls
= nreverse (decls
);
621 current_binding_level
->names
= decls
;
624 /* If there were any declarations or structure tags in that level,
625 or if this level is a function body,
626 create a BLOCK to record them for the life of this function. */
628 /* Avoid function body block if possible. */
629 if (functionbody
&& subblocks
&& BLOCK_CHAIN (subblocks
) == NULL_TREE
)
631 else if (keep
== 1 || functionbody
)
632 block
= make_node (BLOCK
);
633 if (block
!= NULL_TREE
)
635 BLOCK_VARS (block
) = decls
;
636 BLOCK_SUBBLOCKS (block
) = subblocks
;
639 /* In each subblock, record that this is its superior. */
641 for (link
= subblocks
; link
; link
= BLOCK_CHAIN (link
))
642 BLOCK_SUPERCONTEXT (link
) = block
;
644 /* We still support the old for-scope rules, whereby the variables
645 in a init statement were in scope after the for-statement ended.
646 We only use the new rules if flag_new_for_scope is nonzero. */
648 = current_binding_level
->kind
== sk_for
&& flag_new_for_scope
== 1;
650 /* Before we remove the declarations first check for unused variables. */
651 if ((warn_unused_variable
|| warn_unused_but_set_variable
)
652 && current_binding_level
->kind
!= sk_template_parms
653 && !processing_template_decl
)
654 for (tree d
= get_local_decls (); d
; d
= TREE_CHAIN (d
))
656 /* There are cases where D itself is a TREE_LIST. See in
657 push_local_binding where the list of decls returned by
658 getdecls is built. */
659 decl
= TREE_CODE (d
) == TREE_LIST
? TREE_VALUE (d
) : d
;
661 tree type
= TREE_TYPE (decl
);
663 && (! TREE_USED (decl
) || !DECL_READ_P (decl
))
664 && ! DECL_IN_SYSTEM_HEADER (decl
)
665 /* For structured bindings, consider only real variables, not
667 && (DECL_DECOMPOSITION_P (decl
) ? !DECL_DECOMP_BASE (decl
)
668 : (DECL_NAME (decl
) && !DECL_ARTIFICIAL (decl
)))
669 && type
!= error_mark_node
670 && (!CLASS_TYPE_P (type
)
671 || !TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
)
672 || lookup_attribute ("warn_unused",
673 TYPE_ATTRIBUTES (TREE_TYPE (decl
)))))
675 if (! TREE_USED (decl
))
677 if (!DECL_NAME (decl
) && DECL_DECOMPOSITION_P (decl
))
678 warning_at (DECL_SOURCE_LOCATION (decl
),
679 OPT_Wunused_variable
,
680 "unused structured binding declaration");
682 warning_at (DECL_SOURCE_LOCATION (decl
),
683 OPT_Wunused_variable
, "unused variable %qD", decl
);
685 else if (DECL_CONTEXT (decl
) == current_function_decl
686 // For -Wunused-but-set-variable leave references alone.
687 && TREE_CODE (TREE_TYPE (decl
)) != REFERENCE_TYPE
688 && errorcount
== unused_but_set_errorcount
)
690 if (!DECL_NAME (decl
) && DECL_DECOMPOSITION_P (decl
))
691 warning_at (DECL_SOURCE_LOCATION (decl
),
692 OPT_Wunused_but_set_variable
, "structured "
693 "binding declaration set but not used");
695 warning_at (DECL_SOURCE_LOCATION (decl
),
696 OPT_Wunused_but_set_variable
,
697 "variable %qD set but not used", decl
);
698 unused_but_set_errorcount
= errorcount
;
703 /* Remove declarations for all the DECLs in this level. */
704 for (link
= decls
; link
; link
= TREE_CHAIN (link
))
706 decl
= TREE_CODE (link
) == TREE_LIST
? TREE_VALUE (link
) : link
;
707 tree name
= OVL_NAME (decl
);
709 if (leaving_for_scope
&& VAR_P (decl
)
710 /* It's hard to make this ARM compatibility hack play nicely with
711 lambdas, and it really isn't necessary in C++11 mode. */
712 && cxx_dialect
< cxx11
715 cxx_binding
*ob
= outer_binding (name
,
716 IDENTIFIER_BINDING (name
),
718 tree ns_binding
= NULL_TREE
;
720 ns_binding
= get_namespace_binding (current_namespace
, name
);
722 if (ob
&& ob
->scope
== current_binding_level
->level_chain
)
723 /* We have something like:
728 and we are leaving the `for' scope. There's no reason to
729 keep the binding of the inner `i' in this case. */
731 else if ((ob
&& (TREE_CODE (ob
->value
) == TYPE_DECL
))
732 || (ns_binding
&& TREE_CODE (ns_binding
) == TYPE_DECL
))
733 /* Here, we have something like:
741 We must pop the for-scope binding so we know what's a
742 type and what isn't. */
746 /* Mark this VAR_DECL as dead so that we can tell we left it
747 there only for backward compatibility. */
748 DECL_DEAD_FOR_LOCAL (link
) = 1;
750 /* Keep track of what should have happened when we
751 popped the binding. */
754 SET_DECL_SHADOWED_FOR_VAR (link
, ob
->value
);
755 DECL_HAS_SHADOWED_FOR_VAR_P (link
) = 1;
758 /* Add it to the list of dead variables in the next
759 outermost binding to that we can remove these when we
760 leave that binding. */
762 current_binding_level
->level_chain
->dead_vars_from_for
,
765 /* Although we don't pop the cxx_binding, we do clear
766 its SCOPE since the scope is going away now. */
767 IDENTIFIER_BINDING (name
)->scope
768 = current_binding_level
->level_chain
;
770 /* Don't remove the binding. */
774 /* Remove the binding. */
775 if (TREE_CODE (decl
) == LABEL_DECL
)
776 pop_local_label (name
, decl
);
778 pop_local_binding (name
, decl
);
781 /* Remove declarations for any `for' variables from inner scopes
782 that we kept around. */
783 FOR_EACH_VEC_SAFE_ELT_REVERSE (current_binding_level
->dead_vars_from_for
,
785 pop_local_binding (DECL_NAME (decl
), decl
);
787 /* Restore the IDENTIFIER_TYPE_VALUEs. */
788 for (link
= current_binding_level
->type_shadowed
;
789 link
; link
= TREE_CHAIN (link
))
790 SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (link
), TREE_VALUE (link
));
792 /* There may be OVERLOADs (wrapped in TREE_LISTs) on the BLOCK_VARs
793 list if a `using' declaration put them there. The debugging
794 back ends won't understand OVERLOAD, so we remove them here.
795 Because the BLOCK_VARS are (temporarily) shared with
796 CURRENT_BINDING_LEVEL->NAMES we must do this fixup after we have
797 popped all the bindings. Also remove undeduced 'auto' decls,
798 which LTO doesn't understand, and can't have been used by anything. */
803 for (d
= &BLOCK_VARS (block
); *d
; )
805 if (TREE_CODE (*d
) == TREE_LIST
806 || (!processing_template_decl
807 && undeduced_auto_decl (*d
)))
808 *d
= TREE_CHAIN (*d
);
810 d
= &DECL_CHAIN (*d
);
814 /* If the level being exited is the top level of a function,
815 check over all the labels. */
820 /* Since this is the top level block of a function, the vars are
821 the function's parameters. Don't leave them in the BLOCK
822 because they are found in the FUNCTION_DECL instead. */
823 BLOCK_VARS (block
) = 0;
827 pop_labels (subblocks
);
830 kind
= current_binding_level
->kind
;
831 if (kind
== sk_cleanup
)
835 /* If this is a temporary binding created for a cleanup, then we'll
836 have pushed a statement list level. Pop that, create a new
837 BIND_EXPR for the block, and insert it into the stream. */
838 stmt
= pop_stmt_list (current_binding_level
->statement_list
);
839 stmt
= c_build_bind_expr (input_location
, block
, stmt
);
846 /* The current function is being defined, so its DECL_INITIAL
847 should be error_mark_node. */
848 gcc_assert (DECL_INITIAL (current_function_decl
) == error_mark_node
);
849 DECL_INITIAL (current_function_decl
) = block
? block
: subblocks
;
852 if (FUNCTION_NEEDS_BODY_BLOCK (current_function_decl
))
854 if (BLOCK_SUBBLOCKS (subblocks
))
855 BLOCK_OUTER_CURLY_BRACE_P (BLOCK_SUBBLOCKS (subblocks
)) = 1;
858 BLOCK_OUTER_CURLY_BRACE_P (subblocks
) = 1;
862 current_binding_level
->blocks
863 = block_chainon (current_binding_level
->blocks
, block
);
865 /* If we did not make a block for the level just exited,
866 any blocks made for inner levels
867 (since they cannot be recorded as subblocks in that level)
868 must be carried forward so they will later become subblocks
869 of something else. */
871 current_binding_level
->blocks
872 = block_chainon (current_binding_level
->blocks
, subblocks
);
874 /* Each and every BLOCK node created here in `poplevel' is important
875 (e.g. for proper debugging information) so if we created one
876 earlier, mark it as "used". */
878 TREE_USED (block
) = 1;
880 /* All temporary bindings created for cleanups are popped silently. */
881 if (kind
== sk_cleanup
)
884 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
888 /* Call wrapup_globals_declarations for the globals in NAMESPACE. */
889 /* Diagnose odr-used extern inline variables without definitions
890 in the current TU. */
893 wrapup_namespace_globals ()
895 if (vec
<tree
, va_gc
> *statics
= static_decls
)
899 FOR_EACH_VEC_ELT (*statics
, i
, decl
)
901 if (warn_unused_function
902 && TREE_CODE (decl
) == FUNCTION_DECL
903 && DECL_INITIAL (decl
) == 0
904 && DECL_EXTERNAL (decl
)
905 && !TREE_PUBLIC (decl
)
906 && !DECL_ARTIFICIAL (decl
)
907 && !DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION (decl
)
908 && !TREE_NO_WARNING (decl
))
909 warning_at (DECL_SOURCE_LOCATION (decl
),
910 OPT_Wunused_function
,
911 "%qF declared %<static%> but never defined", decl
);
914 && DECL_EXTERNAL (decl
)
915 && DECL_INLINE_VAR_P (decl
)
916 && DECL_ODR_USED (decl
))
917 error_at (DECL_SOURCE_LOCATION (decl
),
918 "odr-used inline variable %qD is not defined", decl
);
921 /* Clear out the list, so we don't rescan next time. */
924 /* Write out any globals that need to be output. */
925 return wrapup_global_declarations (statics
->address (),
931 /* In C++, you don't have to write `struct S' to refer to `S'; you
932 can just use `S'. We accomplish this by creating a TYPE_DECL as
933 if the user had written `typedef struct S S'. Create and return
934 the TYPE_DECL for TYPE. */
937 create_implicit_typedef (tree name
, tree type
)
941 decl
= build_decl (input_location
, TYPE_DECL
, name
, type
);
942 DECL_ARTIFICIAL (decl
) = 1;
943 /* There are other implicit type declarations, like the one *within*
944 a class that allows you to write `S::S'. We must distinguish
946 SET_DECL_IMPLICIT_TYPEDEF_P (decl
);
947 TYPE_NAME (type
) = decl
;
948 TYPE_STUB_DECL (type
) = decl
;
953 /* Remember a local name for name-mangling purposes. */
956 push_local_name (tree decl
)
961 timevar_start (TV_NAME_LOOKUP
);
963 name
= DECL_NAME (decl
);
965 nelts
= vec_safe_length (local_names
);
966 for (i
= 0; i
< nelts
; i
++)
968 t
= (*local_names
)[i
];
969 if (DECL_NAME (t
) == name
)
971 retrofit_lang_decl (decl
);
972 DECL_LANG_SPECIFIC (decl
)->u
.base
.u2sel
= 1;
973 if (DECL_DISCRIMINATOR_SET_P (t
))
974 DECL_DISCRIMINATOR (decl
) = DECL_DISCRIMINATOR (t
) + 1;
976 DECL_DISCRIMINATOR (decl
) = 1;
978 (*local_names
)[i
] = decl
;
979 timevar_stop (TV_NAME_LOOKUP
);
984 vec_safe_push (local_names
, decl
);
985 timevar_stop (TV_NAME_LOOKUP
);
988 /* Subroutine of duplicate_decls: return truthvalue of whether
989 or not types of these decls match.
991 For C++, we must compare the parameter list so that `int' can match
992 `int&' in a parameter position, but `int&' is not confused with
996 decls_match (tree newdecl
, tree olddecl
)
1000 if (newdecl
== olddecl
)
1003 if (TREE_CODE (newdecl
) != TREE_CODE (olddecl
))
1004 /* If the two DECLs are not even the same kind of thing, we're not
1005 interested in their types. */
1008 gcc_assert (DECL_P (newdecl
));
1010 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
1012 tree f1
= TREE_TYPE (newdecl
);
1013 tree f2
= TREE_TYPE (olddecl
);
1014 tree p1
= TYPE_ARG_TYPES (f1
);
1015 tree p2
= TYPE_ARG_TYPES (f2
);
1018 /* Specializations of different templates are different functions
1019 even if they have the same type. */
1020 tree t1
= (DECL_USE_TEMPLATE (newdecl
)
1021 ? DECL_TI_TEMPLATE (newdecl
)
1023 tree t2
= (DECL_USE_TEMPLATE (olddecl
)
1024 ? DECL_TI_TEMPLATE (olddecl
)
1029 if (CP_DECL_CONTEXT (newdecl
) != CP_DECL_CONTEXT (olddecl
)
1030 && ! (DECL_EXTERN_C_P (newdecl
)
1031 && DECL_EXTERN_C_P (olddecl
)))
1034 /* A new declaration doesn't match a built-in one unless it
1035 is also extern "C". */
1036 if (DECL_IS_BUILTIN (olddecl
)
1037 && DECL_EXTERN_C_P (olddecl
) && !DECL_EXTERN_C_P (newdecl
))
1040 if (TREE_CODE (f1
) != TREE_CODE (f2
))
1043 /* A declaration with deduced return type should use its pre-deduction
1044 type for declaration matching. */
1045 r2
= fndecl_declared_return_type (olddecl
);
1047 if (same_type_p (TREE_TYPE (f1
), r2
))
1049 if (!prototype_p (f2
) && DECL_EXTERN_C_P (olddecl
)
1050 && (DECL_BUILT_IN (olddecl
)
1051 #ifndef NO_IMPLICIT_EXTERN_C
1052 || (DECL_IN_SYSTEM_HEADER (newdecl
) && !DECL_CLASS_SCOPE_P (newdecl
))
1053 || (DECL_IN_SYSTEM_HEADER (olddecl
) && !DECL_CLASS_SCOPE_P (olddecl
))
1057 types_match
= self_promoting_args_p (p1
);
1058 if (p1
== void_list_node
)
1059 TREE_TYPE (newdecl
) = TREE_TYPE (olddecl
);
1061 #ifndef NO_IMPLICIT_EXTERN_C
1062 else if (!prototype_p (f1
)
1063 && (DECL_EXTERN_C_P (olddecl
)
1064 && DECL_IN_SYSTEM_HEADER (olddecl
)
1065 && !DECL_CLASS_SCOPE_P (olddecl
))
1066 && (DECL_EXTERN_C_P (newdecl
)
1067 && DECL_IN_SYSTEM_HEADER (newdecl
)
1068 && !DECL_CLASS_SCOPE_P (newdecl
)))
1070 types_match
= self_promoting_args_p (p2
);
1071 TREE_TYPE (newdecl
) = TREE_TYPE (olddecl
);
1077 && type_memfn_rqual (f1
) == type_memfn_rqual (f2
)
1078 && (TYPE_ATTRIBUTES (TREE_TYPE (newdecl
)) == NULL_TREE
1079 || comp_type_attributes (TREE_TYPE (newdecl
),
1080 TREE_TYPE (olddecl
)) != 0);
1085 /* The decls dont match if they correspond to two different versions
1086 of the same function. Disallow extern "C" functions to be
1087 versions for now. */
1089 && !DECL_EXTERN_C_P (newdecl
)
1090 && !DECL_EXTERN_C_P (olddecl
)
1091 && maybe_version_functions (newdecl
, olddecl
))
1094 else if (TREE_CODE (newdecl
) == TEMPLATE_DECL
)
1096 tree oldres
= DECL_TEMPLATE_RESULT (olddecl
);
1097 tree newres
= DECL_TEMPLATE_RESULT (newdecl
);
1099 if (TREE_CODE (newres
) != TREE_CODE (oldres
))
1102 if (!comp_template_parms (DECL_TEMPLATE_PARMS (newdecl
),
1103 DECL_TEMPLATE_PARMS (olddecl
)))
1106 if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl
)) == TYPE_DECL
)
1107 types_match
= (same_type_p (TREE_TYPE (oldres
), TREE_TYPE (newres
))
1108 && equivalently_constrained (olddecl
, newdecl
));
1110 // We don't need to check equivalently_constrained for variable and
1111 // function templates because we check it on the results.
1112 types_match
= decls_match (oldres
, newres
);
1116 /* Need to check scope for variable declaration (VAR_DECL).
1117 For typedef (TYPE_DECL), scope is ignored. */
1119 && CP_DECL_CONTEXT (newdecl
) != CP_DECL_CONTEXT (olddecl
)
1121 Two declarations for an object with C language linkage
1122 with the same name (ignoring the namespace that qualify
1123 it) that appear in different namespace scopes refer to
1125 && !(DECL_EXTERN_C_P (olddecl
) && DECL_EXTERN_C_P (newdecl
)))
1128 if (TREE_TYPE (newdecl
) == error_mark_node
)
1129 types_match
= TREE_TYPE (olddecl
) == error_mark_node
;
1130 else if (TREE_TYPE (olddecl
) == NULL_TREE
)
1131 types_match
= TREE_TYPE (newdecl
) == NULL_TREE
;
1132 else if (TREE_TYPE (newdecl
) == NULL_TREE
)
1135 types_match
= comptypes (TREE_TYPE (newdecl
),
1136 TREE_TYPE (olddecl
),
1137 COMPARE_REDECLARATION
);
1140 // Normal functions can be constrained, as can variable partial
1142 if (types_match
&& VAR_OR_FUNCTION_DECL_P (newdecl
))
1143 types_match
= equivalently_constrained (newdecl
, olddecl
);
1148 /* NEWDECL and OLDDECL have identical signatures. If they are
1149 different versions adjust them and return true. */
1152 maybe_version_functions (tree newdecl
, tree olddecl
)
1154 if (!targetm
.target_option
.function_versions (newdecl
, olddecl
))
1157 bool record
= false;
1159 if (!DECL_FUNCTION_VERSIONED (olddecl
))
1162 DECL_FUNCTION_VERSIONED (olddecl
) = 1;
1163 if (DECL_ASSEMBLER_NAME_SET_P (olddecl
))
1164 mangle_decl (olddecl
);
1167 if (!DECL_FUNCTION_VERSIONED (newdecl
))
1170 DECL_FUNCTION_VERSIONED (newdecl
) = 1;
1171 if (DECL_ASSEMBLER_NAME_SET_P (newdecl
))
1172 mangle_decl (newdecl
);
1175 /* Only record if at least one was not already versions. */
1177 cgraph_node::record_function_versions (olddecl
, newdecl
);
1182 /* If NEWDECL is `static' and an `extern' was seen previously,
1183 warn about it. OLDDECL is the previous declaration.
1185 Note that this does not apply to the C++ case of declaring
1186 a variable `extern const' and then later `const'.
1188 Don't complain about built-in functions, since they are beyond
1189 the user's control. */
1192 warn_extern_redeclared_static (tree newdecl
, tree olddecl
)
1194 if (TREE_CODE (newdecl
) == TYPE_DECL
1195 || TREE_CODE (newdecl
) == TEMPLATE_DECL
1196 || TREE_CODE (newdecl
) == CONST_DECL
1197 || TREE_CODE (newdecl
) == NAMESPACE_DECL
)
1200 /* Don't get confused by static member functions; that's a different
1202 if (TREE_CODE (newdecl
) == FUNCTION_DECL
1203 && DECL_STATIC_FUNCTION_P (newdecl
))
1206 /* If the old declaration was `static', or the new one isn't, then
1207 everything is OK. */
1208 if (DECL_THIS_STATIC (olddecl
) || !DECL_THIS_STATIC (newdecl
))
1211 /* It's OK to declare a builtin function as `static'. */
1212 if (TREE_CODE (olddecl
) == FUNCTION_DECL
1213 && DECL_ARTIFICIAL (olddecl
))
1216 if (permerror (DECL_SOURCE_LOCATION (newdecl
),
1217 "%qD was declared %<extern%> and later %<static%>", newdecl
))
1218 inform (DECL_SOURCE_LOCATION (olddecl
),
1219 "previous declaration of %qD", olddecl
);
1222 /* NEW_DECL is a redeclaration of OLD_DECL; both are functions or
1223 function templates. If their exception specifications do not
1224 match, issue a diagnostic. */
1227 check_redeclaration_exception_specification (tree new_decl
,
1230 tree new_exceptions
= TYPE_RAISES_EXCEPTIONS (TREE_TYPE (new_decl
));
1231 tree old_exceptions
= TYPE_RAISES_EXCEPTIONS (TREE_TYPE (old_decl
));
1233 /* Two default specs are equivalent, don't force evaluation. */
1234 if (UNEVALUATED_NOEXCEPT_SPEC_P (new_exceptions
)
1235 && UNEVALUATED_NOEXCEPT_SPEC_P (old_exceptions
))
1238 maybe_instantiate_noexcept (new_decl
);
1239 maybe_instantiate_noexcept (old_decl
);
1240 new_exceptions
= TYPE_RAISES_EXCEPTIONS (TREE_TYPE (new_decl
));
1241 old_exceptions
= TYPE_RAISES_EXCEPTIONS (TREE_TYPE (old_decl
));
1245 If any declaration of a function has an exception-specification,
1246 all declarations, including the definition and an explicit
1247 specialization, of that function shall have an
1248 exception-specification with the same set of type-ids. */
1249 if (! DECL_IS_BUILTIN (old_decl
)
1250 && !comp_except_specs (new_exceptions
, old_exceptions
, ce_normal
))
1252 const char *const msg
1253 = G_("declaration of %qF has a different exception specifier");
1254 bool complained
= true;
1255 location_t new_loc
= DECL_SOURCE_LOCATION (new_decl
);
1256 if (DECL_IN_SYSTEM_HEADER (old_decl
))
1257 complained
= pedwarn (new_loc
, OPT_Wsystem_headers
, msg
, new_decl
);
1258 else if (!flag_exceptions
)
1259 /* We used to silently permit mismatched eh specs with
1260 -fno-exceptions, so make them a pedwarn now. */
1261 complained
= pedwarn (new_loc
, OPT_Wpedantic
, msg
, new_decl
);
1263 error_at (new_loc
, msg
, new_decl
);
1265 inform (DECL_SOURCE_LOCATION (old_decl
),
1266 "from previous declaration %qF", old_decl
);
1270 /* Return true if OLD_DECL and NEW_DECL agree on constexprness.
1271 Otherwise issue diagnostics. */
1274 validate_constexpr_redeclaration (tree old_decl
, tree new_decl
)
1276 old_decl
= STRIP_TEMPLATE (old_decl
);
1277 new_decl
= STRIP_TEMPLATE (new_decl
);
1278 if (!VAR_OR_FUNCTION_DECL_P (old_decl
)
1279 || !VAR_OR_FUNCTION_DECL_P (new_decl
))
1281 if (DECL_DECLARED_CONSTEXPR_P (old_decl
)
1282 == DECL_DECLARED_CONSTEXPR_P (new_decl
))
1284 if (TREE_CODE (old_decl
) == FUNCTION_DECL
)
1286 if (DECL_BUILT_IN (old_decl
))
1288 /* Hide a built-in declaration. */
1289 DECL_DECLARED_CONSTEXPR_P (old_decl
)
1290 = DECL_DECLARED_CONSTEXPR_P (new_decl
);
1293 /* 7.1.5 [dcl.constexpr]
1294 Note: An explicit specialization can differ from the template
1295 declaration with respect to the constexpr specifier. */
1296 if (! DECL_TEMPLATE_SPECIALIZATION (old_decl
)
1297 && DECL_TEMPLATE_SPECIALIZATION (new_decl
))
1300 error_at (DECL_SOURCE_LOCATION (new_decl
),
1301 "redeclaration %qD differs in %<constexpr%> "
1302 "from previous declaration", new_decl
);
1303 inform (DECL_SOURCE_LOCATION (old_decl
),
1304 "previous declaration %qD", old_decl
);
1310 // If OLDDECL and NEWDECL are concept declarations with the same type
1311 // (i.e., and template parameters), but different requirements,
1312 // emit diagnostics and return true. Otherwise, return false.
1314 check_concept_refinement (tree olddecl
, tree newdecl
)
1316 if (!DECL_DECLARED_CONCEPT_P (olddecl
) || !DECL_DECLARED_CONCEPT_P (newdecl
))
1319 tree d1
= DECL_TEMPLATE_RESULT (olddecl
);
1320 tree d2
= DECL_TEMPLATE_RESULT (newdecl
);
1321 if (TREE_CODE (d1
) != TREE_CODE (d2
))
1324 tree t1
= TREE_TYPE (d1
);
1325 tree t2
= TREE_TYPE (d2
);
1326 if (TREE_CODE (d1
) == FUNCTION_DECL
)
1328 if (compparms (TYPE_ARG_TYPES (t1
), TYPE_ARG_TYPES (t2
))
1329 && comp_template_parms (DECL_TEMPLATE_PARMS (olddecl
),
1330 DECL_TEMPLATE_PARMS (newdecl
))
1331 && !equivalently_constrained (olddecl
, newdecl
))
1333 error ("cannot specialize concept %q#D", olddecl
);
1340 /* DECL is a redeclaration of a function or function template. If
1341 it does have default arguments issue a diagnostic. Note: this
1342 function is used to enforce the requirements in C++11 8.3.6 about
1343 no default arguments in redeclarations. */
1346 check_redeclaration_no_default_args (tree decl
)
1348 gcc_assert (DECL_DECLARES_FUNCTION_P (decl
));
1350 for (tree t
= FUNCTION_FIRST_USER_PARMTYPE (decl
);
1351 t
&& t
!= void_list_node
; t
= TREE_CHAIN (t
))
1352 if (TREE_PURPOSE (t
))
1354 permerror (DECL_SOURCE_LOCATION (decl
),
1355 "redeclaration of %q#D may not have default "
1361 #define GNU_INLINE_P(fn) (DECL_DECLARED_INLINE_P (fn) \
1362 && lookup_attribute ("gnu_inline", \
1363 DECL_ATTRIBUTES (fn)))
1365 /* If NEWDECL is a redeclaration of OLDDECL, merge the declarations.
1366 If the redeclaration is invalid, a diagnostic is issued, and the
1367 error_mark_node is returned. Otherwise, OLDDECL is returned.
1369 If NEWDECL is not a redeclaration of OLDDECL, NULL_TREE is
1372 NEWDECL_IS_FRIEND is true if NEWDECL was declared as a friend. */
1375 duplicate_decls (tree newdecl
, tree olddecl
, bool newdecl_is_friend
)
1377 unsigned olddecl_uid
= DECL_UID (olddecl
);
1378 int olddecl_friend
= 0, types_match
= 0, hidden_friend
= 0;
1379 int new_defines_function
= 0;
1380 tree new_template_info
;
1382 if (newdecl
== olddecl
)
1385 types_match
= decls_match (newdecl
, olddecl
);
1387 /* If either the type of the new decl or the type of the old decl is an
1388 error_mark_node, then that implies that we have already issued an
1389 error (earlier) for some bogus type specification, and in that case,
1390 it is rather pointless to harass the user with yet more error message
1391 about the same declaration, so just pretend the types match here. */
1392 if (TREE_TYPE (newdecl
) == error_mark_node
1393 || TREE_TYPE (olddecl
) == error_mark_node
)
1394 return error_mark_node
;
1396 if (UDLIT_OPER_P (DECL_NAME (newdecl
))
1397 && UDLIT_OPER_P (DECL_NAME (olddecl
)))
1399 if (TREE_CODE (newdecl
) == TEMPLATE_DECL
1400 && TREE_CODE (olddecl
) != TEMPLATE_DECL
1401 && check_raw_literal_operator (olddecl
))
1402 error ("literal operator template %q+D conflicts with"
1403 " raw literal operator %qD", newdecl
, olddecl
);
1404 else if (TREE_CODE (newdecl
) != TEMPLATE_DECL
1405 && TREE_CODE (olddecl
) == TEMPLATE_DECL
1406 && check_raw_literal_operator (newdecl
))
1407 error ("raw literal operator %q+D conflicts with"
1408 " literal operator template %qD", newdecl
, olddecl
);
1411 if (DECL_P (olddecl
)
1412 && TREE_CODE (newdecl
) == FUNCTION_DECL
1413 && TREE_CODE (olddecl
) == FUNCTION_DECL
1414 && diagnose_mismatched_attributes (olddecl
, newdecl
))
1416 if (DECL_INITIAL (olddecl
))
1417 inform (DECL_SOURCE_LOCATION (olddecl
),
1418 "previous definition of %qD was here", olddecl
);
1420 inform (DECL_SOURCE_LOCATION (olddecl
),
1421 "previous declaration of %qD was here", olddecl
);
1424 /* Check for redeclaration and other discrepancies. */
1425 if (TREE_CODE (olddecl
) == FUNCTION_DECL
1426 && DECL_ARTIFICIAL (olddecl
))
1428 gcc_assert (!DECL_HIDDEN_FRIEND_P (olddecl
));
1429 if (TREE_CODE (newdecl
) != FUNCTION_DECL
)
1431 /* Avoid warnings redeclaring built-ins which have not been
1432 explicitly declared. */
1433 if (DECL_ANTICIPATED (olddecl
))
1435 if (TREE_PUBLIC (newdecl
)
1436 && CP_DECL_CONTEXT (newdecl
) == global_namespace
)
1437 warning_at (DECL_SOURCE_LOCATION (newdecl
),
1438 OPT_Wbuiltin_declaration_mismatch
,
1439 "built-in function %qD declared as non-function",
1444 /* If you declare a built-in or predefined function name as static,
1445 the old definition is overridden, but optionally warn this was a
1446 bad choice of name. */
1447 if (! TREE_PUBLIC (newdecl
))
1449 warning (OPT_Wshadow
,
1450 DECL_BUILT_IN (olddecl
)
1451 ? G_("shadowing built-in function %q#D")
1452 : G_("shadowing library function %q#D"), olddecl
);
1453 /* Discard the old built-in function. */
1456 /* If the built-in is not ansi, then programs can override
1457 it even globally without an error. */
1458 else if (! DECL_BUILT_IN (olddecl
))
1459 warning_at (DECL_SOURCE_LOCATION (newdecl
), 0,
1460 "library function %q#D redeclared as non-function %q#D",
1463 error ("declaration of %q+#D conflicts with built-in "
1464 "declaration %q#D", newdecl
, olddecl
);
1467 else if (DECL_OMP_DECLARE_REDUCTION_P (olddecl
))
1469 gcc_assert (DECL_OMP_DECLARE_REDUCTION_P (newdecl
));
1470 error_at (DECL_SOURCE_LOCATION (newdecl
),
1471 "redeclaration of %<pragma omp declare reduction%>");
1472 inform (DECL_SOURCE_LOCATION (olddecl
),
1473 "previous %<pragma omp declare reduction%> declaration");
1474 return error_mark_node
;
1476 else if (!types_match
)
1478 /* Avoid warnings redeclaring built-ins which have not been
1479 explicitly declared. */
1480 if (DECL_ANTICIPATED (olddecl
))
1484 /* A new declaration doesn't match a built-in one unless it
1485 is also extern "C". */
1486 gcc_assert (DECL_IS_BUILTIN (olddecl
));
1487 gcc_assert (DECL_EXTERN_C_P (olddecl
));
1488 if (!DECL_EXTERN_C_P (newdecl
))
1491 for (t1
= TYPE_ARG_TYPES (TREE_TYPE (newdecl
)),
1492 t2
= TYPE_ARG_TYPES (TREE_TYPE (olddecl
));
1494 t1
= TREE_CHAIN (t1
), t2
= TREE_CHAIN (t2
))
1498 /* FILE, tm types are not known at the time
1499 we create the builtins. */
1500 for (unsigned i
= 0;
1501 i
< sizeof (builtin_structptr_types
)
1502 / sizeof (builtin_structptr_type
);
1504 if (TREE_VALUE (t2
) == builtin_structptr_types
[i
].node
)
1506 tree t
= TREE_VALUE (t1
);
1509 && TYPE_IDENTIFIER (TREE_TYPE (t
))
1510 == get_identifier (builtin_structptr_types
[i
].str
)
1511 && compparms (TREE_CHAIN (t1
), TREE_CHAIN (t2
)))
1513 tree oldargs
= TYPE_ARG_TYPES (TREE_TYPE (olddecl
));
1515 TYPE_ARG_TYPES (TREE_TYPE (olddecl
))
1516 = TYPE_ARG_TYPES (TREE_TYPE (newdecl
));
1517 types_match
= decls_match (newdecl
, olddecl
);
1519 return duplicate_decls (newdecl
, olddecl
,
1521 TYPE_ARG_TYPES (TREE_TYPE (olddecl
)) = oldargs
;
1526 if (! same_type_p (TREE_VALUE (t1
), TREE_VALUE (t2
)))
1531 warning_at (DECL_SOURCE_LOCATION (newdecl
),
1532 OPT_Wbuiltin_declaration_mismatch
,
1533 "declaration of %q#D conflicts with built-in "
1534 "declaration %q#D", newdecl
, olddecl
);
1536 else if ((DECL_EXTERN_C_P (newdecl
)
1537 && DECL_EXTERN_C_P (olddecl
))
1538 || compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl
)),
1539 TYPE_ARG_TYPES (TREE_TYPE (olddecl
))))
1541 /* A near match; override the builtin. */
1543 if (TREE_PUBLIC (newdecl
))
1544 warning_at (DECL_SOURCE_LOCATION (newdecl
),
1545 OPT_Wbuiltin_declaration_mismatch
,
1546 "new declaration %q#D ambiguates built-in "
1547 "declaration %q#D", newdecl
, olddecl
);
1549 warning (OPT_Wshadow
,
1550 DECL_BUILT_IN (olddecl
)
1551 ? G_("shadowing built-in function %q#D")
1552 : G_("shadowing library function %q#D"), olddecl
);
1555 /* Discard the old built-in function. */
1558 /* Replace the old RTL to avoid problems with inlining. */
1559 COPY_DECL_RTL (newdecl
, olddecl
);
1561 /* Even if the types match, prefer the new declarations type for
1562 built-ins which have not been explicitly declared, for
1563 exception lists, etc... */
1564 else if (DECL_IS_BUILTIN (olddecl
))
1566 tree type
= TREE_TYPE (newdecl
);
1567 tree attribs
= (*targetm
.merge_type_attributes
)
1568 (TREE_TYPE (olddecl
), type
);
1570 type
= cp_build_type_attribute_variant (type
, attribs
);
1571 TREE_TYPE (newdecl
) = TREE_TYPE (olddecl
) = type
;
1574 /* If a function is explicitly declared "throw ()", propagate that to
1575 the corresponding builtin. */
1576 if (DECL_BUILT_IN_CLASS (olddecl
) == BUILT_IN_NORMAL
1577 && DECL_ANTICIPATED (olddecl
)
1578 && TREE_NOTHROW (newdecl
)
1579 && !TREE_NOTHROW (olddecl
))
1581 enum built_in_function fncode
= DECL_FUNCTION_CODE (olddecl
);
1582 tree tmpdecl
= builtin_decl_explicit (fncode
);
1583 if (tmpdecl
&& tmpdecl
!= olddecl
&& types_match
)
1584 TREE_NOTHROW (tmpdecl
) = 1;
1587 /* Whether or not the builtin can throw exceptions has no
1588 bearing on this declarator. */
1589 TREE_NOTHROW (olddecl
) = 0;
1591 if (DECL_THIS_STATIC (newdecl
) && !DECL_THIS_STATIC (olddecl
))
1593 /* If a builtin function is redeclared as `static', merge
1594 the declarations, but make the original one static. */
1595 DECL_THIS_STATIC (olddecl
) = 1;
1596 TREE_PUBLIC (olddecl
) = 0;
1598 /* Make the old declaration consistent with the new one so
1599 that all remnants of the builtin-ness of this function
1600 will be banished. */
1601 SET_DECL_LANGUAGE (olddecl
, DECL_LANGUAGE (newdecl
));
1602 COPY_DECL_RTL (newdecl
, olddecl
);
1605 else if (TREE_CODE (olddecl
) != TREE_CODE (newdecl
))
1607 /* C++ Standard, 3.3, clause 4:
1608 "[Note: a namespace name or a class template name must be unique
1609 in its declarative region (7.3.2, clause 14). ]" */
1610 if (TREE_CODE (olddecl
) != NAMESPACE_DECL
1611 && TREE_CODE (newdecl
) != NAMESPACE_DECL
1612 && (TREE_CODE (olddecl
) != TEMPLATE_DECL
1613 || TREE_CODE (DECL_TEMPLATE_RESULT (olddecl
)) != TYPE_DECL
)
1614 && (TREE_CODE (newdecl
) != TEMPLATE_DECL
1615 || TREE_CODE (DECL_TEMPLATE_RESULT (newdecl
)) != TYPE_DECL
))
1617 if ((TREE_CODE (olddecl
) == TYPE_DECL
&& DECL_ARTIFICIAL (olddecl
)
1618 && TREE_CODE (newdecl
) != TYPE_DECL
)
1619 || (TREE_CODE (newdecl
) == TYPE_DECL
&& DECL_ARTIFICIAL (newdecl
)
1620 && TREE_CODE (olddecl
) != TYPE_DECL
))
1622 /* We do nothing special here, because C++ does such nasty
1623 things with TYPE_DECLs. Instead, just let the TYPE_DECL
1624 get shadowed, and know that if we need to find a TYPE_DECL
1625 for a given name, we can look in the IDENTIFIER_TYPE_VALUE
1626 slot of the identifier. */
1630 if ((TREE_CODE (newdecl
) == FUNCTION_DECL
1631 && DECL_FUNCTION_TEMPLATE_P (olddecl
))
1632 || (TREE_CODE (olddecl
) == FUNCTION_DECL
1633 && DECL_FUNCTION_TEMPLATE_P (newdecl
)))
1637 error ("%q#D redeclared as different kind of symbol", newdecl
);
1638 if (TREE_CODE (olddecl
) == TREE_LIST
)
1639 olddecl
= TREE_VALUE (olddecl
);
1640 inform (DECL_SOURCE_LOCATION (olddecl
),
1641 "previous declaration %q#D", olddecl
);
1643 return error_mark_node
;
1645 else if (!types_match
)
1647 if (CP_DECL_CONTEXT (newdecl
) != CP_DECL_CONTEXT (olddecl
))
1648 /* These are certainly not duplicate declarations; they're
1649 from different scopes. */
1652 if (TREE_CODE (newdecl
) == TEMPLATE_DECL
)
1654 /* The name of a class template may not be declared to refer to
1655 any other template, class, function, object, namespace, value,
1656 or type in the same scope. */
1657 if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl
)) == TYPE_DECL
1658 || TREE_CODE (DECL_TEMPLATE_RESULT (newdecl
)) == TYPE_DECL
)
1660 error ("conflicting declaration of template %q+#D", newdecl
);
1661 inform (DECL_SOURCE_LOCATION (olddecl
),
1662 "previous declaration %q#D", olddecl
);
1663 return error_mark_node
;
1665 else if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl
)) == FUNCTION_DECL
1666 && TREE_CODE (DECL_TEMPLATE_RESULT (newdecl
)) == FUNCTION_DECL
1667 && compparms (TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl
))),
1668 TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (newdecl
))))
1669 && comp_template_parms (DECL_TEMPLATE_PARMS (newdecl
),
1670 DECL_TEMPLATE_PARMS (olddecl
))
1671 /* Template functions can be disambiguated by
1673 && same_type_p (TREE_TYPE (TREE_TYPE (newdecl
)),
1674 TREE_TYPE (TREE_TYPE (olddecl
)))
1675 // Template functions can also be disambiguated by
1677 && equivalently_constrained (olddecl
, newdecl
))
1679 error ("ambiguating new declaration %q+#D", newdecl
);
1680 inform (DECL_SOURCE_LOCATION (olddecl
),
1681 "old declaration %q#D", olddecl
);
1683 else if (check_concept_refinement (olddecl
, newdecl
))
1684 return error_mark_node
;
1687 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
1689 if (DECL_EXTERN_C_P (newdecl
) && DECL_EXTERN_C_P (olddecl
))
1691 error ("conflicting declaration of C function %q+#D",
1693 inform (DECL_SOURCE_LOCATION (olddecl
),
1694 "previous declaration %q#D", olddecl
);
1697 /* For function versions, params and types match, but they
1698 are not ambiguous. */
1699 else if ((!DECL_FUNCTION_VERSIONED (newdecl
)
1700 && !DECL_FUNCTION_VERSIONED (olddecl
))
1701 // The functions have the same parameter types.
1702 && compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl
)),
1703 TYPE_ARG_TYPES (TREE_TYPE (olddecl
)))
1704 // And the same constraints.
1705 && equivalently_constrained (newdecl
, olddecl
))
1707 error ("ambiguating new declaration of %q+#D", newdecl
);
1708 inform (DECL_SOURCE_LOCATION (olddecl
),
1709 "old declaration %q#D", olddecl
);
1710 return error_mark_node
;
1717 error ("conflicting declaration %q+#D", newdecl
);
1718 inform (DECL_SOURCE_LOCATION (olddecl
),
1719 "previous declaration as %q#D", olddecl
);
1720 return error_mark_node
;
1723 else if (TREE_CODE (newdecl
) == FUNCTION_DECL
1724 && ((DECL_TEMPLATE_SPECIALIZATION (olddecl
)
1725 && (!DECL_TEMPLATE_INFO (newdecl
)
1726 || (DECL_TI_TEMPLATE (newdecl
)
1727 != DECL_TI_TEMPLATE (olddecl
))))
1728 || (DECL_TEMPLATE_SPECIALIZATION (newdecl
)
1729 && (!DECL_TEMPLATE_INFO (olddecl
)
1730 || (DECL_TI_TEMPLATE (olddecl
)
1731 != DECL_TI_TEMPLATE (newdecl
))))))
1732 /* It's OK to have a template specialization and a non-template
1733 with the same type, or to have specializations of two
1734 different templates with the same type. Note that if one is a
1735 specialization, and the other is an instantiation of the same
1736 template, that we do not exit at this point. That situation
1737 can occur if we instantiate a template class, and then
1738 specialize one of its methods. This situation is valid, but
1739 the declarations must be merged in the usual way. */
1741 else if (TREE_CODE (newdecl
) == FUNCTION_DECL
1742 && ((DECL_TEMPLATE_INSTANTIATION (olddecl
)
1743 && !DECL_USE_TEMPLATE (newdecl
))
1744 || (DECL_TEMPLATE_INSTANTIATION (newdecl
)
1745 && !DECL_USE_TEMPLATE (olddecl
))))
1746 /* One of the declarations is a template instantiation, and the
1747 other is not a template at all. That's OK. */
1749 else if (TREE_CODE (newdecl
) == NAMESPACE_DECL
)
1751 /* In [namespace.alias] we have:
1753 In a declarative region, a namespace-alias-definition can be
1754 used to redefine a namespace-alias declared in that declarative
1755 region to refer only to the namespace to which it already
1758 Therefore, if we encounter a second alias directive for the same
1759 alias, we can just ignore the second directive. */
1760 if (DECL_NAMESPACE_ALIAS (newdecl
)
1761 && (DECL_NAMESPACE_ALIAS (newdecl
)
1762 == DECL_NAMESPACE_ALIAS (olddecl
)))
1765 /* Leave it to update_binding to merge or report error. */
1770 const char *errmsg
= redeclaration_error_message (newdecl
, olddecl
);
1773 error_at (DECL_SOURCE_LOCATION (newdecl
), errmsg
, newdecl
);
1774 if (DECL_NAME (olddecl
) != NULL_TREE
)
1775 inform (DECL_SOURCE_LOCATION (olddecl
),
1776 (DECL_INITIAL (olddecl
) && namespace_bindings_p ())
1777 ? G_("%q#D previously defined here")
1778 : G_("%q#D previously declared here"), olddecl
);
1779 return error_mark_node
;
1781 else if (TREE_CODE (olddecl
) == FUNCTION_DECL
1782 && DECL_INITIAL (olddecl
) != NULL_TREE
1783 && !prototype_p (TREE_TYPE (olddecl
))
1784 && prototype_p (TREE_TYPE (newdecl
)))
1786 /* Prototype decl follows defn w/o prototype. */
1787 if (warning_at (DECL_SOURCE_LOCATION (newdecl
), 0,
1788 "prototype specified for %q#D", newdecl
))
1789 inform (DECL_SOURCE_LOCATION (olddecl
),
1790 "previous non-prototype definition here");
1792 else if (VAR_OR_FUNCTION_DECL_P (olddecl
)
1793 && DECL_LANGUAGE (newdecl
) != DECL_LANGUAGE (olddecl
))
1796 If two declarations of the same function or object
1797 specify different linkage-specifications ..., the program
1798 is ill-formed.... Except for functions with C++ linkage,
1799 a function declaration without a linkage specification
1800 shall not precede the first linkage specification for
1801 that function. A function can be declared without a
1802 linkage specification after an explicit linkage
1803 specification has been seen; the linkage explicitly
1804 specified in the earlier declaration is not affected by
1805 such a function declaration.
1807 DR 563 raises the question why the restrictions on
1808 functions should not also apply to objects. Older
1809 versions of G++ silently ignore the linkage-specification
1817 which is clearly wrong. Therefore, we now treat objects
1819 if (current_lang_depth () == 0)
1821 /* There is no explicit linkage-specification, so we use
1822 the linkage from the previous declaration. */
1823 retrofit_lang_decl (newdecl
);
1824 SET_DECL_LANGUAGE (newdecl
, DECL_LANGUAGE (olddecl
));
1828 error ("conflicting declaration of %q+#D with %qL linkage",
1829 newdecl
, DECL_LANGUAGE (newdecl
));
1830 inform (DECL_SOURCE_LOCATION (olddecl
),
1831 "previous declaration with %qL linkage",
1832 DECL_LANGUAGE (olddecl
));
1836 if (DECL_LANG_SPECIFIC (olddecl
) && DECL_USE_TEMPLATE (olddecl
))
1838 else if (TREE_CODE (olddecl
) == FUNCTION_DECL
)
1840 /* Note: free functions, as TEMPLATE_DECLs, are handled below. */
1841 if (DECL_FUNCTION_MEMBER_P (olddecl
)
1842 && (/* grokfndecl passes member function templates too
1843 as FUNCTION_DECLs. */
1844 DECL_TEMPLATE_INFO (olddecl
)
1846 Default arguments for a member function of a class
1847 template shall be specified on the initial declaration
1848 of the member function within the class template. */
1849 || CLASSTYPE_TEMPLATE_INFO (CP_DECL_CONTEXT (olddecl
))))
1850 check_redeclaration_no_default_args (newdecl
);
1853 tree t1
= FUNCTION_FIRST_USER_PARMTYPE (olddecl
);
1854 tree t2
= FUNCTION_FIRST_USER_PARMTYPE (newdecl
);
1857 for (; t1
&& t1
!= void_list_node
;
1858 t1
= TREE_CHAIN (t1
), t2
= TREE_CHAIN (t2
), i
++)
1859 if (TREE_PURPOSE (t1
) && TREE_PURPOSE (t2
))
1861 if (1 == simple_cst_equal (TREE_PURPOSE (t1
),
1864 if (permerror (input_location
,
1865 "default argument given for parameter "
1866 "%d of %q#D", i
, newdecl
))
1867 inform (DECL_SOURCE_LOCATION (olddecl
),
1868 "previous specification in %q#D here",
1873 error ("default argument given for parameter %d "
1874 "of %q#D", i
, newdecl
);
1875 inform (DECL_SOURCE_LOCATION (olddecl
),
1876 "previous specification in %q#D here",
1884 /* Do not merge an implicit typedef with an explicit one. In:
1888 typedef class A A __attribute__ ((foo));
1890 the attribute should apply only to the typedef. */
1891 if (TREE_CODE (olddecl
) == TYPE_DECL
1892 && (DECL_IMPLICIT_TYPEDEF_P (olddecl
)
1893 || DECL_IMPLICIT_TYPEDEF_P (newdecl
)))
1896 /* If new decl is `static' and an `extern' was seen previously,
1898 warn_extern_redeclared_static (newdecl
, olddecl
);
1900 if (!validate_constexpr_redeclaration (olddecl
, newdecl
))
1901 return error_mark_node
;
1903 /* We have committed to returning 1 at this point. */
1904 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
1906 /* Now that functions must hold information normally held
1907 by field decls, there is extra work to do so that
1908 declaration information does not get destroyed during
1910 if (DECL_VINDEX (olddecl
))
1911 DECL_VINDEX (newdecl
) = DECL_VINDEX (olddecl
);
1912 if (DECL_CONTEXT (olddecl
))
1913 DECL_CONTEXT (newdecl
) = DECL_CONTEXT (olddecl
);
1914 DECL_STATIC_CONSTRUCTOR (newdecl
) |= DECL_STATIC_CONSTRUCTOR (olddecl
);
1915 DECL_STATIC_DESTRUCTOR (newdecl
) |= DECL_STATIC_DESTRUCTOR (olddecl
);
1916 DECL_PURE_VIRTUAL_P (newdecl
) |= DECL_PURE_VIRTUAL_P (olddecl
);
1917 DECL_VIRTUAL_P (newdecl
) |= DECL_VIRTUAL_P (olddecl
);
1918 DECL_INVALID_OVERRIDER_P (newdecl
) |= DECL_INVALID_OVERRIDER_P (olddecl
);
1919 DECL_FINAL_P (newdecl
) |= DECL_FINAL_P (olddecl
);
1920 DECL_OVERRIDE_P (newdecl
) |= DECL_OVERRIDE_P (olddecl
);
1921 DECL_THIS_STATIC (newdecl
) |= DECL_THIS_STATIC (olddecl
);
1922 if (DECL_OVERLOADED_OPERATOR_P (olddecl
))
1923 DECL_OVERLOADED_OPERATOR_CODE_RAW (newdecl
)
1924 = DECL_OVERLOADED_OPERATOR_CODE_RAW (olddecl
);
1925 new_defines_function
= DECL_INITIAL (newdecl
) != NULL_TREE
;
1927 /* Optionally warn about more than one declaration for the same
1928 name, but don't warn about a function declaration followed by a
1930 if (warn_redundant_decls
&& ! DECL_ARTIFICIAL (olddecl
)
1931 && !(new_defines_function
&& DECL_INITIAL (olddecl
) == NULL_TREE
)
1932 /* Don't warn about extern decl followed by definition. */
1933 && !(DECL_EXTERNAL (olddecl
) && ! DECL_EXTERNAL (newdecl
))
1934 /* Don't warn about friends, let add_friend take care of it. */
1935 && ! (newdecl_is_friend
|| DECL_FRIEND_P (olddecl
))
1936 /* Don't warn about declaration followed by specialization. */
1937 && (! DECL_TEMPLATE_SPECIALIZATION (newdecl
)
1938 || DECL_TEMPLATE_SPECIALIZATION (olddecl
)))
1940 if (warning_at (DECL_SOURCE_LOCATION (newdecl
),
1941 OPT_Wredundant_decls
,
1942 "redundant redeclaration of %qD in same scope",
1944 inform (DECL_SOURCE_LOCATION (olddecl
),
1945 "previous declaration of %qD", olddecl
);
1948 if (!(DECL_TEMPLATE_INSTANTIATION (olddecl
)
1949 && DECL_TEMPLATE_SPECIALIZATION (newdecl
)))
1951 if (DECL_DELETED_FN (newdecl
))
1953 error ("deleted definition of %q+D", newdecl
);
1954 inform (DECL_SOURCE_LOCATION (olddecl
),
1955 "previous declaration of %qD", olddecl
);
1957 DECL_DELETED_FN (newdecl
) |= DECL_DELETED_FN (olddecl
);
1961 /* Deal with C++: must preserve virtual function table size. */
1962 if (TREE_CODE (olddecl
) == TYPE_DECL
)
1964 tree newtype
= TREE_TYPE (newdecl
);
1965 tree oldtype
= TREE_TYPE (olddecl
);
1967 if (newtype
!= error_mark_node
&& oldtype
!= error_mark_node
1968 && TYPE_LANG_SPECIFIC (newtype
) && TYPE_LANG_SPECIFIC (oldtype
))
1969 CLASSTYPE_FRIEND_CLASSES (newtype
)
1970 = CLASSTYPE_FRIEND_CLASSES (oldtype
);
1972 DECL_ORIGINAL_TYPE (newdecl
) = DECL_ORIGINAL_TYPE (olddecl
);
1975 /* Copy all the DECL_... slots specified in the new decl
1976 except for any that we copy here from the old type. */
1977 DECL_ATTRIBUTES (newdecl
)
1978 = (*targetm
.merge_decl_attributes
) (olddecl
, newdecl
);
1980 if (DECL_DECLARES_FUNCTION_P (olddecl
) && DECL_DECLARES_FUNCTION_P (newdecl
))
1982 olddecl_friend
= DECL_FRIEND_P (olddecl
);
1983 hidden_friend
= (DECL_ANTICIPATED (olddecl
)
1984 && DECL_HIDDEN_FRIEND_P (olddecl
)
1985 && newdecl_is_friend
);
1988 DECL_ANTICIPATED (olddecl
) = 0;
1989 DECL_HIDDEN_FRIEND_P (olddecl
) = 0;
1993 if (TREE_CODE (newdecl
) == TEMPLATE_DECL
)
1997 old_result
= DECL_TEMPLATE_RESULT (olddecl
);
1998 new_result
= DECL_TEMPLATE_RESULT (newdecl
);
1999 TREE_TYPE (olddecl
) = TREE_TYPE (old_result
);
2000 DECL_TEMPLATE_SPECIALIZATIONS (olddecl
)
2001 = chainon (DECL_TEMPLATE_SPECIALIZATIONS (olddecl
),
2002 DECL_TEMPLATE_SPECIALIZATIONS (newdecl
));
2004 DECL_ATTRIBUTES (old_result
)
2005 = (*targetm
.merge_decl_attributes
) (old_result
, new_result
);
2007 if (DECL_FUNCTION_TEMPLATE_P (newdecl
))
2009 /* Per C++11 8.3.6/4, default arguments cannot be added in later
2010 declarations of a function template. */
2011 if (DECL_SOURCE_LOCATION (newdecl
)
2012 != DECL_SOURCE_LOCATION (olddecl
))
2013 check_redeclaration_no_default_args (newdecl
);
2015 check_default_args (newdecl
);
2017 if (GNU_INLINE_P (old_result
) != GNU_INLINE_P (new_result
)
2018 && DECL_INITIAL (new_result
))
2020 if (DECL_INITIAL (old_result
))
2021 DECL_UNINLINABLE (old_result
) = 1;
2023 DECL_UNINLINABLE (old_result
) = DECL_UNINLINABLE (new_result
);
2024 DECL_EXTERNAL (old_result
) = DECL_EXTERNAL (new_result
);
2025 DECL_NOT_REALLY_EXTERN (old_result
)
2026 = DECL_NOT_REALLY_EXTERN (new_result
);
2027 DECL_INTERFACE_KNOWN (old_result
)
2028 = DECL_INTERFACE_KNOWN (new_result
);
2029 DECL_DECLARED_INLINE_P (old_result
)
2030 = DECL_DECLARED_INLINE_P (new_result
);
2031 DECL_DISREGARD_INLINE_LIMITS (old_result
)
2032 |= DECL_DISREGARD_INLINE_LIMITS (new_result
);
2037 DECL_DECLARED_INLINE_P (old_result
)
2038 |= DECL_DECLARED_INLINE_P (new_result
);
2039 DECL_DISREGARD_INLINE_LIMITS (old_result
)
2040 |= DECL_DISREGARD_INLINE_LIMITS (new_result
);
2041 check_redeclaration_exception_specification (newdecl
, olddecl
);
2045 /* If the new declaration is a definition, update the file and
2046 line information on the declaration, and also make
2047 the old declaration the same definition. */
2048 if (DECL_INITIAL (new_result
) != NULL_TREE
)
2050 DECL_SOURCE_LOCATION (olddecl
)
2051 = DECL_SOURCE_LOCATION (old_result
)
2052 = DECL_SOURCE_LOCATION (newdecl
);
2053 DECL_INITIAL (old_result
) = DECL_INITIAL (new_result
);
2054 if (DECL_FUNCTION_TEMPLATE_P (newdecl
))
2057 DECL_ARGUMENTS (old_result
)
2058 = DECL_ARGUMENTS (new_result
);
2059 for (parm
= DECL_ARGUMENTS (old_result
); parm
;
2060 parm
= DECL_CHAIN (parm
))
2061 DECL_CONTEXT (parm
) = old_result
;
2070 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
2071 check_redeclaration_exception_specification (newdecl
, olddecl
);
2073 /* Automatically handles default parameters. */
2074 tree oldtype
= TREE_TYPE (olddecl
);
2077 /* For typedefs use the old type, as the new type's DECL_NAME points
2078 at newdecl, which will be ggc_freed. */
2079 if (TREE_CODE (newdecl
) == TYPE_DECL
)
2081 /* But NEWTYPE might have an attribute, honor that. */
2082 tree tem
= TREE_TYPE (newdecl
);
2085 if (TYPE_USER_ALIGN (tem
))
2087 if (TYPE_ALIGN (tem
) > TYPE_ALIGN (newtype
))
2088 SET_TYPE_ALIGN (newtype
, TYPE_ALIGN (tem
));
2089 TYPE_USER_ALIGN (newtype
) = true;
2092 /* And remove the new type from the variants list. */
2093 if (TYPE_NAME (TREE_TYPE (newdecl
)) == newdecl
)
2095 tree remove
= TREE_TYPE (newdecl
);
2096 for (tree t
= TYPE_MAIN_VARIANT (remove
); ;
2097 t
= TYPE_NEXT_VARIANT (t
))
2098 if (TYPE_NEXT_VARIANT (t
) == remove
)
2100 TYPE_NEXT_VARIANT (t
) = TYPE_NEXT_VARIANT (remove
);
2106 /* Merge the data types specified in the two decls. */
2107 newtype
= merge_types (TREE_TYPE (newdecl
), TREE_TYPE (olddecl
));
2109 if (VAR_P (newdecl
))
2111 DECL_THIS_EXTERN (newdecl
) |= DECL_THIS_EXTERN (olddecl
);
2112 /* For already initialized vars, TREE_READONLY could have been
2113 cleared in cp_finish_decl, because the var needs runtime
2114 initialization or destruction. Make sure not to set
2115 TREE_READONLY on it again. */
2116 if (DECL_INITIALIZED_P (olddecl
)
2117 && !DECL_EXTERNAL (olddecl
)
2118 && !TREE_READONLY (olddecl
))
2119 TREE_READONLY (newdecl
) = 0;
2120 DECL_INITIALIZED_P (newdecl
) |= DECL_INITIALIZED_P (olddecl
);
2121 DECL_NONTRIVIALLY_INITIALIZED_P (newdecl
)
2122 |= DECL_NONTRIVIALLY_INITIALIZED_P (olddecl
);
2123 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (newdecl
)
2124 |= DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (olddecl
);
2125 if (DECL_CLASS_SCOPE_P (olddecl
))
2126 DECL_DECLARED_CONSTEXPR_P (newdecl
)
2127 |= DECL_DECLARED_CONSTEXPR_P (olddecl
);
2129 /* Merge the threadprivate attribute from OLDDECL into NEWDECL. */
2130 if (DECL_LANG_SPECIFIC (olddecl
)
2131 && CP_DECL_THREADPRIVATE_P (olddecl
))
2133 /* Allocate a LANG_SPECIFIC structure for NEWDECL, if needed. */
2134 retrofit_lang_decl (newdecl
);
2135 CP_DECL_THREADPRIVATE_P (newdecl
) = 1;
2139 /* An explicit specialization of a function template or of a member
2140 function of a class template can be declared transaction_safe
2141 independently of whether the corresponding template entity is declared
2142 transaction_safe. */
2143 if (flag_tm
&& TREE_CODE (newdecl
) == FUNCTION_DECL
2144 && DECL_TEMPLATE_INSTANTIATION (olddecl
)
2145 && DECL_TEMPLATE_SPECIALIZATION (newdecl
)
2146 && tx_safe_fn_type_p (newtype
)
2147 && !tx_safe_fn_type_p (TREE_TYPE (newdecl
)))
2148 newtype
= tx_unsafe_fn_variant (newtype
);
2150 TREE_TYPE (newdecl
) = TREE_TYPE (olddecl
) = newtype
;
2152 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
2153 check_default_args (newdecl
);
2155 /* Lay the type out, unless already done. */
2156 if (! same_type_p (newtype
, oldtype
)
2157 && TREE_TYPE (newdecl
) != error_mark_node
2158 && !(processing_template_decl
&& uses_template_parms (newdecl
)))
2159 layout_type (TREE_TYPE (newdecl
));
2161 if ((VAR_P (newdecl
)
2162 || TREE_CODE (newdecl
) == PARM_DECL
2163 || TREE_CODE (newdecl
) == RESULT_DECL
2164 || TREE_CODE (newdecl
) == FIELD_DECL
2165 || TREE_CODE (newdecl
) == TYPE_DECL
)
2166 && !(processing_template_decl
&& uses_template_parms (newdecl
)))
2167 layout_decl (newdecl
, 0);
2169 /* Merge the type qualifiers. */
2170 if (TREE_READONLY (newdecl
))
2171 TREE_READONLY (olddecl
) = 1;
2172 if (TREE_THIS_VOLATILE (newdecl
))
2173 TREE_THIS_VOLATILE (olddecl
) = 1;
2174 if (TREE_NOTHROW (newdecl
))
2175 TREE_NOTHROW (olddecl
) = 1;
2177 /* Merge deprecatedness. */
2178 if (TREE_DEPRECATED (newdecl
))
2179 TREE_DEPRECATED (olddecl
) = 1;
2181 /* Preserve function specific target and optimization options */
2182 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
2184 if (DECL_FUNCTION_SPECIFIC_TARGET (olddecl
)
2185 && !DECL_FUNCTION_SPECIFIC_TARGET (newdecl
))
2186 DECL_FUNCTION_SPECIFIC_TARGET (newdecl
)
2187 = DECL_FUNCTION_SPECIFIC_TARGET (olddecl
);
2189 if (DECL_FUNCTION_SPECIFIC_OPTIMIZATION (olddecl
)
2190 && !DECL_FUNCTION_SPECIFIC_OPTIMIZATION (newdecl
))
2191 DECL_FUNCTION_SPECIFIC_OPTIMIZATION (newdecl
)
2192 = DECL_FUNCTION_SPECIFIC_OPTIMIZATION (olddecl
);
2195 /* Merge the initialization information. */
2196 if (DECL_INITIAL (newdecl
) == NULL_TREE
2197 && DECL_INITIAL (olddecl
) != NULL_TREE
)
2199 DECL_INITIAL (newdecl
) = DECL_INITIAL (olddecl
);
2200 DECL_SOURCE_LOCATION (newdecl
) = DECL_SOURCE_LOCATION (olddecl
);
2201 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
2203 DECL_SAVED_TREE (newdecl
) = DECL_SAVED_TREE (olddecl
);
2204 DECL_STRUCT_FUNCTION (newdecl
) = DECL_STRUCT_FUNCTION (olddecl
);
2208 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
2210 DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (newdecl
)
2211 |= DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (olddecl
);
2212 DECL_NO_LIMIT_STACK (newdecl
) |= DECL_NO_LIMIT_STACK (olddecl
);
2213 TREE_THIS_VOLATILE (newdecl
) |= TREE_THIS_VOLATILE (olddecl
);
2214 TREE_NOTHROW (newdecl
) |= TREE_NOTHROW (olddecl
);
2215 DECL_IS_MALLOC (newdecl
) |= DECL_IS_MALLOC (olddecl
);
2216 DECL_IS_OPERATOR_NEW (newdecl
) |= DECL_IS_OPERATOR_NEW (olddecl
);
2217 DECL_PURE_P (newdecl
) |= DECL_PURE_P (olddecl
);
2218 TREE_READONLY (newdecl
) |= TREE_READONLY (olddecl
);
2219 DECL_LOOPING_CONST_OR_PURE_P (newdecl
)
2220 |= DECL_LOOPING_CONST_OR_PURE_P (olddecl
);
2221 /* Keep the old RTL. */
2222 COPY_DECL_RTL (olddecl
, newdecl
);
2224 else if (VAR_P (newdecl
)
2225 && (DECL_SIZE (olddecl
) || !DECL_SIZE (newdecl
)))
2227 /* Keep the old RTL. We cannot keep the old RTL if the old
2228 declaration was for an incomplete object and the new
2229 declaration is not since many attributes of the RTL will
2231 COPY_DECL_RTL (olddecl
, newdecl
);
2234 /* If cannot merge, then use the new type and qualifiers,
2235 and don't preserve the old rtl. */
2238 /* Clean out any memory we had of the old declaration. */
2239 tree oldstatic
= value_member (olddecl
, static_aggregates
);
2241 TREE_VALUE (oldstatic
) = error_mark_node
;
2243 TREE_TYPE (olddecl
) = TREE_TYPE (newdecl
);
2244 TREE_READONLY (olddecl
) = TREE_READONLY (newdecl
);
2245 TREE_THIS_VOLATILE (olddecl
) = TREE_THIS_VOLATILE (newdecl
);
2246 TREE_NOTHROW (olddecl
) = TREE_NOTHROW (newdecl
);
2247 TREE_SIDE_EFFECTS (olddecl
) = TREE_SIDE_EFFECTS (newdecl
);
2250 /* Merge the storage class information. */
2251 merge_weak (newdecl
, olddecl
);
2253 DECL_DEFER_OUTPUT (newdecl
) |= DECL_DEFER_OUTPUT (olddecl
);
2254 TREE_PUBLIC (newdecl
) = TREE_PUBLIC (olddecl
);
2255 TREE_STATIC (olddecl
) = TREE_STATIC (newdecl
) |= TREE_STATIC (olddecl
);
2256 if (! DECL_EXTERNAL (olddecl
))
2257 DECL_EXTERNAL (newdecl
) = 0;
2258 if (! DECL_COMDAT (olddecl
))
2259 DECL_COMDAT (newdecl
) = 0;
2261 new_template_info
= NULL_TREE
;
2262 if (DECL_LANG_SPECIFIC (newdecl
) && DECL_LANG_SPECIFIC (olddecl
))
2264 bool new_redefines_gnu_inline
= false;
2266 if (new_defines_function
2267 && ((DECL_INTERFACE_KNOWN (olddecl
)
2268 && TREE_CODE (olddecl
) == FUNCTION_DECL
)
2269 || (TREE_CODE (olddecl
) == TEMPLATE_DECL
2270 && (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl
))
2271 == FUNCTION_DECL
))))
2275 if (TREE_CODE (fn
) == TEMPLATE_DECL
)
2276 fn
= DECL_TEMPLATE_RESULT (olddecl
);
2278 new_redefines_gnu_inline
= GNU_INLINE_P (fn
) && DECL_INITIAL (fn
);
2281 if (!new_redefines_gnu_inline
)
2283 DECL_INTERFACE_KNOWN (newdecl
) |= DECL_INTERFACE_KNOWN (olddecl
);
2284 DECL_NOT_REALLY_EXTERN (newdecl
) |= DECL_NOT_REALLY_EXTERN (olddecl
);
2285 DECL_COMDAT (newdecl
) |= DECL_COMDAT (olddecl
);
2287 DECL_TEMPLATE_INSTANTIATED (newdecl
)
2288 |= DECL_TEMPLATE_INSTANTIATED (olddecl
);
2289 DECL_ODR_USED (newdecl
) |= DECL_ODR_USED (olddecl
);
2291 /* If the OLDDECL is an instantiation and/or specialization,
2292 then the NEWDECL must be too. But, it may not yet be marked
2293 as such if the caller has created NEWDECL, but has not yet
2294 figured out that it is a redeclaration. */
2295 if (!DECL_USE_TEMPLATE (newdecl
))
2296 DECL_USE_TEMPLATE (newdecl
) = DECL_USE_TEMPLATE (olddecl
);
2298 /* Don't really know how much of the language-specific
2299 values we should copy from old to new. */
2300 DECL_IN_AGGR_P (newdecl
) = DECL_IN_AGGR_P (olddecl
);
2301 DECL_REPO_AVAILABLE_P (newdecl
) = DECL_REPO_AVAILABLE_P (olddecl
);
2302 DECL_INITIALIZED_IN_CLASS_P (newdecl
)
2303 |= DECL_INITIALIZED_IN_CLASS_P (olddecl
);
2305 if (LANG_DECL_HAS_MIN (newdecl
))
2307 DECL_LANG_SPECIFIC (newdecl
)->u
.min
.u2
=
2308 DECL_LANG_SPECIFIC (olddecl
)->u
.min
.u2
;
2309 if (DECL_TEMPLATE_INFO (newdecl
))
2311 new_template_info
= DECL_TEMPLATE_INFO (newdecl
);
2312 if (DECL_TEMPLATE_INSTANTIATION (olddecl
)
2313 && DECL_TEMPLATE_SPECIALIZATION (newdecl
))
2314 /* Remember the presence of explicit specialization args. */
2315 TINFO_USED_TEMPLATE_ID (DECL_TEMPLATE_INFO (olddecl
))
2316 = TINFO_USED_TEMPLATE_ID (new_template_info
);
2318 DECL_TEMPLATE_INFO (newdecl
) = DECL_TEMPLATE_INFO (olddecl
);
2320 /* Only functions have these fields. */
2321 if (DECL_DECLARES_FUNCTION_P (newdecl
))
2323 DECL_NONCONVERTING_P (newdecl
) = DECL_NONCONVERTING_P (olddecl
);
2324 DECL_BEFRIENDING_CLASSES (newdecl
)
2325 = chainon (DECL_BEFRIENDING_CLASSES (newdecl
),
2326 DECL_BEFRIENDING_CLASSES (olddecl
));
2327 /* DECL_THUNKS is only valid for virtual functions,
2328 otherwise it is a DECL_FRIEND_CONTEXT. */
2329 if (DECL_VIRTUAL_P (newdecl
))
2330 SET_DECL_THUNKS (newdecl
, DECL_THUNKS (olddecl
));
2332 /* Only variables have this field. */
2333 else if (VAR_P (newdecl
)
2334 && VAR_HAD_UNKNOWN_BOUND (olddecl
))
2335 SET_VAR_HAD_UNKNOWN_BOUND (newdecl
);
2338 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
2342 /* Merge parameter attributes. */
2343 tree oldarg
, newarg
;
2344 for (oldarg
= DECL_ARGUMENTS(olddecl
),
2345 newarg
= DECL_ARGUMENTS(newdecl
);
2347 oldarg
= DECL_CHAIN(oldarg
), newarg
= DECL_CHAIN(newarg
)) {
2348 DECL_ATTRIBUTES (newarg
)
2349 = (*targetm
.merge_decl_attributes
) (oldarg
, newarg
);
2350 DECL_ATTRIBUTES (oldarg
) = DECL_ATTRIBUTES (newarg
);
2353 if (DECL_TEMPLATE_INSTANTIATION (olddecl
)
2354 && !DECL_TEMPLATE_INSTANTIATION (newdecl
))
2356 /* If newdecl is not a specialization, then it is not a
2357 template-related function at all. And that means that we
2358 should have exited above, returning 0. */
2359 gcc_assert (DECL_TEMPLATE_SPECIALIZATION (newdecl
));
2361 if (DECL_ODR_USED (olddecl
))
2362 /* From [temp.expl.spec]:
2364 If a template, a member template or the member of a class
2365 template is explicitly specialized then that
2366 specialization shall be declared before the first use of
2367 that specialization that would cause an implicit
2368 instantiation to take place, in every translation unit in
2369 which such a use occurs. */
2370 error ("explicit specialization of %qD after first use",
2373 SET_DECL_TEMPLATE_SPECIALIZATION (olddecl
);
2374 DECL_COMDAT (newdecl
) = (TREE_PUBLIC (newdecl
)
2375 && DECL_DECLARED_INLINE_P (newdecl
));
2377 /* Don't propagate visibility from the template to the
2378 specialization here. We'll do that in determine_visibility if
2380 DECL_VISIBILITY_SPECIFIED (olddecl
) = 0;
2382 /* [temp.expl.spec/14] We don't inline explicit specialization
2383 just because the primary template says so. */
2385 /* But still keep DECL_DISREGARD_INLINE_LIMITS in sync with
2386 the always_inline attribute. */
2387 if (DECL_DISREGARD_INLINE_LIMITS (olddecl
)
2388 && !DECL_DISREGARD_INLINE_LIMITS (newdecl
))
2390 if (DECL_DECLARED_INLINE_P (newdecl
))
2391 DECL_DISREGARD_INLINE_LIMITS (newdecl
) = true;
2393 DECL_ATTRIBUTES (newdecl
)
2394 = remove_attribute ("always_inline",
2395 DECL_ATTRIBUTES (newdecl
));
2398 else if (new_defines_function
&& DECL_INITIAL (olddecl
))
2400 /* Never inline re-defined extern inline functions.
2401 FIXME: this could be better handled by keeping both
2402 function as separate declarations. */
2403 DECL_UNINLINABLE (newdecl
) = 1;
2407 if (DECL_PENDING_INLINE_P (olddecl
))
2409 DECL_PENDING_INLINE_P (newdecl
) = 1;
2410 DECL_PENDING_INLINE_INFO (newdecl
)
2411 = DECL_PENDING_INLINE_INFO (olddecl
);
2413 else if (DECL_PENDING_INLINE_P (newdecl
))
2415 else if (DECL_SAVED_FUNCTION_DATA (newdecl
) == NULL
)
2416 DECL_SAVED_FUNCTION_DATA (newdecl
)
2417 = DECL_SAVED_FUNCTION_DATA (olddecl
);
2419 DECL_DECLARED_INLINE_P (newdecl
) |= DECL_DECLARED_INLINE_P (olddecl
);
2421 DECL_UNINLINABLE (newdecl
) = DECL_UNINLINABLE (olddecl
)
2422 = (DECL_UNINLINABLE (newdecl
) || DECL_UNINLINABLE (olddecl
));
2424 DECL_DISREGARD_INLINE_LIMITS (newdecl
)
2425 = DECL_DISREGARD_INLINE_LIMITS (olddecl
)
2426 = (DECL_DISREGARD_INLINE_LIMITS (newdecl
)
2427 || DECL_DISREGARD_INLINE_LIMITS (olddecl
));
2430 /* Preserve abstractness on cloned [cd]tors. */
2431 DECL_ABSTRACT_P (newdecl
) = DECL_ABSTRACT_P (olddecl
);
2433 /* Update newdecl's parms to point at olddecl. */
2434 for (parm
= DECL_ARGUMENTS (newdecl
); parm
;
2435 parm
= DECL_CHAIN (parm
))
2436 DECL_CONTEXT (parm
) = olddecl
;
2440 SET_DECL_LANGUAGE (olddecl
, DECL_LANGUAGE (newdecl
));
2441 COPY_DECL_ASSEMBLER_NAME (newdecl
, olddecl
);
2442 COPY_DECL_RTL (newdecl
, olddecl
);
2444 if (! types_match
|| new_defines_function
)
2446 /* These need to be copied so that the names are available.
2447 Note that if the types do match, we'll preserve inline
2448 info and other bits, but if not, we won't. */
2449 DECL_ARGUMENTS (olddecl
) = DECL_ARGUMENTS (newdecl
);
2450 DECL_RESULT (olddecl
) = DECL_RESULT (newdecl
);
2452 /* If redeclaring a builtin function, it stays built in
2453 if newdecl is a gnu_inline definition, or if newdecl is just
2455 if (DECL_BUILT_IN (olddecl
)
2456 && (new_defines_function
? GNU_INLINE_P (newdecl
) : types_match
))
2458 DECL_BUILT_IN_CLASS (newdecl
) = DECL_BUILT_IN_CLASS (olddecl
);
2459 DECL_FUNCTION_CODE (newdecl
) = DECL_FUNCTION_CODE (olddecl
);
2460 /* If we're keeping the built-in definition, keep the rtl,
2461 regardless of declaration matches. */
2462 COPY_DECL_RTL (olddecl
, newdecl
);
2463 if (DECL_BUILT_IN_CLASS (newdecl
) == BUILT_IN_NORMAL
)
2465 enum built_in_function fncode
= DECL_FUNCTION_CODE (newdecl
);
2468 /* If a compatible prototype of these builtin functions
2469 is seen, assume the runtime implements it with the
2470 expected semantics. */
2471 case BUILT_IN_STPCPY
:
2472 if (builtin_decl_explicit_p (fncode
))
2473 set_builtin_decl_implicit_p (fncode
, true);
2476 if (builtin_decl_explicit_p (fncode
))
2477 set_builtin_decl_declared_p (fncode
, true);
2482 copy_attributes_to_builtin (newdecl
);
2484 if (new_defines_function
)
2485 /* If defining a function declared with other language
2486 linkage, use the previously declared language linkage. */
2487 SET_DECL_LANGUAGE (newdecl
, DECL_LANGUAGE (olddecl
));
2488 else if (types_match
)
2490 DECL_RESULT (newdecl
) = DECL_RESULT (olddecl
);
2491 /* Don't clear out the arguments if we're just redeclaring a
2493 if (DECL_ARGUMENTS (olddecl
))
2494 DECL_ARGUMENTS (newdecl
) = DECL_ARGUMENTS (olddecl
);
2497 else if (TREE_CODE (newdecl
) == NAMESPACE_DECL
)
2498 NAMESPACE_LEVEL (newdecl
) = NAMESPACE_LEVEL (olddecl
);
2500 /* Now preserve various other info from the definition. */
2501 TREE_ADDRESSABLE (newdecl
) = TREE_ADDRESSABLE (olddecl
);
2502 TREE_ASM_WRITTEN (newdecl
) = TREE_ASM_WRITTEN (olddecl
);
2503 DECL_COMMON (newdecl
) = DECL_COMMON (olddecl
);
2504 COPY_DECL_ASSEMBLER_NAME (olddecl
, newdecl
);
2506 /* Warn about conflicting visibility specifications. */
2507 if (DECL_VISIBILITY_SPECIFIED (olddecl
)
2508 && DECL_VISIBILITY_SPECIFIED (newdecl
)
2509 && DECL_VISIBILITY (newdecl
) != DECL_VISIBILITY (olddecl
))
2511 if (warning_at (DECL_SOURCE_LOCATION (newdecl
), OPT_Wattributes
,
2512 "%qD: visibility attribute ignored because it "
2513 "conflicts with previous declaration", newdecl
))
2514 inform (DECL_SOURCE_LOCATION (olddecl
),
2515 "previous declaration of %qD", olddecl
);
2517 /* Choose the declaration which specified visibility. */
2518 if (DECL_VISIBILITY_SPECIFIED (olddecl
))
2520 DECL_VISIBILITY (newdecl
) = DECL_VISIBILITY (olddecl
);
2521 DECL_VISIBILITY_SPECIFIED (newdecl
) = 1;
2523 /* Init priority used to be merged from newdecl to olddecl by the memcpy,
2524 so keep this behavior. */
2525 if (VAR_P (newdecl
) && DECL_HAS_INIT_PRIORITY_P (newdecl
))
2527 SET_DECL_INIT_PRIORITY (olddecl
, DECL_INIT_PRIORITY (newdecl
));
2528 DECL_HAS_INIT_PRIORITY_P (olddecl
) = 1;
2530 /* Likewise for DECL_ALIGN, DECL_USER_ALIGN and DECL_PACKED. */
2531 if (DECL_ALIGN (olddecl
) > DECL_ALIGN (newdecl
))
2533 SET_DECL_ALIGN (newdecl
, DECL_ALIGN (olddecl
));
2534 DECL_USER_ALIGN (newdecl
) |= DECL_USER_ALIGN (olddecl
);
2536 DECL_USER_ALIGN (olddecl
) = DECL_USER_ALIGN (newdecl
);
2537 if (DECL_WARN_IF_NOT_ALIGN (olddecl
)
2538 > DECL_WARN_IF_NOT_ALIGN (newdecl
))
2539 SET_DECL_WARN_IF_NOT_ALIGN (newdecl
,
2540 DECL_WARN_IF_NOT_ALIGN (olddecl
));
2541 if (TREE_CODE (newdecl
) == FIELD_DECL
)
2542 DECL_PACKED (olddecl
) = DECL_PACKED (newdecl
);
2544 /* The DECL_LANG_SPECIFIC information in OLDDECL will be replaced
2545 with that from NEWDECL below. */
2546 if (DECL_LANG_SPECIFIC (olddecl
))
2548 gcc_assert (DECL_LANG_SPECIFIC (olddecl
)
2549 != DECL_LANG_SPECIFIC (newdecl
));
2550 ggc_free (DECL_LANG_SPECIFIC (olddecl
));
2553 /* Merge the USED information. */
2554 if (TREE_USED (olddecl
))
2555 TREE_USED (newdecl
) = 1;
2556 else if (TREE_USED (newdecl
))
2557 TREE_USED (olddecl
) = 1;
2558 if (VAR_P (newdecl
))
2560 if (DECL_READ_P (olddecl
))
2561 DECL_READ_P (newdecl
) = 1;
2562 else if (DECL_READ_P (newdecl
))
2563 DECL_READ_P (olddecl
) = 1;
2565 if (DECL_PRESERVE_P (olddecl
))
2566 DECL_PRESERVE_P (newdecl
) = 1;
2567 else if (DECL_PRESERVE_P (newdecl
))
2568 DECL_PRESERVE_P (olddecl
) = 1;
2570 /* Merge the DECL_FUNCTION_VERSIONED information. newdecl will be copied
2571 to olddecl and deleted. */
2572 if (TREE_CODE (newdecl
) == FUNCTION_DECL
2573 && DECL_FUNCTION_VERSIONED (olddecl
))
2575 /* Set the flag for newdecl so that it gets copied to olddecl. */
2576 DECL_FUNCTION_VERSIONED (newdecl
) = 1;
2577 /* newdecl will be purged after copying to olddecl and is no longer
2579 cgraph_node::delete_function_version_by_decl (newdecl
);
2582 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
2585 struct symtab_node
*snode
= symtab_node::get (olddecl
);
2587 function_size
= sizeof (struct tree_decl_common
);
2589 memcpy ((char *) olddecl
+ sizeof (struct tree_common
),
2590 (char *) newdecl
+ sizeof (struct tree_common
),
2591 function_size
- sizeof (struct tree_common
));
2593 memcpy ((char *) olddecl
+ sizeof (struct tree_decl_common
),
2594 (char *) newdecl
+ sizeof (struct tree_decl_common
),
2595 sizeof (struct tree_function_decl
) - sizeof (struct tree_decl_common
));
2597 /* Preserve symtab node mapping. */
2598 olddecl
->decl_with_vis
.symtab_node
= snode
;
2600 if (new_template_info
)
2601 /* If newdecl is a template instantiation, it is possible that
2602 the following sequence of events has occurred:
2604 o A friend function was declared in a class template. The
2605 class template was instantiated.
2607 o The instantiation of the friend declaration was
2608 recorded on the instantiation list, and is newdecl.
2610 o Later, however, instantiate_class_template called pushdecl
2611 on the newdecl to perform name injection. But, pushdecl in
2612 turn called duplicate_decls when it discovered that another
2613 declaration of a global function with the same name already
2616 o Here, in duplicate_decls, we decided to clobber newdecl.
2618 If we're going to do that, we'd better make sure that
2619 olddecl, and not newdecl, is on the list of
2620 instantiations so that if we try to do the instantiation
2621 again we won't get the clobbered declaration. */
2622 reregister_specialization (newdecl
,
2628 size_t size
= tree_code_size (TREE_CODE (newdecl
));
2630 memcpy ((char *) olddecl
+ sizeof (struct tree_common
),
2631 (char *) newdecl
+ sizeof (struct tree_common
),
2632 sizeof (struct tree_decl_common
) - sizeof (struct tree_common
));
2633 switch (TREE_CODE (newdecl
))
2643 struct symtab_node
*snode
= NULL
;
2646 && (TREE_STATIC (olddecl
) || TREE_PUBLIC (olddecl
)
2647 || DECL_EXTERNAL (olddecl
)))
2648 snode
= symtab_node::get (olddecl
);
2649 memcpy ((char *) olddecl
+ sizeof (struct tree_decl_common
),
2650 (char *) newdecl
+ sizeof (struct tree_decl_common
),
2651 size
- sizeof (struct tree_decl_common
)
2652 + TREE_CODE_LENGTH (TREE_CODE (newdecl
)) * sizeof (char *));
2653 if (VAR_P (newdecl
))
2654 olddecl
->decl_with_vis
.symtab_node
= snode
;
2658 memcpy ((char *) olddecl
+ sizeof (struct tree_decl_common
),
2659 (char *) newdecl
+ sizeof (struct tree_decl_common
),
2660 sizeof (struct tree_decl_non_common
) - sizeof (struct tree_decl_common
)
2661 + TREE_CODE_LENGTH (TREE_CODE (newdecl
)) * sizeof (char *));
2666 if (VAR_OR_FUNCTION_DECL_P (newdecl
))
2668 if (DECL_EXTERNAL (olddecl
)
2669 || TREE_PUBLIC (olddecl
)
2670 || TREE_STATIC (olddecl
))
2672 /* Merge the section attribute.
2673 We want to issue an error if the sections conflict but that must be
2674 done later in decl_attributes since we are called before attributes
2676 if (DECL_SECTION_NAME (newdecl
) != NULL
)
2677 set_decl_section_name (olddecl
, DECL_SECTION_NAME (newdecl
));
2679 if (DECL_ONE_ONLY (newdecl
))
2681 struct symtab_node
*oldsym
, *newsym
;
2682 if (TREE_CODE (olddecl
) == FUNCTION_DECL
)
2683 oldsym
= cgraph_node::get_create (olddecl
);
2685 oldsym
= varpool_node::get_create (olddecl
);
2686 newsym
= symtab_node::get (newdecl
);
2687 oldsym
->set_comdat_group (newsym
->get_comdat_group ());
2692 && CP_DECL_THREAD_LOCAL_P (newdecl
))
2694 CP_DECL_THREAD_LOCAL_P (olddecl
) = true;
2695 if (!processing_template_decl
)
2696 set_decl_tls_model (olddecl
, DECL_TLS_MODEL (newdecl
));
2700 DECL_UID (olddecl
) = olddecl_uid
;
2702 DECL_FRIEND_P (olddecl
) = 1;
2705 DECL_ANTICIPATED (olddecl
) = 1;
2706 DECL_HIDDEN_FRIEND_P (olddecl
) = 1;
2709 /* NEWDECL contains the merged attribute lists.
2710 Update OLDDECL to be the same. */
2711 DECL_ATTRIBUTES (olddecl
) = DECL_ATTRIBUTES (newdecl
);
2713 /* If OLDDECL had its DECL_RTL instantiated, re-invoke make_decl_rtl
2714 so that encode_section_info has a chance to look at the new decl
2715 flags and attributes. */
2716 if (DECL_RTL_SET_P (olddecl
)
2717 && (TREE_CODE (olddecl
) == FUNCTION_DECL
2719 && TREE_STATIC (olddecl
))))
2720 make_decl_rtl (olddecl
);
2722 /* The NEWDECL will no longer be needed. Because every out-of-class
2723 declaration of a member results in a call to duplicate_decls,
2724 freeing these nodes represents in a significant savings.
2726 Before releasing the node, be sore to remove function from symbol
2727 table that might have been inserted there to record comdat group.
2728 Be sure to however do not free DECL_STRUCT_FUNCTION because this
2729 structure is shared in between newdecl and oldecl. */
2730 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
2731 DECL_STRUCT_FUNCTION (newdecl
) = NULL
;
2732 if (VAR_OR_FUNCTION_DECL_P (newdecl
))
2734 struct symtab_node
*snode
= symtab_node::get (newdecl
);
2739 /* Remove the associated constraints for newdecl, if any, before
2740 reclaiming memory. */
2742 remove_constraints (newdecl
);
2749 /* Return zero if the declaration NEWDECL is valid
2750 when the declaration OLDDECL (assumed to be for the same name)
2751 has already been seen.
2752 Otherwise return an error message format string with a %s
2753 where the identifier should go. */
2756 redeclaration_error_message (tree newdecl
, tree olddecl
)
2758 if (TREE_CODE (newdecl
) == TYPE_DECL
)
2760 /* Because C++ can put things into name space for free,
2761 constructs like "typedef struct foo { ... } foo"
2762 would look like an erroneous redeclaration. */
2763 if (same_type_p (TREE_TYPE (newdecl
), TREE_TYPE (olddecl
)))
2766 return G_("redefinition of %q#D");
2768 else if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
2770 /* If this is a pure function, its olddecl will actually be
2771 the original initialization to `0' (which we force to call
2772 abort()). Don't complain about redefinition in this case. */
2773 if (DECL_LANG_SPECIFIC (olddecl
) && DECL_PURE_VIRTUAL_P (olddecl
)
2774 && DECL_INITIAL (olddecl
) == NULL_TREE
)
2777 /* If both functions come from different namespaces, this is not
2778 a redeclaration - this is a conflict with a used function. */
2779 if (DECL_NAMESPACE_SCOPE_P (olddecl
)
2780 && DECL_CONTEXT (olddecl
) != DECL_CONTEXT (newdecl
)
2781 && ! decls_match (olddecl
, newdecl
))
2782 return G_("%qD conflicts with used function");
2784 /* We'll complain about linkage mismatches in
2785 warn_extern_redeclared_static. */
2787 /* Defining the same name twice is no good. */
2788 if (decl_defined_p (olddecl
)
2789 && decl_defined_p (newdecl
))
2791 if (DECL_NAME (olddecl
) == NULL_TREE
)
2792 return G_("%q#D not declared in class");
2793 else if (!GNU_INLINE_P (olddecl
)
2794 || GNU_INLINE_P (newdecl
))
2795 return G_("redefinition of %q#D");
2798 if (DECL_DECLARED_INLINE_P (olddecl
) && DECL_DECLARED_INLINE_P (newdecl
))
2800 bool olda
= GNU_INLINE_P (olddecl
);
2801 bool newa
= GNU_INLINE_P (newdecl
);
2806 return G_("%q+D redeclared inline with "
2807 "%<gnu_inline%> attribute");
2809 return G_("%q+D redeclared inline without "
2810 "%<gnu_inline%> attribute");
2814 check_abi_tag_redeclaration
2815 (olddecl
, lookup_attribute ("abi_tag", DECL_ATTRIBUTES (olddecl
)),
2816 lookup_attribute ("abi_tag", DECL_ATTRIBUTES (newdecl
)));
2820 else if (TREE_CODE (newdecl
) == TEMPLATE_DECL
)
2824 if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl
)) == TYPE_DECL
)
2826 if (COMPLETE_TYPE_P (TREE_TYPE (newdecl
))
2827 && COMPLETE_TYPE_P (TREE_TYPE (olddecl
)))
2828 return G_("redefinition of %q#D");
2832 if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl
)) != FUNCTION_DECL
2833 || (DECL_TEMPLATE_RESULT (newdecl
)
2834 == DECL_TEMPLATE_RESULT (olddecl
)))
2837 nt
= DECL_TEMPLATE_RESULT (newdecl
);
2838 if (DECL_TEMPLATE_INFO (nt
))
2839 nt
= DECL_TEMPLATE_RESULT (template_for_substitution (nt
));
2840 ot
= DECL_TEMPLATE_RESULT (olddecl
);
2841 if (DECL_TEMPLATE_INFO (ot
))
2842 ot
= DECL_TEMPLATE_RESULT (template_for_substitution (ot
));
2843 if (DECL_INITIAL (nt
) && DECL_INITIAL (ot
)
2844 && (!GNU_INLINE_P (ot
) || GNU_INLINE_P (nt
)))
2845 return G_("redefinition of %q#D");
2847 if (DECL_DECLARED_INLINE_P (ot
) && DECL_DECLARED_INLINE_P (nt
))
2849 bool olda
= GNU_INLINE_P (ot
);
2850 bool newa
= GNU_INLINE_P (nt
);
2855 return G_("%q+D redeclared inline with "
2856 "%<gnu_inline%> attribute");
2858 return G_("%q+D redeclared inline without "
2859 "%<gnu_inline%> attribute");
2863 /* Core issue #226 (C++0x):
2865 If a friend function template declaration specifies a
2866 default template-argument, that declaration shall be a
2867 definition and shall be the only declaration of the
2868 function template in the translation unit. */
2869 if ((cxx_dialect
!= cxx98
)
2870 && TREE_CODE (ot
) == FUNCTION_DECL
&& DECL_FRIEND_P (ot
)
2871 && !check_default_tmpl_args (nt
, DECL_TEMPLATE_PARMS (newdecl
),
2872 /*is_primary=*/true,
2873 /*is_partial=*/false,
2874 /*is_friend_decl=*/2))
2875 return G_("redeclaration of friend %q#D "
2876 "may not have default template arguments");
2880 else if (VAR_P (newdecl
)
2881 && CP_DECL_THREAD_LOCAL_P (newdecl
) != CP_DECL_THREAD_LOCAL_P (olddecl
)
2882 && (! DECL_LANG_SPECIFIC (olddecl
)
2883 || ! CP_DECL_THREADPRIVATE_P (olddecl
)
2884 || CP_DECL_THREAD_LOCAL_P (newdecl
)))
2886 /* Only variables can be thread-local, and all declarations must
2887 agree on this property. */
2888 if (CP_DECL_THREAD_LOCAL_P (newdecl
))
2889 return G_("thread-local declaration of %q#D follows "
2890 "non-thread-local declaration");
2892 return G_("non-thread-local declaration of %q#D follows "
2893 "thread-local declaration");
2895 else if (toplevel_bindings_p () || DECL_NAMESPACE_SCOPE_P (newdecl
))
2897 /* The objects have been declared at namespace scope. If either
2898 is a member of an anonymous union, then this is an invalid
2899 redeclaration. For example:
2905 if ((VAR_P (newdecl
) && DECL_ANON_UNION_VAR_P (newdecl
))
2906 || (VAR_P (olddecl
) && DECL_ANON_UNION_VAR_P (olddecl
)))
2907 return G_("redeclaration of %q#D");
2908 /* If at least one declaration is a reference, there is no
2909 conflict. For example:
2915 if (DECL_EXTERNAL (newdecl
) || DECL_EXTERNAL (olddecl
))
2918 /* Static data member declared outside a class definition
2919 if the variable is defined within the class with constexpr
2920 specifier is declaration rather than definition (and
2922 if (cxx_dialect
>= cxx17
2923 && DECL_CLASS_SCOPE_P (olddecl
)
2924 && DECL_DECLARED_CONSTEXPR_P (olddecl
)
2925 && !DECL_INITIAL (newdecl
))
2927 DECL_EXTERNAL (newdecl
) = 1;
2928 /* For now, only warn with explicit -Wdeprecated. */
2929 if (global_options_set
.x_warn_deprecated
2930 && warning_at (DECL_SOURCE_LOCATION (newdecl
), OPT_Wdeprecated
,
2931 "redundant redeclaration of %<constexpr%> static "
2932 "data member %qD", newdecl
))
2933 inform (DECL_SOURCE_LOCATION (olddecl
),
2934 "previous declaration of %qD", olddecl
);
2938 /* Reject two definitions. */
2939 return G_("redefinition of %q#D");
2943 /* Objects declared with block scope: */
2944 /* Reject two definitions, and reject a definition
2945 together with an external reference. */
2946 if (!(DECL_EXTERNAL (newdecl
) && DECL_EXTERNAL (olddecl
)))
2947 return G_("redeclaration of %q#D");
2953 /* Hash and equality functions for the named_label table. */
2956 named_label_hash::hash (const value_type entry
)
2958 return IDENTIFIER_HASH_VALUE (entry
->name
);
2962 named_label_hash::equal (const value_type entry
, compare_type name
)
2964 return name
== entry
->name
;
2967 /* Look for a label named ID in the current function. If one cannot
2968 be found, create one. Return the named_label_entry, or NULL on
2971 static named_label_entry
*
2972 lookup_label_1 (tree id
, bool making_local_p
)
2974 /* You can't use labels at global scope. */
2975 if (current_function_decl
== NULL_TREE
)
2977 error ("label %qE referenced outside of any function", id
);
2982 named_labels
= hash_table
<named_label_hash
>::create_ggc (13);
2984 hashval_t hash
= IDENTIFIER_HASH_VALUE (id
);
2985 named_label_entry
**slot
2986 = named_labels
->find_slot_with_hash (id
, hash
, INSERT
);
2987 named_label_entry
*old
= *slot
;
2989 if (old
&& old
->label_decl
)
2991 if (!making_local_p
)
2994 if (old
->binding_level
== current_binding_level
)
2996 error ("local label %qE conflicts with existing label", id
);
2997 inform (DECL_SOURCE_LOCATION (old
->label_decl
), "previous label");
3002 /* We are making a new decl, create or reuse the named_label_entry */
3003 named_label_entry
*ent
= NULL
;
3004 if (old
&& !old
->label_decl
)
3008 ent
= ggc_cleared_alloc
<named_label_entry
> ();
3014 /* Now create the LABEL_DECL. */
3015 tree decl
= build_decl (input_location
, LABEL_DECL
, id
, void_type_node
);
3017 DECL_CONTEXT (decl
) = current_function_decl
;
3018 SET_DECL_MODE (decl
, VOIDmode
);
3021 C_DECLARED_LABEL_FLAG (decl
) = true;
3022 DECL_CHAIN (decl
) = current_binding_level
->names
;
3023 current_binding_level
->names
= decl
;
3026 ent
->label_decl
= decl
;
3031 /* Wrapper for lookup_label_1. */
3034 lookup_label (tree id
)
3036 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
3037 named_label_entry
*ent
= lookup_label_1 (id
, false);
3038 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
3039 return ent
? ent
->label_decl
: NULL_TREE
;
3043 declare_local_label (tree id
)
3045 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
3046 named_label_entry
*ent
= lookup_label_1 (id
, true);
3047 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
3048 return ent
? ent
->label_decl
: NULL_TREE
;
3051 /* Returns nonzero if it is ill-formed to jump past the declaration of
3052 DECL. Returns 2 if it's also a real problem. */
3055 decl_jump_unsafe (tree decl
)
3057 /* [stmt.dcl]/3: A program that jumps from a point where a local variable
3058 with automatic storage duration is not in scope to a point where it is
3059 in scope is ill-formed unless the variable has scalar type, class type
3060 with a trivial default constructor and a trivial destructor, a
3061 cv-qualified version of one of these types, or an array of one of the
3062 preceding types and is declared without an initializer (8.5). */
3063 tree type
= TREE_TYPE (decl
);
3065 if (!VAR_P (decl
) || TREE_STATIC (decl
)
3066 || type
== error_mark_node
)
3069 if (DECL_NONTRIVIALLY_INITIALIZED_P (decl
)
3070 || variably_modified_type_p (type
, NULL_TREE
))
3073 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
))
3079 /* A subroutine of check_previous_goto_1 and check_goto to identify a branch
3083 identify_goto (tree decl
, location_t loc
, const location_t
*locus
,
3084 diagnostic_t diag_kind
)
3087 = emit_diagnostic (diag_kind
, loc
, 0,
3088 decl
? N_("jump to label %qD")
3089 : N_("jump to case label"), decl
);
3090 if (complained
&& locus
)
3091 inform (*locus
, " from here");
3095 /* Check that a single previously seen jump to a newly defined label
3096 is OK. DECL is the LABEL_DECL or 0; LEVEL is the binding_level for
3097 the jump context; NAMES are the names in scope in LEVEL at the jump
3098 context; LOCUS is the source position of the jump or 0. Returns
3099 true if all is well. */
3102 check_previous_goto_1 (tree decl
, cp_binding_level
* level
, tree names
,
3103 bool exited_omp
, const location_t
*locus
)
3105 cp_binding_level
*b
;
3106 bool complained
= false;
3108 bool saw_eh
= false, saw_omp
= false, saw_tm
= false, saw_cxif
= false;
3112 complained
= identify_goto (decl
, input_location
, locus
, DK_ERROR
);
3114 inform (input_location
, " exits OpenMP structured block");
3119 for (b
= current_binding_level
; b
; b
= b
->level_chain
)
3121 tree new_decls
, old_decls
= (b
== level
? names
: NULL_TREE
);
3123 for (new_decls
= b
->names
; new_decls
!= old_decls
;
3124 new_decls
= (DECL_P (new_decls
) ? DECL_CHAIN (new_decls
)
3125 : TREE_CHAIN (new_decls
)))
3127 int problem
= decl_jump_unsafe (new_decls
);
3133 complained
= identify_goto (decl
, input_location
, locus
,
3140 inform (DECL_SOURCE_LOCATION (new_decls
),
3141 " crosses initialization of %q#D", new_decls
);
3143 inform (DECL_SOURCE_LOCATION (new_decls
),
3144 " enters scope of %q#D, which has "
3145 "non-trivial destructor", new_decls
);
3152 const char *inf
= NULL
;
3153 location_t loc
= input_location
;
3158 inf
= N_("enters try block");
3164 inf
= N_("enters catch block");
3170 inf
= N_("enters OpenMP structured block");
3174 case sk_transaction
:
3176 inf
= N_("enters synchronized or atomic statement");
3181 if (!saw_cxif
&& level_for_constexpr_if (b
->level_chain
))
3183 inf
= N_("enters constexpr if statement");
3184 loc
= EXPR_LOCATION (b
->level_chain
->this_entity
);
3196 complained
= identify_goto (decl
, input_location
, locus
, DK_ERROR
);
3199 inform (loc
, " %s", inf
);
3207 check_previous_goto (tree decl
, struct named_label_use_entry
*use
)
3209 check_previous_goto_1 (decl
, use
->binding_level
,
3210 use
->names_in_scope
, use
->in_omp_scope
,
3211 &use
->o_goto_locus
);
3215 check_switch_goto (cp_binding_level
* level
)
3217 return check_previous_goto_1 (NULL_TREE
, level
, level
->names
, false, NULL
);
3220 /* Check that a new jump to a label DECL is OK. Called by
3221 finish_goto_stmt. */
3224 check_goto (tree decl
)
3226 /* We can't know where a computed goto is jumping.
3227 So we assume that it's OK. */
3228 if (TREE_CODE (decl
) != LABEL_DECL
)
3231 /* We didn't record any information about this label when we created it,
3232 and there's not much point since it's trivial to analyze as a return. */
3233 if (decl
== cdtor_label
)
3236 hashval_t hash
= IDENTIFIER_HASH_VALUE (DECL_NAME (decl
));
3237 named_label_entry
**slot
3238 = named_labels
->find_slot_with_hash (DECL_NAME (decl
), hash
, NO_INSERT
);
3239 named_label_entry
*ent
= *slot
;
3241 /* If the label hasn't been defined yet, defer checking. */
3242 if (! DECL_INITIAL (decl
))
3244 /* Don't bother creating another use if the last goto had the
3245 same data, and will therefore create the same set of errors. */
3247 && ent
->uses
->names_in_scope
== current_binding_level
->names
)
3250 named_label_use_entry
*new_use
3251 = ggc_alloc
<named_label_use_entry
> ();
3252 new_use
->binding_level
= current_binding_level
;
3253 new_use
->names_in_scope
= current_binding_level
->names
;
3254 new_use
->o_goto_locus
= input_location
;
3255 new_use
->in_omp_scope
= false;
3257 new_use
->next
= ent
->uses
;
3258 ent
->uses
= new_use
;
3262 bool saw_catch
= false, complained
= false;
3267 if (ent
->in_try_scope
|| ent
->in_catch_scope
|| ent
->in_transaction_scope
3268 || ent
->in_constexpr_if
3269 || ent
->in_omp_scope
|| !vec_safe_is_empty (ent
->bad_decls
))
3271 diagnostic_t diag_kind
= DK_PERMERROR
;
3272 if (ent
->in_try_scope
|| ent
->in_catch_scope
|| ent
->in_constexpr_if
3273 || ent
->in_transaction_scope
|| ent
->in_omp_scope
)
3274 diag_kind
= DK_ERROR
;
3275 complained
= identify_goto (decl
, DECL_SOURCE_LOCATION (decl
),
3276 &input_location
, diag_kind
);
3277 identified
= 1 + (diag_kind
== DK_ERROR
);
3280 FOR_EACH_VEC_SAFE_ELT (ent
->bad_decls
, ix
, bad
)
3282 int u
= decl_jump_unsafe (bad
);
3284 if (u
> 1 && DECL_ARTIFICIAL (bad
))
3286 /* Can't skip init of __exception_info. */
3287 if (identified
== 1)
3289 complained
= identify_goto (decl
, DECL_SOURCE_LOCATION (decl
),
3290 &input_location
, DK_ERROR
);
3294 inform (DECL_SOURCE_LOCATION (bad
), " enters catch block");
3297 else if (complained
)
3300 inform (DECL_SOURCE_LOCATION (bad
),
3301 " skips initialization of %q#D", bad
);
3303 inform (DECL_SOURCE_LOCATION (bad
),
3304 " enters scope of %q#D which has "
3305 "non-trivial destructor", bad
);
3311 if (ent
->in_try_scope
)
3312 inform (input_location
, " enters try block");
3313 else if (ent
->in_catch_scope
&& !saw_catch
)
3314 inform (input_location
, " enters catch block");
3315 else if (ent
->in_transaction_scope
)
3316 inform (input_location
, " enters synchronized or atomic statement");
3317 else if (ent
->in_constexpr_if
)
3318 inform (input_location
, " enters constexpr if statement");
3321 if (ent
->in_omp_scope
)
3324 inform (input_location
, " enters OpenMP structured block");
3326 else if (flag_openmp
)
3327 for (cp_binding_level
*b
= current_binding_level
; b
; b
= b
->level_chain
)
3329 if (b
== ent
->binding_level
)
3331 if (b
->kind
== sk_omp
)
3335 complained
= identify_goto (decl
,
3336 DECL_SOURCE_LOCATION (decl
),
3337 &input_location
, DK_ERROR
);
3341 inform (input_location
, " exits OpenMP structured block");
3347 /* Check that a return is ok wrt OpenMP structured blocks.
3348 Called by finish_return_stmt. Returns true if all is well. */
3351 check_omp_return (void)
3353 for (cp_binding_level
*b
= current_binding_level
; b
; b
= b
->level_chain
)
3354 if (b
->kind
== sk_omp
)
3356 error ("invalid exit from OpenMP structured block");
3359 else if (b
->kind
== sk_function_parms
)
3364 /* Define a label, specifying the location in the source file.
3365 Return the LABEL_DECL node for the label. */
3368 define_label_1 (location_t location
, tree name
)
3370 /* After labels, make any new cleanups in the function go into their
3371 own new (temporary) binding contour. */
3372 for (cp_binding_level
*p
= current_binding_level
;
3373 p
->kind
!= sk_function_parms
;
3375 p
->more_cleanups_ok
= 0;
3377 named_label_entry
*ent
= lookup_label_1 (name
, false);
3378 tree decl
= ent
->label_decl
;
3380 if (DECL_INITIAL (decl
) != NULL_TREE
)
3382 error ("duplicate label %qD", decl
);
3383 return error_mark_node
;
3387 /* Mark label as having been defined. */
3388 DECL_INITIAL (decl
) = error_mark_node
;
3389 /* Say where in the source. */
3390 DECL_SOURCE_LOCATION (decl
) = location
;
3392 ent
->binding_level
= current_binding_level
;
3393 ent
->names_in_scope
= current_binding_level
->names
;
3395 for (named_label_use_entry
*use
= ent
->uses
; use
; use
= use
->next
)
3396 check_previous_goto (decl
, use
);
3403 /* Wrapper for define_label_1. */
3406 define_label (location_t location
, tree name
)
3408 bool running
= timevar_cond_start (TV_NAME_LOOKUP
);
3409 tree ret
= define_label_1 (location
, name
);
3410 timevar_cond_stop (TV_NAME_LOOKUP
, running
);
3417 cp_binding_level
*level
;
3418 struct cp_switch
*next
;
3419 /* The SWITCH_STMT being built. */
3421 /* A splay-tree mapping the low element of a case range to the high
3422 element, or NULL_TREE if there is no high element. Used to
3423 determine whether or not a new case label duplicates an old case
3424 label. We need a tree, rather than simply a hash table, because
3425 of the GNU case range extension. */
3427 /* Remember whether there was a case value that is outside the
3428 range of the original type of the controlling expression. */
3429 bool outside_range_p
;
3432 /* A stack of the currently active switch statements. The innermost
3433 switch statement is on the top of the stack. There is no need to
3434 mark the stack for garbage collection because it is only active
3435 during the processing of the body of a function, and we never
3436 collect at that point. */
3438 static struct cp_switch
*switch_stack
;
3440 /* Called right after a switch-statement condition is parsed.
3441 SWITCH_STMT is the switch statement being parsed. */
3444 push_switch (tree switch_stmt
)
3446 struct cp_switch
*p
= XNEW (struct cp_switch
);
3447 p
->level
= current_binding_level
;
3448 p
->next
= switch_stack
;
3449 p
->switch_stmt
= switch_stmt
;
3450 p
->cases
= splay_tree_new (case_compare
, NULL
, NULL
);
3451 p
->outside_range_p
= false;
3458 struct cp_switch
*cs
= switch_stack
;
3459 location_t switch_location
;
3461 /* Emit warnings as needed. */
3462 switch_location
= EXPR_LOC_OR_LOC (cs
->switch_stmt
, input_location
);
3463 const bool bool_cond_p
3464 = (SWITCH_STMT_TYPE (cs
->switch_stmt
)
3465 && TREE_CODE (SWITCH_STMT_TYPE (cs
->switch_stmt
)) == BOOLEAN_TYPE
);
3466 if (!processing_template_decl
)
3467 c_do_switch_warnings (cs
->cases
, switch_location
,
3468 SWITCH_STMT_TYPE (cs
->switch_stmt
),
3469 SWITCH_STMT_COND (cs
->switch_stmt
),
3470 bool_cond_p
, cs
->outside_range_p
);
3472 splay_tree_delete (cs
->cases
);
3473 switch_stack
= switch_stack
->next
;
3477 /* Convert a case constant VALUE in a switch to the type TYPE of the switch
3478 condition. Note that if TYPE and VALUE are already integral we don't
3479 really do the conversion because the language-independent
3480 warning/optimization code will work better that way. */
3483 case_conversion (tree type
, tree value
)
3485 if (value
== NULL_TREE
)
3488 if (cxx_dialect
>= cxx11
3489 && (SCOPED_ENUM_P (type
)
3490 || !INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (TREE_TYPE (value
))))
3492 if (INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type
))
3493 type
= type_promotes_to (type
);
3494 value
= (perform_implicit_conversion_flags
3495 (type
, value
, tf_warning_or_error
,
3496 LOOKUP_IMPLICIT
| LOOKUP_NO_NON_INTEGRAL
));
3498 return cxx_constant_value (value
);
3501 /* Note that we've seen a definition of a case label, and complain if this
3502 is a bad place for one. */
3505 finish_case_label (location_t loc
, tree low_value
, tree high_value
)
3508 cp_binding_level
*p
;
3511 if (processing_template_decl
)
3515 /* For templates, just add the case label; we'll do semantic
3516 analysis at instantiation-time. */
3517 label
= build_decl (loc
, LABEL_DECL
, NULL_TREE
, NULL_TREE
);
3518 return add_stmt (build_case_label (low_value
, high_value
, label
));
3521 /* Find the condition on which this switch statement depends. */
3522 cond
= SWITCH_STMT_COND (switch_stack
->switch_stmt
);
3523 if (cond
&& TREE_CODE (cond
) == TREE_LIST
)
3524 cond
= TREE_VALUE (cond
);
3526 if (!check_switch_goto (switch_stack
->level
))
3527 return error_mark_node
;
3529 type
= SWITCH_STMT_TYPE (switch_stack
->switch_stmt
);
3531 low_value
= case_conversion (type
, low_value
);
3532 high_value
= case_conversion (type
, high_value
);
3534 r
= c_add_case_label (loc
, switch_stack
->cases
, cond
, type
,
3535 low_value
, high_value
,
3536 &switch_stack
->outside_range_p
);
3538 /* After labels, make any new cleanups in the function go into their
3539 own new (temporary) binding contour. */
3540 for (p
= current_binding_level
;
3541 p
->kind
!= sk_function_parms
;
3543 p
->more_cleanups_ok
= 0;
3548 struct typename_info
{
3556 struct typename_hasher
: ggc_ptr_hash
<tree_node
>
3558 typedef typename_info
*compare_type
;
3560 /* Hash a TYPENAME_TYPE. */
3567 hash
= (htab_hash_pointer (TYPE_CONTEXT (t
))
3568 ^ htab_hash_pointer (TYPE_IDENTIFIER (t
)));
3573 /* Compare two TYPENAME_TYPEs. */
3576 equal (tree t1
, const typename_info
*t2
)
3578 return (TYPE_IDENTIFIER (t1
) == t2
->name
3579 && TYPE_CONTEXT (t1
) == t2
->scope
3580 && TYPENAME_TYPE_FULLNAME (t1
) == t2
->template_id
3581 && TYPENAME_IS_ENUM_P (t1
) == t2
->enum_p
3582 && TYPENAME_IS_CLASS_P (t1
) == t2
->class_p
);
3586 /* Build a TYPENAME_TYPE. If the type is `typename T::t', CONTEXT is
3587 the type of `T', NAME is the IDENTIFIER_NODE for `t'.
3589 Returns the new TYPENAME_TYPE. */
3591 static GTY (()) hash_table
<typename_hasher
> *typename_htab
;
3594 build_typename_type (tree context
, tree name
, tree fullname
,
3595 enum tag_types tag_type
)
3603 if (typename_htab
== NULL
)
3604 typename_htab
= hash_table
<typename_hasher
>::create_ggc (61);
3606 ti
.scope
= FROB_CONTEXT (context
);
3608 ti
.template_id
= fullname
;
3609 ti
.enum_p
= tag_type
== enum_type
;
3610 ti
.class_p
= (tag_type
== class_type
3611 || tag_type
== record_type
3612 || tag_type
== union_type
);
3613 hash
= (htab_hash_pointer (ti
.scope
)
3614 ^ htab_hash_pointer (ti
.name
));
3616 /* See if we already have this type. */
3617 e
= typename_htab
->find_slot_with_hash (&ti
, hash
, INSERT
);
3622 /* Build the TYPENAME_TYPE. */
3623 t
= cxx_make_type (TYPENAME_TYPE
);
3624 TYPE_CONTEXT (t
) = ti
.scope
;
3625 TYPENAME_TYPE_FULLNAME (t
) = ti
.template_id
;
3626 TYPENAME_IS_ENUM_P (t
) = ti
.enum_p
;
3627 TYPENAME_IS_CLASS_P (t
) = ti
.class_p
;
3629 /* Build the corresponding TYPE_DECL. */
3630 d
= build_decl (input_location
, TYPE_DECL
, name
, t
);
3631 TYPE_NAME (TREE_TYPE (d
)) = d
;
3632 TYPE_STUB_DECL (TREE_TYPE (d
)) = d
;
3633 DECL_CONTEXT (d
) = FROB_CONTEXT (context
);
3634 DECL_ARTIFICIAL (d
) = 1;
3636 /* Store it in the hash table. */
3639 /* TYPENAME_TYPEs must always be compared structurally, because
3640 they may or may not resolve down to another type depending on
3641 the currently open classes. */
3642 SET_TYPE_STRUCTURAL_EQUALITY (t
);
3648 /* Resolve `typename CONTEXT::NAME'. TAG_TYPE indicates the tag
3649 provided to name the type. Returns an appropriate type, unless an
3650 error occurs, in which case error_mark_node is returned. If we
3651 locate a non-artificial TYPE_DECL and TF_KEEP_TYPE_DECL is set, we
3652 return that, rather than the _TYPE it corresponds to, in other
3653 cases we look through the type decl. If TF_ERROR is set, complain
3654 about errors, otherwise be quiet. */
3657 make_typename_type (tree context
, tree name
, enum tag_types tag_type
,
3658 tsubst_flags_t complain
)
3664 if (name
== error_mark_node
3665 || context
== NULL_TREE
3666 || context
== error_mark_node
)
3667 return error_mark_node
;
3671 if (!(TYPE_LANG_SPECIFIC (name
)
3672 && (CLASSTYPE_IS_TEMPLATE (name
)
3673 || CLASSTYPE_USE_TEMPLATE (name
))))
3674 name
= TYPE_IDENTIFIER (name
);
3676 /* Create a TEMPLATE_ID_EXPR for the type. */
3677 name
= build_nt (TEMPLATE_ID_EXPR
,
3678 CLASSTYPE_TI_TEMPLATE (name
),
3679 CLASSTYPE_TI_ARGS (name
));
3681 else if (TREE_CODE (name
) == TYPE_DECL
)
3682 name
= DECL_NAME (name
);
3686 if (TREE_CODE (name
) == TEMPLATE_ID_EXPR
)
3688 name
= TREE_OPERAND (name
, 0);
3689 if (DECL_TYPE_TEMPLATE_P (name
))
3690 name
= TREE_OPERAND (fullname
, 0) = DECL_NAME (name
);
3691 if (TREE_CODE (name
) != IDENTIFIER_NODE
)
3693 if (complain
& tf_error
)
3694 error ("%qD is not a type", name
);
3695 return error_mark_node
;
3698 if (TREE_CODE (name
) == TEMPLATE_DECL
)
3700 if (complain
& tf_error
)
3701 error ("%qD used without template parameters", name
);
3702 return error_mark_node
;
3704 gcc_assert (identifier_p (name
));
3705 gcc_assert (TYPE_P (context
));
3707 if (!MAYBE_CLASS_TYPE_P (context
))
3709 if (complain
& tf_error
)
3710 error ("%q#T is not a class", context
);
3711 return error_mark_node
;
3714 /* When the CONTEXT is a dependent type, NAME could refer to a
3715 dependent base class of CONTEXT. But look inside it anyway
3716 if CONTEXT is a currently open scope, in case it refers to a
3717 member of the current instantiation or a non-dependent base;
3718 lookup will stop when we hit a dependent base. */
3719 if (!dependent_scope_p (context
))
3720 /* We should only set WANT_TYPE when we're a nested typename type.
3721 Then we can give better diagnostics if we find a non-type. */
3722 t
= lookup_field (context
, name
, 2, /*want_type=*/true);
3726 if ((!t
|| TREE_CODE (t
) == TREE_LIST
) && dependent_type_p (context
))
3727 return build_typename_type (context
, name
, fullname
, tag_type
);
3729 want_template
= TREE_CODE (fullname
) == TEMPLATE_ID_EXPR
;
3733 if (complain
& tf_error
)
3735 if (!COMPLETE_TYPE_P (context
))
3736 cxx_incomplete_type_error (NULL_TREE
, context
);
3738 error (want_template
? G_("no class template named %q#T in %q#T")
3739 : G_("no type named %q#T in %q#T"), name
, context
);
3741 return error_mark_node
;
3744 /* Pull out the template from an injected-class-name (or multiple). */
3746 t
= maybe_get_template_decl_from_type_decl (t
);
3748 if (TREE_CODE (t
) == TREE_LIST
)
3750 if (complain
& tf_error
)
3752 error ("lookup of %qT in %qT is ambiguous", name
, context
);
3753 print_candidates (t
);
3755 return error_mark_node
;
3758 if (want_template
&& !DECL_TYPE_TEMPLATE_P (t
))
3760 if (complain
& tf_error
)
3761 error ("%<typename %T::%D%> names %q#T, which is not a class template",
3763 return error_mark_node
;
3765 if (!want_template
&& TREE_CODE (t
) != TYPE_DECL
)
3767 if (complain
& tf_error
)
3768 error ("%<typename %T::%D%> names %q#T, which is not a type",
3770 return error_mark_node
;
3773 if (!perform_or_defer_access_check (TYPE_BINFO (context
), t
, t
, complain
))
3774 return error_mark_node
;
3776 /* If we are currently parsing a template and if T is a typedef accessed
3777 through CONTEXT then we need to remember and check access of T at
3778 template instantiation time. */
3779 add_typedef_to_current_template_for_access_check (t
, context
, input_location
);
3782 return lookup_template_class (t
, TREE_OPERAND (fullname
, 1),
3784 /*entering_scope=*/0,
3785 complain
| tf_user
);
3787 if (DECL_ARTIFICIAL (t
) || !(complain
& tf_keep_type_decl
))
3790 maybe_record_typedef_use (t
);
3795 /* Resolve `CONTEXT::template NAME'. Returns a TEMPLATE_DECL if the name
3796 can be resolved or an UNBOUND_CLASS_TEMPLATE, unless an error occurs,
3797 in which case error_mark_node is returned.
3799 If PARM_LIST is non-NULL, also make sure that the template parameter
3800 list of TEMPLATE_DECL matches.
3802 If COMPLAIN zero, don't complain about any errors that occur. */
3805 make_unbound_class_template (tree context
, tree name
, tree parm_list
,
3806 tsubst_flags_t complain
)
3812 name
= TYPE_IDENTIFIER (name
);
3813 else if (DECL_P (name
))
3814 name
= DECL_NAME (name
);
3815 gcc_assert (identifier_p (name
));
3817 if (!dependent_type_p (context
)
3818 || currently_open_class (context
))
3820 tree tmpl
= NULL_TREE
;
3822 if (MAYBE_CLASS_TYPE_P (context
))
3823 tmpl
= lookup_field (context
, name
, 0, false);
3825 if (tmpl
&& TREE_CODE (tmpl
) == TYPE_DECL
)
3826 tmpl
= maybe_get_template_decl_from_type_decl (tmpl
);
3828 if (!tmpl
|| !DECL_TYPE_TEMPLATE_P (tmpl
))
3830 if (complain
& tf_error
)
3831 error ("no class template named %q#T in %q#T", name
, context
);
3832 return error_mark_node
;
3836 && !comp_template_parms (DECL_TEMPLATE_PARMS (tmpl
), parm_list
))
3838 if (complain
& tf_error
)
3840 error ("template parameters do not match template %qD", tmpl
);
3841 inform (DECL_SOURCE_LOCATION (tmpl
),
3842 "%qD declared here", tmpl
);
3844 return error_mark_node
;
3847 if (!perform_or_defer_access_check (TYPE_BINFO (context
), tmpl
, tmpl
,
3849 return error_mark_node
;
3854 /* Build the UNBOUND_CLASS_TEMPLATE. */
3855 t
= cxx_make_type (UNBOUND_CLASS_TEMPLATE
);
3856 TYPE_CONTEXT (t
) = FROB_CONTEXT (context
);
3857 TREE_TYPE (t
) = NULL_TREE
;
3858 SET_TYPE_STRUCTURAL_EQUALITY (t
);
3860 /* Build the corresponding TEMPLATE_DECL. */
3861 d
= build_decl (input_location
, TEMPLATE_DECL
, name
, t
);
3862 TYPE_NAME (TREE_TYPE (d
)) = d
;
3863 TYPE_STUB_DECL (TREE_TYPE (d
)) = d
;
3864 DECL_CONTEXT (d
) = FROB_CONTEXT (context
);
3865 DECL_ARTIFICIAL (d
) = 1;
3866 DECL_TEMPLATE_PARMS (d
) = parm_list
;
3873 /* Push the declarations of builtin types into the global namespace.
3874 RID_INDEX is the index of the builtin type in the array
3875 RID_POINTERS. NAME is the name used when looking up the builtin
3876 type. TYPE is the _TYPE node for the builtin type.
3878 The calls to set_global_binding below should be
3879 eliminated. Built-in types should not be looked up name; their
3880 names are keywords that the parser can recognize. However, there
3881 is code in c-common.c that uses identifier_global_value to look up
3882 built-in types by name. */
3885 record_builtin_type (enum rid rid_index
,
3889 tree decl
= NULL_TREE
;
3893 tree tname
= get_identifier (name
);
3894 tree tdecl
= build_decl (BUILTINS_LOCATION
, TYPE_DECL
, tname
, type
);
3895 DECL_ARTIFICIAL (tdecl
) = 1;
3896 set_global_binding (tdecl
);
3900 if ((int) rid_index
< (int) RID_MAX
)
3901 if (tree rname
= ridpointers
[(int) rid_index
])
3902 if (!decl
|| DECL_NAME (decl
) != rname
)
3904 tree rdecl
= build_decl (BUILTINS_LOCATION
, TYPE_DECL
, rname
, type
);
3905 DECL_ARTIFICIAL (rdecl
) = 1;
3906 set_global_binding (rdecl
);
3913 if (!TYPE_NAME (type
))
3914 TYPE_NAME (type
) = decl
;
3915 debug_hooks
->type_decl (decl
, 0);
3919 /* Push a type into the namespace so that the back ends ignore it. */
3922 record_unknown_type (tree type
, const char* name
)
3924 tree decl
= pushdecl (build_decl (UNKNOWN_LOCATION
,
3925 TYPE_DECL
, get_identifier (name
), type
));
3926 /* Make sure the "unknown type" typedecl gets ignored for debug info. */
3927 DECL_IGNORED_P (decl
) = 1;
3928 TYPE_DECL_SUPPRESS_DEBUG (decl
) = 1;
3929 TYPE_SIZE (type
) = TYPE_SIZE (void_type_node
);
3930 SET_TYPE_ALIGN (type
, 1);
3931 TYPE_USER_ALIGN (type
) = 0;
3932 SET_TYPE_MODE (type
, TYPE_MODE (void_type_node
));
3935 /* Create all the predefined identifiers. */
3938 initialize_predefined_identifiers (void)
3940 struct predefined_identifier
3942 const char *name
; /* Name. */
3943 tree
*node
; /* Node to store it in. */
3944 cp_identifier_kind kind
; /* Kind of identifier. */
3947 /* A table of identifiers to create at startup. */
3948 static const predefined_identifier predefined_identifiers
[] = {
3949 {"C++", &lang_name_cplusplus
, cik_normal
},
3950 {"C", &lang_name_c
, cik_normal
},
3951 /* Some of these names have a trailing space so that it is
3952 impossible for them to conflict with names written by users. */
3953 {"__ct ", &ctor_identifier
, cik_ctor
},
3954 {"__ct_base ", &base_ctor_identifier
, cik_ctor
},
3955 {"__ct_comp ", &complete_ctor_identifier
, cik_ctor
},
3956 {"__dt ", &dtor_identifier
, cik_dtor
},
3957 {"__dt_base ", &base_dtor_identifier
, cik_dtor
},
3958 {"__dt_comp ", &complete_dtor_identifier
, cik_dtor
},
3959 {"__dt_del ", &deleting_dtor_identifier
, cik_dtor
},
3960 {"__conv_op ", &conv_op_identifier
, cik_conv_op
},
3961 {"__in_chrg", &in_charge_identifier
, cik_normal
},
3962 {"this", &this_identifier
, cik_normal
},
3963 {"__delta", &delta_identifier
, cik_normal
},
3964 {"__pfn", &pfn_identifier
, cik_normal
},
3965 {"_vptr", &vptr_identifier
, cik_normal
},
3966 {"__vtt_parm", &vtt_parm_identifier
, cik_normal
},
3967 {"::", &global_identifier
, cik_normal
},
3968 {"std", &std_identifier
, cik_normal
},
3969 /* The demangler expects anonymous namespaces to be called
3970 something starting with '_GLOBAL__N_'. It no longer needs
3971 to be unique to the TU. */
3972 {"_GLOBAL__N_1", &anon_identifier
, cik_normal
},
3973 {"auto", &auto_identifier
, cik_normal
},
3974 {"decltype(auto)", &decltype_auto_identifier
, cik_normal
},
3975 {"initializer_list", &init_list_identifier
, cik_normal
},
3976 {NULL
, NULL
, cik_normal
}
3979 for (const predefined_identifier
*pid
= predefined_identifiers
;
3982 *pid
->node
= get_identifier (pid
->name
);
3983 /* Some of these identifiers already have a special kind. */
3984 if (pid
->kind
!= cik_normal
)
3985 set_identifier_kind (*pid
->node
, pid
->kind
);
3989 /* Create the predefined scalar types of C,
3990 and some nodes representing standard constants (0, 1, (void *)0).
3991 Initialize the global binding level.
3992 Make definitions for built-in primitive functions. */
3995 cxx_init_decl_processing (void)
3998 tree void_ftype_ptr
;
4000 /* Create all the identifiers we need. */
4001 initialize_predefined_identifiers ();
4003 /* Create the global variables. */
4004 push_to_top_level ();
4006 current_function_decl
= NULL_TREE
;
4007 current_binding_level
= NULL
;
4008 /* Enter the global namespace. */
4009 gcc_assert (global_namespace
== NULL_TREE
);
4010 global_namespace
= build_lang_decl (NAMESPACE_DECL
, global_identifier
,
4012 TREE_PUBLIC (global_namespace
) = 1;
4013 DECL_CONTEXT (global_namespace
)
4014 = build_translation_unit_decl (get_identifier (main_input_filename
));
4015 debug_hooks
->register_main_translation_unit
4016 (DECL_CONTEXT (global_namespace
));
4017 begin_scope (sk_namespace
, global_namespace
);
4018 current_namespace
= global_namespace
;
4020 if (flag_visibility_ms_compat
)
4021 default_visibility
= VISIBILITY_HIDDEN
;
4024 current_lang_name
= lang_name_c
;
4026 /* Create the `std' namespace. */
4027 push_namespace (std_identifier
);
4028 std_node
= current_namespace
;
4031 flag_noexcept_type
= (cxx_dialect
>= cxx17
);
4033 c_common_nodes_and_builtins ();
4035 integer_two_node
= build_int_cst (NULL_TREE
, 2);
4037 /* Guess at the initial static decls size. */
4038 vec_alloc (static_decls
, 500);
4040 /* ... and keyed classes. */
4041 vec_alloc (keyed_classes
, 100);
4043 record_builtin_type (RID_BOOL
, "bool", boolean_type_node
);
4044 truthvalue_type_node
= boolean_type_node
;
4045 truthvalue_false_node
= boolean_false_node
;
4046 truthvalue_true_node
= boolean_true_node
;
4048 empty_except_spec
= build_tree_list (NULL_TREE
, NULL_TREE
);
4049 noexcept_true_spec
= build_tree_list (boolean_true_node
, NULL_TREE
);
4050 noexcept_false_spec
= build_tree_list (boolean_false_node
, NULL_TREE
);
4051 noexcept_deferred_spec
= build_tree_list (make_node (DEFERRED_NOEXCEPT
),
4055 record_builtin_type (RID_MAX
, NULL
, string_type_node
);
4058 delta_type_node
= ptrdiff_type_node
;
4059 vtable_index_type
= ptrdiff_type_node
;
4061 vtt_parm_type
= build_pointer_type (const_ptr_type_node
);
4062 void_ftype
= build_function_type_list (void_type_node
, NULL_TREE
);
4063 void_ftype_ptr
= build_function_type_list (void_type_node
,
4064 ptr_type_node
, NULL_TREE
);
4066 = build_exception_variant (void_ftype_ptr
, empty_except_spec
);
4068 /* Create the conversion operator marker. This operator's DECL_NAME
4069 is in the identifier table, so we can use identifier equality to
4071 conv_op_marker
= build_lang_decl (FUNCTION_DECL
, conv_op_identifier
,
4074 /* C++ extensions */
4076 unknown_type_node
= make_node (LANG_TYPE
);
4077 record_unknown_type (unknown_type_node
, "unknown type");
4079 /* Indirecting an UNKNOWN_TYPE node yields an UNKNOWN_TYPE node. */
4080 TREE_TYPE (unknown_type_node
) = unknown_type_node
;
4082 /* Looking up TYPE_POINTER_TO and TYPE_REFERENCE_TO yield the same
4084 TYPE_POINTER_TO (unknown_type_node
) = unknown_type_node
;
4085 TYPE_REFERENCE_TO (unknown_type_node
) = unknown_type_node
;
4087 init_list_type_node
= make_node (LANG_TYPE
);
4088 record_unknown_type (init_list_type_node
, "init list");
4091 /* Make sure we get a unique function type, so we can give
4092 its pointer type a name. (This wins for gdb.) */
4093 tree vfunc_type
= make_node (FUNCTION_TYPE
);
4094 TREE_TYPE (vfunc_type
) = integer_type_node
;
4095 TYPE_ARG_TYPES (vfunc_type
) = NULL_TREE
;
4096 layout_type (vfunc_type
);
4098 vtable_entry_type
= build_pointer_type (vfunc_type
);
4100 record_builtin_type (RID_MAX
, "__vtbl_ptr_type", vtable_entry_type
);
4103 = build_cplus_array_type (vtable_entry_type
, NULL_TREE
);
4104 layout_type (vtbl_type_node
);
4105 vtbl_type_node
= cp_build_qualified_type (vtbl_type_node
, TYPE_QUAL_CONST
);
4106 record_builtin_type (RID_MAX
, NULL
, vtbl_type_node
);
4107 vtbl_ptr_type_node
= build_pointer_type (vtable_entry_type
);
4108 layout_type (vtbl_ptr_type_node
);
4109 record_builtin_type (RID_MAX
, NULL
, vtbl_ptr_type_node
);
4111 push_namespace (get_identifier ("__cxxabiv1"));
4112 abi_node
= current_namespace
;
4115 global_type_node
= make_node (LANG_TYPE
);
4116 record_unknown_type (global_type_node
, "global type");
4118 any_targ_node
= make_node (LANG_TYPE
);
4119 record_unknown_type (any_targ_node
, "any type");
4122 current_lang_name
= lang_name_cplusplus
;
4124 if (aligned_new_threshold
> 1
4125 && !pow2p_hwi (aligned_new_threshold
))
4127 error ("-faligned-new=%d is not a power of two", aligned_new_threshold
);
4128 aligned_new_threshold
= 1;
4130 if (aligned_new_threshold
== -1)
4131 aligned_new_threshold
= (cxx_dialect
>= cxx17
) ? 1 : 0;
4132 if (aligned_new_threshold
== 1)
4133 aligned_new_threshold
= malloc_alignment () / BITS_PER_UNIT
;
4136 tree newattrs
, extvisattr
;
4137 tree newtype
, deltype
;
4138 tree ptr_ftype_sizetype
;
4142 = build_function_type_list (ptr_type_node
, size_type_node
, NULL_TREE
);
4143 if (cxx_dialect
== cxx98
)
4146 tree bad_alloc_type_node
;
4147 tree bad_alloc_decl
;
4149 push_namespace (std_identifier
);
4150 bad_alloc_id
= get_identifier ("bad_alloc");
4151 bad_alloc_type_node
= make_class_type (RECORD_TYPE
);
4152 TYPE_CONTEXT (bad_alloc_type_node
) = current_namespace
;
4154 = create_implicit_typedef (bad_alloc_id
, bad_alloc_type_node
);
4155 DECL_CONTEXT (bad_alloc_decl
) = current_namespace
;
4159 = add_exception_specifier (NULL_TREE
, bad_alloc_type_node
, -1);
4162 new_eh_spec
= noexcept_false_spec
;
4164 /* Ensure attribs.c is initialized. */
4167 /* Ensure constraint.cc is initialized. */
4168 init_constraint_processing ();
4170 extvisattr
= build_tree_list (get_identifier ("externally_visible"),
4172 newattrs
= tree_cons (get_identifier ("alloc_size"),
4173 build_tree_list (NULL_TREE
, integer_one_node
),
4175 newtype
= cp_build_type_attribute_variant (ptr_ftype_sizetype
, newattrs
);
4176 newtype
= build_exception_variant (newtype
, new_eh_spec
);
4177 deltype
= cp_build_type_attribute_variant (void_ftype_ptr
, extvisattr
);
4178 deltype
= build_exception_variant (deltype
, empty_except_spec
);
4179 tree opnew
= push_cp_library_fn (NEW_EXPR
, newtype
, 0);
4180 DECL_IS_MALLOC (opnew
) = 1;
4181 DECL_IS_OPERATOR_NEW (opnew
) = 1;
4182 opnew
= push_cp_library_fn (VEC_NEW_EXPR
, newtype
, 0);
4183 DECL_IS_MALLOC (opnew
) = 1;
4184 DECL_IS_OPERATOR_NEW (opnew
) = 1;
4185 push_cp_library_fn (DELETE_EXPR
, deltype
, ECF_NOTHROW
);
4186 push_cp_library_fn (VEC_DELETE_EXPR
, deltype
, ECF_NOTHROW
);
4187 if (flag_sized_deallocation
)
4189 /* Also push the sized deallocation variants:
4190 void operator delete(void*, std::size_t) throw();
4191 void operator delete[](void*, std::size_t) throw(); */
4192 tree void_ftype_ptr_size
4193 = build_function_type_list (void_type_node
, ptr_type_node
,
4194 size_type_node
, NULL_TREE
);
4195 deltype
= cp_build_type_attribute_variant (void_ftype_ptr_size
,
4197 deltype
= build_exception_variant (deltype
, empty_except_spec
);
4198 push_cp_library_fn (DELETE_EXPR
, deltype
, ECF_NOTHROW
);
4199 push_cp_library_fn (VEC_DELETE_EXPR
, deltype
, ECF_NOTHROW
);
4202 if (aligned_new_threshold
)
4204 push_namespace (std_identifier
);
4205 tree align_id
= get_identifier ("align_val_t");
4206 align_type_node
= start_enum (align_id
, NULL_TREE
, size_type_node
,
4207 NULL_TREE
, /*scoped*/true, NULL
);
4210 /* operator new (size_t, align_val_t); */
4211 newtype
= build_function_type_list (ptr_type_node
, size_type_node
,
4212 align_type_node
, NULL_TREE
);
4213 newtype
= cp_build_type_attribute_variant (newtype
, newattrs
);
4214 newtype
= build_exception_variant (newtype
, new_eh_spec
);
4215 opnew
= push_cp_library_fn (NEW_EXPR
, newtype
, 0);
4216 DECL_IS_MALLOC (opnew
) = 1;
4217 DECL_IS_OPERATOR_NEW (opnew
) = 1;
4218 opnew
= push_cp_library_fn (VEC_NEW_EXPR
, newtype
, 0);
4219 DECL_IS_MALLOC (opnew
) = 1;
4220 DECL_IS_OPERATOR_NEW (opnew
) = 1;
4222 /* operator delete (void *, align_val_t); */
4223 deltype
= build_function_type_list (void_type_node
, ptr_type_node
,
4224 align_type_node
, NULL_TREE
);
4225 deltype
= cp_build_type_attribute_variant (deltype
, extvisattr
);
4226 deltype
= build_exception_variant (deltype
, empty_except_spec
);
4227 push_cp_library_fn (DELETE_EXPR
, deltype
, ECF_NOTHROW
);
4228 push_cp_library_fn (VEC_DELETE_EXPR
, deltype
, ECF_NOTHROW
);
4230 if (flag_sized_deallocation
)
4232 /* operator delete (void *, size_t, align_val_t); */
4233 deltype
= build_function_type_list (void_type_node
, ptr_type_node
,
4234 size_type_node
, align_type_node
,
4236 deltype
= cp_build_type_attribute_variant (deltype
, extvisattr
);
4237 deltype
= build_exception_variant (deltype
, empty_except_spec
);
4238 push_cp_library_fn (DELETE_EXPR
, deltype
, ECF_NOTHROW
);
4239 push_cp_library_fn (VEC_DELETE_EXPR
, deltype
, ECF_NOTHROW
);
4243 nullptr_type_node
= make_node (NULLPTR_TYPE
);
4244 TYPE_SIZE (nullptr_type_node
) = bitsize_int (GET_MODE_BITSIZE (ptr_mode
));
4245 TYPE_SIZE_UNIT (nullptr_type_node
) = size_int (GET_MODE_SIZE (ptr_mode
));
4246 TYPE_UNSIGNED (nullptr_type_node
) = 1;
4247 TYPE_PRECISION (nullptr_type_node
) = GET_MODE_BITSIZE (ptr_mode
);
4248 if (abi_version_at_least (9))
4249 SET_TYPE_ALIGN (nullptr_type_node
, GET_MODE_ALIGNMENT (ptr_mode
));
4250 SET_TYPE_MODE (nullptr_type_node
, ptr_mode
);
4251 record_builtin_type (RID_MAX
, "decltype(nullptr)", nullptr_type_node
);
4252 nullptr_node
= build_int_cst (nullptr_type_node
, 0);
4256 = build_library_fn_ptr ("__cxa_pure_virtual", void_ftype
,
4257 ECF_NORETURN
| ECF_NOTHROW
| ECF_COLD
);
4259 /* Perform other language dependent initializations. */
4260 init_class_processing ();
4261 init_rtti_processing ();
4262 init_template_processing ();
4264 if (flag_exceptions
)
4265 init_exception_processing ();
4267 if (! supports_one_only ())
4270 make_fname_decl
= cp_make_fname_decl
;
4271 start_fname_decls ();
4273 /* Show we use EH for cleanups. */
4274 if (flag_exceptions
)
4275 using_eh_for_cleanups ();
4278 /* Generate an initializer for a function naming variable from
4279 NAME. NAME may be NULL, to indicate a dependent name. TYPE_P is
4280 filled in with the type of the init. */
4283 cp_fname_init (const char* name
, tree
*type_p
)
4285 tree domain
= NULL_TREE
;
4287 tree init
= NULL_TREE
;
4292 length
= strlen (name
);
4293 domain
= build_index_type (size_int (length
));
4294 init
= build_string (length
+ 1, name
);
4297 type
= cp_build_qualified_type (char_type_node
, TYPE_QUAL_CONST
);
4298 type
= build_cplus_array_type (type
, domain
);
4303 TREE_TYPE (init
) = type
;
4305 init
= error_mark_node
;
4310 /* Create the VAR_DECL for __FUNCTION__ etc. ID is the name to give
4311 the decl, LOC is the location to give the decl, NAME is the
4312 initialization string and TYPE_DEP indicates whether NAME depended
4313 on the type of the function. We make use of that to detect
4314 __PRETTY_FUNCTION__ inside a template fn. This is being done lazily
4315 at the point of first use, so we mustn't push the decl now. */
4318 cp_make_fname_decl (location_t loc
, tree id
, int type_dep
)
4320 const char *const name
= (type_dep
&& processing_template_decl
4321 ? NULL
: fname_as_string (type_dep
));
4323 tree init
= cp_fname_init (name
, &type
);
4324 tree decl
= build_decl (loc
, VAR_DECL
, id
, type
);
4327 free (CONST_CAST (char *, name
));
4329 TREE_STATIC (decl
) = 1;
4330 TREE_READONLY (decl
) = 1;
4331 DECL_ARTIFICIAL (decl
) = 1;
4333 TREE_USED (decl
) = 1;
4335 if (current_function_decl
)
4337 DECL_CONTEXT (decl
) = current_function_decl
;
4338 decl
= pushdecl_outermost_localscope (decl
);
4339 cp_finish_decl (decl
, init
, /*init_const_expr_p=*/false, NULL_TREE
,
4340 LOOKUP_ONLYCONVERTING
);
4344 DECL_THIS_STATIC (decl
) = true;
4345 pushdecl_top_level_and_finish (decl
, init
);
4352 builtin_function_1 (tree decl
, tree context
, bool is_global
)
4354 tree id
= DECL_NAME (decl
);
4355 const char *name
= IDENTIFIER_POINTER (id
);
4357 retrofit_lang_decl (decl
);
4359 DECL_ARTIFICIAL (decl
) = 1;
4360 SET_DECL_LANGUAGE (decl
, lang_c
);
4361 /* Runtime library routines are, by definition, available in an
4362 external shared object. */
4363 DECL_VISIBILITY (decl
) = VISIBILITY_DEFAULT
;
4364 DECL_VISIBILITY_SPECIFIED (decl
) = 1;
4366 DECL_CONTEXT (decl
) = context
;
4368 /* A function in the user's namespace should have an explicit
4369 declaration before it is used. Mark the built-in function as
4370 anticipated but not actually declared. */
4371 if (name
[0] != '_' || name
[1] != '_')
4372 DECL_ANTICIPATED (decl
) = 1;
4373 else if (strncmp (name
+ 2, "builtin_", strlen ("builtin_")) != 0)
4375 size_t len
= strlen (name
);
4377 /* Treat __*_chk fortification functions as anticipated as well,
4378 unless they are __builtin_*. */
4379 if (len
> strlen ("___chk")
4380 && memcmp (name
+ len
- strlen ("_chk"),
4381 "_chk", strlen ("_chk") + 1) == 0)
4382 DECL_ANTICIPATED (decl
) = 1;
4386 pushdecl_top_level (decl
);
4394 cxx_builtin_function (tree decl
)
4396 tree id
= DECL_NAME (decl
);
4397 const char *name
= IDENTIFIER_POINTER (id
);
4398 /* All builtins that don't begin with an '_' should additionally
4399 go in the 'std' namespace. */
4402 tree decl2
= copy_node(decl
);
4403 push_namespace (std_identifier
);
4404 builtin_function_1 (decl2
, std_node
, false);
4408 return builtin_function_1 (decl
, NULL_TREE
, false);
4411 /* Like cxx_builtin_function, but guarantee the function is added to the global
4412 scope. This is to allow function specific options to add new machine
4413 dependent builtins when the target ISA changes via attribute((target(...)))
4414 which saves space on program startup if the program does not use non-generic
4418 cxx_builtin_function_ext_scope (tree decl
)
4421 tree id
= DECL_NAME (decl
);
4422 const char *name
= IDENTIFIER_POINTER (id
);
4423 /* All builtins that don't begin with an '_' should additionally
4424 go in the 'std' namespace. */
4427 tree decl2
= copy_node(decl
);
4428 push_namespace (std_identifier
);
4429 builtin_function_1 (decl2
, std_node
, true);
4433 return builtin_function_1 (decl
, NULL_TREE
, true);
4436 /* Generate a FUNCTION_DECL with the typical flags for a runtime library
4437 function. Not called directly. */
4440 build_library_fn (tree name
, enum tree_code operator_code
, tree type
,
4443 tree fn
= build_lang_decl (FUNCTION_DECL
, name
, type
);
4444 DECL_EXTERNAL (fn
) = 1;
4445 TREE_PUBLIC (fn
) = 1;
4446 DECL_ARTIFICIAL (fn
) = 1;
4447 DECL_OVERLOADED_OPERATOR_CODE_RAW (fn
)
4448 = OVL_OP_INFO (false, operator_code
)->ovl_op_code
;
4449 SET_DECL_LANGUAGE (fn
, lang_c
);
4450 /* Runtime library routines are, by definition, available in an
4451 external shared object. */
4452 DECL_VISIBILITY (fn
) = VISIBILITY_DEFAULT
;
4453 DECL_VISIBILITY_SPECIFIED (fn
) = 1;
4454 set_call_expr_flags (fn
, ecf_flags
);
4458 /* Returns the _DECL for a library function with C++ linkage. */
4461 build_cp_library_fn (tree name
, enum tree_code operator_code
, tree type
,
4464 tree fn
= build_library_fn (name
, operator_code
, type
, ecf_flags
);
4465 DECL_CONTEXT (fn
) = FROB_CONTEXT (current_namespace
);
4466 SET_DECL_LANGUAGE (fn
, lang_cplusplus
);
4470 /* Like build_library_fn, but takes a C string instead of an
4474 build_library_fn_ptr (const char* name
, tree type
, int ecf_flags
)
4476 return build_library_fn (get_identifier (name
), ERROR_MARK
, type
, ecf_flags
);
4479 /* Like build_cp_library_fn, but takes a C string instead of an
4483 build_cp_library_fn_ptr (const char* name
, tree type
, int ecf_flags
)
4485 return build_cp_library_fn (get_identifier (name
), ERROR_MARK
, type
,
4489 /* Like build_library_fn, but also pushes the function so that we will
4490 be able to find it via get_global_binding. Also, the function
4491 may throw exceptions listed in RAISES. */
4494 push_library_fn (tree name
, tree type
, tree raises
, int ecf_flags
)
4499 type
= build_exception_variant (type
, raises
);
4501 fn
= build_library_fn (name
, ERROR_MARK
, type
, ecf_flags
);
4502 pushdecl_top_level (fn
);
4506 /* Like build_cp_library_fn, but also pushes the function so that it
4507 will be found by normal lookup. */
4510 push_cp_library_fn (enum tree_code operator_code
, tree type
,
4513 tree fn
= build_cp_library_fn (ovl_op_identifier (false, operator_code
),
4514 operator_code
, type
, ecf_flags
);
4517 apply_tm_attr (fn
, get_identifier ("transaction_safe"));
4521 /* Like push_library_fn, but takes a TREE_LIST of parm types rather than
4525 push_void_library_fn (tree name
, tree parmtypes
, int ecf_flags
)
4527 tree type
= build_function_type (void_type_node
, parmtypes
);
4528 return push_library_fn (name
, type
, NULL_TREE
, ecf_flags
);
4531 /* Like push_library_fn, but also note that this function throws
4532 and does not return. Used for __throw_foo and the like. */
4535 push_throw_library_fn (tree name
, tree type
)
4537 tree fn
= push_library_fn (name
, type
, NULL_TREE
, ECF_NORETURN
| ECF_COLD
);
4541 /* When we call finish_struct for an anonymous union, we create
4542 default copy constructors and such. But, an anonymous union
4543 shouldn't have such things; this function undoes the damage to the
4544 anonymous union type T.
4546 (The reason that we create the synthesized methods is that we don't
4547 distinguish `union { int i; }' from `typedef union { int i; } U'.
4548 The first is an anonymous union; the second is just an ordinary
4552 fixup_anonymous_aggr (tree t
)
4554 /* Wipe out memory of synthesized methods. */
4555 TYPE_HAS_USER_CONSTRUCTOR (t
) = 0;
4556 TYPE_HAS_DEFAULT_CONSTRUCTOR (t
) = 0;
4557 TYPE_HAS_COPY_CTOR (t
) = 0;
4558 TYPE_HAS_CONST_COPY_CTOR (t
) = 0;
4559 TYPE_HAS_COPY_ASSIGN (t
) = 0;
4560 TYPE_HAS_CONST_COPY_ASSIGN (t
) = 0;
4562 /* Splice the implicitly generated functions out of TYPE_FIELDS. */
4563 for (tree probe
, *prev_p
= &TYPE_FIELDS (t
); (probe
= *prev_p
);)
4564 if (TREE_CODE (probe
) == FUNCTION_DECL
&& DECL_ARTIFICIAL (probe
))
4565 *prev_p
= DECL_CHAIN (probe
);
4567 prev_p
= &DECL_CHAIN (probe
);
4569 /* Anonymous aggregates cannot have fields with ctors, dtors or complex
4570 assignment operators (because they cannot have these methods themselves).
4571 For anonymous unions this is already checked because they are not allowed
4572 in any union, otherwise we have to check it. */
4573 if (TREE_CODE (t
) != UNION_TYPE
)
4577 for (field
= TYPE_FIELDS (t
); field
; field
= DECL_CHAIN (field
))
4578 if (TREE_CODE (field
) == FIELD_DECL
)
4580 type
= TREE_TYPE (field
);
4581 if (CLASS_TYPE_P (type
))
4583 if (TYPE_NEEDS_CONSTRUCTING (type
))
4584 error ("member %q+#D with constructor not allowed "
4585 "in anonymous aggregate", field
);
4586 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
))
4587 error ("member %q+#D with destructor not allowed "
4588 "in anonymous aggregate", field
);
4589 if (TYPE_HAS_COMPLEX_COPY_ASSIGN (type
))
4590 error ("member %q+#D with copy assignment operator "
4591 "not allowed in anonymous aggregate", field
);
4597 /* Warn for an attribute located at LOCATION that appertains to the
4598 class type CLASS_TYPE that has not been properly placed after its
4599 class-key, in it class-specifier. */
4602 warn_misplaced_attr_for_class_type (source_location location
,
4605 gcc_assert (OVERLOAD_TYPE_P (class_type
));
4607 if (warning_at (location
, OPT_Wattributes
,
4608 "attribute ignored in declaration "
4609 "of %q#T", class_type
))
4611 "attribute for %q#T must follow the %qs keyword",
4612 class_type
, class_key_or_enum_as_string (class_type
));
4615 /* Make sure that a declaration with no declarator is well-formed, i.e.
4616 just declares a tagged type or anonymous union.
4618 Returns the type declared; or NULL_TREE if none. */
4621 check_tag_decl (cp_decl_specifier_seq
*declspecs
,
4622 bool explicit_type_instantiation_p
)
4624 int saw_friend
= decl_spec_seq_has_spec_p (declspecs
, ds_friend
);
4625 int saw_typedef
= decl_spec_seq_has_spec_p (declspecs
, ds_typedef
);
4626 /* If a class, struct, or enum type is declared by the DECLSPECS
4627 (i.e, if a class-specifier, enum-specifier, or non-typename
4628 elaborated-type-specifier appears in the DECLSPECS),
4629 DECLARED_TYPE is set to the corresponding type. */
4630 tree declared_type
= NULL_TREE
;
4631 bool error_p
= false;
4633 if (declspecs
->multiple_types_p
)
4634 error ("multiple types in one declaration");
4635 else if (declspecs
->redefined_builtin_type
)
4637 if (!in_system_header_at (input_location
))
4638 permerror (declspecs
->locations
[ds_redefined_builtin_type_spec
],
4639 "redeclaration of C++ built-in type %qT",
4640 declspecs
->redefined_builtin_type
);
4645 && TYPE_P (declspecs
->type
)
4646 && ((TREE_CODE (declspecs
->type
) != TYPENAME_TYPE
4647 && MAYBE_CLASS_TYPE_P (declspecs
->type
))
4648 || TREE_CODE (declspecs
->type
) == ENUMERAL_TYPE
))
4649 declared_type
= declspecs
->type
;
4650 else if (declspecs
->type
== error_mark_node
)
4652 if (declared_type
== NULL_TREE
&& ! saw_friend
&& !error_p
)
4653 permerror (input_location
, "declaration does not declare anything");
4654 else if (declared_type
!= NULL_TREE
&& type_uses_auto (declared_type
))
4656 error_at (declspecs
->locations
[ds_type_spec
],
4657 "%<auto%> can only be specified for variables "
4658 "or function declarations");
4659 return error_mark_node
;
4661 /* Check for an anonymous union. */
4662 else if (declared_type
&& RECORD_OR_UNION_CODE_P (TREE_CODE (declared_type
))
4663 && TYPE_UNNAMED_P (declared_type
))
4665 /* 7/3 In a simple-declaration, the optional init-declarator-list
4666 can be omitted only when declaring a class (clause 9) or
4667 enumeration (7.2), that is, when the decl-specifier-seq contains
4668 either a class-specifier, an elaborated-type-specifier with
4669 a class-key (9.1), or an enum-specifier. In these cases and
4670 whenever a class-specifier or enum-specifier is present in the
4671 decl-specifier-seq, the identifiers in these specifiers are among
4672 the names being declared by the declaration (as class-name,
4673 enum-names, or enumerators, depending on the syntax). In such
4674 cases, and except for the declaration of an unnamed bit-field (9.6),
4675 the decl-specifier-seq shall introduce one or more names into the
4676 program, or shall redeclare a name introduced by a previous
4677 declaration. [Example:
4678 enum { }; // ill-formed
4679 typedef class { }; // ill-formed
4683 error ("missing type-name in typedef-declaration");
4686 /* Anonymous unions are objects, so they can have specifiers. */;
4687 SET_ANON_AGGR_TYPE_P (declared_type
);
4689 if (TREE_CODE (declared_type
) != UNION_TYPE
4690 && !in_system_header_at (input_location
))
4691 pedwarn (input_location
, OPT_Wpedantic
, "ISO C++ prohibits anonymous structs");
4696 if (decl_spec_seq_has_spec_p (declspecs
, ds_inline
))
4697 error_at (declspecs
->locations
[ds_inline
],
4698 "%<inline%> can only be specified for functions");
4699 else if (decl_spec_seq_has_spec_p (declspecs
, ds_virtual
))
4700 error_at (declspecs
->locations
[ds_virtual
],
4701 "%<virtual%> can only be specified for functions");
4703 && (!current_class_type
4704 || current_scope () != current_class_type
))
4705 error_at (declspecs
->locations
[ds_friend
],
4706 "%<friend%> can only be specified inside a class");
4707 else if (decl_spec_seq_has_spec_p (declspecs
, ds_explicit
))
4708 error_at (declspecs
->locations
[ds_explicit
],
4709 "%<explicit%> can only be specified for constructors");
4710 else if (declspecs
->storage_class
)
4711 error_at (declspecs
->locations
[ds_storage_class
],
4712 "a storage class can only be specified for objects "
4714 else if (decl_spec_seq_has_spec_p (declspecs
, ds_const
))
4715 error_at (declspecs
->locations
[ds_const
],
4716 "%<const%> can only be specified for objects and "
4718 else if (decl_spec_seq_has_spec_p (declspecs
, ds_volatile
))
4719 error_at (declspecs
->locations
[ds_volatile
],
4720 "%<volatile%> can only be specified for objects and "
4722 else if (decl_spec_seq_has_spec_p (declspecs
, ds_restrict
))
4723 error_at (declspecs
->locations
[ds_restrict
],
4724 "%<__restrict%> can only be specified for objects and "
4726 else if (decl_spec_seq_has_spec_p (declspecs
, ds_thread
))
4727 error_at (declspecs
->locations
[ds_thread
],
4728 "%<__thread%> can only be specified for objects "
4730 else if (saw_typedef
)
4731 warning_at (declspecs
->locations
[ds_typedef
], 0,
4732 "%<typedef%> was ignored in this declaration");
4733 else if (decl_spec_seq_has_spec_p (declspecs
, ds_constexpr
))
4734 error_at (declspecs
->locations
[ds_constexpr
],
4735 "%<constexpr%> cannot be used for type declarations");
4738 if (declspecs
->attributes
&& warn_attributes
&& declared_type
)
4741 if (!CLASS_TYPE_P (declared_type
)
4742 || !CLASSTYPE_TEMPLATE_INSTANTIATION (declared_type
))
4743 /* For a non-template class, use the name location. */
4744 loc
= location_of (declared_type
);
4746 /* For a template class (an explicit instantiation), use the
4747 current location. */
4748 loc
= input_location
;
4750 if (explicit_type_instantiation_p
)
4751 /* [dcl.attr.grammar]/4:
4753 No attribute-specifier-seq shall appertain to an explicit
4756 if (warning_at (loc
, OPT_Wattributes
,
4757 "attribute ignored in explicit instantiation %q#T",
4760 "no attribute can be applied to "
4761 "an explicit instantiation");
4764 warn_misplaced_attr_for_class_type (loc
, declared_type
);
4767 return declared_type
;
4770 /* Called when a declaration is seen that contains no names to declare.
4771 If its type is a reference to a structure, union or enum inherited
4772 from a containing scope, shadow that tag name for the current scope
4773 with a forward reference.
4774 If its type defines a new named structure or union
4775 or defines an enum, it is valid but we need not do anything here.
4776 Otherwise, it is an error.
4778 C++: may have to grok the declspecs to learn about static,
4779 complain for anonymous unions.
4781 Returns the TYPE declared -- or NULL_TREE if none. */
4784 shadow_tag (cp_decl_specifier_seq
*declspecs
)
4786 tree t
= check_tag_decl (declspecs
,
4787 /*explicit_type_instantiation_p=*/false);
4792 if (maybe_process_partial_specialization (t
) == error_mark_node
)
4795 /* This is where the variables in an anonymous union are
4796 declared. An anonymous union declaration looks like:
4798 because there is no declarator after the union, the parser
4799 sends that declaration here. */
4800 if (ANON_AGGR_TYPE_P (t
))
4802 fixup_anonymous_aggr (t
);
4804 if (TYPE_FIELDS (t
))
4806 tree decl
= grokdeclarator (/*declarator=*/NULL
,
4807 declspecs
, NORMAL
, 0, NULL
);
4808 finish_anon_union (decl
);
4815 /* Decode a "typename", such as "int **", returning a ..._TYPE node. */
4818 groktypename (cp_decl_specifier_seq
*type_specifiers
,
4819 const cp_declarator
*declarator
,
4820 bool is_template_arg
)
4824 enum decl_context context
4825 = is_template_arg
? TEMPLATE_TYPE_ARG
: TYPENAME
;
4826 attrs
= type_specifiers
->attributes
;
4827 type_specifiers
->attributes
= NULL_TREE
;
4828 type
= grokdeclarator (declarator
, type_specifiers
, context
, 0, &attrs
);
4829 if (attrs
&& type
!= error_mark_node
)
4831 if (CLASS_TYPE_P (type
))
4832 warning (OPT_Wattributes
, "ignoring attributes applied to class type %qT "
4833 "outside of definition", type
);
4834 else if (MAYBE_CLASS_TYPE_P (type
))
4835 /* A template type parameter or other dependent type. */
4836 warning (OPT_Wattributes
, "ignoring attributes applied to dependent "
4837 "type %qT without an associated declaration", type
);
4839 cplus_decl_attributes (&type
, attrs
, 0);
4844 /* Process a DECLARATOR for a function-scope variable declaration,
4845 namespace-scope variable declaration, or function declaration.
4846 (Function definitions go through start_function; class member
4847 declarations appearing in the body of the class go through
4848 grokfield.) The DECL corresponding to the DECLARATOR is returned.
4849 If an error occurs, the error_mark_node is returned instead.
4851 DECLSPECS are the decl-specifiers for the declaration. INITIALIZED is
4852 SD_INITIALIZED if an explicit initializer is present, or SD_DEFAULTED
4853 for an explicitly defaulted function, or SD_DELETED for an explicitly
4854 deleted function, but 0 (SD_UNINITIALIZED) if this is a variable
4855 implicitly initialized via a default constructor. ATTRIBUTES and
4856 PREFIX_ATTRIBUTES are GNU attributes associated with this declaration.
4858 The scope represented by the context of the returned DECL is pushed
4859 (if it is not the global namespace) and is assigned to
4860 *PUSHED_SCOPE_P. The caller is then responsible for calling
4861 pop_scope on *PUSHED_SCOPE_P if it is set. */
4864 start_decl (const cp_declarator
*declarator
,
4865 cp_decl_specifier_seq
*declspecs
,
4868 tree prefix_attributes
,
4869 tree
*pushed_scope_p
)
4877 *pushed_scope_p
= NULL_TREE
;
4879 /* An object declared as __attribute__((deprecated)) suppresses
4880 warnings of uses of other deprecated items. */
4881 if (lookup_attribute ("deprecated", attributes
))
4882 deprecated_state
= DEPRECATED_SUPPRESS
;
4884 attributes
= chainon (attributes
, prefix_attributes
);
4886 decl
= grokdeclarator (declarator
, declspecs
, NORMAL
, initialized
,
4889 deprecated_state
= DEPRECATED_NORMAL
;
4891 if (decl
== NULL_TREE
|| VOID_TYPE_P (decl
)
4892 || decl
== error_mark_node
)
4893 return error_mark_node
;
4895 context
= CP_DECL_CONTEXT (decl
);
4896 if (context
!= global_namespace
)
4897 *pushed_scope_p
= push_scope (context
);
4899 /* Is it valid for this decl to have an initializer at all?
4900 If not, set INITIALIZED to zero, which will indirectly
4901 tell `cp_finish_decl' to ignore the initializer once it is parsed. */
4903 && TREE_CODE (decl
) == TYPE_DECL
)
4905 error ("typedef %qD is initialized (use decltype instead)", decl
);
4906 return error_mark_node
;
4911 if (! toplevel_bindings_p ()
4912 && DECL_EXTERNAL (decl
))
4913 warning (0, "declaration of %q#D has %<extern%> and is initialized",
4915 DECL_EXTERNAL (decl
) = 0;
4916 if (toplevel_bindings_p ())
4917 TREE_STATIC (decl
) = 1;
4919 alias
= lookup_attribute ("alias", DECL_ATTRIBUTES (decl
)) != 0;
4921 if (alias
&& TREE_CODE (decl
) == FUNCTION_DECL
)
4922 record_key_method_defined (decl
);
4924 /* If this is a typedef that names the class for linkage purposes
4925 (7.1.3p8), apply any attributes directly to the type. */
4926 if (TREE_CODE (decl
) == TYPE_DECL
4927 && OVERLOAD_TYPE_P (TREE_TYPE (decl
))
4928 && decl
== TYPE_NAME (TYPE_MAIN_VARIANT (TREE_TYPE (decl
))))
4929 flags
= ATTR_FLAG_TYPE_IN_PLACE
;
4933 /* Set attributes here so if duplicate decl, will have proper attributes. */
4934 cplus_decl_attributes (&decl
, attributes
, flags
);
4936 /* Dllimported symbols cannot be defined. Static data members (which
4937 can be initialized in-class and dllimported) go through grokfield,
4938 not here, so we don't need to exclude those decls when checking for
4940 if (initialized
&& DECL_DLLIMPORT_P (decl
))
4942 error ("definition of %q#D is marked %<dllimport%>", decl
);
4943 DECL_DLLIMPORT_P (decl
) = 0;
4946 /* If #pragma weak was used, mark the decl weak now. */
4947 if (!processing_template_decl
)
4948 maybe_apply_pragma_weak (decl
);
4950 if (TREE_CODE (decl
) == FUNCTION_DECL
4951 && DECL_DECLARED_INLINE_P (decl
)
4952 && DECL_UNINLINABLE (decl
)
4953 && lookup_attribute ("noinline", DECL_ATTRIBUTES (decl
)))
4954 warning_at (DECL_SOURCE_LOCATION (decl
), 0,
4955 "inline function %qD given attribute noinline", decl
);
4957 if (TYPE_P (context
) && COMPLETE_TYPE_P (complete_type (context
)))
4959 bool this_tmpl
= (processing_template_decl
4960 > template_class_depth (context
));
4963 tree field
= lookup_field (context
, DECL_NAME (decl
), 0, false);
4964 if (field
== NULL_TREE
4965 || !(VAR_P (field
) || variable_template_p (field
)))
4966 error ("%q+#D is not a static data member of %q#T", decl
, context
);
4967 else if (variable_template_p (field
) && !this_tmpl
)
4969 if (DECL_LANG_SPECIFIC (decl
)
4970 && DECL_TEMPLATE_SPECIALIZATION (decl
))
4971 /* OK, specialization was already checked. */;
4974 error_at (DECL_SOURCE_LOCATION (decl
),
4975 "non-member-template declaration of %qD", decl
);
4976 inform (DECL_SOURCE_LOCATION (field
), "does not match "
4977 "member template declaration here");
4978 return error_mark_node
;
4983 if (variable_template_p (field
))
4984 field
= DECL_TEMPLATE_RESULT (field
);
4986 if (DECL_CONTEXT (field
) != context
)
4988 if (!same_type_p (DECL_CONTEXT (field
), context
))
4989 permerror (input_location
, "ISO C++ does not permit %<%T::%D%> "
4990 "to be defined as %<%T::%D%>",
4991 DECL_CONTEXT (field
), DECL_NAME (decl
),
4992 context
, DECL_NAME (decl
));
4993 DECL_CONTEXT (decl
) = DECL_CONTEXT (field
);
4995 /* Static data member are tricky; an in-class initialization
4996 still doesn't provide a definition, so the in-class
4997 declaration will have DECL_EXTERNAL set, but will have an
4998 initialization. Thus, duplicate_decls won't warn
4999 about this situation, and so we check here. */
5000 if (initialized
&& DECL_INITIALIZED_IN_CLASS_P (field
))
5001 error ("duplicate initialization of %qD", decl
);
5002 field
= duplicate_decls (decl
, field
,
5003 /*newdecl_is_friend=*/false);
5004 if (field
== error_mark_node
)
5005 return error_mark_node
;
5012 tree field
= check_classfn (context
, decl
,
5014 ? current_template_parms
5016 if (field
&& field
!= error_mark_node
5017 && duplicate_decls (decl
, field
,
5018 /*newdecl_is_friend=*/false))
5022 /* cp_finish_decl sets DECL_EXTERNAL if DECL_IN_AGGR_P is set. */
5023 DECL_IN_AGGR_P (decl
) = 0;
5024 /* Do not mark DECL as an explicit specialization if it was not
5025 already marked as an instantiation; a declaration should
5026 never be marked as a specialization unless we know what
5027 template is being specialized. */
5028 if (DECL_LANG_SPECIFIC (decl
) && DECL_USE_TEMPLATE (decl
))
5030 SET_DECL_TEMPLATE_SPECIALIZATION (decl
);
5031 if (TREE_CODE (decl
) == FUNCTION_DECL
)
5032 DECL_COMDAT (decl
) = (TREE_PUBLIC (decl
)
5033 && DECL_DECLARED_INLINE_P (decl
));
5035 DECL_COMDAT (decl
) = false;
5037 /* [temp.expl.spec] An explicit specialization of a static data
5038 member of a template is a definition if the declaration
5039 includes an initializer; otherwise, it is a declaration.
5041 We check for processing_specialization so this only applies
5042 to the new specialization syntax. */
5043 if (!initialized
&& processing_specialization
)
5044 DECL_EXTERNAL (decl
) = 1;
5047 if (DECL_EXTERNAL (decl
) && ! DECL_TEMPLATE_SPECIALIZATION (decl
)
5048 /* Aliases are definitions. */
5050 permerror (input_location
, "declaration of %q#D outside of class is not definition",
5054 was_public
= TREE_PUBLIC (decl
);
5056 /* Enter this declaration into the symbol table. Don't push the plain
5057 VAR_DECL for a variable template. */
5058 if (!template_parm_scope_p ()
5060 decl
= maybe_push_decl (decl
);
5062 if (processing_template_decl
)
5063 decl
= push_template_decl (decl
);
5064 if (decl
== error_mark_node
)
5065 return error_mark_node
;
5068 && DECL_NAMESPACE_SCOPE_P (decl
) && !TREE_PUBLIC (decl
) && !was_public
5069 && !DECL_THIS_STATIC (decl
) && !DECL_ARTIFICIAL (decl
))
5071 /* This is a const variable with implicit 'static'. Set
5072 DECL_THIS_STATIC so we can tell it from variables that are
5073 !TREE_PUBLIC because of the anonymous namespace. */
5074 gcc_assert (CP_TYPE_CONST_P (TREE_TYPE (decl
)) || errorcount
);
5075 DECL_THIS_STATIC (decl
) = 1;
5078 if (current_function_decl
&& VAR_P (decl
)
5079 && DECL_DECLARED_CONSTEXPR_P (current_function_decl
))
5082 if (CP_DECL_THREAD_LOCAL_P (decl
))
5083 error ("%qD declared %<thread_local%> in %<constexpr%> function",
5085 else if (TREE_STATIC (decl
))
5086 error ("%qD declared %<static%> in %<constexpr%> function", decl
);
5090 cp_function_chain
->invalid_constexpr
= true;
5093 if (!processing_template_decl
&& VAR_P (decl
))
5094 start_decl_1 (decl
, initialized
);
5099 /* Process the declaration of a variable DECL. INITIALIZED is true
5100 iff DECL is explicitly initialized. (INITIALIZED is false if the
5101 variable is initialized via an implicitly-called constructor.)
5102 This function must be called for ordinary variables (including, for
5103 example, implicit instantiations of templates), but must not be
5104 called for template declarations. */
5107 start_decl_1 (tree decl
, bool initialized
)
5111 bool aggregate_definition_p
;
5113 gcc_assert (!processing_template_decl
);
5115 if (error_operand_p (decl
))
5118 gcc_assert (VAR_P (decl
));
5120 type
= TREE_TYPE (decl
);
5121 complete_p
= COMPLETE_TYPE_P (type
);
5122 aggregate_definition_p
= MAYBE_CLASS_TYPE_P (type
) && !DECL_EXTERNAL (decl
);
5124 /* If an explicit initializer is present, or if this is a definition
5125 of an aggregate, then we need a complete type at this point.
5126 (Scalars are always complete types, so there is nothing to
5127 check.) This code just sets COMPLETE_P; errors (if necessary)
5128 are issued below. */
5129 if ((initialized
|| aggregate_definition_p
)
5131 && COMPLETE_TYPE_P (complete_type (type
)))
5134 /* We will not yet have set TREE_READONLY on DECL if the type
5135 was "const", but incomplete, before this point. But, now, we
5136 have a complete type, so we can try again. */
5137 cp_apply_type_quals_to_decl (cp_type_quals (type
), decl
);
5141 /* Is it valid for this decl to have an initializer at all? */
5143 /* Don't allow initializations for incomplete types except for
5144 arrays which might be completed by the initialization. */
5146 ; /* A complete type is ok. */
5147 else if (type_uses_auto (type
))
5148 ; /* An auto type is ok. */
5149 else if (TREE_CODE (type
) != ARRAY_TYPE
)
5151 error ("variable %q#D has initializer but incomplete type", decl
);
5152 type
= TREE_TYPE (decl
) = error_mark_node
;
5154 else if (!COMPLETE_TYPE_P (complete_type (TREE_TYPE (type
))))
5156 if (DECL_LANG_SPECIFIC (decl
) && DECL_TEMPLATE_INFO (decl
))
5157 error ("elements of array %q#D have incomplete type", decl
);
5158 /* else we already gave an error in start_decl. */
5161 else if (aggregate_definition_p
&& !complete_p
)
5163 if (type_uses_auto (type
))
5164 gcc_assert (CLASS_PLACEHOLDER_TEMPLATE (type
));
5167 error ("aggregate %q#D has incomplete type and cannot be defined",
5169 /* Change the type so that assemble_variable will give
5170 DECL an rtl we can live with: (mem (const_int 0)). */
5171 type
= TREE_TYPE (decl
) = error_mark_node
;
5175 /* Create a new scope to hold this declaration if necessary.
5176 Whether or not a new scope is necessary cannot be determined
5177 until after the type has been completed; if the type is a
5178 specialization of a class template it is not until after
5179 instantiation has occurred that TYPE_HAS_NONTRIVIAL_DESTRUCTOR
5180 will be set correctly. */
5181 maybe_push_cleanup_level (type
);
5184 /* Handle initialization of references. DECL, TYPE, and INIT have the
5185 same meaning as in cp_finish_decl. *CLEANUP must be NULL on entry,
5186 but will be set to a new CLEANUP_STMT if a temporary is created
5187 that must be destroyed subsequently.
5189 Returns an initializer expression to use to initialize DECL, or
5190 NULL if the initialization can be performed statically.
5192 Quotes on semantics can be found in ARM 8.4.3. */
5195 grok_reference_init (tree decl
, tree type
, tree init
, int flags
)
5197 if (init
== NULL_TREE
)
5199 if ((DECL_LANG_SPECIFIC (decl
) == 0
5200 || DECL_IN_AGGR_P (decl
) == 0)
5201 && ! DECL_THIS_EXTERN (decl
))
5202 error ("%qD declared as reference but not initialized", decl
);
5206 if (TREE_CODE (init
) == TREE_LIST
)
5207 init
= build_x_compound_expr_from_list (init
, ELK_INIT
,
5208 tf_warning_or_error
);
5210 tree ttype
= TREE_TYPE (type
);
5211 if (TREE_CODE (ttype
) != ARRAY_TYPE
5212 && TREE_CODE (TREE_TYPE (init
)) == ARRAY_TYPE
)
5213 /* Note: default conversion is only called in very special cases. */
5214 init
= decay_conversion (init
, tf_warning_or_error
);
5216 /* check_initializer handles this for non-reference variables, but for
5217 references we need to do it here or the initializer will get the
5218 incomplete array type and confuse later calls to
5219 cp_complete_array_type. */
5220 if (TREE_CODE (ttype
) == ARRAY_TYPE
5221 && TYPE_DOMAIN (ttype
) == NULL_TREE
5222 && (BRACE_ENCLOSED_INITIALIZER_P (init
)
5223 || TREE_CODE (init
) == STRING_CST
))
5225 cp_complete_array_type (&ttype
, init
, false);
5226 if (ttype
!= TREE_TYPE (type
))
5227 type
= cp_build_reference_type (ttype
, TYPE_REF_IS_RVALUE (type
));
5230 /* Convert INIT to the reference type TYPE. This may involve the
5231 creation of a temporary, whose lifetime must be the same as that
5232 of the reference. If so, a DECL_EXPR for the temporary will be
5233 added just after the DECL_EXPR for DECL. That's why we don't set
5234 DECL_INITIAL for local references (instead assigning to them
5235 explicitly); we need to allow the temporary to be initialized
5237 return initialize_reference (type
, init
, flags
,
5238 tf_warning_or_error
);
5241 /* Designated initializers in arrays are not supported in GNU C++.
5242 The parser cannot detect this error since it does not know whether
5243 a given brace-enclosed initializer is for a class type or for an
5244 array. This function checks that CE does not use a designated
5245 initializer. If it does, an error is issued. Returns true if CE
5246 is valid, i.e., does not have a designated initializer. */
5249 check_array_designated_initializer (constructor_elt
*ce
,
5250 unsigned HOST_WIDE_INT index
)
5252 /* Designated initializers for array elements are not supported. */
5255 /* The parser only allows identifiers as designated
5257 if (ce
->index
== error_mark_node
)
5259 error ("name used in a GNU-style designated "
5260 "initializer for an array");
5263 else if (identifier_p (ce
->index
))
5265 error ("name %qD used in a GNU-style designated "
5266 "initializer for an array", ce
->index
);
5270 tree ce_index
= build_expr_type_conversion (WANT_INT
| WANT_ENUM
,
5273 && INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (TREE_TYPE (ce_index
))
5274 && (TREE_CODE (ce_index
= maybe_constant_value (ce_index
))
5277 /* A C99 designator is OK if it matches the current index. */
5278 if (wi::to_wide (ce_index
) == index
)
5281 sorry ("non-trivial designated initializers not supported");
5284 error ("C99 designator %qE is not an integral constant-expression",
5293 /* When parsing `int a[] = {1, 2};' we don't know the size of the
5294 array until we finish parsing the initializer. If that's the
5295 situation we're in, update DECL accordingly. */
5298 maybe_deduce_size_from_array_init (tree decl
, tree init
)
5300 tree type
= TREE_TYPE (decl
);
5302 if (TREE_CODE (type
) == ARRAY_TYPE
5303 && TYPE_DOMAIN (type
) == NULL_TREE
5304 && TREE_CODE (decl
) != TYPE_DECL
)
5306 /* do_default is really a C-ism to deal with tentative definitions.
5307 But let's leave it here to ease the eventual merge. */
5308 int do_default
= !DECL_EXTERNAL (decl
);
5309 tree initializer
= init
? init
: DECL_INITIAL (decl
);
5312 /* Check that there are no designated initializers in INIT, as
5313 those are not supported in GNU C++, and as the middle-end
5314 will crash if presented with a non-numeric designated
5316 if (initializer
&& BRACE_ENCLOSED_INITIALIZER_P (initializer
))
5318 vec
<constructor_elt
, va_gc
> *v
= CONSTRUCTOR_ELTS (initializer
);
5319 constructor_elt
*ce
;
5321 FOR_EACH_VEC_SAFE_ELT (v
, i
, ce
)
5322 if (!check_array_designated_initializer (ce
, i
))
5328 failure
= cp_complete_array_type (&TREE_TYPE (decl
), initializer
,
5332 error_at (EXPR_LOC_OR_LOC (initializer
,
5333 DECL_SOURCE_LOCATION (decl
)),
5334 "initializer fails to determine size of %qD", decl
);
5336 else if (failure
== 2)
5340 error_at (DECL_SOURCE_LOCATION (decl
),
5341 "array size missing in %qD", decl
);
5343 /* If a `static' var's size isn't known, make it extern as
5344 well as static, so it does not get allocated. If it's not
5345 `static', then don't mark it extern; finish_incomplete_decl
5346 will give it a default size and it will get allocated. */
5347 else if (!pedantic
&& TREE_STATIC (decl
) && !TREE_PUBLIC (decl
))
5348 DECL_EXTERNAL (decl
) = 1;
5350 else if (failure
== 3)
5352 error_at (DECL_SOURCE_LOCATION (decl
),
5353 "zero-size array %qD", decl
);
5357 cp_apply_type_quals_to_decl (cp_type_quals (TREE_TYPE (decl
)), decl
);
5359 relayout_decl (decl
);
5363 /* Set DECL_SIZE, DECL_ALIGN, etc. for DECL (a VAR_DECL), and issue
5364 any appropriate error messages regarding the layout. */
5367 layout_var_decl (tree decl
)
5371 type
= TREE_TYPE (decl
);
5372 if (type
== error_mark_node
)
5375 /* If we haven't already laid out this declaration, do so now.
5376 Note that we must not call complete type for an external object
5377 because it's type might involve templates that we are not
5378 supposed to instantiate yet. (And it's perfectly valid to say
5379 `extern X x' for some incomplete type `X'.) */
5380 if (!DECL_EXTERNAL (decl
))
5381 complete_type (type
);
5382 if (!DECL_SIZE (decl
)
5383 && TREE_TYPE (decl
) != error_mark_node
5384 && complete_or_array_type_p (type
))
5385 layout_decl (decl
, 0);
5387 if (!DECL_EXTERNAL (decl
) && DECL_SIZE (decl
) == NULL_TREE
)
5389 /* An automatic variable with an incomplete type: that is an error.
5390 Don't talk about array types here, since we took care of that
5391 message in grokdeclarator. */
5392 error_at (DECL_SOURCE_LOCATION (decl
),
5393 "storage size of %qD isn%'t known", decl
);
5394 TREE_TYPE (decl
) = error_mark_node
;
5397 /* Keep this code around in case we later want to control debug info
5398 based on whether a type is "used". (jason 1999-11-11) */
5400 else if (!DECL_EXTERNAL (decl
) && MAYBE_CLASS_TYPE_P (ttype
))
5401 /* Let debugger know it should output info for this type. */
5402 note_debug_info_needed (ttype
);
5404 if (TREE_STATIC (decl
) && DECL_CLASS_SCOPE_P (decl
))
5405 note_debug_info_needed (DECL_CONTEXT (decl
));
5408 if ((DECL_EXTERNAL (decl
) || TREE_STATIC (decl
))
5409 && DECL_SIZE (decl
) != NULL_TREE
5410 && ! TREE_CONSTANT (DECL_SIZE (decl
)))
5412 if (TREE_CODE (DECL_SIZE (decl
)) == INTEGER_CST
)
5413 constant_expression_warning (DECL_SIZE (decl
));
5416 error_at (DECL_SOURCE_LOCATION (decl
),
5417 "storage size of %qD isn%'t constant", decl
);
5418 TREE_TYPE (decl
) = error_mark_node
;
5423 /* If a local static variable is declared in an inline function, or if
5424 we have a weak definition, we must endeavor to create only one
5425 instance of the variable at link-time. */
5428 maybe_commonize_var (tree decl
)
5430 /* Static data in a function with comdat linkage also has comdat
5432 if ((TREE_STATIC (decl
)
5433 /* Don't mess with __FUNCTION__. */
5434 && ! DECL_ARTIFICIAL (decl
)
5435 && DECL_FUNCTION_SCOPE_P (decl
)
5436 && vague_linkage_p (DECL_CONTEXT (decl
)))
5437 || (TREE_PUBLIC (decl
) && DECL_INLINE_VAR_P (decl
)))
5441 /* With weak symbols, we simply make the variable COMDAT;
5442 that will cause copies in multiple translations units to
5444 comdat_linkage (decl
);
5448 if (DECL_INITIAL (decl
) == NULL_TREE
5449 || DECL_INITIAL (decl
) == error_mark_node
)
5451 /* Without weak symbols, we can use COMMON to merge
5452 uninitialized variables. */
5453 TREE_PUBLIC (decl
) = 1;
5454 DECL_COMMON (decl
) = 1;
5458 /* While for initialized variables, we must use internal
5459 linkage -- which means that multiple copies will not
5461 TREE_PUBLIC (decl
) = 0;
5462 DECL_COMMON (decl
) = 0;
5464 if (DECL_INLINE_VAR_P (decl
))
5465 msg
= G_("sorry: semantics of inline variable "
5466 "%q#D are wrong (you%'ll wind up with "
5467 "multiple copies)");
5469 msg
= G_("sorry: semantics of inline function "
5470 "static data %q#D are wrong (you%'ll wind "
5471 "up with multiple copies)");
5472 if (warning_at (DECL_SOURCE_LOCATION (decl
), 0,
5474 inform (DECL_SOURCE_LOCATION (decl
),
5475 "you can work around this by removing the initializer");
5481 /* Issue an error message if DECL is an uninitialized const variable. */
5484 check_for_uninitialized_const_var (tree decl
)
5486 tree type
= strip_array_types (TREE_TYPE (decl
));
5488 /* ``Unless explicitly declared extern, a const object does not have
5489 external linkage and must be initialized. ($8.4; $12.1)'' ARM
5492 && TREE_CODE (type
) != REFERENCE_TYPE
5493 && (CP_TYPE_CONST_P (type
) || var_in_constexpr_fn (decl
))
5494 && !DECL_INITIAL (decl
))
5496 tree field
= default_init_uninitialized_part (type
);
5500 if (CP_TYPE_CONST_P (type
))
5501 permerror (DECL_SOURCE_LOCATION (decl
),
5502 "uninitialized const %qD", decl
);
5505 if (!is_instantiation_of_constexpr (current_function_decl
))
5506 error_at (DECL_SOURCE_LOCATION (decl
),
5507 "uninitialized variable %qD in %<constexpr%> function",
5509 cp_function_chain
->invalid_constexpr
= true;
5512 if (CLASS_TYPE_P (type
))
5514 tree defaulted_ctor
;
5516 inform (DECL_SOURCE_LOCATION (TYPE_MAIN_DECL (type
)),
5517 "%q#T has no user-provided default constructor", type
);
5518 defaulted_ctor
= in_class_defaulted_default_constructor (type
);
5520 inform (DECL_SOURCE_LOCATION (defaulted_ctor
),
5521 "constructor is not user-provided because it is "
5522 "explicitly defaulted in the class body");
5523 inform (DECL_SOURCE_LOCATION (field
),
5524 "and the implicitly-defined constructor does not "
5525 "initialize %q#D", field
);
5530 /* Structure holding the current initializer being processed by reshape_init.
5531 CUR is a pointer to the current element being processed, END is a pointer
5532 after the last element present in the initializer. */
5535 constructor_elt
*cur
;
5536 constructor_elt
*end
;
5539 static tree
reshape_init_r (tree
, reshape_iter
*, bool, tsubst_flags_t
);
5541 /* FIELD is a FIELD_DECL or NULL. In the former case, the value
5542 returned is the next FIELD_DECL (possibly FIELD itself) that can be
5543 initialized. If there are no more such fields, the return value
5547 next_initializable_field (tree field
)
5550 && (TREE_CODE (field
) != FIELD_DECL
5551 || (DECL_C_BIT_FIELD (field
) && !DECL_NAME (field
))
5552 || (DECL_ARTIFICIAL (field
)
5553 && !(cxx_dialect
>= cxx17
&& DECL_FIELD_IS_BASE (field
)))))
5554 field
= DECL_CHAIN (field
);
5559 /* Return true for [dcl.init.list] direct-list-initialization from
5560 single element of enumeration with a fixed underlying type. */
5563 is_direct_enum_init (tree type
, tree init
)
5565 if (cxx_dialect
>= cxx17
5566 && TREE_CODE (type
) == ENUMERAL_TYPE
5567 && ENUM_FIXED_UNDERLYING_TYPE_P (type
)
5568 && TREE_CODE (init
) == CONSTRUCTOR
5569 && CONSTRUCTOR_IS_DIRECT_INIT (init
)
5570 && CONSTRUCTOR_NELTS (init
) == 1)
5575 /* Subroutine of reshape_init_array and reshape_init_vector, which does
5576 the actual work. ELT_TYPE is the element type of the array. MAX_INDEX is an
5577 INTEGER_CST representing the size of the array minus one (the maximum index),
5578 or NULL_TREE if the array was declared without specifying the size. D is
5579 the iterator within the constructor. */
5582 reshape_init_array_1 (tree elt_type
, tree max_index
, reshape_iter
*d
,
5583 tsubst_flags_t complain
)
5586 bool sized_array_p
= (max_index
&& TREE_CONSTANT (max_index
));
5587 unsigned HOST_WIDE_INT max_index_cst
= 0;
5588 unsigned HOST_WIDE_INT index
;
5590 /* The initializer for an array is always a CONSTRUCTOR. */
5591 new_init
= build_constructor (init_list_type_node
, NULL
);
5595 /* Minus 1 is used for zero sized arrays. */
5596 if (integer_all_onesp (max_index
))
5599 if (tree_fits_uhwi_p (max_index
))
5600 max_index_cst
= tree_to_uhwi (max_index
);
5601 /* sizetype is sign extended, not zero extended. */
5603 max_index_cst
= tree_to_uhwi (fold_convert (size_type_node
, max_index
));
5606 /* Loop until there are no more initializers. */
5608 d
->cur
!= d
->end
&& (!sized_array_p
|| index
<= max_index_cst
);
5612 constructor_elt
*old_cur
= d
->cur
;
5614 check_array_designated_initializer (d
->cur
, index
);
5615 elt_init
= reshape_init_r (elt_type
, d
, /*first_initializer_p=*/false,
5617 if (elt_init
== error_mark_node
)
5618 return error_mark_node
;
5619 CONSTRUCTOR_APPEND_ELT (CONSTRUCTOR_ELTS (new_init
),
5620 size_int (index
), elt_init
);
5621 if (!TREE_CONSTANT (elt_init
))
5622 TREE_CONSTANT (new_init
) = false;
5624 /* This can happen with an invalid initializer (c++/54501). */
5625 if (d
->cur
== old_cur
&& !sized_array_p
)
5632 /* Subroutine of reshape_init_r, processes the initializers for arrays.
5633 Parameters are the same of reshape_init_r. */
5636 reshape_init_array (tree type
, reshape_iter
*d
, tsubst_flags_t complain
)
5638 tree max_index
= NULL_TREE
;
5640 gcc_assert (TREE_CODE (type
) == ARRAY_TYPE
);
5642 if (TYPE_DOMAIN (type
))
5643 max_index
= array_type_nelts (type
);
5645 return reshape_init_array_1 (TREE_TYPE (type
), max_index
, d
, complain
);
5648 /* Subroutine of reshape_init_r, processes the initializers for vectors.
5649 Parameters are the same of reshape_init_r. */
5652 reshape_init_vector (tree type
, reshape_iter
*d
, tsubst_flags_t complain
)
5654 tree max_index
= NULL_TREE
;
5656 gcc_assert (VECTOR_TYPE_P (type
));
5658 if (COMPOUND_LITERAL_P (d
->cur
->value
))
5660 tree value
= d
->cur
->value
;
5661 if (!same_type_p (TREE_TYPE (value
), type
))
5663 if (complain
& tf_error
)
5664 error ("invalid type %qT as initializer for a vector of type %qT",
5665 TREE_TYPE (d
->cur
->value
), type
);
5666 value
= error_mark_node
;
5672 /* For a vector, we initialize it as an array of the appropriate size. */
5673 if (VECTOR_TYPE_P (type
))
5674 max_index
= size_int (TYPE_VECTOR_SUBPARTS (type
) - 1);
5676 return reshape_init_array_1 (TREE_TYPE (type
), max_index
, d
, complain
);
5679 /* Subroutine of reshape_init_r, processes the initializers for classes
5680 or union. Parameters are the same of reshape_init_r. */
5683 reshape_init_class (tree type
, reshape_iter
*d
, bool first_initializer_p
,
5684 tsubst_flags_t complain
)
5689 gcc_assert (CLASS_TYPE_P (type
));
5691 /* The initializer for a class is always a CONSTRUCTOR. */
5692 new_init
= build_constructor (init_list_type_node
, NULL
);
5693 field
= next_initializable_field (TYPE_FIELDS (type
));
5699 An initializer for an aggregate member that is an
5700 empty class shall have the form of an empty
5701 initializer-list {}. */
5702 if (!first_initializer_p
)
5704 if (complain
& tf_error
)
5705 error ("initializer for %qT must be brace-enclosed", type
);
5706 return error_mark_node
;
5711 /* Loop through the initializable fields, gathering initializers. */
5712 while (d
->cur
!= d
->end
)
5715 constructor_elt
*old_cur
= d
->cur
;
5717 /* Handle designated initializers, as an extension. */
5720 if (d
->cur
->index
== error_mark_node
)
5721 return error_mark_node
;
5723 if (TREE_CODE (d
->cur
->index
) == FIELD_DECL
)
5724 /* We already reshaped this. */
5725 gcc_assert (d
->cur
->index
== field
);
5726 else if (TREE_CODE (d
->cur
->index
) == IDENTIFIER_NODE
)
5727 field
= get_class_binding (type
, d
->cur
->index
, false);
5730 if (complain
& tf_error
)
5731 error ("%<[%E] =%> used in a GNU-style designated initializer"
5732 " for class %qT", d
->cur
->index
, type
);
5733 return error_mark_node
;
5736 if (!field
|| TREE_CODE (field
) != FIELD_DECL
)
5738 if (complain
& tf_error
)
5739 error ("%qT has no non-static data member named %qD", type
,
5741 return error_mark_node
;
5745 /* If we processed all the member of the class, we are done. */
5749 field_init
= reshape_init_r (TREE_TYPE (field
), d
,
5750 /*first_initializer_p=*/false, complain
);
5751 if (field_init
== error_mark_node
)
5752 return error_mark_node
;
5754 if (d
->cur
== old_cur
&& d
->cur
->index
)
5756 /* This can happen with an invalid initializer for a flexible
5757 array member (c++/54441). */
5758 if (complain
& tf_error
)
5759 error ("invalid initializer for %q#D", field
);
5760 return error_mark_node
;
5763 CONSTRUCTOR_APPEND_ELT (CONSTRUCTOR_ELTS (new_init
), field
, field_init
);
5767 When a union is initialized with a brace-enclosed
5768 initializer, the braces shall only contain an
5769 initializer for the first member of the union. */
5770 if (TREE_CODE (type
) == UNION_TYPE
)
5773 field
= next_initializable_field (DECL_CHAIN (field
));
5779 /* Subroutine of reshape_init_r. We're in a context where C99 initializer
5780 designators are not valid; either complain or return true to indicate
5781 that reshape_init_r should return error_mark_node. */
5784 has_designator_problem (reshape_iter
*d
, tsubst_flags_t complain
)
5788 if (complain
& tf_error
)
5789 error ("C99 designator %qE outside aggregate initializer",
5797 /* Subroutine of reshape_init, which processes a single initializer (part of
5798 a CONSTRUCTOR). TYPE is the type of the variable being initialized, D is the
5799 iterator within the CONSTRUCTOR which points to the initializer to process.
5800 FIRST_INITIALIZER_P is true if this is the first initializer of the
5801 outermost CONSTRUCTOR node. */
5804 reshape_init_r (tree type
, reshape_iter
*d
, bool first_initializer_p
,
5805 tsubst_flags_t complain
)
5807 tree init
= d
->cur
->value
;
5809 if (error_operand_p (init
))
5810 return error_mark_node
;
5812 if (first_initializer_p
&& !CP_AGGREGATE_TYPE_P (type
)
5813 && has_designator_problem (d
, complain
))
5814 return error_mark_node
;
5816 if (TREE_CODE (type
) == COMPLEX_TYPE
)
5818 /* A complex type can be initialized from one or two initializers,
5819 but braces are not elided. */
5821 if (BRACE_ENCLOSED_INITIALIZER_P (init
))
5823 if (CONSTRUCTOR_NELTS (init
) > 2)
5825 if (complain
& tf_error
)
5826 error ("too many initializers for %qT", type
);
5828 return error_mark_node
;
5831 else if (first_initializer_p
&& d
->cur
!= d
->end
)
5833 vec
<constructor_elt
, va_gc
> *v
= 0;
5834 CONSTRUCTOR_APPEND_ELT (v
, NULL_TREE
, init
);
5835 CONSTRUCTOR_APPEND_ELT (v
, NULL_TREE
, d
->cur
->value
);
5836 if (has_designator_problem (d
, complain
))
5837 return error_mark_node
;
5839 init
= build_constructor (init_list_type_node
, v
);
5844 /* A non-aggregate type is always initialized with a single
5846 if (!CP_AGGREGATE_TYPE_P (type
))
5848 /* It is invalid to initialize a non-aggregate type with a
5849 brace-enclosed initializer before C++0x.
5850 We need to check for BRACE_ENCLOSED_INITIALIZER_P here because
5851 of g++.old-deja/g++.mike/p7626.C: a pointer-to-member constant is
5852 a CONSTRUCTOR (with a record type). */
5853 if (TREE_CODE (init
) == CONSTRUCTOR
5854 /* Don't complain about a capture-init. */
5855 && !CONSTRUCTOR_IS_DIRECT_INIT (init
)
5856 && BRACE_ENCLOSED_INITIALIZER_P (init
)) /* p7626.C */
5858 if (SCALAR_TYPE_P (type
))
5860 if (cxx_dialect
< cxx11
5861 /* Isn't value-initialization. */
5862 || CONSTRUCTOR_NELTS (init
) > 0)
5864 if (complain
& tf_error
)
5865 error ("braces around scalar initializer for type %qT",
5867 init
= error_mark_node
;
5871 maybe_warn_cpp0x (CPP0X_INITIALIZER_LISTS
);
5878 /* "If T is a class type and the initializer list has a single element of
5879 type cv U, where U is T or a class derived from T, the object is
5880 initialized from that element." Even if T is an aggregate. */
5881 if (cxx_dialect
>= cxx11
&& (CLASS_TYPE_P (type
) || VECTOR_TYPE_P (type
))
5882 && first_initializer_p
5883 && d
->end
- d
->cur
== 1
5884 && reference_related_p (type
, TREE_TYPE (init
)))
5892 All implicit type conversions (clause _conv_) are considered when
5893 initializing the aggregate member with an initializer from an
5894 initializer-list. If the initializer can initialize a member,
5895 the member is initialized. Otherwise, if the member is itself a
5896 non-empty subaggregate, brace elision is assumed and the
5897 initializer is considered for the initialization of the first
5898 member of the subaggregate. */
5899 if (TREE_CODE (init
) != CONSTRUCTOR
5900 /* But don't try this for the first initializer, since that would be
5901 looking through the outermost braces; A a2 = { a1 }; is not a
5902 valid aggregate initialization. */
5903 && !first_initializer_p
5904 && (same_type_ignoring_top_level_qualifiers_p (type
, TREE_TYPE (init
))
5905 || can_convert_arg (type
, TREE_TYPE (init
), init
, LOOKUP_NORMAL
,
5912 /* [dcl.init.string]
5914 A char array (whether plain char, signed char, or unsigned char)
5915 can be initialized by a string-literal (optionally enclosed in
5916 braces); a wchar_t array can be initialized by a wide
5917 string-literal (optionally enclosed in braces). */
5918 if (TREE_CODE (type
) == ARRAY_TYPE
5919 && char_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (type
))))
5921 tree str_init
= init
;
5923 /* Strip one level of braces if and only if they enclose a single
5924 element (as allowed by [dcl.init.string]). */
5925 if (!first_initializer_p
5926 && TREE_CODE (str_init
) == CONSTRUCTOR
5927 && CONSTRUCTOR_NELTS (str_init
) == 1)
5929 str_init
= (*CONSTRUCTOR_ELTS (str_init
))[0].value
;
5932 /* If it's a string literal, then it's the initializer for the array
5933 as a whole. Otherwise, continue with normal initialization for
5934 array types (one value per array element). */
5935 if (TREE_CODE (str_init
) == STRING_CST
)
5937 if (has_designator_problem (d
, complain
))
5938 return error_mark_node
;
5944 /* The following cases are about aggregates. If we are not within a full
5945 initializer already, and there is not a CONSTRUCTOR, it means that there
5946 is a missing set of braces (that is, we are processing the case for
5947 which reshape_init exists). */
5948 if (!first_initializer_p
)
5950 if (TREE_CODE (init
) == CONSTRUCTOR
)
5952 if (TREE_TYPE (init
) && TYPE_PTRMEMFUNC_P (TREE_TYPE (init
)))
5953 /* There is no need to reshape pointer-to-member function
5954 initializers, as they are always constructed correctly
5955 by the front end. */
5957 else if (COMPOUND_LITERAL_P (init
))
5958 /* For a nested compound literal, there is no need to reshape since
5959 brace elision is not allowed. Even if we decided to allow it,
5960 we should add a call to reshape_init in finish_compound_literal,
5961 before calling digest_init, so changing this code would still
5962 not be necessary. */
5963 gcc_assert (!BRACE_ENCLOSED_INITIALIZER_P (init
));
5967 gcc_assert (BRACE_ENCLOSED_INITIALIZER_P (init
));
5968 return reshape_init (type
, init
, complain
);
5972 if (complain
& tf_warning
)
5973 warning (OPT_Wmissing_braces
,
5974 "missing braces around initializer for %qT",
5978 /* Dispatch to specialized routines. */
5979 if (CLASS_TYPE_P (type
))
5980 return reshape_init_class (type
, d
, first_initializer_p
, complain
);
5981 else if (TREE_CODE (type
) == ARRAY_TYPE
)
5982 return reshape_init_array (type
, d
, complain
);
5983 else if (VECTOR_TYPE_P (type
))
5984 return reshape_init_vector (type
, d
, complain
);
5989 /* Undo the brace-elision allowed by [dcl.init.aggr] in a
5990 brace-enclosed aggregate initializer.
5992 INIT is the CONSTRUCTOR containing the list of initializers describing
5993 a brace-enclosed initializer for an entity of the indicated aggregate TYPE.
5994 It may not presently match the shape of the TYPE; for example:
5996 struct S { int a; int b; };
5997 struct S a[] = { 1, 2, 3, 4 };
5999 Here INIT will hold a vector of four elements, rather than a
6000 vector of two elements, each itself a vector of two elements. This
6001 routine transforms INIT from the former form into the latter. The
6002 revised CONSTRUCTOR node is returned. */
6005 reshape_init (tree type
, tree init
, tsubst_flags_t complain
)
6007 vec
<constructor_elt
, va_gc
> *v
;
6011 gcc_assert (BRACE_ENCLOSED_INITIALIZER_P (init
));
6013 v
= CONSTRUCTOR_ELTS (init
);
6015 /* An empty constructor does not need reshaping, and it is always a valid
6017 if (vec_safe_is_empty (v
))
6020 /* Handle [dcl.init.list] direct-list-initialization from
6021 single element of enumeration with a fixed underlying type. */
6022 if (is_direct_enum_init (type
, init
))
6024 tree elt
= CONSTRUCTOR_ELT (init
, 0)->value
;
6025 type
= cv_unqualified (type
);
6026 if (check_narrowing (ENUM_UNDERLYING_TYPE (type
), elt
, complain
))
6028 warning_sentinel
w (warn_useless_cast
);
6029 return cp_build_c_cast (type
, elt
, tf_warning_or_error
);
6032 return error_mark_node
;
6035 /* Recurse on this CONSTRUCTOR. */
6037 d
.end
= d
.cur
+ v
->length ();
6039 new_init
= reshape_init_r (type
, &d
, true, complain
);
6040 if (new_init
== error_mark_node
)
6041 return error_mark_node
;
6043 /* Make sure all the element of the constructor were used. Otherwise,
6044 issue an error about exceeding initializers. */
6047 if (complain
& tf_error
)
6048 error ("too many initializers for %qT", type
);
6049 return error_mark_node
;
6052 if (CONSTRUCTOR_IS_DIRECT_INIT (init
)
6053 && BRACE_ENCLOSED_INITIALIZER_P (new_init
))
6054 CONSTRUCTOR_IS_DIRECT_INIT (new_init
) = true;
6059 /* Verify array initializer. Returns true if errors have been reported. */
6062 check_array_initializer (tree decl
, tree type
, tree init
)
6064 tree element_type
= TREE_TYPE (type
);
6066 /* The array type itself need not be complete, because the
6067 initializer may tell us how many elements are in the array.
6068 But, the elements of the array must be complete. */
6069 if (!COMPLETE_TYPE_P (complete_type (element_type
)))
6072 error_at (DECL_SOURCE_LOCATION (decl
),
6073 "elements of array %q#D have incomplete type", decl
);
6075 error ("elements of array %q#T have incomplete type", type
);
6078 /* A compound literal can't have variable size. */
6080 && ((COMPLETE_TYPE_P (type
) && !TREE_CONSTANT (TYPE_SIZE (type
)))
6081 || !TREE_CONSTANT (TYPE_SIZE (element_type
))))
6083 error ("variable-sized compound literal");
6089 /* Subroutine of check_initializer; args are passed down from that function.
6090 Set stmts_are_full_exprs_p to 1 across a call to build_aggr_init. */
6093 build_aggr_init_full_exprs (tree decl
, tree init
, int flags
)
6096 gcc_assert (stmts_are_full_exprs_p ());
6097 return build_aggr_init (decl
, init
, flags
, tf_warning_or_error
);
6100 /* Verify INIT (the initializer for DECL), and record the
6101 initialization in DECL_INITIAL, if appropriate. CLEANUP is as for
6102 grok_reference_init.
6104 If the return value is non-NULL, it is an expression that must be
6105 evaluated dynamically to initialize DECL. */
6108 check_initializer (tree decl
, tree init
, int flags
, vec
<tree
, va_gc
> **cleanups
)
6110 tree type
= TREE_TYPE (decl
);
6111 tree init_code
= NULL
;
6114 /* Things that are going to be initialized need to have complete
6116 TREE_TYPE (decl
) = type
= complete_type (TREE_TYPE (decl
));
6118 if (DECL_HAS_VALUE_EXPR_P (decl
))
6120 /* A variable with DECL_HAS_VALUE_EXPR_P set is just a placeholder,
6121 it doesn't have storage to be initialized. */
6122 gcc_assert (init
== NULL_TREE
);
6126 if (type
== error_mark_node
)
6127 /* We will have already complained. */
6130 if (TREE_CODE (type
) == ARRAY_TYPE
)
6132 if (check_array_initializer (decl
, type
, init
))
6135 else if (!COMPLETE_TYPE_P (type
))
6137 error_at (DECL_SOURCE_LOCATION (decl
),
6138 "%q#D has incomplete type", decl
);
6139 TREE_TYPE (decl
) = error_mark_node
;
6143 /* There is no way to make a variable-sized class type in GNU C++. */
6144 gcc_assert (TREE_CONSTANT (TYPE_SIZE (type
)));
6146 if (init
&& BRACE_ENCLOSED_INITIALIZER_P (init
))
6148 int init_len
= CONSTRUCTOR_NELTS (init
);
6149 if (SCALAR_TYPE_P (type
))
6153 maybe_warn_cpp0x (CPP0X_INITIALIZER_LISTS
);
6154 init
= build_zero_init (type
, NULL_TREE
, false);
6156 else if (init_len
!= 1 && TREE_CODE (type
) != COMPLEX_TYPE
)
6158 error_at (EXPR_LOC_OR_LOC (init
, DECL_SOURCE_LOCATION (decl
)),
6159 "scalar object %qD requires one element in "
6160 "initializer", decl
);
6161 TREE_TYPE (decl
) = error_mark_node
;
6167 if (TREE_CODE (decl
) == CONST_DECL
)
6169 gcc_assert (TREE_CODE (type
) != REFERENCE_TYPE
);
6171 DECL_INITIAL (decl
) = init
;
6173 gcc_assert (init
!= NULL_TREE
);
6176 else if (!init
&& DECL_REALLY_EXTERN (decl
))
6178 else if (init
|| type_build_ctor_call (type
)
6179 || TREE_CODE (type
) == REFERENCE_TYPE
)
6181 if (TREE_CODE (type
) == REFERENCE_TYPE
)
6183 init
= grok_reference_init (decl
, type
, init
, flags
);
6184 flags
|= LOOKUP_ALREADY_DIGESTED
;
6187 check_for_uninitialized_const_var (decl
);
6188 /* Do not reshape constructors of vectors (they don't need to be
6190 else if (BRACE_ENCLOSED_INITIALIZER_P (init
))
6192 if (is_std_init_list (type
))
6194 init
= perform_implicit_conversion (type
, init
,
6195 tf_warning_or_error
);
6196 flags
|= LOOKUP_ALREADY_DIGESTED
;
6198 else if (TYPE_NON_AGGREGATE_CLASS (type
))
6200 /* Don't reshape if the class has constructors. */
6201 if (cxx_dialect
== cxx98
)
6202 error_at (EXPR_LOC_OR_LOC (init
, DECL_SOURCE_LOCATION (decl
)),
6203 "in C++98 %qD must be initialized by "
6204 "constructor, not by %<{...}%>",
6207 else if (VECTOR_TYPE_P (type
) && TYPE_VECTOR_OPAQUE (type
))
6209 error ("opaque vector types cannot be initialized");
6210 init
= error_mark_node
;
6214 init
= reshape_init (type
, init
, tf_warning_or_error
);
6215 flags
|= LOOKUP_NO_NARROWING
;
6218 else if (TREE_CODE (init
) == TREE_LIST
6219 && TREE_TYPE (init
) != unknown_type_node
6220 && !MAYBE_CLASS_TYPE_P (type
))
6222 gcc_assert (TREE_CODE (decl
) != RESULT_DECL
);
6224 /* We get here with code like `int a (2);' */
6225 init
= build_x_compound_expr_from_list (init
, ELK_INIT
,
6226 tf_warning_or_error
);
6229 /* If DECL has an array type without a specific bound, deduce the
6230 array size from the initializer. */
6231 maybe_deduce_size_from_array_init (decl
, init
);
6232 type
= TREE_TYPE (decl
);
6233 if (type
== error_mark_node
)
6236 if (((type_build_ctor_call (type
) || CLASS_TYPE_P (type
))
6237 && !(flags
& LOOKUP_ALREADY_DIGESTED
)
6238 && !(init
&& BRACE_ENCLOSED_INITIALIZER_P (init
)
6239 && CP_AGGREGATE_TYPE_P (type
)
6240 && (CLASS_TYPE_P (type
)
6241 || !TYPE_NEEDS_CONSTRUCTING (type
)
6242 || type_has_extended_temps (type
))))
6243 || (DECL_DECOMPOSITION_P (decl
) && TREE_CODE (type
) == ARRAY_TYPE
))
6245 init_code
= build_aggr_init_full_exprs (decl
, init
, flags
);
6247 /* A constructor call is a non-trivial initializer even if
6248 it isn't explicitly written. */
6249 if (TREE_SIDE_EFFECTS (init_code
))
6250 DECL_NONTRIVIALLY_INITIALIZED_P (decl
) = true;
6252 /* If this is a constexpr initializer, expand_default_init will
6253 have returned an INIT_EXPR rather than a CALL_EXPR. In that
6254 case, pull the initializer back out and pass it down into
6255 store_init_value. */
6256 while (TREE_CODE (init_code
) == EXPR_STMT
6257 || TREE_CODE (init_code
) == CONVERT_EXPR
)
6258 init_code
= TREE_OPERAND (init_code
, 0);
6259 if (TREE_CODE (init_code
) == INIT_EXPR
)
6261 init
= TREE_OPERAND (init_code
, 1);
6262 init_code
= NULL_TREE
;
6263 /* Don't call digest_init; it's unnecessary and will complain
6264 about aggregate initialization of non-aggregate classes. */
6265 flags
|= LOOKUP_ALREADY_DIGESTED
;
6267 else if (DECL_DECLARED_CONSTEXPR_P (decl
))
6269 /* Declared constexpr, but no suitable initializer; massage
6270 init appropriately so we can pass it into store_init_value
6272 if (CLASS_TYPE_P (type
)
6273 && (!init
|| TREE_CODE (init
) == TREE_LIST
))
6275 init
= build_functional_cast (type
, init
, tf_none
);
6276 if (TREE_CODE (init
) == TARGET_EXPR
)
6277 TARGET_EXPR_DIRECT_INIT_P (init
) = true;
6279 init_code
= NULL_TREE
;
6285 if (init
&& TREE_CODE (init
) != TREE_VEC
)
6287 /* In aggregate initialization of a variable, each element
6288 initialization is a full-expression because there is no
6289 enclosing expression. */
6290 gcc_assert (stmts_are_full_exprs_p ());
6292 init_code
= store_init_value (decl
, init
, cleanups
, flags
);
6294 if (pedantic
&& TREE_CODE (type
) == ARRAY_TYPE
6295 && DECL_INITIAL (decl
)
6296 && TREE_CODE (DECL_INITIAL (decl
)) == STRING_CST
6297 && PAREN_STRING_LITERAL_P (DECL_INITIAL (decl
)))
6298 warning_at (EXPR_LOC_OR_LOC (DECL_INITIAL (decl
),
6299 DECL_SOURCE_LOCATION (decl
)),
6300 0, "array %qD initialized by parenthesized "
6301 "string literal %qE",
6302 decl
, DECL_INITIAL (decl
));
6308 if (CLASS_TYPE_P (core_type
= strip_array_types (type
))
6309 && (CLASSTYPE_READONLY_FIELDS_NEED_INIT (core_type
)
6310 || CLASSTYPE_REF_FIELDS_NEED_INIT (core_type
)))
6311 diagnose_uninitialized_cst_or_ref_member (core_type
, /*using_new=*/false,
6314 check_for_uninitialized_const_var (decl
);
6317 if (init
&& init
!= error_mark_node
)
6318 init_code
= build2 (INIT_EXPR
, type
, decl
, init
);
6322 /* We might have set these in cp_finish_decl. */
6323 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (decl
) = false;
6324 TREE_CONSTANT (decl
) = false;
6328 && (DECL_IN_AGGR_P (decl
) && !DECL_VAR_DECLARED_INLINE_P (decl
)))
6330 static int explained
= 0;
6332 if (cxx_dialect
< cxx11
)
6333 error ("initializer invalid for static member with constructor");
6334 else if (cxx_dialect
< cxx17
)
6335 error ("non-constant in-class initialization invalid for static "
6336 "member %qD", decl
);
6338 error ("non-constant in-class initialization invalid for non-inline "
6339 "static member %qD", decl
);
6342 inform (input_location
,
6343 "(an out of class initialization is required)");
6352 /* If DECL is not a local variable, give it RTL. */
6355 make_rtl_for_nonlocal_decl (tree decl
, tree init
, const char* asmspec
)
6357 int toplev
= toplevel_bindings_p ();
6360 /* Set the DECL_ASSEMBLER_NAME for the object. */
6363 /* The `register' keyword, when used together with an
6364 asm-specification, indicates that the variable should be
6365 placed in a particular register. */
6366 if (VAR_P (decl
) && DECL_REGISTER (decl
))
6368 set_user_assembler_name (decl
, asmspec
);
6369 DECL_HARD_REGISTER (decl
) = 1;
6373 if (TREE_CODE (decl
) == FUNCTION_DECL
6374 && DECL_BUILT_IN_CLASS (decl
) == BUILT_IN_NORMAL
)
6375 set_builtin_user_assembler_name (decl
, asmspec
);
6376 set_user_assembler_name (decl
, asmspec
);
6380 /* Handle non-variables up front. */
6383 rest_of_decl_compilation (decl
, toplev
, at_eof
);
6387 /* If we see a class member here, it should be a static data
6389 if (DECL_LANG_SPECIFIC (decl
) && DECL_IN_AGGR_P (decl
))
6391 gcc_assert (TREE_STATIC (decl
));
6392 /* An in-class declaration of a static data member should be
6393 external; it is only a declaration, and not a definition. */
6394 if (init
== NULL_TREE
)
6395 gcc_assert (DECL_EXTERNAL (decl
)
6396 || !TREE_PUBLIC (decl
)
6397 || DECL_INLINE_VAR_P (decl
));
6400 /* We don't create any RTL for local variables. */
6401 if (DECL_FUNCTION_SCOPE_P (decl
) && !TREE_STATIC (decl
))
6404 /* We defer emission of local statics until the corresponding
6405 DECL_EXPR is expanded. But with constexpr its function might never
6406 be expanded, so go ahead and tell cgraph about the variable now. */
6407 defer_p
= ((DECL_FUNCTION_SCOPE_P (decl
)
6408 && !var_in_maybe_constexpr_fn (decl
))
6409 || DECL_VIRTUAL_P (decl
));
6411 /* Defer template instantiations. */
6412 if (DECL_LANG_SPECIFIC (decl
)
6413 && DECL_IMPLICIT_INSTANTIATION (decl
))
6416 /* If we're not deferring, go ahead and assemble the variable. */
6418 rest_of_decl_compilation (decl
, toplev
, at_eof
);
6421 /* walk_tree helper for wrap_temporary_cleanups, below. */
6424 wrap_cleanups_r (tree
*stmt_p
, int *walk_subtrees
, void *data
)
6426 /* Stop at types or full-expression boundaries. */
6427 if (TYPE_P (*stmt_p
)
6428 || TREE_CODE (*stmt_p
) == CLEANUP_POINT_EXPR
)
6434 if (TREE_CODE (*stmt_p
) == TARGET_EXPR
)
6436 tree guard
= (tree
)data
;
6437 tree tcleanup
= TARGET_EXPR_CLEANUP (*stmt_p
);
6439 tcleanup
= build2 (TRY_CATCH_EXPR
, void_type_node
, tcleanup
, guard
);
6440 /* Tell honor_protect_cleanup_actions to handle this as a separate
6442 TRY_CATCH_IS_CLEANUP (tcleanup
) = 1;
6444 TARGET_EXPR_CLEANUP (*stmt_p
) = tcleanup
;
6450 /* We're initializing a local variable which has a cleanup GUARD. If there
6451 are any temporaries used in the initializer INIT of this variable, we
6452 need to wrap their cleanups with TRY_CATCH_EXPR (, GUARD) so that the
6453 variable will be cleaned up properly if one of them throws.
6455 Unfortunately, there's no way to express this properly in terms of
6456 nesting, as the regions for the temporaries overlap the region for the
6457 variable itself; if there are two temporaries, the variable needs to be
6458 the first thing destroyed if either of them throws. However, we only
6459 want to run the variable's cleanup if it actually got constructed. So
6460 we need to guard the temporary cleanups with the variable's cleanup if
6461 they are run on the normal path, but not if they are run on the
6462 exceptional path. We implement this by telling
6463 honor_protect_cleanup_actions to strip the variable cleanup from the
6464 exceptional path. */
6467 wrap_temporary_cleanups (tree init
, tree guard
)
6469 cp_walk_tree_without_duplicates (&init
, wrap_cleanups_r
, (void *)guard
);
6472 /* Generate code to initialize DECL (a local variable). */
6475 initialize_local_var (tree decl
, tree init
)
6477 tree type
= TREE_TYPE (decl
);
6481 gcc_assert (VAR_P (decl
)
6482 || TREE_CODE (decl
) == RESULT_DECL
);
6483 gcc_assert (!TREE_STATIC (decl
));
6485 if (DECL_SIZE (decl
) == NULL_TREE
)
6487 /* If we used it already as memory, it must stay in memory. */
6488 DECL_INITIAL (decl
) = NULL_TREE
;
6489 TREE_ADDRESSABLE (decl
) = TREE_USED (decl
);
6493 if (type
== error_mark_node
)
6496 /* Compute and store the initial value. */
6497 already_used
= TREE_USED (decl
) || TREE_USED (type
);
6498 if (TREE_USED (type
))
6499 DECL_READ_P (decl
) = 1;
6501 /* Generate a cleanup, if necessary. */
6502 cleanup
= cxx_maybe_build_cleanup (decl
, tf_warning_or_error
);
6504 /* Perform the initialization. */
6507 tree rinit
= (TREE_CODE (init
) == INIT_EXPR
6508 ? TREE_OPERAND (init
, 1) : NULL_TREE
);
6509 if (rinit
&& !TREE_SIDE_EFFECTS (rinit
))
6511 /* Stick simple initializers in DECL_INITIAL so that
6512 -Wno-init-self works (c++/34772). */
6513 gcc_assert (TREE_OPERAND (init
, 0) == decl
);
6514 DECL_INITIAL (decl
) = rinit
;
6516 if (warn_init_self
&& TREE_CODE (type
) == REFERENCE_TYPE
)
6520 warning_at (DECL_SOURCE_LOCATION (decl
),
6522 "reference %qD is initialized with itself", decl
);
6527 int saved_stmts_are_full_exprs_p
;
6529 /* If we're only initializing a single object, guard the
6530 destructors of any temporaries used in its initializer with
6531 its destructor. This isn't right for arrays because each
6532 element initialization is a full-expression. */
6533 if (cleanup
&& TREE_CODE (type
) != ARRAY_TYPE
)
6534 wrap_temporary_cleanups (init
, cleanup
);
6536 gcc_assert (building_stmt_list_p ());
6537 saved_stmts_are_full_exprs_p
= stmts_are_full_exprs_p ();
6538 current_stmt_tree ()->stmts_are_full_exprs_p
= 1;
6539 finish_expr_stmt (init
);
6540 current_stmt_tree ()->stmts_are_full_exprs_p
=
6541 saved_stmts_are_full_exprs_p
;
6545 /* Set this to 0 so we can tell whether an aggregate which was
6546 initialized was ever used. Don't do this if it has a
6547 destructor, so we don't complain about the 'resource
6548 allocation is initialization' idiom. Now set
6549 attribute((unused)) on types so decls of that type will be
6550 marked used. (see TREE_USED, above.) */
6551 if (TYPE_NEEDS_CONSTRUCTING (type
)
6553 && TYPE_HAS_TRIVIAL_DESTRUCTOR (type
)
6554 && DECL_NAME (decl
))
6555 TREE_USED (decl
) = 0;
6556 else if (already_used
)
6557 TREE_USED (decl
) = 1;
6560 finish_decl_cleanup (decl
, cleanup
);
6563 /* DECL is a VAR_DECL for a compiler-generated variable with static
6564 storage duration (like a virtual table) whose initializer is a
6565 compile-time constant. Initialize the variable and provide it to the
6569 initialize_artificial_var (tree decl
, vec
<constructor_elt
, va_gc
> *v
)
6572 gcc_assert (DECL_ARTIFICIAL (decl
));
6573 init
= build_constructor (TREE_TYPE (decl
), v
);
6574 gcc_assert (TREE_CODE (init
) == CONSTRUCTOR
);
6575 DECL_INITIAL (decl
) = init
;
6576 DECL_INITIALIZED_P (decl
) = 1;
6577 determine_visibility (decl
);
6578 layout_var_decl (decl
);
6579 maybe_commonize_var (decl
);
6580 make_rtl_for_nonlocal_decl (decl
, init
, /*asmspec=*/NULL
);
6583 /* INIT is the initializer for a variable, as represented by the
6584 parser. Returns true iff INIT is type-dependent. */
6587 type_dependent_init_p (tree init
)
6589 if (TREE_CODE (init
) == TREE_LIST
)
6590 /* A parenthesized initializer, e.g.: int i (3, 2); ? */
6591 return any_type_dependent_elements_p (init
);
6592 else if (TREE_CODE (init
) == CONSTRUCTOR
)
6593 /* A brace-enclosed initializer, e.g.: int i = { 3 }; ? */
6595 if (dependent_type_p (TREE_TYPE (init
)))
6598 vec
<constructor_elt
, va_gc
> *elts
;
6602 elts
= CONSTRUCTOR_ELTS (init
);
6603 nelts
= vec_safe_length (elts
);
6604 for (i
= 0; i
< nelts
; ++i
)
6605 if (type_dependent_init_p ((*elts
)[i
].value
))
6609 /* It must be a simple expression, e.g., int i = 3; */
6610 return type_dependent_expression_p (init
);
6615 /* INIT is the initializer for a variable, as represented by the
6616 parser. Returns true iff INIT is value-dependent. */
6619 value_dependent_init_p (tree init
)
6621 if (TREE_CODE (init
) == TREE_LIST
)
6622 /* A parenthesized initializer, e.g.: int i (3, 2); ? */
6623 return any_value_dependent_elements_p (init
);
6624 else if (TREE_CODE (init
) == CONSTRUCTOR
)
6625 /* A brace-enclosed initializer, e.g.: int i = { 3 }; ? */
6627 vec
<constructor_elt
, va_gc
> *elts
;
6631 elts
= CONSTRUCTOR_ELTS (init
);
6632 nelts
= vec_safe_length (elts
);
6633 for (i
= 0; i
< nelts
; ++i
)
6634 if (value_dependent_init_p ((*elts
)[i
].value
))
6638 /* It must be a simple expression, e.g., int i = 3; */
6639 return value_dependent_expression_p (init
);
6644 // Returns true if a DECL is VAR_DECL with the concept specifier.
6646 is_concept_var (tree decl
)
6648 return (VAR_P (decl
)
6649 // Not all variables have DECL_LANG_SPECIFIC.
6650 && DECL_LANG_SPECIFIC (decl
)
6651 && DECL_DECLARED_CONCEPT_P (decl
));
6654 /* A helper function to be called via walk_tree. If any label exists
6655 under *TP, it is (going to be) forced. Set has_forced_label_in_static. */
6658 notice_forced_label_r (tree
*tp
, int *walk_subtrees
, void *)
6662 if (TREE_CODE (*tp
) == LABEL_DECL
)
6663 cfun
->has_forced_label_in_static
= 1;
6667 /* Finish processing of a declaration;
6668 install its line number and initial value.
6669 If the length of an array type is not known before,
6670 it must be determined now, from the initial value, or it is an error.
6672 INIT is the initializer (if any) for DECL. If INIT_CONST_EXPR_P is
6673 true, then INIT is an integral constant expression.
6675 FLAGS is LOOKUP_ONLYCONVERTING if the = init syntax was used, else 0
6676 if the (init) syntax was used. */
6679 cp_finish_decl (tree decl
, tree init
, bool init_const_expr_p
,
6680 tree asmspec_tree
, int flags
)
6683 vec
<tree
, va_gc
> *cleanups
= NULL
;
6684 const char *asmspec
= NULL
;
6685 int was_readonly
= 0;
6686 bool var_definition_p
= false;
6689 if (decl
== error_mark_node
)
6694 error ("assignment (not initialization) in declaration");
6698 gcc_assert (TREE_CODE (decl
) != RESULT_DECL
);
6699 /* Parameters are handled by store_parm_decls, not cp_finish_decl. */
6700 gcc_assert (TREE_CODE (decl
) != PARM_DECL
);
6702 type
= TREE_TYPE (decl
);
6703 if (type
== error_mark_node
)
6706 /* Warn about register storage specifiers except when in GNU global
6707 or local register variable extension. */
6708 if (VAR_P (decl
) && DECL_REGISTER (decl
) && asmspec_tree
== NULL_TREE
)
6710 if (cxx_dialect
>= cxx17
)
6711 pedwarn (DECL_SOURCE_LOCATION (decl
), OPT_Wregister
,
6712 "ISO C++17 does not allow %<register%> storage "
6715 warning_at (DECL_SOURCE_LOCATION (decl
), OPT_Wregister
,
6716 "%<register%> storage class specifier used");
6719 /* If a name was specified, get the string. */
6720 if (at_namespace_scope_p ())
6721 asmspec_tree
= maybe_apply_renaming_pragma (decl
, asmspec_tree
);
6722 if (asmspec_tree
&& asmspec_tree
!= error_mark_node
)
6723 asmspec
= TREE_STRING_POINTER (asmspec_tree
);
6725 if (current_class_type
6726 && CP_DECL_CONTEXT (decl
) == current_class_type
6727 && TYPE_BEING_DEFINED (current_class_type
)
6728 && !CLASSTYPE_TEMPLATE_INSTANTIATION (current_class_type
)
6729 && (DECL_INITIAL (decl
) || init
))
6730 DECL_INITIALIZED_IN_CLASS_P (decl
) = 1;
6732 if (TREE_CODE (decl
) != FUNCTION_DECL
6733 && (auto_node
= type_uses_auto (type
)))
6736 if (init
== NULL_TREE
)
6738 if (DECL_LANG_SPECIFIC (decl
)
6739 && DECL_TEMPLATE_INSTANTIATION (decl
)
6740 && !DECL_TEMPLATE_INSTANTIATED (decl
))
6742 /* init is null because we're deferring instantiating the
6743 initializer until we need it. Well, we need it now. */
6744 instantiate_decl (decl
, /*defer_ok*/true, /*expl*/false);
6748 gcc_assert (CLASS_PLACEHOLDER_TEMPLATE (auto_node
));
6753 if (TREE_CODE (d_init
) == TREE_LIST
6754 && !CLASS_PLACEHOLDER_TEMPLATE (auto_node
))
6755 d_init
= build_x_compound_expr_from_list (d_init
, ELK_INIT
,
6756 tf_warning_or_error
);
6757 d_init
= resolve_nondeduced_context (d_init
, tf_warning_or_error
);
6759 enum auto_deduction_context adc
= adc_variable_type
;
6760 if (VAR_P (decl
) && DECL_DECOMPOSITION_P (decl
))
6761 adc
= adc_decomp_type
;
6762 type
= TREE_TYPE (decl
) = do_auto_deduction (type
, d_init
, auto_node
,
6763 tf_warning_or_error
, adc
,
6765 if (type
== error_mark_node
)
6767 if (TREE_CODE (type
) == FUNCTION_TYPE
)
6769 error ("initializer for %<decltype(auto) %D%> has function type "
6770 "(did you forget the %<()%> ?)", decl
);
6771 TREE_TYPE (decl
) = error_mark_node
;
6774 cp_apply_type_quals_to_decl (cp_type_quals (type
), decl
);
6777 if (!ensure_literal_type_for_constexpr_object (decl
))
6778 DECL_DECLARED_CONSTEXPR_P (decl
) = 0;
6781 && DECL_CLASS_SCOPE_P (decl
)
6782 && DECL_INITIALIZED_IN_CLASS_P (decl
))
6783 check_static_variable_definition (decl
, type
);
6785 if (init
&& TREE_CODE (decl
) == FUNCTION_DECL
)
6788 if (init
== ridpointers
[(int)RID_DELETE
])
6790 /* FIXME check this is 1st decl. */
6791 DECL_DELETED_FN (decl
) = 1;
6792 DECL_DECLARED_INLINE_P (decl
) = 1;
6793 DECL_INITIAL (decl
) = error_mark_node
;
6794 FOR_EACH_CLONE (clone
, decl
)
6796 DECL_DELETED_FN (clone
) = 1;
6797 DECL_DECLARED_INLINE_P (clone
) = 1;
6798 DECL_INITIAL (clone
) = error_mark_node
;
6802 else if (init
== ridpointers
[(int)RID_DEFAULT
])
6804 if (defaultable_fn_check (decl
))
6805 DECL_DEFAULTED_FN (decl
) = 1;
6807 DECL_INITIAL (decl
) = NULL_TREE
;
6811 if (init
&& VAR_P (decl
))
6813 DECL_NONTRIVIALLY_INITIALIZED_P (decl
) = 1;
6814 /* If DECL is a reference, then we want to know whether init is a
6815 reference constant; init_const_expr_p as passed tells us whether
6816 it's an rvalue constant. */
6817 if (TREE_CODE (type
) == REFERENCE_TYPE
)
6818 init_const_expr_p
= potential_constant_expression (init
);
6819 if (init_const_expr_p
)
6821 /* Set these flags now for templates. We'll update the flags in
6822 store_init_value for instantiations. */
6823 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (decl
) = 1;
6824 if (decl_maybe_constant_var_p (decl
)
6825 /* FIXME setting TREE_CONSTANT on refs breaks the back end. */
6826 && TREE_CODE (type
) != REFERENCE_TYPE
)
6827 TREE_CONSTANT (decl
) = 1;
6831 if (processing_template_decl
)
6833 bool type_dependent_p
;
6835 /* Add this declaration to the statement-tree. */
6836 if (at_function_scope_p ())
6837 add_decl_expr (decl
);
6839 type_dependent_p
= dependent_type_p (type
);
6841 if (check_for_bare_parameter_packs (init
))
6844 DECL_INITIAL (decl
) = NULL_TREE
;
6847 init
= do_dependent_capture (init
);
6849 /* Generally, initializers in templates are expanded when the
6850 template is instantiated. But, if DECL is a variable constant
6851 then it can be used in future constant expressions, so its value
6852 must be available. */
6854 if (!VAR_P (decl
) || type_dependent_p
)
6855 /* We can't do anything if the decl has dependent type. */;
6857 && init_const_expr_p
6858 && TREE_CODE (type
) != REFERENCE_TYPE
6859 && decl_maybe_constant_var_p (decl
)
6860 && !type_dependent_init_p (init
)
6861 && !value_dependent_init_p (init
))
6863 /* This variable seems to be a non-dependent constant, so process
6864 its initializer. If check_initializer returns non-null the
6865 initialization wasn't constant after all. */
6867 cleanups
= make_tree_vector ();
6868 init_code
= check_initializer (decl
, init
, flags
, &cleanups
);
6869 if (init_code
== NULL_TREE
)
6871 release_tree_vector (cleanups
);
6873 else if (!init
&& is_concept_var (decl
))
6874 error ("variable concept has no initializer");
6875 else if (!DECL_PRETTY_FUNCTION_P (decl
))
6877 /* Deduce array size even if the initializer is dependent. */
6878 maybe_deduce_size_from_array_init (decl
, init
);
6879 /* And complain about multiple initializers. */
6880 if (init
&& TREE_CODE (init
) == TREE_LIST
&& TREE_CHAIN (init
)
6881 && !MAYBE_CLASS_TYPE_P (type
))
6882 init
= build_x_compound_expr_from_list (init
, ELK_INIT
,
6883 tf_warning_or_error
);
6887 DECL_INITIAL (decl
) = init
;
6891 /* Just store non-static data member initializers for later. */
6892 if (init
&& TREE_CODE (decl
) == FIELD_DECL
)
6893 DECL_INITIAL (decl
) = init
;
6895 /* Take care of TYPE_DECLs up front. */
6896 if (TREE_CODE (decl
) == TYPE_DECL
)
6898 if (type
!= error_mark_node
6899 && MAYBE_CLASS_TYPE_P (type
) && DECL_NAME (decl
))
6901 if (TREE_TYPE (DECL_NAME (decl
)) && TREE_TYPE (decl
) != type
)
6902 warning (0, "shadowing previous type declaration of %q#D", decl
);
6903 set_identifier_type_value (DECL_NAME (decl
), decl
);
6906 /* If we have installed this as the canonical typedef for this
6907 type, and that type has not been defined yet, delay emitting
6908 the debug information for it, as we will emit it later. */
6909 if (TYPE_MAIN_DECL (TREE_TYPE (decl
)) == decl
6910 && !COMPLETE_TYPE_P (TREE_TYPE (decl
)))
6911 TYPE_DECL_SUPPRESS_DEBUG (decl
) = 1;
6913 rest_of_decl_compilation (decl
, DECL_FILE_SCOPE_P (decl
),
6918 /* A reference will be modified here, as it is initialized. */
6919 if (! DECL_EXTERNAL (decl
)
6920 && TREE_READONLY (decl
)
6921 && TREE_CODE (type
) == REFERENCE_TYPE
)
6924 TREE_READONLY (decl
) = 0;
6929 /* If this is a local variable that will need a mangled name,
6930 register it now. We must do this before processing the
6931 initializer for the variable, since the initialization might
6932 require a guard variable, and since the mangled name of the
6933 guard variable will depend on the mangled name of this
6935 if (DECL_FUNCTION_SCOPE_P (decl
)
6936 && TREE_STATIC (decl
)
6937 && !DECL_ARTIFICIAL (decl
))
6939 push_local_name (decl
);
6940 /* Normally has_forced_label_in_static is set during GIMPLE
6941 lowering, but [cd]tors are never actually compiled directly.
6942 We need to set this early so we can deal with the label
6943 address extension. */
6944 if ((DECL_CONSTRUCTOR_P (current_function_decl
)
6945 || DECL_DESTRUCTOR_P (current_function_decl
))
6948 walk_tree (&init
, notice_forced_label_r
, NULL
, NULL
);
6949 add_local_decl (cfun
, decl
);
6951 /* And make sure it's in the symbol table for
6952 c_parse_final_cleanups to find. */
6953 varpool_node::get_create (decl
);
6956 /* Convert the initializer to the type of DECL, if we have not
6957 already initialized DECL. */
6958 if (!DECL_INITIALIZED_P (decl
)
6959 /* If !DECL_EXTERNAL then DECL is being defined. In the
6960 case of a static data member initialized inside the
6961 class-specifier, there can be an initializer even if DECL
6962 is *not* defined. */
6963 && (!DECL_EXTERNAL (decl
) || init
))
6965 cleanups
= make_tree_vector ();
6966 init
= check_initializer (decl
, init
, flags
, &cleanups
);
6972 The memory occupied by any object of static storage
6973 duration is zero-initialized at program startup before
6974 any other initialization takes place.
6976 We cannot create an appropriate initializer until after
6977 the type of DECL is finalized. If DECL_INITIAL is set,
6978 then the DECL is statically initialized, and any
6979 necessary zero-initialization has already been performed. */
6980 if (TREE_STATIC (decl
) && !DECL_INITIAL (decl
))
6981 DECL_INITIAL (decl
) = build_zero_init (TREE_TYPE (decl
),
6982 /*nelts=*/NULL_TREE
,
6983 /*static_storage_p=*/true);
6984 /* Remember that the initialization for this variable has
6986 DECL_INITIALIZED_P (decl
) = 1;
6987 /* This declaration is the definition of this variable,
6988 unless we are initializing a static data member within
6989 the class specifier. */
6990 if (!DECL_EXTERNAL (decl
))
6991 var_definition_p
= true;
6993 /* If the variable has an array type, lay out the type, even if
6994 there is no initializer. It is valid to index through the
6995 array, and we must get TYPE_ALIGN set correctly on the array
6997 else if (TREE_CODE (type
) == ARRAY_TYPE
)
7000 if (TREE_STATIC (decl
)
7001 && !at_function_scope_p ()
7002 && current_function_decl
== NULL
)
7003 /* So decl is a global variable or a static member of a
7004 non local class. Record the types it uses
7005 so that we can decide later to emit debug info for them. */
7006 record_types_used_by_current_var_decl (decl
);
7009 /* Add this declaration to the statement-tree. This needs to happen
7010 after the call to check_initializer so that the DECL_EXPR for a
7011 reference temp is added before the DECL_EXPR for the reference itself. */
7012 if (DECL_FUNCTION_SCOPE_P (decl
))
7014 /* If we're building a variable sized type, and we might be
7015 reachable other than via the top of the current binding
7016 level, then create a new BIND_EXPR so that we deallocate
7017 the object at the right time. */
7020 && !TREE_CONSTANT (DECL_SIZE (decl
))
7021 && STATEMENT_LIST_HAS_LABEL (cur_stmt_list
))
7024 bind
= build3 (BIND_EXPR
, void_type_node
, NULL
, NULL
, NULL
);
7025 TREE_SIDE_EFFECTS (bind
) = 1;
7027 BIND_EXPR_BODY (bind
) = push_stmt_list ();
7029 add_decl_expr (decl
);
7032 /* Let the middle end know about variables and functions -- but not
7033 static data members in uninstantiated class templates. */
7034 if (VAR_OR_FUNCTION_DECL_P (decl
))
7038 layout_var_decl (decl
);
7039 maybe_commonize_var (decl
);
7042 /* This needs to happen after the linkage is set. */
7043 determine_visibility (decl
);
7045 if (var_definition_p
&& TREE_STATIC (decl
))
7047 /* If a TREE_READONLY variable needs initialization
7048 at runtime, it is no longer readonly and we need to
7049 avoid MEM_READONLY_P being set on RTL created for it. */
7052 if (TREE_READONLY (decl
))
7053 TREE_READONLY (decl
) = 0;
7056 else if (was_readonly
)
7057 TREE_READONLY (decl
) = 1;
7059 /* Likewise if it needs destruction. */
7060 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
))
7061 TREE_READONLY (decl
) = 0;
7064 make_rtl_for_nonlocal_decl (decl
, init
, asmspec
);
7066 /* Check for abstractness of the type. Notice that there is no
7067 need to strip array types here since the check for those types
7068 is already done within create_array_type_for_decl. */
7069 abstract_virtuals_error (decl
, type
);
7071 if (TREE_TYPE (decl
) == error_mark_node
)
7072 /* No initialization required. */
7074 else if (TREE_CODE (decl
) == FUNCTION_DECL
)
7078 if (init
== ridpointers
[(int)RID_DEFAULT
])
7080 /* An out-of-class default definition is defined at
7081 the point where it is explicitly defaulted. */
7082 if (DECL_DELETED_FN (decl
))
7083 maybe_explain_implicit_delete (decl
);
7084 else if (DECL_INITIAL (decl
) == error_mark_node
)
7085 synthesize_method (decl
);
7088 error ("function %q#D is initialized like a variable", decl
);
7090 /* else no initialization required. */
7092 else if (DECL_EXTERNAL (decl
)
7093 && ! (DECL_LANG_SPECIFIC (decl
)
7094 && DECL_NOT_REALLY_EXTERN (decl
)))
7097 DECL_INITIAL (decl
) = init
;
7099 /* A variable definition. */
7100 else if (DECL_FUNCTION_SCOPE_P (decl
) && !TREE_STATIC (decl
))
7101 /* Initialize the local variable. */
7102 initialize_local_var (decl
, init
);
7104 /* If a variable is defined, and then a subsequent
7105 definition with external linkage is encountered, we will
7106 get here twice for the same variable. We want to avoid
7107 calling expand_static_init more than once. For variables
7108 that are not static data members, we can call
7109 expand_static_init only when we actually process the
7110 initializer. It is not legal to redeclare a static data
7111 member, so this issue does not arise in that case. */
7112 else if (var_definition_p
&& TREE_STATIC (decl
))
7113 expand_static_init (decl
, init
);
7116 /* If a CLEANUP_STMT was created to destroy a temporary bound to a
7117 reference, insert it in the statement-tree now. */
7121 FOR_EACH_VEC_ELT (*cleanups
, i
, t
)
7122 push_cleanup (decl
, t
, false);
7123 release_tree_vector (cleanups
);
7127 TREE_READONLY (decl
) = 1;
7129 invoke_plugin_callbacks (PLUGIN_FINISH_DECL
, decl
);
7132 /* For class TYPE return itself or some its bases that contain
7133 any direct non-static data members. Return error_mark_node if an
7134 error has been diagnosed. */
7137 find_decomp_class_base (location_t loc
, tree type
, tree ret
)
7139 bool member_seen
= false;
7140 for (tree field
= TYPE_FIELDS (type
); field
; field
= DECL_CHAIN (field
))
7141 if (TREE_CODE (field
) != FIELD_DECL
|| DECL_ARTIFICIAL (field
))
7145 else if (ANON_AGGR_TYPE_P (TREE_TYPE (field
)))
7147 if (TREE_CODE (TREE_TYPE (field
)) == RECORD_TYPE
)
7148 error_at (loc
, "cannot decompose class type %qT because it has an "
7149 "anonymous struct member", type
);
7151 error_at (loc
, "cannot decompose class type %qT because it has an "
7152 "anonymous union member", type
);
7153 inform (DECL_SOURCE_LOCATION (field
), "declared here");
7154 return error_mark_node
;
7156 else if (TREE_PRIVATE (field
) || TREE_PROTECTED (field
))
7158 error_at (loc
, "cannot decompose non-public member %qD of %qT",
7160 inform (DECL_SOURCE_LOCATION (field
),
7161 TREE_PRIVATE (field
)
7162 ? G_("declared private here")
7163 : G_("declared protected here"));
7164 return error_mark_node
;
7169 tree base_binfo
, binfo
;
7170 tree orig_ret
= ret
;
7174 for (binfo
= TYPE_BINFO (type
), i
= 0;
7175 BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); i
++)
7177 tree t
= find_decomp_class_base (loc
, TREE_TYPE (base_binfo
), ret
);
7178 if (t
== error_mark_node
)
7179 return error_mark_node
;
7184 error_at (loc
, "cannot decompose class type %qT: both it and "
7185 "its base class %qT have non-static data members",
7187 return error_mark_node
;
7189 else if (orig_ret
!= NULL_TREE
)
7192 /* OK, found the same base along another path. We'll complain
7193 in convert_to_base if it's ambiguous. */;
7194 else if (ret
!= NULL_TREE
)
7196 error_at (loc
, "cannot decompose class type %qT: its base "
7197 "classes %qT and %qT have non-static data "
7198 "members", type
, ret
, t
);
7199 return error_mark_node
;
7208 /* Return std::tuple_size<TYPE>::value. */
7211 get_tuple_size (tree type
)
7213 tree args
= make_tree_vec (1);
7214 TREE_VEC_ELT (args
, 0) = type
;
7215 tree inst
= lookup_template_class (get_identifier ("tuple_size"), args
,
7216 /*in_decl*/NULL_TREE
,
7217 /*context*/std_node
,
7218 /*entering_scope*/false, tf_none
);
7219 inst
= complete_type (inst
);
7220 if (inst
== error_mark_node
|| !COMPLETE_TYPE_P (inst
))
7222 tree val
= lookup_qualified_name (inst
, get_identifier ("value"),
7223 /*type*/false, /*complain*/false);
7224 if (TREE_CODE (val
) == VAR_DECL
|| TREE_CODE (val
) == CONST_DECL
)
7225 val
= maybe_constant_value (val
);
7226 if (TREE_CODE (val
) == INTEGER_CST
)
7229 return error_mark_node
;
7232 /* Return std::tuple_element<I,TYPE>::type. */
7235 get_tuple_element_type (tree type
, unsigned i
)
7237 tree args
= make_tree_vec (2);
7238 TREE_VEC_ELT (args
, 0) = build_int_cst (integer_type_node
, i
);
7239 TREE_VEC_ELT (args
, 1) = type
;
7240 tree inst
= lookup_template_class (get_identifier ("tuple_element"), args
,
7241 /*in_decl*/NULL_TREE
,
7242 /*context*/std_node
,
7243 /*entering_scope*/false,
7244 tf_warning_or_error
);
7245 return make_typename_type (inst
, get_identifier ("type"),
7246 none_type
, tf_warning_or_error
);
7249 /* Return e.get<i>() or get<i>(e). */
7252 get_tuple_decomp_init (tree decl
, unsigned i
)
7254 tree get_id
= get_identifier ("get");
7255 tree targs
= make_tree_vec (1);
7256 TREE_VEC_ELT (targs
, 0) = build_int_cst (integer_type_node
, i
);
7258 tree etype
= TREE_TYPE (decl
);
7259 tree e
= convert_from_reference (decl
);
7261 /* [The id-expression] e is an lvalue if the type of the entity e is an
7262 lvalue reference and an xvalue otherwise. */
7263 if (TREE_CODE (etype
) != REFERENCE_TYPE
7264 || TYPE_REF_IS_RVALUE (etype
))
7267 tree fns
= lookup_qualified_name (TREE_TYPE (e
), get_id
,
7268 /*type*/false, /*complain*/false);
7269 if (fns
!= error_mark_node
)
7271 fns
= lookup_template_function (fns
, targs
);
7272 return build_new_method_call (e
, fns
, /*args*/NULL
,
7273 /*path*/NULL_TREE
, LOOKUP_NORMAL
,
7274 /*fn_p*/NULL
, tf_warning_or_error
);
7278 vec
<tree
,va_gc
> *args
= make_tree_vector_single (e
);
7279 fns
= lookup_template_function (get_id
, targs
);
7280 fns
= perform_koenig_lookup (fns
, args
, tf_warning_or_error
);
7281 return finish_call_expr (fns
, &args
, /*novirt*/false,
7282 /*koenig*/true, tf_warning_or_error
);
7286 /* It's impossible to recover the decltype of a tuple decomposition variable
7287 based on the actual type of the variable, so store it in a hash table. */
7288 static GTY(()) hash_map
<tree
,tree
> *decomp_type_table
;
7290 store_decomp_type (tree v
, tree t
)
7292 if (!decomp_type_table
)
7293 decomp_type_table
= hash_map
<tree
,tree
>::create_ggc (13);
7294 decomp_type_table
->put (v
, t
);
7298 lookup_decomp_type (tree v
)
7300 return *decomp_type_table
->get (v
);
7303 /* Finish a decomposition declaration. DECL is the underlying declaration
7304 "e", FIRST is the head of a chain of decls for the individual identifiers
7305 chained through DECL_CHAIN in reverse order and COUNT is the number of
7309 cp_finish_decomp (tree decl
, tree first
, unsigned int count
)
7311 if (error_operand_p (decl
))
7316 TREE_TYPE (first
) = error_mark_node
;
7317 if (DECL_HAS_VALUE_EXPR_P (first
))
7319 SET_DECL_VALUE_EXPR (first
, NULL_TREE
);
7320 DECL_HAS_VALUE_EXPR_P (first
) = 0;
7322 first
= DECL_CHAIN (first
);
7324 if (DECL_P (decl
) && DECL_NAMESPACE_SCOPE_P (decl
))
7325 SET_DECL_ASSEMBLER_NAME (decl
, get_identifier ("<decomp>"));
7329 location_t loc
= DECL_SOURCE_LOCATION (decl
);
7330 if (type_dependent_expression_p (decl
)
7331 /* This happens for range for when not in templates.
7332 Still add the DECL_VALUE_EXPRs for later processing. */
7333 || (!processing_template_decl
7334 && type_uses_auto (TREE_TYPE (decl
))))
7336 for (unsigned int i
= 0; i
< count
; i
++)
7338 if (!DECL_HAS_VALUE_EXPR_P (first
))
7340 tree v
= build_nt (ARRAY_REF
, decl
,
7341 size_int (count
- i
- 1),
7342 NULL_TREE
, NULL_TREE
);
7343 SET_DECL_VALUE_EXPR (first
, v
);
7344 DECL_HAS_VALUE_EXPR_P (first
) = 1;
7346 if (processing_template_decl
)
7347 fit_decomposition_lang_decl (first
, decl
);
7348 first
= DECL_CHAIN (first
);
7353 auto_vec
<tree
, 16> v
;
7354 v
.safe_grow (count
);
7356 for (unsigned int i
= 0; i
< count
; i
++, d
= DECL_CHAIN (d
))
7358 v
[count
- i
- 1] = d
;
7359 fit_decomposition_lang_decl (d
, decl
);
7362 tree type
= TREE_TYPE (decl
);
7365 if (TREE_CODE (type
) == REFERENCE_TYPE
)
7367 dexp
= convert_from_reference (dexp
);
7368 type
= TREE_TYPE (type
);
7371 tree eltype
= NULL_TREE
;
7372 unsigned HOST_WIDE_INT eltscnt
= 0;
7373 if (TREE_CODE (type
) == ARRAY_TYPE
)
7376 nelts
= array_type_nelts_top (type
);
7377 if (nelts
== error_mark_node
)
7379 if (!tree_fits_uhwi_p (nelts
))
7381 error_at (loc
, "cannot decompose variable length array %qT", type
);
7384 eltscnt
= tree_to_uhwi (nelts
);
7385 if (count
!= eltscnt
)
7388 if (count
> eltscnt
)
7389 error_at (loc
, "%u names provided while %qT decomposes into "
7390 "%wu elements", count
, type
, eltscnt
);
7392 error_at (loc
, "only %u names provided while %qT decomposes into "
7393 "%wu elements", count
, type
, eltscnt
);
7396 eltype
= TREE_TYPE (type
);
7397 for (unsigned int i
= 0; i
< count
; i
++)
7399 TREE_TYPE (v
[i
]) = eltype
;
7400 layout_decl (v
[i
], 0);
7401 if (processing_template_decl
)
7403 tree t
= unshare_expr (dexp
);
7404 t
= build4_loc (DECL_SOURCE_LOCATION (v
[i
]), ARRAY_REF
,
7405 eltype
, t
, size_int (i
), NULL_TREE
,
7407 SET_DECL_VALUE_EXPR (v
[i
], t
);
7408 DECL_HAS_VALUE_EXPR_P (v
[i
]) = 1;
7411 /* 2 GNU extensions. */
7412 else if (TREE_CODE (type
) == COMPLEX_TYPE
)
7415 if (count
!= eltscnt
)
7417 eltype
= cp_build_qualified_type (TREE_TYPE (type
), TYPE_QUALS (type
));
7418 for (unsigned int i
= 0; i
< count
; i
++)
7420 TREE_TYPE (v
[i
]) = eltype
;
7421 layout_decl (v
[i
], 0);
7422 if (processing_template_decl
)
7424 tree t
= unshare_expr (dexp
);
7425 t
= build1_loc (DECL_SOURCE_LOCATION (v
[i
]),
7426 i
? IMAGPART_EXPR
: REALPART_EXPR
, eltype
,
7428 SET_DECL_VALUE_EXPR (v
[i
], t
);
7429 DECL_HAS_VALUE_EXPR_P (v
[i
]) = 1;
7432 else if (TREE_CODE (type
) == VECTOR_TYPE
)
7434 eltscnt
= TYPE_VECTOR_SUBPARTS (type
);
7435 if (count
!= eltscnt
)
7437 eltype
= cp_build_qualified_type (TREE_TYPE (type
), TYPE_QUALS (type
));
7438 for (unsigned int i
= 0; i
< count
; i
++)
7440 TREE_TYPE (v
[i
]) = eltype
;
7441 layout_decl (v
[i
], 0);
7442 if (processing_template_decl
)
7444 tree t
= unshare_expr (dexp
);
7445 convert_vector_to_array_for_subscript (DECL_SOURCE_LOCATION (v
[i
]),
7447 t
= build4_loc (DECL_SOURCE_LOCATION (v
[i
]), ARRAY_REF
,
7448 eltype
, t
, size_int (i
), NULL_TREE
,
7450 SET_DECL_VALUE_EXPR (v
[i
], t
);
7451 DECL_HAS_VALUE_EXPR_P (v
[i
]) = 1;
7454 else if (tree tsize
= get_tuple_size (type
))
7456 if (tsize
== error_mark_node
)
7458 error_at (loc
, "%<std::tuple_size<%T>::value%> is not an integral "
7459 "constant expression", type
);
7462 eltscnt
= tree_to_uhwi (tsize
);
7463 if (count
!= eltscnt
)
7465 int save_read
= DECL_READ_P (decl
);
7466 for (unsigned i
= 0; i
< count
; ++i
)
7468 location_t sloc
= input_location
;
7469 location_t dloc
= DECL_SOURCE_LOCATION (v
[i
]);
7471 input_location
= dloc
;
7472 tree init
= get_tuple_decomp_init (decl
, i
);
7473 tree eltype
= (init
== error_mark_node
? error_mark_node
7474 : get_tuple_element_type (type
, i
));
7475 input_location
= sloc
;
7477 if (init
== error_mark_node
|| eltype
== error_mark_node
)
7479 inform (dloc
, "in initialization of structured binding "
7480 "variable %qD", v
[i
]);
7483 /* Save the decltype away before reference collapse. */
7484 store_decomp_type (v
[i
], eltype
);
7485 eltype
= cp_build_reference_type (eltype
, !lvalue_p (init
));
7486 TREE_TYPE (v
[i
]) = eltype
;
7487 layout_decl (v
[i
], 0);
7488 if (DECL_HAS_VALUE_EXPR_P (v
[i
]))
7490 /* In this case the names are variables, not just proxies. */
7491 SET_DECL_VALUE_EXPR (v
[i
], NULL_TREE
);
7492 DECL_HAS_VALUE_EXPR_P (v
[i
]) = 0;
7494 if (!processing_template_decl
)
7495 cp_finish_decl (v
[i
], init
, /*constexpr*/false,
7496 /*asm*/NULL_TREE
, LOOKUP_NORMAL
);
7498 /* Ignore reads from the underlying decl performed during initialization
7499 of the individual variables. If those will be read, we'll mark
7500 the underlying decl as read at that point. */
7501 DECL_READ_P (decl
) = save_read
;
7503 else if (TREE_CODE (type
) == UNION_TYPE
)
7505 error_at (loc
, "cannot decompose union type %qT", type
);
7508 else if (!CLASS_TYPE_P (type
))
7510 error_at (loc
, "cannot decompose non-array non-class type %qT", type
);
7513 else if (LAMBDA_TYPE_P (type
))
7515 error_at (loc
, "cannot decompose lambda closure type %qT", type
);
7520 tree btype
= find_decomp_class_base (loc
, type
, NULL_TREE
);
7521 if (btype
== error_mark_node
)
7523 else if (btype
== NULL_TREE
)
7525 error_at (loc
, "cannot decompose class type %qT without non-static "
7526 "data members", type
);
7529 for (tree field
= TYPE_FIELDS (btype
); field
; field
= TREE_CHAIN (field
))
7530 if (TREE_CODE (field
) != FIELD_DECL
|| DECL_ARTIFICIAL (field
))
7534 if (count
!= eltscnt
)
7539 t
= convert_to_base (t
, btype
, /*check_access*/true,
7540 /*nonnull*/false, tf_warning_or_error
);
7544 for (tree field
= TYPE_FIELDS (btype
); field
; field
= TREE_CHAIN (field
))
7545 if (TREE_CODE (field
) != FIELD_DECL
|| DECL_ARTIFICIAL (field
))
7549 tree tt
= finish_non_static_data_member (field
, unshare_expr (t
),
7551 if (REFERENCE_REF_P (tt
))
7552 tt
= TREE_OPERAND (tt
, 0);
7553 TREE_TYPE (v
[i
]) = TREE_TYPE (tt
);
7554 layout_decl (v
[i
], 0);
7555 if (!processing_template_decl
)
7557 SET_DECL_VALUE_EXPR (v
[i
], tt
);
7558 DECL_HAS_VALUE_EXPR_P (v
[i
]) = 1;
7563 if (processing_template_decl
)
7565 for (unsigned int i
= 0; i
< count
; i
++)
7566 if (!DECL_HAS_VALUE_EXPR_P (v
[i
]))
7568 tree a
= build_nt (ARRAY_REF
, decl
, size_int (i
),
7569 NULL_TREE
, NULL_TREE
);
7570 SET_DECL_VALUE_EXPR (v
[i
], a
);
7571 DECL_HAS_VALUE_EXPR_P (v
[i
]) = 1;
7574 else if (DECL_NAMESPACE_SCOPE_P (decl
))
7575 SET_DECL_ASSEMBLER_NAME (decl
, mangle_decomp (decl
, v
));
7578 /* Returns a declaration for a VAR_DECL as if:
7580 extern "C" TYPE NAME;
7582 had been seen. Used to create compiler-generated global
7586 declare_global_var (tree name
, tree type
)
7590 push_to_top_level ();
7591 decl
= build_decl (input_location
, VAR_DECL
, name
, type
);
7592 TREE_PUBLIC (decl
) = 1;
7593 DECL_EXTERNAL (decl
) = 1;
7594 DECL_ARTIFICIAL (decl
) = 1;
7595 DECL_CONTEXT (decl
) = FROB_CONTEXT (global_namespace
);
7596 /* If the user has explicitly declared this variable (perhaps
7597 because the code we are compiling is part of a low-level runtime
7598 library), then it is possible that our declaration will be merged
7599 with theirs by pushdecl. */
7600 decl
= pushdecl (decl
);
7601 cp_finish_decl (decl
, NULL_TREE
, false, NULL_TREE
, 0);
7602 pop_from_top_level ();
7607 /* Returns the type for the argument to "__cxa_atexit" (or "atexit",
7608 if "__cxa_atexit" is not being used) corresponding to the function
7609 to be called when the program exits. */
7612 get_atexit_fn_ptr_type (void)
7616 if (!atexit_fn_ptr_type_node
)
7619 if (flag_use_cxa_atexit
7620 && !targetm
.cxx
.use_atexit_for_cxa_atexit ())
7621 /* The parameter to "__cxa_atexit" is "void (*)(void *)". */
7622 arg_type
= ptr_type_node
;
7624 /* The parameter to "atexit" is "void (*)(void)". */
7625 arg_type
= NULL_TREE
;
7627 fn_type
= build_function_type_list (void_type_node
,
7628 arg_type
, NULL_TREE
);
7629 atexit_fn_ptr_type_node
= build_pointer_type (fn_type
);
7632 return atexit_fn_ptr_type_node
;
7635 /* Returns a pointer to the `atexit' function. Note that if
7636 FLAG_USE_CXA_ATEXIT is nonzero, then this will actually be the new
7637 `__cxa_atexit' function specified in the IA64 C++ ABI. */
7640 get_atexit_node (void)
7646 bool use_aeabi_atexit
;
7651 if (flag_use_cxa_atexit
&& !targetm
.cxx
.use_atexit_for_cxa_atexit ())
7653 /* The declaration for `__cxa_atexit' is:
7655 int __cxa_atexit (void (*)(void *), void *, void *)
7657 We build up the argument types and then the function type
7659 tree argtype0
, argtype1
, argtype2
;
7661 use_aeabi_atexit
= targetm
.cxx
.use_aeabi_atexit ();
7662 /* First, build the pointer-to-function type for the first
7664 fn_ptr_type
= get_atexit_fn_ptr_type ();
7665 /* Then, build the rest of the argument types. */
7666 argtype2
= ptr_type_node
;
7667 if (use_aeabi_atexit
)
7669 argtype1
= fn_ptr_type
;
7670 argtype0
= ptr_type_node
;
7674 argtype1
= ptr_type_node
;
7675 argtype0
= fn_ptr_type
;
7677 /* And the final __cxa_atexit type. */
7678 fn_type
= build_function_type_list (integer_type_node
,
7679 argtype0
, argtype1
, argtype2
,
7681 if (use_aeabi_atexit
)
7682 name
= "__aeabi_atexit";
7684 name
= "__cxa_atexit";
7688 /* The declaration for `atexit' is:
7690 int atexit (void (*)());
7692 We build up the argument types and then the function type
7694 fn_ptr_type
= get_atexit_fn_ptr_type ();
7695 /* Build the final atexit type. */
7696 fn_type
= build_function_type_list (integer_type_node
,
7697 fn_ptr_type
, NULL_TREE
);
7701 /* Now, build the function declaration. */
7702 push_lang_context (lang_name_c
);
7703 atexit_fndecl
= build_library_fn_ptr (name
, fn_type
, ECF_LEAF
| ECF_NOTHROW
);
7704 mark_used (atexit_fndecl
);
7705 pop_lang_context ();
7706 atexit_node
= decay_conversion (atexit_fndecl
, tf_warning_or_error
);
7711 /* Like get_atexit_node, but for thread-local cleanups. */
7714 get_thread_atexit_node (void)
7716 /* The declaration for `__cxa_thread_atexit' is:
7718 int __cxa_thread_atexit (void (*)(void *), void *, void *) */
7719 tree fn_type
= build_function_type_list (integer_type_node
,
7720 get_atexit_fn_ptr_type (),
7721 ptr_type_node
, ptr_type_node
,
7724 /* Now, build the function declaration. */
7725 tree atexit_fndecl
= build_library_fn_ptr ("__cxa_thread_atexit", fn_type
,
7726 ECF_LEAF
| ECF_NOTHROW
);
7727 return decay_conversion (atexit_fndecl
, tf_warning_or_error
);
7730 /* Returns the __dso_handle VAR_DECL. */
7733 get_dso_handle_node (void)
7735 if (dso_handle_node
)
7736 return dso_handle_node
;
7738 /* Declare the variable. */
7739 dso_handle_node
= declare_global_var (get_identifier ("__dso_handle"),
7742 #ifdef HAVE_GAS_HIDDEN
7743 if (dso_handle_node
!= error_mark_node
)
7745 DECL_VISIBILITY (dso_handle_node
) = VISIBILITY_HIDDEN
;
7746 DECL_VISIBILITY_SPECIFIED (dso_handle_node
) = 1;
7750 return dso_handle_node
;
7753 /* Begin a new function with internal linkage whose job will be simply
7754 to destroy some particular variable. */
7756 static GTY(()) int start_cleanup_cnt
;
7759 start_cleanup_fn (void)
7764 bool use_cxa_atexit
= flag_use_cxa_atexit
7765 && !targetm
.cxx
.use_atexit_for_cxa_atexit ();
7767 push_to_top_level ();
7769 /* No need to mangle this. */
7770 push_lang_context (lang_name_c
);
7772 /* Build the name of the function. */
7773 sprintf (name
, "__tcf_%d", start_cleanup_cnt
++);
7774 /* Build the function declaration. */
7775 fntype
= TREE_TYPE (get_atexit_fn_ptr_type ());
7776 fndecl
= build_lang_decl (FUNCTION_DECL
, get_identifier (name
), fntype
);
7777 /* It's a function with internal linkage, generated by the
7779 TREE_PUBLIC (fndecl
) = 0;
7780 DECL_ARTIFICIAL (fndecl
) = 1;
7781 /* Make the function `inline' so that it is only emitted if it is
7782 actually needed. It is unlikely that it will be inlined, since
7783 it is only called via a function pointer, but we avoid unnecessary
7784 emissions this way. */
7785 DECL_DECLARED_INLINE_P (fndecl
) = 1;
7786 DECL_INTERFACE_KNOWN (fndecl
) = 1;
7787 /* Build the parameter. */
7790 tree parmdecl
= cp_build_parm_decl (fndecl
, NULL_TREE
, ptr_type_node
);
7791 TREE_USED (parmdecl
) = 1;
7792 DECL_READ_P (parmdecl
) = 1;
7793 DECL_ARGUMENTS (fndecl
) = parmdecl
;
7797 start_preparsed_function (fndecl
, NULL_TREE
, SF_PRE_PARSED
);
7799 pop_lang_context ();
7801 return current_function_decl
;
7804 /* Finish the cleanup function begun by start_cleanup_fn. */
7807 end_cleanup_fn (void)
7809 expand_or_defer_fn (finish_function (/*inline_p=*/false));
7811 pop_from_top_level ();
7814 /* Generate code to handle the destruction of DECL, an object with
7815 static storage duration. */
7818 register_dtor_fn (tree decl
)
7825 bool ob_parm
, dso_parm
, use_dtor
;
7826 tree arg0
, arg1
, arg2
;
7829 type
= TREE_TYPE (decl
);
7830 if (TYPE_HAS_TRIVIAL_DESTRUCTOR (type
))
7833 /* If we're using "__cxa_atexit" (or "__cxa_thread_atexit" or
7834 "__aeabi_atexit"), and DECL is a class object, we can just pass the
7835 destructor to "__cxa_atexit"; we don't have to build a temporary
7836 function to do the cleanup. */
7837 dso_parm
= (flag_use_cxa_atexit
7838 && !targetm
.cxx
.use_atexit_for_cxa_atexit ());
7839 ob_parm
= (CP_DECL_THREAD_LOCAL_P (decl
) || dso_parm
);
7840 use_dtor
= ob_parm
&& CLASS_TYPE_P (type
);
7843 cleanup
= get_class_binding (type
, complete_dtor_identifier
);
7845 /* Make sure it is accessible. */
7846 perform_or_defer_access_check (TYPE_BINFO (type
), cleanup
, cleanup
,
7847 tf_warning_or_error
);
7851 /* Call build_cleanup before we enter the anonymous function so
7852 that any access checks will be done relative to the current
7853 scope, rather than the scope of the anonymous function. */
7854 build_cleanup (decl
);
7856 /* Now start the function. */
7857 cleanup
= start_cleanup_fn ();
7859 /* Now, recompute the cleanup. It may contain SAVE_EXPRs that refer
7860 to the original function, rather than the anonymous one. That
7861 will make the back end think that nested functions are in use,
7862 which causes confusion. */
7863 push_deferring_access_checks (dk_no_check
);
7864 fcall
= build_cleanup (decl
);
7865 pop_deferring_access_checks ();
7867 /* Create the body of the anonymous function. */
7868 compound_stmt
= begin_compound_stmt (BCS_FN_BODY
);
7869 finish_expr_stmt (fcall
);
7870 finish_compound_stmt (compound_stmt
);
7874 /* Call atexit with the cleanup function. */
7875 mark_used (cleanup
);
7876 cleanup
= build_address (cleanup
);
7878 if (CP_DECL_THREAD_LOCAL_P (decl
))
7879 atex_node
= get_thread_atexit_node ();
7881 atex_node
= get_atexit_node ();
7885 /* We must convert CLEANUP to the type that "__cxa_atexit"
7887 cleanup
= build_nop (get_atexit_fn_ptr_type (), cleanup
);
7888 /* "__cxa_atexit" will pass the address of DECL to the
7889 cleanup function. */
7891 addr
= build_address (decl
);
7892 /* The declared type of the parameter to "__cxa_atexit" is
7893 "void *". For plain "T*", we could just let the
7894 machinery in cp_build_function_call convert it -- but if the
7895 type is "cv-qualified T *", then we need to convert it
7896 before passing it in, to avoid spurious errors. */
7897 addr
= build_nop (ptr_type_node
, addr
);
7900 /* Since the cleanup functions we build ignore the address
7901 they're given, there's no reason to pass the actual address
7902 in, and, in general, it's cheaper to pass NULL than any
7904 addr
= null_pointer_node
;
7907 arg2
= cp_build_addr_expr (get_dso_handle_node (),
7908 tf_warning_or_error
);
7910 /* Just pass NULL to the dso handle parm if we don't actually
7911 have a DSO handle on this target. */
7912 arg2
= null_pointer_node
;
7918 if (!CP_DECL_THREAD_LOCAL_P (decl
)
7919 && targetm
.cxx
.use_aeabi_atexit ())
7935 return cp_build_function_call_nary (atex_node
, tf_warning_or_error
,
7936 arg0
, arg1
, arg2
, NULL_TREE
);
7939 /* DECL is a VAR_DECL with static storage duration. INIT, if present,
7940 is its initializer. Generate code to handle the construction
7941 and destruction of DECL. */
7944 expand_static_init (tree decl
, tree init
)
7946 gcc_assert (VAR_P (decl
));
7947 gcc_assert (TREE_STATIC (decl
));
7949 /* Some variables require no dynamic initialization. */
7950 if (TYPE_HAS_TRIVIAL_DESTRUCTOR (TREE_TYPE (decl
)))
7952 /* Make sure the destructor is callable. */
7953 cxx_maybe_build_cleanup (decl
, tf_warning_or_error
);
7958 if (CP_DECL_THREAD_LOCAL_P (decl
) && DECL_GNU_TLS_P (decl
)
7959 && !DECL_FUNCTION_SCOPE_P (decl
))
7962 error ("non-local variable %qD declared %<__thread%> "
7963 "needs dynamic initialization", decl
);
7965 error ("non-local variable %qD declared %<__thread%> "
7966 "has a non-trivial destructor", decl
);
7967 static bool informed
;
7970 inform (DECL_SOURCE_LOCATION (decl
),
7971 "C++11 %<thread_local%> allows dynamic initialization "
7978 if (DECL_FUNCTION_SCOPE_P (decl
))
7980 /* Emit code to perform this initialization but once. */
7981 tree if_stmt
= NULL_TREE
, inner_if_stmt
= NULL_TREE
;
7982 tree then_clause
= NULL_TREE
, inner_then_clause
= NULL_TREE
;
7983 tree guard
, guard_addr
;
7985 /* We don't need thread-safety code for thread-local vars. */
7986 bool thread_guard
= (flag_threadsafe_statics
7987 && !CP_DECL_THREAD_LOCAL_P (decl
));
7989 /* Emit code to perform this initialization but once. This code
7992 static <type> guard;
7993 if (!__atomic_load (guard.first_byte)) {
7994 if (__cxa_guard_acquire (&guard)) {
7997 // Do initialization.
7998 flag = true; __cxa_guard_release (&guard);
7999 // Register variable for destruction at end of program.
8001 if (!flag) __cxa_guard_abort (&guard);
8006 Note that the `flag' variable is only set to 1 *after* the
8007 initialization is complete. This ensures that an exception,
8008 thrown during the construction, will cause the variable to
8009 reinitialized when we pass through this code again, as per:
8013 If the initialization exits by throwing an exception, the
8014 initialization is not complete, so it will be tried again
8015 the next time control enters the declaration.
8017 This process should be thread-safe, too; multiple threads
8018 should not be able to initialize the variable more than
8021 /* Create the guard variable. */
8022 guard
= get_guard (decl
);
8024 /* Begin the conditional initialization. */
8025 if_stmt
= begin_if_stmt ();
8027 finish_if_stmt_cond (get_guard_cond (guard
, thread_guard
), if_stmt
);
8028 then_clause
= begin_compound_stmt (BCS_NO_SCOPE
);
8032 tree vfntype
= NULL_TREE
;
8033 tree acquire_name
, release_name
, abort_name
;
8034 tree acquire_fn
, release_fn
, abort_fn
;
8035 guard_addr
= build_address (guard
);
8037 acquire_name
= get_identifier ("__cxa_guard_acquire");
8038 release_name
= get_identifier ("__cxa_guard_release");
8039 abort_name
= get_identifier ("__cxa_guard_abort");
8040 acquire_fn
= get_global_binding (acquire_name
);
8041 release_fn
= get_global_binding (release_name
);
8042 abort_fn
= get_global_binding (abort_name
);
8044 acquire_fn
= push_library_fn
8045 (acquire_name
, build_function_type_list (integer_type_node
,
8046 TREE_TYPE (guard_addr
),
8048 NULL_TREE
, ECF_NOTHROW
| ECF_LEAF
);
8049 if (!release_fn
|| !abort_fn
)
8050 vfntype
= build_function_type_list (void_type_node
,
8051 TREE_TYPE (guard_addr
),
8054 release_fn
= push_library_fn (release_name
, vfntype
, NULL_TREE
,
8055 ECF_NOTHROW
| ECF_LEAF
);
8057 abort_fn
= push_library_fn (abort_name
, vfntype
, NULL_TREE
,
8058 ECF_NOTHROW
| ECF_LEAF
);
8060 inner_if_stmt
= begin_if_stmt ();
8061 finish_if_stmt_cond (build_call_n (acquire_fn
, 1, guard_addr
),
8064 inner_then_clause
= begin_compound_stmt (BCS_NO_SCOPE
);
8065 begin
= get_target_expr (boolean_false_node
);
8066 flag
= TARGET_EXPR_SLOT (begin
);
8068 TARGET_EXPR_CLEANUP (begin
)
8069 = build3 (COND_EXPR
, void_type_node
, flag
,
8071 build_call_n (abort_fn
, 1, guard_addr
));
8072 CLEANUP_EH_ONLY (begin
) = 1;
8074 /* Do the initialization itself. */
8075 init
= add_stmt_to_compound (begin
, init
);
8076 init
= add_stmt_to_compound
8077 (init
, build2 (MODIFY_EXPR
, void_type_node
, flag
, boolean_true_node
));
8078 init
= add_stmt_to_compound
8079 (init
, build_call_n (release_fn
, 1, guard_addr
));
8082 init
= add_stmt_to_compound (init
, set_guard (guard
));
8084 /* Use atexit to register a function for destroying this static
8086 init
= add_stmt_to_compound (init
, register_dtor_fn (decl
));
8088 finish_expr_stmt (init
);
8092 finish_compound_stmt (inner_then_clause
);
8093 finish_then_clause (inner_if_stmt
);
8094 finish_if_stmt (inner_if_stmt
);
8097 finish_compound_stmt (then_clause
);
8098 finish_then_clause (if_stmt
);
8099 finish_if_stmt (if_stmt
);
8101 else if (CP_DECL_THREAD_LOCAL_P (decl
))
8102 tls_aggregates
= tree_cons (init
, decl
, tls_aggregates
);
8104 static_aggregates
= tree_cons (init
, decl
, static_aggregates
);
8108 /* Make TYPE a complete type based on INITIAL_VALUE.
8109 Return 0 if successful, 1 if INITIAL_VALUE can't be deciphered,
8110 2 if there was no information (in which case assume 0 if DO_DEFAULT),
8111 3 if the initializer list is empty (in pedantic mode). */
8114 cp_complete_array_type (tree
*ptype
, tree initial_value
, bool do_default
)
8117 tree type
, elt_type
;
8119 /* Don't get confused by a CONSTRUCTOR for some other type. */
8120 if (initial_value
&& TREE_CODE (initial_value
) == CONSTRUCTOR
8121 && !BRACE_ENCLOSED_INITIALIZER_P (initial_value
)
8122 && TREE_CODE (TREE_TYPE (initial_value
)) != ARRAY_TYPE
)
8127 unsigned HOST_WIDE_INT i
;
8130 /* An array of character type can be initialized from a
8131 brace-enclosed string constant.
8133 FIXME: this code is duplicated from reshape_init. Probably
8134 we should just call reshape_init here? */
8135 if (char_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (*ptype
)))
8136 && TREE_CODE (initial_value
) == CONSTRUCTOR
8137 && !vec_safe_is_empty (CONSTRUCTOR_ELTS (initial_value
)))
8139 vec
<constructor_elt
, va_gc
> *v
= CONSTRUCTOR_ELTS (initial_value
);
8140 tree value
= (*v
)[0].value
;
8142 if (TREE_CODE (value
) == STRING_CST
8143 && v
->length () == 1)
8144 initial_value
= value
;
8147 /* If any of the elements are parameter packs, we can't actually
8148 complete this type now because the array size is dependent. */
8149 if (TREE_CODE (initial_value
) == CONSTRUCTOR
)
8151 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (initial_value
),
8154 if (PACK_EXPANSION_P (value
))
8160 failure
= complete_array_type (ptype
, initial_value
, do_default
);
8162 /* We can create the array before the element type is complete, which
8163 means that we didn't have these two bits set in the original type
8164 either. In completing the type, we are expected to propagate these
8165 bits. See also complete_type which does the same thing for arrays
8168 if (TYPE_DOMAIN (type
))
8170 elt_type
= TREE_TYPE (type
);
8171 TYPE_NEEDS_CONSTRUCTING (type
) = TYPE_NEEDS_CONSTRUCTING (elt_type
);
8172 TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
)
8173 = TYPE_HAS_NONTRIVIAL_DESTRUCTOR (elt_type
);
8179 /* As above, but either give an error or reject zero-size arrays, depending
8183 cp_complete_array_type_or_error (tree
*ptype
, tree initial_value
,
8184 bool do_default
, tsubst_flags_t complain
)
8187 bool sfinae
= !(complain
& tf_error
);
8188 /* In SFINAE context we can't be lenient about zero-size arrays. */
8191 failure
= cp_complete_array_type (ptype
, initial_value
, do_default
);
8197 /* Not an error. */;
8198 else if (failure
== 1)
8199 error ("initializer fails to determine size of %qT", *ptype
);
8200 else if (failure
== 2)
8203 error ("array size missing in %qT", *ptype
);
8205 else if (failure
== 3)
8206 error ("zero-size array %qT", *ptype
);
8207 *ptype
= error_mark_node
;
8212 /* Return zero if something is declared to be a member of type
8213 CTYPE when in the context of CUR_TYPE. STRING is the error
8214 message to print in that case. Otherwise, quietly return 1. */
8217 member_function_or_else (tree ctype
, tree cur_type
, enum overload_flags flags
)
8219 if (ctype
&& ctype
!= cur_type
)
8221 if (flags
== DTOR_FLAG
)
8222 error ("destructor for alien class %qT cannot be a member", ctype
);
8224 error ("constructor for alien class %qT cannot be a member", ctype
);
8230 /* Subroutine of `grokdeclarator'. */
8232 /* Generate errors possibly applicable for a given set of specifiers.
8233 This is for ARM $7.1.2. */
8236 bad_specifiers (tree object
,
8237 enum bad_spec_place type
,
8248 error ("%qD declared as a %<virtual%> variable", object
);
8250 error ("%<const%> and %<volatile%> function specifiers on "
8251 "%qD invalid in variable declaration", object
);
8255 error ("%qD declared as a %<virtual%> parameter", object
);
8257 error ("%qD declared as an %<inline%> parameter", object
);
8259 error ("%<const%> and %<volatile%> function specifiers on "
8260 "%qD invalid in parameter declaration", object
);
8264 error ("%qD declared as a %<virtual%> type", object
);
8266 error ("%qD declared as an %<inline%> type", object
);
8268 error ("%<const%> and %<volatile%> function specifiers on "
8269 "%qD invalid in type declaration", object
);
8273 error ("%qD declared as a %<virtual%> field", object
);
8275 error ("%qD declared as an %<inline%> field", object
);
8277 error ("%<const%> and %<volatile%> function specifiers on "
8278 "%qD invalid in field declaration", object
);
8284 error ("%q+D declared as a friend", object
);
8286 && !flag_noexcept_type
8287 && (TREE_CODE (object
) == TYPE_DECL
8288 || (!TYPE_PTRFN_P (TREE_TYPE (object
))
8289 && !TYPE_REFFN_P (TREE_TYPE (object
))
8290 && !TYPE_PTRMEMFUNC_P (TREE_TYPE (object
)))))
8291 error ("%q+D declared with an exception specification", object
);
8294 /* DECL is a member function or static data member and is presently
8295 being defined. Check that the definition is taking place in a
8299 check_class_member_definition_namespace (tree decl
)
8301 /* These checks only apply to member functions and static data
8303 gcc_assert (VAR_OR_FUNCTION_DECL_P (decl
));
8304 /* We check for problems with specializations in pt.c in
8305 check_specialization_namespace, where we can issue better
8307 if (processing_specialization
)
8309 /* We check this in check_explicit_instantiation_namespace. */
8310 if (processing_explicit_instantiation
)
8314 A member function definition that appears outside of the
8315 class definition shall appear in a namespace scope enclosing
8316 the class definition.
8320 The definition for a static data member shall appear in a
8321 namespace scope enclosing the member's class definition. */
8322 if (!is_ancestor (current_namespace
, DECL_CONTEXT (decl
)))
8323 permerror (input_location
, "definition of %qD is not in namespace enclosing %qT",
8324 decl
, DECL_CONTEXT (decl
));
8327 /* Build a PARM_DECL for the "this" parameter of FN. TYPE is the
8328 METHOD_TYPE for a non-static member function; QUALS are the
8329 cv-qualifiers that apply to the function. */
8332 build_this_parm (tree fn
, tree type
, cp_cv_quals quals
)
8337 cp_cv_quals this_quals
;
8339 if (CLASS_TYPE_P (type
))
8342 = cp_build_qualified_type (type
, quals
& ~TYPE_QUAL_RESTRICT
);
8343 this_type
= build_pointer_type (this_type
);
8346 this_type
= type_of_this_parm (type
);
8347 /* The `this' parameter is implicitly `const'; it cannot be
8349 this_quals
= (quals
& TYPE_QUAL_RESTRICT
) | TYPE_QUAL_CONST
;
8350 qual_type
= cp_build_qualified_type (this_type
, this_quals
);
8351 parm
= build_artificial_parm (fn
, this_identifier
, qual_type
);
8352 cp_apply_type_quals_to_decl (this_quals
, parm
);
8356 /* DECL is a static member function. Complain if it was declared
8357 with function-cv-quals. */
8360 check_static_quals (tree decl
, cp_cv_quals quals
)
8362 if (quals
!= TYPE_UNQUALIFIED
)
8363 error ("static member function %q#D declared with type qualifiers",
8367 // Check that FN takes no arguments and returns bool.
8369 check_concept_fn (tree fn
)
8371 // A constraint is nullary.
8372 if (DECL_ARGUMENTS (fn
))
8373 error ("concept %q#D declared with function parameters", fn
);
8375 // The declared return type of the concept shall be bool, and
8376 // it shall not be deduced from it definition.
8377 tree type
= TREE_TYPE (TREE_TYPE (fn
));
8379 error ("concept %q#D declared with a deduced return type", fn
);
8380 else if (type
!= boolean_type_node
)
8381 error ("concept %q#D with non-%<bool%> return type %qT", fn
, type
);
8384 /* Helper function. Replace the temporary this parameter injected
8385 during cp_finish_omp_declare_simd with the real this parameter. */
8388 declare_simd_adjust_this (tree
*tp
, int *walk_subtrees
, void *data
)
8390 tree this_parm
= (tree
) data
;
8391 if (TREE_CODE (*tp
) == PARM_DECL
8392 && DECL_NAME (*tp
) == this_identifier
8393 && *tp
!= this_parm
)
8395 else if (TYPE_P (*tp
))
8400 /* CTYPE is class type, or null if non-class.
8401 TYPE is type this FUNCTION_DECL should have, either FUNCTION_TYPE
8403 DECLARATOR is the function's name.
8404 PARMS is a chain of PARM_DECLs for the function.
8405 VIRTUALP is truthvalue of whether the function is virtual or not.
8406 FLAGS are to be passed through to `grokclassfn'.
8407 QUALS are qualifiers indicating whether the function is `const'
8409 RAISES is a list of exceptions that this function can raise.
8410 CHECK is 1 if we must find this method in CTYPE, 0 if we should
8411 not look, and -1 if we should not call `grokclassfn' at all.
8413 SFK is the kind of special function (if any) for the new function.
8415 Returns `NULL_TREE' if something goes wrong, after issuing
8416 applicable error messages. */
8419 grokfndecl (tree ctype
,
8423 tree orig_declarator
,
8426 enum overload_flags flags
,
8428 cp_ref_qualifier rqual
,
8435 special_function_kind sfk
,
8440 location_t location
)
8443 int staticp
= ctype
&& TREE_CODE (type
) == FUNCTION_TYPE
;
8446 // Was the concept specifier present?
8447 bool concept_p
= inlinep
& 4;
8449 // Concept declarations must have a corresponding definition.
8450 if (concept_p
&& !funcdef_flag
)
8452 error ("concept %qD has no definition", declarator
);
8457 type
= build_ref_qualified_type (type
, rqual
);
8459 type
= build_exception_variant (type
, raises
);
8461 decl
= build_lang_decl (FUNCTION_DECL
, declarator
, type
);
8463 /* Set the constraints on the declaration. */
8466 tree tmpl_reqs
= NULL_TREE
;
8467 if (processing_template_decl
> template_class_depth (ctype
))
8468 tmpl_reqs
= TEMPLATE_PARMS_CONSTRAINTS (current_template_parms
);
8470 /* Adjust the required expression into a constraint. */
8472 decl_reqs
= normalize_expression (decl_reqs
);
8474 tree ci
= build_constraints (tmpl_reqs
, decl_reqs
);
8475 set_constraints (decl
, ci
);
8478 /* If we have an explicit location, use it, otherwise use whatever
8479 build_lang_decl used (probably input_location). */
8480 if (location
!= UNKNOWN_LOCATION
)
8481 DECL_SOURCE_LOCATION (decl
) = location
;
8483 if (TREE_CODE (type
) == METHOD_TYPE
)
8485 tree parm
= build_this_parm (decl
, type
, quals
);
8486 DECL_CHAIN (parm
) = parms
;
8489 /* Allocate space to hold the vptr bit if needed. */
8490 SET_DECL_ALIGN (decl
, MINIMUM_METHOD_BOUNDARY
);
8493 DECL_ARGUMENTS (decl
) = parms
;
8494 for (t
= parms
; t
; t
= DECL_CHAIN (t
))
8495 DECL_CONTEXT (t
) = decl
;
8497 /* Propagate volatile out from type to decl. */
8498 if (TYPE_VOLATILE (type
))
8499 TREE_THIS_VOLATILE (decl
) = 1;
8501 /* Setup decl according to sfk. */
8504 case sfk_constructor
:
8505 case sfk_copy_constructor
:
8506 case sfk_move_constructor
:
8507 DECL_CXX_CONSTRUCTOR_P (decl
) = 1;
8508 DECL_NAME (decl
) = ctor_identifier
;
8510 case sfk_destructor
:
8511 DECL_CXX_DESTRUCTOR_P (decl
) = 1;
8512 DECL_NAME (decl
) = dtor_identifier
;
8518 if (friendp
&& TREE_CODE (orig_declarator
) == TEMPLATE_ID_EXPR
)
8521 error ("defining explicit specialization %qD in friend declaration",
8525 tree fns
= TREE_OPERAND (orig_declarator
, 0);
8526 tree args
= TREE_OPERAND (orig_declarator
, 1);
8528 if (PROCESSING_REAL_TEMPLATE_DECL_P ())
8530 /* Something like `template <class T> friend void f<T>()'. */
8531 error ("invalid use of template-id %qD in declaration "
8532 "of primary template",
8538 /* A friend declaration of the form friend void f<>(). Record
8539 the information in the TEMPLATE_ID_EXPR. */
8540 SET_DECL_IMPLICIT_INSTANTIATION (decl
);
8542 gcc_assert (identifier_p (fns
) || TREE_CODE (fns
) == OVERLOAD
);
8543 DECL_TEMPLATE_INFO (decl
) = build_template_info (fns
, args
);
8545 for (t
= TYPE_ARG_TYPES (TREE_TYPE (decl
)); t
; t
= TREE_CHAIN (t
))
8546 if (TREE_PURPOSE (t
)
8547 && TREE_CODE (TREE_PURPOSE (t
)) == DEFAULT_ARG
)
8549 error ("default arguments are not allowed in declaration "
8550 "of friend template specialization %qD",
8557 error ("%<inline%> is not allowed in declaration of friend "
8558 "template specialization %qD",
8565 /* If this decl has namespace scope, set that up. */
8567 set_decl_namespace (decl
, in_namespace
, friendp
);
8569 DECL_CONTEXT (decl
) = FROB_CONTEXT (current_decl_namespace ());
8571 /* `main' and builtins have implicit 'C' linkage. */
8572 if (ctype
== NULL_TREE
8573 && DECL_FILE_SCOPE_P (decl
)
8574 && current_lang_name
== lang_name_cplusplus
8575 && (MAIN_NAME_P (declarator
)
8576 || (IDENTIFIER_LENGTH (declarator
) > 10
8577 && IDENTIFIER_POINTER (declarator
)[0] == '_'
8578 && IDENTIFIER_POINTER (declarator
)[1] == '_'
8579 && strncmp (IDENTIFIER_POINTER (declarator
)+2,
8580 "builtin_", 8) == 0)
8581 || (targetcm
.cxx_implicit_extern_c
8582 && (targetcm
.cxx_implicit_extern_c
8583 (IDENTIFIER_POINTER (declarator
))))))
8584 SET_DECL_LANGUAGE (decl
, lang_c
);
8586 /* Should probably propagate const out from type to decl I bet (mrs). */
8589 DECL_STATIC_FUNCTION_P (decl
) = 1;
8590 DECL_CONTEXT (decl
) = ctype
;
8594 DECL_DELETED_FN (decl
) = 1;
8598 DECL_CONTEXT (decl
) = ctype
;
8600 check_class_member_definition_namespace (decl
);
8603 if (ctype
== NULL_TREE
&& DECL_MAIN_P (decl
))
8605 if (PROCESSING_REAL_TEMPLATE_DECL_P())
8606 error ("cannot declare %<::main%> to be a template");
8608 error ("cannot declare %<::main%> to be inline");
8610 error ("cannot declare %<::main%> to be constexpr");
8612 error ("cannot declare %<::main%> to be static");
8617 /* Members of anonymous types and local classes have no linkage; make
8618 them internal. If a typedef is made later, this will be changed. */
8619 if (ctype
&& (!TREE_PUBLIC (TYPE_MAIN_DECL (ctype
))
8620 || decl_function_context (TYPE_MAIN_DECL (ctype
))))
8623 if (publicp
&& cxx_dialect
== cxx98
)
8625 /* [basic.link]: A name with no linkage (notably, the name of a class
8626 or enumeration declared in a local scope) shall not be used to
8627 declare an entity with linkage.
8629 DR 757 relaxes this restriction for C++0x. */
8630 no_linkage_error (decl
);
8633 TREE_PUBLIC (decl
) = publicp
;
8636 DECL_INTERFACE_KNOWN (decl
) = 1;
8637 DECL_NOT_REALLY_EXTERN (decl
) = 1;
8640 /* If the declaration was declared inline, mark it as such. */
8643 DECL_DECLARED_INLINE_P (decl
) = 1;
8645 DECL_COMDAT (decl
) = 1;
8648 DECL_DECLARED_CONSTEXPR_P (decl
) = true;
8650 // If the concept declaration specifier was found, check
8651 // that the declaration satisfies the necessary requirements.
8654 DECL_DECLARED_CONCEPT_P (decl
) = true;
8655 check_concept_fn (decl
);
8658 DECL_EXTERNAL (decl
) = 1;
8659 if (TREE_CODE (type
) == FUNCTION_TYPE
)
8662 TREE_TYPE (decl
) = apply_memfn_quals (TREE_TYPE (decl
),
8669 ? G_("static member function %qD cannot have cv-qualifier")
8670 : G_("non-member function %qD cannot have cv-qualifier"),
8672 quals
= TYPE_UNQUALIFIED
;
8678 ? G_("static member function %qD cannot have ref-qualifier")
8679 : G_("non-member function %qD cannot have ref-qualifier"),
8681 rqual
= REF_QUAL_NONE
;
8685 if (deduction_guide_p (decl
))
8687 if (!DECL_NAMESPACE_SCOPE_P (decl
))
8689 error_at (location
, "deduction guide %qD must be declared at "
8690 "namespace scope", decl
);
8695 "deduction guide %qD must not have a function body", decl
);
8697 else if (IDENTIFIER_ANY_OP_P (DECL_NAME (decl
))
8698 && !grok_op_properties (decl
, /*complain=*/true))
8700 else if (UDLIT_OPER_P (DECL_NAME (decl
)))
8702 bool long_long_unsigned_p
;
8704 const char *suffix
= NULL
;
8705 /* [over.literal]/6: Literal operators shall not have C linkage. */
8706 if (DECL_LANGUAGE (decl
) == lang_c
)
8708 error ("literal operator with C linkage");
8709 maybe_show_extern_c_location ();
8713 if (DECL_NAMESPACE_SCOPE_P (decl
))
8715 if (!check_literal_operator_args (decl
, &long_long_unsigned_p
,
8718 error ("%qD has invalid argument list", decl
);
8722 suffix
= UDLIT_OP_SUFFIX (DECL_NAME (decl
));
8723 if (long_long_unsigned_p
)
8725 if (cpp_interpret_int_suffix (parse_in
, suffix
, strlen (suffix
)))
8726 warning (0, "integer suffix %qs"
8727 " shadowed by implementation", suffix
);
8729 else if (long_double_p
)
8731 if (cpp_interpret_float_suffix (parse_in
, suffix
, strlen (suffix
)))
8732 warning (0, "floating point suffix %qs"
8733 " shadowed by implementation", suffix
);
8738 error ("%qD must be a non-member function", decl
);
8744 /* Make the init_value nonzero so pushdecl knows this is not
8745 tentative. error_mark_node is replaced later with the BLOCK. */
8746 DECL_INITIAL (decl
) = error_mark_node
;
8748 if (TYPE_NOTHROW_P (type
) || nothrow_libfn_p (decl
))
8749 TREE_NOTHROW (decl
) = 1;
8751 if (flag_openmp
|| flag_openmp_simd
|| flag_cilkplus
)
8753 /* Adjust "omp declare simd" attributes. */
8754 tree ods
= lookup_attribute ("omp declare simd", *attrlist
);
8758 for (attr
= ods
; attr
;
8759 attr
= lookup_attribute ("omp declare simd", TREE_CHAIN (attr
)))
8761 if (TREE_CODE (type
) == METHOD_TYPE
)
8762 walk_tree (&TREE_VALUE (attr
), declare_simd_adjust_this
,
8763 DECL_ARGUMENTS (decl
), NULL
);
8764 if (TREE_VALUE (attr
) != NULL_TREE
)
8766 tree cl
= TREE_VALUE (TREE_VALUE (attr
));
8767 cl
= c_omp_declare_simd_clauses_to_numbers
8768 (DECL_ARGUMENTS (decl
), cl
);
8770 TREE_VALUE (TREE_VALUE (attr
)) = cl
;
8772 TREE_VALUE (attr
) = NULL_TREE
;
8778 /* Caller will do the rest of this. */
8782 if (ctype
!= NULL_TREE
)
8783 grokclassfn (ctype
, decl
, flags
);
8786 if (cxx_dialect
>= cxx11
8787 && DECL_DESTRUCTOR_P (decl
)
8788 && !TYPE_BEING_DEFINED (DECL_CONTEXT (decl
))
8789 && !processing_template_decl
)
8790 deduce_noexcept_on_destructor (decl
);
8792 decl
= check_explicit_specialization (orig_declarator
, decl
,
8795 4 * (friendp
!= 0) +
8797 if (decl
== error_mark_node
)
8800 if (DECL_STATIC_FUNCTION_P (decl
))
8801 check_static_quals (decl
, quals
);
8805 cplus_decl_attributes (&decl
, *attrlist
, 0);
8806 *attrlist
= NULL_TREE
;
8809 /* Check main's type after attributes have been applied. */
8810 if (ctype
== NULL_TREE
&& DECL_MAIN_P (decl
))
8812 if (!same_type_p (TREE_TYPE (TREE_TYPE (decl
)),
8815 tree oldtypeargs
= TYPE_ARG_TYPES (TREE_TYPE (decl
));
8817 error ("%<::main%> must return %<int%>");
8818 newtype
= build_function_type (integer_type_node
, oldtypeargs
);
8819 TREE_TYPE (decl
) = newtype
;
8822 check_main_parameter_types (decl
);
8825 if (ctype
!= NULL_TREE
&& check
)
8827 tree old_decl
= check_classfn (ctype
, decl
,
8828 (processing_template_decl
8829 > template_class_depth (ctype
))
8830 ? current_template_parms
8833 if (old_decl
== error_mark_node
)
8841 if (TREE_CODE (old_decl
) == TEMPLATE_DECL
)
8842 /* Because grokfndecl is always supposed to return a
8843 FUNCTION_DECL, we pull out the DECL_TEMPLATE_RESULT
8844 here. We depend on our callers to figure out that its
8845 really a template that's being returned. */
8846 old_decl
= DECL_TEMPLATE_RESULT (old_decl
);
8848 if (DECL_STATIC_FUNCTION_P (old_decl
)
8849 && TREE_CODE (TREE_TYPE (decl
)) == METHOD_TYPE
)
8851 /* Remove the `this' parm added by grokclassfn. */
8852 revert_static_member_fn (decl
);
8853 check_static_quals (decl
, quals
);
8855 if (DECL_ARTIFICIAL (old_decl
))
8857 error ("definition of implicitly-declared %qD", old_decl
);
8860 else if (DECL_DEFAULTED_FN (old_decl
))
8862 error ("definition of explicitly-defaulted %q+D", decl
);
8863 inform (DECL_SOURCE_LOCATION (old_decl
),
8864 "%q#D explicitly defaulted here", old_decl
);
8868 /* Since we've smashed OLD_DECL to its
8869 DECL_TEMPLATE_RESULT, we must do the same to DECL. */
8870 if (TREE_CODE (decl
) == TEMPLATE_DECL
)
8871 decl
= DECL_TEMPLATE_RESULT (decl
);
8873 /* Attempt to merge the declarations. This can fail, in
8874 the case of some invalid specialization declarations. */
8875 pushed_scope
= push_scope (ctype
);
8876 ok
= duplicate_decls (decl
, old_decl
, friendp
);
8878 pop_scope (pushed_scope
);
8881 error ("no %q#D member function declared in class %qT",
8885 if (ok
== error_mark_node
)
8891 if (DECL_CONSTRUCTOR_P (decl
) && !grok_ctor_properties (ctype
, decl
))
8894 if (ctype
== NULL_TREE
|| check
)
8898 DECL_VIRTUAL_P (decl
) = 1;
8903 /* decl is a FUNCTION_DECL.
8904 specifiers are the parsed virt-specifiers.
8906 Set flags to reflect the virt-specifiers.
8911 set_virt_specifiers (tree decl
, cp_virt_specifiers specifiers
)
8913 if (decl
== NULL_TREE
)
8915 if (specifiers
& VIRT_SPEC_OVERRIDE
)
8916 DECL_OVERRIDE_P (decl
) = 1;
8917 if (specifiers
& VIRT_SPEC_FINAL
)
8918 DECL_FINAL_P (decl
) = 1;
8922 /* DECL is a VAR_DECL for a static data member. Set flags to reflect
8923 the linkage that DECL will receive in the object file. */
8926 set_linkage_for_static_data_member (tree decl
)
8928 /* A static data member always has static storage duration and
8929 external linkage. Note that static data members are forbidden in
8930 local classes -- the only situation in which a class has
8931 non-external linkage. */
8932 TREE_PUBLIC (decl
) = 1;
8933 TREE_STATIC (decl
) = 1;
8934 /* For non-template classes, static data members are always put
8935 out in exactly those files where they are defined, just as
8936 with ordinary namespace-scope variables. */
8937 if (!processing_template_decl
)
8938 DECL_INTERFACE_KNOWN (decl
) = 1;
8941 /* Create a VAR_DECL named NAME with the indicated TYPE.
8943 If SCOPE is non-NULL, it is the class type or namespace containing
8944 the variable. If SCOPE is NULL, the variable should is created in
8945 the innermost enclosing scope. */
8948 grokvardecl (tree type
,
8950 tree orig_declarator
,
8951 const cp_decl_specifier_seq
*declspecs
,
8960 tree explicit_scope
;
8962 gcc_assert (!name
|| identifier_p (name
));
8964 bool constp
= (type_quals
& TYPE_QUAL_CONST
) != 0;
8965 bool volatilep
= (type_quals
& TYPE_QUAL_VOLATILE
) != 0;
8967 /* Compute the scope in which to place the variable, but remember
8968 whether or not that scope was explicitly specified by the user. */
8969 explicit_scope
= scope
;
8972 /* An explicit "extern" specifier indicates a namespace-scope
8974 if (declspecs
->storage_class
== sc_extern
)
8975 scope
= current_decl_namespace ();
8976 else if (!at_function_scope_p ())
8977 scope
= current_scope ();
8981 && (/* If the variable is a namespace-scope variable declared in a
8982 template, we need DECL_LANG_SPECIFIC. */
8983 (TREE_CODE (scope
) == NAMESPACE_DECL
&& processing_template_decl
)
8984 /* Similarly for namespace-scope variables with language linkage
8986 || (TREE_CODE (scope
) == NAMESPACE_DECL
8987 && current_lang_name
!= lang_name_cplusplus
)
8988 /* Similarly for static data members. */
8990 /* Similarly for explicit specializations. */
8992 && TREE_CODE (orig_declarator
) == TEMPLATE_ID_EXPR
)))
8993 decl
= build_lang_decl (VAR_DECL
, name
, type
);
8995 decl
= build_decl (input_location
, VAR_DECL
, name
, type
);
8997 if (explicit_scope
&& TREE_CODE (explicit_scope
) == NAMESPACE_DECL
)
8998 set_decl_namespace (decl
, explicit_scope
, 0);
9000 DECL_CONTEXT (decl
) = FROB_CONTEXT (scope
);
9002 if (declspecs
->storage_class
== sc_extern
)
9004 DECL_THIS_EXTERN (decl
) = 1;
9005 DECL_EXTERNAL (decl
) = !initialized
;
9008 if (DECL_CLASS_SCOPE_P (decl
))
9010 set_linkage_for_static_data_member (decl
);
9011 /* This function is only called with out-of-class definitions. */
9012 DECL_EXTERNAL (decl
) = 0;
9013 check_class_member_definition_namespace (decl
);
9015 /* At top level, either `static' or no s.c. makes a definition
9016 (perhaps tentative), and absence of `static' makes it public. */
9017 else if (toplevel_bindings_p ())
9019 TREE_PUBLIC (decl
) = (declspecs
->storage_class
!= sc_static
9020 && (DECL_THIS_EXTERN (decl
)
9024 TREE_STATIC (decl
) = ! DECL_EXTERNAL (decl
);
9026 /* Not at top level, only `static' makes a static definition. */
9029 TREE_STATIC (decl
) = declspecs
->storage_class
== sc_static
;
9030 TREE_PUBLIC (decl
) = DECL_EXTERNAL (decl
);
9033 if (decl_spec_seq_has_spec_p (declspecs
, ds_thread
))
9035 if (DECL_EXTERNAL (decl
) || TREE_STATIC (decl
))
9037 CP_DECL_THREAD_LOCAL_P (decl
) = true;
9038 if (!processing_template_decl
)
9039 set_decl_tls_model (decl
, decl_default_tls_model (decl
));
9041 if (declspecs
->gnu_thread_keyword_p
)
9042 SET_DECL_GNU_TLS_P (decl
);
9045 /* If the type of the decl has no linkage, make sure that we'll
9046 notice that in mark_used. */
9047 if (cxx_dialect
> cxx98
9048 && decl_linkage (decl
) != lk_none
9049 && DECL_LANG_SPECIFIC (decl
) == NULL
9050 && !DECL_EXTERN_C_P (decl
)
9051 && no_linkage_check (TREE_TYPE (decl
), /*relaxed_p=*/false))
9052 retrofit_lang_decl (decl
);
9054 if (TREE_PUBLIC (decl
))
9056 /* [basic.link]: A name with no linkage (notably, the name of a class
9057 or enumeration declared in a local scope) shall not be used to
9058 declare an entity with linkage.
9060 DR 757 relaxes this restriction for C++0x. */
9061 if (cxx_dialect
< cxx11
)
9062 no_linkage_error (decl
);
9065 DECL_INTERFACE_KNOWN (decl
) = 1;
9067 if (DECL_NAME (decl
)
9068 && MAIN_NAME_P (DECL_NAME (decl
))
9069 && scope
== global_namespace
)
9070 error ("cannot declare %<::main%> to be a global variable");
9072 /* Check that the variable can be safely declared as a concept.
9073 Note that this also forbids explicit specializations. */
9076 if (!processing_template_decl
)
9078 error ("a non-template variable cannot be %<concept%>");
9082 DECL_DECLARED_CONCEPT_P (decl
) = true;
9083 if (!same_type_ignoring_top_level_qualifiers_p (type
, boolean_type_node
))
9084 error_at (declspecs
->locations
[ds_type_spec
],
9085 "concept must have type %<bool%>");
9087 else if (flag_concepts
9088 && processing_template_decl
> template_class_depth (scope
))
9090 tree reqs
= TEMPLATE_PARMS_CONSTRAINTS (current_template_parms
);
9091 tree ci
= build_constraints (reqs
, NULL_TREE
);
9092 set_constraints (decl
, ci
);
9095 // Handle explicit specializations and instantiations of variable templates.
9096 if (orig_declarator
)
9097 decl
= check_explicit_specialization (orig_declarator
, decl
,
9098 template_count
, conceptp
* 8);
9100 return decl
!= error_mark_node
? decl
: NULL_TREE
;
9103 /* Create and return a canonical pointer to member function type, for
9104 TYPE, which is a POINTER_TYPE to a METHOD_TYPE. */
9107 build_ptrmemfunc_type (tree type
)
9112 if (type
== error_mark_node
)
9115 /* Make sure that we always have the unqualified pointer-to-member
9117 if (cp_cv_quals quals
= cp_type_quals (type
))
9119 tree unqual
= build_ptrmemfunc_type (TYPE_MAIN_VARIANT (type
));
9120 return cp_build_qualified_type (unqual
, quals
);
9123 /* If a canonical type already exists for this type, use it. We use
9124 this method instead of type_hash_canon, because it only does a
9125 simple equality check on the list of field members. */
9127 t
= TYPE_PTRMEMFUNC_TYPE (type
);
9131 t
= make_node (RECORD_TYPE
);
9133 /* Let the front end know this is a pointer to member function. */
9134 TYPE_PTRMEMFUNC_FLAG (t
) = 1;
9136 field
= build_decl (input_location
, FIELD_DECL
, pfn_identifier
, type
);
9139 field
= build_decl (input_location
, FIELD_DECL
, delta_identifier
,
9141 DECL_CHAIN (field
) = fields
;
9144 finish_builtin_struct (t
, "__ptrmemfunc_type", fields
, ptr_type_node
);
9146 /* Zap out the name so that the back end will give us the debugging
9147 information for this anonymous RECORD_TYPE. */
9148 TYPE_NAME (t
) = NULL_TREE
;
9150 /* Cache this pointer-to-member type so that we can find it again
9152 TYPE_PTRMEMFUNC_TYPE (type
) = t
;
9154 if (TYPE_STRUCTURAL_EQUALITY_P (type
))
9155 SET_TYPE_STRUCTURAL_EQUALITY (t
);
9156 else if (TYPE_CANONICAL (type
) != type
)
9157 TYPE_CANONICAL (t
) = build_ptrmemfunc_type (TYPE_CANONICAL (type
));
9162 /* Create and return a pointer to data member type. */
9165 build_ptrmem_type (tree class_type
, tree member_type
)
9167 if (TREE_CODE (member_type
) == METHOD_TYPE
)
9169 cp_cv_quals quals
= type_memfn_quals (member_type
);
9170 cp_ref_qualifier rqual
= type_memfn_rqual (member_type
);
9171 member_type
= build_memfn_type (member_type
, class_type
, quals
, rqual
);
9172 return build_ptrmemfunc_type (build_pointer_type (member_type
));
9176 gcc_assert (TREE_CODE (member_type
) != FUNCTION_TYPE
);
9177 return build_offset_type (class_type
, member_type
);
9181 /* DECL is a VAR_DECL defined in-class, whose TYPE is also given.
9182 Check to see that the definition is valid. Issue appropriate error
9183 messages. Return 1 if the definition is particularly bad, or 0
9187 check_static_variable_definition (tree decl
, tree type
)
9189 /* Avoid redundant diagnostics on out-of-class definitions. */
9190 if (!current_class_type
|| !TYPE_BEING_DEFINED (current_class_type
))
9192 /* Can't check yet if we don't know the type. */
9193 if (dependent_type_p (type
))
9195 /* If DECL is declared constexpr, we'll do the appropriate checks
9196 in check_initializer. Similarly for inline static data members. */
9198 && (DECL_DECLARED_CONSTEXPR_P (decl
)
9199 || DECL_VAR_DECLARED_INLINE_P (decl
)))
9201 else if (cxx_dialect
>= cxx11
&& !INTEGRAL_OR_ENUMERATION_TYPE_P (type
))
9203 if (!COMPLETE_TYPE_P (type
))
9204 error_at (DECL_SOURCE_LOCATION (decl
),
9205 "in-class initialization of static data member %q#D of "
9206 "incomplete type", decl
);
9207 else if (literal_type_p (type
))
9208 permerror (DECL_SOURCE_LOCATION (decl
),
9209 "%<constexpr%> needed for in-class initialization of "
9210 "static data member %q#D of non-integral type", decl
);
9212 error_at (DECL_SOURCE_LOCATION (decl
),
9213 "in-class initialization of static data member %q#D of "
9214 "non-literal type", decl
);
9218 /* Motion 10 at San Diego: If a static const integral data member is
9219 initialized with an integral constant expression, the initializer
9220 may appear either in the declaration (within the class), or in
9221 the definition, but not both. If it appears in the class, the
9222 member is a member constant. The file-scope definition is always
9224 if (!ARITHMETIC_TYPE_P (type
) && TREE_CODE (type
) != ENUMERAL_TYPE
)
9226 error_at (DECL_SOURCE_LOCATION (decl
),
9227 "invalid in-class initialization of static data member "
9228 "of non-integral type %qT",
9232 else if (!CP_TYPE_CONST_P (type
))
9233 error_at (DECL_SOURCE_LOCATION (decl
),
9234 "ISO C++ forbids in-class initialization of non-const "
9235 "static member %qD",
9237 else if (!INTEGRAL_OR_ENUMERATION_TYPE_P (type
))
9238 pedwarn (DECL_SOURCE_LOCATION (decl
), OPT_Wpedantic
,
9239 "ISO C++ forbids initialization of member constant "
9240 "%qD of non-integral type %qT", decl
, type
);
9245 /* *expr_p is part of the TYPE_SIZE of a variably-sized array. If any
9246 SAVE_EXPRs in *expr_p wrap expressions with side-effects, break those
9247 expressions out into temporary variables so that walk_tree doesn't
9248 step into them (c++/15764). */
9251 stabilize_save_expr_r (tree
*expr_p
, int *walk_subtrees
, void *data
)
9253 hash_set
<tree
> *pset
= (hash_set
<tree
> *)data
;
9254 tree expr
= *expr_p
;
9255 if (TREE_CODE (expr
) == SAVE_EXPR
)
9257 tree op
= TREE_OPERAND (expr
, 0);
9258 cp_walk_tree (&op
, stabilize_save_expr_r
, data
, pset
);
9259 if (TREE_SIDE_EFFECTS (op
))
9260 TREE_OPERAND (expr
, 0) = get_temp_regvar (TREE_TYPE (op
), op
);
9263 else if (!EXPR_P (expr
) || !TREE_SIDE_EFFECTS (expr
))
9268 /* Entry point for the above. */
9271 stabilize_vla_size (tree size
)
9273 hash_set
<tree
> pset
;
9274 /* Break out any function calls into temporary variables. */
9275 cp_walk_tree (&size
, stabilize_save_expr_r
, &pset
, &pset
);
9278 /* Reduce a SIZEOF_EXPR to its value. */
9281 fold_sizeof_expr (tree t
)
9284 if (SIZEOF_EXPR_TYPE_P (t
))
9285 r
= cxx_sizeof_or_alignof_type (TREE_TYPE (TREE_OPERAND (t
, 0)),
9286 SIZEOF_EXPR
, false);
9287 else if (TYPE_P (TREE_OPERAND (t
, 0)))
9288 r
= cxx_sizeof_or_alignof_type (TREE_OPERAND (t
, 0), SIZEOF_EXPR
,
9291 r
= cxx_sizeof_or_alignof_expr (TREE_OPERAND (t
, 0), SIZEOF_EXPR
,
9293 if (r
== error_mark_node
)
9298 /* Given the SIZE (i.e., number of elements) in an array, compute
9299 an appropriate index type for the array. If non-NULL, NAME is
9300 the name of the entity being declared. */
9303 compute_array_index_type (tree name
, tree size
, tsubst_flags_t complain
)
9308 if (error_operand_p (size
))
9309 return error_mark_node
;
9311 if (!type_dependent_expression_p (size
))
9313 tree type
= TREE_TYPE (size
);
9315 size
= mark_rvalue_use (size
);
9317 if (cxx_dialect
< cxx11
&& TREE_CODE (size
) == NOP_EXPR
9318 && TREE_SIDE_EFFECTS (size
))
9319 /* In C++98, we mark a non-constant array bound with a magic
9320 NOP_EXPR with TREE_SIDE_EFFECTS; don't fold in that case. */;
9323 size
= instantiate_non_dependent_expr_sfinae (size
, complain
);
9325 if (CLASS_TYPE_P (type
)
9326 && CLASSTYPE_LITERAL_P (type
))
9328 size
= build_expr_type_conversion (WANT_INT
, size
, true);
9331 if (!(complain
& tf_error
))
9332 return error_mark_node
;
9334 error ("size of array %qD has non-integral type %qT",
9337 error ("size of array has non-integral type %qT", type
);
9338 size
= integer_one_node
;
9340 if (size
== error_mark_node
)
9341 return error_mark_node
;
9342 type
= TREE_TYPE (size
);
9345 if (INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type
))
9346 size
= maybe_constant_value (size
);
9348 if (!TREE_CONSTANT (size
))
9352 if (error_operand_p (size
))
9353 return error_mark_node
;
9355 /* The array bound must be an integer type. */
9356 if (!INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type
))
9358 if (!(complain
& tf_error
))
9359 return error_mark_node
;
9361 error ("size of array %qD has non-integral type %qT", name
, type
);
9363 error ("size of array has non-integral type %qT", type
);
9364 size
= integer_one_node
;
9365 type
= TREE_TYPE (size
);
9369 /* A type is dependent if it is...an array type constructed from any
9370 dependent type or whose size is specified by a constant expression
9371 that is value-dependent. */
9372 /* We can only call value_dependent_expression_p on integral constant
9373 expressions; treat non-constant expressions as dependent, too. */
9374 if (processing_template_decl
9375 && (type_dependent_expression_p (size
)
9376 || !TREE_CONSTANT (size
) || value_dependent_expression_p (size
)))
9378 /* We cannot do any checking for a SIZE that isn't known to be
9379 constant. Just build the index type and mark that it requires
9380 structural equality checks. */
9381 itype
= build_index_type (build_min (MINUS_EXPR
, sizetype
,
9382 size
, size_one_node
));
9383 TYPE_DEPENDENT_P (itype
) = 1;
9384 TYPE_DEPENDENT_P_VALID (itype
) = 1;
9385 SET_TYPE_STRUCTURAL_EQUALITY (itype
);
9389 if (TREE_CODE (size
) != INTEGER_CST
)
9391 tree folded
= cp_fully_fold (size
);
9392 if (TREE_CODE (folded
) == INTEGER_CST
)
9393 pedwarn (location_of (size
), OPT_Wpedantic
,
9394 "size of array is not an integral constant-expression");
9395 /* Use the folded result for VLAs, too; it will have resolved
9400 /* Normally, the array-bound will be a constant. */
9401 if (TREE_CODE (size
) == INTEGER_CST
)
9403 /* Check to see if the array bound overflowed. Make that an
9404 error, no matter how generous we're being. */
9405 constant_expression_error (size
);
9407 /* An array must have a positive number of elements. */
9408 if (tree_int_cst_lt (size
, integer_zero_node
))
9410 if (!(complain
& tf_error
))
9411 return error_mark_node
;
9413 error ("size of array %qD is negative", name
);
9415 error ("size of array is negative");
9416 size
= integer_one_node
;
9418 /* As an extension we allow zero-sized arrays. */
9419 else if (integer_zerop (size
))
9421 if (!(complain
& tf_error
))
9422 /* We must fail if performing argument deduction (as
9423 indicated by the state of complain), so that
9424 another substitution can be found. */
9425 return error_mark_node
;
9426 else if (in_system_header_at (input_location
))
9427 /* Allow them in system headers because glibc uses them. */;
9429 pedwarn (input_location
, OPT_Wpedantic
, "ISO C++ forbids zero-size array %qD", name
);
9431 pedwarn (input_location
, OPT_Wpedantic
, "ISO C++ forbids zero-size array");
9434 else if (TREE_CONSTANT (size
)
9435 /* We don't allow VLAs at non-function scopes, or during
9436 tentative template substitution. */
9437 || !at_function_scope_p ()
9438 || !(complain
& tf_error
))
9440 if (!(complain
& tf_error
))
9441 return error_mark_node
;
9442 /* `(int) &fn' is not a valid array bound. */
9444 error ("size of array %qD is not an integral constant-expression",
9447 error ("size of array is not an integral constant-expression");
9448 size
= integer_one_node
;
9450 else if (pedantic
&& warn_vla
!= 0)
9453 pedwarn (input_location
, OPT_Wvla
, "ISO C++ forbids variable length array %qD", name
);
9455 pedwarn (input_location
, OPT_Wvla
, "ISO C++ forbids variable length array");
9457 else if (warn_vla
> 0)
9461 "variable length array %qD is used", name
);
9464 "variable length array is used");
9467 if (processing_template_decl
&& !TREE_CONSTANT (size
))
9468 /* A variable sized array. */
9469 itype
= build_min (MINUS_EXPR
, sizetype
, size
, integer_one_node
);
9472 /* Compute the index of the largest element in the array. It is
9473 one less than the number of elements in the array. We save
9474 and restore PROCESSING_TEMPLATE_DECL so that computations in
9475 cp_build_binary_op will be appropriately folded. */
9477 processing_template_decl_sentinel s
;
9478 itype
= cp_build_binary_op (input_location
,
9480 cp_convert (ssizetype
, size
, complain
),
9481 cp_convert (ssizetype
, integer_one_node
,
9484 itype
= maybe_constant_value (itype
);
9487 if (!TREE_CONSTANT (itype
))
9489 /* A variable sized array. */
9490 itype
= variable_size (itype
);
9492 stabilize_vla_size (itype
);
9494 if (sanitize_flags_p (SANITIZE_VLA
)
9495 && current_function_decl
!= NULL_TREE
)
9497 /* We have to add 1 -- in the ubsan routine we generate
9498 LE_EXPR rather than LT_EXPR. */
9499 tree t
= fold_build2 (PLUS_EXPR
, TREE_TYPE (itype
), itype
,
9500 build_one_cst (TREE_TYPE (itype
)));
9501 t
= ubsan_instrument_vla (input_location
, t
);
9502 finish_expr_stmt (t
);
9505 /* Make sure that there was no overflow when creating to a signed
9506 index type. (For example, on a 32-bit machine, an array with
9507 size 2^32 - 1 is too big.) */
9508 else if (TREE_CODE (itype
) == INTEGER_CST
9509 && TREE_OVERFLOW (itype
))
9511 if (!(complain
& tf_error
))
9512 return error_mark_node
;
9513 error ("overflow in array dimension");
9514 TREE_OVERFLOW (itype
) = 0;
9518 /* Create and return the appropriate index type. */
9519 itype
= build_index_type (itype
);
9521 /* If the index type were dependent, we would have returned early, so
9522 remember that it isn't. */
9523 TYPE_DEPENDENT_P (itype
) = 0;
9524 TYPE_DEPENDENT_P_VALID (itype
) = 1;
9528 /* Returns the scope (if any) in which the entity declared by
9529 DECLARATOR will be located. If the entity was declared with an
9530 unqualified name, NULL_TREE is returned. */
9533 get_scope_of_declarator (const cp_declarator
*declarator
)
9535 while (declarator
&& declarator
->kind
!= cdk_id
)
9536 declarator
= declarator
->declarator
;
9538 /* If the declarator-id is a SCOPE_REF, the scope in which the
9539 declaration occurs is the first operand. */
9541 && declarator
->u
.id
.qualifying_scope
)
9542 return declarator
->u
.id
.qualifying_scope
;
9544 /* Otherwise, the declarator is not a qualified name; the entity will
9545 be declared in the current scope. */
9549 /* Returns an ARRAY_TYPE for an array with SIZE elements of the
9550 indicated TYPE. If non-NULL, NAME is the NAME of the declaration
9554 create_array_type_for_decl (tree name
, tree type
, tree size
)
9556 tree itype
= NULL_TREE
;
9558 /* If things have already gone awry, bail now. */
9559 if (type
== error_mark_node
|| size
== error_mark_node
)
9560 return error_mark_node
;
9562 /* 8.3.4/1: If the type of the identifier of D contains the auto
9563 type-specifier, the program is ill-formed. */
9564 if (type_uses_auto (type
))
9566 error ("%qD declared as array of %qT", name
, type
);
9567 return error_mark_node
;
9570 /* If there are some types which cannot be array elements,
9571 issue an error-message and return. */
9572 switch (TREE_CODE (type
))
9576 error ("declaration of %qD as array of void", name
);
9578 error ("creating array of void");
9579 return error_mark_node
;
9583 error ("declaration of %qD as array of functions", name
);
9585 error ("creating array of functions");
9586 return error_mark_node
;
9588 case REFERENCE_TYPE
:
9590 error ("declaration of %qD as array of references", name
);
9592 error ("creating array of references");
9593 return error_mark_node
;
9597 error ("declaration of %qD as array of function members", name
);
9599 error ("creating array of function members");
9600 return error_mark_node
;
9608 The constant expressions that specify the bounds of the arrays
9609 can be omitted only for the first member of the sequence. */
9610 if (TREE_CODE (type
) == ARRAY_TYPE
&& !TYPE_DOMAIN (type
))
9613 error ("declaration of %qD as multidimensional array must "
9614 "have bounds for all dimensions except the first",
9617 error ("multidimensional array must have bounds for all "
9618 "dimensions except the first");
9620 return error_mark_node
;
9623 /* Figure out the index type for the array. */
9625 itype
= compute_array_index_type (name
, size
, tf_warning_or_error
);
9628 T is called the array element type; this type shall not be [...] an
9629 abstract class type. */
9630 abstract_virtuals_error (name
, type
);
9632 return build_cplus_array_type (type
, itype
);
9635 /* Returns the smallest location != UNKNOWN_LOCATION among the
9636 three stored in LOCATIONS[ds_const], LOCATIONS[ds_volatile],
9637 and LOCATIONS[ds_restrict]. */
9640 smallest_type_quals_location (int type_quals
, const location_t
* locations
)
9642 location_t loc
= UNKNOWN_LOCATION
;
9644 if (type_quals
& TYPE_QUAL_CONST
)
9645 loc
= locations
[ds_const
];
9647 if ((type_quals
& TYPE_QUAL_VOLATILE
)
9648 && (loc
== UNKNOWN_LOCATION
|| locations
[ds_volatile
] < loc
))
9649 loc
= locations
[ds_volatile
];
9651 if ((type_quals
& TYPE_QUAL_RESTRICT
)
9652 && (loc
== UNKNOWN_LOCATION
|| locations
[ds_restrict
] < loc
))
9653 loc
= locations
[ds_restrict
];
9658 /* Check that it's OK to declare a function with the indicated TYPE
9659 and TYPE_QUALS. SFK indicates the kind of special function (if any)
9660 that this function is. OPTYPE is the type given in a conversion
9661 operator declaration, or the class type for a constructor/destructor.
9662 Returns the actual return type of the function; that may be different
9663 than TYPE if an error occurs, or for certain special functions. */
9666 check_special_function_return_type (special_function_kind sfk
,
9670 const location_t
* locations
)
9674 case sfk_constructor
:
9676 error ("return type specification for constructor invalid");
9677 else if (type_quals
!= TYPE_UNQUALIFIED
)
9678 error_at (smallest_type_quals_location (type_quals
, locations
),
9679 "qualifiers are not allowed on constructor declaration");
9681 if (targetm
.cxx
.cdtor_returns_this ())
9682 type
= build_pointer_type (optype
);
9684 type
= void_type_node
;
9687 case sfk_destructor
:
9689 error ("return type specification for destructor invalid");
9690 else if (type_quals
!= TYPE_UNQUALIFIED
)
9691 error_at (smallest_type_quals_location (type_quals
, locations
),
9692 "qualifiers are not allowed on destructor declaration");
9694 /* We can't use the proper return type here because we run into
9695 problems with ambiguous bases and covariant returns. */
9696 if (targetm
.cxx
.cdtor_returns_this ())
9697 type
= build_pointer_type (void_type_node
);
9699 type
= void_type_node
;
9702 case sfk_conversion
:
9704 error ("return type specified for %<operator %T%>", optype
);
9705 else if (type_quals
!= TYPE_UNQUALIFIED
)
9706 error_at (smallest_type_quals_location (type_quals
, locations
),
9707 "qualifiers are not allowed on declaration of "
9708 "%<operator %T%>", optype
);
9713 case sfk_deduction_guide
:
9715 error ("return type specified for deduction guide");
9716 else if (type_quals
!= TYPE_UNQUALIFIED
)
9717 error_at (smallest_type_quals_location (type_quals
, locations
),
9718 "qualifiers are not allowed on declaration of "
9720 type
= make_template_placeholder (CLASSTYPE_TI_TEMPLATE (optype
));
9721 for (int i
= 0; i
< ds_last
; ++i
)
9722 if (i
!= ds_explicit
&& locations
[i
])
9723 error_at (locations
[i
],
9724 "decl-specifier in declaration of deduction guide");
9734 /* A variable or data member (whose unqualified name is IDENTIFIER)
9735 has been declared with the indicated TYPE. If the TYPE is not
9736 acceptable, issue an error message and return a type to use for
9737 error-recovery purposes. */
9740 check_var_type (tree identifier
, tree type
)
9742 if (VOID_TYPE_P (type
))
9745 error ("unnamed variable or field declared void");
9746 else if (identifier_p (identifier
))
9748 gcc_assert (!IDENTIFIER_ANY_OP_P (identifier
));
9749 error ("variable or field %qE declared void", identifier
);
9752 error ("variable or field declared void");
9753 type
= error_mark_node
;
9759 /* Handle declaring DECL as an inline variable. */
9762 mark_inline_variable (tree decl
)
9764 bool inlinep
= true;
9765 if (! toplevel_bindings_p ())
9767 error ("%<inline%> specifier invalid for variable "
9768 "%qD declared at block scope", decl
);
9771 else if (cxx_dialect
< cxx17
)
9772 pedwarn (DECL_SOURCE_LOCATION (decl
), 0,
9773 "inline variables are only available "
9774 "with -std=c++17 or -std=gnu++17");
9777 retrofit_lang_decl (decl
);
9778 SET_DECL_VAR_DECLARED_INLINE_P (decl
);
9783 /* Assign a typedef-given name to a class or enumeration type declared
9784 as anonymous at first. This was split out of grokdeclarator
9785 because it is also used in libcc1. */
9788 name_unnamed_type (tree type
, tree decl
)
9790 gcc_assert (TYPE_UNNAMED_P (type
));
9792 /* Replace the anonymous name with the real name everywhere. */
9793 for (tree t
= TYPE_MAIN_VARIANT (type
); t
; t
= TYPE_NEXT_VARIANT (t
))
9795 if (anon_aggrname_p (TYPE_IDENTIFIER (t
)))
9796 /* We do not rename the debug info representing the
9797 unnamed tagged type because the standard says in
9798 [dcl.typedef] that the naming applies only for
9799 linkage purposes. */
9800 /*debug_hooks->set_name (t, decl);*/
9801 TYPE_NAME (t
) = decl
;
9804 if (TYPE_LANG_SPECIFIC (type
))
9805 TYPE_WAS_UNNAMED (type
) = 1;
9807 /* If this is a typedef within a template class, the nested
9808 type is a (non-primary) template. The name for the
9809 template needs updating as well. */
9810 if (TYPE_LANG_SPECIFIC (type
) && CLASSTYPE_TEMPLATE_INFO (type
))
9811 DECL_NAME (CLASSTYPE_TI_TEMPLATE (type
))
9812 = TYPE_IDENTIFIER (type
);
9814 /* Adjust linkage now that we aren't unnamed anymore. */
9815 reset_type_linkage (type
);
9817 /* FIXME remangle member functions; member functions of a
9818 type with external linkage have external linkage. */
9820 /* Check that our job is done, and that it would fail if we
9821 attempted to do it again. */
9822 gcc_assert (!TYPE_UNNAMED_P (type
));
9825 /* Given declspecs and a declarator (abstract or otherwise), determine
9826 the name and type of the object declared and construct a DECL node
9829 DECLSPECS points to the representation of declaration-specifier
9830 sequence that precedes declarator.
9832 DECL_CONTEXT says which syntactic context this declaration is in:
9833 NORMAL for most contexts. Make a VAR_DECL or FUNCTION_DECL or TYPE_DECL.
9834 FUNCDEF for a function definition. Like NORMAL but a few different
9835 error messages in each case. Return value may be zero meaning
9836 this definition is too screwy to try to parse.
9837 MEMFUNCDEF for a function definition. Like FUNCDEF but prepares to
9838 handle member functions (which have FIELD context).
9839 Return value may be zero meaning this definition is too screwy to
9841 PARM for a parameter declaration (either within a function prototype
9842 or before a function body). Make a PARM_DECL, or return void_type_node.
9843 TPARM for a template parameter declaration.
9844 CATCHPARM for a parameter declaration before a catch clause.
9845 TYPENAME if for a typename (in a cast or sizeof).
9846 Don't make a DECL node; just return the ..._TYPE node.
9847 FIELD for a struct or union field; make a FIELD_DECL.
9848 BITFIELD for a field with specified width.
9850 INITIALIZED is as for start_decl.
9852 ATTRLIST is a pointer to the list of attributes, which may be NULL
9853 if there are none; *ATTRLIST may be modified if attributes from inside
9854 the declarator should be applied to the declaration.
9856 When this function is called, scoping variables (such as
9857 CURRENT_CLASS_TYPE) should reflect the scope in which the
9858 declaration occurs, not the scope in which the new declaration will
9859 be placed. For example, on:
9863 when grokdeclarator is called for `S::f', the CURRENT_CLASS_TYPE
9866 Returns a DECL (if a declarator is present), a TYPE (if there is no
9867 declarator, in cases like "struct S;"), or the ERROR_MARK_NODE if an
9871 grokdeclarator (const cp_declarator
*declarator
,
9872 cp_decl_specifier_seq
*declspecs
,
9873 enum decl_context decl_context
,
9877 tree type
= NULL_TREE
;
9879 int explicit_intN
= 0;
9880 int virtualp
, explicitp
, friendp
, inlinep
, staticp
;
9881 int explicit_int
= 0;
9882 int explicit_char
= 0;
9883 int defaulted_int
= 0;
9885 tree typedef_decl
= NULL_TREE
;
9886 const char *name
= NULL
;
9887 tree typedef_type
= NULL_TREE
;
9888 /* True if this declarator is a function definition. */
9889 bool funcdef_flag
= false;
9890 cp_declarator_kind innermost_code
= cdk_error
;
9893 /* See the code below that used this. */
9894 tree decl_attr
= NULL_TREE
;
9897 /* Keep track of what sort of function is being processed
9898 so that we can warn about default return values, or explicit
9899 return values which do not match prescribed defaults. */
9900 special_function_kind sfk
= sfk_none
;
9902 tree dname
= NULL_TREE
;
9903 tree ctor_return_type
= NULL_TREE
;
9904 enum overload_flags flags
= NO_SPECIAL
;
9905 /* cv-qualifiers that apply to the declarator, for a declaration of
9906 a member function. */
9907 cp_cv_quals memfn_quals
= TYPE_UNQUALIFIED
;
9908 /* virt-specifiers that apply to the declarator, for a declaration of
9909 a member function. */
9910 cp_virt_specifiers virt_specifiers
= VIRT_SPEC_UNSPECIFIED
;
9911 /* ref-qualifier that applies to the declarator, for a declaration of
9912 a member function. */
9913 cp_ref_qualifier rqual
= REF_QUAL_NONE
;
9914 /* cv-qualifiers that apply to the type specified by the DECLSPECS. */
9915 int type_quals
= TYPE_UNQUALIFIED
;
9916 tree raises
= NULL_TREE
;
9917 int template_count
= 0;
9918 tree returned_attrs
= NULL_TREE
;
9919 tree parms
= NULL_TREE
;
9920 const cp_declarator
*id_declarator
;
9921 /* The unqualified name of the declarator; either an
9922 IDENTIFIER_NODE, BIT_NOT_EXPR, or TEMPLATE_ID_EXPR. */
9923 tree unqualified_id
;
9924 /* The class type, if any, in which this entity is located,
9925 or NULL_TREE if none. Note that this value may be different from
9926 the current class type; for example if an attempt is made to declare
9927 "A::f" inside "B", this value will be "A". */
9928 tree ctype
= current_class_type
;
9929 /* The NAMESPACE_DECL for the namespace in which this entity is
9930 located. If an unqualified name is used to declare the entity,
9931 this value will be NULL_TREE, even if the entity is located at
9933 tree in_namespace
= NULL_TREE
;
9934 cp_storage_class storage_class
;
9935 bool unsigned_p
, signed_p
, short_p
, long_p
, thread_p
;
9936 bool type_was_error_mark_node
= false;
9937 bool parameter_pack_p
= declarator
? declarator
->parameter_pack_p
: false;
9938 bool template_type_arg
= false;
9939 bool template_parm_flag
= false;
9940 bool typedef_p
= decl_spec_seq_has_spec_p (declspecs
, ds_typedef
);
9941 bool constexpr_p
= decl_spec_seq_has_spec_p (declspecs
, ds_constexpr
);
9942 bool late_return_type_p
= false;
9943 bool array_parameter_p
= false;
9944 source_location saved_loc
= input_location
;
9945 tree reqs
= NULL_TREE
;
9947 signed_p
= decl_spec_seq_has_spec_p (declspecs
, ds_signed
);
9948 unsigned_p
= decl_spec_seq_has_spec_p (declspecs
, ds_unsigned
);
9949 short_p
= decl_spec_seq_has_spec_p (declspecs
, ds_short
);
9950 long_p
= decl_spec_seq_has_spec_p (declspecs
, ds_long
);
9951 longlong
= decl_spec_seq_has_spec_p (declspecs
, ds_long_long
);
9952 explicit_intN
= declspecs
->explicit_intN_p
;
9953 thread_p
= decl_spec_seq_has_spec_p (declspecs
, ds_thread
);
9955 // Was concept_p specified? Note that ds_concept
9956 // implies ds_constexpr!
9957 bool concept_p
= decl_spec_seq_has_spec_p (declspecs
, ds_concept
);
9961 if (decl_spec_seq_has_spec_p (declspecs
, ds_const
))
9962 type_quals
|= TYPE_QUAL_CONST
;
9963 if (decl_spec_seq_has_spec_p (declspecs
, ds_volatile
))
9964 type_quals
|= TYPE_QUAL_VOLATILE
;
9965 if (decl_spec_seq_has_spec_p (declspecs
, ds_restrict
))
9966 type_quals
|= TYPE_QUAL_RESTRICT
;
9968 if (decl_context
== FUNCDEF
)
9969 funcdef_flag
= true, decl_context
= NORMAL
;
9970 else if (decl_context
== MEMFUNCDEF
)
9971 funcdef_flag
= true, decl_context
= FIELD
;
9972 else if (decl_context
== BITFIELD
)
9973 bitfield
= 1, decl_context
= FIELD
;
9974 else if (decl_context
== TEMPLATE_TYPE_ARG
)
9975 template_type_arg
= true, decl_context
= TYPENAME
;
9976 else if (decl_context
== TPARM
)
9977 template_parm_flag
= true, decl_context
= PARM
;
9979 if (initialized
> 1)
9980 funcdef_flag
= true;
9982 location_t typespec_loc
= smallest_type_quals_location (type_quals
,
9983 declspecs
->locations
);
9984 if (typespec_loc
== UNKNOWN_LOCATION
)
9985 typespec_loc
= declspecs
->locations
[ds_type_spec
];
9986 if (typespec_loc
== UNKNOWN_LOCATION
)
9987 typespec_loc
= input_location
;
9989 /* Look inside a declarator for the name being declared
9990 and get it as a string, for an error message. */
9991 for (id_declarator
= declarator
;
9993 id_declarator
= id_declarator
->declarator
)
9995 if (id_declarator
->kind
!= cdk_id
)
9996 innermost_code
= id_declarator
->kind
;
9998 switch (id_declarator
->kind
)
10001 if (id_declarator
->declarator
10002 && id_declarator
->declarator
->kind
== cdk_id
)
10004 sfk
= id_declarator
->declarator
->u
.id
.sfk
;
10005 if (sfk
== sfk_destructor
)
10012 tree qualifying_scope
= id_declarator
->u
.id
.qualifying_scope
;
10013 tree decl
= id_declarator
->u
.id
.unqualified_name
;
10016 if (qualifying_scope
)
10018 if (at_function_scope_p ())
10022 A declarator-id shall not be qualified except
10025 None of the cases are permitted in block
10027 if (qualifying_scope
== global_namespace
)
10028 error ("invalid use of qualified-name %<::%D%>",
10030 else if (TYPE_P (qualifying_scope
))
10031 error ("invalid use of qualified-name %<%T::%D%>",
10032 qualifying_scope
, decl
);
10034 error ("invalid use of qualified-name %<%D::%D%>",
10035 qualifying_scope
, decl
);
10036 return error_mark_node
;
10038 else if (TYPE_P (qualifying_scope
))
10040 ctype
= qualifying_scope
;
10041 if (!MAYBE_CLASS_TYPE_P (ctype
))
10043 error ("%q#T is not a class or a namespace", ctype
);
10046 else if (innermost_code
!= cdk_function
10047 && current_class_type
10048 && !uniquely_derived_from_p (ctype
,
10049 current_class_type
))
10051 error ("invalid use of qualified-name %<%T::%D%>",
10052 qualifying_scope
, decl
);
10053 return error_mark_node
;
10056 else if (TREE_CODE (qualifying_scope
) == NAMESPACE_DECL
)
10057 in_namespace
= qualifying_scope
;
10059 switch (TREE_CODE (decl
))
10063 if (innermost_code
!= cdk_function
)
10065 error ("declaration of %qD as non-function", decl
);
10066 return error_mark_node
;
10068 else if (!qualifying_scope
10069 && !(current_class_type
&& at_class_scope_p ()))
10071 error ("declaration of %qD as non-member", decl
);
10072 return error_mark_node
;
10075 tree type
= TREE_OPERAND (decl
, 0);
10077 type
= constructor_name (type
);
10078 name
= identifier_to_locale (IDENTIFIER_POINTER (type
));
10083 case TEMPLATE_ID_EXPR
:
10085 tree fns
= TREE_OPERAND (decl
, 0);
10088 if (!identifier_p (dname
))
10089 dname
= OVL_NAME (dname
);
10091 /* Fall through. */
10093 case IDENTIFIER_NODE
:
10094 if (identifier_p (decl
))
10097 if (IDENTIFIER_KEYWORD_P (dname
))
10099 error ("declarator-id missing; using reserved word %qD",
10101 name
= identifier_to_locale (IDENTIFIER_POINTER (dname
));
10103 else if (!IDENTIFIER_CONV_OP_P (dname
))
10104 name
= identifier_to_locale (IDENTIFIER_POINTER (dname
));
10107 gcc_assert (flags
== NO_SPECIAL
);
10108 flags
= TYPENAME_FLAG
;
10109 sfk
= sfk_conversion
;
10110 tree glob
= get_global_binding (dname
);
10111 if (glob
&& TREE_CODE (glob
) == TYPE_DECL
)
10112 name
= identifier_to_locale (IDENTIFIER_POINTER (dname
));
10114 name
= "<invalid operator>";
10119 gcc_unreachable ();
10126 case cdk_reference
:
10131 name
= "structured binding";
10135 return error_mark_node
;
10138 gcc_unreachable ();
10140 if (id_declarator
->kind
== cdk_id
)
10146 The declarator in a function-definition shall have the form
10147 D1 ( parameter-declaration-clause) ... */
10148 if (funcdef_flag
&& innermost_code
!= cdk_function
)
10150 error ("function definition does not declare parameters");
10151 return error_mark_node
;
10154 if (flags
== TYPENAME_FLAG
10155 && innermost_code
!= cdk_function
10156 && ! (ctype
&& !declspecs
->any_specifiers_p
))
10158 error ("declaration of %qD as non-function", dname
);
10159 return error_mark_node
;
10162 if (dname
&& identifier_p (dname
))
10164 if (UDLIT_OPER_P (dname
)
10165 && innermost_code
!= cdk_function
)
10167 error ("declaration of %qD as non-function", dname
);
10168 return error_mark_node
;
10171 if (IDENTIFIER_ANY_OP_P (dname
))
10175 error ("declaration of %qD as %<typedef%>", dname
);
10176 return error_mark_node
;
10178 else if (decl_context
== PARM
|| decl_context
== CATCHPARM
)
10180 error ("declaration of %qD as parameter", dname
);
10181 return error_mark_node
;
10186 /* Anything declared one level down from the top level
10187 must be one of the parameters of a function
10188 (because the body is at least two levels down). */
10190 /* This heuristic cannot be applied to C++ nodes! Fixed, however,
10191 by not allowing C++ class definitions to specify their parameters
10192 with xdecls (must be spec.d in the parmlist).
10194 Since we now wait to push a class scope until we are sure that
10195 we are in a legitimate method context, we must set oldcname
10196 explicitly (since current_class_name is not yet alive).
10198 We also want to avoid calling this a PARM if it is in a namespace. */
10200 if (decl_context
== NORMAL
&& !toplevel_bindings_p ())
10202 cp_binding_level
*b
= current_binding_level
;
10203 current_binding_level
= b
->level_chain
;
10204 if (current_binding_level
!= 0 && toplevel_bindings_p ())
10205 decl_context
= PARM
;
10206 current_binding_level
= b
;
10210 name
= decl_context
== PARM
? "parameter" : "type name";
10212 if (concept_p
&& typedef_p
)
10214 error ("%<concept%> cannot appear in a typedef declaration");
10215 return error_mark_node
;
10218 if (constexpr_p
&& typedef_p
)
10220 error ("%<constexpr%> cannot appear in a typedef declaration");
10221 return error_mark_node
;
10224 /* If there were multiple types specified in the decl-specifier-seq,
10225 issue an error message. */
10226 if (declspecs
->multiple_types_p
)
10228 error ("two or more data types in declaration of %qs", name
);
10229 return error_mark_node
;
10232 if (declspecs
->conflicting_specifiers_p
)
10234 error ("conflicting specifiers in declaration of %qs", name
);
10235 return error_mark_node
;
10238 /* Extract the basic type from the decl-specifier-seq. */
10239 type
= declspecs
->type
;
10240 if (type
== error_mark_node
)
10243 type_was_error_mark_node
= true;
10245 /* If the entire declaration is itself tagged as deprecated then
10246 suppress reports of deprecated items. */
10247 if (type
&& TREE_DEPRECATED (type
)
10248 && deprecated_state
!= DEPRECATED_SUPPRESS
)
10249 warn_deprecated_use (type
, NULL_TREE
);
10250 if (type
&& TREE_CODE (type
) == TYPE_DECL
)
10252 typedef_decl
= type
;
10253 type
= TREE_TYPE (typedef_decl
);
10254 if (TREE_DEPRECATED (type
)
10255 && DECL_ARTIFICIAL (typedef_decl
)
10256 && deprecated_state
!= DEPRECATED_SUPPRESS
)
10257 warn_deprecated_use (type
, NULL_TREE
);
10259 /* No type at all: default to `int', and set DEFAULTED_INT
10260 because it was not a user-defined typedef. */
10261 if (type
== NULL_TREE
)
10263 if (signed_p
|| unsigned_p
|| long_p
|| short_p
)
10265 /* These imply 'int'. */
10266 type
= integer_type_node
;
10269 /* If we just have "complex", it is equivalent to "complex double". */
10270 else if (!longlong
&& !explicit_intN
10271 && decl_spec_seq_has_spec_p (declspecs
, ds_complex
))
10273 type
= double_type_node
;
10274 pedwarn (declspecs
->locations
[ds_complex
], OPT_Wpedantic
,
10275 "ISO C++ does not support plain %<complex%> meaning "
10276 "%<double complex%>");
10279 /* Gather flags. */
10280 explicit_int
= declspecs
->explicit_int_p
;
10281 explicit_char
= declspecs
->explicit_char_p
;
10284 /* See the code below that used this. */
10286 decl_attr
= DECL_ATTRIBUTES (typedef_decl
);
10288 typedef_type
= type
;
10290 if (sfk
== sfk_conversion
|| sfk
== sfk_deduction_guide
)
10291 ctor_return_type
= TREE_TYPE (dname
);
10293 ctor_return_type
= ctype
;
10295 if (sfk
!= sfk_none
)
10297 type
= check_special_function_return_type (sfk
, type
,
10300 declspecs
->locations
);
10301 type_quals
= TYPE_UNQUALIFIED
;
10303 else if (type
== NULL_TREE
)
10309 /* We handle `main' specially here, because 'main () { }' is so
10310 common. With no options, it is allowed. With -Wreturn-type,
10311 it is a warning. It is only an error with -pedantic-errors. */
10312 is_main
= (funcdef_flag
10313 && dname
&& identifier_p (dname
)
10314 && MAIN_NAME_P (dname
)
10315 && ctype
== NULL_TREE
10316 && in_namespace
== NULL_TREE
10317 && current_namespace
== global_namespace
);
10319 if (type_was_error_mark_node
)
10320 /* We've already issued an error, don't complain more. */;
10321 else if (in_system_header_at (input_location
) || flag_ms_extensions
)
10322 /* Allow it, sigh. */;
10323 else if (! is_main
)
10324 permerror (input_location
, "ISO C++ forbids declaration of %qs with no type", name
);
10326 pedwarn (input_location
, OPT_Wpedantic
,
10327 "ISO C++ forbids declaration of %qs with no type", name
);
10329 warning (OPT_Wreturn_type
,
10330 "ISO C++ forbids declaration of %qs with no type", name
);
10332 if (type_was_error_mark_node
&& template_parm_flag
)
10333 /* FIXME we should be able to propagate the error_mark_node as is
10334 for other contexts too. */
10335 type
= error_mark_node
;
10337 type
= integer_type_node
;
10344 if (! int_n_enabled_p
[declspecs
->int_n_idx
])
10346 error ("%<__int%d%> is not supported by this target",
10347 int_n_data
[declspecs
->int_n_idx
].bitsize
);
10348 explicit_intN
= false;
10350 else if (pedantic
&& ! in_system_header_at (input_location
))
10351 pedwarn (input_location
, OPT_Wpedantic
,
10352 "ISO C++ does not support %<__int%d%> for %qs",
10353 int_n_data
[declspecs
->int_n_idx
].bitsize
, name
);
10356 /* Now process the modifiers that were specified
10357 and check for invalid combinations. */
10359 /* Long double is a special combination. */
10360 if (long_p
&& !longlong
&& TYPE_MAIN_VARIANT (type
) == double_type_node
)
10363 type
= cp_build_qualified_type (long_double_type_node
,
10364 cp_type_quals (type
));
10367 /* Check all other uses of type modifiers. */
10369 if (unsigned_p
|| signed_p
|| long_p
|| short_p
)
10373 if ((signed_p
|| unsigned_p
) && TREE_CODE (type
) != INTEGER_TYPE
)
10374 error ("%<signed%> or %<unsigned%> invalid for %qs", name
);
10375 else if (signed_p
&& unsigned_p
)
10376 error ("%<signed%> and %<unsigned%> specified together for %qs", name
);
10377 else if (longlong
&& TREE_CODE (type
) != INTEGER_TYPE
)
10378 error ("%<long long%> invalid for %qs", name
);
10379 else if (long_p
&& TREE_CODE (type
) == REAL_TYPE
)
10380 error ("%<long%> invalid for %qs", name
);
10381 else if (short_p
&& TREE_CODE (type
) == REAL_TYPE
)
10382 error ("%<short%> invalid for %qs", name
);
10383 else if ((long_p
|| short_p
) && TREE_CODE (type
) != INTEGER_TYPE
)
10384 error ("%<long%> or %<short%> invalid for %qs", name
);
10385 else if ((long_p
|| short_p
|| explicit_char
|| explicit_int
) && explicit_intN
)
10386 error ("%<long%>, %<int%>, %<short%>, or %<char%> invalid for %qs", name
);
10387 else if ((long_p
|| short_p
) && explicit_char
)
10388 error ("%<long%> or %<short%> specified with char for %qs", name
);
10389 else if (long_p
&& short_p
)
10390 error ("%<long%> and %<short%> specified together for %qs", name
);
10391 else if (type
== char16_type_node
|| type
== char32_type_node
)
10393 if (signed_p
|| unsigned_p
)
10394 error ("%<signed%> or %<unsigned%> invalid for %qs", name
);
10395 else if (short_p
|| long_p
)
10396 error ("%<short%> or %<long%> invalid for %qs", name
);
10401 if (!explicit_int
&& !defaulted_int
&& !explicit_char
&& !explicit_intN
&& pedantic
)
10403 pedwarn (input_location
, OPT_Wpedantic
,
10404 "long, short, signed or unsigned used invalidly for %qs",
10406 if (flag_pedantic_errors
)
10411 /* Discard the type modifiers if they are invalid. */
10414 unsigned_p
= false;
10422 /* Decide whether an integer type is signed or not.
10423 Optionally treat bitfields as signed by default. */
10427 It is implementation-defined whether a plain (neither
10428 explicitly signed or unsigned) char, short, int, or long
10429 bit-field is signed or unsigned.
10431 Naturally, we extend this to long long as well. Note that
10432 this does not include wchar_t. */
10433 || (bitfield
&& !flag_signed_bitfields
10435 /* A typedef for plain `int' without `signed' can be
10436 controlled just like plain `int', but a typedef for
10437 `signed int' cannot be so controlled. */
10439 && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl
))
10440 && TREE_CODE (type
) == INTEGER_TYPE
10441 && !same_type_p (TYPE_MAIN_VARIANT (type
), wchar_type_node
)))
10444 type
= int_n_trees
[declspecs
->int_n_idx
].unsigned_type
;
10446 type
= long_long_unsigned_type_node
;
10448 type
= long_unsigned_type_node
;
10450 type
= short_unsigned_type_node
;
10451 else if (type
== char_type_node
)
10452 type
= unsigned_char_type_node
;
10453 else if (typedef_decl
)
10454 type
= unsigned_type_for (type
);
10456 type
= unsigned_type_node
;
10458 else if (signed_p
&& type
== char_type_node
)
10459 type
= signed_char_type_node
;
10460 else if (explicit_intN
)
10461 type
= int_n_trees
[declspecs
->int_n_idx
].signed_type
;
10463 type
= long_long_integer_type_node
;
10465 type
= long_integer_type_node
;
10467 type
= short_integer_type_node
;
10469 if (decl_spec_seq_has_spec_p (declspecs
, ds_complex
))
10471 if (TREE_CODE (type
) != INTEGER_TYPE
&& TREE_CODE (type
) != REAL_TYPE
)
10472 error ("complex invalid for %qs", name
);
10473 /* If a modifier is specified, the resulting complex is the complex
10474 form of TYPE. E.g, "complex short" is "complex short int". */
10475 else if (type
== integer_type_node
)
10476 type
= complex_integer_type_node
;
10477 else if (type
== float_type_node
)
10478 type
= complex_float_type_node
;
10479 else if (type
== double_type_node
)
10480 type
= complex_double_type_node
;
10481 else if (type
== long_double_type_node
)
10482 type
= complex_long_double_type_node
;
10484 type
= build_complex_type (type
);
10487 /* If we're using the injected-class-name to form a compound type or a
10488 declaration, replace it with the underlying class so we don't get
10489 redundant typedefs in the debug output. But if we are returning the
10490 type unchanged, leave it alone so that it's available to
10491 maybe_get_template_decl_from_type_decl. */
10492 if (CLASS_TYPE_P (type
)
10493 && DECL_SELF_REFERENCE_P (TYPE_NAME (type
))
10494 && type
== TREE_TYPE (TYPE_NAME (type
))
10495 && (declarator
|| type_quals
))
10496 type
= DECL_ORIGINAL_TYPE (TYPE_NAME (type
));
10498 type_quals
|= cp_type_quals (type
);
10499 type
= cp_build_qualified_type_real
10500 (type
, type_quals
, ((((typedef_decl
&& !DECL_ARTIFICIAL (typedef_decl
))
10501 || declspecs
->decltype_p
)
10502 ? tf_ignore_bad_quals
: 0) | tf_warning_or_error
));
10503 /* We might have ignored or rejected some of the qualifiers. */
10504 type_quals
= cp_type_quals (type
);
10506 if (cxx_dialect
>= cxx17
&& type
&& is_auto (type
)
10507 && innermost_code
!= cdk_function
10508 && id_declarator
&& declarator
!= id_declarator
)
10509 if (tree tmpl
= CLASS_PLACEHOLDER_TEMPLATE (type
))
10511 error_at (typespec_loc
, "template placeholder type %qT must be followed "
10512 "by a simple declarator-id", type
);
10513 inform (DECL_SOURCE_LOCATION (tmpl
), "%qD declared here", tmpl
);
10517 inlinep
= decl_spec_seq_has_spec_p (declspecs
, ds_inline
);
10518 virtualp
= decl_spec_seq_has_spec_p (declspecs
, ds_virtual
);
10519 explicitp
= decl_spec_seq_has_spec_p (declspecs
, ds_explicit
);
10521 storage_class
= declspecs
->storage_class
;
10522 if (storage_class
== sc_static
)
10523 staticp
= 1 + (decl_context
== FIELD
);
10529 error ("member %qD cannot be declared both %<virtual%> "
10530 "and %<static%>", dname
);
10531 storage_class
= sc_none
;
10535 error ("member %qD cannot be declared both %<virtual%> "
10536 "and %<constexpr%>", dname
);
10538 friendp
= decl_spec_seq_has_spec_p (declspecs
, ds_friend
);
10540 /* Issue errors about use of storage classes for parameters. */
10541 if (decl_context
== PARM
)
10545 error ("typedef declaration invalid in parameter declaration");
10546 return error_mark_node
;
10548 else if (template_parm_flag
&& storage_class
!= sc_none
)
10550 error ("storage class specified for template parameter %qs", name
);
10551 return error_mark_node
;
10553 else if (storage_class
== sc_static
10554 || storage_class
== sc_extern
10556 error ("storage class specifiers invalid in parameter declarations");
10558 /* Function parameters cannot be concept. */
10560 error ("a parameter cannot be declared %<concept%>");
10561 /* Function parameters cannot be constexpr. If we saw one, moan
10562 and pretend it wasn't there. */
10563 else if (constexpr_p
)
10565 error ("a parameter cannot be declared %<constexpr%>");
10570 /* Give error if `virtual' is used outside of class declaration. */
10572 && (current_class_name
== NULL_TREE
|| decl_context
!= FIELD
))
10574 error_at (declspecs
->locations
[ds_virtual
],
10575 "%<virtual%> outside class declaration");
10579 if (innermost_code
== cdk_decomp
)
10581 location_t loc
= (declarator
->kind
== cdk_reference
10582 ? declarator
->declarator
->id_loc
: declarator
->id_loc
);
10584 error_at (declspecs
->locations
[ds_inline
],
10585 "structured binding declaration cannot be %<inline%>");
10587 error_at (declspecs
->locations
[ds_typedef
],
10588 "structured binding declaration cannot be %<typedef%>");
10590 error_at (declspecs
->locations
[ds_constexpr
], "structured "
10591 "binding declaration cannot be %<constexpr%>");
10593 error_at (declspecs
->locations
[ds_thread
],
10594 "structured binding declaration cannot be %qs",
10595 declspecs
->gnu_thread_keyword_p
10596 ? "__thread" : "thread_local");
10598 error_at (declspecs
->locations
[ds_concept
],
10599 "structured binding declaration cannot be %<concept%>");
10600 switch (storage_class
)
10605 error_at (loc
, "structured binding declaration cannot be "
10609 error_at (loc
, "structured binding declaration cannot be "
10613 error_at (loc
, "structured binding declaration cannot be "
10617 error_at (loc
, "structured binding declaration cannot be "
10621 error_at (loc
, "structured binding declaration cannot be "
10625 gcc_unreachable ();
10627 if (TREE_CODE (type
) != TEMPLATE_TYPE_PARM
10628 || TYPE_IDENTIFIER (type
) != auto_identifier
)
10630 if (type
!= error_mark_node
)
10632 error_at (loc
, "structured binding declaration cannot have "
10635 "type must be cv-qualified %<auto%> or reference to "
10636 "cv-qualified %<auto%>");
10638 type
= build_qualified_type (make_auto (), type_quals
);
10639 declspecs
->type
= type
;
10646 storage_class
= sc_none
;
10648 declspecs
->storage_class
= sc_none
;
10649 declspecs
->locations
[ds_thread
] = UNKNOWN_LOCATION
;
10652 /* Static anonymous unions are dealt with here. */
10653 if (staticp
&& decl_context
== TYPENAME
10655 && ANON_AGGR_TYPE_P (declspecs
->type
))
10656 decl_context
= FIELD
;
10658 /* Warn about storage classes that are invalid for certain
10659 kinds of declarations (parameters, typenames, etc.). */
10662 && storage_class
!= sc_extern
10663 && storage_class
!= sc_static
)
10666 error ("multiple storage classes in declaration of %qs", name
);
10669 if (decl_context
!= NORMAL
10670 && ((storage_class
!= sc_none
10671 && storage_class
!= sc_mutable
)
10674 if ((decl_context
== PARM
|| decl_context
== CATCHPARM
)
10675 && (storage_class
== sc_register
10676 || storage_class
== sc_auto
))
10678 else if (typedef_p
)
10680 else if (decl_context
== FIELD
10681 /* C++ allows static class elements. */
10682 && storage_class
== sc_static
)
10683 /* C++ also allows inlines and signed and unsigned elements,
10684 but in those cases we don't come in here. */
10688 if (decl_context
== FIELD
)
10689 error ("storage class specified for %qs", name
);
10692 if (decl_context
== PARM
|| decl_context
== CATCHPARM
)
10693 error ("storage class specified for parameter %qs", name
);
10695 error ("storage class specified for typename");
10697 if (storage_class
== sc_register
10698 || storage_class
== sc_auto
10699 || storage_class
== sc_extern
10701 storage_class
= sc_none
;
10704 else if (storage_class
== sc_extern
&& funcdef_flag
10705 && ! toplevel_bindings_p ())
10706 error ("nested function %qs declared %<extern%>", name
);
10707 else if (toplevel_bindings_p ())
10709 if (storage_class
== sc_auto
)
10710 error ("top-level declaration of %qs specifies %<auto%>", name
);
10713 && storage_class
!= sc_extern
10714 && storage_class
!= sc_static
)
10716 if (declspecs
->gnu_thread_keyword_p
)
10717 pedwarn (input_location
, 0, "function-scope %qs implicitly auto and "
10718 "declared %<__thread%>", name
);
10720 /* When thread_local is applied to a variable of block scope the
10721 storage-class-specifier static is implied if it does not appear
10723 storage_class
= declspecs
->storage_class
= sc_static
;
10727 if (storage_class
&& friendp
)
10729 error ("storage class specifiers invalid in friend function declarations");
10730 storage_class
= sc_none
;
10734 if (!id_declarator
)
10735 unqualified_id
= NULL_TREE
;
10738 unqualified_id
= id_declarator
->u
.id
.unqualified_name
;
10739 switch (TREE_CODE (unqualified_id
))
10742 unqualified_id
= TREE_OPERAND (unqualified_id
, 0);
10743 if (TYPE_P (unqualified_id
))
10744 unqualified_id
= constructor_name (unqualified_id
);
10747 case IDENTIFIER_NODE
:
10748 case TEMPLATE_ID_EXPR
:
10752 gcc_unreachable ();
10756 if (declspecs
->std_attributes
)
10758 /* Apply the c++11 attributes to the type preceding them. */
10759 input_location
= declspecs
->locations
[ds_std_attribute
];
10760 decl_attributes (&type
, declspecs
->std_attributes
, 0);
10761 input_location
= saved_loc
;
10764 /* Determine the type of the entity declared by recurring on the
10766 for (; declarator
; declarator
= declarator
->declarator
)
10768 const cp_declarator
*inner_declarator
;
10771 if (type
== error_mark_node
)
10772 return error_mark_node
;
10774 attrs
= declarator
->attributes
;
10780 if (declarator
== NULL
|| declarator
->kind
== cdk_id
)
10781 attr_flags
|= (int) ATTR_FLAG_DECL_NEXT
;
10782 if (declarator
->kind
== cdk_function
)
10783 attr_flags
|= (int) ATTR_FLAG_FUNCTION_NEXT
;
10784 if (declarator
->kind
== cdk_array
)
10785 attr_flags
|= (int) ATTR_FLAG_ARRAY_NEXT
;
10786 returned_attrs
= decl_attributes (&type
,
10787 chainon (returned_attrs
, attrs
),
10791 inner_declarator
= declarator
->declarator
;
10793 /* We don't want to warn in parmeter context because we don't
10794 yet know if the parse will succeed, and this might turn out
10795 to be a constructor call. */
10796 if (decl_context
!= PARM
10797 && declarator
->parenthesized
!= UNKNOWN_LOCATION
10798 /* If the type is class-like and the inner name used a
10799 global namespace qualifier, we need the parens.
10800 Unfortunately all we can tell is whether a qualified name
10801 was used or not. */
10802 && !(inner_declarator
10803 && inner_declarator
->kind
== cdk_id
10804 && inner_declarator
->u
.id
.qualifying_scope
10805 && (MAYBE_CLASS_TYPE_P (type
)
10806 || TREE_CODE (type
) == ENUMERAL_TYPE
)))
10807 warning_at (declarator
->parenthesized
, OPT_Wparentheses
,
10808 "unnecessary parentheses in declaration of %qs", name
);
10809 if (declarator
->kind
== cdk_id
|| declarator
->kind
== cdk_decomp
)
10812 switch (declarator
->kind
)
10815 type
= create_array_type_for_decl (dname
, type
,
10816 declarator
->u
.array
.bounds
);
10817 if (!valid_array_size_p (input_location
, type
, dname
))
10818 type
= error_mark_node
;
10820 if (declarator
->std_attributes
)
10823 The optional attribute-specifier-seq appertains to the
10825 returned_attrs
= chainon (returned_attrs
,
10826 declarator
->std_attributes
);
10834 /* Declaring a function type. */
10836 input_location
= declspecs
->locations
[ds_type_spec
];
10837 abstract_virtuals_error (ACU_RETURN
, type
);
10838 input_location
= saved_loc
;
10840 /* Pick up type qualifiers which should be applied to `this'. */
10841 memfn_quals
= declarator
->u
.function
.qualifiers
;
10842 /* Pick up virt-specifiers. */
10843 virt_specifiers
= declarator
->u
.function
.virt_specifiers
;
10844 /* And ref-qualifier, too */
10845 rqual
= declarator
->u
.function
.ref_qualifier
;
10846 /* And tx-qualifier. */
10847 tree tx_qual
= declarator
->u
.function
.tx_qualifier
;
10848 /* Pick up the exception specifications. */
10849 raises
= declarator
->u
.function
.exception_specification
;
10850 /* If the exception-specification is ill-formed, let's pretend
10851 there wasn't one. */
10852 if (raises
== error_mark_node
)
10853 raises
= NULL_TREE
;
10856 error_at (location_of (reqs
), "requires-clause on return type");
10857 reqs
= declarator
->u
.function
.requires_clause
;
10859 /* Say it's a definition only for the CALL_EXPR
10860 closest to the identifier. */
10861 funcdecl_p
= inner_declarator
&& inner_declarator
->kind
== cdk_id
;
10863 /* Handle a late-specified return type. */
10864 tree late_return_type
= declarator
->u
.function
.late_return_type
;
10867 if (tree auto_node
= type_uses_auto (type
))
10869 if (!late_return_type
)
10871 if (current_class_type
10872 && LAMBDA_TYPE_P (current_class_type
))
10873 /* OK for C++11 lambdas. */;
10874 else if (cxx_dialect
< cxx14
)
10876 error ("%qs function uses "
10877 "%<auto%> type specifier without trailing "
10878 "return type", name
);
10879 inform (input_location
, "deduced return type "
10880 "only available with -std=c++14 or "
10885 error ("virtual function cannot "
10886 "have deduced return type");
10890 else if (!is_auto (type
) && sfk
!= sfk_conversion
)
10892 error ("%qs function with trailing return type has"
10893 " %qT as its type rather than plain %<auto%>",
10895 return error_mark_node
;
10897 if (tree tmpl
= CLASS_PLACEHOLDER_TEMPLATE (auto_node
))
10899 if (!late_return_type
)
10901 if (dguide_name_p (unqualified_id
))
10902 error_at (declarator
->id_loc
, "deduction guide "
10903 "for %qT must have trailing return "
10904 "type", TREE_TYPE (tmpl
));
10906 error_at (declarator
->id_loc
, "deduced class "
10907 "type %qT in function return type",
10909 inform (DECL_SOURCE_LOCATION (tmpl
),
10910 "%qD declared here", tmpl
);
10912 else if (CLASS_TYPE_P (late_return_type
)
10913 && CLASSTYPE_TEMPLATE_INFO (late_return_type
)
10914 && (CLASSTYPE_TI_TEMPLATE (late_return_type
)
10918 error ("trailing return type %qT of deduction guide "
10919 "is not a specialization of %qT",
10920 late_return_type
, TREE_TYPE (tmpl
));
10923 else if (late_return_type
10924 && sfk
!= sfk_conversion
)
10926 if (cxx_dialect
< cxx11
)
10927 /* Not using maybe_warn_cpp0x because this should
10928 always be an error. */
10929 error ("trailing return type only available with "
10930 "-std=c++11 or -std=gnu++11");
10932 error ("%qs function with trailing return type not "
10933 "declared with %<auto%> type specifier", name
);
10934 return error_mark_node
;
10937 type
= splice_late_return_type (type
, late_return_type
);
10938 if (type
== error_mark_node
)
10939 return error_mark_node
;
10941 if (late_return_type
)
10943 late_return_type_p
= true;
10944 type_quals
= cp_type_quals (type
);
10947 if (type_quals
!= TYPE_UNQUALIFIED
)
10949 if (SCALAR_TYPE_P (type
) || VOID_TYPE_P (type
))
10950 warning_at (typespec_loc
, OPT_Wignored_qualifiers
, "type "
10951 "qualifiers ignored on function return type");
10952 /* We now know that the TYPE_QUALS don't apply to the
10953 decl, but to its return type. */
10954 type_quals
= TYPE_UNQUALIFIED
;
10957 /* Error about some types functions can't return. */
10959 if (TREE_CODE (type
) == FUNCTION_TYPE
)
10961 error_at (typespec_loc
, "%qs declared as function returning "
10962 "a function", name
);
10963 return error_mark_node
;
10965 if (TREE_CODE (type
) == ARRAY_TYPE
)
10967 error_at (typespec_loc
, "%qs declared as function returning "
10969 return error_mark_node
;
10972 if (ctype
== NULL_TREE
10973 && decl_context
== FIELD
10976 ctype
= current_class_type
;
10978 if (ctype
&& (sfk
== sfk_constructor
10979 || sfk
== sfk_destructor
))
10981 /* We are within a class's scope. If our declarator name
10982 is the same as the class name, and we are defining
10983 a function, then it is a constructor/destructor, and
10984 therefore returns a void type. */
10986 /* ISO C++ 12.4/2. A destructor may not be declared
10987 const or volatile. A destructor may not be static.
10988 A destructor may not be declared with ref-qualifier.
10990 ISO C++ 12.1. A constructor may not be declared
10991 const or volatile. A constructor may not be
10992 virtual. A constructor may not be static.
10993 A constructor may not be declared with ref-qualifier. */
10995 error ((flags
== DTOR_FLAG
)
10996 ? G_("destructor cannot be static member function")
10997 : G_("constructor cannot be static member function"));
11000 error ((flags
== DTOR_FLAG
)
11001 ? G_("destructors may not be cv-qualified")
11002 : G_("constructors may not be cv-qualified"));
11003 memfn_quals
= TYPE_UNQUALIFIED
;
11008 maybe_warn_cpp0x (CPP0X_REF_QUALIFIER
);
11009 error ((flags
== DTOR_FLAG
)
11010 ? G_("destructors may not be ref-qualified")
11011 : G_("constructors may not be ref-qualified"));
11012 rqual
= REF_QUAL_NONE
;
11015 if (decl_context
== FIELD
11016 && !member_function_or_else (ctype
,
11017 current_class_type
,
11019 return error_mark_node
;
11021 if (flags
!= DTOR_FLAG
)
11023 /* It's a constructor. */
11024 if (explicitp
== 1)
11028 permerror (input_location
,
11029 "constructors cannot be declared %<virtual%>");
11032 if (decl_context
== FIELD
11033 && sfk
!= sfk_constructor
)
11034 return error_mark_node
;
11036 if (decl_context
== FIELD
)
11043 /* Cannot be both friend and virtual. */
11044 error ("virtual functions cannot be friends");
11047 if (decl_context
== NORMAL
)
11048 error ("friend declaration not in class definition");
11049 if (current_function_decl
&& funcdef_flag
)
11050 error ("can%'t define friend function %qs in a local "
11051 "class definition",
11054 else if (ctype
&& sfk
== sfk_conversion
)
11056 if (explicitp
== 1)
11058 maybe_warn_cpp0x (CPP0X_EXPLICIT_CONVERSION
);
11061 if (late_return_type_p
)
11062 error ("a conversion function cannot have a trailing return type");
11064 else if (sfk
== sfk_deduction_guide
)
11066 if (explicitp
== 1)
11070 arg_types
= grokparms (declarator
->u
.function
.parameters
,
11073 if (inner_declarator
11074 && inner_declarator
->kind
== cdk_id
11075 && inner_declarator
->u
.id
.sfk
== sfk_destructor
11076 && arg_types
!= void_list_node
)
11078 error ("destructors may not have parameters");
11079 arg_types
= void_list_node
;
11083 type
= build_function_type (type
, arg_types
);
11085 tree attrs
= declarator
->std_attributes
;
11088 tree att
= build_tree_list (tx_qual
, NULL_TREE
);
11089 /* transaction_safe applies to the type, but
11090 transaction_safe_dynamic applies to the function. */
11091 if (is_attribute_p ("transaction_safe", tx_qual
))
11092 attrs
= chainon (attrs
, att
);
11094 returned_attrs
= chainon (returned_attrs
, att
);
11099 The optional attribute-specifier-seq appertains to
11100 the function type. */
11101 decl_attributes (&type
, attrs
, 0);
11104 type
= build_exception_variant (type
, raises
);
11109 case cdk_reference
:
11111 /* Filter out pointers-to-references and references-to-references.
11112 We can get these if a TYPE_DECL is used. */
11114 if (TREE_CODE (type
) == REFERENCE_TYPE
)
11116 if (declarator
->kind
!= cdk_reference
)
11118 error ("cannot declare pointer to %q#T", type
);
11119 type
= TREE_TYPE (type
);
11122 /* In C++0x, we allow reference to reference declarations
11123 that occur indirectly through typedefs [7.1.3/8 dcl.typedef]
11124 and template type arguments [14.3.1/4 temp.arg.type]. The
11125 check for direct reference to reference declarations, which
11126 are still forbidden, occurs below. Reasoning behind the change
11127 can be found in DR106, DR540, and the rvalue reference
11129 else if (cxx_dialect
== cxx98
)
11131 error ("cannot declare reference to %q#T", type
);
11132 type
= TREE_TYPE (type
);
11135 else if (VOID_TYPE_P (type
))
11137 if (declarator
->kind
== cdk_reference
)
11138 error ("cannot declare reference to %q#T", type
);
11139 else if (declarator
->kind
== cdk_ptrmem
)
11140 error ("cannot declare pointer to %q#T member", type
);
11143 /* We now know that the TYPE_QUALS don't apply to the decl,
11144 but to the target of the pointer. */
11145 type_quals
= TYPE_UNQUALIFIED
;
11147 /* This code used to handle METHOD_TYPE, but I don't think it's
11148 possible to get it here anymore. */
11149 gcc_assert (TREE_CODE (type
) != METHOD_TYPE
);
11150 if (declarator
->kind
== cdk_ptrmem
11151 && TREE_CODE (type
) == FUNCTION_TYPE
)
11153 memfn_quals
|= type_memfn_quals (type
);
11154 type
= build_memfn_type (type
,
11155 declarator
->u
.pointer
.class_type
,
11158 if (type
== error_mark_node
)
11159 return error_mark_node
;
11161 rqual
= REF_QUAL_NONE
;
11162 memfn_quals
= TYPE_UNQUALIFIED
;
11165 if (TREE_CODE (type
) == FUNCTION_TYPE
11166 && (type_memfn_quals (type
) != TYPE_UNQUALIFIED
11167 || type_memfn_rqual (type
) != REF_QUAL_NONE
))
11168 error (declarator
->kind
== cdk_reference
11169 ? G_("cannot declare reference to qualified function type %qT")
11170 : G_("cannot declare pointer to qualified function type %qT"),
11173 /* When the pointed-to type involves components of variable size,
11174 care must be taken to ensure that the size evaluation code is
11175 emitted early enough to dominate all the possible later uses
11176 and late enough for the variables on which it depends to have
11179 This is expected to happen automatically when the pointed-to
11180 type has a name/declaration of it's own, but special attention
11181 is required if the type is anonymous.
11183 We handle the NORMAL and FIELD contexts here by inserting a
11184 dummy statement that just evaluates the size at a safe point
11185 and ensures it is not deferred until e.g. within a deeper
11186 conditional context (c++/43555).
11188 We expect nothing to be needed here for PARM or TYPENAME.
11189 Evaluating the size at this point for TYPENAME would
11190 actually be incorrect, as we might be in the middle of an
11191 expression with side effects on the pointed-to type size
11192 "arguments" prior to the pointer declaration point and the
11193 size evaluation could end up prior to the side effects. */
11195 if (!TYPE_NAME (type
)
11196 && (decl_context
== NORMAL
|| decl_context
== FIELD
)
11197 && at_function_scope_p ()
11198 && variably_modified_type_p (type
, NULL_TREE
))
11200 TYPE_NAME (type
) = build_decl (UNKNOWN_LOCATION
, TYPE_DECL
,
11202 add_decl_expr (TYPE_NAME (type
));
11205 if (declarator
->kind
== cdk_reference
)
11207 /* In C++0x, the type we are creating a reference to might be
11208 a typedef which is itself a reference type. In that case,
11209 we follow the reference collapsing rules in
11210 [7.1.3/8 dcl.typedef] to create the final reference type:
11212 "If a typedef TD names a type that is a reference to a type
11213 T, an attempt to create the type 'lvalue reference to cv TD'
11214 creates the type 'lvalue reference to T,' while an attempt
11215 to create the type "rvalue reference to cv TD' creates the
11218 if (VOID_TYPE_P (type
))
11219 /* We already gave an error. */;
11220 else if (TREE_CODE (type
) == REFERENCE_TYPE
)
11222 if (declarator
->u
.reference
.rvalue_ref
)
11223 /* Leave type alone. */;
11225 type
= cp_build_reference_type (TREE_TYPE (type
), false);
11228 type
= cp_build_reference_type
11229 (type
, declarator
->u
.reference
.rvalue_ref
);
11231 /* In C++0x, we need this check for direct reference to
11232 reference declarations, which are forbidden by
11233 [8.3.2/5 dcl.ref]. Reference to reference declarations
11234 are only allowed indirectly through typedefs and template
11235 type arguments. Example:
11237 void foo(int & &); // invalid ref-to-ref decl
11239 typedef int & int_ref;
11240 void foo(int_ref &); // valid ref-to-ref decl
11242 if (inner_declarator
&& inner_declarator
->kind
== cdk_reference
)
11243 error ("cannot declare reference to %q#T, which is not "
11244 "a typedef or a template type argument", type
);
11246 else if (TREE_CODE (type
) == METHOD_TYPE
)
11247 type
= build_ptrmemfunc_type (build_pointer_type (type
));
11248 else if (declarator
->kind
== cdk_ptrmem
)
11250 gcc_assert (TREE_CODE (declarator
->u
.pointer
.class_type
)
11251 != NAMESPACE_DECL
);
11252 if (declarator
->u
.pointer
.class_type
== error_mark_node
)
11253 /* We will already have complained. */
11254 type
= error_mark_node
;
11256 type
= build_ptrmem_type (declarator
->u
.pointer
.class_type
,
11260 type
= build_pointer_type (type
);
11262 /* Process a list of type modifier keywords (such as
11263 const or volatile) that were given inside the `*' or `&'. */
11265 if (declarator
->u
.pointer
.qualifiers
)
11268 = cp_build_qualified_type (type
,
11269 declarator
->u
.pointer
.qualifiers
);
11270 type_quals
= cp_type_quals (type
);
11273 /* Apply C++11 attributes to the pointer, and not to the
11274 type pointed to. This is unlike what is done for GNU
11275 attributes above. It is to comply with [dcl.ptr]/1:
11277 [the optional attribute-specifier-seq (7.6.1) appertains
11278 to the pointer and not to the object pointed to]. */
11279 if (declarator
->std_attributes
)
11280 decl_attributes (&type
, declarator
->std_attributes
,
11290 gcc_unreachable ();
11294 /* A `constexpr' specifier used in an object declaration declares
11295 the object as `const'. */
11296 if (constexpr_p
&& innermost_code
!= cdk_function
)
11298 /* DR1688 says that a `constexpr' specifier in combination with
11299 `volatile' is valid. */
11301 if (TREE_CODE (type
) != REFERENCE_TYPE
)
11303 type_quals
|= TYPE_QUAL_CONST
;
11304 type
= cp_build_qualified_type (type
, type_quals
);
11308 if (unqualified_id
&& TREE_CODE (unqualified_id
) == TEMPLATE_ID_EXPR
11309 && TREE_CODE (type
) != FUNCTION_TYPE
11310 && TREE_CODE (type
) != METHOD_TYPE
11311 && !variable_template_p (TREE_OPERAND (unqualified_id
, 0)))
11313 error ("template-id %qD used as a declarator",
11315 unqualified_id
= dname
;
11318 /* If TYPE is a FUNCTION_TYPE, but the function name was explicitly
11319 qualified with a class-name, turn it into a METHOD_TYPE, unless
11320 we know that the function is static. We take advantage of this
11321 opportunity to do other processing that pertains to entities
11322 explicitly declared to be class members. Note that if DECLARATOR
11323 is non-NULL, we know it is a cdk_id declarator; otherwise, we
11324 would not have exited the loop above. */
11326 && declarator
->kind
== cdk_id
11327 && declarator
->u
.id
.qualifying_scope
11328 && MAYBE_CLASS_TYPE_P (declarator
->u
.id
.qualifying_scope
))
11330 ctype
= declarator
->u
.id
.qualifying_scope
;
11331 ctype
= TYPE_MAIN_VARIANT (ctype
);
11332 template_count
= num_template_headers_for_class (ctype
);
11334 if (ctype
== current_class_type
)
11338 permerror (input_location
, "member functions are implicitly "
11339 "friends of their class");
11343 permerror (declarator
->id_loc
,
11344 "extra qualification %<%T::%> on member %qs",
11347 else if (/* If the qualifying type is already complete, then we
11348 can skip the following checks. */
11349 !COMPLETE_TYPE_P (ctype
)
11350 && (/* If the function is being defined, then
11351 qualifying type must certainly be complete. */
11353 /* A friend declaration of "T::f" is OK, even if
11354 "T" is a template parameter. But, if this
11355 function is not a friend, the qualifying type
11356 must be a class. */
11357 || (!friendp
&& !CLASS_TYPE_P (ctype
))
11358 /* For a declaration, the type need not be
11359 complete, if either it is dependent (since there
11360 is no meaningful definition of complete in that
11361 case) or the qualifying class is currently being
11363 || !(dependent_type_p (ctype
)
11364 || currently_open_class (ctype
)))
11365 /* Check that the qualifying type is complete. */
11366 && !complete_type_or_else (ctype
, NULL_TREE
))
11367 return error_mark_node
;
11368 else if (TREE_CODE (type
) == FUNCTION_TYPE
)
11370 if (current_class_type
11371 && (!friendp
|| funcdef_flag
|| initialized
))
11373 error (funcdef_flag
|| initialized
11374 ? G_("cannot define member function %<%T::%s%> "
11376 : G_("cannot declare member function %<%T::%s%> "
11378 ctype
, name
, current_class_type
);
11379 return error_mark_node
;
11382 else if (typedef_p
&& current_class_type
)
11384 error ("cannot declare member %<%T::%s%> within %qT",
11385 ctype
, name
, current_class_type
);
11386 return error_mark_node
;
11390 if (ctype
== NULL_TREE
&& decl_context
== FIELD
&& friendp
== 0)
11391 ctype
= current_class_type
;
11393 /* Now TYPE has the actual type. */
11395 if (returned_attrs
)
11398 *attrlist
= chainon (returned_attrs
, *attrlist
);
11400 attrlist
= &returned_attrs
;
11404 && declarator
->kind
== cdk_id
11405 && declarator
->std_attributes
11406 && attrlist
!= NULL
)
11407 /* [dcl.meaning]/1: The optional attribute-specifier-seq following
11408 a declarator-id appertains to the entity that is declared. */
11409 *attrlist
= chainon (*attrlist
, declarator
->std_attributes
);
11411 /* Handle parameter packs. */
11412 if (parameter_pack_p
)
11414 if (decl_context
== PARM
)
11415 /* Turn the type into a pack expansion.*/
11416 type
= make_pack_expansion (type
);
11418 error ("non-parameter %qs cannot be a parameter pack", name
);
11421 if ((decl_context
== FIELD
|| decl_context
== PARM
)
11422 && !processing_template_decl
11423 && variably_modified_type_p (type
, NULL_TREE
))
11425 if (decl_context
== FIELD
)
11426 error ("data member may not have variably modified type %qT", type
);
11428 error ("parameter may not have variably modified type %qT", type
);
11429 type
= error_mark_node
;
11432 if (explicitp
== 1 || (explicitp
&& friendp
))
11434 /* [dcl.fct.spec] (C++11) The explicit specifier shall be used only
11435 in the declaration of a constructor or conversion function within
11436 a class definition. */
11437 if (!current_class_type
)
11438 error_at (declspecs
->locations
[ds_explicit
],
11439 "%<explicit%> outside class declaration");
11441 error_at (declspecs
->locations
[ds_explicit
],
11442 "%<explicit%> in friend declaration");
11444 error_at (declspecs
->locations
[ds_explicit
],
11445 "only declarations of constructors and conversion operators "
11446 "can be %<explicit%>");
11450 if (storage_class
== sc_mutable
)
11452 if (decl_context
!= FIELD
|| friendp
)
11454 error ("non-member %qs cannot be declared %<mutable%>", name
);
11455 storage_class
= sc_none
;
11457 else if (decl_context
== TYPENAME
|| typedef_p
)
11459 error ("non-object member %qs cannot be declared %<mutable%>", name
);
11460 storage_class
= sc_none
;
11462 else if (TREE_CODE (type
) == FUNCTION_TYPE
11463 || TREE_CODE (type
) == METHOD_TYPE
)
11465 error ("function %qs cannot be declared %<mutable%>", name
);
11466 storage_class
= sc_none
;
11470 error ("static %qs cannot be declared %<mutable%>", name
);
11471 storage_class
= sc_none
;
11473 else if (type_quals
& TYPE_QUAL_CONST
)
11475 error ("const %qs cannot be declared %<mutable%>", name
);
11476 storage_class
= sc_none
;
11478 else if (TREE_CODE (type
) == REFERENCE_TYPE
)
11480 permerror (input_location
, "reference %qs cannot be declared "
11481 "%<mutable%>", name
);
11482 storage_class
= sc_none
;
11486 /* If this is declaring a typedef name, return a TYPE_DECL. */
11487 if (typedef_p
&& decl_context
!= TYPENAME
)
11491 /* This declaration:
11493 typedef void f(int) const;
11495 declares a function type which is not a member of any
11496 particular class, but which is cv-qualified; for
11497 example "f S::*" declares a pointer to a const-qualified
11498 member function of S. We record the cv-qualification in the
11500 if ((rqual
|| memfn_quals
) && TREE_CODE (type
) == FUNCTION_TYPE
)
11502 type
= apply_memfn_quals (type
, memfn_quals
, rqual
);
11504 /* We have now dealt with these qualifiers. */
11505 memfn_quals
= TYPE_UNQUALIFIED
;
11506 rqual
= REF_QUAL_NONE
;
11509 if (type_uses_auto (type
))
11511 error ("typedef declared %<auto%>");
11512 type
= error_mark_node
;
11516 error_at (location_of (reqs
), "requires-clause on typedef");
11518 if (decl_context
== FIELD
)
11519 decl
= build_lang_decl (TYPE_DECL
, unqualified_id
, type
);
11521 decl
= build_decl (input_location
, TYPE_DECL
, unqualified_id
, type
);
11522 if (id_declarator
&& declarator
->u
.id
.qualifying_scope
) {
11523 error_at (DECL_SOURCE_LOCATION (decl
),
11524 "typedef name may not be a nested-name-specifier");
11525 TREE_TYPE (decl
) = error_mark_node
;
11528 if (decl_context
!= FIELD
)
11530 if (!current_function_decl
)
11531 DECL_CONTEXT (decl
) = FROB_CONTEXT (current_namespace
);
11532 else if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (current_function_decl
)
11533 || (DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P
11534 (current_function_decl
)))
11535 /* The TYPE_DECL is "abstract" because there will be
11536 clones of this constructor/destructor, and there will
11537 be copies of this TYPE_DECL generated in those
11538 clones. The decloning optimization (for space) may
11539 revert this subsequently if it determines that
11540 the clones should share a common implementation. */
11541 DECL_ABSTRACT_P (decl
) = true;
11543 else if (current_class_type
11544 && constructor_name_p (unqualified_id
, current_class_type
))
11545 permerror (input_location
, "ISO C++ forbids nested type %qD with same name "
11546 "as enclosing class",
11549 /* If the user declares "typedef struct {...} foo" then the
11550 struct will have an anonymous name. Fill that name in now.
11551 Nothing can refer to it, so nothing needs know about the name
11553 if (type
!= error_mark_node
11555 && TYPE_NAME (type
)
11556 && TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
11557 && TYPE_UNNAMED_P (type
)
11558 && declspecs
->type_definition_p
11559 && attributes_naming_typedef_ok (*attrlist
)
11560 && cp_type_quals (type
) == TYPE_UNQUALIFIED
)
11561 name_unnamed_type (type
, decl
);
11564 || (typedef_decl
&& C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl
)))
11565 C_TYPEDEF_EXPLICITLY_SIGNED (decl
) = 1;
11567 bad_specifiers (decl
, BSP_TYPE
, virtualp
,
11568 memfn_quals
!= TYPE_UNQUALIFIED
,
11569 inlinep
, friendp
, raises
!= NULL_TREE
);
11571 if (decl_spec_seq_has_spec_p (declspecs
, ds_alias
))
11572 /* Acknowledge that this was written:
11573 `using analias = atype;'. */
11574 TYPE_DECL_ALIAS_P (decl
) = 1;
11579 /* Detect the case of an array type of unspecified size
11580 which came, as such, direct from a typedef name.
11581 We must copy the type, so that the array's domain can be
11582 individually set by the object's initializer. */
11584 if (type
&& typedef_type
11585 && TREE_CODE (type
) == ARRAY_TYPE
&& !TYPE_DOMAIN (type
)
11586 && TYPE_MAIN_VARIANT (type
) == TYPE_MAIN_VARIANT (typedef_type
))
11587 type
= build_cplus_array_type (TREE_TYPE (type
), NULL_TREE
);
11589 /* Detect where we're using a typedef of function type to declare a
11590 function. PARMS will not be set, so we must create it now. */
11592 if (type
== typedef_type
&& TREE_CODE (type
) == FUNCTION_TYPE
)
11594 tree decls
= NULL_TREE
;
11597 for (args
= TYPE_ARG_TYPES (type
);
11598 args
&& args
!= void_list_node
;
11599 args
= TREE_CHAIN (args
))
11601 tree decl
= cp_build_parm_decl (NULL_TREE
, NULL_TREE
,
11602 TREE_VALUE (args
));
11604 DECL_CHAIN (decl
) = decls
;
11608 parms
= nreverse (decls
);
11610 if (decl_context
!= TYPENAME
)
11612 /* The qualifiers on the function type become the qualifiers on
11613 the non-static member function. */
11614 memfn_quals
|= type_memfn_quals (type
);
11615 rqual
= type_memfn_rqual (type
);
11616 type_quals
= TYPE_UNQUALIFIED
;
11620 /* If this is a type name (such as, in a cast or sizeof),
11621 compute the type and return it now. */
11623 if (decl_context
== TYPENAME
)
11625 /* Note that here we don't care about type_quals. */
11627 /* Special case: "friend class foo" looks like a TYPENAME context. */
11632 error ("%<inline%> specified for friend class declaration");
11638 /* Don't allow friend declaration without a class-key. */
11639 if (TREE_CODE (type
) == TEMPLATE_TYPE_PARM
)
11640 permerror (input_location
, "template parameters cannot be friends");
11641 else if (TREE_CODE (type
) == TYPENAME_TYPE
)
11642 permerror (input_location
, "friend declaration requires class-key, "
11643 "i.e. %<friend class %T::%D%>",
11644 TYPE_CONTEXT (type
), TYPENAME_TYPE_FULLNAME (type
));
11646 permerror (input_location
, "friend declaration requires class-key, "
11647 "i.e. %<friend %#T%>",
11651 /* Only try to do this stuff if we didn't already give up. */
11652 if (type
!= integer_type_node
)
11654 /* A friendly class? */
11655 if (current_class_type
)
11656 make_friend_class (current_class_type
, TYPE_MAIN_VARIANT (type
),
11657 /*complain=*/true);
11659 error ("trying to make class %qT a friend of global scope",
11662 type
= void_type_node
;
11665 else if (memfn_quals
|| rqual
)
11667 if (ctype
== NULL_TREE
11668 && TREE_CODE (type
) == METHOD_TYPE
)
11669 ctype
= TYPE_METHOD_BASETYPE (type
);
11672 type
= build_memfn_type (type
, ctype
, memfn_quals
, rqual
);
11673 /* Core issue #547: need to allow this in template type args.
11674 Allow it in general in C++11 for alias-declarations. */
11675 else if ((template_type_arg
|| cxx_dialect
>= cxx11
)
11676 && TREE_CODE (type
) == FUNCTION_TYPE
)
11677 type
= apply_memfn_quals (type
, memfn_quals
, rqual
);
11679 error ("invalid qualifiers on non-member function type");
11683 error_at (location_of (reqs
), "requires-clause on type-id");
11687 else if (unqualified_id
== NULL_TREE
&& decl_context
!= PARM
11688 && decl_context
!= CATCHPARM
11689 && TREE_CODE (type
) != UNION_TYPE
11691 && innermost_code
!= cdk_decomp
)
11693 error ("abstract declarator %qT used as declaration", type
);
11694 return error_mark_node
;
11697 if (!FUNC_OR_METHOD_TYPE_P (type
))
11699 /* Only functions may be declared using an operator-function-id. */
11700 if (dname
&& IDENTIFIER_ANY_OP_P (dname
))
11702 error ("declaration of %qD as non-function", dname
);
11703 return error_mark_node
;
11707 error_at (location_of (reqs
),
11708 "requires-clause on declaration of non-function type %qT",
11712 /* We don't check parameter types here because we can emit a better
11713 error message later. */
11714 if (decl_context
!= PARM
)
11716 type
= check_var_type (unqualified_id
, type
);
11717 if (type
== error_mark_node
)
11718 return error_mark_node
;
11721 /* Now create the decl, which may be a VAR_DECL, a PARM_DECL
11722 or a FUNCTION_DECL, depending on DECL_CONTEXT and TYPE. */
11724 if (decl_context
== PARM
|| decl_context
== CATCHPARM
)
11726 if (ctype
|| in_namespace
)
11727 error ("cannot use %<::%> in parameter declaration");
11729 if (type_uses_auto (type
)
11730 && !(cxx_dialect
>= cxx17
&& template_parm_flag
))
11732 if (cxx_dialect
>= cxx14
)
11733 error ("%<auto%> parameter not permitted in this context");
11735 error ("parameter declared %<auto%>");
11736 type
= error_mark_node
;
11739 /* A parameter declared as an array of T is really a pointer to T.
11740 One declared as a function is really a pointer to a function.
11741 One declared as a member is really a pointer to member. */
11743 if (TREE_CODE (type
) == ARRAY_TYPE
)
11745 /* Transfer const-ness of array into that of type pointed to. */
11746 type
= build_pointer_type (TREE_TYPE (type
));
11747 type_quals
= TYPE_UNQUALIFIED
;
11748 array_parameter_p
= true;
11750 else if (TREE_CODE (type
) == FUNCTION_TYPE
)
11751 type
= build_pointer_type (type
);
11754 if (ctype
&& TREE_CODE (type
) == FUNCTION_TYPE
&& staticp
< 2
11755 && !(identifier_p (unqualified_id
)
11756 && IDENTIFIER_NEWDEL_OP_P (unqualified_id
)))
11758 cp_cv_quals real_quals
= memfn_quals
;
11759 if (cxx_dialect
< cxx14
&& constexpr_p
11760 && sfk
!= sfk_constructor
&& sfk
!= sfk_destructor
)
11761 real_quals
|= TYPE_QUAL_CONST
;
11762 type
= build_memfn_type (type
, ctype
, real_quals
, rqual
);
11766 tree decl
= NULL_TREE
;
11768 if (decl_context
== PARM
)
11770 decl
= cp_build_parm_decl (NULL_TREE
, unqualified_id
, type
);
11771 DECL_ARRAY_PARAMETER_P (decl
) = array_parameter_p
;
11773 bad_specifiers (decl
, BSP_PARM
, virtualp
,
11774 memfn_quals
!= TYPE_UNQUALIFIED
,
11775 inlinep
, friendp
, raises
!= NULL_TREE
);
11777 else if (decl_context
== FIELD
)
11779 if (!staticp
&& !friendp
&& TREE_CODE (type
) != METHOD_TYPE
)
11780 if (tree auto_node
= type_uses_auto (type
))
11782 location_t loc
= declspecs
->locations
[ds_type_spec
];
11783 if (CLASS_PLACEHOLDER_TEMPLATE (auto_node
))
11784 error_at (loc
, "invalid use of template-name %qE without an "
11786 CLASS_PLACEHOLDER_TEMPLATE (auto_node
));
11788 error_at (loc
, "non-static data member declared with "
11789 "placeholder %qT", auto_node
);
11790 type
= error_mark_node
;
11793 /* The C99 flexible array extension. */
11794 if (!staticp
&& TREE_CODE (type
) == ARRAY_TYPE
11795 && TYPE_DOMAIN (type
) == NULL_TREE
)
11798 && (TREE_CODE (ctype
) == UNION_TYPE
11799 || TREE_CODE (ctype
) == QUAL_UNION_TYPE
))
11801 error ("flexible array member in union");
11802 type
= error_mark_node
;
11806 /* Array is a flexible member. */
11807 if (in_system_header_at (input_location
))
11808 /* Do not warn on flexible array members in system
11809 headers because glibc uses them. */;
11811 pedwarn (input_location
, OPT_Wpedantic
,
11812 "ISO C++ forbids flexible array member %qs", name
);
11814 pedwarn (input_location
, OPT_Wpedantic
,
11815 "ISO C++ forbids flexible array members");
11817 /* Flexible array member has a null domain. */
11818 type
= build_cplus_array_type (TREE_TYPE (type
), NULL_TREE
);
11822 if (type
== error_mark_node
)
11824 /* Happens when declaring arrays of sizes which
11825 are error_mark_node, for example. */
11828 else if (in_namespace
&& !friendp
)
11830 /* Something like struct S { int N::j; }; */
11831 error ("invalid use of %<::%>");
11832 return error_mark_node
;
11834 else if (TREE_CODE (type
) == FUNCTION_TYPE
11835 || TREE_CODE (type
) == METHOD_TYPE
)
11838 tree function_context
;
11842 /* This should never happen in pure C++ (the check
11843 could be an assert). It could happen in
11844 Objective-C++ if someone writes invalid code that
11845 uses a function declaration for an instance
11846 variable or property (instance variables and
11847 properties are parsed as FIELD_DECLs, but they are
11848 part of an Objective-C class, not a C++ class).
11849 That code is invalid and is caught by this
11853 error ("declaration of function %qD in invalid context",
11855 return error_mark_node
;
11858 /* ``A union may [ ... ] not [ have ] virtual functions.''
11860 if (virtualp
&& TREE_CODE (ctype
) == UNION_TYPE
)
11862 error ("function %qD declared %<virtual%> inside a union",
11864 return error_mark_node
;
11868 && identifier_p (unqualified_id
)
11869 && IDENTIFIER_NEWDEL_OP_P (unqualified_id
))
11871 error ("%qD cannot be declared %<virtual%>, since it "
11872 "is always static", unqualified_id
);
11877 /* Check that the name used for a destructor makes sense. */
11878 if (sfk
== sfk_destructor
)
11880 tree uqname
= id_declarator
->u
.id
.unqualified_name
;
11884 gcc_assert (friendp
);
11885 error ("expected qualified name in friend declaration "
11886 "for destructor %qD", uqname
);
11887 return error_mark_node
;
11890 if (!check_dtor_name (ctype
, TREE_OPERAND (uqname
, 0)))
11892 error ("declaration of %qD as member of %qT",
11894 return error_mark_node
;
11898 error ("a destructor cannot be %<concept%>");
11899 return error_mark_node
;
11903 error ("a destructor cannot be %<constexpr%>");
11904 return error_mark_node
;
11907 else if (sfk
== sfk_constructor
&& friendp
&& !ctype
)
11909 error ("expected qualified name in friend declaration "
11910 "for constructor %qD",
11911 id_declarator
->u
.id
.unqualified_name
);
11912 return error_mark_node
;
11914 if (sfk
== sfk_constructor
)
11917 error ("a constructor cannot be %<concept%>");
11918 return error_mark_node
;
11922 error ("a concept cannot be a member function");
11926 if (TREE_CODE (unqualified_id
) == TEMPLATE_ID_EXPR
)
11928 tree tmpl
= TREE_OPERAND (unqualified_id
, 0);
11929 if (variable_template_p (tmpl
))
11931 error ("specialization of variable template %qD "
11932 "declared as function", tmpl
);
11933 inform (DECL_SOURCE_LOCATION (tmpl
),
11934 "variable template declared here");
11935 return error_mark_node
;
11939 /* Tell grokfndecl if it needs to set TREE_PUBLIC on the node. */
11940 function_context
= (ctype
!= NULL_TREE
) ?
11941 decl_function_context (TYPE_MAIN_DECL (ctype
)) : NULL_TREE
;
11942 publicp
= (! friendp
|| ! staticp
)
11943 && function_context
== NULL_TREE
;
11945 if (late_return_type_p
)
11946 TYPE_HAS_LATE_RETURN_TYPE (type
) = 1;
11948 decl
= grokfndecl (ctype
, type
,
11949 TREE_CODE (unqualified_id
) != TEMPLATE_ID_EXPR
11950 ? unqualified_id
: dname
,
11954 virtualp
, flags
, memfn_quals
, rqual
, raises
,
11955 friendp
? -1 : 0, friendp
, publicp
,
11956 inlinep
| (2 * constexpr_p
) | (4 * concept_p
),
11957 initialized
== SD_DELETED
, sfk
,
11958 funcdef_flag
, template_count
, in_namespace
,
11959 attrlist
, declarator
->id_loc
);
11960 decl
= set_virt_specifiers (decl
, virt_specifiers
);
11961 if (decl
== NULL_TREE
)
11962 return error_mark_node
;
11964 /* This clobbers the attrs stored in `decl' from `attrlist'. */
11965 /* The decl and setting of decl_attr is also turned off. */
11966 decl
= build_decl_attribute_variant (decl
, decl_attr
);
11969 /* [class.conv.ctor]
11971 A constructor declared without the function-specifier
11972 explicit that can be called with a single parameter
11973 specifies a conversion from the type of its first
11974 parameter to the type of its class. Such a constructor
11975 is called a converting constructor. */
11976 if (explicitp
== 2)
11977 DECL_NONCONVERTING_P (decl
) = 1;
11979 else if (!staticp
&& !dependent_type_p (type
)
11980 && !COMPLETE_TYPE_P (complete_type (type
))
11981 && (!complete_or_array_type_p (type
)
11982 || initialized
== 0))
11984 if (TREE_CODE (type
) != ARRAY_TYPE
11985 || !COMPLETE_TYPE_P (TREE_TYPE (type
)))
11987 if (unqualified_id
)
11989 error ("field %qD has incomplete type %qT",
11990 unqualified_id
, type
);
11991 cxx_incomplete_type_inform (strip_array_types (type
));
11994 error ("name %qT has incomplete type", type
);
11996 type
= error_mark_node
;
12004 error ("%qE is neither function nor member function; "
12005 "cannot be declared friend", unqualified_id
);
12013 /* Friends are treated specially. */
12014 if (ctype
== current_class_type
)
12015 ; /* We already issued a permerror. */
12016 else if (decl
&& DECL_NAME (decl
))
12018 if (template_class_depth (current_class_type
) == 0)
12020 decl
= check_explicit_specialization
12021 (unqualified_id
, decl
, template_count
,
12022 2 * funcdef_flag
+ 4);
12023 if (decl
== error_mark_node
)
12024 return error_mark_node
;
12027 decl
= do_friend (ctype
, unqualified_id
, decl
,
12033 return error_mark_node
;
12036 /* Structure field. It may not be a function, except for C++. */
12038 if (decl
== NULL_TREE
)
12042 /* C++ allows static class members. All other work
12043 for this is done by grokfield. */
12044 decl
= build_lang_decl_loc (declarator
12045 ? declarator
->id_loc
12047 VAR_DECL
, unqualified_id
, type
);
12048 set_linkage_for_static_data_member (decl
);
12050 error ("static data member %qE declared %<concept%>",
12052 else if (constexpr_p
&& !initialized
)
12054 error ("constexpr static data member %qD must have an "
12055 "initializer", decl
);
12056 constexpr_p
= false;
12060 mark_inline_variable (decl
);
12062 if (!DECL_VAR_DECLARED_INLINE_P (decl
)
12063 && !(cxx_dialect
>= cxx17
&& constexpr_p
))
12064 /* Even if there is an in-class initialization, DECL
12065 is considered undefined until an out-of-class
12066 definition is provided, unless this is an inline
12068 DECL_EXTERNAL (decl
) = 1;
12072 CP_DECL_THREAD_LOCAL_P (decl
) = true;
12073 if (!processing_template_decl
)
12074 set_decl_tls_model (decl
, decl_default_tls_model (decl
));
12075 if (declspecs
->gnu_thread_keyword_p
)
12076 SET_DECL_GNU_TLS_P (decl
);
12082 error ("non-static data member %qE declared %<concept%>",
12084 else if (constexpr_p
)
12086 error ("non-static data member %qE declared %<constexpr%>",
12088 constexpr_p
= false;
12090 decl
= build_decl (input_location
,
12091 FIELD_DECL
, unqualified_id
, type
);
12092 DECL_NONADDRESSABLE_P (decl
) = bitfield
;
12093 if (bitfield
&& !unqualified_id
)
12094 TREE_NO_WARNING (decl
) = 1;
12096 if (storage_class
== sc_mutable
)
12098 DECL_MUTABLE_P (decl
) = 1;
12099 storage_class
= sc_none
;
12104 /* An attempt is being made to initialize a non-static
12105 member. This is new in C++11. */
12106 maybe_warn_cpp0x (CPP0X_NSDMI
);
12108 /* If this has been parsed with static storage class, but
12109 errors forced staticp to be cleared, ensure NSDMI is
12111 if (declspecs
->storage_class
== sc_static
)
12112 DECL_INITIAL (decl
) = error_mark_node
;
12116 bad_specifiers (decl
, BSP_FIELD
, virtualp
,
12117 memfn_quals
!= TYPE_UNQUALIFIED
,
12118 staticp
? false : inlinep
, friendp
,
12119 raises
!= NULL_TREE
);
12122 else if (TREE_CODE (type
) == FUNCTION_TYPE
12123 || TREE_CODE (type
) == METHOD_TYPE
)
12125 tree original_name
;
12128 if (!unqualified_id
)
12129 return error_mark_node
;
12131 if (TREE_CODE (unqualified_id
) == TEMPLATE_ID_EXPR
)
12132 original_name
= dname
;
12134 original_name
= unqualified_id
;
12135 // FIXME:gcc_assert (original_name == dname);
12137 if (storage_class
== sc_auto
)
12138 error ("storage class %<auto%> invalid for function %qs", name
);
12139 else if (storage_class
== sc_register
)
12140 error ("storage class %<register%> invalid for function %qs", name
);
12143 if (declspecs
->gnu_thread_keyword_p
)
12144 error ("storage class %<__thread%> invalid for function %qs",
12147 error ("storage class %<thread_local%> invalid for function %qs",
12151 if (virt_specifiers
)
12152 error ("virt-specifiers in %qs not allowed outside a class definition", name
);
12153 /* Function declaration not at top level.
12154 Storage classes other than `extern' are not allowed
12155 and `extern' makes no difference. */
12156 if (! toplevel_bindings_p ()
12157 && (storage_class
== sc_static
12158 || decl_spec_seq_has_spec_p (declspecs
, ds_inline
))
12161 if (storage_class
== sc_static
)
12162 pedwarn (input_location
, OPT_Wpedantic
,
12163 "%<static%> specifier invalid for function %qs "
12164 "declared out of global scope", name
);
12166 pedwarn (input_location
, OPT_Wpedantic
,
12167 "%<inline%> specifier invalid for function %qs "
12168 "declared out of global scope", name
);
12171 if (ctype
== NULL_TREE
)
12175 error ("virtual non-class function %qs", name
);
12178 else if (sfk
== sfk_constructor
12179 || sfk
== sfk_destructor
)
12181 error (funcdef_flag
12182 ? G_("%qs defined in a non-class scope")
12183 : G_("%qs declared in a non-class scope"), name
);
12188 /* Record whether the function is public. */
12189 publicp
= (ctype
!= NULL_TREE
12190 || storage_class
!= sc_static
);
12192 if (late_return_type_p
)
12193 TYPE_HAS_LATE_RETURN_TYPE (type
) = 1;
12195 decl
= grokfndecl (ctype
, type
, original_name
, parms
, unqualified_id
,
12196 reqs
, virtualp
, flags
, memfn_quals
, rqual
, raises
,
12199 inlinep
| (2 * constexpr_p
) | (4 * concept_p
),
12200 initialized
== SD_DELETED
,
12203 template_count
, in_namespace
, attrlist
,
12204 declarator
->id_loc
);
12205 if (decl
== NULL_TREE
)
12206 return error_mark_node
;
12208 if (explicitp
== 2)
12209 DECL_NONCONVERTING_P (decl
) = 1;
12212 int invalid_static
= 0;
12214 /* Don't allow a static member function in a class, and forbid
12215 declaring main to be static. */
12216 if (TREE_CODE (type
) == METHOD_TYPE
)
12218 permerror (input_location
, "cannot declare member function %qD to have "
12219 "static linkage", decl
);
12220 invalid_static
= 1;
12222 else if (current_function_decl
)
12224 /* 7.1.1: There can be no static function declarations within a
12226 error ("cannot declare static function inside another function");
12227 invalid_static
= 1;
12230 if (invalid_static
)
12233 storage_class
= sc_none
;
12239 /* It's a variable. */
12241 /* An uninitialized decl with `extern' is a reference. */
12242 decl
= grokvardecl (type
, dname
, unqualified_id
,
12249 ctype
? ctype
: in_namespace
);
12250 if (decl
== NULL_TREE
)
12251 return error_mark_node
;
12253 bad_specifiers (decl
, BSP_VAR
, virtualp
,
12254 memfn_quals
!= TYPE_UNQUALIFIED
,
12255 inlinep
, friendp
, raises
!= NULL_TREE
);
12259 DECL_CONTEXT (decl
) = ctype
;
12262 permerror (input_location
, "%<static%> may not be used when defining "
12263 "(as opposed to declaring) a static data member");
12265 storage_class
= sc_none
;
12267 if (storage_class
== sc_register
&& TREE_STATIC (decl
))
12269 error ("static member %qD declared %<register%>", decl
);
12270 storage_class
= sc_none
;
12272 if (storage_class
== sc_extern
&& pedantic
)
12274 pedwarn (input_location
, OPT_Wpedantic
,
12275 "cannot explicitly declare member %q#D to have "
12276 "extern linkage", decl
);
12277 storage_class
= sc_none
;
12280 else if (constexpr_p
&& DECL_EXTERNAL (decl
))
12282 error ("declaration of constexpr variable %qD is not a definition",
12284 constexpr_p
= false;
12288 mark_inline_variable (decl
);
12289 if (innermost_code
== cdk_decomp
)
12291 gcc_assert (declarator
&& declarator
->kind
== cdk_decomp
);
12292 DECL_SOURCE_LOCATION (decl
) = declarator
->id_loc
;
12293 DECL_ARTIFICIAL (decl
) = 1;
12294 fit_decomposition_lang_decl (decl
, NULL_TREE
);
12298 if (VAR_P (decl
) && !initialized
)
12299 if (tree auto_node
= type_uses_auto (type
))
12300 if (!CLASS_PLACEHOLDER_TEMPLATE (auto_node
))
12302 location_t loc
= declspecs
->locations
[ds_type_spec
];
12303 error_at (loc
, "declaration of %q#D has no initializer", decl
);
12304 TREE_TYPE (decl
) = error_mark_node
;
12307 if (storage_class
== sc_extern
&& initialized
&& !funcdef_flag
)
12309 if (toplevel_bindings_p ())
12311 /* It's common practice (and completely valid) to have a const
12312 be initialized and declared extern. */
12313 if (!(type_quals
& TYPE_QUAL_CONST
))
12314 warning (0, "%qs initialized and declared %<extern%>", name
);
12318 error ("%qs has both %<extern%> and initializer", name
);
12319 return error_mark_node
;
12323 /* Record `register' declaration for warnings on &
12324 and in case doing stupid register allocation. */
12326 if (storage_class
== sc_register
)
12328 DECL_REGISTER (decl
) = 1;
12329 /* Warn about register storage specifiers on PARM_DECLs. */
12330 if (TREE_CODE (decl
) == PARM_DECL
)
12332 if (cxx_dialect
>= cxx17
)
12333 pedwarn (DECL_SOURCE_LOCATION (decl
), OPT_Wregister
,
12334 "ISO C++17 does not allow %<register%> storage "
12335 "class specifier");
12337 warning_at (DECL_SOURCE_LOCATION (decl
), OPT_Wregister
,
12338 "%<register%> storage class specifier used");
12341 else if (storage_class
== sc_extern
)
12342 DECL_THIS_EXTERN (decl
) = 1;
12343 else if (storage_class
== sc_static
)
12344 DECL_THIS_STATIC (decl
) = 1;
12346 /* Set constexpr flag on vars (functions got it in grokfndecl). */
12347 if (constexpr_p
&& VAR_P (decl
))
12348 DECL_DECLARED_CONSTEXPR_P (decl
) = true;
12350 /* Record constancy and volatility on the DECL itself . There's
12351 no need to do this when processing a template; we'll do this
12352 for the instantiated declaration based on the type of DECL. */
12353 if (!processing_template_decl
)
12354 cp_apply_type_quals_to_decl (type_quals
, decl
);
12360 /* Subroutine of start_function. Ensure that each of the parameter
12361 types (as listed in PARMS) is complete, as is required for a
12362 function definition. */
12365 require_complete_types_for_parms (tree parms
)
12367 for (; parms
; parms
= DECL_CHAIN (parms
))
12369 if (dependent_type_p (TREE_TYPE (parms
)))
12371 if (!VOID_TYPE_P (TREE_TYPE (parms
))
12372 && complete_type_or_else (TREE_TYPE (parms
), parms
))
12374 relayout_decl (parms
);
12375 DECL_ARG_TYPE (parms
) = type_passed_as (TREE_TYPE (parms
));
12377 maybe_warn_parm_abi (TREE_TYPE (parms
),
12378 DECL_SOURCE_LOCATION (parms
));
12381 /* grokparms or complete_type_or_else will have already issued
12383 TREE_TYPE (parms
) = error_mark_node
;
12387 /* Returns nonzero if T is a local variable. */
12390 local_variable_p (const_tree t
)
12393 /* A VAR_DECL with a context that is a _TYPE is a static data
12395 && !TYPE_P (CP_DECL_CONTEXT (t
))
12396 /* Any other non-local variable must be at namespace scope. */
12397 && !DECL_NAMESPACE_SCOPE_P (t
))
12398 || (TREE_CODE (t
) == PARM_DECL
))
12404 /* Like local_variable_p, but suitable for use as a tree-walking
12408 local_variable_p_walkfn (tree
*tp
, int *walk_subtrees
,
12411 if (local_variable_p (*tp
)
12412 && (!DECL_ARTIFICIAL (*tp
) || DECL_NAME (*tp
) == this_identifier
))
12414 else if (TYPE_P (*tp
))
12415 *walk_subtrees
= 0;
12420 /* Check that ARG, which is a default-argument expression for a
12421 parameter DECL, is valid. Returns ARG, or ERROR_MARK_NODE, if
12422 something goes wrong. DECL may also be a _TYPE node, rather than a
12423 DECL, if there is no DECL available. */
12426 check_default_argument (tree decl
, tree arg
, tsubst_flags_t complain
)
12431 if (TREE_CODE (arg
) == DEFAULT_ARG
)
12432 /* We get a DEFAULT_ARG when looking at an in-class declaration
12433 with a default argument. Ignore the argument for now; we'll
12434 deal with it after the class is complete. */
12443 decl_type
= TREE_TYPE (decl
);
12445 if (arg
== error_mark_node
12446 || decl
== error_mark_node
12447 || TREE_TYPE (arg
) == error_mark_node
12448 || decl_type
== error_mark_node
)
12449 /* Something already went wrong. There's no need to check
12451 return error_mark_node
;
12453 /* [dcl.fct.default]
12455 A default argument expression is implicitly converted to the
12457 ++cp_unevaluated_operand
;
12458 perform_implicit_conversion_flags (decl_type
, arg
, complain
,
12460 --cp_unevaluated_operand
;
12462 /* Avoid redundant -Wzero-as-null-pointer-constant warnings at
12464 if (TYPE_PTR_OR_PTRMEM_P (decl_type
)
12465 && null_ptr_cst_p (arg
))
12466 return nullptr_node
;
12468 /* [dcl.fct.default]
12470 Local variables shall not be used in default argument
12473 The keyword `this' shall not be used in a default argument of a
12474 member function. */
12475 var
= cp_walk_tree_without_duplicates (&arg
, local_variable_p_walkfn
, NULL
);
12478 if (complain
& tf_warning_or_error
)
12480 if (DECL_NAME (var
) == this_identifier
)
12481 permerror (input_location
, "default argument %qE uses %qD",
12484 error ("default argument %qE uses local variable %qD", arg
, var
);
12486 return error_mark_node
;
12493 /* Returns a deprecated type used within TYPE, or NULL_TREE if none. */
12496 type_is_deprecated (tree type
)
12498 enum tree_code code
;
12499 if (TREE_DEPRECATED (type
))
12501 if (TYPE_NAME (type
))
12503 if (TREE_DEPRECATED (TYPE_NAME (type
)))
12509 /* Do warn about using typedefs to a deprecated class. */
12510 if (OVERLOAD_TYPE_P (type
) && type
!= TYPE_MAIN_VARIANT (type
))
12511 return type_is_deprecated (TYPE_MAIN_VARIANT (type
));
12513 code
= TREE_CODE (type
);
12515 if (code
== POINTER_TYPE
|| code
== REFERENCE_TYPE
12516 || code
== OFFSET_TYPE
|| code
== FUNCTION_TYPE
12517 || code
== METHOD_TYPE
|| code
== ARRAY_TYPE
)
12518 return type_is_deprecated (TREE_TYPE (type
));
12520 if (TYPE_PTRMEMFUNC_P (type
))
12521 return type_is_deprecated
12522 (TREE_TYPE (TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (type
))));
12527 /* Decode the list of parameter types for a function type.
12528 Given the list of things declared inside the parens,
12529 return a list of types.
12531 If this parameter does not end with an ellipsis, we append
12534 *PARMS is set to the chain of PARM_DECLs created. */
12537 grokparms (tree parmlist
, tree
*parms
)
12539 tree result
= NULL_TREE
;
12540 tree decls
= NULL_TREE
;
12544 for (parm
= parmlist
; parm
!= NULL_TREE
; parm
= TREE_CHAIN (parm
))
12546 tree type
= NULL_TREE
;
12547 tree init
= TREE_PURPOSE (parm
);
12548 tree decl
= TREE_VALUE (parm
);
12550 if (parm
== void_list_node
)
12553 if (! decl
|| TREE_TYPE (decl
) == error_mark_node
)
12556 type
= TREE_TYPE (decl
);
12557 if (VOID_TYPE_P (type
))
12559 if (same_type_p (type
, void_type_node
)
12561 && !DECL_NAME (decl
) && !result
12562 && TREE_CHAIN (parm
) == void_list_node
)
12563 /* DR 577: A parameter list consisting of a single
12564 unnamed parameter of non-dependent type 'void'. */
12566 else if (cv_qualified_p (type
))
12567 error_at (DECL_SOURCE_LOCATION (decl
),
12568 "invalid use of cv-qualified type %qT in "
12569 "parameter declaration", type
);
12571 error_at (DECL_SOURCE_LOCATION (decl
),
12572 "invalid use of type %<void%> in parameter "
12574 /* It's not a good idea to actually create parameters of
12575 type `void'; other parts of the compiler assume that a
12576 void type terminates the parameter list. */
12577 type
= error_mark_node
;
12578 TREE_TYPE (decl
) = error_mark_node
;
12581 if (type
!= error_mark_node
)
12583 if (deprecated_state
!= DEPRECATED_SUPPRESS
)
12585 tree deptype
= type_is_deprecated (type
);
12587 warn_deprecated_use (deptype
, NULL_TREE
);
12590 /* Top-level qualifiers on the parameters are
12591 ignored for function types. */
12592 type
= cp_build_qualified_type (type
, 0);
12593 if (TREE_CODE (type
) == METHOD_TYPE
)
12595 error ("parameter %qD invalidly declared method type", decl
);
12596 type
= build_pointer_type (type
);
12597 TREE_TYPE (decl
) = type
;
12599 else if (abstract_virtuals_error (decl
, type
))
12600 any_error
= 1; /* Seems like a good idea. */
12601 else if (cxx_dialect
< cxx17
&& POINTER_TYPE_P (type
))
12603 /* Before C++17 DR 393:
12604 [dcl.fct]/6, parameter types cannot contain pointers
12605 (references) to arrays of unknown bound. */
12606 tree t
= TREE_TYPE (type
);
12607 int ptr
= TYPE_PTR_P (type
);
12611 if (TYPE_PTR_P (t
))
12613 else if (TREE_CODE (t
) != ARRAY_TYPE
)
12615 else if (!TYPE_DOMAIN (t
))
12619 if (TREE_CODE (t
) == ARRAY_TYPE
)
12620 pedwarn (DECL_SOURCE_LOCATION (decl
), OPT_Wpedantic
,
12622 ? G_("parameter %qD includes pointer to array of "
12623 "unknown bound %qT")
12624 : G_("parameter %qD includes reference to array of "
12625 "unknown bound %qT"),
12631 else if (init
&& !processing_template_decl
)
12632 init
= check_default_argument (decl
, init
, tf_warning_or_error
);
12635 DECL_CHAIN (decl
) = decls
;
12637 result
= tree_cons (init
, type
, result
);
12639 decls
= nreverse (decls
);
12640 result
= nreverse (result
);
12642 result
= chainon (result
, void_list_node
);
12649 /* D is a constructor or overloaded `operator='.
12651 Let T be the class in which D is declared. Then, this function
12654 -1 if D's is an ill-formed constructor or copy assignment operator
12655 whose first parameter is of type `T'.
12656 0 if D is not a copy constructor or copy assignment
12658 1 if D is a copy constructor or copy assignment operator whose
12659 first parameter is a reference to non-const qualified T.
12660 2 if D is a copy constructor or copy assignment operator whose
12661 first parameter is a reference to const qualified T.
12663 This function can be used as a predicate. Positive values indicate
12664 a copy constructor and nonzero values indicate a copy assignment
12668 copy_fn_p (const_tree d
)
12674 gcc_assert (DECL_FUNCTION_MEMBER_P (d
));
12676 if (TREE_CODE (d
) == TEMPLATE_DECL
12677 || (DECL_TEMPLATE_INFO (d
)
12678 && DECL_MEMBER_TEMPLATE_P (DECL_TI_TEMPLATE (d
))))
12679 /* Instantiations of template member functions are never copy
12680 functions. Note that member functions of templated classes are
12681 represented as template functions internally, and we must
12682 accept those as copy functions. */
12685 args
= FUNCTION_FIRST_USER_PARMTYPE (d
);
12689 arg_type
= TREE_VALUE (args
);
12690 if (arg_type
== error_mark_node
)
12693 if (TYPE_MAIN_VARIANT (arg_type
) == DECL_CONTEXT (d
))
12695 /* Pass by value copy assignment operator. */
12698 else if (TREE_CODE (arg_type
) == REFERENCE_TYPE
12699 && !TYPE_REF_IS_RVALUE (arg_type
)
12700 && TYPE_MAIN_VARIANT (TREE_TYPE (arg_type
)) == DECL_CONTEXT (d
))
12702 if (CP_TYPE_CONST_P (TREE_TYPE (arg_type
)))
12708 args
= TREE_CHAIN (args
);
12710 if (args
&& args
!= void_list_node
&& !TREE_PURPOSE (args
))
12711 /* There are more non-optional args. */
12717 /* D is a constructor or overloaded `operator='.
12719 Let T be the class in which D is declared. Then, this function
12720 returns true when D is a move constructor or move assignment
12721 operator, false otherwise. */
12724 move_fn_p (const_tree d
)
12726 gcc_assert (DECL_FUNCTION_MEMBER_P (d
));
12728 if (cxx_dialect
== cxx98
)
12729 /* There are no move constructors if we are in C++98 mode. */
12732 if (TREE_CODE (d
) == TEMPLATE_DECL
12733 || (DECL_TEMPLATE_INFO (d
)
12734 && DECL_MEMBER_TEMPLATE_P (DECL_TI_TEMPLATE (d
))))
12735 /* Instantiations of template member functions are never move
12736 functions. Note that member functions of templated classes are
12737 represented as template functions internally, and we must
12738 accept those as move functions. */
12741 return move_signature_fn_p (d
);
12744 /* D is a constructor or overloaded `operator='.
12746 Then, this function returns true when D has the same signature as a move
12747 constructor or move assignment operator (because either it is such a
12748 ctor/op= or it is a template specialization with the same signature),
12749 false otherwise. */
12752 move_signature_fn_p (const_tree d
)
12756 bool result
= false;
12758 args
= FUNCTION_FIRST_USER_PARMTYPE (d
);
12762 arg_type
= TREE_VALUE (args
);
12763 if (arg_type
== error_mark_node
)
12766 if (TREE_CODE (arg_type
) == REFERENCE_TYPE
12767 && TYPE_REF_IS_RVALUE (arg_type
)
12768 && same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (arg_type
)),
12772 args
= TREE_CHAIN (args
);
12774 if (args
&& args
!= void_list_node
&& !TREE_PURPOSE (args
))
12775 /* There are more non-optional args. */
12781 /* Remember any special properties of member function DECL. */
12784 grok_special_member_properties (tree decl
)
12788 if (!DECL_NONSTATIC_MEMBER_FUNCTION_P (decl
))
12791 class_type
= DECL_CONTEXT (decl
);
12792 if (IDENTIFIER_CTOR_P (DECL_NAME (decl
)))
12794 int ctor
= copy_fn_p (decl
);
12796 if (!DECL_ARTIFICIAL (decl
))
12797 TYPE_HAS_USER_CONSTRUCTOR (class_type
) = 1;
12803 A non-template constructor for class X is a copy
12804 constructor if its first parameter is of type X&, const
12805 X&, volatile X& or const volatile X&, and either there
12806 are no other parameters or else all other parameters have
12807 default arguments. */
12808 TYPE_HAS_COPY_CTOR (class_type
) = 1;
12809 if (user_provided_p (decl
))
12810 TYPE_HAS_COMPLEX_COPY_CTOR (class_type
) = 1;
12812 TYPE_HAS_CONST_COPY_CTOR (class_type
) = 1;
12814 else if (sufficient_parms_p (FUNCTION_FIRST_USER_PARMTYPE (decl
)))
12815 TYPE_HAS_DEFAULT_CONSTRUCTOR (class_type
) = 1;
12816 else if (move_fn_p (decl
) && user_provided_p (decl
))
12817 TYPE_HAS_COMPLEX_MOVE_CTOR (class_type
) = 1;
12818 else if (is_list_ctor (decl
))
12819 TYPE_HAS_LIST_CTOR (class_type
) = 1;
12821 if (DECL_DECLARED_CONSTEXPR_P (decl
)
12822 && !ctor
&& !move_fn_p (decl
))
12823 TYPE_HAS_CONSTEXPR_CTOR (class_type
) = 1;
12825 else if (DECL_NAME (decl
) == assign_op_identifier
)
12829 A non-template assignment operator for class X is a copy
12830 assignment operator if its parameter is of type X, X&, const
12831 X&, volatile X& or const volatile X&. */
12833 int assop
= copy_fn_p (decl
);
12837 TYPE_HAS_COPY_ASSIGN (class_type
) = 1;
12838 if (user_provided_p (decl
))
12839 TYPE_HAS_COMPLEX_COPY_ASSIGN (class_type
) = 1;
12841 TYPE_HAS_CONST_COPY_ASSIGN (class_type
) = 1;
12843 else if (move_fn_p (decl
) && user_provided_p (decl
))
12844 TYPE_HAS_COMPLEX_MOVE_ASSIGN (class_type
) = 1;
12846 else if (IDENTIFIER_CONV_OP_P (DECL_NAME (decl
)))
12847 TYPE_HAS_CONVERSION (class_type
) = true;
12849 /* Destructors are handled in check_methods. */
12852 /* Check a constructor DECL has the correct form. Complains
12853 if the class has a constructor of the form X(X). */
12856 grok_ctor_properties (const_tree ctype
, const_tree decl
)
12858 int ctor_parm
= copy_fn_p (decl
);
12864 A declaration of a constructor for a class X is ill-formed if
12865 its first parameter is of type (optionally cv-qualified) X
12866 and either there are no other parameters or else all other
12867 parameters have default arguments.
12869 We *don't* complain about member template instantiations that
12870 have this form, though; they can occur as we try to decide
12871 what constructor to use during overload resolution. Since
12872 overload resolution will never prefer such a constructor to
12873 the non-template copy constructor (which is either explicitly
12874 or implicitly defined), there's no need to worry about their
12875 existence. Theoretically, they should never even be
12876 instantiated, but that's hard to forestall. */
12877 error ("invalid constructor; you probably meant %<%T (const %T&)%>",
12885 /* DECL is a declaration for an overloaded or conversion operator. If
12886 COMPLAIN is true, errors are issued for invalid declarations. */
12889 grok_op_properties (tree decl
, bool complain
)
12891 tree argtypes
= TYPE_ARG_TYPES (TREE_TYPE (decl
));
12892 bool methodp
= TREE_CODE (TREE_TYPE (decl
)) == METHOD_TYPE
;
12893 tree name
= DECL_NAME (decl
);
12895 tree class_type
= DECL_CONTEXT (decl
);
12896 if (class_type
&& !CLASS_TYPE_P (class_type
))
12897 class_type
= NULL_TREE
;
12899 tree_code operator_code
;
12901 if (IDENTIFIER_CONV_OP_P (name
))
12903 /* Conversion operators are TYPE_EXPR for the purposes of this
12905 operator_code
= TYPE_EXPR
;
12906 op_flags
= OVL_OP_FLAG_UNARY
;
12910 const ovl_op_info_t
*ovl_op
= IDENTIFIER_OVL_OP_INFO (name
);
12912 operator_code
= ovl_op
->tree_code
;
12913 op_flags
= ovl_op
->flags
;
12914 gcc_checking_assert (operator_code
!= ERROR_MARK
);
12915 DECL_OVERLOADED_OPERATOR_CODE_RAW (decl
) = ovl_op
->ovl_op_code
;
12918 if (op_flags
& OVL_OP_FLAG_ALLOC
)
12920 /* operator new and operator delete are quite special. */
12924 case OVL_OP_FLAG_ALLOC
:
12925 TYPE_HAS_NEW_OPERATOR (class_type
) = 1;
12928 case OVL_OP_FLAG_ALLOC
| OVL_OP_FLAG_DELETE
:
12929 TYPE_GETS_DELETE (class_type
) |= 1;
12932 case OVL_OP_FLAG_ALLOC
| OVL_OP_FLAG_VEC
:
12933 TYPE_HAS_ARRAY_NEW_OPERATOR (class_type
) = 1;
12936 case OVL_OP_FLAG_ALLOC
| OVL_OP_FLAG_DELETE
| OVL_OP_FLAG_VEC
:
12937 TYPE_GETS_DELETE (class_type
) |= 2;
12941 gcc_unreachable ();
12944 /* [basic.std.dynamic.allocation]/1:
12946 A program is ill-formed if an allocation function is declared
12947 in a namespace scope other than global scope or declared
12948 static in global scope.
12950 The same also holds true for deallocation functions. */
12951 if (DECL_NAMESPACE_SCOPE_P (decl
))
12953 if (CP_DECL_CONTEXT (decl
) != global_namespace
)
12955 error ("%qD may not be declared within a namespace", decl
);
12959 if (!TREE_PUBLIC (decl
))
12961 error ("%qD may not be declared as static", decl
);
12966 if (op_flags
& OVL_OP_FLAG_DELETE
)
12967 TREE_TYPE (decl
) = coerce_delete_type (TREE_TYPE (decl
));
12970 DECL_IS_OPERATOR_NEW (decl
) = 1;
12971 TREE_TYPE (decl
) = coerce_new_type (TREE_TYPE (decl
));
12977 /* An operator function must either be a non-static member function
12978 or have at least one parameter of a class, a reference to a class,
12979 an enumeration, or a reference to an enumeration. 13.4.0.6 */
12980 if (! methodp
|| DECL_STATIC_FUNCTION_P (decl
))
12982 if (operator_code
== TYPE_EXPR
12983 || operator_code
== CALL_EXPR
12984 || operator_code
== COMPONENT_REF
12985 || operator_code
== ARRAY_REF
12986 || operator_code
== NOP_EXPR
)
12988 error ("%qD must be a nonstatic member function", decl
);
12992 if (DECL_STATIC_FUNCTION_P (decl
))
12994 error ("%qD must be either a non-static member "
12995 "function or a non-member function", decl
);
12999 for (tree arg
= argtypes
; ; arg
= TREE_CHAIN (arg
))
13001 if (!arg
|| arg
== void_list_node
)
13004 error ("%qD must have an argument of class or "
13005 "enumerated type", decl
);
13009 tree type
= non_reference (TREE_VALUE (arg
));
13010 if (type
== error_mark_node
)
13013 /* MAYBE_CLASS_TYPE_P, rather than CLASS_TYPE_P, is used
13014 because these checks are performed even on template
13016 if (MAYBE_CLASS_TYPE_P (type
)
13017 || TREE_CODE (type
) == ENUMERAL_TYPE
)
13022 if (operator_code
== CALL_EXPR
)
13023 /* There are no further restrictions on the arguments to an overloaded
13027 if (operator_code
== COND_EXPR
)
13030 error ("ISO C++ prohibits overloading operator ?:");
13034 /* Count the number of arguments and check for ellipsis. */
13036 for (tree arg
= argtypes
; arg
!= void_list_node
; arg
= TREE_CHAIN (arg
))
13041 error ("%qD must not have variable number of arguments", decl
);
13047 /* Verify correct number of arguments. */
13050 case OVL_OP_FLAG_AMBIARY
:
13053 /* We have a unary instance of an ambi-ary op. Remap to the
13055 unsigned alt
= ovl_op_alternate
[ovl_op_mapping
[operator_code
]];
13056 const ovl_op_info_t
*ovl_op
= &ovl_op_info
[false][alt
];
13057 gcc_checking_assert (ovl_op
->flags
== OVL_OP_FLAG_UNARY
);
13058 operator_code
= ovl_op
->tree_code
;
13059 DECL_OVERLOADED_OPERATOR_CODE_RAW (decl
) = ovl_op
->ovl_op_code
;
13061 else if (arity
!= 2)
13063 /* This was an ambiguous operator but is invalid. */
13065 ? G_("%qD must have either zero or one argument")
13066 : G_("%qD must have either one or two arguments"), decl
);
13069 else if ((operator_code
== POSTINCREMENT_EXPR
13070 || operator_code
== POSTDECREMENT_EXPR
)
13071 && ! processing_template_decl
13072 /* x++ and x--'s second argument must be an int. */
13073 && ! same_type_p (TREE_VALUE (TREE_CHAIN (argtypes
)),
13074 integer_type_node
))
13077 ? G_("postfix %qD must have %<int%> as its argument")
13078 : G_("postfix %qD must have %<int%> as its second argument"),
13084 case OVL_OP_FLAG_UNARY
:
13088 ? G_("%qD must have no arguments")
13089 : G_("%qD must have exactly one argument"), decl
);
13094 case OVL_OP_FLAG_BINARY
:
13098 ? G_("%qD must have exactly one argument")
13099 : G_("%qD must have exactly two arguments"), decl
);
13105 gcc_unreachable ();
13108 /* There can be no default arguments. */
13109 for (tree arg
= argtypes
; arg
!= void_list_node
; arg
= TREE_CHAIN (arg
))
13110 if (TREE_PURPOSE (arg
))
13112 TREE_PURPOSE (arg
) = NULL_TREE
;
13113 if (operator_code
== POSTINCREMENT_EXPR
13114 || operator_code
== POSTDECREMENT_EXPR
)
13115 pedwarn (input_location
, OPT_Wpedantic
,
13116 "%qD cannot have default arguments", decl
);
13119 error ("%qD cannot have default arguments", decl
);
13124 /* At this point the declaration is well-formed. It may not be
13125 sensible though. */
13127 /* Check member function warnings only on the in-class declaration.
13128 There's no point warning on an out-of-class definition. */
13129 if (class_type
&& class_type
!= current_class_type
)
13132 /* Warn about conversion operators that will never be used. */
13133 if (IDENTIFIER_CONV_OP_P (name
)
13134 && ! DECL_TEMPLATE_INFO (decl
)
13135 && warn_conversion
)
13137 tree t
= TREE_TYPE (name
);
13138 int ref
= (TREE_CODE (t
) == REFERENCE_TYPE
);
13141 t
= TYPE_MAIN_VARIANT (TREE_TYPE (t
));
13143 if (VOID_TYPE_P (t
))
13144 warning (OPT_Wconversion
,
13146 ? G_("conversion to a reference to void "
13147 "will never use a type conversion operator")
13148 : G_("conversion to void "
13149 "will never use a type conversion operator"));
13150 else if (class_type
)
13152 if (t
== class_type
)
13153 warning (OPT_Wconversion
,
13155 ? G_("conversion to a reference to the same type "
13156 "will never use a type conversion operator")
13157 : G_("conversion to the same type "
13158 "will never use a type conversion operator"));
13159 /* Don't force t to be complete here. */
13160 else if (MAYBE_CLASS_TYPE_P (t
)
13161 && COMPLETE_TYPE_P (t
)
13162 && DERIVED_FROM_P (t
, class_type
))
13163 warning (OPT_Wconversion
,
13165 ? G_("conversion to a reference to a base class "
13166 "will never use a type conversion operator")
13167 : G_("conversion to a base class "
13168 "will never use a type conversion operator"));
13175 /* Effective C++ rules below. */
13177 /* More Effective C++ rule 7. */
13178 if (operator_code
== TRUTH_ANDIF_EXPR
13179 || operator_code
== TRUTH_ORIF_EXPR
13180 || operator_code
== COMPOUND_EXPR
)
13181 warning (OPT_Weffc__
,
13182 "user-defined %qD always evaluates both arguments", decl
);
13184 /* More Effective C++ rule 6. */
13185 if (operator_code
== POSTINCREMENT_EXPR
13186 || operator_code
== POSTDECREMENT_EXPR
13187 || operator_code
== PREINCREMENT_EXPR
13188 || operator_code
== PREDECREMENT_EXPR
)
13190 tree arg
= TREE_VALUE (argtypes
);
13191 tree ret
= TREE_TYPE (TREE_TYPE (decl
));
13192 if (methodp
|| TREE_CODE (arg
) == REFERENCE_TYPE
)
13193 arg
= TREE_TYPE (arg
);
13194 arg
= TYPE_MAIN_VARIANT (arg
);
13196 if (operator_code
== PREINCREMENT_EXPR
13197 || operator_code
== PREDECREMENT_EXPR
)
13199 if (TREE_CODE (ret
) != REFERENCE_TYPE
13200 || !same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (ret
)), arg
))
13201 warning (OPT_Weffc__
, "prefix %qD should return %qT", decl
,
13202 build_reference_type (arg
));
13206 if (!same_type_p (TYPE_MAIN_VARIANT (ret
), arg
))
13207 warning (OPT_Weffc__
, "postfix %qD should return %qT", decl
, arg
);
13211 /* Effective C++ rule 23. */
13212 if (!DECL_ASSIGNMENT_OPERATOR_P (decl
)
13213 && (operator_code
== PLUS_EXPR
13214 || operator_code
== MINUS_EXPR
13215 || operator_code
== TRUNC_DIV_EXPR
13216 || operator_code
== MULT_EXPR
13217 || operator_code
== TRUNC_MOD_EXPR
)
13218 && TREE_CODE (TREE_TYPE (TREE_TYPE (decl
))) == REFERENCE_TYPE
)
13219 warning (OPT_Weffc__
, "%qD should return by value", decl
);
13224 /* Return a string giving the keyword associate with CODE. */
13226 static const char *
13227 tag_name (enum tag_types code
)
13239 case typename_type
:
13242 gcc_unreachable ();
13246 /* Name lookup in an elaborated-type-specifier (after the keyword
13247 indicated by TAG_CODE) has found the TYPE_DECL DECL. If the
13248 elaborated-type-specifier is invalid, issue a diagnostic and return
13249 error_mark_node; otherwise, return the *_TYPE to which it referred.
13250 If ALLOW_TEMPLATE_P is true, TYPE may be a class template. */
13253 check_elaborated_type_specifier (enum tag_types tag_code
,
13255 bool allow_template_p
)
13261 struct S { struct S *p; };
13263 name lookup will find the TYPE_DECL for the implicit "S::S"
13264 typedef. Adjust for that here. */
13265 if (DECL_SELF_REFERENCE_P (decl
))
13266 decl
= TYPE_NAME (TREE_TYPE (decl
));
13268 type
= TREE_TYPE (decl
);
13270 /* Check TEMPLATE_TYPE_PARM first because DECL_IMPLICIT_TYPEDEF_P
13271 is false for this case as well. */
13272 if (TREE_CODE (type
) == TEMPLATE_TYPE_PARM
)
13274 error ("using template type parameter %qT after %qs",
13275 type
, tag_name (tag_code
));
13276 return error_mark_node
;
13278 /* Accept template template parameters. */
13279 else if (allow_template_p
13280 && (TREE_CODE (type
) == BOUND_TEMPLATE_TEMPLATE_PARM
13281 || TREE_CODE (type
) == TEMPLATE_TEMPLATE_PARM
))
13285 If the identifier resolves to a typedef-name or the
13286 simple-template-id resolves to an alias template
13287 specialization, the elaborated-type-specifier is ill-formed.
13289 In other words, the only legitimate declaration to use in the
13290 elaborated type specifier is the implicit typedef created when
13291 the type is declared. */
13292 else if (!DECL_IMPLICIT_TYPEDEF_P (decl
)
13293 && !DECL_SELF_REFERENCE_P (decl
)
13294 && tag_code
!= typename_type
)
13296 if (alias_template_specialization_p (type
))
13297 error ("using alias template specialization %qT after %qs",
13298 type
, tag_name (tag_code
));
13300 error ("using typedef-name %qD after %qs", decl
, tag_name (tag_code
));
13301 inform (DECL_SOURCE_LOCATION (decl
),
13302 "%qD has a previous declaration here", decl
);
13303 return error_mark_node
;
13305 else if (TREE_CODE (type
) != RECORD_TYPE
13306 && TREE_CODE (type
) != UNION_TYPE
13307 && tag_code
!= enum_type
13308 && tag_code
!= typename_type
)
13310 error ("%qT referred to as %qs", type
, tag_name (tag_code
));
13311 inform (location_of (type
), "%qT has a previous declaration here", type
);
13312 return error_mark_node
;
13314 else if (TREE_CODE (type
) != ENUMERAL_TYPE
13315 && tag_code
== enum_type
)
13317 error ("%qT referred to as enum", type
);
13318 inform (location_of (type
), "%qT has a previous declaration here", type
);
13319 return error_mark_node
;
13321 else if (!allow_template_p
13322 && TREE_CODE (type
) == RECORD_TYPE
13323 && CLASSTYPE_IS_TEMPLATE (type
))
13325 /* If a class template appears as elaborated type specifier
13326 without a template header such as:
13328 template <class T> class C {};
13329 void f(class C); // No template header here
13331 then the required template argument is missing. */
13332 error ("template argument required for %<%s %T%>",
13333 tag_name (tag_code
),
13334 DECL_NAME (CLASSTYPE_TI_TEMPLATE (type
)));
13335 return error_mark_node
;
13341 /* Lookup NAME in elaborate type specifier in scope according to
13342 SCOPE and issue diagnostics if necessary.
13343 Return *_TYPE node upon success, NULL_TREE when the NAME is not
13344 found, and ERROR_MARK_NODE for type error. */
13347 lookup_and_check_tag (enum tag_types tag_code
, tree name
,
13348 tag_scope scope
, bool template_header_p
)
13352 if (scope
== ts_global
)
13354 /* First try ordinary name lookup, ignoring hidden class name
13355 injected via friend declaration. */
13356 decl
= lookup_name_prefer_type (name
, 2);
13357 decl
= strip_using_decl (decl
);
13358 /* If that fails, the name will be placed in the smallest
13359 non-class, non-function-prototype scope according to 3.3.1/5.
13360 We may already have a hidden name declared as friend in this
13361 scope. So lookup again but not ignoring hidden names.
13362 If we find one, that name will be made visible rather than
13363 creating a new tag. */
13365 decl
= lookup_type_scope (name
, ts_within_enclosing_non_class
);
13368 decl
= lookup_type_scope (name
, scope
);
13371 && (DECL_CLASS_TEMPLATE_P (decl
)
13372 /* If scope is ts_current we're defining a class, so ignore a
13373 template template parameter. */
13374 || (scope
!= ts_current
13375 && DECL_TEMPLATE_TEMPLATE_PARM_P (decl
))))
13376 decl
= DECL_TEMPLATE_RESULT (decl
);
13378 if (decl
&& TREE_CODE (decl
) == TYPE_DECL
)
13380 /* Look for invalid nested type:
13384 if (scope
== ts_current
&& DECL_SELF_REFERENCE_P (decl
))
13386 error ("%qD has the same name as the class in which it is "
13389 return error_mark_node
;
13392 /* Two cases we need to consider when deciding if a class
13393 template is allowed as an elaborated type specifier:
13394 1. It is a self reference to its own class.
13395 2. It comes with a template header.
13399 template <class T> class C {
13400 class C *c1; // DECL_SELF_REFERENCE_P is true
13403 template <class U> class C; // template_header_p is true
13404 template <class T> class C<T>::D {
13405 class C *c2; // DECL_SELF_REFERENCE_P is true
13408 t
= check_elaborated_type_specifier (tag_code
,
13411 | DECL_SELF_REFERENCE_P (decl
));
13412 if (template_header_p
&& t
&& CLASS_TYPE_P (t
)
13413 && (!CLASSTYPE_TEMPLATE_INFO (t
)
13414 || (!PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (t
)))))
13416 error ("%qT is not a template", t
);
13417 inform (location_of (t
), "previous declaration here");
13418 if (TYPE_CLASS_SCOPE_P (t
)
13419 && CLASSTYPE_TEMPLATE_INFO (TYPE_CONTEXT (t
)))
13420 inform (input_location
,
13421 "perhaps you want to explicitly add %<%T::%>",
13423 t
= error_mark_node
;
13428 else if (decl
&& TREE_CODE (decl
) == TREE_LIST
)
13430 error ("reference to %qD is ambiguous", name
);
13431 print_candidates (decl
);
13432 return error_mark_node
;
13438 /* Get the struct, enum or union (TAG_CODE says which) with tag NAME.
13439 Define the tag as a forward-reference if it is not defined.
13441 If a declaration is given, process it here, and report an error if
13442 multiple declarations are not identical.
13444 SCOPE is TS_CURRENT when this is also a definition. Only look in
13445 the current frame for the name (since C++ allows new names in any
13446 scope.) It is TS_WITHIN_ENCLOSING_NON_CLASS if this is a friend
13447 declaration. Only look beginning from the current scope outward up
13448 till the nearest non-class scope. Otherwise it is TS_GLOBAL.
13450 TEMPLATE_HEADER_P is true when this declaration is preceded by
13451 a set of template parameters. */
13454 xref_tag_1 (enum tag_types tag_code
, tree name
,
13455 tag_scope scope
, bool template_header_p
)
13457 enum tree_code code
;
13458 tree context
= NULL_TREE
;
13460 gcc_assert (identifier_p (name
));
13466 code
= RECORD_TYPE
;
13472 code
= ENUMERAL_TYPE
;
13475 gcc_unreachable ();
13478 /* In case of anonymous name, xref_tag is only called to
13479 make type node and push name. Name lookup is not required. */
13480 tree t
= NULL_TREE
;
13481 if (scope
!= ts_lambda
&& !anon_aggrname_p (name
))
13482 t
= lookup_and_check_tag (tag_code
, name
, scope
, template_header_p
);
13484 if (t
== error_mark_node
)
13485 return error_mark_node
;
13487 if (scope
!= ts_current
&& t
&& current_class_type
13488 && template_class_depth (current_class_type
)
13489 && template_header_p
)
13491 if (TREE_CODE (t
) == TEMPLATE_TEMPLATE_PARM
)
13494 /* Since SCOPE is not TS_CURRENT, we are not looking at a
13495 definition of this tag. Since, in addition, we are currently
13496 processing a (member) template declaration of a template
13497 class, we must be very careful; consider:
13504 { template <class V>
13505 friend struct S1; };
13507 Here, the S2::S1 declaration should not be confused with the
13508 outer declaration. In particular, the inner version should
13509 have a template parameter of level 2, not level 1. This
13510 would be particularly important if the member declaration
13513 template <class V = U> friend struct S1;
13515 say, when we should tsubst into `U' when instantiating
13516 S2. On the other hand, when presented with:
13526 we must find the inner binding eventually. We
13527 accomplish this by making sure that the new type we
13528 create to represent this declaration has the right
13530 context
= TYPE_CONTEXT (t
);
13536 /* If no such tag is yet defined, create a forward-reference node
13537 and record it as the "definition".
13538 When a real declaration of this type is found,
13539 the forward-reference will be altered into a real type. */
13540 if (code
== ENUMERAL_TYPE
)
13542 error ("use of enum %q#D without previous declaration", name
);
13543 return error_mark_node
;
13547 t
= make_class_type (code
);
13548 TYPE_CONTEXT (t
) = context
;
13549 if (scope
== ts_lambda
)
13550 /* Mark it as a lambda type. */
13551 CLASSTYPE_LAMBDA_EXPR (t
) = error_mark_node
;
13552 t
= pushtag (name
, t
, scope
);
13557 if (template_header_p
&& MAYBE_CLASS_TYPE_P (t
))
13559 /* Check that we aren't trying to overload a class with different
13561 tree constr
= NULL_TREE
;
13562 if (current_template_parms
)
13564 tree reqs
= TEMPLATE_PARMS_CONSTRAINTS (current_template_parms
);
13565 constr
= build_constraints (reqs
, NULL_TREE
);
13567 if (!redeclare_class_template (t
, current_template_parms
, constr
))
13568 return error_mark_node
;
13570 else if (!processing_template_decl
13571 && CLASS_TYPE_P (t
)
13572 && CLASSTYPE_IS_TEMPLATE (t
))
13574 error ("redeclaration of %qT as a non-template", t
);
13575 inform (location_of (t
), "previous declaration %qD", t
);
13576 return error_mark_node
;
13579 /* Make injected friend class visible. */
13580 if (scope
!= ts_within_enclosing_non_class
&& TYPE_HIDDEN_P (t
))
13582 tree decl
= TYPE_NAME (t
);
13584 DECL_ANTICIPATED (decl
) = false;
13585 DECL_FRIEND_P (decl
) = false;
13587 if (TYPE_TEMPLATE_INFO (t
))
13589 tree tmpl
= TYPE_TI_TEMPLATE (t
);
13590 DECL_ANTICIPATED (tmpl
) = false;
13591 DECL_FRIEND_P (tmpl
) = false;
13599 /* Wrapper for xref_tag_1. */
13602 xref_tag (enum tag_types tag_code
, tree name
,
13603 tag_scope scope
, bool template_header_p
)
13607 subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
13608 ret
= xref_tag_1 (tag_code
, name
, scope
, template_header_p
);
13609 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
13615 xref_tag_from_type (tree old
, tree id
, tag_scope scope
)
13617 enum tag_types tag_kind
;
13619 if (TREE_CODE (old
) == RECORD_TYPE
)
13620 tag_kind
= (CLASSTYPE_DECLARED_CLASS (old
) ? class_type
: record_type
);
13622 tag_kind
= union_type
;
13624 if (id
== NULL_TREE
)
13625 id
= TYPE_IDENTIFIER (old
);
13627 return xref_tag (tag_kind
, id
, scope
, false);
13630 /* Create the binfo hierarchy for REF with (possibly NULL) base list
13631 BASE_LIST. For each element on BASE_LIST the TREE_PURPOSE is an
13632 access_* node, and the TREE_VALUE is the type of the base-class.
13633 Non-NULL TREE_TYPE indicates virtual inheritance. */
13636 xref_basetypes (tree ref
, tree base_list
)
13639 tree binfo
, base_binfo
;
13640 unsigned max_vbases
= 0; /* Maximum direct & indirect virtual bases. */
13641 unsigned max_bases
= 0; /* Maximum direct bases. */
13642 unsigned max_dvbases
= 0; /* Maximum direct virtual bases. */
13644 tree default_access
;
13645 tree igo_prev
; /* Track Inheritance Graph Order. */
13647 if (ref
== error_mark_node
)
13650 /* The base of a derived class is private by default, all others are
13652 default_access
= (TREE_CODE (ref
) == RECORD_TYPE
13653 && CLASSTYPE_DECLARED_CLASS (ref
)
13654 ? access_private_node
: access_public_node
);
13656 /* First, make sure that any templates in base-classes are
13657 instantiated. This ensures that if we call ourselves recursively
13658 we do not get confused about which classes are marked and which
13660 basep
= &base_list
;
13663 tree basetype
= TREE_VALUE (*basep
);
13665 /* The dependent_type_p call below should really be dependent_scope_p
13666 so that we give a hard error about using an incomplete type as a
13667 base, but we allow it with a pedwarn for backward
13669 if (processing_template_decl
13670 && CLASS_TYPE_P (basetype
) && TYPE_BEING_DEFINED (basetype
))
13671 cxx_incomplete_type_diagnostic (NULL_TREE
, basetype
, DK_PEDWARN
);
13672 if (!dependent_type_p (basetype
)
13673 && !complete_type_or_else (basetype
, NULL
))
13674 /* An incomplete type. Remove it from the list. */
13675 *basep
= TREE_CHAIN (*basep
);
13679 if (TREE_TYPE (*basep
))
13681 if (CLASS_TYPE_P (basetype
))
13682 max_vbases
+= vec_safe_length (CLASSTYPE_VBASECLASSES (basetype
));
13683 basep
= &TREE_CHAIN (*basep
);
13686 max_vbases
+= max_dvbases
;
13688 TYPE_MARKED_P (ref
) = 1;
13690 /* The binfo slot should be empty, unless this is an (ill-formed)
13692 gcc_assert (!TYPE_BINFO (ref
) || TYPE_SIZE (ref
));
13694 gcc_assert (TYPE_MAIN_VARIANT (ref
) == ref
);
13696 binfo
= make_tree_binfo (max_bases
);
13698 TYPE_BINFO (ref
) = binfo
;
13699 BINFO_OFFSET (binfo
) = size_zero_node
;
13700 BINFO_TYPE (binfo
) = ref
;
13702 /* Apply base-class info set up to the variants of this type. */
13703 fixup_type_variants (ref
);
13707 vec_alloc (BINFO_BASE_ACCESSES (binfo
), max_bases
);
13708 /* A C++98 POD cannot have base classes. */
13709 CLASSTYPE_NON_LAYOUT_POD_P (ref
) = true;
13711 if (TREE_CODE (ref
) == UNION_TYPE
)
13712 error ("derived union %qT invalid", ref
);
13716 warning (OPT_Wmultiple_inheritance
,
13717 "%qT defined with multiple direct bases", ref
);
13721 /* An aggregate can't have virtual base classes. */
13722 CLASSTYPE_NON_AGGREGATE (ref
) = true;
13724 vec_alloc (CLASSTYPE_VBASECLASSES (ref
), max_vbases
);
13727 warning (OPT_Wvirtual_inheritance
,
13728 "%qT defined with direct virtual base", ref
);
13731 for (igo_prev
= binfo
; base_list
; base_list
= TREE_CHAIN (base_list
))
13733 tree access
= TREE_PURPOSE (base_list
);
13734 int via_virtual
= TREE_TYPE (base_list
) != NULL_TREE
;
13735 tree basetype
= TREE_VALUE (base_list
);
13737 if (access
== access_default_node
)
13738 access
= default_access
;
13740 /* Before C++17, an aggregate cannot have base classes. In C++17, an
13741 aggregate can't have virtual, private, or protected base classes. */
13742 if (cxx_dialect
< cxx17
13743 || access
!= access_public_node
13745 CLASSTYPE_NON_AGGREGATE (ref
) = true;
13747 if (PACK_EXPANSION_P (basetype
))
13748 basetype
= PACK_EXPANSION_PATTERN (basetype
);
13749 if (TREE_CODE (basetype
) == TYPE_DECL
)
13750 basetype
= TREE_TYPE (basetype
);
13751 if (!MAYBE_CLASS_TYPE_P (basetype
) || TREE_CODE (basetype
) == UNION_TYPE
)
13753 error ("base type %qT fails to be a struct or class type",
13758 base_binfo
= NULL_TREE
;
13759 if (CLASS_TYPE_P (basetype
) && !dependent_scope_p (basetype
))
13761 base_binfo
= TYPE_BINFO (basetype
);
13762 /* The original basetype could have been a typedef'd type. */
13763 basetype
= BINFO_TYPE (base_binfo
);
13765 /* Inherit flags from the base. */
13766 TYPE_HAS_NEW_OPERATOR (ref
)
13767 |= TYPE_HAS_NEW_OPERATOR (basetype
);
13768 TYPE_HAS_ARRAY_NEW_OPERATOR (ref
)
13769 |= TYPE_HAS_ARRAY_NEW_OPERATOR (basetype
);
13770 TYPE_GETS_DELETE (ref
) |= TYPE_GETS_DELETE (basetype
);
13771 TYPE_HAS_CONVERSION (ref
) |= TYPE_HAS_CONVERSION (basetype
);
13772 CLASSTYPE_DIAMOND_SHAPED_P (ref
)
13773 |= CLASSTYPE_DIAMOND_SHAPED_P (basetype
);
13774 CLASSTYPE_REPEATED_BASE_P (ref
)
13775 |= CLASSTYPE_REPEATED_BASE_P (basetype
);
13778 /* We must do this test after we've seen through a typedef
13780 if (TYPE_MARKED_P (basetype
))
13782 if (basetype
== ref
)
13783 error ("recursive type %qT undefined", basetype
);
13785 error ("duplicate base type %qT invalid", basetype
);
13789 if (PACK_EXPANSION_P (TREE_VALUE (base_list
)))
13790 /* Regenerate the pack expansion for the bases. */
13791 basetype
= make_pack_expansion (basetype
);
13793 TYPE_MARKED_P (basetype
) = 1;
13795 base_binfo
= copy_binfo (base_binfo
, basetype
, ref
,
13796 &igo_prev
, via_virtual
);
13797 if (!BINFO_INHERITANCE_CHAIN (base_binfo
))
13798 BINFO_INHERITANCE_CHAIN (base_binfo
) = binfo
;
13800 BINFO_BASE_APPEND (binfo
, base_binfo
);
13801 BINFO_BASE_ACCESS_APPEND (binfo
, access
);
13805 /* Update max_vbases to reflect the reality that we are dropping
13806 this base: if it reaches zero we want to undo the vec_alloc
13807 above to avoid inconsistencies during error-recovery: eg, in
13808 build_special_member_call, CLASSTYPE_VBASECLASSES non null
13809 and vtt null (c++/27952). */
13812 if (CLASS_TYPE_P (basetype
))
13814 -= vec_safe_length (CLASSTYPE_VBASECLASSES (basetype
));
13817 if (CLASSTYPE_VBASECLASSES (ref
)
13818 && max_vbases
== 0)
13819 vec_free (CLASSTYPE_VBASECLASSES (ref
));
13821 if (vec_safe_length (CLASSTYPE_VBASECLASSES (ref
)) < max_vbases
)
13822 /* If we didn't get max_vbases vbases, we must have shared at
13823 least one of them, and are therefore diamond shaped. */
13824 CLASSTYPE_DIAMOND_SHAPED_P (ref
) = 1;
13826 /* Unmark all the types. */
13827 for (i
= 0; BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); i
++)
13828 TYPE_MARKED_P (BINFO_TYPE (base_binfo
)) = 0;
13829 TYPE_MARKED_P (ref
) = 0;
13831 /* Now see if we have a repeated base type. */
13832 if (!CLASSTYPE_REPEATED_BASE_P (ref
))
13834 for (base_binfo
= binfo
; base_binfo
;
13835 base_binfo
= TREE_CHAIN (base_binfo
))
13837 if (TYPE_MARKED_P (BINFO_TYPE (base_binfo
)))
13839 CLASSTYPE_REPEATED_BASE_P (ref
) = 1;
13842 TYPE_MARKED_P (BINFO_TYPE (base_binfo
)) = 1;
13844 for (base_binfo
= binfo
; base_binfo
;
13845 base_binfo
= TREE_CHAIN (base_binfo
))
13846 if (TYPE_MARKED_P (BINFO_TYPE (base_binfo
)))
13847 TYPE_MARKED_P (BINFO_TYPE (base_binfo
)) = 0;
13854 /* Copies the enum-related properties from type SRC to type DST.
13855 Used with the underlying type of an enum and the enum itself. */
13857 copy_type_enum (tree dst
, tree src
)
13860 for (t
= dst
; t
; t
= TYPE_NEXT_VARIANT (t
))
13862 TYPE_MIN_VALUE (t
) = TYPE_MIN_VALUE (src
);
13863 TYPE_MAX_VALUE (t
) = TYPE_MAX_VALUE (src
);
13864 TYPE_SIZE (t
) = TYPE_SIZE (src
);
13865 TYPE_SIZE_UNIT (t
) = TYPE_SIZE_UNIT (src
);
13866 SET_TYPE_MODE (dst
, TYPE_MODE (src
));
13867 TYPE_PRECISION (t
) = TYPE_PRECISION (src
);
13868 unsigned valign
= TYPE_ALIGN (src
);
13869 if (TYPE_USER_ALIGN (t
))
13870 valign
= MAX (valign
, TYPE_ALIGN (t
));
13872 TYPE_USER_ALIGN (t
) = TYPE_USER_ALIGN (src
);
13873 SET_TYPE_ALIGN (t
, valign
);
13874 TYPE_UNSIGNED (t
) = TYPE_UNSIGNED (src
);
13878 /* Begin compiling the definition of an enumeration type.
13881 if ENUMTYPE is not NULL_TREE then the type has alredy been found.
13883 UNDERLYING_TYPE is the type that will be used as the storage for
13884 the enumeration type. This should be NULL_TREE if no storage type
13887 ATTRIBUTES are any attributes specified after the enum-key.
13889 SCOPED_ENUM_P is true if this is a scoped enumeration type.
13891 if IS_NEW is not NULL, gets TRUE iff a new type is created.
13893 Returns the type object, as yet incomplete.
13894 Also records info about it so that build_enumerator
13895 may be used to declare the individual values as they are read. */
13898 start_enum (tree name
, tree enumtype
, tree underlying_type
,
13899 tree attributes
, bool scoped_enum_p
, bool *is_new
)
13901 tree prevtype
= NULL_TREE
;
13902 gcc_assert (identifier_p (name
));
13906 /* [C++0x dcl.enum]p5:
13908 If not explicitly specified, the underlying type of a scoped
13909 enumeration type is int. */
13910 if (!underlying_type
&& scoped_enum_p
)
13911 underlying_type
= integer_type_node
;
13913 if (underlying_type
)
13914 underlying_type
= cv_unqualified (underlying_type
);
13916 /* If this is the real definition for a previous forward reference,
13917 fill in the contents in the same object that used to be the
13918 forward reference. */
13920 enumtype
= lookup_and_check_tag (enum_type
, name
,
13921 /*tag_scope=*/ts_current
,
13922 /*template_header_p=*/false);
13924 /* In case of a template_decl, the only check that should be deferred
13925 to instantiation time is the comparison of underlying types. */
13926 if (enumtype
&& TREE_CODE (enumtype
) == ENUMERAL_TYPE
)
13928 if (scoped_enum_p
!= SCOPED_ENUM_P (enumtype
))
13930 error_at (input_location
, "scoped/unscoped mismatch "
13931 "in enum %q#T", enumtype
);
13932 inform (DECL_SOURCE_LOCATION (TYPE_MAIN_DECL (enumtype
)),
13933 "previous definition here");
13934 enumtype
= error_mark_node
;
13936 else if (ENUM_FIXED_UNDERLYING_TYPE_P (enumtype
) != !! underlying_type
)
13938 error_at (input_location
, "underlying type mismatch "
13939 "in enum %q#T", enumtype
);
13940 inform (DECL_SOURCE_LOCATION (TYPE_MAIN_DECL (enumtype
)),
13941 "previous definition here");
13942 enumtype
= error_mark_node
;
13944 else if (underlying_type
&& ENUM_UNDERLYING_TYPE (enumtype
)
13945 && !dependent_type_p (underlying_type
)
13946 && !dependent_type_p (ENUM_UNDERLYING_TYPE (enumtype
))
13947 && !same_type_p (underlying_type
,
13948 ENUM_UNDERLYING_TYPE (enumtype
)))
13950 error_at (input_location
, "different underlying type "
13951 "in enum %q#T", enumtype
);
13952 inform (DECL_SOURCE_LOCATION (TYPE_MAIN_DECL (enumtype
)),
13953 "previous definition here");
13954 underlying_type
= NULL_TREE
;
13958 if (!enumtype
|| TREE_CODE (enumtype
) != ENUMERAL_TYPE
13959 || processing_template_decl
)
13961 /* In case of error, make a dummy enum to allow parsing to
13963 if (enumtype
== error_mark_node
)
13965 name
= make_anon_name ();
13966 enumtype
= NULL_TREE
;
13969 /* enumtype may be an ENUMERAL_TYPE if this is a redefinition
13970 of an opaque enum, or an opaque enum of an already defined
13971 enumeration (C++0x only).
13972 In any other case, it'll be NULL_TREE. */
13978 prevtype
= enumtype
;
13980 /* Do not push the decl more than once, unless we need to
13981 compare underlying types at instantiation time */
13983 || TREE_CODE (enumtype
) != ENUMERAL_TYPE
13984 || (underlying_type
13985 && dependent_type_p (underlying_type
))
13986 || (ENUM_UNDERLYING_TYPE (enumtype
)
13987 && dependent_type_p (ENUM_UNDERLYING_TYPE (enumtype
))))
13989 enumtype
= cxx_make_type (ENUMERAL_TYPE
);
13990 enumtype
= pushtag (name
, enumtype
, /*tag_scope=*/ts_current
);
13992 /* std::byte aliases anything. */
13993 if (enumtype
!= error_mark_node
13994 && TYPE_CONTEXT (enumtype
) == std_node
13995 && !strcmp ("byte", TYPE_NAME_STRING (enumtype
)))
13996 TYPE_ALIAS_SET (enumtype
) = 0;
13999 enumtype
= xref_tag (enum_type
, name
, /*tag_scope=*/ts_current
,
14002 if (enumtype
== error_mark_node
)
14003 return error_mark_node
;
14005 /* The enum is considered opaque until the opening '{' of the
14006 enumerator list. */
14007 SET_OPAQUE_ENUM_P (enumtype
, true);
14008 ENUM_FIXED_UNDERLYING_TYPE_P (enumtype
) = !! underlying_type
;
14011 SET_SCOPED_ENUM_P (enumtype
, scoped_enum_p
);
14013 cplus_decl_attributes (&enumtype
, attributes
, (int)ATTR_FLAG_TYPE_IN_PLACE
);
14015 if (underlying_type
)
14017 if (ENUM_UNDERLYING_TYPE (enumtype
))
14018 /* We already checked that it matches, don't change it to a different
14019 typedef variant. */;
14020 else if (CP_INTEGRAL_TYPE_P (underlying_type
))
14022 copy_type_enum (enumtype
, underlying_type
);
14023 ENUM_UNDERLYING_TYPE (enumtype
) = underlying_type
;
14025 else if (dependent_type_p (underlying_type
))
14026 ENUM_UNDERLYING_TYPE (enumtype
) = underlying_type
;
14028 error ("underlying type %qT of %qT must be an integral type",
14029 underlying_type
, enumtype
);
14032 /* If into a template class, the returned enum is always the first
14033 declaration (opaque or not) seen. This way all the references to
14034 this type will be to the same declaration. The following ones are used
14035 only to check for definition errors. */
14036 if (prevtype
&& processing_template_decl
)
14042 /* After processing and defining all the values of an enumeration type,
14043 install their decls in the enumeration type.
14044 ENUMTYPE is the type object. */
14047 finish_enum_value_list (tree enumtype
)
14050 tree underlying_type
;
14053 tree minnode
, maxnode
;
14056 bool fixed_underlying_type_p
14057 = ENUM_UNDERLYING_TYPE (enumtype
) != NULL_TREE
;
14059 /* We built up the VALUES in reverse order. */
14060 TYPE_VALUES (enumtype
) = nreverse (TYPE_VALUES (enumtype
));
14062 /* For an enum defined in a template, just set the type of the values;
14063 all further processing is postponed until the template is
14064 instantiated. We need to set the type so that tsubst of a CONST_DECL
14066 if (processing_template_decl
)
14068 for (values
= TYPE_VALUES (enumtype
);
14070 values
= TREE_CHAIN (values
))
14071 TREE_TYPE (TREE_VALUE (values
)) = enumtype
;
14075 /* Determine the minimum and maximum values of the enumerators. */
14076 if (TYPE_VALUES (enumtype
))
14078 minnode
= maxnode
= NULL_TREE
;
14080 for (values
= TYPE_VALUES (enumtype
);
14082 values
= TREE_CHAIN (values
))
14084 decl
= TREE_VALUE (values
);
14086 /* [dcl.enum]: Following the closing brace of an enum-specifier,
14087 each enumerator has the type of its enumeration. Prior to the
14088 closing brace, the type of each enumerator is the type of its
14089 initializing value. */
14090 TREE_TYPE (decl
) = enumtype
;
14092 /* Update the minimum and maximum values, if appropriate. */
14093 value
= DECL_INITIAL (decl
);
14094 if (value
== error_mark_node
)
14095 value
= integer_zero_node
;
14096 /* Figure out what the minimum and maximum values of the
14097 enumerators are. */
14099 minnode
= maxnode
= value
;
14100 else if (tree_int_cst_lt (maxnode
, value
))
14102 else if (tree_int_cst_lt (value
, minnode
))
14109 If the enumerator-list is empty, the underlying type is as if
14110 the enumeration had a single enumerator with value 0. */
14111 minnode
= maxnode
= integer_zero_node
;
14113 if (!fixed_underlying_type_p
)
14115 /* Compute the number of bits require to represent all values of the
14116 enumeration. We must do this before the type of MINNODE and
14117 MAXNODE are transformed, since tree_int_cst_min_precision relies
14118 on the TREE_TYPE of the value it is passed. */
14119 signop sgn
= tree_int_cst_sgn (minnode
) >= 0 ? UNSIGNED
: SIGNED
;
14120 int lowprec
= tree_int_cst_min_precision (minnode
, sgn
);
14121 int highprec
= tree_int_cst_min_precision (maxnode
, sgn
);
14122 int precision
= MAX (lowprec
, highprec
);
14124 bool use_short_enum
;
14126 /* Determine the underlying type of the enumeration.
14130 The underlying type of an enumeration is an integral type that
14131 can represent all the enumerator values defined in the
14132 enumeration. It is implementation-defined which integral type is
14133 used as the underlying type for an enumeration except that the
14134 underlying type shall not be larger than int unless the value of
14135 an enumerator cannot fit in an int or unsigned int.
14137 We use "int" or an "unsigned int" as the underlying type, even if
14138 a smaller integral type would work, unless the user has
14139 explicitly requested that we use the smallest possible type. The
14140 user can request that for all enumerations with a command line
14141 flag, or for just one enumeration with an attribute. */
14143 use_short_enum
= flag_short_enums
14144 || lookup_attribute ("packed", TYPE_ATTRIBUTES (enumtype
));
14146 /* If the precision of the type was specified with an attribute and it
14147 was too small, give an error. Otherwise, use it. */
14148 if (TYPE_PRECISION (enumtype
))
14150 if (precision
> TYPE_PRECISION (enumtype
))
14151 error ("specified mode too small for enumeral values");
14154 use_short_enum
= true;
14155 precision
= TYPE_PRECISION (enumtype
);
14159 for (itk
= (use_short_enum
? itk_char
: itk_int
);
14163 underlying_type
= integer_types
[itk
];
14164 if (underlying_type
!= NULL_TREE
14165 && TYPE_PRECISION (underlying_type
) >= precision
14166 && TYPE_SIGN (underlying_type
) == sgn
)
14169 if (itk
== itk_none
)
14173 IF no integral type can represent all the enumerator values, the
14174 enumeration is ill-formed. */
14175 error ("no integral type can represent all of the enumerator values "
14176 "for %qT", enumtype
);
14177 precision
= TYPE_PRECISION (long_long_integer_type_node
);
14178 underlying_type
= integer_types
[itk_unsigned_long_long
];
14183 The value of sizeof() applied to an enumeration type, an object
14184 of an enumeration type, or an enumerator, is the value of sizeof()
14185 applied to the underlying type. */
14186 copy_type_enum (enumtype
, underlying_type
);
14188 /* Compute the minimum and maximum values for the type.
14192 For an enumeration where emin is the smallest enumerator and emax
14193 is the largest, the values of the enumeration are the values of the
14194 underlying type in the range bmin to bmax, where bmin and bmax are,
14195 respectively, the smallest and largest values of the smallest bit-
14196 field that can store emin and emax. */
14198 /* The middle-end currently assumes that types with TYPE_PRECISION
14199 narrower than their underlying type are suitably zero or sign
14200 extended to fill their mode. Similarly, it assumes that the front
14201 end assures that a value of a particular type must be within
14202 TYPE_MIN_VALUE and TYPE_MAX_VALUE.
14204 We used to set these fields based on bmin and bmax, but that led
14205 to invalid assumptions like optimizing away bounds checking. So
14206 now we just set the TYPE_PRECISION, TYPE_MIN_VALUE, and
14207 TYPE_MAX_VALUE to the values for the mode above and only restrict
14208 the ENUM_UNDERLYING_TYPE for the benefit of diagnostics. */
14209 ENUM_UNDERLYING_TYPE (enumtype
)
14210 = build_distinct_type_copy (underlying_type
);
14211 TYPE_PRECISION (ENUM_UNDERLYING_TYPE (enumtype
)) = precision
;
14212 set_min_and_max_values_for_integral_type
14213 (ENUM_UNDERLYING_TYPE (enumtype
), precision
, sgn
);
14215 /* If -fstrict-enums, still constrain TYPE_MIN/MAX_VALUE. */
14216 if (flag_strict_enums
)
14217 set_min_and_max_values_for_integral_type (enumtype
, precision
, sgn
);
14220 underlying_type
= ENUM_UNDERLYING_TYPE (enumtype
);
14222 /* Convert each of the enumerators to the type of the underlying
14223 type of the enumeration. */
14224 for (values
= TYPE_VALUES (enumtype
); values
; values
= TREE_CHAIN (values
))
14226 location_t saved_location
;
14228 decl
= TREE_VALUE (values
);
14229 saved_location
= input_location
;
14230 input_location
= DECL_SOURCE_LOCATION (decl
);
14231 if (fixed_underlying_type_p
)
14232 /* If the enumeration type has a fixed underlying type, we
14233 already checked all of the enumerator values. */
14234 value
= DECL_INITIAL (decl
);
14236 value
= perform_implicit_conversion (underlying_type
,
14237 DECL_INITIAL (decl
),
14238 tf_warning_or_error
);
14239 input_location
= saved_location
;
14241 /* Do not clobber shared ints. */
14242 if (value
!= error_mark_node
)
14244 value
= copy_node (value
);
14246 TREE_TYPE (value
) = enumtype
;
14248 DECL_INITIAL (decl
) = value
;
14251 /* Fix up all variant types of this enum type. */
14252 for (t
= TYPE_MAIN_VARIANT (enumtype
); t
; t
= TYPE_NEXT_VARIANT (t
))
14253 TYPE_VALUES (t
) = TYPE_VALUES (enumtype
);
14255 if (at_class_scope_p ()
14256 && COMPLETE_TYPE_P (current_class_type
)
14257 && UNSCOPED_ENUM_P (enumtype
))
14259 insert_late_enum_def_bindings (current_class_type
, enumtype
);
14260 /* TYPE_FIELDS needs fixup. */
14261 fixup_type_variants (current_class_type
);
14264 /* Finish debugging output for this type. */
14265 rest_of_type_compilation (enumtype
, namespace_bindings_p ());
14267 /* Each enumerator now has the type of its enumeration. Clear the cache
14268 so that this change in types doesn't confuse us later on. */
14269 clear_cv_and_fold_caches ();
14272 /* Finishes the enum type. This is called only the first time an
14273 enumeration is seen, be it opaque or odinary.
14274 ENUMTYPE is the type object. */
14277 finish_enum (tree enumtype
)
14279 if (processing_template_decl
)
14281 if (at_function_scope_p ())
14282 add_stmt (build_min (TAG_DEFN
, enumtype
));
14286 /* If this is a forward declaration, there should not be any variants,
14287 though we can get a variant in the middle of an enum-specifier with
14288 wacky code like 'enum E { e = sizeof(const E*) };' */
14289 gcc_assert (enumtype
== TYPE_MAIN_VARIANT (enumtype
)
14290 && (TYPE_VALUES (enumtype
)
14291 || !TYPE_NEXT_VARIANT (enumtype
)));
14294 /* Build and install a CONST_DECL for an enumeration constant of the
14295 enumeration type ENUMTYPE whose NAME and VALUE (if any) are provided.
14296 Apply ATTRIBUTES if available. LOC is the location of NAME.
14297 Assignment of sequential values by default is handled here. */
14300 build_enumerator (tree name
, tree value
, tree enumtype
, tree attributes
,
14307 /* scalar_constant_value will pull out this expression, so make sure
14308 it's folded as appropriate. */
14309 if (processing_template_decl
)
14310 value
= fold_non_dependent_expr (value
);
14312 /* If the VALUE was erroneous, pretend it wasn't there; that will
14313 result in the enum being assigned the next value in sequence. */
14314 if (value
== error_mark_node
)
14317 /* Remove no-op casts from the value. */
14319 STRIP_TYPE_NOPS (value
);
14321 if (! processing_template_decl
)
14323 /* Validate and default VALUE. */
14324 if (value
!= NULL_TREE
)
14326 if (!ENUM_UNDERLYING_TYPE (enumtype
))
14328 tree tmp_value
= build_expr_type_conversion (WANT_INT
| WANT_ENUM
,
14333 else if (! INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P
14334 (TREE_TYPE (value
)))
14335 value
= perform_implicit_conversion_flags
14336 (ENUM_UNDERLYING_TYPE (enumtype
), value
, tf_warning_or_error
,
14337 LOOKUP_IMPLICIT
| LOOKUP_NO_NARROWING
);
14339 if (value
== error_mark_node
)
14342 if (value
!= NULL_TREE
)
14344 if (! INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P
14345 (TREE_TYPE (value
)))
14347 error ("enumerator value for %qD must have integral or "
14348 "unscoped enumeration type", name
);
14353 value
= cxx_constant_value (value
);
14355 if (TREE_CODE (value
) != INTEGER_CST
)
14357 error ("enumerator value for %qD is not an integer "
14365 /* Default based on previous value. */
14366 if (value
== NULL_TREE
)
14368 if (TYPE_VALUES (enumtype
))
14373 /* C++03 7.2/4: If no initializer is specified for the first
14374 enumerator, the type is an unspecified integral
14375 type. Otherwise the type is the same as the type of the
14376 initializing value of the preceding enumerator unless the
14377 incremented value is not representable in that type, in
14378 which case the type is an unspecified integral type
14379 sufficient to contain the incremented value. */
14380 prev_value
= DECL_INITIAL (TREE_VALUE (TYPE_VALUES (enumtype
)));
14381 if (error_operand_p (prev_value
))
14382 value
= error_mark_node
;
14385 tree type
= TREE_TYPE (prev_value
);
14386 signop sgn
= TYPE_SIGN (type
);
14387 widest_int wi
= wi::add (wi::to_widest (prev_value
), 1, sgn
,
14391 bool pos
= !wi::neg_p (wi
, sgn
);
14392 if (!wi::fits_to_tree_p (wi
, type
))
14395 for (itk
= itk_int
; itk
!= itk_none
; itk
++)
14397 type
= integer_types
[itk
];
14398 if (type
!= NULL_TREE
14399 && (pos
|| !TYPE_UNSIGNED (type
))
14400 && wi::fits_to_tree_p (wi
, type
))
14403 if (type
&& cxx_dialect
< cxx11
14404 && itk
> itk_unsigned_long
)
14405 pedwarn (input_location
, OPT_Wlong_long
,
14407 incremented enumerator value is too large for %<unsigned long%>") : G_("\
14408 incremented enumerator value is too large for %<long%>"));
14410 if (type
== NULL_TREE
)
14413 value
= wide_int_to_tree (type
, wi
);
14418 error ("overflow in enumeration values at %qD", name
);
14419 value
= error_mark_node
;
14424 value
= integer_zero_node
;
14427 /* Remove no-op casts from the value. */
14428 STRIP_TYPE_NOPS (value
);
14430 /* If the underlying type of the enum is fixed, check whether
14431 the enumerator values fits in the underlying type. If it
14432 does not fit, the program is ill-formed [C++0x dcl.enum]. */
14433 if (ENUM_UNDERLYING_TYPE (enumtype
)
14435 && TREE_CODE (value
) == INTEGER_CST
)
14437 if (!int_fits_type_p (value
, ENUM_UNDERLYING_TYPE (enumtype
)))
14438 error ("enumerator value %qE is outside the range of underlying "
14439 "type %qT", value
, ENUM_UNDERLYING_TYPE (enumtype
));
14441 /* Convert the value to the appropriate type. */
14442 value
= fold_convert (ENUM_UNDERLYING_TYPE (enumtype
), value
);
14446 /* C++ associates enums with global, function, or class declarations. */
14447 context
= current_scope ();
14449 /* Build the actual enumeration constant. Note that the enumeration
14450 constants have the underlying type of the enum (if it is fixed)
14451 or the type of their initializer (if the underlying type of the
14452 enum is not fixed):
14456 If the underlying type is fixed, the type of each enumerator
14457 prior to the closing brace is the underlying type; if the
14458 initializing value of an enumerator cannot be represented by
14459 the underlying type, the program is ill-formed. If the
14460 underlying type is not fixed, the type of each enumerator is
14461 the type of its initializing value.
14463 If the underlying type is not fixed, it will be computed by
14464 finish_enum and we will reset the type of this enumerator. Of
14465 course, if we're processing a template, there may be no value. */
14466 type
= value
? TREE_TYPE (value
) : NULL_TREE
;
14468 decl
= build_decl (loc
, CONST_DECL
, name
, type
);
14470 DECL_CONTEXT (decl
) = enumtype
;
14471 TREE_CONSTANT (decl
) = 1;
14472 TREE_READONLY (decl
) = 1;
14473 DECL_INITIAL (decl
) = value
;
14476 cplus_decl_attributes (&decl
, attributes
, 0);
14478 if (context
&& context
== current_class_type
&& !SCOPED_ENUM_P (enumtype
))
14480 /* In something like `struct S { enum E { i = 7 }; };' we put `i'
14481 on the TYPE_FIELDS list for `S'. (That's so that you can say
14482 things like `S::i' later.) */
14484 /* The enumerator may be getting declared outside of its enclosing
14487 class S { public: enum E : int; }; enum S::E : int { i = 7; };
14489 For which case we need to make sure that the access of `S::i'
14490 matches the access of `S::E'. */
14491 tree saved_cas
= current_access_specifier
;
14492 if (TREE_PRIVATE (TYPE_NAME (enumtype
)))
14493 current_access_specifier
= access_private_node
;
14494 else if (TREE_PROTECTED (TYPE_NAME (enumtype
)))
14495 current_access_specifier
= access_protected_node
;
14497 current_access_specifier
= access_public_node
;
14499 finish_member_declaration (decl
);
14501 current_access_specifier
= saved_cas
;
14506 /* Add this enumeration constant to the list for this type. */
14507 TYPE_VALUES (enumtype
) = tree_cons (name
, decl
, TYPE_VALUES (enumtype
));
14510 /* Look for an enumerator with the given NAME within the enumeration
14511 type ENUMTYPE. This routine is used primarily for qualified name
14512 lookup into an enumerator in C++0x, e.g.,
14514 enum class Color { Red, Green, Blue };
14516 Color color = Color::Red;
14518 Returns the value corresponding to the enumerator, or
14519 NULL_TREE if no such enumerator was found. */
14521 lookup_enumerator (tree enumtype
, tree name
)
14524 gcc_assert (enumtype
&& TREE_CODE (enumtype
) == ENUMERAL_TYPE
);
14526 e
= purpose_member (name
, TYPE_VALUES (enumtype
));
14527 return e
? TREE_VALUE (e
) : NULL_TREE
;
14531 /* We're defining DECL. Make sure that its type is OK. */
14534 check_function_type (tree decl
, tree current_function_parms
)
14536 tree fntype
= TREE_TYPE (decl
);
14537 tree return_type
= complete_type (TREE_TYPE (fntype
));
14539 /* In a function definition, arg types must be complete. */
14540 require_complete_types_for_parms (current_function_parms
);
14542 if (dependent_type_p (return_type
)
14543 || type_uses_auto (return_type
))
14545 if (!COMPLETE_OR_VOID_TYPE_P (return_type
))
14547 tree args
= TYPE_ARG_TYPES (fntype
);
14549 error ("return type %q#T is incomplete", return_type
);
14551 /* Make it return void instead. */
14552 if (TREE_CODE (fntype
) == METHOD_TYPE
)
14553 fntype
= build_method_type_directly (TREE_TYPE (TREE_VALUE (args
)),
14555 TREE_CHAIN (args
));
14557 fntype
= build_function_type (void_type_node
, args
);
14559 = build_exception_variant (fntype
,
14560 TYPE_RAISES_EXCEPTIONS (TREE_TYPE (decl
)));
14561 fntype
= (cp_build_type_attribute_variant
14562 (fntype
, TYPE_ATTRIBUTES (TREE_TYPE (decl
))));
14563 TREE_TYPE (decl
) = fntype
;
14567 abstract_virtuals_error (decl
, TREE_TYPE (fntype
));
14568 maybe_warn_parm_abi (TREE_TYPE (fntype
),
14569 DECL_SOURCE_LOCATION (decl
));
14573 /* True iff FN is an implicitly-defined default constructor. */
14576 implicit_default_ctor_p (tree fn
)
14578 return (DECL_CONSTRUCTOR_P (fn
)
14579 && !user_provided_p (fn
)
14580 && sufficient_parms_p (FUNCTION_FIRST_USER_PARMTYPE (fn
)));
14583 /* Clobber the contents of *this to let the back end know that the object
14584 storage is dead when we enter the constructor or leave the destructor. */
14587 build_clobber_this ()
14589 /* Clobbering an empty base is pointless, and harmful if its one byte
14590 TYPE_SIZE overlays real data. */
14591 if (is_empty_class (current_class_type
))
14594 /* If we have virtual bases, clobber the whole object, but only if we're in
14595 charge. If we don't have virtual bases, clobber the as-base type so we
14596 don't mess with tail padding. */
14597 bool vbases
= CLASSTYPE_VBASECLASSES (current_class_type
);
14599 tree ctype
= current_class_type
;
14601 ctype
= CLASSTYPE_AS_BASE (ctype
);
14603 tree clobber
= build_constructor (ctype
, NULL
);
14604 TREE_THIS_VOLATILE (clobber
) = true;
14606 tree thisref
= current_class_ref
;
14607 if (ctype
!= current_class_type
)
14609 thisref
= build_nop (build_reference_type (ctype
), current_class_ptr
);
14610 thisref
= convert_from_reference (thisref
);
14613 tree exprstmt
= build2 (MODIFY_EXPR
, void_type_node
, thisref
, clobber
);
14615 exprstmt
= build_if_in_charge (exprstmt
);
14620 /* Create the FUNCTION_DECL for a function definition.
14621 DECLSPECS and DECLARATOR are the parts of the declaration;
14622 they describe the function's name and the type it returns,
14623 but twisted together in a fashion that parallels the syntax of C.
14625 FLAGS is a bitwise or of SF_PRE_PARSED (indicating that the
14626 DECLARATOR is really the DECL for the function we are about to
14627 process and that DECLSPECS should be ignored), SF_INCLASS_INLINE
14628 indicating that the function is an inline defined in-class.
14630 This function creates a binding context for the function body
14631 as well as setting up the FUNCTION_DECL in current_function_decl.
14633 For C++, we must first check whether that datum makes any sense.
14634 For example, "class A local_a(1,2);" means that variable local_a
14635 is an aggregate of type A, which should have a constructor
14636 applied to it with the argument list [1, 2].
14638 On entry, DECL_INITIAL (decl1) should be NULL_TREE or error_mark_node,
14639 or may be a BLOCK if the function has been defined previously
14640 in this translation unit. On exit, DECL_INITIAL (decl1) will be
14641 error_mark_node if the function has never been defined, or
14642 a BLOCK if the function has been defined somewhere. */
14645 start_preparsed_function (tree decl1
, tree attrs
, int flags
)
14647 tree ctype
= NULL_TREE
;
14650 int doing_friend
= 0;
14651 cp_binding_level
*bl
;
14652 tree current_function_parms
;
14653 struct c_fileinfo
*finfo
14654 = get_fileinfo (LOCATION_FILE (DECL_SOURCE_LOCATION (decl1
)));
14655 bool honor_interface
;
14657 /* Sanity check. */
14658 gcc_assert (VOID_TYPE_P (TREE_VALUE (void_list_node
)));
14659 gcc_assert (TREE_CHAIN (void_list_node
) == NULL_TREE
);
14661 fntype
= TREE_TYPE (decl1
);
14662 if (TREE_CODE (fntype
) == METHOD_TYPE
)
14663 ctype
= TYPE_METHOD_BASETYPE (fntype
);
14665 /* ISO C++ 11.4/5. A friend function defined in a class is in
14666 the (lexical) scope of the class in which it is defined. */
14667 if (!ctype
&& DECL_FRIEND_P (decl1
))
14669 ctype
= DECL_FRIEND_CONTEXT (decl1
);
14671 /* CTYPE could be null here if we're dealing with a template;
14672 for example, `inline friend float foo()' inside a template
14673 will have no CTYPE set. */
14674 if (ctype
&& TREE_CODE (ctype
) != RECORD_TYPE
)
14680 if (DECL_DECLARED_INLINE_P (decl1
)
14681 && lookup_attribute ("noinline", attrs
))
14682 warning_at (DECL_SOURCE_LOCATION (decl1
), 0,
14683 "inline function %qD given attribute noinline", decl1
);
14685 /* Handle gnu_inline attribute. */
14686 if (GNU_INLINE_P (decl1
))
14688 DECL_EXTERNAL (decl1
) = 1;
14689 DECL_NOT_REALLY_EXTERN (decl1
) = 0;
14690 DECL_INTERFACE_KNOWN (decl1
) = 1;
14691 DECL_DISREGARD_INLINE_LIMITS (decl1
) = 1;
14694 if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (decl1
))
14695 /* This is a constructor, we must ensure that any default args
14696 introduced by this definition are propagated to the clones
14697 now. The clones are used directly in overload resolution. */
14698 adjust_clone_args (decl1
);
14700 /* Sometimes we don't notice that a function is a static member, and
14701 build a METHOD_TYPE for it. Fix that up now. */
14702 gcc_assert (!(ctype
!= NULL_TREE
&& DECL_STATIC_FUNCTION_P (decl1
)
14703 && TREE_CODE (TREE_TYPE (decl1
)) == METHOD_TYPE
));
14705 /* Set up current_class_type, and enter the scope of the class, if
14708 push_nested_class (ctype
);
14709 else if (DECL_STATIC_FUNCTION_P (decl1
))
14710 push_nested_class (DECL_CONTEXT (decl1
));
14712 /* Now that we have entered the scope of the class, we must restore
14713 the bindings for any template parameters surrounding DECL1, if it
14714 is an inline member template. (Order is important; consider the
14715 case where a template parameter has the same name as a field of
14716 the class.) It is not until after this point that
14717 PROCESSING_TEMPLATE_DECL is guaranteed to be set up correctly. */
14718 if (flags
& SF_INCLASS_INLINE
)
14719 maybe_begin_member_template_processing (decl1
);
14721 /* Effective C++ rule 15. */
14723 && DECL_ASSIGNMENT_OPERATOR_P (decl1
)
14724 && DECL_OVERLOADED_OPERATOR_IS (decl1
, NOP_EXPR
)
14725 && VOID_TYPE_P (TREE_TYPE (fntype
)))
14726 warning (OPT_Weffc__
,
14727 "%<operator=%> should return a reference to %<*this%>");
14729 /* Make the init_value nonzero so pushdecl knows this is not tentative.
14730 error_mark_node is replaced below (in poplevel) with the BLOCK. */
14731 if (!DECL_INITIAL (decl1
))
14732 DECL_INITIAL (decl1
) = error_mark_node
;
14734 /* This function exists in static storage.
14735 (This does not mean `static' in the C sense!) */
14736 TREE_STATIC (decl1
) = 1;
14738 /* We must call push_template_decl after current_class_type is set
14739 up. (If we are processing inline definitions after exiting a
14740 class scope, current_class_type will be NULL_TREE until set above
14741 by push_nested_class.) */
14742 if (processing_template_decl
)
14744 tree newdecl1
= push_template_decl (decl1
);
14745 if (newdecl1
== error_mark_node
)
14747 if (ctype
|| DECL_STATIC_FUNCTION_P (decl1
))
14748 pop_nested_class ();
14754 /* Make sure the parameter and return types are reasonable. When
14755 you declare a function, these types can be incomplete, but they
14756 must be complete when you define the function. */
14757 check_function_type (decl1
, DECL_ARGUMENTS (decl1
));
14759 /* Build the return declaration for the function. */
14760 restype
= TREE_TYPE (fntype
);
14762 if (DECL_RESULT (decl1
) == NULL_TREE
)
14766 resdecl
= build_decl (input_location
, RESULT_DECL
, 0, restype
);
14767 DECL_ARTIFICIAL (resdecl
) = 1;
14768 DECL_IGNORED_P (resdecl
) = 1;
14769 DECL_RESULT (decl1
) = resdecl
;
14771 cp_apply_type_quals_to_decl (cp_type_quals (restype
), resdecl
);
14774 /* Record the decl so that the function name is defined.
14775 If we already have a decl for this name, and it is a FUNCTION_DECL,
14776 use the old decl. */
14777 if (!processing_template_decl
&& !(flags
& SF_PRE_PARSED
))
14779 /* A specialization is not used to guide overload resolution. */
14780 if (!DECL_FUNCTION_MEMBER_P (decl1
)
14781 && !(DECL_USE_TEMPLATE (decl1
) &&
14782 PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (decl1
))))
14784 tree olddecl
= pushdecl (decl1
);
14786 if (olddecl
== error_mark_node
)
14787 /* If something went wrong when registering the declaration,
14788 use DECL1; we have to have a FUNCTION_DECL to use when
14789 parsing the body of the function. */
14793 /* Otherwise, OLDDECL is either a previous declaration
14794 of the same function or DECL1 itself. */
14796 if (warn_missing_declarations
14797 && olddecl
== decl1
14798 && !DECL_MAIN_P (decl1
)
14799 && TREE_PUBLIC (decl1
)
14800 && !DECL_DECLARED_INLINE_P (decl1
))
14804 /* Check whether DECL1 is in an anonymous
14806 for (context
= DECL_CONTEXT (decl1
);
14808 context
= DECL_CONTEXT (context
))
14810 if (TREE_CODE (context
) == NAMESPACE_DECL
14811 && DECL_NAME (context
) == NULL_TREE
)
14815 if (context
== NULL
)
14816 warning_at (DECL_SOURCE_LOCATION (decl1
),
14817 OPT_Wmissing_declarations
,
14818 "no previous declaration for %qD", decl1
);
14826 /* We need to set the DECL_CONTEXT. */
14827 if (!DECL_CONTEXT (decl1
) && DECL_TEMPLATE_INFO (decl1
))
14828 DECL_CONTEXT (decl1
) = DECL_CONTEXT (DECL_TI_TEMPLATE (decl1
));
14830 fntype
= TREE_TYPE (decl1
);
14831 restype
= TREE_TYPE (fntype
);
14833 /* If #pragma weak applies, mark the decl appropriately now.
14834 The pragma only applies to global functions. Because
14835 determining whether or not the #pragma applies involves
14836 computing the mangled name for the declaration, we cannot
14837 apply the pragma until after we have merged this declaration
14838 with any previous declarations; if the original declaration
14839 has a linkage specification, that specification applies to
14840 the definition as well, and may affect the mangled name. */
14841 if (DECL_FILE_SCOPE_P (decl1
))
14842 maybe_apply_pragma_weak (decl1
);
14845 /* We are now in the scope of the function being defined. */
14846 current_function_decl
= decl1
;
14848 /* Save the parm names or decls from this function's declarator
14849 where store_parm_decls will find them. */
14850 current_function_parms
= DECL_ARGUMENTS (decl1
);
14852 /* Let the user know we're compiling this function. */
14853 announce_function (decl1
);
14855 gcc_assert (DECL_INITIAL (decl1
));
14857 /* This function may already have been parsed, in which case just
14858 return; our caller will skip over the body without parsing. */
14859 if (DECL_INITIAL (decl1
) != error_mark_node
)
14862 /* Initialize RTL machinery. We cannot do this until
14863 CURRENT_FUNCTION_DECL and DECL_RESULT are set up. We do this
14864 even when processing a template; this is how we get
14865 CFUN set up, and our per-function variables initialized.
14866 FIXME factor out the non-RTL stuff. */
14867 bl
= current_binding_level
;
14868 allocate_struct_function (decl1
, processing_template_decl
);
14870 /* Initialize the language data structures. Whenever we start
14871 a new function, we destroy temporaries in the usual way. */
14872 cfun
->language
= ggc_cleared_alloc
<language_function
> ();
14873 current_stmt_tree ()->stmts_are_full_exprs_p
= 1;
14874 current_binding_level
= bl
;
14876 if (!processing_template_decl
&& type_uses_auto (restype
))
14878 FNDECL_USED_AUTO (decl1
) = true;
14879 current_function_auto_return_pattern
= restype
;
14882 /* Start the statement-tree, start the tree now. */
14883 DECL_SAVED_TREE (decl1
) = push_stmt_list ();
14885 /* If we are (erroneously) defining a function that we have already
14886 defined before, wipe out what we knew before. */
14887 if (!DECL_PENDING_INLINE_P (decl1
))
14888 DECL_SAVED_FUNCTION_DATA (decl1
) = NULL
;
14890 if (ctype
&& !doing_friend
&& !DECL_STATIC_FUNCTION_P (decl1
))
14892 /* We know that this was set up by `grokclassfn'. We do not
14893 wait until `store_parm_decls', since evil parse errors may
14894 never get us to that point. Here we keep the consistency
14895 between `current_class_type' and `current_class_ptr'. */
14896 tree t
= DECL_ARGUMENTS (decl1
);
14898 gcc_assert (t
!= NULL_TREE
&& TREE_CODE (t
) == PARM_DECL
);
14899 gcc_assert (TYPE_PTR_P (TREE_TYPE (t
)));
14901 cp_function_chain
->x_current_class_ref
14902 = cp_build_indirect_ref (t
, RO_NULL
, tf_warning_or_error
);
14903 /* Set this second to avoid shortcut in cp_build_indirect_ref. */
14904 cp_function_chain
->x_current_class_ptr
= t
;
14906 /* Constructors and destructors need to know whether they're "in
14907 charge" of initializing virtual base classes. */
14908 t
= DECL_CHAIN (t
);
14909 if (DECL_HAS_IN_CHARGE_PARM_P (decl1
))
14911 current_in_charge_parm
= t
;
14912 t
= DECL_CHAIN (t
);
14914 if (DECL_HAS_VTT_PARM_P (decl1
))
14916 gcc_assert (DECL_NAME (t
) == vtt_parm_identifier
);
14917 current_vtt_parm
= t
;
14921 honor_interface
= (!DECL_TEMPLATE_INSTANTIATION (decl1
)
14922 /* Implicitly-defined methods (like the
14923 destructor for a class in which no destructor
14924 is explicitly declared) must not be defined
14925 until their definition is needed. So, we
14926 ignore interface specifications for
14927 compiler-generated functions. */
14928 && !DECL_ARTIFICIAL (decl1
));
14930 if (processing_template_decl
)
14931 /* Don't mess with interface flags. */;
14932 else if (DECL_INTERFACE_KNOWN (decl1
))
14934 tree ctx
= decl_function_context (decl1
);
14936 if (DECL_NOT_REALLY_EXTERN (decl1
))
14937 DECL_EXTERNAL (decl1
) = 0;
14939 if (ctx
!= NULL_TREE
&& vague_linkage_p (ctx
))
14940 /* This is a function in a local class in an extern inline
14941 or template function. */
14942 comdat_linkage (decl1
);
14944 /* If this function belongs to an interface, it is public.
14945 If it belongs to someone else's interface, it is also external.
14946 This only affects inlines and template instantiations. */
14947 else if (!finfo
->interface_unknown
&& honor_interface
)
14949 if (DECL_DECLARED_INLINE_P (decl1
)
14950 || DECL_TEMPLATE_INSTANTIATION (decl1
))
14952 DECL_EXTERNAL (decl1
)
14953 = (finfo
->interface_only
14954 || (DECL_DECLARED_INLINE_P (decl1
)
14955 && ! flag_implement_inlines
14956 && !DECL_VINDEX (decl1
)));
14958 /* For WIN32 we also want to put these in linkonce sections. */
14959 maybe_make_one_only (decl1
);
14962 DECL_EXTERNAL (decl1
) = 0;
14963 DECL_INTERFACE_KNOWN (decl1
) = 1;
14964 /* If this function is in an interface implemented in this file,
14965 make sure that the back end knows to emit this function
14967 if (!DECL_EXTERNAL (decl1
))
14968 mark_needed (decl1
);
14970 else if (finfo
->interface_unknown
&& finfo
->interface_only
14971 && honor_interface
)
14973 /* If MULTIPLE_SYMBOL_SPACES is defined and we saw a #pragma
14974 interface, we will have both finfo->interface_unknown and
14975 finfo->interface_only set. In that case, we don't want to
14976 use the normal heuristics because someone will supply a
14977 #pragma implementation elsewhere, and deducing it here would
14978 produce a conflict. */
14979 comdat_linkage (decl1
);
14980 DECL_EXTERNAL (decl1
) = 0;
14981 DECL_INTERFACE_KNOWN (decl1
) = 1;
14982 DECL_DEFER_OUTPUT (decl1
) = 1;
14986 /* This is a definition, not a reference.
14987 So clear DECL_EXTERNAL, unless this is a GNU extern inline. */
14988 if (!GNU_INLINE_P (decl1
))
14989 DECL_EXTERNAL (decl1
) = 0;
14991 if ((DECL_DECLARED_INLINE_P (decl1
)
14992 || DECL_TEMPLATE_INSTANTIATION (decl1
))
14993 && ! DECL_INTERFACE_KNOWN (decl1
))
14994 DECL_DEFER_OUTPUT (decl1
) = 1;
14996 DECL_INTERFACE_KNOWN (decl1
) = 1;
14999 /* Determine the ELF visibility attribute for the function. We must not
15000 do this before calling "pushdecl", as we must allow "duplicate_decls"
15001 to merge any attributes appropriately. We also need to wait until
15003 if (!DECL_CLONED_FUNCTION_P (decl1
))
15004 determine_visibility (decl1
);
15006 if (!processing_template_decl
)
15007 maybe_instantiate_noexcept (decl1
);
15009 begin_scope (sk_function_parms
, decl1
);
15013 if (DECL_DESTRUCTOR_P (decl1
)
15014 || (DECL_CONSTRUCTOR_P (decl1
)
15015 && targetm
.cxx
.cdtor_returns_this ()))
15017 cdtor_label
= create_artificial_label (input_location
);
15018 LABEL_DECL_CDTOR (cdtor_label
) = true;
15021 start_fname_decls ();
15023 store_parm_decls (current_function_parms
);
15025 if (!processing_template_decl
15026 && (flag_lifetime_dse
> 1)
15027 && DECL_CONSTRUCTOR_P (decl1
)
15028 && !DECL_CLONED_FUNCTION_P (decl1
)
15029 /* Clobbering an empty base is harmful if it overlays real data. */
15030 && !is_empty_class (current_class_type
)
15031 /* We can't clobber safely for an implicitly-defined default constructor
15032 because part of the initialization might happen before we enter the
15033 constructor, via AGGR_INIT_ZERO_FIRST (c++/68006). */
15034 && !implicit_default_ctor_p (decl1
))
15035 finish_expr_stmt (build_clobber_this ());
15037 if (!processing_template_decl
15038 && DECL_CONSTRUCTOR_P (decl1
)
15039 && sanitize_flags_p (SANITIZE_VPTR
)
15040 && !DECL_CLONED_FUNCTION_P (decl1
)
15041 && !implicit_default_ctor_p (decl1
))
15042 cp_ubsan_maybe_initialize_vtbl_ptrs (current_class_ptr
);
15044 start_lambda_scope (decl1
);
15050 /* Like start_preparsed_function, except that instead of a
15051 FUNCTION_DECL, this function takes DECLSPECS and DECLARATOR.
15053 Returns true on success. If the DECLARATOR is not suitable
15054 for a function, we return false, which tells the parser to
15055 skip the entire function. */
15058 start_function (cp_decl_specifier_seq
*declspecs
,
15059 const cp_declarator
*declarator
,
15064 decl1
= grokdeclarator (declarator
, declspecs
, FUNCDEF
, 1, &attrs
);
15065 invoke_plugin_callbacks (PLUGIN_START_PARSE_FUNCTION
, decl1
);
15066 if (decl1
== error_mark_node
)
15068 /* If the declarator is not suitable for a function definition,
15069 cause a syntax error. */
15070 if (decl1
== NULL_TREE
|| TREE_CODE (decl1
) != FUNCTION_DECL
)
15072 error ("invalid function declaration");
15076 if (DECL_MAIN_P (decl1
))
15077 /* main must return int. grokfndecl should have corrected it
15078 (and issued a diagnostic) if the user got it wrong. */
15079 gcc_assert (same_type_p (TREE_TYPE (TREE_TYPE (decl1
)),
15080 integer_type_node
));
15082 return start_preparsed_function (decl1
, attrs
, /*flags=*/SF_DEFAULT
);
15085 /* Returns true iff an EH_SPEC_BLOCK should be created in the body of
15089 use_eh_spec_block (tree fn
)
15091 return (flag_exceptions
&& flag_enforce_eh_specs
15092 && !processing_template_decl
15093 && !type_throw_all_p (TREE_TYPE (fn
))
15094 /* We insert the EH_SPEC_BLOCK only in the original
15095 function; then, it is copied automatically to the
15097 && !DECL_CLONED_FUNCTION_P (fn
)
15098 /* Implicitly-generated constructors and destructors have
15099 exception specifications. However, those specifications
15100 are the union of the possible exceptions specified by the
15101 constructors/destructors for bases and members, so no
15102 unallowed exception will ever reach this function. By
15103 not creating the EH_SPEC_BLOCK we save a little memory,
15104 and we avoid spurious warnings about unreachable
15106 && !DECL_DEFAULTED_FN (fn
));
15109 /* Store the parameter declarations into the current function declaration.
15110 This is called after parsing the parameter declarations, before
15111 digesting the body of the function.
15113 Also install to binding contour return value identifier, if any. */
15116 store_parm_decls (tree current_function_parms
)
15118 tree fndecl
= current_function_decl
;
15121 /* This is a chain of any other decls that came in among the parm
15122 declarations. If a parm is declared with enum {foo, bar} x;
15123 then CONST_DECLs for foo and bar are put here. */
15124 tree nonparms
= NULL_TREE
;
15126 if (current_function_parms
)
15128 /* This case is when the function was defined with an ANSI prototype.
15129 The parms already have decls, so we need not do anything here
15130 except record them as in effect
15131 and complain if any redundant old-style parm decls were written. */
15133 tree specparms
= current_function_parms
;
15136 /* Must clear this because it might contain TYPE_DECLs declared
15138 current_binding_level
->names
= NULL
;
15140 /* If we're doing semantic analysis, then we'll call pushdecl
15141 for each of these. We must do them in reverse order so that
15142 they end in the correct forward order. */
15143 specparms
= nreverse (specparms
);
15145 for (parm
= specparms
; parm
; parm
= next
)
15147 next
= DECL_CHAIN (parm
);
15148 if (TREE_CODE (parm
) == PARM_DECL
)
15152 /* If we find an enum constant or a type tag,
15153 put it aside for the moment. */
15154 TREE_CHAIN (parm
) = NULL_TREE
;
15155 nonparms
= chainon (nonparms
, parm
);
15159 /* Get the decls in their original chain order and record in the
15160 function. This is all and only the PARM_DECLs that were
15161 pushed into scope by the loop above. */
15162 DECL_ARGUMENTS (fndecl
) = get_local_decls ();
15165 DECL_ARGUMENTS (fndecl
) = NULL_TREE
;
15167 /* Now store the final chain of decls for the arguments
15168 as the decl-chain of the current lexical scope.
15169 Put the enumerators in as well, at the front so that
15170 DECL_ARGUMENTS is not modified. */
15171 current_binding_level
->names
= chainon (nonparms
, DECL_ARGUMENTS (fndecl
));
15173 if (use_eh_spec_block (current_function_decl
))
15174 current_eh_spec_block
= begin_eh_spec_block ();
15178 /* We have finished doing semantic analysis on DECL, but have not yet
15179 generated RTL for its body. Save away our current state, so that
15180 when we want to generate RTL later we know what to do. */
15183 save_function_data (tree decl
)
15185 struct language_function
*f
;
15187 /* Save the language-specific per-function data so that we can
15188 get it back when we really expand this function. */
15189 gcc_assert (!DECL_PENDING_INLINE_P (decl
));
15192 f
= ggc_alloc
<language_function
> ();
15193 memcpy (f
, cp_function_chain
, sizeof (struct language_function
));
15194 DECL_SAVED_FUNCTION_DATA (decl
) = f
;
15196 /* Clear out the bits we don't need. */
15197 f
->base
.x_stmt_tree
.x_cur_stmt_list
= NULL
;
15198 f
->bindings
= NULL
;
15199 f
->x_local_names
= NULL
;
15200 f
->base
.local_typedefs
= NULL
;
15204 /* Set the return value of the constructor (if present). */
15207 finish_constructor_body (void)
15212 if (targetm
.cxx
.cdtor_returns_this ())
15214 /* Any return from a constructor will end up here. */
15215 add_stmt (build_stmt (input_location
, LABEL_EXPR
, cdtor_label
));
15217 val
= DECL_ARGUMENTS (current_function_decl
);
15218 val
= build2 (MODIFY_EXPR
, TREE_TYPE (val
),
15219 DECL_RESULT (current_function_decl
), val
);
15220 /* Return the address of the object. */
15221 exprstmt
= build_stmt (input_location
, RETURN_EXPR
, val
);
15222 add_stmt (exprstmt
);
15226 /* Do all the processing for the beginning of a destructor; set up the
15227 vtable pointers and cleanups for bases and members. */
15230 begin_destructor_body (void)
15232 tree compound_stmt
;
15234 /* If the CURRENT_CLASS_TYPE is incomplete, we will have already
15235 issued an error message. We still want to try to process the
15236 body of the function, but initialize_vtbl_ptrs will crash if
15237 TYPE_BINFO is NULL. */
15238 if (COMPLETE_TYPE_P (current_class_type
))
15240 compound_stmt
= begin_compound_stmt (0);
15241 /* Make all virtual function table pointers in non-virtual base
15242 classes point to CURRENT_CLASS_TYPE's virtual function
15244 initialize_vtbl_ptrs (current_class_ptr
);
15245 finish_compound_stmt (compound_stmt
);
15247 if (flag_lifetime_dse
15248 /* Clobbering an empty base is harmful if it overlays real data. */
15249 && !is_empty_class (current_class_type
))
15250 finish_decl_cleanup (NULL_TREE
, build_clobber_this ());
15252 /* And insert cleanups for our bases and members so that they
15253 will be properly destroyed if we throw. */
15254 push_base_cleanups ();
15258 /* At the end of every destructor we generate code to delete the object if
15259 necessary. Do that now. */
15262 finish_destructor_body (void)
15266 /* Any return from a destructor will end up here; that way all base
15267 and member cleanups will be run when the function returns. */
15268 add_stmt (build_stmt (input_location
, LABEL_EXPR
, cdtor_label
));
15270 if (targetm
.cxx
.cdtor_returns_this ())
15274 val
= DECL_ARGUMENTS (current_function_decl
);
15275 val
= build2 (MODIFY_EXPR
, TREE_TYPE (val
),
15276 DECL_RESULT (current_function_decl
), val
);
15277 /* Return the address of the object. */
15278 exprstmt
= build_stmt (input_location
, RETURN_EXPR
, val
);
15279 add_stmt (exprstmt
);
15283 /* Do the necessary processing for the beginning of a function body, which
15284 in this case includes member-initializers, but not the catch clauses of
15285 a function-try-block. Currently, this means opening a binding level
15286 for the member-initializers (in a ctor), member cleanups (in a dtor),
15287 and capture proxies (in a lambda operator()). */
15290 begin_function_body (void)
15294 if (! FUNCTION_NEEDS_BODY_BLOCK (current_function_decl
))
15297 if (processing_template_decl
)
15298 /* Do nothing now. */;
15300 /* Always keep the BLOCK node associated with the outermost pair of
15301 curly braces of a function. These are needed for correct
15302 operation of dwarfout.c. */
15303 keep_next_level (true);
15305 stmt
= begin_compound_stmt (BCS_FN_BODY
);
15307 if (processing_template_decl
)
15308 /* Do nothing now. */;
15309 else if (DECL_DESTRUCTOR_P (current_function_decl
))
15310 begin_destructor_body ();
15315 /* Do the processing for the end of a function body. Currently, this means
15316 closing out the cleanups for fully-constructed bases and members, and in
15317 the case of the destructor, deleting the object if desired. Again, this
15318 is only meaningful for [cd]tors, since they are the only functions where
15319 there is a significant distinction between the main body and any
15320 function catch clauses. Handling, say, main() return semantics here
15321 would be wrong, as flowing off the end of a function catch clause for
15322 main() would also need to return 0. */
15325 finish_function_body (tree compstmt
)
15327 if (compstmt
== NULL_TREE
)
15330 /* Close the block. */
15331 finish_compound_stmt (compstmt
);
15333 if (processing_template_decl
)
15334 /* Do nothing now. */;
15335 else if (DECL_CONSTRUCTOR_P (current_function_decl
))
15336 finish_constructor_body ();
15337 else if (DECL_DESTRUCTOR_P (current_function_decl
))
15338 finish_destructor_body ();
15341 /* Given a function, returns the BLOCK corresponding to the outermost level
15342 of curly braces, skipping the artificial block created for constructor
15346 outer_curly_brace_block (tree fndecl
)
15348 tree block
= DECL_INITIAL (fndecl
);
15349 if (BLOCK_OUTER_CURLY_BRACE_P (block
))
15351 block
= BLOCK_SUBBLOCKS (block
);
15352 if (BLOCK_OUTER_CURLY_BRACE_P (block
))
15354 block
= BLOCK_SUBBLOCKS (block
);
15355 gcc_assert (BLOCK_OUTER_CURLY_BRACE_P (block
));
15359 /* If FNDECL is a class's key method, add the class to the list of
15360 keyed classes that should be emitted. */
15363 record_key_method_defined (tree fndecl
)
15365 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fndecl
)
15366 && DECL_VIRTUAL_P (fndecl
)
15367 && !processing_template_decl
)
15369 tree fnclass
= DECL_CONTEXT (fndecl
);
15370 if (fndecl
== CLASSTYPE_KEY_METHOD (fnclass
))
15371 vec_safe_push (keyed_classes
, fnclass
);
15375 /* Subroutine of finish_function.
15376 Save the body of constexpr functions for possible
15377 future compile time evaluation. */
15380 maybe_save_function_definition (tree fun
)
15382 if (!processing_template_decl
15383 && DECL_DECLARED_CONSTEXPR_P (fun
)
15384 && !cp_function_chain
->invalid_constexpr
15385 && !DECL_CLONED_FUNCTION_P (fun
))
15386 register_constexpr_fundef (fun
, DECL_SAVED_TREE (fun
));
15389 /* Finish up a function declaration and compile that function
15390 all the way to assembler language output. The free the storage
15391 for the function definition. INLINE_P is TRUE if we just
15392 finished processing the body of an in-class inline function
15393 definition. (This processing will have taken place after the
15394 class definition is complete.) */
15397 finish_function (bool inline_p
)
15399 tree fndecl
= current_function_decl
;
15400 tree fntype
, ctype
= NULL_TREE
;
15402 /* When we get some parse errors, we can end up without a
15403 current_function_decl, so cope. */
15404 if (fndecl
== NULL_TREE
)
15405 return error_mark_node
;
15407 finish_lambda_scope ();
15409 if (c_dialect_objc ())
15410 objc_finish_function ();
15412 record_key_method_defined (fndecl
);
15414 fntype
= TREE_TYPE (fndecl
);
15416 /* TREE_READONLY (fndecl) = 1;
15417 This caused &foo to be of type ptr-to-const-function
15418 which then got a warning when stored in a ptr-to-function variable. */
15420 gcc_assert (building_stmt_list_p ());
15421 /* The current function is being defined, so its DECL_INITIAL should
15422 be set, and unless there's a multiple definition, it should be
15423 error_mark_node. */
15424 gcc_assert (DECL_INITIAL (fndecl
) == error_mark_node
);
15426 /* For a cloned function, we've already got all the code we need;
15427 there's no need to add any extra bits. */
15428 if (!DECL_CLONED_FUNCTION_P (fndecl
))
15430 /* Make it so that `main' always returns 0 by default. */
15431 if (DECL_MAIN_P (current_function_decl
))
15432 finish_return_stmt (integer_zero_node
);
15434 if (use_eh_spec_block (current_function_decl
))
15435 finish_eh_spec_block (TYPE_RAISES_EXCEPTIONS
15436 (TREE_TYPE (current_function_decl
)),
15437 current_eh_spec_block
);
15440 /* If we're saving up tree structure, tie off the function now. */
15441 DECL_SAVED_TREE (fndecl
) = pop_stmt_list (DECL_SAVED_TREE (fndecl
));
15443 if (fn_contains_cilk_spawn_p (cfun
) && !processing_template_decl
)
15444 cfun
->cilk_frame_decl
= insert_cilk_frame (fndecl
);
15446 finish_fname_decls ();
15448 /* If this function can't throw any exceptions, remember that. */
15449 if (!processing_template_decl
15450 && !cp_function_chain
->can_throw
15451 && !flag_non_call_exceptions
15452 && !decl_replaceable_p (fndecl
))
15453 TREE_NOTHROW (fndecl
) = 1;
15455 /* This must come after expand_function_end because cleanups might
15456 have declarations (from inline functions) that need to go into
15457 this function's blocks. */
15459 /* If the current binding level isn't the outermost binding level
15460 for this function, either there is a bug, or we have experienced
15461 syntax errors and the statement tree is malformed. */
15462 if (current_binding_level
->kind
!= sk_function_parms
)
15464 /* Make sure we have already experienced errors. */
15465 gcc_assert (errorcount
);
15467 /* Throw away the broken statement tree and extra binding
15469 DECL_SAVED_TREE (fndecl
) = alloc_stmt_list ();
15471 while (current_binding_level
->kind
!= sk_function_parms
)
15473 if (current_binding_level
->kind
== sk_class
)
15474 pop_nested_class ();
15476 poplevel (0, 0, 0);
15479 poplevel (1, 0, 1);
15481 /* Statements should always be full-expressions at the outermost set
15482 of curly braces for a function. */
15483 gcc_assert (stmts_are_full_exprs_p ());
15485 /* If there are no return statements in a function with auto return type,
15486 the return type is void. But if the declared type is something like
15487 auto*, this is an error. */
15488 if (!processing_template_decl
&& FNDECL_USED_AUTO (fndecl
)
15489 && TREE_TYPE (fntype
) == current_function_auto_return_pattern
)
15491 if (is_auto (current_function_auto_return_pattern
))
15493 apply_deduced_return_type (fndecl
, void_type_node
);
15494 fntype
= TREE_TYPE (fndecl
);
15496 else if (!current_function_returns_value
15497 && !current_function_returns_null
)
15499 error ("no return statements in function returning %qT",
15500 current_function_auto_return_pattern
);
15501 inform (input_location
, "only plain %<auto%> return type can be "
15502 "deduced to %<void%>");
15506 // If this is a concept, check that the definition is reasonable.
15507 if (DECL_DECLARED_CONCEPT_P (fndecl
))
15508 check_function_concept (fndecl
);
15510 /* Lambda closure members are implicitly constexpr if possible. */
15511 if (cxx_dialect
>= cxx17
15512 && LAMBDA_TYPE_P (CP_DECL_CONTEXT (fndecl
)))
15513 DECL_DECLARED_CONSTEXPR_P (fndecl
)
15514 = ((processing_template_decl
15515 || is_valid_constexpr_fn (fndecl
, /*complain*/false))
15516 && potential_constant_expression (DECL_SAVED_TREE (fndecl
)));
15518 /* Save constexpr function body before it gets munged by
15519 the NRV transformation. */
15520 maybe_save_function_definition (fndecl
);
15522 /* Invoke the pre-genericize plugin before we start munging things. */
15523 if (!processing_template_decl
)
15524 invoke_plugin_callbacks (PLUGIN_PRE_GENERICIZE
, fndecl
);
15526 /* Perform delayed folding before NRV transformation. */
15527 if (!processing_template_decl
)
15528 cp_fold_function (fndecl
);
15530 /* Set up the named return value optimization, if we can. Candidate
15531 variables are selected in check_return_expr. */
15532 if (current_function_return_value
)
15534 tree r
= current_function_return_value
;
15537 if (r
!= error_mark_node
15538 /* This is only worth doing for fns that return in memory--and
15539 simpler, since we don't have to worry about promoted modes. */
15540 && aggregate_value_p (TREE_TYPE (TREE_TYPE (fndecl
)), fndecl
)
15541 /* Only allow this for variables declared in the outer scope of
15542 the function so we know that their lifetime always ends with a
15543 return; see g++.dg/opt/nrv6.C. We could be more flexible if
15544 we were to do this optimization in tree-ssa. */
15545 && (outer
= outer_curly_brace_block (fndecl
))
15546 && chain_member (r
, BLOCK_VARS (outer
)))
15547 finalize_nrv (&DECL_SAVED_TREE (fndecl
), r
, DECL_RESULT (fndecl
));
15549 current_function_return_value
= NULL_TREE
;
15552 /* Remember that we were in class scope. */
15553 if (current_class_name
)
15554 ctype
= current_class_type
;
15556 /* Must mark the RESULT_DECL as being in this function. */
15557 DECL_CONTEXT (DECL_RESULT (fndecl
)) = fndecl
;
15559 /* Set the BLOCK_SUPERCONTEXT of the outermost function scope to point
15560 to the FUNCTION_DECL node itself. */
15561 BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl
)) = fndecl
;
15563 /* Save away current state, if appropriate. */
15564 if (!processing_template_decl
)
15565 save_function_data (fndecl
);
15567 /* Complain if there's just no return statement. */
15568 if (warn_return_type
15569 && !VOID_TYPE_P (TREE_TYPE (fntype
))
15570 && !dependent_type_p (TREE_TYPE (fntype
))
15571 && !current_function_returns_value
&& !current_function_returns_null
15572 /* Don't complain if we abort or throw. */
15573 && !current_function_returns_abnormally
15574 /* Don't complain if there's an infinite loop. */
15575 && !current_function_infinite_loop
15576 /* Don't complain if we are declared noreturn. */
15577 && !TREE_THIS_VOLATILE (fndecl
)
15578 && !DECL_NAME (DECL_RESULT (fndecl
))
15579 && !TREE_NO_WARNING (fndecl
)
15580 /* Structor return values (if any) are set by the compiler. */
15581 && !DECL_CONSTRUCTOR_P (fndecl
)
15582 && !DECL_DESTRUCTOR_P (fndecl
)
15583 && targetm
.warn_func_return (fndecl
))
15585 warning (OPT_Wreturn_type
,
15586 "no return statement in function returning non-void");
15587 TREE_NO_WARNING (fndecl
) = 1;
15590 /* Store the end of the function, so that we get good line number
15591 info for the epilogue. */
15592 cfun
->function_end_locus
= input_location
;
15594 /* Complain about parameters that are only set, but never otherwise used. */
15595 if (warn_unused_but_set_parameter
15596 && !processing_template_decl
15597 && errorcount
== unused_but_set_errorcount
15598 && !DECL_CLONED_FUNCTION_P (fndecl
))
15602 for (decl
= DECL_ARGUMENTS (fndecl
);
15604 decl
= DECL_CHAIN (decl
))
15605 if (TREE_USED (decl
)
15606 && TREE_CODE (decl
) == PARM_DECL
15607 && !DECL_READ_P (decl
)
15608 && DECL_NAME (decl
)
15609 && !DECL_ARTIFICIAL (decl
)
15610 && !TREE_NO_WARNING (decl
)
15611 && !DECL_IN_SYSTEM_HEADER (decl
)
15612 && TREE_TYPE (decl
) != error_mark_node
15613 && TREE_CODE (TREE_TYPE (decl
)) != REFERENCE_TYPE
15614 && (!CLASS_TYPE_P (TREE_TYPE (decl
))
15615 || !TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TREE_TYPE (decl
))))
15616 warning_at (DECL_SOURCE_LOCATION (decl
),
15617 OPT_Wunused_but_set_parameter
,
15618 "parameter %qD set but not used", decl
);
15619 unused_but_set_errorcount
= errorcount
;
15622 /* Complain about locally defined typedefs that are not used in this
15624 maybe_warn_unused_local_typedefs ();
15626 /* Possibly warn about unused parameters. */
15627 if (warn_unused_parameter
15628 && !processing_template_decl
15629 && !DECL_CLONED_FUNCTION_P (fndecl
))
15630 do_warn_unused_parameter (fndecl
);
15632 /* Genericize before inlining. */
15633 if (!processing_template_decl
)
15635 struct language_function
*f
= DECL_SAVED_FUNCTION_DATA (fndecl
);
15636 cp_genericize (fndecl
);
15637 /* Clear out the bits we don't need. */
15638 f
->x_current_class_ptr
= NULL
;
15639 f
->x_current_class_ref
= NULL
;
15640 f
->x_eh_spec_block
= NULL
;
15641 f
->x_in_charge_parm
= NULL
;
15642 f
->x_vtt_parm
= NULL
;
15643 f
->x_return_value
= NULL
;
15644 f
->bindings
= NULL
;
15645 f
->extern_decl_map
= NULL
;
15646 f
->infinite_loops
= NULL
;
15648 /* Clear out the bits we don't need. */
15649 local_names
= NULL
;
15651 /* We're leaving the context of this function, so zap cfun. It's still in
15652 DECL_STRUCT_FUNCTION, and we'll restore it in tree_rest_of_compilation. */
15654 current_function_decl
= NULL
;
15656 /* If this is an in-class inline definition, we may have to pop the
15657 bindings for the template parameters that we added in
15658 maybe_begin_member_template_processing when start_function was
15661 maybe_end_member_template_processing ();
15663 /* Leave the scope of the class. */
15665 pop_nested_class ();
15670 current_function_decl
= NULL_TREE
;
15672 invoke_plugin_callbacks (PLUGIN_FINISH_PARSE_FUNCTION
, fndecl
);
15676 /* Create the FUNCTION_DECL for a function definition.
15677 DECLSPECS and DECLARATOR are the parts of the declaration;
15678 they describe the return type and the name of the function,
15679 but twisted together in a fashion that parallels the syntax of C.
15681 This function creates a binding context for the function body
15682 as well as setting up the FUNCTION_DECL in current_function_decl.
15684 Returns a FUNCTION_DECL on success.
15686 If the DECLARATOR is not suitable for a function (it defines a datum
15687 instead), we return 0, which tells yyparse to report a parse error.
15689 May return void_type_node indicating that this method is actually
15690 a friend. See grokfield for more details.
15692 Came here with a `.pushlevel' .
15694 DO NOT MAKE ANY CHANGES TO THIS CODE WITHOUT MAKING CORRESPONDING
15695 CHANGES TO CODE IN `grokfield'. */
15698 grokmethod (cp_decl_specifier_seq
*declspecs
,
15699 const cp_declarator
*declarator
, tree attrlist
)
15701 tree fndecl
= grokdeclarator (declarator
, declspecs
, MEMFUNCDEF
, 0,
15704 if (fndecl
== error_mark_node
)
15705 return error_mark_node
;
15707 if (fndecl
== NULL
|| TREE_CODE (fndecl
) != FUNCTION_DECL
)
15709 error ("invalid member function declaration");
15710 return error_mark_node
;
15714 cplus_decl_attributes (&fndecl
, attrlist
, 0);
15716 /* Pass friends other than inline friend functions back. */
15717 if (fndecl
== void_type_node
)
15720 if (DECL_IN_AGGR_P (fndecl
))
15722 if (DECL_CLASS_SCOPE_P (fndecl
))
15723 error ("%qD is already defined in class %qT", fndecl
,
15724 DECL_CONTEXT (fndecl
));
15725 return error_mark_node
;
15728 check_template_shadow (fndecl
);
15730 if (TREE_PUBLIC (fndecl
))
15731 DECL_COMDAT (fndecl
) = 1;
15732 DECL_DECLARED_INLINE_P (fndecl
) = 1;
15733 DECL_NO_INLINE_WARNING_P (fndecl
) = 1;
15735 /* We process method specializations in finish_struct_1. */
15736 if (processing_template_decl
&& !DECL_TEMPLATE_SPECIALIZATION (fndecl
))
15738 fndecl
= push_template_decl (fndecl
);
15739 if (fndecl
== error_mark_node
)
15743 if (! DECL_FRIEND_P (fndecl
))
15745 if (DECL_CHAIN (fndecl
))
15747 fndecl
= copy_node (fndecl
);
15748 TREE_CHAIN (fndecl
) = NULL_TREE
;
15752 cp_finish_decl (fndecl
, NULL_TREE
, false, NULL_TREE
, 0);
15754 DECL_IN_AGGR_P (fndecl
) = 1;
15759 /* VAR is a VAR_DECL. If its type is incomplete, remember VAR so that
15760 we can lay it out later, when and if its type becomes complete.
15762 Also handle constexpr variables where the initializer involves
15763 an unlowered PTRMEM_CST because the class isn't complete yet. */
15766 maybe_register_incomplete_var (tree var
)
15768 gcc_assert (VAR_P (var
));
15770 /* Keep track of variables with incomplete types. */
15771 if (!processing_template_decl
&& TREE_TYPE (var
) != error_mark_node
15772 && DECL_EXTERNAL (var
))
15774 tree inner_type
= TREE_TYPE (var
);
15776 while (TREE_CODE (inner_type
) == ARRAY_TYPE
)
15777 inner_type
= TREE_TYPE (inner_type
);
15778 inner_type
= TYPE_MAIN_VARIANT (inner_type
);
15780 if ((!COMPLETE_TYPE_P (inner_type
) && CLASS_TYPE_P (inner_type
))
15781 /* RTTI TD entries are created while defining the type_info. */
15782 || (TYPE_LANG_SPECIFIC (inner_type
)
15783 && TYPE_BEING_DEFINED (inner_type
)))
15785 incomplete_var iv
= {var
, inner_type
};
15786 vec_safe_push (incomplete_vars
, iv
);
15788 else if (!(DECL_LANG_SPECIFIC (var
) && DECL_TEMPLATE_INFO (var
))
15789 && decl_constant_var_p (var
)
15790 && (TYPE_PTRMEM_P (inner_type
) || CLASS_TYPE_P (inner_type
)))
15792 /* When the outermost open class is complete we can resolve any
15793 pointers-to-members. */
15794 tree context
= outermost_open_class ();
15795 incomplete_var iv
= {var
, context
};
15796 vec_safe_push (incomplete_vars
, iv
);
15801 /* Called when a class type (given by TYPE) is defined. If there are
15802 any existing VAR_DECLs whose type has been completed by this
15803 declaration, update them now. */
15806 complete_vars (tree type
)
15809 incomplete_var
*iv
;
15811 for (ix
= 0; vec_safe_iterate (incomplete_vars
, ix
, &iv
); )
15813 if (same_type_p (type
, iv
->incomplete_type
))
15815 tree var
= iv
->decl
;
15816 tree type
= TREE_TYPE (var
);
15818 if (type
!= error_mark_node
15819 && (TYPE_MAIN_VARIANT (strip_array_types (type
))
15820 == iv
->incomplete_type
))
15822 /* Complete the type of the variable. The VAR_DECL itself
15823 will be laid out in expand_expr. */
15824 complete_type (type
);
15825 cp_apply_type_quals_to_decl (cp_type_quals (type
), var
);
15828 /* Remove this entry from the list. */
15829 incomplete_vars
->unordered_remove (ix
);
15835 /* Check for pending declarations which may have abstract type. */
15836 complete_type_check_abstract (type
);
15839 /* If DECL is of a type which needs a cleanup, build and return an
15840 expression to perform that cleanup here. Return NULL_TREE if no
15841 cleanup need be done. DECL can also be a _REF when called from
15842 split_nonconstant_init_1. */
15845 cxx_maybe_build_cleanup (tree decl
, tsubst_flags_t complain
)
15851 /* Assume no cleanup is required. */
15852 cleanup
= NULL_TREE
;
15854 if (error_operand_p (decl
))
15857 /* Handle "__attribute__((cleanup))". We run the cleanup function
15858 before the destructor since the destructor is what actually
15859 terminates the lifetime of the object. */
15861 attr
= lookup_attribute ("cleanup", DECL_ATTRIBUTES (decl
));
15870 /* Get the name specified by the user for the cleanup function. */
15871 id
= TREE_VALUE (TREE_VALUE (attr
));
15872 /* Look up the name to find the cleanup function to call. It is
15873 important to use lookup_name here because that is what is
15874 used in c-common.c:handle_cleanup_attribute when performing
15875 initial checks on the attribute. Note that those checks
15876 include ensuring that the function found is not an overloaded
15877 function, or an object with an overloaded call operator,
15878 etc.; we can rely on the fact that the function found is an
15879 ordinary FUNCTION_DECL. */
15880 fn
= lookup_name (id
);
15881 arg
= build_address (decl
);
15882 if (!mark_used (decl
, complain
) && !(complain
& tf_error
))
15883 return error_mark_node
;
15884 cleanup
= cp_build_function_call_nary (fn
, complain
, arg
, NULL_TREE
);
15885 if (cleanup
== error_mark_node
)
15886 return error_mark_node
;
15888 /* Handle ordinary C++ destructors. */
15889 type
= TREE_TYPE (decl
);
15890 if (type_build_dtor_call (type
))
15892 int flags
= LOOKUP_NORMAL
|LOOKUP_NONVIRTUAL
|LOOKUP_DESTRUCTOR
;
15896 if (TREE_CODE (type
) == ARRAY_TYPE
)
15899 addr
= build_address (decl
);
15901 call
= build_delete (TREE_TYPE (addr
), addr
,
15902 sfk_complete_destructor
, flags
, 0, complain
);
15903 if (call
== error_mark_node
)
15904 cleanup
= error_mark_node
;
15905 else if (TYPE_HAS_TRIVIAL_DESTRUCTOR (type
))
15906 /* Discard the call. */;
15908 cleanup
= cp_build_compound_expr (cleanup
, call
, complain
);
15913 /* build_delete sets the location of the destructor call to the
15914 current location, even though the destructor is going to be
15915 called later, at the end of the current scope. This can lead to
15916 a "jumpy" behavior for users of debuggers when they step around
15917 the end of the block. So let's unset the location of the
15918 destructor call instead. */
15919 protected_set_expr_location (cleanup
, UNKNOWN_LOCATION
);
15923 && !lookup_attribute ("warn_unused", TYPE_ATTRIBUTES (TREE_TYPE (decl
)))
15924 /* Treat objects with destructors as used; the destructor may do
15925 something substantive. */
15926 && !mark_used (decl
, complain
) && !(complain
& tf_error
))
15927 return error_mark_node
;
15933 /* Return the FUNCTION_TYPE that corresponds to MEMFNTYPE, which can be a
15934 FUNCTION_DECL, METHOD_TYPE, FUNCTION_TYPE, pointer or reference to
15935 METHOD_TYPE or FUNCTION_TYPE, or pointer to member function. */
15938 static_fn_type (tree memfntype
)
15943 if (TYPE_PTRMEMFUNC_P (memfntype
))
15944 memfntype
= TYPE_PTRMEMFUNC_FN_TYPE (memfntype
);
15945 if (POINTER_TYPE_P (memfntype
)
15946 || TREE_CODE (memfntype
) == FUNCTION_DECL
)
15947 memfntype
= TREE_TYPE (memfntype
);
15948 if (TREE_CODE (memfntype
) == FUNCTION_TYPE
)
15950 gcc_assert (TREE_CODE (memfntype
) == METHOD_TYPE
);
15951 args
= TYPE_ARG_TYPES (memfntype
);
15952 cp_ref_qualifier rqual
= type_memfn_rqual (memfntype
);
15953 fntype
= build_function_type (TREE_TYPE (memfntype
), TREE_CHAIN (args
));
15954 fntype
= apply_memfn_quals (fntype
, type_memfn_quals (memfntype
), rqual
);
15955 fntype
= (cp_build_type_attribute_variant
15956 (fntype
, TYPE_ATTRIBUTES (memfntype
)));
15957 fntype
= (build_exception_variant
15958 (fntype
, TYPE_RAISES_EXCEPTIONS (memfntype
)));
15959 if (TYPE_HAS_LATE_RETURN_TYPE (memfntype
))
15960 TYPE_HAS_LATE_RETURN_TYPE (fntype
) = 1;
15964 /* DECL was originally constructed as a non-static member function,
15965 but turned out to be static. Update it accordingly. */
15968 revert_static_member_fn (tree decl
)
15970 tree stype
= static_fn_type (decl
);
15971 cp_cv_quals quals
= type_memfn_quals (stype
);
15972 cp_ref_qualifier rqual
= type_memfn_rqual (stype
);
15974 if (quals
!= TYPE_UNQUALIFIED
|| rqual
!= REF_QUAL_NONE
)
15975 stype
= apply_memfn_quals (stype
, TYPE_UNQUALIFIED
, REF_QUAL_NONE
);
15977 TREE_TYPE (decl
) = stype
;
15979 if (DECL_ARGUMENTS (decl
))
15980 DECL_ARGUMENTS (decl
) = DECL_CHAIN (DECL_ARGUMENTS (decl
));
15981 DECL_STATIC_FUNCTION_P (decl
) = 1;
15984 /* Return which tree structure is used by T, or TS_CP_GENERIC if T is
15985 one of the language-independent trees. */
15987 enum cp_tree_node_structure_enum
15988 cp_tree_node_structure (union lang_tree_node
* t
)
15990 switch (TREE_CODE (&t
->generic
))
15992 case DEFAULT_ARG
: return TS_CP_DEFAULT_ARG
;
15993 case DEFERRED_NOEXCEPT
: return TS_CP_DEFERRED_NOEXCEPT
;
15994 case IDENTIFIER_NODE
: return TS_CP_IDENTIFIER
;
15995 case OVERLOAD
: return TS_CP_OVERLOAD
;
15996 case TEMPLATE_PARM_INDEX
: return TS_CP_TPI
;
15997 case PTRMEM_CST
: return TS_CP_PTRMEM
;
15998 case BASELINK
: return TS_CP_BASELINK
;
15999 case TEMPLATE_DECL
: return TS_CP_TEMPLATE_DECL
;
16000 case STATIC_ASSERT
: return TS_CP_STATIC_ASSERT
;
16001 case ARGUMENT_PACK_SELECT
: return TS_CP_ARGUMENT_PACK_SELECT
;
16002 case TRAIT_EXPR
: return TS_CP_TRAIT_EXPR
;
16003 case LAMBDA_EXPR
: return TS_CP_LAMBDA_EXPR
;
16004 case TEMPLATE_INFO
: return TS_CP_TEMPLATE_INFO
;
16005 case CONSTRAINT_INFO
: return TS_CP_CONSTRAINT_INFO
;
16006 case USERDEF_LITERAL
: return TS_CP_USERDEF_LITERAL
;
16007 default: return TS_CP_GENERIC
;
16011 /* Build the void_list_node (void_type_node having been created). */
16013 build_void_list_node (void)
16015 tree t
= build_tree_list (NULL_TREE
, void_type_node
);
16020 cp_missing_noreturn_ok_p (tree decl
)
16022 /* A missing noreturn is ok for the `main' function. */
16023 return DECL_MAIN_P (decl
);
16026 /* Return the decl used to identify the COMDAT group into which DECL should
16030 cxx_comdat_group (tree decl
)
16032 /* Virtual tables, construction virtual tables, and virtual table
16033 tables all go in a single COMDAT group, named after the primary
16035 if (VAR_P (decl
) && DECL_VTABLE_OR_VTT_P (decl
))
16036 decl
= CLASSTYPE_VTABLES (DECL_CONTEXT (decl
));
16037 /* For all other DECLs, the COMDAT group is the mangled name of the
16038 declaration itself. */
16041 while (DECL_THUNK_P (decl
))
16043 /* If TARGET_USE_LOCAL_THUNK_ALIAS_P, use_thunk puts the thunk
16044 into the same section as the target function. In that case
16045 we must return target's name. */
16046 tree target
= THUNK_TARGET (decl
);
16047 if (TARGET_USE_LOCAL_THUNK_ALIAS_P (target
)
16048 && DECL_SECTION_NAME (target
) != NULL
16049 && DECL_ONE_ONLY (target
))
16059 /* Returns the return type for FN as written by the user, which may include
16060 a placeholder for a deduced return type. */
16063 fndecl_declared_return_type (tree fn
)
16065 fn
= STRIP_TEMPLATE (fn
);
16066 if (FNDECL_USED_AUTO (fn
))
16068 struct language_function
*f
= NULL
;
16069 if (DECL_STRUCT_FUNCTION (fn
))
16070 f
= DECL_STRUCT_FUNCTION (fn
)->language
;
16072 f
= DECL_SAVED_FUNCTION_DATA (fn
);
16073 return f
->x_auto_return_pattern
;
16075 return TREE_TYPE (TREE_TYPE (fn
));
16078 /* Returns true iff DECL was declared with an auto type and it has
16079 not yet been deduced to a real type. */
16082 undeduced_auto_decl (tree decl
)
16084 if (cxx_dialect
< cxx11
)
16086 return type_uses_auto (TREE_TYPE (decl
));
16089 /* Complain if DECL has an undeduced return type. */
16092 require_deduced_type (tree decl
, tsubst_flags_t complain
)
16094 if (undeduced_auto_decl (decl
))
16096 if (complain
& tf_error
)
16097 error ("use of %qD before deduction of %<auto%>", decl
);
16103 #include "gt-cp-decl.h"