1 /* Handle the hair of processing (but not expanding) inline functions.
2 Also manage function and variable name overloading.
3 Copyright (C) 1987-2024 Free Software Foundation, Inc.
4 Contributed by Michael Tiemann (tiemann@cygnus.com)
6 This file is part of GCC.
8 GCC is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3, or (at your option)
13 GCC is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING3. If not see
20 <http://www.gnu.org/licenses/>. */
23 /* Handle method declarations. */
26 #include "coretypes.h"
29 #include "stringpool.h"
34 #include "common/common-target.h"
36 static void do_build_copy_assign (tree
);
37 static void do_build_copy_constructor (tree
);
38 static tree
make_alias_for_thunk (tree
);
40 /* Called once to initialize method.cc. */
48 /* Return a this or result adjusting thunk to FUNCTION. THIS_ADJUSTING
49 indicates whether it is a this or result adjusting thunk.
50 FIXED_OFFSET and VIRTUAL_OFFSET indicate how to do the adjustment
51 (see thunk_adjust). VIRTUAL_OFFSET can be NULL, but FIXED_OFFSET
52 never is. VIRTUAL_OFFSET is the /index/ into the vtable for this
53 adjusting thunks, we scale it to a byte offset. For covariant
54 thunks VIRTUAL_OFFSET is the virtual binfo. You must post process
55 the returned thunk with finish_thunk. */
58 make_thunk (tree function
, bool this_adjusting
,
59 tree fixed_offset
, tree virtual_offset
)
64 gcc_assert (TREE_CODE (function
) == FUNCTION_DECL
);
65 /* We can have this thunks to covariant thunks, but not vice versa. */
66 gcc_assert (!DECL_THIS_THUNK_P (function
));
67 gcc_assert (!DECL_RESULT_THUNK_P (function
) || this_adjusting
);
69 /* Scale the VIRTUAL_OFFSET to be in terms of bytes. */
70 if (this_adjusting
&& virtual_offset
)
72 = size_binop (MULT_EXPR
,
75 TYPE_SIZE_UNIT (vtable_entry_type
)));
77 d
= tree_to_shwi (fixed_offset
);
79 /* See if we already have the thunk in question. For this_adjusting
80 thunks VIRTUAL_OFFSET will be an INTEGER_CST, for covariant thunks it
82 for (thunk
= DECL_THUNKS (function
); thunk
; thunk
= DECL_CHAIN (thunk
))
83 if (DECL_THIS_THUNK_P (thunk
) == this_adjusting
84 && THUNK_FIXED_OFFSET (thunk
) == d
85 && !virtual_offset
== !THUNK_VIRTUAL_OFFSET (thunk
)
88 ? tree_int_cst_equal (THUNK_VIRTUAL_OFFSET (thunk
),
90 : THUNK_VIRTUAL_OFFSET (thunk
) == virtual_offset
)))
93 /* All thunks must be created before FUNCTION is actually emitted;
94 the ABI requires that all thunks be emitted together with the
95 function to which they transfer control. */
96 gcc_assert (!TREE_ASM_WRITTEN (function
));
97 /* Likewise, we can only be adding thunks to a function declared in
98 the class currently being laid out. */
99 gcc_assert (TYPE_SIZE (DECL_CONTEXT (function
))
100 && TYPE_BEING_DEFINED (DECL_CONTEXT (function
)));
102 thunk
= build_decl (DECL_SOURCE_LOCATION (function
),
103 FUNCTION_DECL
, NULL_TREE
, TREE_TYPE (function
));
104 DECL_LANG_SPECIFIC (thunk
) = DECL_LANG_SPECIFIC (function
);
105 cxx_dup_lang_specific_decl (thunk
);
106 DECL_VIRTUAL_P (thunk
) = true;
107 SET_DECL_THUNKS (thunk
, NULL_TREE
);
109 DECL_CONTEXT (thunk
) = DECL_CONTEXT (function
);
110 TREE_READONLY (thunk
) = TREE_READONLY (function
);
111 TREE_THIS_VOLATILE (thunk
) = TREE_THIS_VOLATILE (function
);
112 TREE_PUBLIC (thunk
) = TREE_PUBLIC (function
);
113 SET_DECL_THUNK_P (thunk
, this_adjusting
);
114 THUNK_TARGET (thunk
) = function
;
115 THUNK_FIXED_OFFSET (thunk
) = d
;
116 THUNK_VIRTUAL_OFFSET (thunk
) = virtual_offset
;
117 THUNK_ALIAS (thunk
) = NULL_TREE
;
119 DECL_INTERFACE_KNOWN (thunk
) = 1;
120 DECL_NOT_REALLY_EXTERN (thunk
) = 1;
121 DECL_COMDAT (thunk
) = DECL_COMDAT (function
);
122 DECL_SAVED_AUTO_RETURN_TYPE (thunk
) = NULL
;
123 /* The thunk itself is not a constructor or destructor, even if
124 the thing it is thunking to is. */
125 DECL_CXX_DESTRUCTOR_P (thunk
) = 0;
126 DECL_CXX_CONSTRUCTOR_P (thunk
) = 0;
127 DECL_EXTERNAL (thunk
) = 1;
128 DECL_ARTIFICIAL (thunk
) = 1;
129 /* The THUNK is not a pending inline, even if the FUNCTION is. */
130 DECL_PENDING_INLINE_P (thunk
) = 0;
131 DECL_DECLARED_INLINE_P (thunk
) = 0;
132 /* Nor is it a template instantiation. */
133 DECL_USE_TEMPLATE (thunk
) = 0;
134 DECL_TEMPLATE_INFO (thunk
) = NULL
;
136 /* Add it to the list of thunks associated with FUNCTION. */
137 DECL_CHAIN (thunk
) = DECL_THUNKS (function
);
138 SET_DECL_THUNKS (function
, thunk
);
143 /* Finish THUNK, a thunk decl. */
146 finish_thunk (tree thunk
)
149 tree fixed_offset
= ssize_int (THUNK_FIXED_OFFSET (thunk
));
150 tree virtual_offset
= THUNK_VIRTUAL_OFFSET (thunk
);
152 gcc_assert (!DECL_NAME (thunk
) && DECL_THUNK_P (thunk
));
153 if (virtual_offset
&& DECL_RESULT_THUNK_P (thunk
))
154 virtual_offset
= BINFO_VPTR_FIELD (virtual_offset
);
155 function
= THUNK_TARGET (thunk
);
156 name
= mangle_thunk (function
, DECL_THIS_THUNK_P (thunk
),
157 fixed_offset
, virtual_offset
, thunk
);
159 /* We can end up with declarations of (logically) different
160 covariant thunks, that do identical adjustments. The two thunks
161 will be adjusting between within different hierarchies, which
162 happen to have the same layout. We must nullify one of them to
163 refer to the other. */
164 if (DECL_RESULT_THUNK_P (thunk
))
168 for (cov_probe
= DECL_THUNKS (function
);
169 cov_probe
; cov_probe
= DECL_CHAIN (cov_probe
))
170 if (DECL_NAME (cov_probe
) == name
)
172 gcc_assert (!DECL_THUNKS (thunk
));
173 THUNK_ALIAS (thunk
) = (THUNK_ALIAS (cov_probe
)
174 ? THUNK_ALIAS (cov_probe
) : cov_probe
);
179 DECL_NAME (thunk
) = name
;
180 SET_DECL_ASSEMBLER_NAME (thunk
, name
);
183 static GTY (()) int thunk_labelno
;
185 /* Create a static alias to target. */
188 make_alias_for (tree target
, tree newid
)
190 tree alias
= build_decl (DECL_SOURCE_LOCATION (target
),
191 TREE_CODE (target
), newid
, TREE_TYPE (target
));
192 DECL_LANG_SPECIFIC (alias
) = DECL_LANG_SPECIFIC (target
);
193 cxx_dup_lang_specific_decl (alias
);
194 DECL_CONTEXT (alias
) = DECL_CONTEXT (target
);
195 TREE_READONLY (alias
) = TREE_READONLY (target
);
196 TREE_THIS_VOLATILE (alias
) = TREE_THIS_VOLATILE (target
);
197 TREE_PUBLIC (alias
) = 0;
198 DECL_INTERFACE_KNOWN (alias
) = 1;
199 if (DECL_LANG_SPECIFIC (alias
))
201 DECL_NOT_REALLY_EXTERN (alias
) = 1;
202 DECL_USE_TEMPLATE (alias
) = 0;
203 DECL_TEMPLATE_INFO (alias
) = NULL
;
205 DECL_EXTERNAL (alias
) = 0;
206 DECL_ARTIFICIAL (alias
) = 1;
207 DECL_TEMPLATE_INSTANTIATED (alias
) = 0;
208 if (TREE_CODE (alias
) == FUNCTION_DECL
)
210 DECL_SAVED_AUTO_RETURN_TYPE (alias
) = NULL
;
211 DECL_CXX_DESTRUCTOR_P (alias
) = 0;
212 DECL_CXX_CONSTRUCTOR_P (alias
) = 0;
213 DECL_PENDING_INLINE_P (alias
) = 0;
214 DECL_DECLARED_INLINE_P (alias
) = 0;
215 DECL_INITIAL (alias
) = error_mark_node
;
216 DECL_ARGUMENTS (alias
) = copy_list (DECL_ARGUMENTS (target
));
219 TREE_STATIC (alias
) = 1;
220 TREE_ADDRESSABLE (alias
) = 1;
221 TREE_USED (alias
) = 1;
222 SET_DECL_ASSEMBLER_NAME (alias
, DECL_NAME (alias
));
227 make_alias_for_thunk (tree function
)
232 targetm
.asm_out
.generate_internal_label (buf
, "LTHUNK", thunk_labelno
);
235 alias
= make_alias_for (function
, get_identifier (buf
));
237 if (!flag_syntax_only
)
239 struct cgraph_node
*funcn
, *aliasn
;
240 funcn
= cgraph_node::get (function
);
241 gcc_checking_assert (funcn
);
242 aliasn
= cgraph_node::create_same_body_alias (alias
, function
);
243 DECL_ASSEMBLER_NAME (function
);
244 gcc_assert (aliasn
!= NULL
);
250 /* Emit the definition of a C++ multiple inheritance or covariant
251 return vtable thunk. If EMIT_P is nonzero, the thunk is emitted
255 use_thunk (tree thunk_fndecl
, bool emit_p
)
257 tree a
, t
, function
, alias
;
259 HOST_WIDE_INT fixed_offset
, virtual_value
;
260 bool this_adjusting
= DECL_THIS_THUNK_P (thunk_fndecl
);
261 struct cgraph_node
*funcn
, *thunk_node
;
263 /* We should have called finish_thunk to give it a name. */
264 gcc_assert (DECL_NAME (thunk_fndecl
));
266 /* We should never be using an alias, always refer to the
268 gcc_assert (!THUNK_ALIAS (thunk_fndecl
));
270 if (TREE_ASM_WRITTEN (thunk_fndecl
))
273 function
= THUNK_TARGET (thunk_fndecl
);
274 if (DECL_RESULT (thunk_fndecl
))
275 /* We already turned this thunk into an ordinary function.
276 There's no need to process this thunk again. */
279 if (DECL_THUNK_P (function
))
280 /* The target is itself a thunk, process it now. */
281 use_thunk (function
, emit_p
);
283 /* Thunks are always addressable; they only appear in vtables. */
284 TREE_ADDRESSABLE (thunk_fndecl
) = 1;
286 /* Figure out what function is being thunked to. It's referenced in
287 this translation unit. */
288 TREE_ADDRESSABLE (function
) = 1;
289 mark_used (function
);
293 if (TARGET_USE_LOCAL_THUNK_ALIAS_P (function
))
294 alias
= make_alias_for_thunk (function
);
298 fixed_offset
= THUNK_FIXED_OFFSET (thunk_fndecl
);
299 virtual_offset
= THUNK_VIRTUAL_OFFSET (thunk_fndecl
);
304 virtual_offset
= BINFO_VPTR_FIELD (virtual_offset
);
305 virtual_value
= tree_to_shwi (virtual_offset
);
306 gcc_assert (virtual_value
);
311 /* And, if we need to emit the thunk, it's used. */
312 mark_used (thunk_fndecl
);
313 /* This thunk is actually defined. */
314 DECL_EXTERNAL (thunk_fndecl
) = 0;
315 /* The linkage of the function may have changed. FIXME in linkage
317 gcc_assert (DECL_INTERFACE_KNOWN (function
));
318 TREE_PUBLIC (thunk_fndecl
) = TREE_PUBLIC (function
);
319 DECL_VISIBILITY (thunk_fndecl
) = DECL_VISIBILITY (function
);
320 DECL_VISIBILITY_SPECIFIED (thunk_fndecl
)
321 = DECL_VISIBILITY_SPECIFIED (function
);
322 DECL_COMDAT (thunk_fndecl
) = DECL_COMDAT (function
);
323 DECL_WEAK (thunk_fndecl
) = DECL_WEAK (function
);
325 if (flag_syntax_only
)
327 TREE_ASM_WRITTEN (thunk_fndecl
) = 1;
331 push_to_top_level ();
333 if (TARGET_USE_LOCAL_THUNK_ALIAS_P (function
)
334 && targetm_common
.have_named_sections
)
337 struct symtab_node
*symbol
;
339 if ((symbol
= symtab_node::get (function
))
342 if (symbol
->analyzed
)
343 fn
= symtab_node::get (function
)->ultimate_alias_target ()->decl
;
345 fn
= symtab_node::get (function
)->alias_target
;
347 resolve_unique_section (fn
, 0, flag_function_sections
);
349 if (DECL_SECTION_NAME (fn
) != NULL
&& DECL_ONE_ONLY (fn
))
351 resolve_unique_section (thunk_fndecl
, 0, flag_function_sections
);
353 /* Output the thunk into the same section as function. */
354 set_decl_section_name (thunk_fndecl
, fn
);
355 symtab_node::get (thunk_fndecl
)->implicit_section
356 = symtab_node::get (fn
)->implicit_section
;
360 /* Set up cloned argument trees for the thunk. */
362 for (a
= DECL_ARGUMENTS (function
); a
; a
= DECL_CHAIN (a
))
364 tree x
= copy_node (a
);
366 DECL_CONTEXT (x
) = thunk_fndecl
;
367 SET_DECL_RTL (x
, NULL
);
368 DECL_HAS_VALUE_EXPR_P (x
) = 0;
369 TREE_ADDRESSABLE (x
) = 0;
373 DECL_ARGUMENTS (thunk_fndecl
) = a
;
374 TREE_ASM_WRITTEN (thunk_fndecl
) = 1;
375 funcn
= cgraph_node::get (function
);
376 gcc_checking_assert (funcn
);
377 thunk_node
= funcn
->create_thunk (thunk_fndecl
, function
,
378 this_adjusting
, fixed_offset
, virtual_value
,
379 0, virtual_offset
, alias
);
380 if (DECL_ONE_ONLY (function
))
381 thunk_node
->add_to_same_comdat_group (funcn
);
383 pop_from_top_level ();
386 /* Code for synthesizing methods which have default semantics defined. */
388 /* True iff CTYPE has a trivial SFK. */
391 type_has_trivial_fn (tree ctype
, special_function_kind sfk
)
395 case sfk_constructor
:
396 return !TYPE_HAS_COMPLEX_DFLT (ctype
);
397 case sfk_copy_constructor
:
398 return !TYPE_HAS_COMPLEX_COPY_CTOR (ctype
);
399 case sfk_move_constructor
:
400 return !TYPE_HAS_COMPLEX_MOVE_CTOR (ctype
);
401 case sfk_copy_assignment
:
402 return !TYPE_HAS_COMPLEX_COPY_ASSIGN (ctype
);
403 case sfk_move_assignment
:
404 return !TYPE_HAS_COMPLEX_MOVE_ASSIGN (ctype
);
406 case sfk_virtual_destructor
:
407 return !TYPE_HAS_NONTRIVIAL_DESTRUCTOR (ctype
);
408 case sfk_inheriting_constructor
:
416 /* Note that CTYPE has a non-trivial SFK even though we previously thought
420 type_set_nontrivial_flag (tree ctype
, special_function_kind sfk
)
424 case sfk_constructor
:
425 TYPE_HAS_COMPLEX_DFLT (ctype
) = true;
427 case sfk_copy_constructor
:
428 TYPE_HAS_COMPLEX_COPY_CTOR (ctype
) = true;
430 case sfk_move_constructor
:
431 TYPE_HAS_COMPLEX_MOVE_CTOR (ctype
) = true;
433 case sfk_copy_assignment
:
434 TYPE_HAS_COMPLEX_COPY_ASSIGN (ctype
) = true;
436 case sfk_move_assignment
:
437 TYPE_HAS_COMPLEX_MOVE_ASSIGN (ctype
) = true;
440 TYPE_HAS_NONTRIVIAL_DESTRUCTOR (ctype
) = true;
442 case sfk_inheriting_constructor
:
448 /* True iff FN is a trivial defaulted member function ([cd]tor, op=). */
451 trivial_fn_p (tree fn
)
453 if (TREE_CODE (fn
) == TEMPLATE_DECL
)
455 if (!DECL_DEFAULTED_FN (fn
))
458 /* If fn is a clone, get the primary variant. */
459 if (tree prim
= DECL_CLONED_FUNCTION (fn
))
461 return type_has_trivial_fn (DECL_CONTEXT (fn
), special_function_p (fn
));
464 /* PARM is a PARM_DECL for a function which we want to forward to another
465 function without changing its value category, a la std::forward. */
468 forward_parm (tree parm
)
470 tree exp
= convert_from_reference (parm
);
471 tree type
= TREE_TYPE (parm
);
472 if (DECL_PACK_P (parm
))
473 type
= PACK_EXPANSION_PATTERN (type
);
474 if (!TYPE_REF_P (type
))
475 type
= cp_build_reference_type (type
, /*rval=*/true);
476 warning_sentinel
w (warn_useless_cast
);
477 exp
= build_static_cast (input_location
, type
, exp
,
478 tf_warning_or_error
);
479 if (DECL_PACK_P (parm
))
480 exp
= make_pack_expansion (exp
);
484 /* Strip all inheriting constructors, if any, to return the original
485 constructor from a (possibly indirect) base class. */
488 strip_inheriting_ctors (tree dfn
)
490 if (!flag_new_inheriting_ctors
)
493 while (tree inh
= DECL_INHERITED_CTOR (fn
))
494 fn
= OVL_FIRST (inh
);
496 if (TREE_CODE (fn
) == TEMPLATE_DECL
497 && TREE_CODE (dfn
) == FUNCTION_DECL
)
498 fn
= DECL_TEMPLATE_RESULT (fn
);
502 /* Find the binfo for the base subobject of BINFO being initialized by
503 inherited constructor FNDECL (a member of a direct base of BINFO). */
505 static tree
inherited_ctor_binfo (tree
, tree
);
507 inherited_ctor_binfo_1 (tree binfo
, tree fndecl
)
509 tree base
= DECL_CONTEXT (fndecl
);
511 for (int i
= 0; BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); i
++)
512 if (BINFO_TYPE (base_binfo
) == base
)
513 return inherited_ctor_binfo (base_binfo
, fndecl
);
518 /* Find the binfo for the base subobject of BINFO being initialized by
519 inheriting constructor FNDECL (a member of BINFO), or BINFO if FNDECL is not
520 an inheriting constructor. */
523 inherited_ctor_binfo (tree binfo
, tree fndecl
)
525 tree inh
= DECL_INHERITED_CTOR (fndecl
);
529 tree results
= NULL_TREE
;
530 for (ovl_iterator
iter (inh
); iter
; ++iter
)
532 tree one
= inherited_ctor_binfo_1 (binfo
, *iter
);
535 else if (one
!= results
)
536 results
= tree_cons (NULL_TREE
, one
, results
);
541 /* Find the binfo for the base subobject being initialized by inheriting
542 constructor FNDECL, or NULL_TREE if FNDECL is not an inheriting
546 inherited_ctor_binfo (tree fndecl
)
548 if (!DECL_INHERITED_CTOR (fndecl
))
550 tree binfo
= TYPE_BINFO (DECL_CONTEXT (fndecl
));
551 return inherited_ctor_binfo (binfo
, fndecl
);
555 /* True if we should omit all user-declared parameters from a base
556 construtor built from complete constructor FN.
557 That's when the ctor is inherited from a virtual base. */
560 base_ctor_omit_inherited_parms (tree comp_ctor
)
562 gcc_checking_assert (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (comp_ctor
));
564 if (!flag_new_inheriting_ctors
)
565 /* We only optimize away the parameters in the new model. */
568 if (!CLASSTYPE_VBASECLASSES (DECL_CONTEXT (comp_ctor
)))
571 if (FUNCTION_FIRST_USER_PARMTYPE (comp_ctor
) == void_list_node
)
572 /* No user-declared parameters to omit. */
575 for (tree binfo
= inherited_ctor_binfo (comp_ctor
);
577 binfo
= BINFO_INHERITANCE_CHAIN (binfo
))
578 if (BINFO_VIRTUAL_P (binfo
))
585 /* True if we should omit all user-declared parameters from constructor FN,
586 because it is a base clone of a ctor inherited from a virtual base. */
589 ctor_omit_inherited_parms (tree fn
)
591 gcc_checking_assert (TREE_CODE (fn
) == FUNCTION_DECL
);
593 if (!DECL_BASE_CONSTRUCTOR_P (fn
))
596 return base_ctor_omit_inherited_parms (DECL_CLONED_FUNCTION (fn
));
599 /* True iff constructor(s) INH inherited into BINFO initializes INIT_BINFO.
600 This can be true for multiple virtual bases as well as one direct
604 binfo_inherited_from (tree binfo
, tree init_binfo
, tree inh
)
606 /* inh is an OVERLOAD if we inherited the same constructor along
607 multiple paths, check all of them. */
608 for (ovl_iterator
iter (inh
); iter
; ++iter
)
611 tree base
= DECL_CONTEXT (fn
);
612 tree base_binfo
= NULL_TREE
;
613 for (int i
= 0; BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); i
++)
614 if (BINFO_TYPE (base_binfo
) == base
)
616 if (base_binfo
== init_binfo
617 || (flag_new_inheriting_ctors
618 && binfo_inherited_from (base_binfo
, init_binfo
,
619 DECL_INHERITED_CTOR (fn
))))
625 /* Subroutine of do_build_copy_constructor: Add a mem-initializer for BINFO
626 given the parameter or parameters PARM, possibly inherited constructor
627 base INH, or move flag MOVE_P. */
630 add_one_base_init (tree binfo
, tree parm
, bool move_p
, tree inh
,
631 tree member_init_list
)
636 /* An inheriting constructor only has a mem-initializer for
637 the base it inherits from. */
638 if (!binfo_inherited_from (TYPE_BINFO (current_class_type
), binfo
, inh
))
639 return member_init_list
;
643 for (; parm
; parm
= DECL_CHAIN (parm
))
645 tree exp
= forward_parm (parm
);
646 *p
= build_tree_list (NULL_TREE
, exp
);
647 p
= &TREE_CHAIN (*p
);
652 init
= build_base_path (PLUS_EXPR
, parm
, binfo
, 1,
653 tf_warning_or_error
);
656 init
= build_tree_list (NULL_TREE
, init
);
658 return tree_cons (binfo
, init
, member_init_list
);
661 /* Generate code for default X(X&) or X(X&&) constructor or an inheriting
665 do_build_copy_constructor (tree fndecl
)
667 tree parm
= FUNCTION_FIRST_USER_PARM (fndecl
);
668 bool move_p
= DECL_MOVE_CONSTRUCTOR_P (fndecl
);
669 bool trivial
= trivial_fn_p (fndecl
);
670 tree inh
= DECL_INHERITED_CTOR (fndecl
);
673 parm
= convert_from_reference (parm
);
677 if (is_empty_class (current_class_type
))
678 /* Don't copy the padding byte; it might not have been allocated
679 if *this is a base subobject. */;
680 else if (tree_int_cst_equal (TYPE_SIZE (current_class_type
),
681 CLASSTYPE_SIZE (current_class_type
)))
683 tree t
= cp_build_init_expr (current_class_ref
, parm
);
684 finish_expr_stmt (t
);
688 /* We must only copy the non-tail padding parts. */
689 tree base_size
= CLASSTYPE_SIZE_UNIT (current_class_type
);
690 base_size
= size_binop (MINUS_EXPR
, base_size
, size_int (1));
691 tree array_type
= build_array_type (unsigned_char_type_node
,
692 build_index_type (base_size
));
693 tree alias_set
= build_int_cst (TREE_TYPE (current_class_ptr
), 0);
694 tree lhs
= build2 (MEM_REF
, array_type
,
695 current_class_ptr
, alias_set
);
696 tree rhs
= build2 (MEM_REF
, array_type
,
697 TREE_OPERAND (parm
, 0), alias_set
);
698 tree t
= cp_build_init_expr (lhs
, rhs
);
699 finish_expr_stmt (t
);
704 tree member_init_list
= NULL_TREE
;
706 tree binfo
, base_binfo
;
707 vec
<tree
, va_gc
> *vbases
;
709 /* Initialize all the base-classes with the parameter converted
710 to their type so that we get their copy constructor and not
711 another constructor that takes current_class_type. We must
712 deal with the binfo's directly as a direct base might be
713 inaccessible due to ambiguity. */
714 for (vbases
= CLASSTYPE_VBASECLASSES (current_class_type
), i
= 0;
715 vec_safe_iterate (vbases
, i
, &binfo
); i
++)
717 member_init_list
= add_one_base_init (binfo
, parm
, move_p
, inh
,
721 for (binfo
= TYPE_BINFO (current_class_type
), i
= 0;
722 BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); i
++)
724 if (BINFO_VIRTUAL_P (base_binfo
))
726 member_init_list
= add_one_base_init (base_binfo
, parm
, move_p
,
727 inh
, member_init_list
);
732 int cvquals
= cp_type_quals (TREE_TYPE (parm
));
734 for (tree fields
= TYPE_FIELDS (current_class_type
);
735 fields
; fields
= DECL_CHAIN (fields
))
740 if (TREE_CODE (field
) != FIELD_DECL
)
743 expr_type
= TREE_TYPE (field
);
744 if (DECL_NAME (field
))
746 if (VFIELD_NAME_P (DECL_NAME (field
)))
749 else if (ANON_AGGR_TYPE_P (expr_type
) && TYPE_FIELDS (expr_type
))
750 /* Just use the field; anonymous types can't have
751 nontrivial copy ctors or assignment ops or this
752 function would be deleted. */;
756 /* Compute the type of "init->field". If the copy-constructor
757 parameter is, for example, "const S&", and the type of
758 the field is "T", then the type will usually be "const
759 T". (There are no cv-qualified variants of reference
761 if (!TYPE_REF_P (expr_type
))
765 if (DECL_MUTABLE_P (field
))
766 quals
&= ~TYPE_QUAL_CONST
;
767 quals
|= cp_type_quals (expr_type
);
768 expr_type
= cp_build_qualified_type (expr_type
, quals
);
771 tree init
= build3 (COMPONENT_REF
, expr_type
, parm
, field
, NULL_TREE
);
772 if (move_p
&& !TYPE_REF_P (expr_type
)
773 /* 'move' breaks bit-fields, and has no effect for scalars. */
774 && !scalarish_type_p (expr_type
))
776 init
= build_tree_list (NULL_TREE
, init
);
778 member_init_list
= tree_cons (field
, init
, member_init_list
);
782 finish_mem_initializers (member_init_list
);
787 do_build_copy_assign (tree fndecl
)
789 tree parm
= DECL_CHAIN (DECL_ARGUMENTS (fndecl
));
791 bool move_p
= move_fn_p (fndecl
);
792 bool trivial
= trivial_fn_p (fndecl
);
793 int flags
= LOOKUP_NORMAL
| LOOKUP_NONVIRTUAL
| LOOKUP_DEFAULTED
;
795 compound_stmt
= begin_compound_stmt (0);
796 parm
= convert_from_reference (parm
);
799 && is_empty_class (current_class_type
))
800 /* Don't copy the padding byte; it might not have been allocated
801 if *this is a base subobject. */;
804 tree t
= build2 (MODIFY_EXPR
, void_type_node
, current_class_ref
, parm
);
805 finish_expr_stmt (t
);
810 int cvquals
= cp_type_quals (TREE_TYPE (parm
));
812 tree binfo
, base_binfo
;
814 /* Assign to each of the direct base classes. */
815 for (binfo
= TYPE_BINFO (current_class_type
), i
= 0;
816 BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); i
++)
820 /* We must convert PARM directly to the base class
821 explicitly since the base class may be ambiguous. */
822 converted_parm
= build_base_path (PLUS_EXPR
, parm
, base_binfo
, 1,
823 tf_warning_or_error
);
825 converted_parm
= move (converted_parm
);
826 /* Call the base class assignment operator. */
827 releasing_vec
parmvec (make_tree_vector_single (converted_parm
));
829 (build_special_member_call (current_class_ref
,
830 assign_op_identifier
,
834 tf_warning_or_error
));
837 /* Assign to each of the non-static data members. */
838 for (fields
= TYPE_FIELDS (current_class_type
);
840 fields
= DECL_CHAIN (fields
))
842 tree comp
= current_class_ref
;
848 if (TREE_CODE (field
) != FIELD_DECL
|| DECL_ARTIFICIAL (field
))
851 expr_type
= TREE_TYPE (field
);
853 if (CP_TYPE_CONST_P (expr_type
))
855 error ("non-static const member %q#D, cannot use default "
856 "assignment operator", field
);
859 else if (TYPE_REF_P (expr_type
))
861 error ("non-static reference member %q#D, cannot use "
862 "default assignment operator", field
);
866 if (DECL_NAME (field
))
868 if (VFIELD_NAME_P (DECL_NAME (field
)))
871 else if (ANON_AGGR_TYPE_P (expr_type
)
872 && TYPE_FIELDS (expr_type
) != NULL_TREE
)
873 /* Just use the field; anonymous types can't have
874 nontrivial copy ctors or assignment ops or this
875 function would be deleted. */;
879 comp
= build3 (COMPONENT_REF
, expr_type
, comp
, field
, NULL_TREE
);
881 /* Compute the type of init->field */
883 if (DECL_MUTABLE_P (field
))
884 quals
&= ~TYPE_QUAL_CONST
;
885 expr_type
= cp_build_qualified_type (expr_type
, quals
);
887 init
= build3 (COMPONENT_REF
, expr_type
, init
, field
, NULL_TREE
);
888 if (move_p
&& !TYPE_REF_P (expr_type
)
889 /* 'move' breaks bit-fields, and has no effect for scalars. */
890 && !scalarish_type_p (expr_type
))
893 if (DECL_NAME (field
))
894 init
= cp_build_modify_expr (input_location
, comp
, NOP_EXPR
, init
,
895 tf_warning_or_error
);
897 init
= build2 (MODIFY_EXPR
, TREE_TYPE (comp
), comp
, init
);
898 finish_expr_stmt (init
);
901 finish_return_stmt (current_class_ref
);
902 finish_compound_stmt (compound_stmt
);
905 /* C++20 <compare> comparison category types. */
915 /* Names of the comparison categories and their value members, to be indexed by
916 comp_cat_tag enumerators. genericize_spaceship below relies on the ordering
919 struct comp_cat_info_t
922 const char *members
[4];
924 static const comp_cat_info_t comp_cat_info
[cc_last
]
926 { "partial_ordering", { "equivalent", "greater", "less", "unordered" } },
927 { "weak_ordering", { "equivalent", "greater", "less" } },
928 { "strong_ordering", { "equal", "greater", "less" } }
931 /* A cache of the category types to speed repeated lookups. */
933 static GTY((deletable
)) tree comp_cat_cache
[cc_last
];
935 /* Look up one of the result variables in the comparison category type. */
938 lookup_comparison_result (tree type
, const char *name_str
,
939 tsubst_flags_t complain
= tf_warning_or_error
)
941 tree name
= get_identifier (name_str
);
942 tree decl
= lookup_qualified_name (type
, name
);
943 if (TREE_CODE (decl
) != VAR_DECL
)
945 if (complain
& tf_error
)
947 auto_diagnostic_group d
;
948 if (decl
== error_mark_node
|| TREE_CODE (decl
) == TREE_LIST
)
949 qualified_name_lookup_error (type
, name
, decl
, input_location
);
951 error ("%qD is not a static data member", decl
);
952 inform (input_location
, "determining value of %qs", "operator<=>");
954 return error_mark_node
;
959 /* Look up a <compare> comparison category type in std. */
962 lookup_comparison_category (comp_cat_tag tag
,
963 tsubst_flags_t complain
= tf_warning_or_error
)
965 if (tree cached
= comp_cat_cache
[tag
])
968 tree name
= get_identifier (comp_cat_info
[tag
].name
);
969 tree decl
= lookup_qualified_name (std_node
, name
);
970 if (TREE_CODE (decl
) != TYPE_DECL
)
972 if (complain
& tf_error
)
974 auto_diagnostic_group d
;
975 if (decl
== error_mark_node
|| TREE_CODE (decl
) == TREE_LIST
)
976 qualified_name_lookup_error (std_node
, name
, decl
, input_location
);
978 error ("%qD is not a type", decl
);
979 inform (input_location
, "forming type of %qs", "operator<=>");
981 return error_mark_node
;
983 /* Also make sure we can look up the value members now, since we won't
984 really use them until genericize time. */
985 tree type
= TREE_TYPE (decl
);
986 for (int i
= 0; i
< 4; ++i
)
988 const char *p
= comp_cat_info
[tag
].members
[i
];
990 if (lookup_comparison_result (type
, p
, complain
)
992 return error_mark_node
;
994 return comp_cat_cache
[tag
] = type
;
997 /* Wrapper that takes the tag rather than the type. */
1000 lookup_comparison_result (comp_cat_tag tag
, const char *name_str
,
1001 tsubst_flags_t complain
= tf_warning_or_error
)
1003 tree type
= lookup_comparison_category (tag
, complain
);
1004 return lookup_comparison_result (type
, name_str
, complain
);
1007 /* Wrapper that takes the index into the members array instead of the name. */
1010 lookup_comparison_result (comp_cat_tag tag
, tree type
, int idx
)
1012 const char *name_str
= comp_cat_info
[tag
].members
[idx
];
1015 return lookup_comparison_result (type
, name_str
);
1018 /* Does TYPE correspond to TAG? */
1021 is_cat (tree type
, comp_cat_tag tag
)
1023 tree name
= TYPE_LINKAGE_IDENTIFIER (type
);
1024 return id_equal (name
, comp_cat_info
[tag
].name
);
1027 /* Return the comp_cat_tag for TYPE. */
1030 cat_tag_for (tree type
)
1032 if (!CLASS_TYPE_P (type
) || !decl_in_std_namespace_p (TYPE_MAIN_DECL (type
)))
1034 for (int i
= 0; i
< cc_last
; ++i
)
1036 comp_cat_tag tag
= (comp_cat_tag
)i
;
1037 if (is_cat (type
, tag
))
1043 /* Return the comparison category tag of a <=> expression with non-class type
1047 spaceship_comp_cat (tree optype
)
1049 if (INTEGRAL_OR_ENUMERATION_TYPE_P (optype
) || TYPE_PTROBV_P (optype
))
1050 return cc_strong_ordering
;
1051 else if (SCALAR_FLOAT_TYPE_P (optype
))
1052 return cc_partial_ordering
;
1054 /* ??? should vector <=> produce a vector of one of the above? */
1058 /* Return the comparison category type of a <=> expression with non-class type
1062 spaceship_type (tree optype
, tsubst_flags_t complain
)
1064 comp_cat_tag tag
= spaceship_comp_cat (optype
);
1065 return lookup_comparison_category (tag
, complain
);
1068 /* Turn <=> with type TYPE and operands OP0 and OP1 into GENERIC.
1069 This is also used by build_comparison_op for fallback to op< and op==
1070 in a defaulted op<=>. */
1073 genericize_spaceship (location_t loc
, tree type
, tree op0
, tree op1
)
1075 /* ??? maybe optimize based on knowledge of representation? */
1076 comp_cat_tag tag
= cat_tag_for (type
);
1078 if (tag
== cc_last
&& is_auto (type
))
1080 /* build_comparison_op is checking to see if we want to suggest changing
1081 the op<=> return type from auto to a specific comparison category; any
1082 category will do for now. */
1083 tag
= cc_strong_ordering
;
1084 type
= lookup_comparison_category (tag
, tf_none
);
1085 if (type
== error_mark_node
)
1086 return error_mark_node
;
1089 gcc_checking_assert (tag
< cc_last
);
1092 bool scalar
= SCALAR_TYPE_P (TREE_TYPE (op0
));
1095 op0
= save_expr (op0
);
1096 op1
= save_expr (op1
);
1099 tree gt
= lookup_comparison_result (tag
, type
, 1);
1101 int flags
= LOOKUP_NORMAL
;
1102 tsubst_flags_t complain
= tf_none
;
1105 if (tag
== cc_partial_ordering
)
1107 /* op0 == op1 ? equivalent : op0 < op1 ? less :
1108 op1 < op0 ? greater : unordered */
1109 tree uo
= lookup_comparison_result (tag
, type
, 3);
1112 /* For scalars use the low level operations; using build_new_op causes
1113 trouble with constexpr eval in the middle of genericize (100367). */
1114 comp
= fold_build2 (LT_EXPR
, boolean_type_node
, op1
, op0
);
1115 r
= fold_build3 (COND_EXPR
, type
, comp
, gt
, uo
);
1119 comp
= build_new_op (loc
, LT_EXPR
, flags
, op1
, op0
, complain
);
1120 r
= build_conditional_expr (loc
, comp
, gt
, uo
, complain
);
1124 /* op0 == op1 ? equal : op0 < op1 ? less : greater */
1127 tree lt
= lookup_comparison_result (tag
, type
, 2);
1130 comp
= fold_build2 (LT_EXPR
, boolean_type_node
, op0
, op1
);
1131 r
= fold_build3 (COND_EXPR
, type
, comp
, lt
, r
);
1135 comp
= build_new_op (loc
, LT_EXPR
, flags
, op0
, op1
, complain
);
1136 r
= build_conditional_expr (loc
, comp
, lt
, r
, complain
);
1139 tree eq
= lookup_comparison_result (tag
, type
, 0);
1142 comp
= fold_build2 (EQ_EXPR
, boolean_type_node
, op0
, op1
);
1143 r
= fold_build3 (COND_EXPR
, type
, comp
, eq
, r
);
1147 comp
= build_new_op (loc
, EQ_EXPR
, flags
, op0
, op1
, complain
);
1148 r
= build_conditional_expr (loc
, comp
, eq
, r
, complain
);
1154 /* Check that the signature of a defaulted comparison operator is
1158 early_check_defaulted_comparison (tree fn
)
1160 location_t loc
= DECL_SOURCE_LOCATION (fn
);
1162 if (DECL_CLASS_SCOPE_P (fn
))
1163 ctx
= DECL_CONTEXT (fn
);
1165 ctx
= DECL_FRIEND_CONTEXT (fn
);
1168 if (cxx_dialect
< cxx20
)
1170 error_at (loc
, "defaulted %qD only available with %<-std=c++20%> or "
1171 "%<-std=gnu++20%>", fn
);
1175 if (!DECL_OVERLOADED_OPERATOR_IS (fn
, SPACESHIP_EXPR
)
1176 && !same_type_p (TREE_TYPE (TREE_TYPE (fn
)), boolean_type_node
))
1178 diagnostic_t kind
= DK_UNSPECIFIED
;
1180 if (is_auto (TREE_TYPE (fn
)))
1184 emit_diagnostic (kind
, loc
, opt
,
1185 "defaulted %qD must return %<bool%>", fn
);
1186 if (kind
== DK_ERROR
)
1190 bool mem
= DECL_IOBJ_MEMBER_FUNCTION_P (fn
);
1191 if (mem
&& type_memfn_quals (TREE_TYPE (fn
)) != TYPE_QUAL_CONST
)
1193 error_at (loc
, "defaulted %qD must be %<const%>", fn
);
1196 if (mem
&& type_memfn_rqual (TREE_TYPE (fn
)) == REF_QUAL_RVALUE
)
1198 error_at (loc
, "defaulted %qD must not have %<&&%> ref-qualifier", fn
);
1201 tree parmnode
= FUNCTION_FIRST_USER_PARMTYPE (fn
);
1202 bool saw_byval
= false;
1203 bool saw_byref
= mem
;
1204 bool saw_bad
= false;
1205 for (; parmnode
!= void_list_node
; parmnode
= TREE_CHAIN (parmnode
))
1207 tree parmtype
= TREE_VALUE (parmnode
);
1208 if (CLASS_TYPE_P (parmtype
))
1210 else if (TREE_CODE (parmtype
) == REFERENCE_TYPE
1211 && !TYPE_REF_IS_RVALUE (parmtype
)
1212 && TYPE_QUALS (TREE_TYPE (parmtype
)) == TYPE_QUAL_CONST
)
1215 parmtype
= TREE_TYPE (parmtype
);
1220 if (!saw_bad
&& !ctx
)
1222 /* Defaulted outside the class body. */
1223 ctx
= TYPE_MAIN_VARIANT (parmtype
);
1224 if (!is_friend (ctx
, fn
))
1225 error_at (loc
, "defaulted %qD is not a friend of %qT", fn
, ctx
);
1227 else if (!same_type_ignoring_top_level_qualifiers_p (parmtype
, ctx
))
1231 if (saw_bad
|| (saw_byval
&& saw_byref
))
1233 if (DECL_IOBJ_MEMBER_FUNCTION_P (fn
))
1234 error_at (loc
, "defaulted member %qD must have parameter type "
1235 "%<const %T&%>", fn
, ctx
);
1237 error_at (loc
, "defaulted %qD must have parameters of either type "
1238 "%<const %T&%> or %qT", fn
, ctx
, ctx
);
1240 error_at (loc
, "defaulted %qD must have parameters of either type "
1241 "%<const %T&%> or %qT, not both", fn
, ctx
, ctx
);
1245 /* We still need to deduce deleted/constexpr/noexcept and maybe return. */
1246 DECL_MAYBE_DELETED (fn
) = ok
;
1251 /* Subroutine of build_comparison_op. Given the vec of memberwise
1252 comparisons COMPS, calculate the overall comparison category for
1256 common_comparison_type (vec
<tree
> &comps
)
1258 tree seen
[cc_last
] = {};
1260 for (unsigned i
= 0; i
< comps
.length(); ++i
)
1262 tree comp
= comps
[i
];
1263 if (TREE_CODE (comp
) == TREE_LIST
)
1264 comp
= TREE_VALUE (comp
);
1265 tree ctype
= TREE_TYPE (comp
);
1266 comp_cat_tag tag
= cat_tag_for (ctype
);
1267 /* build_comparison_op already checked this. */
1268 gcc_checking_assert (tag
< cc_last
);
1272 /* Otherwise, if at least one T i is std::partial_ordering, U is
1273 std::partial_ordering. */
1274 if (tree t
= seen
[cc_partial_ordering
]) return t
;
1276 /* Otherwise, if at least one T i is std::weak_ordering, U is
1277 std::weak_ordering. */
1278 if (tree t
= seen
[cc_weak_ordering
]) return t
;
1280 /* Otherwise, U is std::strong_ordering. */
1281 if (tree t
= seen
[cc_strong_ordering
]) return t
;
1282 return lookup_comparison_category (cc_strong_ordering
);
1285 /* Data structure for build_comparison_op. */
1291 tsubst_flags_t complain
;
1293 comp_cat_tag retcat
;
1299 comp_info (tree fndecl
, tsubst_flags_t complain
)
1300 : fndecl (fndecl
), complain (complain
)
1302 loc
= DECL_SOURCE_LOCATION (fndecl
);
1304 first_time
= DECL_MAYBE_DELETED (fndecl
);
1305 DECL_MAYBE_DELETED (fndecl
) = false;
1307 /* Do we want to try to set constexpr? */
1308 was_constexp
= DECL_DECLARED_CONSTEXPR_P (fndecl
);
1309 constexp
= first_time
;
1311 /* Set this for var_in_constexpr_fn. */
1312 DECL_DECLARED_CONSTEXPR_P (fndecl
) = true;
1314 /* Do we want to try to set noexcept? */
1318 tree raises
= TYPE_RAISES_EXCEPTIONS (TREE_TYPE (fndecl
));
1319 if (raises
&& !UNEVALUATED_NOEXCEPT_SPEC_P (raises
))
1320 /* There was an explicit exception-specification. */
1325 /* EXPR is an expression built as part of the function body.
1326 Adjust the properties appropriately. */
1327 void check (tree expr
)
1329 if (expr
== error_mark_node
)
1330 DECL_DELETED_FN (fndecl
) = true;
1331 if ((constexp
|| was_constexp
)
1332 && !potential_rvalue_constant_expression (expr
))
1335 require_potential_rvalue_constant_expression_fncheck (expr
);
1339 if (noex
&& !expr_noexcept_p (expr
, tf_none
))
1347 DECL_DECLARED_CONSTEXPR_P (fndecl
) = constexp
|| was_constexp
;
1348 tree raises
= TYPE_RAISES_EXCEPTIONS (TREE_TYPE (fndecl
));
1349 if (!raises
|| UNEVALUATED_NOEXCEPT_SPEC_P (raises
))
1351 raises
= noex
? noexcept_true_spec
: noexcept_false_spec
;
1352 TREE_TYPE (fndecl
) = build_exception_variant (TREE_TYPE (fndecl
),
1359 /* Subroutine of build_comparison_op, to compare a single subobject. */
1362 do_one_comp (location_t loc
, const comp_info
&info
, tree sub
, tree lhs
, tree rhs
)
1364 const tree_code code
= info
.code
;
1365 const tree fndecl
= info
.fndecl
;
1366 const comp_cat_tag retcat
= info
.retcat
;
1367 const tsubst_flags_t complain
= info
.complain
;
1369 tree overload
= NULL_TREE
;
1370 int flags
= LOOKUP_NORMAL
| LOOKUP_NONVIRTUAL
| LOOKUP_DEFAULTED
;
1371 /* If we have an explicit comparison category return type we can fall back
1372 to </=, so don't give an error yet if <=> lookup fails. */
1373 bool tentative
= retcat
!= cc_last
;
1374 tree comp
= build_new_op (loc
, code
, flags
, lhs
, rhs
,
1375 NULL_TREE
, NULL_TREE
, &overload
,
1376 tentative
? tf_none
: complain
);
1378 if (code
!= SPACESHIP_EXPR
)
1381 tree rettype
= TREE_TYPE (TREE_TYPE (fndecl
));
1383 if (comp
== error_mark_node
)
1385 if (overload
== NULL_TREE
&& (tentative
|| complain
))
1387 /* No viable <=>, try using op< and op==. */
1388 tree lteq
= genericize_spaceship (loc
, rettype
, lhs
, rhs
);
1389 if (lteq
!= error_mark_node
)
1391 /* We found usable < and ==. */
1392 if (retcat
!= cc_last
)
1393 /* Return type is a comparison category, use them. */
1395 else if (complain
& tf_error
)
1396 /* Return type is auto, suggest changing it. */
1397 inform (info
.loc
, "changing the return type from %qs "
1398 "to a comparison category type will allow the "
1399 "comparison to use %qs and %qs", "auto",
1400 "operator<", "operator==");
1402 else if (tentative
&& complain
)
1403 /* No usable < and ==, give an error for op<=>. */
1404 build_new_op (loc
, code
, flags
, lhs
, rhs
, complain
);
1406 if (comp
== error_mark_node
)
1407 return error_mark_node
;
1410 if (FNDECL_USED_AUTO (fndecl
)
1411 && cat_tag_for (TREE_TYPE (comp
)) == cc_last
)
1413 /* The operator function is defined as deleted if ... Ri is not a
1414 comparison category type. */
1415 if (complain
& tf_error
)
1417 "three-way comparison of %qD has type %qT, not a "
1418 "comparison category type", sub
, TREE_TYPE (comp
));
1419 return error_mark_node
;
1421 else if (!FNDECL_USED_AUTO (fndecl
)
1422 && !can_convert (rettype
, TREE_TYPE (comp
), complain
))
1424 if (complain
& tf_error
)
1426 "three-way comparison of %qD has type %qT, which "
1427 "does not convert to %qT",
1428 sub
, TREE_TYPE (comp
), rettype
);
1429 return error_mark_node
;
1435 /* Build up the definition of a defaulted comparison operator. Unlike other
1436 defaulted functions that use synthesized_method_walk to determine whether
1437 the function is e.g. deleted, for comparisons we use the same code. We try
1438 to use synthesize_method at the earliest opportunity and bail out if the
1439 function ends up being deleted. */
1442 build_comparison_op (tree fndecl
, bool defining
, tsubst_flags_t complain
)
1444 comp_info
info (fndecl
, complain
);
1446 if (!defining
&& !(complain
& tf_error
) && !DECL_MAYBE_DELETED (fndecl
))
1449 int flags
= LOOKUP_NORMAL
;
1450 const ovl_op_info_t
*op
= IDENTIFIER_OVL_OP_INFO (DECL_NAME (fndecl
));
1451 tree_code code
= info
.code
= op
->tree_code
;
1453 tree lhs
= DECL_ARGUMENTS (fndecl
);
1454 tree rhs
= DECL_CHAIN (lhs
);
1455 if (is_this_parameter (lhs
))
1456 lhs
= cp_build_fold_indirect_ref (lhs
);
1458 lhs
= convert_from_reference (lhs
);
1459 rhs
= convert_from_reference (rhs
);
1460 tree ctype
= TYPE_MAIN_VARIANT (TREE_TYPE (lhs
));
1461 gcc_assert (!defining
|| COMPLETE_TYPE_P (ctype
));
1463 iloc_sentinel
ils (info
.loc
);
1465 /* A defaulted comparison operator function for class C is defined as
1466 deleted if ... C has variant members. */
1467 if (TREE_CODE (ctype
) == UNION_TYPE
1468 && next_aggregate_field (TYPE_FIELDS (ctype
)))
1470 if (complain
& tf_error
)
1471 inform (info
.loc
, "cannot default compare union %qT", ctype
);
1472 DECL_DELETED_FN (fndecl
) = true;
1476 tree compound_stmt
= NULL_TREE
;
1478 compound_stmt
= begin_compound_stmt (0);
1480 ++cp_unevaluated_operand
;
1482 tree rettype
= TREE_TYPE (TREE_TYPE (fndecl
));
1483 if (code
!= SPACESHIP_EXPR
&& is_auto (rettype
))
1485 rettype
= boolean_type_node
;
1486 apply_deduced_return_type (fndecl
, rettype
);
1489 if (code
== EQ_EXPR
|| code
== SPACESHIP_EXPR
)
1491 comp_cat_tag
&retcat
= (info
.retcat
= cc_last
);
1492 if (code
== SPACESHIP_EXPR
&& !FNDECL_USED_AUTO (fndecl
))
1493 retcat
= cat_tag_for (rettype
);
1496 auto_vec
<tree
> comps
;
1498 /* Compare the base subobjects. We handle them this way, rather than in
1499 the field loop below, because maybe_instantiate_noexcept might bring
1500 us here before we've built the base fields. */
1501 for (tree base_binfo
: BINFO_BASE_BINFOS (TYPE_BINFO (ctype
)))
1504 = build_base_path (PLUS_EXPR
, lhs
, base_binfo
, 0, complain
);
1506 = build_base_path (PLUS_EXPR
, rhs
, base_binfo
, 0, complain
);
1508 location_t loc
= DECL_SOURCE_LOCATION (TYPE_MAIN_DECL (ctype
));
1509 tree comp
= do_one_comp (loc
, info
, BINFO_TYPE (base_binfo
),
1510 lhs_base
, rhs_base
);
1511 if (comp
== error_mark_node
)
1517 comps
.safe_push (comp
);
1520 /* Now compare the field subobjects. */
1521 for (tree field
= next_aggregate_field (TYPE_FIELDS (ctype
));
1523 field
= next_aggregate_field (DECL_CHAIN (field
)))
1525 if (DECL_VIRTUAL_P (field
) || DECL_FIELD_IS_BASE (field
))
1526 /* We ignore the vptr, and we already handled bases. */
1529 tree expr_type
= TREE_TYPE (field
);
1531 location_t field_loc
= DECL_SOURCE_LOCATION (field
);
1533 /* A defaulted comparison operator function for class C is defined as
1534 deleted if any non-static data member of C is of reference type or
1535 C has variant members. */
1536 if (TREE_CODE (expr_type
) == REFERENCE_TYPE
)
1538 if (complain
& tf_error
)
1539 inform (field_loc
, "cannot default compare "
1540 "reference member %qD", field
);
1544 else if (ANON_UNION_TYPE_P (expr_type
)
1545 && next_aggregate_field (TYPE_FIELDS (expr_type
)))
1547 if (complain
& tf_error
)
1548 inform (field_loc
, "cannot default compare "
1549 "anonymous union member");
1554 tree lhs_mem
= build3_loc (field_loc
, COMPONENT_REF
, expr_type
, lhs
,
1556 tree rhs_mem
= build3_loc (field_loc
, COMPONENT_REF
, expr_type
, rhs
,
1558 tree loop_indexes
= NULL_TREE
;
1559 while (TREE_CODE (expr_type
) == ARRAY_TYPE
)
1561 /* Flexible array member. */
1562 if (TYPE_DOMAIN (expr_type
) == NULL_TREE
1563 || TYPE_MAX_VALUE (TYPE_DOMAIN (expr_type
)) == NULL_TREE
)
1565 if (complain
& tf_error
)
1566 inform (field_loc
, "cannot default compare "
1567 "flexible array member");
1571 tree maxval
= TYPE_MAX_VALUE (TYPE_DOMAIN (expr_type
));
1572 /* [0] array. No subobjects to compare, just skip it. */
1573 if (integer_all_onesp (maxval
))
1576 /* [1] array, no loop needed, just add [0] ARRAY_REF.
1577 Similarly if !defining. */
1578 if (integer_zerop (maxval
) || !defining
)
1579 idx
= size_zero_node
;
1580 /* Some other array, will need runtime loop. */
1583 idx
= force_target_expr (sizetype
, maxval
, complain
);
1584 loop_indexes
= tree_cons (idx
, NULL_TREE
, loop_indexes
);
1586 expr_type
= TREE_TYPE (expr_type
);
1587 lhs_mem
= build4_loc (field_loc
, ARRAY_REF
, expr_type
, lhs_mem
,
1588 idx
, NULL_TREE
, NULL_TREE
);
1589 rhs_mem
= build4_loc (field_loc
, ARRAY_REF
, expr_type
, rhs_mem
,
1590 idx
, NULL_TREE
, NULL_TREE
);
1592 if (TREE_CODE (expr_type
) == ARRAY_TYPE
)
1595 tree comp
= do_one_comp (field_loc
, info
, field
, lhs_mem
, rhs_mem
);
1596 if (comp
== error_mark_node
)
1602 /* Most of the time, comp is the expression that should be evaluated
1603 to compare the two members. If the expression needs to be
1604 evaluated more than once in a loop, it will be a TREE_LIST
1605 instead, whose TREE_VALUE is the expression for one array element,
1606 TREE_PURPOSE is innermost iterator temporary and if the array
1607 is multidimensional, TREE_CHAIN will contain another TREE_LIST
1608 with second innermost iterator in its TREE_PURPOSE and so on. */
1611 TREE_VALUE (loop_indexes
) = comp
;
1612 comp
= loop_indexes
;
1614 comps
.safe_push (comp
);
1616 if (code
== SPACESHIP_EXPR
&& is_auto (rettype
))
1618 rettype
= common_comparison_type (comps
);
1619 apply_deduced_return_type (fndecl
, rettype
);
1623 DECL_DELETED_FN (fndecl
) = true;
1626 for (unsigned i
= 0; i
< comps
.length(); ++i
)
1628 tree comp
= comps
[i
];
1629 tree eq
, retval
= NULL_TREE
, if_
= NULL_TREE
;
1630 tree loop_indexes
= NULL_TREE
;
1633 if (TREE_CODE (comp
) == TREE_LIST
)
1635 loop_indexes
= comp
;
1636 comp
= TREE_VALUE (comp
);
1637 loop_indexes
= nreverse (loop_indexes
);
1638 for (tree loop_index
= loop_indexes
; loop_index
;
1639 loop_index
= TREE_CHAIN (loop_index
))
1641 tree for_stmt
= begin_for_stmt (NULL_TREE
, NULL_TREE
);
1642 tree idx
= TREE_PURPOSE (loop_index
);
1643 tree maxval
= TARGET_EXPR_INITIAL (idx
);
1644 TARGET_EXPR_INITIAL (idx
) = size_zero_node
;
1646 finish_init_stmt (for_stmt
);
1647 finish_for_cond (build2 (LE_EXPR
, boolean_type_node
, idx
,
1648 maxval
), for_stmt
, false, 0,
1650 finish_for_expr (cp_build_unary_op (PREINCREMENT_EXPR
,
1651 TARGET_EXPR_SLOT (idx
),
1654 /* Store in TREE_VALUE the for_stmt tree, so that we can
1655 later on call finish_for_stmt on it (in the reverse
1657 TREE_VALUE (loop_index
) = for_stmt
;
1659 loop_indexes
= nreverse (loop_indexes
);
1661 if_
= begin_if_stmt ();
1663 /* Spaceship is specified to use !=, but for the comparison category
1664 types, != is equivalent to !(==), so let's use == directly. */
1665 if (code
== EQ_EXPR
)
1667 /* if (x==y); else return false; */
1669 retval
= boolean_false_node
;
1673 /* if (auto v = x<=>y, v == 0); else return v; */
1674 if (TREE_CODE (comp
) == SPACESHIP_EXPR
)
1675 TREE_TYPE (comp
) = rettype
;
1677 comp
= build_static_cast (input_location
, rettype
, comp
,
1682 tree var
= create_temporary_var (rettype
);
1683 DECL_NAME (var
) = get_identifier ("retval");
1685 cp_finish_decl (var
, comp
, false, NULL_TREE
, flags
);
1686 comp
= retval
= var
;
1688 eq
= build_new_op (info
.loc
, EQ_EXPR
, flags
, comp
,
1689 integer_zero_node
, NULL_TREE
, NULL_TREE
,
1692 tree ceq
= contextual_conv_bool (eq
, complain
);
1696 finish_if_stmt_cond (ceq
, if_
);
1697 finish_then_clause (if_
);
1698 begin_else_clause (if_
);
1699 finish_return_stmt (retval
);
1700 finish_else_clause (if_
);
1701 finish_if_stmt (if_
);
1702 for (tree loop_index
= loop_indexes
; loop_index
;
1703 loop_index
= TREE_CHAIN (loop_index
))
1704 finish_for_stmt (TREE_VALUE (loop_index
));
1710 if (code
== EQ_EXPR
)
1711 val
= boolean_true_node
;
1714 tree seql
= lookup_comparison_result (cc_strong_ordering
,
1716 val
= build_static_cast (input_location
, rettype
, seql
,
1719 finish_return_stmt (val
);
1722 else if (code
== NE_EXPR
)
1724 tree comp
= build_new_op (info
.loc
, EQ_EXPR
, flags
, lhs
, rhs
,
1725 NULL_TREE
, NULL_TREE
, NULL
, complain
);
1726 comp
= contextual_conv_bool (comp
, complain
);
1730 tree neg
= build1 (TRUTH_NOT_EXPR
, boolean_type_node
, comp
);
1731 finish_return_stmt (neg
);
1736 tree comp
= build_new_op (info
.loc
, SPACESHIP_EXPR
, flags
, lhs
, rhs
,
1737 NULL_TREE
, NULL_TREE
, NULL
, complain
);
1738 tree comp2
= build_new_op (info
.loc
, code
, flags
, comp
, integer_zero_node
,
1739 NULL_TREE
, NULL_TREE
, NULL
, complain
);
1742 finish_return_stmt (comp2
);
1747 finish_compound_stmt (compound_stmt
);
1749 --cp_unevaluated_operand
;
1752 /* True iff DECL is an implicitly-declared special member function with no real
1753 source location, so we can use its DECL_SOURCE_LOCATION to remember where we
1754 triggered its synthesis. */
1757 decl_remember_implicit_trigger_p (tree decl
)
1759 if (!DECL_ARTIFICIAL (decl
))
1761 special_function_kind sfk
= special_function_p (decl
);
1762 /* Inherited constructors have the location of their using-declaration, and
1763 operator== has the location of the corresponding operator<=>. */
1764 return (sfk
!= sfk_inheriting_constructor
1765 && sfk
!= sfk_comparison
);
1768 /* Synthesize FNDECL, a non-static member function. */
1771 synthesize_method (tree fndecl
)
1773 bool need_body
= true;
1775 location_t save_input_location
= input_location
;
1776 int error_count
= errorcount
;
1777 int warning_count
= warningcount
+ werrorcount
;
1778 special_function_kind sfk
= special_function_p (fndecl
);
1780 /* Reset the source location, we might have been previously
1781 deferred, and thus have saved where we were first needed. */
1782 if (decl_remember_implicit_trigger_p (fndecl
))
1783 DECL_SOURCE_LOCATION (fndecl
)
1784 = DECL_SOURCE_LOCATION (TYPE_NAME (DECL_CONTEXT (fndecl
)));
1786 /* If we've been asked to synthesize a clone, just synthesize the
1787 cloned function instead. Doing so will automatically fill in the
1788 body for the clone. */
1789 if (DECL_CLONED_FUNCTION_P (fndecl
))
1790 fndecl
= DECL_CLONED_FUNCTION (fndecl
);
1792 /* We may be in the middle of deferred access check. Disable
1794 push_deferring_access_checks (dk_no_deferred
);
1796 bool push_to_top
= maybe_push_to_top_level (fndecl
);
1798 input_location
= DECL_SOURCE_LOCATION (fndecl
);
1800 start_preparsed_function (fndecl
, NULL_TREE
, SF_DEFAULT
| SF_PRE_PARSED
);
1801 stmt
= begin_function_body ();
1803 if (DECL_ASSIGNMENT_OPERATOR_P (fndecl
)
1804 && DECL_OVERLOADED_OPERATOR_IS (fndecl
, NOP_EXPR
))
1806 do_build_copy_assign (fndecl
);
1809 else if (DECL_CONSTRUCTOR_P (fndecl
))
1811 tree arg_chain
= FUNCTION_FIRST_USER_PARMTYPE (fndecl
);
1812 if (arg_chain
!= void_list_node
)
1813 do_build_copy_constructor (fndecl
);
1815 finish_mem_initializers (NULL_TREE
);
1817 else if (sfk
== sfk_comparison
)
1819 /* Pass tf_none so the function is just deleted if there's a problem. */
1820 build_comparison_op (fndecl
, true, tf_none
);
1824 /* If we haven't yet generated the body of the function, just
1825 generate an empty compound statement. */
1829 compound_stmt
= begin_compound_stmt (BCS_FN_BODY
);
1830 finish_compound_stmt (compound_stmt
);
1833 finish_function_body (stmt
);
1834 finish_function (/*inline_p=*/false);
1836 if (!DECL_DELETED_FN (fndecl
))
1837 expand_or_defer_fn (fndecl
);
1839 input_location
= save_input_location
;
1841 maybe_pop_from_top_level (push_to_top
);
1843 pop_deferring_access_checks ();
1845 if (error_count
!= errorcount
|| warning_count
!= warningcount
+ werrorcount
)
1846 if (DECL_ARTIFICIAL (fndecl
))
1847 inform (input_location
, "synthesized method %qD first required here",
1851 /* Like synthesize_method, but don't actually synthesize defaulted comparison
1852 methods if their class is still incomplete. Just deduce the return
1853 type in that case. */
1856 maybe_synthesize_method (tree fndecl
)
1858 if (special_function_p (fndecl
) == sfk_comparison
)
1860 tree lhs
= DECL_ARGUMENTS (fndecl
);
1861 if (is_this_parameter (lhs
))
1862 lhs
= cp_build_fold_indirect_ref (lhs
);
1864 lhs
= convert_from_reference (lhs
);
1865 tree ctype
= TYPE_MAIN_VARIANT (TREE_TYPE (lhs
));
1866 if (!COMPLETE_TYPE_P (ctype
))
1868 push_deferring_access_checks (dk_no_deferred
);
1869 build_comparison_op (fndecl
, false, tf_none
);
1870 pop_deferring_access_checks ();
1874 return synthesize_method (fndecl
);
1877 /* Build a reference to type TYPE with cv-quals QUALS, which is an
1878 rvalue if RVALUE is true. */
1881 build_stub_type (tree type
, int quals
, bool rvalue
)
1883 tree argtype
= cp_build_qualified_type (type
, quals
);
1884 return cp_build_reference_type (argtype
, rvalue
);
1887 /* Build a dummy glvalue from dereferencing a dummy reference of type
1891 build_stub_object (tree reftype
)
1893 if (!TYPE_REF_P (reftype
))
1894 reftype
= cp_build_reference_type (reftype
, /*rval*/true);
1895 tree stub
= build1 (CONVERT_EXPR
, reftype
, integer_one_node
);
1896 return convert_from_reference (stub
);
1899 /* Build a std::declval<TYPE>() expression and return it. */
1902 build_trait_object (tree type
)
1904 /* TYPE can't be a function with cv-/ref-qualifiers: std::declval is
1908 typename std::add_rvalue_reference<T>::type declval() noexcept;
1910 and std::add_rvalue_reference yields T when T is a function with
1911 cv- or ref-qualifiers, making the definition ill-formed. */
1912 if (FUNC_OR_METHOD_TYPE_P (type
)
1913 && (type_memfn_quals (type
) != TYPE_UNQUALIFIED
1914 || type_memfn_rqual (type
) != REF_QUAL_NONE
))
1915 return error_mark_node
;
1917 return build_stub_object (type
);
1920 /* Determine which function will be called when looking up NAME in TYPE,
1921 called with a single ARGTYPE argument, or no argument if ARGTYPE is
1922 null. FLAGS and COMPLAIN are as for build_new_method_call.
1924 Returns a FUNCTION_DECL if all is well.
1925 Returns NULL_TREE if overload resolution failed.
1926 Returns error_mark_node if the chosen function cannot be called. */
1929 locate_fn_flags (tree type
, tree name
, tree argtype
, int flags
,
1930 tsubst_flags_t complain
)
1932 tree ob
, fn
, fns
, binfo
, rval
;
1935 binfo
= TYPE_BINFO (type
);
1939 type
= BINFO_TYPE (binfo
);
1942 ob
= build_stub_object (cp_build_reference_type (type
, false));
1946 if (TREE_CODE (argtype
) == TREE_LIST
)
1948 for (tree elt
= argtype
; elt
&& elt
!= void_list_node
;
1949 elt
= TREE_CHAIN (elt
))
1951 tree type
= TREE_VALUE (elt
);
1952 tree arg
= build_stub_object (type
);
1953 vec_safe_push (args
, arg
);
1958 tree arg
= build_stub_object (argtype
);
1959 args
->quick_push (arg
);
1963 fns
= lookup_fnfields (binfo
, name
, 0, complain
);
1964 rval
= build_new_method_call (ob
, fns
, &args
, binfo
, flags
, &fn
, complain
);
1966 if (fn
&& rval
== error_mark_node
)
1972 /* Locate the dtor of TYPE. */
1975 get_dtor (tree type
, tsubst_flags_t complain
)
1977 tree fn
= locate_fn_flags (type
, complete_dtor_identifier
, NULL_TREE
,
1978 LOOKUP_NORMAL
, complain
);
1979 if (fn
== error_mark_node
)
1984 /* Locate the default ctor of TYPE. */
1987 locate_ctor (tree type
)
1991 push_deferring_access_checks (dk_no_check
);
1992 fn
= locate_fn_flags (type
, complete_ctor_identifier
, NULL_TREE
,
1993 LOOKUP_SPECULATIVE
, tf_none
);
1994 pop_deferring_access_checks ();
1995 if (fn
== error_mark_node
)
2000 /* Likewise, but give any appropriate errors. */
2003 get_default_ctor (tree type
)
2005 tree fn
= locate_fn_flags (type
, complete_ctor_identifier
, NULL_TREE
,
2006 LOOKUP_NORMAL
, tf_warning_or_error
);
2007 if (fn
== error_mark_node
)
2012 /* Locate the copy ctor of TYPE. */
2015 get_copy_ctor (tree type
, tsubst_flags_t complain
)
2017 int quals
= (TYPE_HAS_CONST_COPY_CTOR (type
)
2018 ? TYPE_QUAL_CONST
: TYPE_UNQUALIFIED
);
2019 tree argtype
= build_stub_type (type
, quals
, false);
2020 tree fn
= locate_fn_flags (type
, complete_ctor_identifier
, argtype
,
2021 LOOKUP_NORMAL
, complain
);
2022 if (fn
== error_mark_node
)
2027 /* Locate the copy assignment operator of TYPE. */
2030 get_copy_assign (tree type
)
2032 int quals
= (TYPE_HAS_CONST_COPY_ASSIGN (type
)
2033 ? TYPE_QUAL_CONST
: TYPE_UNQUALIFIED
);
2034 tree argtype
= build_stub_type (type
, quals
, false);
2035 tree fn
= locate_fn_flags (type
, assign_op_identifier
, argtype
,
2036 LOOKUP_NORMAL
, tf_warning_or_error
);
2037 if (fn
== error_mark_node
)
2042 /* walk_tree helper function for is_trivially_xible. If *TP is a call,
2043 return it if it calls something other than a trivial special member
2047 check_nontriv (tree
*tp
, int *, void *)
2049 tree fn
= cp_get_callee (*tp
);
2050 if (fn
== NULL_TREE
)
2053 if (TREE_CODE (fn
) == ADDR_EXPR
)
2054 fn
= TREE_OPERAND (fn
, 0);
2056 if (TREE_CODE (fn
) != FUNCTION_DECL
2057 || !trivial_fn_p (fn
))
2062 /* Return declval<T>() = declval<U>() treated as an unevaluated operand. */
2065 assignable_expr (tree to
, tree from
)
2067 cp_unevaluated cp_uneval_guard
;
2068 to
= build_trait_object (to
);
2069 from
= build_trait_object (from
);
2070 tree r
= cp_build_modify_expr (input_location
, to
, NOP_EXPR
, from
, tf_none
);
2074 /* The predicate condition for a template specialization
2075 is_constructible<T, Args...> shall be satisfied if and only if the
2076 following variable definition would be well-formed for some invented
2077 variable t: T t(create<Args>()...);
2079 Return something equivalent in well-formedness and triviality. */
2082 constructible_expr (tree to
, tree from
)
2085 cp_unevaluated cp_uneval_guard
;
2086 const int len
= TREE_VEC_LENGTH (from
);
2087 if (CLASS_TYPE_P (to
))
2090 vec
<tree
, va_gc
> *args
= NULL
;
2091 if (!TYPE_REF_P (to
))
2092 to
= cp_build_reference_type (to
, /*rval*/false);
2093 tree ob
= build_stub_object (to
);
2095 expr
= build_value_init (ctype
, tf_none
);
2098 vec_alloc (args
, len
);
2099 for (tree arg
: tree_vec_range (from
))
2100 args
->quick_push (build_stub_object (arg
));
2101 expr
= build_special_member_call (ob
, complete_ctor_identifier
, &args
,
2102 ctype
, LOOKUP_NORMAL
, tf_none
);
2104 if (expr
== error_mark_node
)
2105 return error_mark_node
;
2106 /* The current state of the standard vis-a-vis LWG 2116 is that
2107 is_*constructible involves destruction as well. */
2108 if (type_build_dtor_call (ctype
))
2110 tree dtor
= build_special_member_call (ob
, complete_dtor_identifier
,
2111 NULL
, ctype
, LOOKUP_NORMAL
,
2113 if (dtor
== error_mark_node
)
2114 return error_mark_node
;
2115 if (!TYPE_HAS_TRIVIAL_DESTRUCTOR (ctype
))
2116 expr
= build2 (COMPOUND_EXPR
, void_type_node
, expr
, dtor
);
2122 return build_value_init (strip_array_types (to
), tf_none
);
2125 if (cxx_dialect
< cxx20
)
2126 /* Too many initializers. */
2127 return error_mark_node
;
2129 /* In C++20 this is well-formed:
2132 which means that std::is_constructible_v<int[2], int, int>
2134 vec
<constructor_elt
, va_gc
> *v
;
2136 for (tree arg
: tree_vec_range (from
))
2138 tree stub
= build_stub_object (arg
);
2139 constructor_elt elt
= { NULL_TREE
, stub
};
2140 v
->quick_push (elt
);
2142 from
= build_constructor (init_list_type_node
, v
);
2143 CONSTRUCTOR_IS_DIRECT_INIT (from
) = true;
2144 CONSTRUCTOR_IS_PAREN_INIT (from
) = true;
2147 from
= build_stub_object (TREE_VEC_ELT (from
, 0));
2148 expr
= perform_direct_initialization_if_possible (to
, from
,
2151 /* If t(e) didn't work, maybe t{e} will. */
2152 if (expr
== NULL_TREE
2154 && cxx_dialect
>= cxx20
)
2156 from
= build_constructor_single (init_list_type_node
, NULL_TREE
,
2158 CONSTRUCTOR_IS_DIRECT_INIT (from
) = true;
2159 CONSTRUCTOR_IS_PAREN_INIT (from
) = true;
2160 expr
= perform_direct_initialization_if_possible (to
, from
,
2168 /* Returns a tree iff TO is assignable (if CODE is MODIFY_EXPR) or
2169 constructible (otherwise) from FROM, which is a single type for
2170 assignment or a list of types for construction. */
2173 is_xible_helper (enum tree_code code
, tree to
, tree from
, bool trivial
)
2175 to
= complete_type (to
);
2176 deferring_access_check_sentinel
acs (dk_no_deferred
);
2177 if (VOID_TYPE_P (to
) || ABSTRACT_CLASS_TYPE_P (to
)
2178 || (from
&& FUNC_OR_METHOD_TYPE_P (from
)
2179 && (TYPE_READONLY (from
) || FUNCTION_REF_QUALIFIED (from
))))
2180 return error_mark_node
;
2182 if (code
== MODIFY_EXPR
)
2183 expr
= assignable_expr (to
, from
);
2184 else if (trivial
&& TREE_VEC_LENGTH (from
) > 1
2185 && cxx_dialect
< cxx20
)
2186 return error_mark_node
; // only 0- and 1-argument ctors can be trivial
2187 // before C++20 aggregate paren init
2188 else if (TREE_CODE (to
) == ARRAY_TYPE
&& !TYPE_DOMAIN (to
))
2189 return error_mark_node
; // can't construct an array of unknown bound
2191 expr
= constructible_expr (to
, from
);
2195 /* Returns true iff TO is trivially assignable (if CODE is MODIFY_EXPR) or
2196 constructible (otherwise) from FROM, which is a single type for
2197 assignment or a list of types for construction. */
2200 is_trivially_xible (enum tree_code code
, tree to
, tree from
)
2202 tree expr
= is_xible_helper (code
, to
, from
, /*trivial*/true);
2203 if (expr
== NULL_TREE
|| expr
== error_mark_node
)
2205 tree nt
= cp_walk_tree_without_duplicates (&expr
, check_nontriv
, NULL
);
2209 /* Returns true iff TO is nothrow assignable (if CODE is MODIFY_EXPR) or
2210 constructible (otherwise) from FROM, which is a single type for
2211 assignment or a list of types for construction. */
2214 is_nothrow_xible (enum tree_code code
, tree to
, tree from
)
2216 ++cp_noexcept_operand
;
2217 tree expr
= is_xible_helper (code
, to
, from
, /*trivial*/false);
2218 --cp_noexcept_operand
;
2219 if (expr
== NULL_TREE
|| expr
== error_mark_node
)
2221 return expr_noexcept_p (expr
, tf_none
);
2224 /* Returns true iff TO is assignable (if CODE is MODIFY_EXPR) or
2225 constructible (otherwise) from FROM, which is a single type for
2226 assignment or a list of types for construction. */
2229 is_xible (enum tree_code code
, tree to
, tree from
)
2231 tree expr
= is_xible_helper (code
, to
, from
, /*trivial*/false);
2232 if (expr
== error_mark_node
)
2237 /* Return true iff conjunction_v<is_reference<T>, is_constructible<T, U>> is
2238 true, and the initialization
2239 T t(VAL<U>); // DIRECT_INIT_P
2241 T t = VAL<U>; // !DIRECT_INIT_P
2242 binds t to a temporary object whose lifetime is extended.
2243 VAL<T> is defined in [meta.unary.prop]:
2244 -- If T is a reference or function type, VAL<T> is an expression with the
2245 same type and value category as declval<T>().
2246 -- Otherwise, VAL<T> is a prvalue that initially has type T. */
2249 ref_xes_from_temporary (tree to
, tree from
, bool direct_init_p
)
2251 /* Check is_reference<T>. */
2252 if (!TYPE_REF_P (to
))
2254 /* We don't check is_constructible<T, U>: if T isn't constructible
2255 from U, we won't be able to create a conversion. */
2256 tree val
= build_trait_object (from
);
2257 if (val
== error_mark_node
)
2259 if (!TYPE_REF_P (from
) && TREE_CODE (from
) != FUNCTION_TYPE
)
2260 val
= CLASS_TYPE_P (from
) ? force_rvalue (val
, tf_none
) : rvalue (val
);
2261 return ref_conv_binds_to_temporary (to
, val
, direct_init_p
).is_true ();
2264 /* Worker for is_{,nothrow_}convertible. Attempt to perform an implicit
2265 conversion from FROM to TO and return the result. */
2268 is_convertible_helper (tree from
, tree to
)
2270 if (VOID_TYPE_P (from
) && VOID_TYPE_P (to
))
2271 return integer_one_node
;
2273 tree expr
= build_trait_object (from
);
2274 /* std::is_{,nothrow_}convertible test whether the imaginary function
2277 To test() { return std::declval<From>(); }
2279 is well-formed. A function can't return a function. */
2280 if (FUNC_OR_METHOD_TYPE_P (to
) || expr
== error_mark_node
)
2281 return error_mark_node
;
2282 deferring_access_check_sentinel
acs (dk_no_deferred
);
2283 return perform_implicit_conversion (to
, expr
, tf_none
);
2286 /* Return true if FROM can be converted to TO using implicit conversions,
2287 or both FROM and TO are possibly cv-qualified void. NB: This doesn't
2288 implement the "Access checks are performed as if from a context unrelated
2289 to either type" restriction. */
2292 is_convertible (tree from
, tree to
)
2294 tree expr
= is_convertible_helper (from
, to
);
2295 if (expr
== error_mark_node
)
2300 /* Like is_convertible, but the conversion is also noexcept. */
2303 is_nothrow_convertible (tree from
, tree to
)
2305 tree expr
= is_convertible_helper (from
, to
);
2306 if (expr
== NULL_TREE
|| expr
== error_mark_node
)
2308 return expr_noexcept_p (expr
, tf_none
);
2311 /* Categorize various special_function_kinds. */
2312 #define SFK_CTOR_P(sfk) \
2313 ((sfk) >= sfk_constructor && (sfk) <= sfk_move_constructor)
2314 #define SFK_DTOR_P(sfk) \
2315 ((sfk) == sfk_destructor || (sfk) == sfk_virtual_destructor)
2316 #define SFK_ASSIGN_P(sfk) \
2317 ((sfk) == sfk_copy_assignment || (sfk) == sfk_move_assignment)
2318 #define SFK_COPY_P(sfk) \
2319 ((sfk) == sfk_copy_constructor || (sfk) == sfk_copy_assignment)
2320 #define SFK_MOVE_P(sfk) \
2321 ((sfk) == sfk_move_constructor || (sfk) == sfk_move_assignment)
2323 /* Subroutine of synthesized_method_walk. Update SPEC_P, TRIVIAL_P and
2324 DELETED_P or give an error message MSG with argument ARG. */
2327 process_subob_fn (tree fn
, special_function_kind sfk
, tree
*spec_p
,
2328 bool *trivial_p
, bool *deleted_p
, bool *constexpr_p
,
2329 bool diag
, tree arg
, bool dtor_from_ctor
= false)
2331 if (!fn
|| fn
== error_mark_node
)
2340 if (!maybe_instantiate_noexcept (fn
))
2341 *spec_p
= error_mark_node
;
2344 tree raises
= TYPE_RAISES_EXCEPTIONS (TREE_TYPE (fn
));
2345 *spec_p
= merge_exception_specifiers (*spec_p
, raises
);
2349 if (!trivial_fn_p (fn
) && !dtor_from_ctor
)
2353 if (TREE_CODE (arg
) == FIELD_DECL
2354 && TREE_CODE (DECL_CONTEXT (arg
)) == UNION_TYPE
)
2359 error ("union member %q+D with non-trivial %qD", arg
, fn
);
2363 if (constexpr_p
&& !DECL_DECLARED_CONSTEXPR_P (fn
))
2365 *constexpr_p
= false;
2368 inform (DECL_SOURCE_LOCATION (fn
),
2370 ? G_("defaulted destructor calls non-%<constexpr%> %qD")
2371 : G_("defaulted constructor calls non-%<constexpr%> %qD"),
2373 explain_invalid_constexpr_fn (fn
);
2378 /* Subroutine of synthesized_method_walk to allow recursion into anonymous
2379 aggregates. If DTOR_FROM_CTOR is true, we're walking subobject destructors
2380 called from a synthesized constructor, in which case we don't consider
2381 the triviality of the subobject destructor. */
2384 walk_field_subobs (tree fields
, special_function_kind sfk
, tree fnname
,
2385 int quals
, tree
*spec_p
, bool *trivial_p
,
2386 bool *deleted_p
, bool *constexpr_p
,
2387 bool diag
, int flags
, tsubst_flags_t complain
,
2388 bool dtor_from_ctor
)
2393 tree ctx
= DECL_CONTEXT (fields
);
2395 /* CWG2084: A defaulted default ctor for a union with a DMI only initializes
2396 that member, so don't check other members. */
2397 enum { unknown
, no
, yes
}
2398 only_dmi_mem
= (sfk
== sfk_constructor
&& TREE_CODE (ctx
) == UNION_TYPE
2402 for (tree field
= fields
; field
; field
= DECL_CHAIN (field
))
2404 tree mem_type
, argtype
, rval
;
2406 if (TREE_CODE (field
) != FIELD_DECL
2407 || DECL_ARTIFICIAL (field
)
2408 || DECL_UNNAMED_BIT_FIELD (field
))
2411 /* Variant members only affect deletedness. In particular, they don't
2412 affect the exception-specification of a user-provided destructor,
2413 which we're figuring out via get_defaulted_eh_spec. So if we aren't
2414 asking if this is deleted, don't even look up the function; we don't
2415 want an error about a deleted function we aren't actually calling. */
2416 if (sfk
== sfk_destructor
&& deleted_p
== NULL
2417 && TREE_CODE (ctx
) == UNION_TYPE
)
2420 if (only_dmi_mem
!= no
)
2422 if (DECL_INITIAL (field
))
2425 /* Don't check this until we know there's no DMI. */
2429 mem_type
= strip_array_types (TREE_TYPE (field
));
2430 if (SFK_ASSIGN_P (sfk
))
2433 if (CP_TYPE_CONST_P (mem_type
) && !CLASS_TYPE_P (mem_type
))
2436 error ("non-static const member %q#D, cannot use default "
2437 "assignment operator", field
);
2439 else if (TYPE_REF_P (mem_type
))
2442 error ("non-static reference member %q#D, cannot use "
2443 "default assignment operator", field
);
2448 if (bad
&& deleted_p
)
2451 else if (sfk
== sfk_constructor
|| sfk
== sfk_inheriting_constructor
)
2455 if (DECL_INITIAL (field
))
2457 if (diag
&& DECL_INITIAL (field
) == error_mark_node
)
2458 inform (DECL_SOURCE_LOCATION (field
),
2459 "initializer for %q#D is invalid", field
);
2462 /* Core 1351: If the field has an NSDMI that could throw, the
2463 default constructor is noexcept(false). */
2466 tree nsdmi
= get_nsdmi (field
, /*ctor*/false, complain
);
2467 if (nsdmi
== error_mark_node
)
2468 *spec_p
= error_mark_node
;
2469 else if (*spec_p
!= error_mark_node
2470 && !expr_noexcept_p (nsdmi
, tf_none
))
2471 *spec_p
= noexcept_false_spec
;
2473 /* Don't do the normal processing. */
2478 if (CP_TYPE_CONST_P (mem_type
)
2479 && default_init_uninitialized_part (mem_type
))
2483 error ("uninitialized const member in %q#T",
2484 current_class_type
);
2485 inform (DECL_SOURCE_LOCATION (field
),
2486 "%q#D should be initialized", field
);
2490 else if (TYPE_REF_P (mem_type
))
2494 error ("uninitialized reference member in %q#T",
2495 current_class_type
);
2496 inform (DECL_SOURCE_LOCATION (field
),
2497 "%q#D should be initialized", field
);
2502 if (bad
&& deleted_p
)
2505 /* Before C++20, for an implicitly-defined default constructor to
2506 be constexpr, every member must have a user-provided default
2507 constructor or an explicit initializer. */
2509 && cxx_dialect
< cxx20
2510 && !CLASS_TYPE_P (mem_type
)
2511 && TREE_CODE (ctx
) != UNION_TYPE
)
2513 *constexpr_p
= false;
2515 inform (DECL_SOURCE_LOCATION (field
),
2516 "defaulted default constructor does not "
2517 "initialize %q#D", field
);
2520 else if (sfk
== sfk_copy_constructor
)
2523 if (TYPE_REF_P (mem_type
)
2524 && TYPE_REF_IS_RVALUE (mem_type
))
2527 error ("copying non-static data member %q#D of rvalue "
2528 "reference type", field
);
2534 if (!CLASS_TYPE_P (mem_type
))
2537 if (ANON_AGGR_TYPE_P (mem_type
))
2539 walk_field_subobs (TYPE_FIELDS (mem_type
), sfk
, fnname
, quals
,
2540 spec_p
, trivial_p
, deleted_p
, constexpr_p
,
2541 diag
, flags
, complain
, dtor_from_ctor
);
2545 if (SFK_COPY_P (sfk
) || SFK_MOVE_P (sfk
))
2547 int mem_quals
= cp_type_quals (mem_type
) | quals
;
2548 if (DECL_MUTABLE_P (field
))
2549 mem_quals
&= ~TYPE_QUAL_CONST
;
2550 argtype
= build_stub_type (mem_type
, mem_quals
, SFK_MOVE_P (sfk
));
2553 argtype
= NULL_TREE
;
2555 rval
= locate_fn_flags (mem_type
, fnname
, argtype
, flags
, complain
);
2557 process_subob_fn (rval
, sfk
, spec_p
, trivial_p
, deleted_p
,
2558 constexpr_p
, diag
, field
, dtor_from_ctor
);
2561 /* We didn't find a DMI in this union, now check all the members. */
2562 if (only_dmi_mem
== unknown
)
2569 /* Base walker helper for synthesized_method_walk. Inspect a direct
2570 or virtual base. BINFO is the parent type's binfo. BASE_BINFO is
2571 the base binfo of interests. All other parms are as for
2572 synthesized_method_walk, or its local vars. */
2575 synthesized_method_base_walk (tree binfo
, tree base_binfo
,
2576 special_function_kind sfk
, tree fnname
, int quals
,
2577 tree
*inheriting_ctor
, tree inherited_parms
,
2578 int flags
, bool diag
,
2579 tree
*spec_p
, bool *trivial_p
,
2580 bool *deleted_p
, bool *constexpr_p
)
2582 bool inherited_binfo
= false;
2583 tree argtype
= NULL_TREE
;
2584 deferring_kind defer
= dk_no_deferred
;
2586 if (SFK_COPY_P (sfk
) || SFK_MOVE_P (sfk
))
2587 argtype
= build_stub_type (BINFO_TYPE (base_binfo
), quals
, SFK_MOVE_P (sfk
));
2588 else if (inheriting_ctor
2590 = binfo_inherited_from (binfo
, base_binfo
, *inheriting_ctor
)))
2592 argtype
= inherited_parms
;
2593 /* Don't check access on the inherited constructor. */
2594 if (flag_new_inheriting_ctors
)
2595 defer
= dk_deferred
;
2597 else if (cxx_dialect
>= cxx14
&& sfk
== sfk_virtual_destructor
2598 && BINFO_VIRTUAL_P (base_binfo
)
2599 && ABSTRACT_CLASS_TYPE_P (BINFO_TYPE (binfo
)))
2600 /* Don't check access when looking at vbases of abstract class's
2601 virtual destructor. */
2602 defer
= dk_no_check
;
2604 if (defer
!= dk_no_deferred
)
2605 push_deferring_access_checks (defer
);
2606 tree rval
= locate_fn_flags (base_binfo
, fnname
, argtype
, flags
,
2607 diag
? tf_warning_or_error
: tf_none
);
2608 if (defer
!= dk_no_deferred
)
2609 pop_deferring_access_checks ();
2611 /* Replace an inherited template with the appropriate specialization. */
2612 if (inherited_binfo
&& rval
2613 && DECL_P (*inheriting_ctor
) && DECL_P (rval
)
2614 && DECL_CONTEXT (*inheriting_ctor
) == DECL_CONTEXT (rval
))
2615 *inheriting_ctor
= DECL_CLONED_FUNCTION (rval
);
2617 process_subob_fn (rval
, sfk
, spec_p
, trivial_p
, deleted_p
,
2618 constexpr_p
, diag
, BINFO_TYPE (base_binfo
));
2619 if (SFK_CTOR_P (sfk
)
2620 && (!BINFO_VIRTUAL_P (base_binfo
)
2621 || TYPE_HAS_NONTRIVIAL_DESTRUCTOR (BINFO_TYPE (base_binfo
))))
2623 /* In a constructor we also need to check the subobject
2624 destructors for cleanup of partially constructed objects. */
2625 tree dtor
= locate_fn_flags (base_binfo
, complete_dtor_identifier
,
2627 diag
? tf_warning_or_error
: tf_none
);
2628 /* Note that we don't pass down trivial_p; the subobject
2629 destructors don't affect triviality of the constructor. Nor
2630 do they affect constexpr-ness (a constant expression doesn't
2631 throw) or exception-specification (a throw from one of the
2632 dtors would be a double-fault). */
2633 process_subob_fn (dtor
, sfk
, NULL
, NULL
, deleted_p
, NULL
, false,
2634 BINFO_TYPE (base_binfo
), /*dtor_from_ctor*/true);
2640 /* The caller wants to generate an implicit declaration of SFK for
2641 CTYPE which is const if relevant and CONST_P is set. If SPEC_P,
2642 TRIVIAL_P, DELETED_P or CONSTEXPR_P are non-null, set their
2643 referent appropriately. If DIAG is true, we're either being called
2644 from maybe_explain_implicit_delete to give errors, or if
2645 CONSTEXPR_P is non-null, from explain_invalid_constexpr_fn. */
2648 synthesized_method_walk (tree ctype
, special_function_kind sfk
, bool const_p
,
2649 tree
*spec_p
, bool *trivial_p
, bool *deleted_p
,
2650 bool *constexpr_p
, bool diag
,
2651 tree
*inheriting_ctor
, tree inherited_parms
)
2653 tree binfo
, base_binfo
;
2656 /* SFK must be exactly one category. */
2657 gcc_checking_assert (SFK_DTOR_P(sfk
) + SFK_CTOR_P(sfk
)
2658 + SFK_ASSIGN_P(sfk
) == 1);
2661 *spec_p
= (cxx_dialect
>= cxx11
? noexcept_true_spec
: empty_except_spec
);
2665 /* "The closure type associated with a lambda-expression has a deleted
2666 default constructor and a deleted copy assignment operator."
2667 This is diagnosed in maybe_explain_implicit_delete.
2668 In C++20, only lambda-expressions with lambda-captures have those
2670 if (LAMBDA_TYPE_P (ctype
)
2671 && (sfk
== sfk_constructor
|| sfk
== sfk_copy_assignment
)
2672 && (cxx_dialect
< cxx20
2673 || LAMBDA_EXPR_CAPTURE_LIST (CLASSTYPE_LAMBDA_EXPR (ctype
))
2674 || LAMBDA_EXPR_DEFAULT_CAPTURE_MODE
2675 (CLASSTYPE_LAMBDA_EXPR (ctype
)) != CPLD_NONE
))
2684 bool check_vdtor
= false;
2687 if (SFK_DTOR_P (sfk
))
2690 /* The synthesized method will call base dtors, but check complete
2691 here to avoid having to deal with VTT. */
2692 fnname
= complete_dtor_identifier
;
2694 else if (SFK_ASSIGN_P (sfk
))
2695 fnname
= assign_op_identifier
;
2697 fnname
= complete_ctor_identifier
;
2699 gcc_assert ((sfk
== sfk_inheriting_constructor
)
2700 == (inheriting_ctor
&& *inheriting_ctor
!= NULL_TREE
));
2702 /* If that user-written default constructor would satisfy the
2703 requirements of a constexpr constructor (7.1.5), the
2704 implicitly-defined default constructor is constexpr.
2707 The implicitly-defined copy/move assignment operator is constexpr if
2708 - X is a literal type, and
2709 - the assignment operator selected to copy/move each direct base class
2710 subobject is a constexpr function, and
2711 - for each non-static data member of X that is of class type (or array
2712 thereof), the assignment operator selected to copy/move that
2713 member is a constexpr function.
2716 The implicitly-defined copy/move assignment operator is constexpr. */
2718 *constexpr_p
= (SFK_CTOR_P (sfk
)
2719 || (SFK_ASSIGN_P (sfk
) && cxx_dialect
>= cxx14
)
2720 || (SFK_DTOR_P (sfk
) && cxx_dialect
>= cxx20
));
2722 bool expected_trivial
= type_has_trivial_fn (ctype
, sfk
);
2724 *trivial_p
= expected_trivial
;
2726 /* The TYPE_HAS_COMPLEX_* flags tell us about constraints from base
2727 class versions and other properties of the type. But a subobject
2728 class can be trivially copyable and yet have overload resolution
2729 choose a template constructor for initialization, depending on
2730 rvalueness and cv-quals. And furthermore, a member in a base might
2731 be trivial but deleted or otherwise not callable. So we can't exit
2732 early in C++0x. The same considerations apply in C++98/03, but
2733 there the definition of triviality does not consider overload
2734 resolution, so a constructor can be trivial even if it would otherwise
2735 call a non-trivial constructor. */
2736 if (expected_trivial
2737 && (!(SFK_COPY_P (sfk
) || SFK_MOVE_P (sfk
)) || cxx_dialect
< cxx11
))
2739 if (constexpr_p
&& sfk
== sfk_constructor
)
2741 bool cx
= trivial_default_constructor_is_constexpr (ctype
);
2743 if (diag
&& !cx
&& TREE_CODE (ctype
) == UNION_TYPE
)
2744 /* A trivial constructor doesn't have any NSDMI. */
2745 inform (input_location
, "defaulted default constructor does "
2746 "not initialize any non-static data member");
2748 if (!diag
&& cxx_dialect
< cxx11
)
2752 ++cp_unevaluated_operand
;
2753 ++c_inhibit_evaluation_warnings
;
2754 push_deferring_access_checks (dk_no_deferred
);
2756 tree scope
= push_scope (ctype
);
2758 int flags
= LOOKUP_NORMAL
| LOOKUP_SPECULATIVE
;
2759 if (sfk
!= sfk_inheriting_constructor
)
2760 flags
|= LOOKUP_DEFAULTED
;
2762 tsubst_flags_t complain
= diag
? tf_warning_or_error
: tf_none
;
2764 /* We're in get_defaulted_eh_spec; we don't actually want any walking
2765 diagnostics, we just want complain set. */
2767 int quals
= const_p
? TYPE_QUAL_CONST
: TYPE_UNQUALIFIED
;
2769 for (binfo
= TYPE_BINFO (ctype
), i
= 0;
2770 BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); ++i
)
2772 if (!SFK_ASSIGN_P (sfk
) && BINFO_VIRTUAL_P (base_binfo
))
2773 /* We'll handle virtual bases below. */
2776 tree fn
= synthesized_method_base_walk (binfo
, base_binfo
,
2778 inheriting_ctor
, inherited_parms
,
2779 flags
, diag
, spec_p
, trivial_p
,
2780 deleted_p
, constexpr_p
);
2782 if (diag
&& SFK_ASSIGN_P (sfk
) && SFK_MOVE_P (sfk
)
2783 && BINFO_VIRTUAL_P (base_binfo
)
2784 && fn
&& TREE_CODE (fn
) == FUNCTION_DECL
2785 && move_fn_p (fn
) && !trivial_fn_p (fn
)
2786 && vbase_has_user_provided_move_assign (BINFO_TYPE (base_binfo
)))
2787 warning (OPT_Wvirtual_move_assign
,
2788 "defaulted move assignment for %qT calls a non-trivial "
2789 "move assignment operator for virtual base %qT",
2790 ctype
, BINFO_TYPE (base_binfo
));
2792 if (check_vdtor
&& type_has_virtual_destructor (BINFO_TYPE (base_binfo
)))
2794 /* Unlike for base ctor/op=/dtor, for operator delete it's fine
2795 to have a null fn (no class-specific op delete). */
2796 fn
= locate_fn_flags (ctype
, ovl_op_identifier (false, DELETE_EXPR
),
2797 ptr_type_node
, flags
, tf_none
);
2798 if (fn
&& fn
== error_mark_node
)
2800 if (complain
& tf_error
)
2801 locate_fn_flags (ctype
, ovl_op_identifier (false, DELETE_EXPR
),
2802 ptr_type_node
, flags
, complain
);
2806 check_vdtor
= false;
2810 vec
<tree
, va_gc
> *vbases
= CLASSTYPE_VBASECLASSES (ctype
);
2811 if (SFK_ASSIGN_P (sfk
))
2812 /* Already examined vbases above. */;
2813 else if (vec_safe_is_empty (vbases
))
2814 /* No virtual bases to worry about. */;
2815 else if (ABSTRACT_CLASS_TYPE_P (ctype
) && cxx_dialect
>= cxx14
2816 /* DR 1658 specifies that vbases of abstract classes are
2817 ignored for both ctors and dtors. Except DR 2336
2818 overrides that skipping when determing the eh-spec of a
2819 virtual destructor. */
2820 && sfk
!= sfk_virtual_destructor
)
2821 /* Vbase cdtors are not relevant. */;
2825 *constexpr_p
= false;
2827 FOR_EACH_VEC_ELT (*vbases
, i
, base_binfo
)
2828 synthesized_method_base_walk (binfo
, base_binfo
, sfk
, fnname
, quals
,
2829 inheriting_ctor
, inherited_parms
,
2831 spec_p
, trivial_p
, deleted_p
, constexpr_p
);
2834 /* Now handle the non-static data members. */
2835 walk_field_subobs (TYPE_FIELDS (ctype
), sfk
, fnname
, quals
,
2836 spec_p
, trivial_p
, deleted_p
, constexpr_p
,
2837 diag
, flags
, complain
, /*dtor_from_ctor*/false);
2838 if (SFK_CTOR_P (sfk
))
2839 walk_field_subobs (TYPE_FIELDS (ctype
), sfk_destructor
,
2840 complete_dtor_identifier
, TYPE_UNQUALIFIED
,
2841 NULL
, NULL
, deleted_p
, NULL
,
2842 false, flags
, complain
, /*dtor_from_ctor*/true);
2846 pop_deferring_access_checks ();
2847 --cp_unevaluated_operand
;
2848 --c_inhibit_evaluation_warnings
;
2851 /* DECL is a defaulted function whose exception specification is now
2852 needed. Return what it should be. */
2855 get_defaulted_eh_spec (tree decl
, tsubst_flags_t complain
)
2857 /* For DECL_MAYBE_DELETED this should already have been handled by
2858 synthesize_method. */
2859 gcc_assert (!DECL_MAYBE_DELETED (decl
));
2861 if (DECL_CLONED_FUNCTION_P (decl
))
2862 decl
= DECL_CLONED_FUNCTION (decl
);
2863 special_function_kind sfk
= special_function_p (decl
);
2864 tree ctype
= DECL_CONTEXT (decl
);
2865 tree parms
= FUNCTION_FIRST_USER_PARMTYPE (decl
);
2866 tree parm_type
= TREE_VALUE (parms
);
2867 bool const_p
= CP_TYPE_CONST_P (non_reference (parm_type
));
2868 tree spec
= empty_except_spec
;
2869 bool diag
= !DECL_DELETED_FN (decl
) && (complain
& tf_error
);
2870 tree inh
= DECL_INHERITED_CTOR (decl
);
2871 if (SFK_DTOR_P (sfk
) && DECL_VIRTUAL_P (decl
))
2872 /* We have to examine virtual bases even if abstract. */
2873 sfk
= sfk_virtual_destructor
;
2874 bool pushed
= false;
2875 if (CLASSTYPE_TEMPLATE_INSTANTIATION (ctype
))
2876 pushed
= push_tinst_level (decl
);
2877 synthesized_method_walk (ctype
, sfk
, const_p
, &spec
, NULL
, NULL
,
2878 NULL
, diag
, &inh
, parms
);
2884 /* DECL is a deleted function. If it's implicitly deleted, explain why and
2885 return true; else return false. */
2888 maybe_explain_implicit_delete (tree decl
)
2890 /* If decl is a clone, get the primary variant. */
2891 decl
= DECL_ORIGIN (decl
);
2892 gcc_assert (DECL_DELETED_FN (decl
));
2893 if (DECL_DEFAULTED_FN (decl
))
2895 /* Not marked GTY; it doesn't need to be GC'd or written to PCH. */
2896 static hash_set
<tree
> *explained
;
2898 special_function_kind sfk
;
2904 explained
= new hash_set
<tree
>;
2905 if (explained
->add (decl
))
2908 sfk
= special_function_p (decl
);
2909 ctype
= DECL_CONTEXT (decl
);
2910 loc
= input_location
;
2911 input_location
= DECL_SOURCE_LOCATION (decl
);
2914 if (LAMBDA_TYPE_P (ctype
))
2917 if (sfk
== sfk_constructor
)
2918 inform (DECL_SOURCE_LOCATION (decl
),
2919 "a lambda closure type has a deleted default constructor");
2920 else if (sfk
== sfk_copy_assignment
)
2921 inform (DECL_SOURCE_LOCATION (decl
),
2922 "a lambda closure type has a deleted copy assignment operator");
2926 else if (DECL_ARTIFICIAL (decl
)
2927 && (sfk
== sfk_copy_assignment
|| sfk
== sfk_copy_constructor
)
2928 && classtype_has_move_assign_or_move_ctor_p (ctype
, true))
2930 inform (DECL_SOURCE_LOCATION (decl
),
2931 "%q#D is implicitly declared as deleted because %qT "
2932 "declares a move constructor or move assignment operator",
2936 else if (sfk
== sfk_inheriting_constructor
)
2938 tree binfo
= inherited_ctor_binfo (decl
);
2939 if (TREE_CODE (binfo
) != TREE_BINFO
)
2941 inform (DECL_SOURCE_LOCATION (decl
),
2942 "%q#D inherits from multiple base subobjects",
2947 if (!informed
&& sfk
== sfk_comparison
)
2949 inform (DECL_SOURCE_LOCATION (decl
),
2950 "%q#D is implicitly deleted because the default "
2951 "definition would be ill-formed:", decl
);
2952 build_comparison_op (decl
, false, tf_warning_or_error
);
2956 tree parms
= FUNCTION_FIRST_USER_PARMTYPE (decl
);
2957 bool const_p
= false;
2960 tree parm_type
= TREE_VALUE (parms
);
2961 const_p
= CP_TYPE_CONST_P (non_reference (parm_type
));
2963 tree raises
= NULL_TREE
;
2964 bool deleted_p
= false;
2965 tree scope
= push_scope (ctype
);
2966 tree inh
= DECL_INHERITED_CTOR (decl
);
2968 synthesized_method_walk (ctype
, sfk
, const_p
,
2969 &raises
, NULL
, &deleted_p
, NULL
, false,
2973 inform (DECL_SOURCE_LOCATION (decl
),
2974 "%q#D is implicitly deleted because the default "
2975 "definition would be ill-formed:", decl
);
2976 synthesized_method_walk (ctype
, sfk
, const_p
,
2977 NULL
, NULL
, &deleted_p
, NULL
, true,
2980 else if (!comp_except_specs
2981 (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (decl
)),
2983 inform (DECL_SOURCE_LOCATION (decl
), "%q#F is implicitly "
2984 "deleted because its exception-specification does not "
2985 "match the implicit exception-specification %qX",
2987 else if (flag_checking
)
2993 input_location
= loc
;
2999 /* DECL is a defaulted function which was declared constexpr. Explain why
3000 it can't be constexpr. */
3003 explain_implicit_non_constexpr (tree decl
)
3005 tree parms
= FUNCTION_FIRST_USER_PARMTYPE (decl
);
3006 bool const_p
= CP_TYPE_CONST_P (non_reference (TREE_VALUE (parms
)));
3007 tree inh
= DECL_INHERITED_CTOR (decl
);
3009 special_function_kind sfk
= special_function_p (decl
);
3010 if (sfk
== sfk_comparison
)
3012 DECL_DECLARED_CONSTEXPR_P (decl
) = true;
3013 build_comparison_op (decl
, false, tf_warning_or_error
);
3014 DECL_DECLARED_CONSTEXPR_P (decl
) = false;
3017 synthesized_method_walk (DECL_CLASS_CONTEXT (decl
),
3019 NULL
, NULL
, NULL
, &dummy
, true,
3023 /* DECL is an instantiation of an inheriting constructor template. Deduce
3024 the correct exception-specification and deletedness for this particular
3025 specialization. Return true if the deduction succeeds; false otherwise. */
3028 deduce_inheriting_ctor (tree decl
)
3030 decl
= DECL_ORIGIN (decl
);
3031 gcc_assert (DECL_INHERITED_CTOR (decl
));
3033 bool trivial
, constexpr_
, deleted
;
3034 tree inh
= DECL_INHERITED_CTOR (decl
);
3035 synthesized_method_walk (DECL_CONTEXT (decl
), sfk_inheriting_constructor
,
3036 false, &spec
, &trivial
, &deleted
, &constexpr_
,
3039 FUNCTION_FIRST_USER_PARMTYPE (decl
));
3040 if (spec
== error_mark_node
)
3042 if (TREE_CODE (inherited_ctor_binfo (decl
)) != TREE_BINFO
)
3043 /* Inherited the same constructor from different base subobjects. */
3045 DECL_DELETED_FN (decl
) = deleted
;
3046 TREE_TYPE (decl
) = build_exception_variant (TREE_TYPE (decl
), spec
);
3047 SET_DECL_INHERITED_CTOR (decl
, inh
);
3050 FOR_EACH_CLONE (clone
, decl
)
3052 DECL_DELETED_FN (clone
) = deleted
;
3053 TREE_TYPE (clone
) = build_exception_variant (TREE_TYPE (clone
), spec
);
3054 SET_DECL_INHERITED_CTOR (clone
, inh
);
3060 /* Implicitly declare the special function indicated by KIND, as a
3061 member of TYPE. For copy constructors and assignment operators,
3062 CONST_P indicates whether these functions should take a const
3063 reference argument or a non-const reference.
3064 Returns the FUNCTION_DECL for the implicitly declared function. */
3067 implicitly_declare_fn (special_function_kind kind
, tree type
,
3068 bool const_p
, tree pattern_fn
,
3069 tree inherited_parms
)
3072 tree parameter_types
= void_list_node
;
3075 tree raises
= empty_except_spec
;
3076 tree rhs_parm_type
= NULL_TREE
;
3079 HOST_WIDE_INT saved_processing_template_decl
;
3080 bool deleted_p
= false;
3081 bool constexpr_p
= false;
3082 tree inherited_ctor
= (kind
== sfk_inheriting_constructor
3083 ? pattern_fn
: NULL_TREE
);
3085 /* Because we create declarations for implicitly declared functions
3086 lazily, we may be creating the declaration for a member of TYPE
3087 while in some completely different context. However, TYPE will
3088 never be a dependent class (because we never want to do lookups
3089 for implicitly defined functions in a dependent class). */
3090 gcc_assert (!dependent_type_p (type
));
3092 /* If the member-specification does not explicitly declare any member or
3093 friend named operator==, an == operator function is declared
3094 implicitly for each three-way comparison operator function defined as
3095 defaulted in the member-specification, with the same access and
3096 function-definition and in the same class scope as the respective
3097 three-way comparison operator function, except that the return type is
3098 replaced with bool and the declarator-id is replaced with
3101 [Note: Such an implicitly-declared == operator for a class X is
3102 defined as defaulted in the definition of X and has the same
3103 parameter-declaration-clause and trailing requires-clause as the
3104 respective three-way comparison operator. It is declared with friend,
3105 virtual, constexpr, or consteval if the three-way comparison operator
3106 function is so declared. If the three-way comparison operator function
3107 has no noexcept-specifier, the implicitly-declared == operator
3108 function has an implicit exception specification (14.5) that may
3109 differ from the implicit exception specification of the three-way
3110 comparison operator function. --end note] */
3111 if (kind
== sfk_comparison
)
3113 fn
= copy_operator_fn (pattern_fn
, EQ_EXPR
);
3114 DECL_ARTIFICIAL (fn
) = 1;
3115 apply_deduced_return_type (fn
, boolean_type_node
);
3119 /* Furthermore, we must set PROCESSING_TEMPLATE_DECL to zero here
3120 because we only create clones for constructors and destructors
3121 when not in a template. */
3122 saved_processing_template_decl
= processing_template_decl
;
3123 processing_template_decl
= 0;
3125 type
= TYPE_MAIN_VARIANT (type
);
3127 if (targetm
.cxx
.cdtor_returns_this ())
3129 if (kind
== sfk_destructor
)
3130 /* See comment in check_special_function_return_type. */
3131 return_type
= build_pointer_type (void_type_node
);
3133 return_type
= build_pointer_type (type
);
3136 return_type
= void_type_node
;
3138 int this_quals
= TYPE_UNQUALIFIED
;
3141 case sfk_destructor
:
3143 name
= dtor_identifier
;
3146 case sfk_constructor
:
3147 /* Default constructor. */
3148 name
= ctor_identifier
;
3151 case sfk_copy_constructor
:
3152 case sfk_copy_assignment
:
3153 case sfk_move_constructor
:
3154 case sfk_move_assignment
:
3155 case sfk_inheriting_constructor
:
3157 if (kind
== sfk_copy_assignment
3158 || kind
== sfk_move_assignment
)
3160 return_type
= build_reference_type (type
);
3161 name
= assign_op_identifier
;
3164 name
= ctor_identifier
;
3166 if (kind
== sfk_inheriting_constructor
)
3167 parameter_types
= inherited_parms
;
3171 rhs_parm_type
= cp_build_qualified_type (type
, TYPE_QUAL_CONST
);
3173 rhs_parm_type
= type
;
3174 bool move_p
= (kind
== sfk_move_assignment
3175 || kind
== sfk_move_constructor
);
3176 rhs_parm_type
= cp_build_reference_type (rhs_parm_type
, move_p
);
3178 parameter_types
= tree_cons (NULL_TREE
, rhs_parm_type
, parameter_types
);
3187 bool trivial_p
= false;
3191 /* For an inheriting constructor, just copy these flags from the
3192 inherited constructor until deduce_inheriting_ctor. */
3193 raises
= TYPE_RAISES_EXCEPTIONS (TREE_TYPE (inherited_ctor
));
3194 deleted_p
= DECL_DELETED_FN (inherited_ctor
);
3195 constexpr_p
= DECL_DECLARED_CONSTEXPR_P (inherited_ctor
);
3197 else if (cxx_dialect
>= cxx11
)
3199 raises
= noexcept_deferred_spec
;
3200 synthesized_method_walk (type
, kind
, const_p
, NULL
, &trivial_p
,
3201 &deleted_p
, &constexpr_p
, false,
3202 &inherited_ctor
, inherited_parms
);
3205 synthesized_method_walk (type
, kind
, const_p
, &raises
, &trivial_p
,
3206 &deleted_p
, &constexpr_p
, false,
3207 &inherited_ctor
, inherited_parms
);
3208 /* Don't bother marking a deleted constructor as constexpr. */
3210 constexpr_p
= false;
3211 /* A trivial copy/move constructor is also a constexpr constructor,
3212 unless the class has virtual bases (7.1.5p4). */
3214 && cxx_dialect
>= cxx11
3215 && (kind
== sfk_copy_constructor
3216 || kind
== sfk_move_constructor
)
3217 && !CLASSTYPE_VBASECLASSES (type
))
3218 gcc_assert (constexpr_p
);
3220 if (!trivial_p
&& type_has_trivial_fn (type
, kind
))
3221 type_set_nontrivial_flag (type
, kind
);
3223 /* Create the function. */
3224 tree this_type
= cp_build_qualified_type (type
, this_quals
);
3225 fn_type
= build_method_type_directly (this_type
, return_type
,
3230 if (raises
!= error_mark_node
)
3231 fn_type
= build_exception_variant (fn_type
, raises
);
3234 /* Can happen, e.g., in C++98 mode for an ill-formed non-static data
3235 member initializer (c++/89914). Also, in C++98, we might have
3236 failed to deduce RAISES, so try again but complain this time. */
3237 if (cxx_dialect
< cxx11
)
3238 synthesized_method_walk (type
, kind
, const_p
, &raises
, nullptr,
3239 nullptr, nullptr, /*diag=*/true,
3240 &inherited_ctor
, inherited_parms
);
3241 /* We should have seen an error at this point. */
3242 gcc_assert (seen_error ());
3245 fn
= build_lang_decl (FUNCTION_DECL
, name
, fn_type
);
3246 if (kind
!= sfk_inheriting_constructor
)
3247 DECL_SOURCE_LOCATION (fn
) = DECL_SOURCE_LOCATION (TYPE_NAME (type
));
3249 if (IDENTIFIER_OVL_OP_P (name
))
3251 const ovl_op_info_t
*op
= IDENTIFIER_OVL_OP_INFO (name
);
3252 DECL_OVERLOADED_OPERATOR_CODE_RAW (fn
) = op
->ovl_op_code
;
3254 else if (IDENTIFIER_CTOR_P (name
))
3255 DECL_CXX_CONSTRUCTOR_P (fn
) = true;
3256 else if (IDENTIFIER_DTOR_P (name
))
3257 DECL_CXX_DESTRUCTOR_P (fn
) = true;
3261 SET_DECL_ALIGN (fn
, MINIMUM_METHOD_BOUNDARY
);
3263 /* Create the explicit arguments. */
3266 /* Note that this parameter is *not* marked DECL_ARTIFICIAL; we
3267 want its type to be included in the mangled function
3269 tree decl
= cp_build_parm_decl (fn
, NULL_TREE
, rhs_parm_type
);
3270 TREE_READONLY (decl
) = 1;
3271 retrofit_lang_decl (decl
);
3272 DECL_PARM_INDEX (decl
) = DECL_PARM_LEVEL (decl
) = 1;
3273 DECL_ARGUMENTS (fn
) = decl
;
3275 else if (kind
== sfk_inheriting_constructor
)
3277 tree
*p
= &DECL_ARGUMENTS (fn
);
3279 for (tree parm
= inherited_parms
; parm
&& parm
!= void_list_node
;
3280 parm
= TREE_CHAIN (parm
))
3282 *p
= cp_build_parm_decl (fn
, NULL_TREE
, TREE_VALUE (parm
));
3283 retrofit_lang_decl (*p
);
3284 DECL_PARM_LEVEL (*p
) = 1;
3285 DECL_PARM_INDEX (*p
) = index
++;
3286 p
= &DECL_CHAIN (*p
);
3288 SET_DECL_INHERITED_CTOR (fn
, inherited_ctor
);
3289 DECL_NONCONVERTING_P (fn
) = DECL_NONCONVERTING_P (inherited_ctor
);
3290 /* A constructor so declared has the same access as the corresponding
3291 constructor in X. */
3292 TREE_PRIVATE (fn
) = TREE_PRIVATE (inherited_ctor
);
3293 TREE_PROTECTED (fn
) = TREE_PROTECTED (inherited_ctor
);
3294 /* Copy constexpr from the inherited constructor even if the
3295 inheriting constructor doesn't satisfy the requirements. */
3296 constexpr_p
= DECL_DECLARED_CONSTEXPR_P (inherited_ctor
);
3297 /* Also copy any attributes. */
3298 DECL_ATTRIBUTES (fn
) = clone_attrs (DECL_ATTRIBUTES (inherited_ctor
));
3301 /* Add the "this" parameter. */
3302 this_parm
= build_this_parm (fn
, fn_type
, this_quals
);
3303 DECL_CHAIN (this_parm
) = DECL_ARGUMENTS (fn
);
3304 DECL_ARGUMENTS (fn
) = this_parm
;
3306 grokclassfn (type
, fn
, kind
== sfk_destructor
? DTOR_FLAG
: NO_SPECIAL
);
3308 DECL_IN_AGGR_P (fn
) = 1;
3309 DECL_ARTIFICIAL (fn
) = 1;
3310 DECL_DEFAULTED_FN (fn
) = 1;
3311 if (cxx_dialect
>= cxx11
)
3313 DECL_DELETED_FN (fn
) = deleted_p
;
3314 DECL_DECLARED_CONSTEXPR_P (fn
) = constexpr_p
;
3316 DECL_EXTERNAL (fn
) = true;
3317 DECL_NOT_REALLY_EXTERN (fn
) = 1;
3318 DECL_DECLARED_INLINE_P (fn
) = 1;
3319 set_linkage_according_to_type (type
, fn
);
3320 if (TREE_PUBLIC (fn
))
3321 DECL_COMDAT (fn
) = 1;
3322 rest_of_decl_compilation (fn
, namespace_bindings_p (), at_eof
);
3323 gcc_assert (!TREE_USED (fn
));
3325 /* Propagate constraints from the inherited constructor. */
3326 if (flag_concepts
&& inherited_ctor
)
3327 if (tree orig_ci
= get_constraints (inherited_ctor
))
3329 tree new_ci
= copy_node (orig_ci
);
3330 set_constraints (fn
, new_ci
);
3333 /* Restore PROCESSING_TEMPLATE_DECL. */
3334 processing_template_decl
= saved_processing_template_decl
;
3336 if (inherited_ctor
&& TREE_CODE (inherited_ctor
) == TEMPLATE_DECL
)
3337 fn
= add_inherited_template_parms (fn
, inherited_ctor
);
3339 /* Warn about calling a non-trivial move assignment in a virtual base. */
3340 if (kind
== sfk_move_assignment
&& !deleted_p
&& !trivial_p
3341 && CLASSTYPE_VBASECLASSES (type
))
3343 location_t loc
= input_location
;
3344 input_location
= DECL_SOURCE_LOCATION (fn
);
3345 synthesized_method_walk (type
, kind
, const_p
,
3346 NULL
, NULL
, NULL
, NULL
, true,
3348 input_location
= loc
;
3354 /* Gives any errors about defaulted functions which need to be deferred
3355 until the containing class is complete. */
3358 defaulted_late_check (tree fn
)
3360 /* Complain about invalid signature for defaulted fn. */
3361 tree ctx
= DECL_CONTEXT (fn
);
3362 special_function_kind kind
= special_function_p (fn
);
3364 if (kind
== sfk_comparison
)
3366 /* If the function was declared constexpr, check that the definition
3367 qualifies. Otherwise we can define the function lazily. */
3368 if (DECL_DECLARED_CONSTEXPR_P (fn
) && !DECL_INITIAL (fn
))
3372 synthesize_method (fn
);
3378 bool fn_const_p
= (copy_fn_p (fn
) == 2);
3379 tree implicit_fn
= implicitly_declare_fn (kind
, ctx
, fn_const_p
,
3381 tree eh_spec
= TYPE_RAISES_EXCEPTIONS (TREE_TYPE (implicit_fn
));
3383 if (!same_type_p (TREE_TYPE (TREE_TYPE (fn
)),
3384 TREE_TYPE (TREE_TYPE (implicit_fn
)))
3385 || !compparms (TYPE_ARG_TYPES (TREE_TYPE (fn
)),
3386 TYPE_ARG_TYPES (TREE_TYPE (implicit_fn
))))
3388 error ("defaulted declaration %q+D does not match the "
3389 "expected signature", fn
);
3390 inform (DECL_SOURCE_LOCATION (fn
),
3391 "expected signature: %qD", implicit_fn
);
3394 if (DECL_DELETED_FN (implicit_fn
))
3396 DECL_DELETED_FN (fn
) = 1;
3400 /* If a function is explicitly defaulted on its first declaration without an
3401 exception-specification, it is implicitly considered to have the same
3402 exception-specification as if it had been implicitly declared. */
3403 if (!TYPE_RAISES_EXCEPTIONS (TREE_TYPE (fn
))
3404 && DECL_DEFAULTED_IN_CLASS_P (fn
))
3405 TREE_TYPE (fn
) = build_exception_variant (TREE_TYPE (fn
), eh_spec
);
3407 if (DECL_DEFAULTED_IN_CLASS_P (fn
)
3408 && DECL_DECLARED_CONSTEXPR_P (implicit_fn
))
3410 /* Hmm...should we do this for out-of-class too? Should it be OK to
3411 add constexpr later like inline, rather than requiring
3412 declarations to match? */
3413 DECL_DECLARED_CONSTEXPR_P (fn
) = true;
3414 if (kind
== sfk_constructor
)
3415 TYPE_HAS_CONSTEXPR_CTOR (ctx
) = true;
3418 if (!DECL_DECLARED_CONSTEXPR_P (implicit_fn
)
3419 && DECL_DECLARED_CONSTEXPR_P (fn
))
3421 if (!CLASSTYPE_TEMPLATE_INSTANTIATION (ctx
))
3423 error ("explicitly defaulted function %q+D cannot be declared "
3424 "%qs because the implicit declaration is not %qs:", fn
,
3425 DECL_IMMEDIATE_FUNCTION_P (fn
) ? "consteval" : "constexpr",
3427 explain_implicit_non_constexpr (fn
);
3429 DECL_DECLARED_CONSTEXPR_P (fn
) = false;
3433 /* Returns true iff FN can be explicitly defaulted, and gives any
3434 errors if defaulting FN is ill-formed. */
3437 defaultable_fn_check (tree fn
)
3439 special_function_kind kind
= sfk_none
;
3441 if (template_parm_scope_p ())
3443 error ("a template cannot be defaulted");
3447 if (DECL_CONSTRUCTOR_P (fn
))
3449 if (FUNCTION_FIRST_USER_PARMTYPE (fn
) == void_list_node
)
3450 kind
= sfk_constructor
;
3451 else if (copy_fn_p (fn
) > 0
3452 && (TREE_CHAIN (FUNCTION_FIRST_USER_PARMTYPE (fn
))
3454 kind
= sfk_copy_constructor
;
3455 else if (move_fn_p (fn
))
3456 kind
= sfk_move_constructor
;
3458 else if (DECL_DESTRUCTOR_P (fn
))
3459 kind
= sfk_destructor
;
3460 else if (DECL_ASSIGNMENT_OPERATOR_P (fn
)
3461 && DECL_OVERLOADED_OPERATOR_IS (fn
, NOP_EXPR
))
3464 kind
= sfk_copy_assignment
;
3465 else if (move_fn_p (fn
))
3466 kind
= sfk_move_assignment
;
3468 else if (DECL_OVERLOADED_OPERATOR_CODE_RAW (fn
) >= OVL_OP_EQ_EXPR
3469 && DECL_OVERLOADED_OPERATOR_CODE_RAW (fn
) <= OVL_OP_SPACESHIP_EXPR
)
3471 kind
= sfk_comparison
;
3472 if (!early_check_defaulted_comparison (fn
))
3476 if (kind
== sfk_none
)
3478 error ("%qD cannot be defaulted", fn
);
3483 for (tree t
= FUNCTION_FIRST_USER_PARMTYPE (fn
);
3484 t
&& t
!= void_list_node
; t
= TREE_CHAIN (t
))
3485 if (TREE_PURPOSE (t
))
3487 error ("defaulted function %q+D with default argument", fn
);
3491 /* Avoid do_warn_unused_parameter warnings. */
3492 for (tree p
= FUNCTION_FIRST_USER_PARM (fn
); p
; p
= DECL_CHAIN (p
))
3494 suppress_warning (p
, OPT_Wunused_parameter
);
3496 if (current_class_type
&& TYPE_BEING_DEFINED (current_class_type
))
3497 /* Defer checking. */;
3498 else if (!processing_template_decl
)
3499 defaulted_late_check (fn
);
3505 /* Add an implicit declaration to TYPE for the kind of function
3506 indicated by SFK. Return the FUNCTION_DECL for the new implicit
3510 lazily_declare_fn (special_function_kind sfk
, tree type
)
3513 /* Whether or not the argument has a const reference type. */
3514 bool const_p
= false;
3516 type
= TYPE_MAIN_VARIANT (type
);
3520 case sfk_constructor
:
3521 CLASSTYPE_LAZY_DEFAULT_CTOR (type
) = 0;
3523 case sfk_copy_constructor
:
3524 const_p
= TYPE_HAS_CONST_COPY_CTOR (type
);
3525 CLASSTYPE_LAZY_COPY_CTOR (type
) = 0;
3527 case sfk_move_constructor
:
3528 CLASSTYPE_LAZY_MOVE_CTOR (type
) = 0;
3530 case sfk_copy_assignment
:
3531 const_p
= TYPE_HAS_CONST_COPY_ASSIGN (type
);
3532 CLASSTYPE_LAZY_COPY_ASSIGN (type
) = 0;
3534 case sfk_move_assignment
:
3535 CLASSTYPE_LAZY_MOVE_ASSIGN (type
) = 0;
3537 case sfk_destructor
:
3538 CLASSTYPE_LAZY_DESTRUCTOR (type
) = 0;
3544 /* Declare the function. */
3545 fn
= implicitly_declare_fn (sfk
, type
, const_p
, NULL
, NULL
);
3547 /* [class.copy]/8 If the class definition declares a move constructor or
3548 move assignment operator, the implicitly declared copy constructor is
3549 defined as deleted.... */
3550 if ((sfk
== sfk_copy_assignment
|| sfk
== sfk_copy_constructor
)
3551 && cxx_dialect
>= cxx11
)
3553 if (classtype_has_move_assign_or_move_ctor_p (type
, true))
3554 DECL_DELETED_FN (fn
) = true;
3555 else if (classtype_has_depr_implicit_copy (type
))
3556 /* The implicit definition of a copy constructor as defaulted is
3557 deprecated if the class has a user-declared copy assignment operator
3558 or a user-declared destructor. The implicit definition of a copy
3559 assignment operator as defaulted is deprecated if the class has a
3560 user-declared copy constructor or a user-declared destructor (15.4,
3562 TREE_DEPRECATED (fn
) = true;
3565 /* Destructors and assignment operators may be virtual. */
3566 if (sfk
== sfk_destructor
3567 || sfk
== sfk_move_assignment
3568 || sfk
== sfk_copy_assignment
)
3569 check_for_override (fn
, type
);
3571 /* Add it to the class */
3572 bool added
= add_method (type
, fn
, false);
3573 gcc_assert (added
|| errorcount
);
3575 /* Add it to TYPE_FIELDS. */
3576 if (sfk
== sfk_destructor
3577 && DECL_VIRTUAL_P (fn
))
3578 /* The ABI requires that a virtual destructor go at the end of the
3580 TYPE_FIELDS (type
) = chainon (TYPE_FIELDS (type
), fn
);
3583 DECL_CHAIN (fn
) = TYPE_FIELDS (type
);
3584 TYPE_FIELDS (type
) = fn
;
3586 /* Propagate TYPE_FIELDS. */
3587 fixup_type_variants (type
);
3589 maybe_add_class_template_decl_list (type
, fn
, /*friend_p=*/0);
3590 if (DECL_MAYBE_IN_CHARGE_CDTOR_P (fn
))
3591 /* Create appropriate clones. */
3592 clone_cdtor (fn
, /*update_methods=*/true);
3594 /* Classes, structs or unions TYPE marked with hotness attributes propagate
3595 the attribute to all methods. This is typically done in
3596 check_bases_and_members, but we must also inject them here for deferred
3597 lazily-declared functions. */
3598 maybe_propagate_warmth_attributes (fn
, type
);
3603 /* Given a FUNCTION_DECL FN and a chain LIST, skip as many elements of LIST
3604 as there are artificial parms in FN. */
3607 skip_artificial_parms_for (const_tree fn
, tree list
)
3609 if (DECL_IOBJ_MEMBER_FUNCTION_P (fn
))
3610 list
= TREE_CHAIN (list
);
3614 if (DECL_HAS_IN_CHARGE_PARM_P (fn
))
3615 list
= TREE_CHAIN (list
);
3616 if (DECL_HAS_VTT_PARM_P (fn
))
3617 list
= TREE_CHAIN (list
);
3621 /* Given a FUNCTION_DECL FN and a chain LIST, return the number of
3622 artificial parms in FN. */
3625 num_artificial_parms_for (const_tree fn
)
3629 if (DECL_IOBJ_MEMBER_FUNCTION_P (fn
))
3634 if (DECL_HAS_IN_CHARGE_PARM_P (fn
))
3636 if (DECL_HAS_VTT_PARM_P (fn
))
3642 #include "gt-cp-method.h"