1 /* Handle the hair of processing (but not expanding) inline functions.
2 Also manage function and variable name overloading.
3 Copyright (C) 1987-2018 Free Software Foundation, Inc.
4 Contributed by Michael Tiemann (tiemann@cygnus.com)
5
6 This file is part of GCC.
7
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)
11 any later version.
12
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.
17
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/>. */
21
22
23 /* Handle method declarations. */
24 #include "config.h"
25 #include "system.h"
26 #include "coretypes.h"
27 #include "target.h"
28 #include "cp-tree.h"
29 #include "stringpool.h"
30 #include "cgraph.h"
31 #include "varasm.h"
32 #include "toplev.h"
33 #include "common/common-target.h"
34
35 static void do_build_copy_assign (tree);
36 static void do_build_copy_constructor (tree);
37 static tree make_alias_for_thunk (tree);
38
39 /* Called once to initialize method.c. */
40
41 void
init_method(void)42 init_method (void)
43 {
44 init_mangle ();
45 }
46
47 /* Return a this or result adjusting thunk to FUNCTION. THIS_ADJUSTING
48 indicates whether it is a this or result adjusting thunk.
49 FIXED_OFFSET and VIRTUAL_OFFSET indicate how to do the adjustment
50 (see thunk_adjust). VIRTUAL_OFFSET can be NULL, but FIXED_OFFSET
51 never is. VIRTUAL_OFFSET is the /index/ into the vtable for this
52 adjusting thunks, we scale it to a byte offset. For covariant
53 thunks VIRTUAL_OFFSET is the virtual binfo. You must post process
54 the returned thunk with finish_thunk. */
55
56 tree
make_thunk(tree function,bool this_adjusting,tree fixed_offset,tree virtual_offset)57 make_thunk (tree function, bool this_adjusting,
58 tree fixed_offset, tree virtual_offset)
59 {
60 HOST_WIDE_INT d;
61 tree thunk;
62
63 gcc_assert (TREE_CODE (function) == FUNCTION_DECL);
64 /* We can have this thunks to covariant thunks, but not vice versa. */
65 gcc_assert (!DECL_THIS_THUNK_P (function));
66 gcc_assert (!DECL_RESULT_THUNK_P (function) || this_adjusting);
67
68 /* Scale the VIRTUAL_OFFSET to be in terms of bytes. */
69 if (this_adjusting && virtual_offset)
70 virtual_offset
71 = size_binop (MULT_EXPR,
72 virtual_offset,
73 convert (ssizetype,
74 TYPE_SIZE_UNIT (vtable_entry_type)));
75
76 d = tree_to_shwi (fixed_offset);
77
78 /* See if we already have the thunk in question. For this_adjusting
79 thunks VIRTUAL_OFFSET will be an INTEGER_CST, for covariant thunks it
80 will be a BINFO. */
81 for (thunk = DECL_THUNKS (function); thunk; thunk = DECL_CHAIN (thunk))
82 if (DECL_THIS_THUNK_P (thunk) == this_adjusting
83 && THUNK_FIXED_OFFSET (thunk) == d
84 && !virtual_offset == !THUNK_VIRTUAL_OFFSET (thunk)
85 && (!virtual_offset
86 || (this_adjusting
87 ? tree_int_cst_equal (THUNK_VIRTUAL_OFFSET (thunk),
88 virtual_offset)
89 : THUNK_VIRTUAL_OFFSET (thunk) == virtual_offset)))
90 return thunk;
91
92 /* All thunks must be created before FUNCTION is actually emitted;
93 the ABI requires that all thunks be emitted together with the
94 function to which they transfer control. */
95 gcc_assert (!TREE_ASM_WRITTEN (function));
96 /* Likewise, we can only be adding thunks to a function declared in
97 the class currently being laid out. */
98 gcc_assert (TYPE_SIZE (DECL_CONTEXT (function))
99 && TYPE_BEING_DEFINED (DECL_CONTEXT (function)));
100
101 thunk = build_decl (DECL_SOURCE_LOCATION (function),
102 FUNCTION_DECL, NULL_TREE, TREE_TYPE (function));
103 DECL_LANG_SPECIFIC (thunk) = DECL_LANG_SPECIFIC (function);
104 cxx_dup_lang_specific_decl (thunk);
105 DECL_VIRTUAL_P (thunk) = true;
106 SET_DECL_THUNKS (thunk, NULL_TREE);
107
108 DECL_CONTEXT (thunk) = DECL_CONTEXT (function);
109 TREE_READONLY (thunk) = TREE_READONLY (function);
110 TREE_THIS_VOLATILE (thunk) = TREE_THIS_VOLATILE (function);
111 TREE_PUBLIC (thunk) = TREE_PUBLIC (function);
112 SET_DECL_THUNK_P (thunk, this_adjusting);
113 THUNK_TARGET (thunk) = function;
114 THUNK_FIXED_OFFSET (thunk) = d;
115 THUNK_VIRTUAL_OFFSET (thunk) = virtual_offset;
116 THUNK_ALIAS (thunk) = NULL_TREE;
117
118 DECL_INTERFACE_KNOWN (thunk) = 1;
119 DECL_NOT_REALLY_EXTERN (thunk) = 1;
120 DECL_COMDAT (thunk) = DECL_COMDAT (function);
121 DECL_SAVED_FUNCTION_DATA (thunk) = NULL;
122 /* The thunk itself is not a constructor or destructor, even if
123 the thing it is thunking to is. */
124 DECL_CXX_DESTRUCTOR_P (thunk) = 0;
125 DECL_CXX_CONSTRUCTOR_P (thunk) = 0;
126 DECL_EXTERNAL (thunk) = 1;
127 DECL_ARTIFICIAL (thunk) = 1;
128 /* The THUNK is not a pending inline, even if the FUNCTION is. */
129 DECL_PENDING_INLINE_P (thunk) = 0;
130 DECL_DECLARED_INLINE_P (thunk) = 0;
131 /* Nor is it a template instantiation. */
132 DECL_USE_TEMPLATE (thunk) = 0;
133 DECL_TEMPLATE_INFO (thunk) = NULL;
134
135 /* Add it to the list of thunks associated with FUNCTION. */
136 DECL_CHAIN (thunk) = DECL_THUNKS (function);
137 SET_DECL_THUNKS (function, thunk);
138
139 return thunk;
140 }
141
142 /* Finish THUNK, a thunk decl. */
143
144 void
finish_thunk(tree thunk)145 finish_thunk (tree thunk)
146 {
147 tree function, name;
148 tree fixed_offset = ssize_int (THUNK_FIXED_OFFSET (thunk));
149 tree virtual_offset = THUNK_VIRTUAL_OFFSET (thunk);
150
151 gcc_assert (!DECL_NAME (thunk) && DECL_THUNK_P (thunk));
152 if (virtual_offset && DECL_RESULT_THUNK_P (thunk))
153 virtual_offset = BINFO_VPTR_FIELD (virtual_offset);
154 function = THUNK_TARGET (thunk);
155 name = mangle_thunk (function, DECL_THIS_THUNK_P (thunk),
156 fixed_offset, virtual_offset, thunk);
157
158 /* We can end up with declarations of (logically) different
159 covariant thunks, that do identical adjustments. The two thunks
160 will be adjusting between within different hierarchies, which
161 happen to have the same layout. We must nullify one of them to
162 refer to the other. */
163 if (DECL_RESULT_THUNK_P (thunk))
164 {
165 tree cov_probe;
166
167 for (cov_probe = DECL_THUNKS (function);
168 cov_probe; cov_probe = DECL_CHAIN (cov_probe))
169 if (DECL_NAME (cov_probe) == name)
170 {
171 gcc_assert (!DECL_THUNKS (thunk));
172 THUNK_ALIAS (thunk) = (THUNK_ALIAS (cov_probe)
173 ? THUNK_ALIAS (cov_probe) : cov_probe);
174 break;
175 }
176 }
177
178 DECL_NAME (thunk) = name;
179 SET_DECL_ASSEMBLER_NAME (thunk, name);
180 }
181
182 static GTY (()) int thunk_labelno;
183
184 /* Create a static alias to target. */
185
186 tree
make_alias_for(tree target,tree newid)187 make_alias_for (tree target, tree newid)
188 {
189 tree alias = build_decl (DECL_SOURCE_LOCATION (target),
190 TREE_CODE (target), newid, TREE_TYPE (target));
191 DECL_LANG_SPECIFIC (alias) = DECL_LANG_SPECIFIC (target);
192 cxx_dup_lang_specific_decl (alias);
193 DECL_CONTEXT (alias) = DECL_CONTEXT (target);
194 TREE_READONLY (alias) = TREE_READONLY (target);
195 TREE_THIS_VOLATILE (alias) = TREE_THIS_VOLATILE (target);
196 TREE_PUBLIC (alias) = 0;
197 DECL_INTERFACE_KNOWN (alias) = 1;
198 if (DECL_LANG_SPECIFIC (alias))
199 {
200 DECL_NOT_REALLY_EXTERN (alias) = 1;
201 DECL_USE_TEMPLATE (alias) = 0;
202 DECL_TEMPLATE_INFO (alias) = NULL;
203 }
204 DECL_EXTERNAL (alias) = 0;
205 DECL_ARTIFICIAL (alias) = 1;
206 DECL_TEMPLATE_INSTANTIATED (alias) = 0;
207 if (TREE_CODE (alias) == FUNCTION_DECL)
208 {
209 DECL_SAVED_FUNCTION_DATA (alias) = NULL;
210 DECL_CXX_DESTRUCTOR_P (alias) = 0;
211 DECL_CXX_CONSTRUCTOR_P (alias) = 0;
212 DECL_PENDING_INLINE_P (alias) = 0;
213 DECL_DECLARED_INLINE_P (alias) = 0;
214 DECL_INITIAL (alias) = error_mark_node;
215 DECL_ARGUMENTS (alias) = copy_list (DECL_ARGUMENTS (target));
216 }
217 else
218 TREE_STATIC (alias) = 1;
219 TREE_ADDRESSABLE (alias) = 1;
220 TREE_USED (alias) = 1;
221 SET_DECL_ASSEMBLER_NAME (alias, DECL_NAME (alias));
222 return alias;
223 }
224
225 static tree
make_alias_for_thunk(tree function)226 make_alias_for_thunk (tree function)
227 {
228 tree alias;
229 char buf[256];
230
231 targetm.asm_out.generate_internal_label (buf, "LTHUNK", thunk_labelno);
232 thunk_labelno++;
233
234 alias = make_alias_for (function, get_identifier (buf));
235
236 if (!flag_syntax_only)
237 {
238 struct cgraph_node *funcn, *aliasn;
239 funcn = cgraph_node::get (function);
240 gcc_checking_assert (funcn);
241 aliasn = cgraph_node::create_same_body_alias (alias, function);
242 DECL_ASSEMBLER_NAME (function);
243 gcc_assert (aliasn != NULL);
244 }
245
246 return alias;
247 }
248
249 /* Emit the definition of a C++ multiple inheritance or covariant
250 return vtable thunk. If EMIT_P is nonzero, the thunk is emitted
251 immediately. */
252
253 void
use_thunk(tree thunk_fndecl,bool emit_p)254 use_thunk (tree thunk_fndecl, bool emit_p)
255 {
256 tree a, t, function, alias;
257 tree virtual_offset;
258 HOST_WIDE_INT fixed_offset, virtual_value;
259 bool this_adjusting = DECL_THIS_THUNK_P (thunk_fndecl);
260 struct cgraph_node *funcn, *thunk_node;
261
262 /* We should have called finish_thunk to give it a name. */
263 gcc_assert (DECL_NAME (thunk_fndecl));
264
265 /* We should never be using an alias, always refer to the
266 aliased thunk. */
267 gcc_assert (!THUNK_ALIAS (thunk_fndecl));
268
269 if (TREE_ASM_WRITTEN (thunk_fndecl))
270 return;
271
272 function = THUNK_TARGET (thunk_fndecl);
273 if (DECL_RESULT (thunk_fndecl))
274 /* We already turned this thunk into an ordinary function.
275 There's no need to process this thunk again. */
276 return;
277
278 if (DECL_THUNK_P (function))
279 /* The target is itself a thunk, process it now. */
280 use_thunk (function, emit_p);
281
282 /* Thunks are always addressable; they only appear in vtables. */
283 TREE_ADDRESSABLE (thunk_fndecl) = 1;
284
285 /* Figure out what function is being thunked to. It's referenced in
286 this translation unit. */
287 TREE_ADDRESSABLE (function) = 1;
288 mark_used (function);
289 if (!emit_p)
290 return;
291
292 if (TARGET_USE_LOCAL_THUNK_ALIAS_P (function))
293 alias = make_alias_for_thunk (function);
294 else
295 alias = function;
296
297 fixed_offset = THUNK_FIXED_OFFSET (thunk_fndecl);
298 virtual_offset = THUNK_VIRTUAL_OFFSET (thunk_fndecl);
299
300 if (virtual_offset)
301 {
302 if (!this_adjusting)
303 virtual_offset = BINFO_VPTR_FIELD (virtual_offset);
304 virtual_value = tree_to_shwi (virtual_offset);
305 gcc_assert (virtual_value);
306 }
307 else
308 virtual_value = 0;
309
310 /* And, if we need to emit the thunk, it's used. */
311 mark_used (thunk_fndecl);
312 /* This thunk is actually defined. */
313 DECL_EXTERNAL (thunk_fndecl) = 0;
314 /* The linkage of the function may have changed. FIXME in linkage
315 rewrite. */
316 gcc_assert (DECL_INTERFACE_KNOWN (function));
317 TREE_PUBLIC (thunk_fndecl) = TREE_PUBLIC (function);
318 DECL_VISIBILITY (thunk_fndecl) = DECL_VISIBILITY (function);
319 DECL_VISIBILITY_SPECIFIED (thunk_fndecl)
320 = DECL_VISIBILITY_SPECIFIED (function);
321 DECL_COMDAT (thunk_fndecl) = DECL_COMDAT (function);
322 DECL_WEAK (thunk_fndecl) = DECL_WEAK (function);
323
324 if (flag_syntax_only)
325 {
326 TREE_ASM_WRITTEN (thunk_fndecl) = 1;
327 return;
328 }
329
330 push_to_top_level ();
331
332 if (TARGET_USE_LOCAL_THUNK_ALIAS_P (function)
333 && targetm_common.have_named_sections)
334 {
335 tree fn = function;
336 struct symtab_node *symbol;
337
338 if ((symbol = symtab_node::get (function))
339 && symbol->alias)
340 {
341 if (symbol->analyzed)
342 fn = symtab_node::get (function)->ultimate_alias_target ()->decl;
343 else
344 fn = symtab_node::get (function)->alias_target;
345 }
346 resolve_unique_section (fn, 0, flag_function_sections);
347
348 if (DECL_SECTION_NAME (fn) != NULL && DECL_ONE_ONLY (fn))
349 {
350 resolve_unique_section (thunk_fndecl, 0, flag_function_sections);
351
352 /* Output the thunk into the same section as function. */
353 set_decl_section_name (thunk_fndecl, DECL_SECTION_NAME (fn));
354 symtab_node::get (thunk_fndecl)->implicit_section
355 = symtab_node::get (fn)->implicit_section;
356 }
357 }
358
359 /* Set up cloned argument trees for the thunk. */
360 t = NULL_TREE;
361 for (a = DECL_ARGUMENTS (function); a; a = DECL_CHAIN (a))
362 {
363 tree x = copy_node (a);
364 DECL_CHAIN (x) = t;
365 DECL_CONTEXT (x) = thunk_fndecl;
366 SET_DECL_RTL (x, NULL);
367 DECL_HAS_VALUE_EXPR_P (x) = 0;
368 TREE_ADDRESSABLE (x) = 0;
369 t = x;
370 }
371 a = nreverse (t);
372 DECL_ARGUMENTS (thunk_fndecl) = a;
373 TREE_ASM_WRITTEN (thunk_fndecl) = 1;
374 funcn = cgraph_node::get (function);
375 gcc_checking_assert (funcn);
376 thunk_node = funcn->create_thunk (thunk_fndecl, function,
377 this_adjusting, fixed_offset, virtual_value,
378 virtual_offset, alias);
379 if (DECL_ONE_ONLY (function))
380 thunk_node->add_to_same_comdat_group (funcn);
381
382 pop_from_top_level ();
383 }
384
385 /* Code for synthesizing methods which have default semantics defined. */
386
387 /* True iff CTYPE has a trivial SFK. */
388
389 static bool
type_has_trivial_fn(tree ctype,special_function_kind sfk)390 type_has_trivial_fn (tree ctype, special_function_kind sfk)
391 {
392 switch (sfk)
393 {
394 case sfk_constructor:
395 return !TYPE_HAS_COMPLEX_DFLT (ctype);
396 case sfk_copy_constructor:
397 return !TYPE_HAS_COMPLEX_COPY_CTOR (ctype);
398 case sfk_move_constructor:
399 return !TYPE_HAS_COMPLEX_MOVE_CTOR (ctype);
400 case sfk_copy_assignment:
401 return !TYPE_HAS_COMPLEX_COPY_ASSIGN (ctype);
402 case sfk_move_assignment:
403 return !TYPE_HAS_COMPLEX_MOVE_ASSIGN (ctype);
404 case sfk_destructor:
405 return !TYPE_HAS_NONTRIVIAL_DESTRUCTOR (ctype);
406 case sfk_inheriting_constructor:
407 return false;
408 default:
409 gcc_unreachable ();
410 }
411 }
412
413 /* Note that CTYPE has a non-trivial SFK even though we previously thought
414 it was trivial. */
415
416 static void
type_set_nontrivial_flag(tree ctype,special_function_kind sfk)417 type_set_nontrivial_flag (tree ctype, special_function_kind sfk)
418 {
419 switch (sfk)
420 {
421 case sfk_constructor:
422 TYPE_HAS_COMPLEX_DFLT (ctype) = true;
423 return;
424 case sfk_copy_constructor:
425 TYPE_HAS_COMPLEX_COPY_CTOR (ctype) = true;
426 return;
427 case sfk_move_constructor:
428 TYPE_HAS_COMPLEX_MOVE_CTOR (ctype) = true;
429 return;
430 case sfk_copy_assignment:
431 TYPE_HAS_COMPLEX_COPY_ASSIGN (ctype) = true;
432 return;
433 case sfk_move_assignment:
434 TYPE_HAS_COMPLEX_MOVE_ASSIGN (ctype) = true;
435 return;
436 case sfk_destructor:
437 TYPE_HAS_NONTRIVIAL_DESTRUCTOR (ctype) = true;
438 return;
439 case sfk_inheriting_constructor:
440 default:
441 gcc_unreachable ();
442 }
443 }
444
445 /* True iff FN is a trivial defaulted member function ([cd]tor, op=). */
446
447 bool
trivial_fn_p(tree fn)448 trivial_fn_p (tree fn)
449 {
450 if (TREE_CODE (fn) == TEMPLATE_DECL)
451 return false;
452 if (!DECL_DEFAULTED_FN (fn))
453 return false;
454
455 /* If fn is a clone, get the primary variant. */
456 if (tree prim = DECL_CLONED_FUNCTION (fn))
457 fn = prim;
458 return type_has_trivial_fn (DECL_CONTEXT (fn), special_function_p (fn));
459 }
460
461 /* PARM is a PARM_DECL for a function which we want to forward to another
462 function without changing its value category, a la std::forward. */
463
464 tree
forward_parm(tree parm)465 forward_parm (tree parm)
466 {
467 tree exp = convert_from_reference (parm);
468 tree type = TREE_TYPE (parm);
469 if (DECL_PACK_P (parm))
470 type = PACK_EXPANSION_PATTERN (type);
471 if (TREE_CODE (type) != REFERENCE_TYPE)
472 type = cp_build_reference_type (type, /*rval=*/true);
473 warning_sentinel w (warn_useless_cast);
474 exp = build_static_cast (type, exp, tf_warning_or_error);
475 if (DECL_PACK_P (parm))
476 exp = make_pack_expansion (exp);
477 return exp;
478 }
479
480 /* Strip all inheriting constructors, if any, to return the original
481 constructor from a (possibly indirect) base class. */
482
483 tree
strip_inheriting_ctors(tree dfn)484 strip_inheriting_ctors (tree dfn)
485 {
486 if (!flag_new_inheriting_ctors)
487 return dfn;
488 tree fn = dfn;
489 while (tree inh = DECL_INHERITED_CTOR (fn))
490 fn = OVL_FIRST (inh);
491
492 if (TREE_CODE (fn) == TEMPLATE_DECL
493 && TREE_CODE (dfn) == FUNCTION_DECL)
494 fn = DECL_TEMPLATE_RESULT (fn);
495 return fn;
496 }
497
498 /* Find the binfo for the base subobject of BINFO being initialized by
499 inherited constructor FNDECL (a member of a direct base of BINFO). */
500
501 static tree inherited_ctor_binfo (tree, tree);
502 static tree
inherited_ctor_binfo_1(tree binfo,tree fndecl)503 inherited_ctor_binfo_1 (tree binfo, tree fndecl)
504 {
505 tree base = DECL_CONTEXT (fndecl);
506 tree base_binfo;
507 for (int i = 0; BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
508 if (BINFO_TYPE (base_binfo) == base)
509 return inherited_ctor_binfo (base_binfo, fndecl);
510
511 gcc_unreachable();
512 }
513
514 /* Find the binfo for the base subobject of BINFO being initialized by
515 inheriting constructor FNDECL (a member of BINFO), or BINFO if FNDECL is not
516 an inheriting constructor. */
517
518 static tree
inherited_ctor_binfo(tree binfo,tree fndecl)519 inherited_ctor_binfo (tree binfo, tree fndecl)
520 {
521 tree inh = DECL_INHERITED_CTOR (fndecl);
522 if (!inh)
523 return binfo;
524
525 tree results = NULL_TREE;
526 for (ovl_iterator iter (inh); iter; ++iter)
527 {
528 tree one = inherited_ctor_binfo_1 (binfo, *iter);
529 if (!results)
530 results = one;
531 else if (one != results)
532 results = tree_cons (NULL_TREE, one, results);
533 }
534 return results;
535 }
536
537 /* Find the binfo for the base subobject being initialized by inheriting
538 constructor FNDECL, or NULL_TREE if FNDECL is not an inheriting
539 constructor. */
540
541 tree
inherited_ctor_binfo(tree fndecl)542 inherited_ctor_binfo (tree fndecl)
543 {
544 if (!DECL_INHERITED_CTOR (fndecl))
545 return NULL_TREE;
546 tree binfo = TYPE_BINFO (DECL_CONTEXT (fndecl));
547 return inherited_ctor_binfo (binfo, fndecl);
548 }
549
550 /* True if we should omit all user-declared parameters from constructor FN,
551 because it is a base clone of a ctor inherited from a virtual base. */
552
553 bool
ctor_omit_inherited_parms(tree fn)554 ctor_omit_inherited_parms (tree fn)
555 {
556 if (!flag_new_inheriting_ctors)
557 /* We only optimize away the parameters in the new model. */
558 return false;
559 if (!DECL_BASE_CONSTRUCTOR_P (fn)
560 || !CLASSTYPE_VBASECLASSES (DECL_CONTEXT (fn)))
561 return false;
562 if (FUNCTION_FIRST_USER_PARMTYPE (DECL_ORIGIN (fn)) == void_list_node)
563 /* No user-declared parameters to omit. */
564 return false;
565 tree binfo = inherited_ctor_binfo (fn);
566 for (; binfo; binfo = BINFO_INHERITANCE_CHAIN (binfo))
567 if (BINFO_VIRTUAL_P (binfo))
568 return true;
569 return false;
570 }
571
572 /* True iff constructor(s) INH inherited into BINFO initializes INIT_BINFO.
573 This can be true for multiple virtual bases as well as one direct
574 non-virtual base. */
575
576 static bool
binfo_inherited_from(tree binfo,tree init_binfo,tree inh)577 binfo_inherited_from (tree binfo, tree init_binfo, tree inh)
578 {
579 /* inh is an OVERLOAD if we inherited the same constructor along
580 multiple paths, check all of them. */
581 for (ovl_iterator iter (inh); iter; ++iter)
582 {
583 tree fn = *iter;
584 tree base = DECL_CONTEXT (fn);
585 tree base_binfo = NULL_TREE;
586 for (int i = 0; BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
587 if (BINFO_TYPE (base_binfo) == base)
588 break;
589 if (base_binfo == init_binfo
590 || (flag_new_inheriting_ctors
591 && binfo_inherited_from (base_binfo, init_binfo,
592 DECL_INHERITED_CTOR (fn))))
593 return true;
594 }
595 return false;
596 }
597
598 /* Subroutine of do_build_copy_constructor: Add a mem-initializer for BINFO
599 given the parameter or parameters PARM, possibly inherited constructor
600 base INH, or move flag MOVE_P. */
601
602 static tree
add_one_base_init(tree binfo,tree parm,bool move_p,tree inh,tree member_init_list)603 add_one_base_init (tree binfo, tree parm, bool move_p, tree inh,
604 tree member_init_list)
605 {
606 tree init;
607 if (inh)
608 {
609 /* An inheriting constructor only has a mem-initializer for
610 the base it inherits from. */
611 if (!binfo_inherited_from (TYPE_BINFO (current_class_type), binfo, inh))
612 return member_init_list;
613
614 tree *p = &init;
615 init = NULL_TREE;
616 for (; parm; parm = DECL_CHAIN (parm))
617 {
618 tree exp = forward_parm (parm);
619 *p = build_tree_list (NULL_TREE, exp);
620 p = &TREE_CHAIN (*p);
621 }
622 }
623 else
624 {
625 init = build_base_path (PLUS_EXPR, parm, binfo, 1,
626 tf_warning_or_error);
627 if (move_p)
628 init = move (init);
629 init = build_tree_list (NULL_TREE, init);
630 }
631 return tree_cons (binfo, init, member_init_list);
632 }
633
634 /* Generate code for default X(X&) or X(X&&) constructor or an inheriting
635 constructor. */
636
637 static void
do_build_copy_constructor(tree fndecl)638 do_build_copy_constructor (tree fndecl)
639 {
640 tree parm = FUNCTION_FIRST_USER_PARM (fndecl);
641 bool move_p = DECL_MOVE_CONSTRUCTOR_P (fndecl);
642 bool trivial = trivial_fn_p (fndecl);
643 tree inh = DECL_INHERITED_CTOR (fndecl);
644
645 if (!inh)
646 parm = convert_from_reference (parm);
647
648 if (trivial)
649 {
650 if (is_empty_class (current_class_type))
651 /* Don't copy the padding byte; it might not have been allocated
652 if *this is a base subobject. */;
653 else if (tree_int_cst_equal (TYPE_SIZE (current_class_type),
654 CLASSTYPE_SIZE (current_class_type)))
655 {
656 tree t = build2 (INIT_EXPR, void_type_node, current_class_ref, parm);
657 finish_expr_stmt (t);
658 }
659 else
660 {
661 /* We must only copy the non-tail padding parts. */
662 tree base_size = CLASSTYPE_SIZE_UNIT (current_class_type);
663 base_size = size_binop (MINUS_EXPR, base_size, size_int (1));
664 tree array_type = build_array_type (unsigned_char_type_node,
665 build_index_type (base_size));
666 tree alias_set = build_int_cst (TREE_TYPE (current_class_ptr), 0);
667 tree lhs = build2 (MEM_REF, array_type,
668 current_class_ptr, alias_set);
669 tree rhs = build2 (MEM_REF, array_type,
670 TREE_OPERAND (parm, 0), alias_set);
671 tree t = build2 (INIT_EXPR, void_type_node, lhs, rhs);
672 finish_expr_stmt (t);
673 }
674 }
675 else
676 {
677 tree fields = TYPE_FIELDS (current_class_type);
678 tree member_init_list = NULL_TREE;
679 int cvquals = cp_type_quals (TREE_TYPE (parm));
680 int i;
681 tree binfo, base_binfo;
682 tree init;
683 vec<tree, va_gc> *vbases;
684
685 /* Initialize all the base-classes with the parameter converted
686 to their type so that we get their copy constructor and not
687 another constructor that takes current_class_type. We must
688 deal with the binfo's directly as a direct base might be
689 inaccessible due to ambiguity. */
690 for (vbases = CLASSTYPE_VBASECLASSES (current_class_type), i = 0;
691 vec_safe_iterate (vbases, i, &binfo); i++)
692 {
693 member_init_list = add_one_base_init (binfo, parm, move_p, inh,
694 member_init_list);
695 }
696
697 for (binfo = TYPE_BINFO (current_class_type), i = 0;
698 BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
699 {
700 if (BINFO_VIRTUAL_P (base_binfo))
701 continue;
702 member_init_list = add_one_base_init (base_binfo, parm, move_p,
703 inh, member_init_list);
704 }
705
706 for (; fields; fields = DECL_CHAIN (fields))
707 {
708 tree field = fields;
709 tree expr_type;
710
711 if (TREE_CODE (field) != FIELD_DECL)
712 continue;
713 if (inh)
714 continue;
715
716 expr_type = TREE_TYPE (field);
717 if (DECL_NAME (field))
718 {
719 if (VFIELD_NAME_P (DECL_NAME (field)))
720 continue;
721 }
722 else if (ANON_AGGR_TYPE_P (expr_type) && TYPE_FIELDS (expr_type))
723 /* Just use the field; anonymous types can't have
724 nontrivial copy ctors or assignment ops or this
725 function would be deleted. */;
726 else
727 continue;
728
729 /* Compute the type of "init->field". If the copy-constructor
730 parameter is, for example, "const S&", and the type of
731 the field is "T", then the type will usually be "const
732 T". (There are no cv-qualified variants of reference
733 types.) */
734 if (TREE_CODE (expr_type) != REFERENCE_TYPE)
735 {
736 int quals = cvquals;
737
738 if (DECL_MUTABLE_P (field))
739 quals &= ~TYPE_QUAL_CONST;
740 quals |= cp_type_quals (expr_type);
741 expr_type = cp_build_qualified_type (expr_type, quals);
742 }
743
744 init = build3 (COMPONENT_REF, expr_type, parm, field, NULL_TREE);
745 if (move_p && TREE_CODE (expr_type) != REFERENCE_TYPE
746 /* 'move' breaks bit-fields, and has no effect for scalars. */
747 && !scalarish_type_p (expr_type))
748 init = move (init);
749 init = build_tree_list (NULL_TREE, init);
750
751 member_init_list = tree_cons (field, init, member_init_list);
752 }
753 finish_mem_initializers (member_init_list);
754 }
755 }
756
757 static void
do_build_copy_assign(tree fndecl)758 do_build_copy_assign (tree fndecl)
759 {
760 tree parm = DECL_CHAIN (DECL_ARGUMENTS (fndecl));
761 tree compound_stmt;
762 bool move_p = move_fn_p (fndecl);
763 bool trivial = trivial_fn_p (fndecl);
764 int flags = LOOKUP_NORMAL | LOOKUP_NONVIRTUAL | LOOKUP_DEFAULTED;
765
766 compound_stmt = begin_compound_stmt (0);
767 parm = convert_from_reference (parm);
768
769 if (trivial
770 && is_empty_class (current_class_type))
771 /* Don't copy the padding byte; it might not have been allocated
772 if *this is a base subobject. */;
773 else if (trivial)
774 {
775 tree t = build2 (MODIFY_EXPR, void_type_node, current_class_ref, parm);
776 finish_expr_stmt (t);
777 }
778 else
779 {
780 tree fields;
781 int cvquals = cp_type_quals (TREE_TYPE (parm));
782 int i;
783 tree binfo, base_binfo;
784
785 /* Assign to each of the direct base classes. */
786 for (binfo = TYPE_BINFO (current_class_type), i = 0;
787 BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
788 {
789 tree converted_parm;
790 vec<tree, va_gc> *parmvec;
791
792 /* We must convert PARM directly to the base class
793 explicitly since the base class may be ambiguous. */
794 converted_parm = build_base_path (PLUS_EXPR, parm, base_binfo, 1,
795 tf_warning_or_error);
796 if (move_p)
797 converted_parm = move (converted_parm);
798 /* Call the base class assignment operator. */
799 parmvec = make_tree_vector_single (converted_parm);
800 finish_expr_stmt
801 (build_special_member_call (current_class_ref,
802 assign_op_identifier,
803 &parmvec,
804 base_binfo,
805 flags,
806 tf_warning_or_error));
807 release_tree_vector (parmvec);
808 }
809
810 /* Assign to each of the non-static data members. */
811 for (fields = TYPE_FIELDS (current_class_type);
812 fields;
813 fields = DECL_CHAIN (fields))
814 {
815 tree comp = current_class_ref;
816 tree init = parm;
817 tree field = fields;
818 tree expr_type;
819 int quals;
820
821 if (TREE_CODE (field) != FIELD_DECL || DECL_ARTIFICIAL (field))
822 continue;
823
824 expr_type = TREE_TYPE (field);
825
826 if (CP_TYPE_CONST_P (expr_type))
827 {
828 error ("non-static const member %q#D, can%'t use default "
829 "assignment operator", field);
830 continue;
831 }
832 else if (TREE_CODE (expr_type) == REFERENCE_TYPE)
833 {
834 error ("non-static reference member %q#D, can%'t use "
835 "default assignment operator", field);
836 continue;
837 }
838
839 if (DECL_NAME (field))
840 {
841 if (VFIELD_NAME_P (DECL_NAME (field)))
842 continue;
843 }
844 else if (ANON_AGGR_TYPE_P (expr_type)
845 && TYPE_FIELDS (expr_type) != NULL_TREE)
846 /* Just use the field; anonymous types can't have
847 nontrivial copy ctors or assignment ops or this
848 function would be deleted. */;
849 else
850 continue;
851
852 comp = build3 (COMPONENT_REF, expr_type, comp, field, NULL_TREE);
853
854 /* Compute the type of init->field */
855 quals = cvquals;
856 if (DECL_MUTABLE_P (field))
857 quals &= ~TYPE_QUAL_CONST;
858 expr_type = cp_build_qualified_type (expr_type, quals);
859
860 init = build3 (COMPONENT_REF, expr_type, init, field, NULL_TREE);
861 if (move_p && TREE_CODE (expr_type) != REFERENCE_TYPE
862 /* 'move' breaks bit-fields, and has no effect for scalars. */
863 && !scalarish_type_p (expr_type))
864 init = move (init);
865
866 if (DECL_NAME (field))
867 init = cp_build_modify_expr (input_location, comp, NOP_EXPR, init,
868 tf_warning_or_error);
869 else
870 init = build2 (MODIFY_EXPR, TREE_TYPE (comp), comp, init);
871 finish_expr_stmt (init);
872 }
873 }
874 finish_return_stmt (current_class_ref);
875 finish_compound_stmt (compound_stmt);
876 }
877
878 /* Synthesize FNDECL, a non-static member function. */
879
880 void
synthesize_method(tree fndecl)881 synthesize_method (tree fndecl)
882 {
883 bool nested = (current_function_decl != NULL_TREE);
884 tree context = decl_function_context (fndecl);
885 bool need_body = true;
886 tree stmt;
887 location_t save_input_location = input_location;
888 int error_count = errorcount;
889 int warning_count = warningcount + werrorcount;
890
891 /* Reset the source location, we might have been previously
892 deferred, and thus have saved where we were first needed. */
893 DECL_SOURCE_LOCATION (fndecl)
894 = DECL_SOURCE_LOCATION (TYPE_NAME (DECL_CONTEXT (fndecl)));
895
896 /* If we've been asked to synthesize a clone, just synthesize the
897 cloned function instead. Doing so will automatically fill in the
898 body for the clone. */
899 if (DECL_CLONED_FUNCTION_P (fndecl))
900 fndecl = DECL_CLONED_FUNCTION (fndecl);
901
902 /* We may be in the middle of deferred access check. Disable
903 it now. */
904 push_deferring_access_checks (dk_no_deferred);
905
906 if (! context)
907 push_to_top_level ();
908 else if (nested)
909 push_function_context ();
910
911 input_location = DECL_SOURCE_LOCATION (fndecl);
912
913 start_preparsed_function (fndecl, NULL_TREE, SF_DEFAULT | SF_PRE_PARSED);
914 stmt = begin_function_body ();
915
916 if (DECL_ASSIGNMENT_OPERATOR_P (fndecl)
917 && DECL_OVERLOADED_OPERATOR_IS (fndecl, NOP_EXPR))
918 {
919 do_build_copy_assign (fndecl);
920 need_body = false;
921 }
922 else if (DECL_CONSTRUCTOR_P (fndecl))
923 {
924 tree arg_chain = FUNCTION_FIRST_USER_PARMTYPE (fndecl);
925 if (arg_chain != void_list_node)
926 do_build_copy_constructor (fndecl);
927 else
928 finish_mem_initializers (NULL_TREE);
929 }
930
931 /* If we haven't yet generated the body of the function, just
932 generate an empty compound statement. */
933 if (need_body)
934 {
935 tree compound_stmt;
936 compound_stmt = begin_compound_stmt (BCS_FN_BODY);
937 finish_compound_stmt (compound_stmt);
938 }
939
940 finish_function_body (stmt);
941 expand_or_defer_fn (finish_function (/*inline_p=*/false));
942
943 input_location = save_input_location;
944
945 if (! context)
946 pop_from_top_level ();
947 else if (nested)
948 pop_function_context ();
949
950 pop_deferring_access_checks ();
951
952 if (error_count != errorcount || warning_count != warningcount + werrorcount)
953 inform (input_location, "synthesized method %qD first required here",
954 fndecl);
955 }
956
957 /* Build a reference to type TYPE with cv-quals QUALS, which is an
958 rvalue if RVALUE is true. */
959
960 static tree
build_stub_type(tree type,int quals,bool rvalue)961 build_stub_type (tree type, int quals, bool rvalue)
962 {
963 tree argtype = cp_build_qualified_type (type, quals);
964 return cp_build_reference_type (argtype, rvalue);
965 }
966
967 /* Build a dummy glvalue from dereferencing a dummy reference of type
968 REFTYPE. */
969
970 static tree
build_stub_object(tree reftype)971 build_stub_object (tree reftype)
972 {
973 if (TREE_CODE (reftype) != REFERENCE_TYPE)
974 reftype = cp_build_reference_type (reftype, /*rval*/true);
975 tree stub = build1 (CONVERT_EXPR, reftype, integer_one_node);
976 return convert_from_reference (stub);
977 }
978
979 /* Determine which function will be called when looking up NAME in TYPE,
980 called with a single ARGTYPE argument, or no argument if ARGTYPE is
981 null. FLAGS and COMPLAIN are as for build_new_method_call.
982
983 Returns a FUNCTION_DECL if all is well.
984 Returns NULL_TREE if overload resolution failed.
985 Returns error_mark_node if the chosen function cannot be called. */
986
987 static tree
locate_fn_flags(tree type,tree name,tree argtype,int flags,tsubst_flags_t complain)988 locate_fn_flags (tree type, tree name, tree argtype, int flags,
989 tsubst_flags_t complain)
990 {
991 tree ob, fn, fns, binfo, rval;
992 vec<tree, va_gc> *args;
993
994 if (TYPE_P (type))
995 binfo = TYPE_BINFO (type);
996 else
997 {
998 binfo = type;
999 type = BINFO_TYPE (binfo);
1000 }
1001
1002 ob = build_stub_object (cp_build_reference_type (type, false));
1003 args = make_tree_vector ();
1004 if (argtype)
1005 {
1006 if (TREE_CODE (argtype) == TREE_LIST)
1007 {
1008 for (tree elt = argtype; elt && elt != void_list_node;
1009 elt = TREE_CHAIN (elt))
1010 {
1011 tree type = TREE_VALUE (elt);
1012 tree arg = build_stub_object (type);
1013 vec_safe_push (args, arg);
1014 }
1015 }
1016 else
1017 {
1018 tree arg = build_stub_object (argtype);
1019 args->quick_push (arg);
1020 }
1021 }
1022
1023 fns = lookup_fnfields (binfo, name, 0);
1024 rval = build_new_method_call (ob, fns, &args, binfo, flags, &fn, complain);
1025
1026 release_tree_vector (args);
1027 if (fn && rval == error_mark_node)
1028 return rval;
1029 else
1030 return fn;
1031 }
1032
1033 /* Locate the dtor of TYPE. */
1034
1035 tree
get_dtor(tree type,tsubst_flags_t complain)1036 get_dtor (tree type, tsubst_flags_t complain)
1037 {
1038 tree fn = locate_fn_flags (type, complete_dtor_identifier, NULL_TREE,
1039 LOOKUP_NORMAL, complain);
1040 if (fn == error_mark_node)
1041 return NULL_TREE;
1042 return fn;
1043 }
1044
1045 /* Locate the default ctor of TYPE. */
1046
1047 tree
locate_ctor(tree type)1048 locate_ctor (tree type)
1049 {
1050 tree fn;
1051
1052 push_deferring_access_checks (dk_no_check);
1053 fn = locate_fn_flags (type, complete_ctor_identifier, NULL_TREE,
1054 LOOKUP_SPECULATIVE, tf_none);
1055 pop_deferring_access_checks ();
1056 if (fn == error_mark_node)
1057 return NULL_TREE;
1058 return fn;
1059 }
1060
1061 /* Likewise, but give any appropriate errors. */
1062
1063 tree
get_default_ctor(tree type)1064 get_default_ctor (tree type)
1065 {
1066 tree fn = locate_fn_flags (type, complete_ctor_identifier, NULL_TREE,
1067 LOOKUP_NORMAL, tf_warning_or_error);
1068 if (fn == error_mark_node)
1069 return NULL_TREE;
1070 return fn;
1071 }
1072
1073 /* Locate the copy ctor of TYPE. */
1074
1075 tree
get_copy_ctor(tree type,tsubst_flags_t complain)1076 get_copy_ctor (tree type, tsubst_flags_t complain)
1077 {
1078 int quals = (TYPE_HAS_CONST_COPY_CTOR (type)
1079 ? TYPE_QUAL_CONST : TYPE_UNQUALIFIED);
1080 tree argtype = build_stub_type (type, quals, false);
1081 tree fn = locate_fn_flags (type, complete_ctor_identifier, argtype,
1082 LOOKUP_NORMAL, complain);
1083 if (fn == error_mark_node)
1084 return NULL_TREE;
1085 return fn;
1086 }
1087
1088 /* Locate the copy assignment operator of TYPE. */
1089
1090 tree
get_copy_assign(tree type)1091 get_copy_assign (tree type)
1092 {
1093 int quals = (TYPE_HAS_CONST_COPY_ASSIGN (type)
1094 ? TYPE_QUAL_CONST : TYPE_UNQUALIFIED);
1095 tree argtype = build_stub_type (type, quals, false);
1096 tree fn = locate_fn_flags (type, assign_op_identifier, argtype,
1097 LOOKUP_NORMAL, tf_warning_or_error);
1098 if (fn == error_mark_node)
1099 return NULL_TREE;
1100 return fn;
1101 }
1102
1103 /* walk_tree helper function for is_trivially_xible. If *TP is a call,
1104 return it if it calls something other than a trivial special member
1105 function. */
1106
1107 static tree
check_nontriv(tree * tp,int *,void *)1108 check_nontriv (tree *tp, int *, void *)
1109 {
1110 tree fn = cp_get_callee (*tp);
1111 if (fn == NULL_TREE)
1112 return NULL_TREE;
1113
1114 if (TREE_CODE (fn) == ADDR_EXPR)
1115 fn = TREE_OPERAND (fn, 0);
1116
1117 if (TREE_CODE (fn) != FUNCTION_DECL
1118 || !trivial_fn_p (fn))
1119 return fn;
1120 return NULL_TREE;
1121 }
1122
1123 /* Return declval<T>() = declval<U>() treated as an unevaluated operand. */
1124
1125 static tree
assignable_expr(tree to,tree from)1126 assignable_expr (tree to, tree from)
1127 {
1128 ++cp_unevaluated_operand;
1129 to = build_stub_object (to);
1130 from = build_stub_object (from);
1131 tree r = cp_build_modify_expr (input_location, to, NOP_EXPR, from, tf_none);
1132 --cp_unevaluated_operand;
1133 return r;
1134 }
1135
1136 /* The predicate condition for a template specialization
1137 is_constructible<T, Args...> shall be satisfied if and only if the
1138 following variable definition would be well-formed for some invented
1139 variable t: T t(create<Args>()...);
1140
1141 Return something equivalent in well-formedness and triviality. */
1142
1143 static tree
constructible_expr(tree to,tree from)1144 constructible_expr (tree to, tree from)
1145 {
1146 tree expr;
1147 cp_unevaluated cp_uneval_guard;
1148 if (CLASS_TYPE_P (to))
1149 {
1150 tree ctype = to;
1151 vec<tree, va_gc> *args = NULL;
1152 if (TREE_CODE (to) != REFERENCE_TYPE)
1153 to = cp_build_reference_type (to, /*rval*/false);
1154 tree ob = build_stub_object (to);
1155 for (; from; from = TREE_CHAIN (from))
1156 vec_safe_push (args, build_stub_object (TREE_VALUE (from)));
1157 expr = build_special_member_call (ob, complete_ctor_identifier, &args,
1158 ctype, LOOKUP_NORMAL, tf_none);
1159 if (expr == error_mark_node)
1160 return error_mark_node;
1161 /* The current state of the standard vis-a-vis LWG 2116 is that
1162 is_*constructible involves destruction as well. */
1163 if (type_build_dtor_call (ctype))
1164 {
1165 tree dtor = build_special_member_call (ob, complete_dtor_identifier,
1166 NULL, ctype, LOOKUP_NORMAL,
1167 tf_none);
1168 if (dtor == error_mark_node)
1169 return error_mark_node;
1170 if (!TYPE_HAS_TRIVIAL_DESTRUCTOR (ctype))
1171 expr = build2 (COMPOUND_EXPR, void_type_node, expr, dtor);
1172 }
1173 }
1174 else
1175 {
1176 if (from == NULL_TREE)
1177 return build_value_init (strip_array_types (to), tf_none);
1178 else if (TREE_CHAIN (from))
1179 return error_mark_node; // too many initializers
1180 from = build_stub_object (TREE_VALUE (from));
1181 expr = perform_direct_initialization_if_possible (to, from,
1182 /*cast*/false,
1183 tf_none);
1184 }
1185 return expr;
1186 }
1187
1188 /* Returns a tree iff TO is assignable (if CODE is MODIFY_EXPR) or
1189 constructible (otherwise) from FROM, which is a single type for
1190 assignment or a list of types for construction. */
1191
1192 static tree
is_xible_helper(enum tree_code code,tree to,tree from,bool trivial)1193 is_xible_helper (enum tree_code code, tree to, tree from, bool trivial)
1194 {
1195 if (VOID_TYPE_P (to) || ABSTRACT_CLASS_TYPE_P (to)
1196 || (from && FUNC_OR_METHOD_TYPE_P (from)
1197 && (TYPE_READONLY (from) || FUNCTION_REF_QUALIFIED (from))))
1198 return error_mark_node;
1199 tree expr;
1200 if (code == MODIFY_EXPR)
1201 expr = assignable_expr (to, from);
1202 else if (trivial && from && TREE_CHAIN (from))
1203 return error_mark_node; // only 0- and 1-argument ctors can be trivial
1204 else
1205 expr = constructible_expr (to, from);
1206 return expr;
1207 }
1208
1209 /* Returns true iff TO is trivially assignable (if CODE is MODIFY_EXPR) or
1210 constructible (otherwise) from FROM, which is a single type for
1211 assignment or a list of types for construction. */
1212
1213 bool
is_trivially_xible(enum tree_code code,tree to,tree from)1214 is_trivially_xible (enum tree_code code, tree to, tree from)
1215 {
1216 tree expr;
1217 expr = is_xible_helper (code, to, from, /*trivial*/true);
1218
1219 if (expr == NULL_TREE || expr == error_mark_node)
1220 return false;
1221 tree nt = cp_walk_tree_without_duplicates (&expr, check_nontriv, NULL);
1222 return !nt;
1223 }
1224
1225 /* Returns true iff TO is assignable (if CODE is MODIFY_EXPR) or
1226 constructible (otherwise) from FROM, which is a single type for
1227 assignment or a list of types for construction. */
1228
1229 bool
is_xible(enum tree_code code,tree to,tree from)1230 is_xible (enum tree_code code, tree to, tree from)
1231 {
1232 tree expr = is_xible_helper (code, to, from, /*trivial*/false);
1233 if (expr == error_mark_node)
1234 return false;
1235 return !!expr;
1236 }
1237
1238 /* Subroutine of synthesized_method_walk. Update SPEC_P, TRIVIAL_P and
1239 DELETED_P or give an error message MSG with argument ARG. */
1240
1241 static void
1242 process_subob_fn (tree fn, tree *spec_p, bool *trivial_p,
1243 bool *deleted_p, bool *constexpr_p,
1244 bool diag, tree arg, bool dtor_from_ctor = false)
1245 {
1246 if (!fn || fn == error_mark_node)
1247 {
1248 if (deleted_p)
1249 *deleted_p = true;
1250 return;
1251 }
1252
1253 if (spec_p)
1254 {
1255 maybe_instantiate_noexcept (fn);
1256 tree raises = TYPE_RAISES_EXCEPTIONS (TREE_TYPE (fn));
1257 *spec_p = merge_exception_specifiers (*spec_p, raises);
1258 }
1259
1260 if (!trivial_fn_p (fn) && !dtor_from_ctor)
1261 {
1262 if (trivial_p)
1263 *trivial_p = false;
1264 if (TREE_CODE (arg) == FIELD_DECL
1265 && TREE_CODE (DECL_CONTEXT (arg)) == UNION_TYPE)
1266 {
1267 if (deleted_p)
1268 *deleted_p = true;
1269 if (diag)
1270 error ("union member %q+D with non-trivial %qD", arg, fn);
1271 }
1272 }
1273
1274 if (constexpr_p && !DECL_DECLARED_CONSTEXPR_P (fn))
1275 {
1276 *constexpr_p = false;
1277 if (diag)
1278 {
1279 inform (DECL_SOURCE_LOCATION (fn),
1280 "defaulted constructor calls non-%<constexpr%> %qD", fn);
1281 explain_invalid_constexpr_fn (fn);
1282 }
1283 }
1284 }
1285
1286 /* Subroutine of synthesized_method_walk to allow recursion into anonymous
1287 aggregates. If DTOR_FROM_CTOR is true, we're walking subobject destructors
1288 called from a synthesized constructor, in which case we don't consider
1289 the triviality of the subobject destructor. */
1290
1291 static void
walk_field_subobs(tree fields,tree fnname,special_function_kind sfk,int quals,bool copy_arg_p,bool move_p,bool assign_p,tree * spec_p,bool * trivial_p,bool * deleted_p,bool * constexpr_p,bool diag,int flags,tsubst_flags_t complain,bool dtor_from_ctor)1292 walk_field_subobs (tree fields, tree fnname, special_function_kind sfk,
1293 int quals, bool copy_arg_p, bool move_p,
1294 bool assign_p, tree *spec_p, bool *trivial_p,
1295 bool *deleted_p, bool *constexpr_p,
1296 bool diag, int flags, tsubst_flags_t complain,
1297 bool dtor_from_ctor)
1298 {
1299 tree field;
1300 for (field = fields; field; field = DECL_CHAIN (field))
1301 {
1302 tree mem_type, argtype, rval;
1303
1304 if (TREE_CODE (field) != FIELD_DECL
1305 || DECL_ARTIFICIAL (field))
1306 continue;
1307
1308 /* Variant members only affect deletedness. In particular, they don't
1309 affect the exception-specification of a user-provided destructor,
1310 which we're figuring out via get_defaulted_eh_spec. So if we aren't
1311 asking if this is deleted, don't even look up the function; we don't
1312 want an error about a deleted function we aren't actually calling. */
1313 if (sfk == sfk_destructor && deleted_p == NULL
1314 && TREE_CODE (DECL_CONTEXT (field)) == UNION_TYPE)
1315 break;
1316
1317 mem_type = strip_array_types (TREE_TYPE (field));
1318 if (assign_p)
1319 {
1320 bool bad = true;
1321 if (CP_TYPE_CONST_P (mem_type) && !CLASS_TYPE_P (mem_type))
1322 {
1323 if (diag)
1324 error ("non-static const member %q#D, can%'t use default "
1325 "assignment operator", field);
1326 }
1327 else if (TREE_CODE (mem_type) == REFERENCE_TYPE)
1328 {
1329 if (diag)
1330 error ("non-static reference member %q#D, can%'t use "
1331 "default assignment operator", field);
1332 }
1333 else
1334 bad = false;
1335
1336 if (bad && deleted_p)
1337 *deleted_p = true;
1338 }
1339 else if (sfk == sfk_constructor || sfk == sfk_inheriting_constructor)
1340 {
1341 bool bad;
1342
1343 if (DECL_INITIAL (field))
1344 {
1345 if (diag && DECL_INITIAL (field) == error_mark_node)
1346 inform (DECL_SOURCE_LOCATION (field),
1347 "initializer for %q#D is invalid", field);
1348 if (trivial_p)
1349 *trivial_p = false;
1350 /* Core 1351: If the field has an NSDMI that could throw, the
1351 default constructor is noexcept(false). */
1352 if (spec_p)
1353 {
1354 tree nsdmi = get_nsdmi (field, /*ctor*/false, complain);
1355 if (!expr_noexcept_p (nsdmi, complain))
1356 *spec_p = noexcept_false_spec;
1357 }
1358 /* Don't do the normal processing. */
1359 continue;
1360 }
1361
1362 bad = false;
1363 if (CP_TYPE_CONST_P (mem_type)
1364 && default_init_uninitialized_part (mem_type))
1365 {
1366 if (diag)
1367 {
1368 error ("uninitialized const member in %q#T",
1369 current_class_type);
1370 inform (DECL_SOURCE_LOCATION (field),
1371 "%q#D should be initialized", field);
1372 }
1373 bad = true;
1374 }
1375 else if (TREE_CODE (mem_type) == REFERENCE_TYPE)
1376 {
1377 if (diag)
1378 {
1379 error ("uninitialized reference member in %q#T",
1380 current_class_type);
1381 inform (DECL_SOURCE_LOCATION (field),
1382 "%q#D should be initialized", field);
1383 }
1384 bad = true;
1385 }
1386
1387 if (bad && deleted_p)
1388 *deleted_p = true;
1389
1390 /* For an implicitly-defined default constructor to be constexpr,
1391 every member must have a user-provided default constructor or
1392 an explicit initializer. */
1393 if (constexpr_p && !CLASS_TYPE_P (mem_type)
1394 && TREE_CODE (DECL_CONTEXT (field)) != UNION_TYPE)
1395 {
1396 *constexpr_p = false;
1397 if (diag)
1398 inform (DECL_SOURCE_LOCATION (field),
1399 "defaulted default constructor does not "
1400 "initialize %q#D", field);
1401 }
1402 }
1403 else if (sfk == sfk_copy_constructor)
1404 {
1405 /* 12.8p11b5 */
1406 if (TREE_CODE (mem_type) == REFERENCE_TYPE
1407 && TYPE_REF_IS_RVALUE (mem_type))
1408 {
1409 if (diag)
1410 error ("copying non-static data member %q#D of rvalue "
1411 "reference type", field);
1412 if (deleted_p)
1413 *deleted_p = true;
1414 }
1415 }
1416
1417 if (!CLASS_TYPE_P (mem_type))
1418 continue;
1419
1420 if (ANON_AGGR_TYPE_P (mem_type))
1421 {
1422 walk_field_subobs (TYPE_FIELDS (mem_type), fnname, sfk, quals,
1423 copy_arg_p, move_p, assign_p, spec_p, trivial_p,
1424 deleted_p, constexpr_p,
1425 diag, flags, complain, dtor_from_ctor);
1426 continue;
1427 }
1428
1429 if (copy_arg_p)
1430 {
1431 int mem_quals = cp_type_quals (mem_type) | quals;
1432 if (DECL_MUTABLE_P (field))
1433 mem_quals &= ~TYPE_QUAL_CONST;
1434 argtype = build_stub_type (mem_type, mem_quals, move_p);
1435 }
1436 else
1437 argtype = NULL_TREE;
1438
1439 rval = locate_fn_flags (mem_type, fnname, argtype, flags, complain);
1440
1441 process_subob_fn (rval, spec_p, trivial_p, deleted_p,
1442 constexpr_p, diag, field, dtor_from_ctor);
1443 }
1444 }
1445
1446 /* Base walker helper for synthesized_method_walk. Inspect a direct
1447 or virtual base. BINFO is the parent type's binfo. BASE_BINFO is
1448 the base binfo of interests. All other parms are as for
1449 synthesized_method_walk, or its local vars. */
1450
1451 static tree
synthesized_method_base_walk(tree binfo,tree base_binfo,int quals,bool copy_arg_p,bool move_p,bool ctor_p,tree * inheriting_ctor,tree inherited_parms,tree fnname,int flags,bool diag,tree * spec_p,bool * trivial_p,bool * deleted_p,bool * constexpr_p)1452 synthesized_method_base_walk (tree binfo, tree base_binfo,
1453 int quals, bool copy_arg_p,
1454 bool move_p, bool ctor_p,
1455 tree *inheriting_ctor, tree inherited_parms,
1456 tree fnname, int flags, bool diag,
1457 tree *spec_p, bool *trivial_p,
1458 bool *deleted_p, bool *constexpr_p)
1459 {
1460 bool inherited_binfo = false;
1461 tree argtype = NULL_TREE;
1462 deferring_kind defer = dk_no_deferred;
1463
1464 if (copy_arg_p)
1465 argtype = build_stub_type (BINFO_TYPE (base_binfo), quals, move_p);
1466 else if (inheriting_ctor
1467 && (inherited_binfo
1468 = binfo_inherited_from (binfo, base_binfo, *inheriting_ctor)))
1469 {
1470 argtype = inherited_parms;
1471 /* Don't check access on the inherited constructor. */
1472 if (flag_new_inheriting_ctors)
1473 defer = dk_deferred;
1474 }
1475 /* To be conservative, ignore access to the base dtor that
1476 DR1658 instructs us to ignore. See the comment in
1477 synthesized_method_walk. */
1478 else if (cxx_dialect >= cxx14 && fnname == complete_dtor_identifier
1479 && BINFO_VIRTUAL_P (base_binfo)
1480 && ABSTRACT_CLASS_TYPE_P (BINFO_TYPE (binfo)))
1481 defer = dk_no_check;
1482
1483 if (defer != dk_no_deferred)
1484 push_deferring_access_checks (defer);
1485 tree rval = locate_fn_flags (base_binfo, fnname, argtype, flags,
1486 diag ? tf_warning_or_error : tf_none);
1487 if (defer != dk_no_deferred)
1488 pop_deferring_access_checks ();
1489
1490 /* Replace an inherited template with the appropriate specialization. */
1491 if (inherited_binfo && rval
1492 && DECL_P (*inheriting_ctor) && DECL_P (rval)
1493 && DECL_CONTEXT (*inheriting_ctor) == DECL_CONTEXT (rval))
1494 *inheriting_ctor = DECL_CLONED_FUNCTION (rval);
1495
1496 process_subob_fn (rval, spec_p, trivial_p, deleted_p,
1497 constexpr_p, diag, BINFO_TYPE (base_binfo));
1498 if (ctor_p &&
1499 (!BINFO_VIRTUAL_P (base_binfo)
1500 || TYPE_HAS_NONTRIVIAL_DESTRUCTOR (BINFO_TYPE (base_binfo))))
1501 {
1502 /* In a constructor we also need to check the subobject
1503 destructors for cleanup of partially constructed objects. */
1504 tree dtor = locate_fn_flags (base_binfo, complete_dtor_identifier,
1505 NULL_TREE, flags,
1506 diag ? tf_warning_or_error : tf_none);
1507 /* Note that we don't pass down trivial_p; the subobject
1508 destructors don't affect triviality of the constructor. Nor
1509 do they affect constexpr-ness (a constant expression doesn't
1510 throw) or exception-specification (a throw from one of the
1511 dtors would be a double-fault). */
1512 process_subob_fn (dtor, NULL, NULL, deleted_p, NULL, false,
1513 BINFO_TYPE (base_binfo), /*dtor_from_ctor*/true);
1514 }
1515
1516 return rval;
1517 }
1518
1519 /* The caller wants to generate an implicit declaration of SFK for
1520 CTYPE which is const if relevant and CONST_P is set. If SPEC_P,
1521 TRIVIAL_P, DELETED_P or CONSTEXPR_P are non-null, set their
1522 referent appropriately. If DIAG is true, we're either being called
1523 from maybe_explain_implicit_delete to give errors, or if
1524 CONSTEXPR_P is non-null, from explain_invalid_constexpr_fn. */
1525
1526 static void
synthesized_method_walk(tree ctype,special_function_kind sfk,bool const_p,tree * spec_p,bool * trivial_p,bool * deleted_p,bool * constexpr_p,bool diag,tree * inheriting_ctor,tree inherited_parms)1527 synthesized_method_walk (tree ctype, special_function_kind sfk, bool const_p,
1528 tree *spec_p, bool *trivial_p, bool *deleted_p,
1529 bool *constexpr_p, bool diag,
1530 tree *inheriting_ctor, tree inherited_parms)
1531 {
1532 tree binfo, base_binfo, fnname;
1533 int i;
1534
1535 if (spec_p)
1536 *spec_p = (cxx_dialect >= cxx11 ? noexcept_true_spec : empty_except_spec);
1537
1538 if (deleted_p)
1539 {
1540 /* "The closure type associated with a lambda-expression has a deleted
1541 default constructor and a deleted copy assignment operator."
1542 This is diagnosed in maybe_explain_implicit_delete. */
1543 if (LAMBDA_TYPE_P (ctype)
1544 && (sfk == sfk_constructor
1545 || sfk == sfk_copy_assignment))
1546 {
1547 *deleted_p = true;
1548 return;
1549 }
1550
1551 *deleted_p = false;
1552 }
1553
1554 bool ctor_p = false;
1555 bool assign_p = false;
1556 bool check_vdtor = false;
1557 switch (sfk)
1558 {
1559 case sfk_move_assignment:
1560 case sfk_copy_assignment:
1561 assign_p = true;
1562 fnname = assign_op_identifier;
1563 break;
1564
1565 case sfk_destructor:
1566 check_vdtor = true;
1567 /* The synthesized method will call base dtors, but check complete
1568 here to avoid having to deal with VTT. */
1569 fnname = complete_dtor_identifier;
1570 break;
1571
1572 case sfk_constructor:
1573 case sfk_move_constructor:
1574 case sfk_copy_constructor:
1575 case sfk_inheriting_constructor:
1576 ctor_p = true;
1577 fnname = complete_ctor_identifier;
1578 break;
1579
1580 default:
1581 gcc_unreachable ();
1582 }
1583
1584 gcc_assert ((sfk == sfk_inheriting_constructor)
1585 == (inheriting_ctor && *inheriting_ctor != NULL_TREE));
1586
1587 /* If that user-written default constructor would satisfy the
1588 requirements of a constexpr constructor (7.1.5), the
1589 implicitly-defined default constructor is constexpr.
1590
1591 The implicitly-defined copy/move assignment operator is constexpr if
1592 - X is a literal type, and
1593 - the assignment operator selected to copy/move each direct base class
1594 subobject is a constexpr function, and
1595 - for each non-static data member of X that is of class type (or array
1596 thereof), the assignment operator selected to copy/move that
1597 member is a constexpr function. */
1598 if (constexpr_p)
1599 *constexpr_p = ctor_p || (assign_p && cxx_dialect >= cxx14);
1600
1601 bool move_p = false;
1602 bool copy_arg_p = false;
1603 switch (sfk)
1604 {
1605 case sfk_constructor:
1606 case sfk_destructor:
1607 case sfk_inheriting_constructor:
1608 break;
1609
1610 case sfk_move_constructor:
1611 case sfk_move_assignment:
1612 move_p = true;
1613 /* FALLTHRU */
1614 case sfk_copy_constructor:
1615 case sfk_copy_assignment:
1616 copy_arg_p = true;
1617 break;
1618
1619 default:
1620 gcc_unreachable ();
1621 }
1622
1623 bool expected_trivial = type_has_trivial_fn (ctype, sfk);
1624 if (trivial_p)
1625 *trivial_p = expected_trivial;
1626
1627 /* The TYPE_HAS_COMPLEX_* flags tell us about constraints from base
1628 class versions and other properties of the type. But a subobject
1629 class can be trivially copyable and yet have overload resolution
1630 choose a template constructor for initialization, depending on
1631 rvalueness and cv-quals. And furthermore, a member in a base might
1632 be trivial but deleted or otherwise not callable. So we can't exit
1633 early in C++0x. The same considerations apply in C++98/03, but
1634 there the definition of triviality does not consider overload
1635 resolution, so a constructor can be trivial even if it would otherwise
1636 call a non-trivial constructor. */
1637 if (expected_trivial
1638 && (!copy_arg_p || cxx_dialect < cxx11))
1639 {
1640 if (constexpr_p && sfk == sfk_constructor)
1641 {
1642 bool cx = trivial_default_constructor_is_constexpr (ctype);
1643 *constexpr_p = cx;
1644 if (diag && !cx && TREE_CODE (ctype) == UNION_TYPE)
1645 /* A trivial constructor doesn't have any NSDMI. */
1646 inform (input_location, "defaulted default constructor does "
1647 "not initialize any non-static data member");
1648 }
1649 if (!diag && cxx_dialect < cxx11)
1650 return;
1651 }
1652
1653 ++cp_unevaluated_operand;
1654 ++c_inhibit_evaluation_warnings;
1655 push_deferring_access_checks (dk_no_deferred);
1656
1657 tree scope = push_scope (ctype);
1658
1659 int flags = LOOKUP_NORMAL | LOOKUP_SPECULATIVE;
1660 if (sfk != sfk_inheriting_constructor)
1661 flags |= LOOKUP_DEFAULTED;
1662
1663 tsubst_flags_t complain = diag ? tf_warning_or_error : tf_none;
1664 if (diag && spec_p)
1665 /* We're in get_defaulted_eh_spec; we don't actually want any walking
1666 diagnostics, we just want complain set. */
1667 diag = false;
1668 int quals = const_p ? TYPE_QUAL_CONST : TYPE_UNQUALIFIED;
1669
1670 for (binfo = TYPE_BINFO (ctype), i = 0;
1671 BINFO_BASE_ITERATE (binfo, i, base_binfo); ++i)
1672 {
1673 if (!assign_p && BINFO_VIRTUAL_P (base_binfo))
1674 /* We'll handle virtual bases below. */
1675 continue;
1676
1677 tree fn = synthesized_method_base_walk (binfo, base_binfo, quals,
1678 copy_arg_p, move_p, ctor_p,
1679 inheriting_ctor,
1680 inherited_parms,
1681 fnname, flags, diag,
1682 spec_p, trivial_p,
1683 deleted_p, constexpr_p);
1684
1685 if (diag && assign_p && move_p
1686 && BINFO_VIRTUAL_P (base_binfo)
1687 && fn && TREE_CODE (fn) == FUNCTION_DECL
1688 && move_fn_p (fn) && !trivial_fn_p (fn)
1689 && vbase_has_user_provided_move_assign (BINFO_TYPE (base_binfo)))
1690 warning (OPT_Wvirtual_move_assign,
1691 "defaulted move assignment for %qT calls a non-trivial "
1692 "move assignment operator for virtual base %qT",
1693 ctype, BINFO_TYPE (base_binfo));
1694
1695 if (check_vdtor && type_has_virtual_destructor (BINFO_TYPE (base_binfo)))
1696 {
1697 /* Unlike for base ctor/op=/dtor, for operator delete it's fine
1698 to have a null fn (no class-specific op delete). */
1699 fn = locate_fn_flags (ctype, ovl_op_identifier (false, DELETE_EXPR),
1700 ptr_type_node, flags, tf_none);
1701 if (fn && fn == error_mark_node)
1702 {
1703 if (complain & tf_error)
1704 locate_fn_flags (ctype, ovl_op_identifier (false, DELETE_EXPR),
1705 ptr_type_node, flags, complain);
1706 if (deleted_p)
1707 *deleted_p = true;
1708 }
1709 check_vdtor = false;
1710 }
1711 }
1712
1713 vec<tree, va_gc> *vbases = CLASSTYPE_VBASECLASSES (ctype);
1714 if (assign_p)
1715 /* Already examined vbases above. */;
1716 else if (vec_safe_is_empty (vbases))
1717 /* No virtual bases to worry about. */;
1718 else if (ABSTRACT_CLASS_TYPE_P (ctype) && cxx_dialect >= cxx14
1719 /* DR 1658 specifies that vbases of abstract classes are
1720 ignored for both ctors and dtors. However, that breaks
1721 virtual dtor overriding when the ignored base has a
1722 throwing destructor. So, ignore that piece of 1658. A
1723 defect has been filed (no number yet). */
1724 && sfk != sfk_destructor)
1725 /* Vbase cdtors are not relevant. */;
1726 else
1727 {
1728 if (constexpr_p)
1729 *constexpr_p = false;
1730
1731 FOR_EACH_VEC_ELT (*vbases, i, base_binfo)
1732 synthesized_method_base_walk (binfo, base_binfo, quals,
1733 copy_arg_p, move_p, ctor_p,
1734 inheriting_ctor, inherited_parms,
1735 fnname, flags, diag,
1736 spec_p, trivial_p,
1737 deleted_p, constexpr_p);
1738 }
1739
1740 /* Now handle the non-static data members. */
1741 walk_field_subobs (TYPE_FIELDS (ctype), fnname, sfk, quals,
1742 copy_arg_p, move_p, assign_p, spec_p, trivial_p,
1743 deleted_p, constexpr_p,
1744 diag, flags, complain, /*dtor_from_ctor*/false);
1745 if (ctor_p)
1746 walk_field_subobs (TYPE_FIELDS (ctype), complete_dtor_identifier,
1747 sfk_destructor, TYPE_UNQUALIFIED, false,
1748 false, false, NULL, NULL,
1749 deleted_p, NULL,
1750 false, flags, complain, /*dtor_from_ctor*/true);
1751
1752 pop_scope (scope);
1753
1754 pop_deferring_access_checks ();
1755 --cp_unevaluated_operand;
1756 --c_inhibit_evaluation_warnings;
1757 }
1758
1759 /* DECL is a defaulted function whose exception specification is now
1760 needed. Return what it should be. */
1761
1762 tree
get_defaulted_eh_spec(tree decl,tsubst_flags_t complain)1763 get_defaulted_eh_spec (tree decl, tsubst_flags_t complain)
1764 {
1765 if (DECL_CLONED_FUNCTION_P (decl))
1766 decl = DECL_CLONED_FUNCTION (decl);
1767 special_function_kind sfk = special_function_p (decl);
1768 tree ctype = DECL_CONTEXT (decl);
1769 tree parms = FUNCTION_FIRST_USER_PARMTYPE (decl);
1770 tree parm_type = TREE_VALUE (parms);
1771 bool const_p = CP_TYPE_CONST_P (non_reference (parm_type));
1772 tree spec = empty_except_spec;
1773 bool diag = !DECL_DELETED_FN (decl) && (complain & tf_error);
1774 tree inh = DECL_INHERITED_CTOR (decl);
1775 synthesized_method_walk (ctype, sfk, const_p, &spec, NULL, NULL,
1776 NULL, diag, &inh, parms);
1777 return spec;
1778 }
1779
1780 /* DECL is a deleted function. If it's implicitly deleted, explain why and
1781 return true; else return false. */
1782
1783 bool
maybe_explain_implicit_delete(tree decl)1784 maybe_explain_implicit_delete (tree decl)
1785 {
1786 /* If decl is a clone, get the primary variant. */
1787 decl = DECL_ORIGIN (decl);
1788 gcc_assert (DECL_DELETED_FN (decl));
1789 if (DECL_DEFAULTED_FN (decl))
1790 {
1791 /* Not marked GTY; it doesn't need to be GC'd or written to PCH. */
1792 static hash_set<tree> *explained;
1793
1794 special_function_kind sfk;
1795 location_t loc;
1796 bool informed;
1797 tree ctype;
1798
1799 if (!explained)
1800 explained = new hash_set<tree>;
1801 if (explained->add (decl))
1802 return true;
1803
1804 sfk = special_function_p (decl);
1805 ctype = DECL_CONTEXT (decl);
1806 loc = input_location;
1807 input_location = DECL_SOURCE_LOCATION (decl);
1808
1809 informed = false;
1810 if (LAMBDA_TYPE_P (ctype))
1811 {
1812 informed = true;
1813 if (sfk == sfk_constructor)
1814 inform (DECL_SOURCE_LOCATION (decl),
1815 "a lambda closure type has a deleted default constructor");
1816 else if (sfk == sfk_copy_assignment)
1817 inform (DECL_SOURCE_LOCATION (decl),
1818 "a lambda closure type has a deleted copy assignment operator");
1819 else
1820 informed = false;
1821 }
1822 else if (DECL_ARTIFICIAL (decl)
1823 && (sfk == sfk_copy_assignment || sfk == sfk_copy_constructor)
1824 && classtype_has_move_assign_or_move_ctor_p (ctype, true))
1825 {
1826 inform (DECL_SOURCE_LOCATION (decl),
1827 "%q#D is implicitly declared as deleted because %qT "
1828 "declares a move constructor or move assignment operator",
1829 decl, ctype);
1830 informed = true;
1831 }
1832 else if (sfk == sfk_inheriting_constructor)
1833 {
1834 tree binfo = inherited_ctor_binfo (decl);
1835 if (TREE_CODE (binfo) != TREE_BINFO)
1836 {
1837 inform (DECL_SOURCE_LOCATION (decl),
1838 "%q#D inherits from multiple base subobjects",
1839 decl);
1840 informed = true;
1841 }
1842 }
1843 if (!informed)
1844 {
1845 tree parms = FUNCTION_FIRST_USER_PARMTYPE (decl);
1846 bool const_p = false;
1847 if (parms)
1848 {
1849 tree parm_type = TREE_VALUE (parms);
1850 const_p = CP_TYPE_CONST_P (non_reference (parm_type));
1851 }
1852 tree raises = NULL_TREE;
1853 bool deleted_p = false;
1854 tree scope = push_scope (ctype);
1855 tree inh = DECL_INHERITED_CTOR (decl);
1856
1857 synthesized_method_walk (ctype, sfk, const_p,
1858 &raises, NULL, &deleted_p, NULL, false,
1859 &inh, parms);
1860 if (deleted_p)
1861 {
1862 inform (DECL_SOURCE_LOCATION (decl),
1863 "%q#D is implicitly deleted because the default "
1864 "definition would be ill-formed:", decl);
1865 synthesized_method_walk (ctype, sfk, const_p,
1866 NULL, NULL, &deleted_p, NULL, true,
1867 &inh, parms);
1868 }
1869 else if (!comp_except_specs
1870 (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (decl)),
1871 raises, ce_normal))
1872 inform (DECL_SOURCE_LOCATION (decl), "%q#F is implicitly "
1873 "deleted because its exception-specification does not "
1874 "match the implicit exception-specification %qX",
1875 decl, raises);
1876 else if (flag_checking)
1877 gcc_unreachable ();
1878
1879 pop_scope (scope);
1880 }
1881
1882 input_location = loc;
1883 return true;
1884 }
1885 return false;
1886 }
1887
1888 /* DECL is a defaulted function which was declared constexpr. Explain why
1889 it can't be constexpr. */
1890
1891 void
explain_implicit_non_constexpr(tree decl)1892 explain_implicit_non_constexpr (tree decl)
1893 {
1894 tree parm_type = TREE_VALUE (FUNCTION_FIRST_USER_PARMTYPE (decl));
1895 bool const_p = CP_TYPE_CONST_P (non_reference (parm_type));
1896 tree inh = DECL_INHERITED_CTOR (decl);
1897 bool dummy;
1898 synthesized_method_walk (DECL_CLASS_CONTEXT (decl),
1899 special_function_p (decl), const_p,
1900 NULL, NULL, NULL, &dummy, true,
1901 &inh,
1902 FUNCTION_FIRST_USER_PARMTYPE (decl));
1903 }
1904
1905 /* DECL is an instantiation of an inheriting constructor template. Deduce
1906 the correct exception-specification and deletedness for this particular
1907 specialization. */
1908
1909 void
deduce_inheriting_ctor(tree decl)1910 deduce_inheriting_ctor (tree decl)
1911 {
1912 decl = DECL_ORIGIN (decl);
1913 gcc_assert (DECL_INHERITED_CTOR (decl));
1914 tree spec;
1915 bool trivial, constexpr_, deleted;
1916 tree inh = DECL_INHERITED_CTOR (decl);
1917 synthesized_method_walk (DECL_CONTEXT (decl), sfk_inheriting_constructor,
1918 false, &spec, &trivial, &deleted, &constexpr_,
1919 /*diag*/false,
1920 &inh,
1921 FUNCTION_FIRST_USER_PARMTYPE (decl));
1922 if (TREE_CODE (inherited_ctor_binfo (decl)) != TREE_BINFO)
1923 /* Inherited the same constructor from different base subobjects. */
1924 deleted = true;
1925 DECL_DELETED_FN (decl) = deleted;
1926 TREE_TYPE (decl) = build_exception_variant (TREE_TYPE (decl), spec);
1927 SET_DECL_INHERITED_CTOR (decl, inh);
1928
1929 tree clone;
1930 FOR_EACH_CLONE (clone, decl)
1931 {
1932 DECL_DELETED_FN (clone) = deleted;
1933 TREE_TYPE (clone) = build_exception_variant (TREE_TYPE (clone), spec);
1934 SET_DECL_INHERITED_CTOR (clone, inh);
1935 }
1936 }
1937
1938 /* Implicitly declare the special function indicated by KIND, as a
1939 member of TYPE. For copy constructors and assignment operators,
1940 CONST_P indicates whether these functions should take a const
1941 reference argument or a non-const reference. Returns the
1942 FUNCTION_DECL for the implicitly declared function. */
1943
1944 tree
implicitly_declare_fn(special_function_kind kind,tree type,bool const_p,tree inherited_ctor,tree inherited_parms)1945 implicitly_declare_fn (special_function_kind kind, tree type,
1946 bool const_p, tree inherited_ctor,
1947 tree inherited_parms)
1948 {
1949 tree fn;
1950 tree parameter_types = void_list_node;
1951 tree return_type;
1952 tree fn_type;
1953 tree raises = empty_except_spec;
1954 tree rhs_parm_type = NULL_TREE;
1955 tree this_parm;
1956 tree name;
1957 HOST_WIDE_INT saved_processing_template_decl;
1958 bool deleted_p;
1959 bool constexpr_p;
1960
1961 /* Because we create declarations for implicitly declared functions
1962 lazily, we may be creating the declaration for a member of TYPE
1963 while in some completely different context. However, TYPE will
1964 never be a dependent class (because we never want to do lookups
1965 for implicitly defined functions in a dependent class).
1966 Furthermore, we must set PROCESSING_TEMPLATE_DECL to zero here
1967 because we only create clones for constructors and destructors
1968 when not in a template. */
1969 gcc_assert (!dependent_type_p (type));
1970 saved_processing_template_decl = processing_template_decl;
1971 processing_template_decl = 0;
1972
1973 type = TYPE_MAIN_VARIANT (type);
1974
1975 if (targetm.cxx.cdtor_returns_this ())
1976 {
1977 if (kind == sfk_destructor)
1978 /* See comment in check_special_function_return_type. */
1979 return_type = build_pointer_type (void_type_node);
1980 else
1981 return_type = build_pointer_type (type);
1982 }
1983 else
1984 return_type = void_type_node;
1985
1986 switch (kind)
1987 {
1988 case sfk_destructor:
1989 /* Destructor. */
1990 name = dtor_identifier;
1991 break;
1992
1993 case sfk_constructor:
1994 /* Default constructor. */
1995 name = ctor_identifier;
1996 break;
1997
1998 case sfk_copy_constructor:
1999 case sfk_copy_assignment:
2000 case sfk_move_constructor:
2001 case sfk_move_assignment:
2002 case sfk_inheriting_constructor:
2003 {
2004 if (kind == sfk_copy_assignment
2005 || kind == sfk_move_assignment)
2006 {
2007 return_type = build_reference_type (type);
2008 name = assign_op_identifier;
2009 }
2010 else
2011 name = ctor_identifier;
2012
2013 if (kind == sfk_inheriting_constructor)
2014 parameter_types = inherited_parms;
2015 else
2016 {
2017 if (const_p)
2018 rhs_parm_type = cp_build_qualified_type (type, TYPE_QUAL_CONST);
2019 else
2020 rhs_parm_type = type;
2021 bool move_p = (kind == sfk_move_assignment
2022 || kind == sfk_move_constructor);
2023 rhs_parm_type = cp_build_reference_type (rhs_parm_type, move_p);
2024
2025 parameter_types = tree_cons (NULL_TREE, rhs_parm_type, parameter_types);
2026 }
2027 break;
2028 }
2029 default:
2030 gcc_unreachable ();
2031 }
2032
2033 bool trivial_p = false;
2034
2035 if (inherited_ctor)
2036 {
2037 /* For an inheriting constructor, just copy these flags from the
2038 inherited constructor until deduce_inheriting_ctor. */
2039 raises = TYPE_RAISES_EXCEPTIONS (TREE_TYPE (inherited_ctor));
2040 deleted_p = DECL_DELETED_FN (inherited_ctor);
2041 constexpr_p = DECL_DECLARED_CONSTEXPR_P (inherited_ctor);
2042 }
2043 else if (cxx_dialect >= cxx11)
2044 {
2045 raises = noexcept_deferred_spec;
2046 synthesized_method_walk (type, kind, const_p, NULL, &trivial_p,
2047 &deleted_p, &constexpr_p, false,
2048 &inherited_ctor, inherited_parms);
2049 }
2050 else
2051 synthesized_method_walk (type, kind, const_p, &raises, &trivial_p,
2052 &deleted_p, &constexpr_p, false,
2053 &inherited_ctor, inherited_parms);
2054 /* Don't bother marking a deleted constructor as constexpr. */
2055 if (deleted_p)
2056 constexpr_p = false;
2057 /* A trivial copy/move constructor is also a constexpr constructor,
2058 unless the class has virtual bases (7.1.5p4). */
2059 else if (trivial_p && cxx_dialect >= cxx11
2060 && (kind == sfk_copy_constructor
2061 || kind == sfk_move_constructor)
2062 && !CLASSTYPE_VBASECLASSES (type))
2063 gcc_assert (constexpr_p);
2064
2065 if (!trivial_p && type_has_trivial_fn (type, kind))
2066 type_set_nontrivial_flag (type, kind);
2067
2068 /* Create the function. */
2069 fn_type = build_method_type_directly (type, return_type, parameter_types);
2070 if (raises)
2071 fn_type = build_exception_variant (fn_type, raises);
2072 fn = build_lang_decl (FUNCTION_DECL, name, fn_type);
2073 if (kind != sfk_inheriting_constructor)
2074 DECL_SOURCE_LOCATION (fn) = DECL_SOURCE_LOCATION (TYPE_NAME (type));
2075
2076 if (!IDENTIFIER_CDTOR_P (name))
2077 /* Assignment operator. */
2078 DECL_OVERLOADED_OPERATOR_CODE_RAW (fn) = OVL_OP_NOP_EXPR;
2079 else if (IDENTIFIER_CTOR_P (name))
2080 DECL_CXX_CONSTRUCTOR_P (fn) = true;
2081 else
2082 DECL_CXX_DESTRUCTOR_P (fn) = true;
2083
2084 SET_DECL_ALIGN (fn, MINIMUM_METHOD_BOUNDARY);
2085
2086 /* Create the explicit arguments. */
2087 if (rhs_parm_type)
2088 {
2089 /* Note that this parameter is *not* marked DECL_ARTIFICIAL; we
2090 want its type to be included in the mangled function
2091 name. */
2092 tree decl = cp_build_parm_decl (fn, NULL_TREE, rhs_parm_type);
2093 TREE_READONLY (decl) = 1;
2094 retrofit_lang_decl (decl);
2095 DECL_PARM_INDEX (decl) = DECL_PARM_LEVEL (decl) = 1;
2096 DECL_ARGUMENTS (fn) = decl;
2097 }
2098 else if (kind == sfk_inheriting_constructor)
2099 {
2100 tree *p = &DECL_ARGUMENTS (fn);
2101 int index = 1;
2102 for (tree parm = inherited_parms; parm && parm != void_list_node;
2103 parm = TREE_CHAIN (parm))
2104 {
2105 *p = cp_build_parm_decl (fn, NULL_TREE, TREE_VALUE (parm));
2106 retrofit_lang_decl (*p);
2107 DECL_PARM_LEVEL (*p) = 1;
2108 DECL_PARM_INDEX (*p) = index++;
2109 p = &DECL_CHAIN (*p);
2110 }
2111 SET_DECL_INHERITED_CTOR (fn, inherited_ctor);
2112 DECL_NONCONVERTING_P (fn) = DECL_NONCONVERTING_P (inherited_ctor);
2113 /* A constructor so declared has the same access as the corresponding
2114 constructor in X. */
2115 TREE_PRIVATE (fn) = TREE_PRIVATE (inherited_ctor);
2116 TREE_PROTECTED (fn) = TREE_PROTECTED (inherited_ctor);
2117 /* Copy constexpr from the inherited constructor even if the
2118 inheriting constructor doesn't satisfy the requirements. */
2119 constexpr_p = DECL_DECLARED_CONSTEXPR_P (inherited_ctor);
2120 }
2121 /* Add the "this" parameter. */
2122 this_parm = build_this_parm (fn, fn_type, TYPE_UNQUALIFIED);
2123 DECL_CHAIN (this_parm) = DECL_ARGUMENTS (fn);
2124 DECL_ARGUMENTS (fn) = this_parm;
2125
2126 grokclassfn (type, fn, kind == sfk_destructor ? DTOR_FLAG : NO_SPECIAL);
2127 DECL_IN_AGGR_P (fn) = 1;
2128 DECL_ARTIFICIAL (fn) = 1;
2129 DECL_DEFAULTED_FN (fn) = 1;
2130 if (cxx_dialect >= cxx11)
2131 {
2132 DECL_DELETED_FN (fn) = deleted_p;
2133 DECL_DECLARED_CONSTEXPR_P (fn) = constexpr_p;
2134 }
2135 DECL_EXTERNAL (fn) = true;
2136 DECL_NOT_REALLY_EXTERN (fn) = 1;
2137 DECL_DECLARED_INLINE_P (fn) = 1;
2138 set_linkage_according_to_type (type, fn);
2139 if (TREE_PUBLIC (fn))
2140 DECL_COMDAT (fn) = 1;
2141 rest_of_decl_compilation (fn, namespace_bindings_p (), at_eof);
2142 gcc_assert (!TREE_USED (fn));
2143
2144 /* Propagate constraints from the inherited constructor. */
2145 if (flag_concepts && inherited_ctor)
2146 if (tree orig_ci = get_constraints (inherited_ctor))
2147 {
2148 tree new_ci = copy_node (orig_ci);
2149 set_constraints (fn, new_ci);
2150 }
2151
2152 /* Restore PROCESSING_TEMPLATE_DECL. */
2153 processing_template_decl = saved_processing_template_decl;
2154
2155 if (inherited_ctor && TREE_CODE (inherited_ctor) == TEMPLATE_DECL)
2156 fn = add_inherited_template_parms (fn, inherited_ctor);
2157
2158 /* Warn about calling a non-trivial move assignment in a virtual base. */
2159 if (kind == sfk_move_assignment && !deleted_p && !trivial_p
2160 && CLASSTYPE_VBASECLASSES (type))
2161 {
2162 location_t loc = input_location;
2163 input_location = DECL_SOURCE_LOCATION (fn);
2164 synthesized_method_walk (type, kind, const_p,
2165 NULL, NULL, NULL, NULL, true,
2166 NULL, NULL_TREE);
2167 input_location = loc;
2168 }
2169
2170 return fn;
2171 }
2172
2173 /* Gives any errors about defaulted functions which need to be deferred
2174 until the containing class is complete. */
2175
2176 void
defaulted_late_check(tree fn)2177 defaulted_late_check (tree fn)
2178 {
2179 /* Complain about invalid signature for defaulted fn. */
2180 tree ctx = DECL_CONTEXT (fn);
2181 special_function_kind kind = special_function_p (fn);
2182 bool fn_const_p = (copy_fn_p (fn) == 2);
2183 tree implicit_fn = implicitly_declare_fn (kind, ctx, fn_const_p,
2184 NULL, NULL);
2185 tree eh_spec = TYPE_RAISES_EXCEPTIONS (TREE_TYPE (implicit_fn));
2186
2187 if (!same_type_p (TREE_TYPE (TREE_TYPE (fn)),
2188 TREE_TYPE (TREE_TYPE (implicit_fn)))
2189 || !compparms (TYPE_ARG_TYPES (TREE_TYPE (fn)),
2190 TYPE_ARG_TYPES (TREE_TYPE (implicit_fn))))
2191 {
2192 error ("defaulted declaration %q+D does not match the "
2193 "expected signature", fn);
2194 inform (DECL_SOURCE_LOCATION (fn),
2195 "expected signature: %qD", implicit_fn);
2196 }
2197
2198 if (DECL_DELETED_FN (implicit_fn))
2199 {
2200 DECL_DELETED_FN (fn) = 1;
2201 return;
2202 }
2203
2204 /* 8.4.2/2: An explicitly-defaulted function (...) may have an explicit
2205 exception-specification only if it is compatible (15.4) with the
2206 exception-specification on the implicit declaration. If a function
2207 is explicitly defaulted on its first declaration, (...) it is
2208 implicitly considered to have the same exception-specification as if
2209 it had been implicitly declared. */
2210 maybe_instantiate_noexcept (fn);
2211 tree fn_spec = TYPE_RAISES_EXCEPTIONS (TREE_TYPE (fn));
2212 if (!fn_spec)
2213 {
2214 if (DECL_DEFAULTED_IN_CLASS_P (fn))
2215 TREE_TYPE (fn) = build_exception_variant (TREE_TYPE (fn), eh_spec);
2216 }
2217 else if (UNEVALUATED_NOEXCEPT_SPEC_P (fn_spec))
2218 /* Equivalent to the implicit spec. */;
2219 else if (DECL_DEFAULTED_IN_CLASS_P (fn)
2220 && !CLASSTYPE_TEMPLATE_INSTANTIATION (ctx))
2221 /* We can't compare an explicit exception-specification on a
2222 constructor defaulted in the class body to the implicit
2223 exception-specification until after we've parsed any NSDMI; see
2224 after_nsdmi_defaulted_late_checks. */;
2225 else
2226 {
2227 tree eh_spec = get_defaulted_eh_spec (fn);
2228 if (!comp_except_specs (fn_spec, eh_spec, ce_normal))
2229 {
2230 if (DECL_DEFAULTED_IN_CLASS_P (fn))
2231 DECL_DELETED_FN (fn) = true;
2232 else
2233 error ("function %q+D defaulted on its redeclaration "
2234 "with an exception-specification that differs from "
2235 "the implicit exception-specification %qX", fn, eh_spec);
2236 }
2237 }
2238
2239 if (DECL_DEFAULTED_IN_CLASS_P (fn)
2240 && DECL_DECLARED_CONSTEXPR_P (implicit_fn))
2241 {
2242 /* Hmm...should we do this for out-of-class too? Should it be OK to
2243 add constexpr later like inline, rather than requiring
2244 declarations to match? */
2245 DECL_DECLARED_CONSTEXPR_P (fn) = true;
2246 if (kind == sfk_constructor)
2247 TYPE_HAS_CONSTEXPR_CTOR (ctx) = true;
2248 }
2249
2250 if (!DECL_DECLARED_CONSTEXPR_P (implicit_fn)
2251 && DECL_DECLARED_CONSTEXPR_P (fn))
2252 {
2253 if (!CLASSTYPE_TEMPLATE_INSTANTIATION (ctx))
2254 {
2255 error ("explicitly defaulted function %q+D cannot be declared "
2256 "as %<constexpr%> because the implicit declaration is not "
2257 "%<constexpr%>:", fn);
2258 explain_implicit_non_constexpr (fn);
2259 }
2260 DECL_DECLARED_CONSTEXPR_P (fn) = false;
2261 }
2262 }
2263
2264 /* OK, we've parsed the NSDMI for class T, now we can check any explicit
2265 exception-specifications on functions defaulted in the class body. */
2266
2267 void
after_nsdmi_defaulted_late_checks(tree t)2268 after_nsdmi_defaulted_late_checks (tree t)
2269 {
2270 if (uses_template_parms (t))
2271 return;
2272 if (t == error_mark_node)
2273 return;
2274 for (tree fn = TYPE_FIELDS (t); fn; fn = DECL_CHAIN (fn))
2275 if (!DECL_ARTIFICIAL (fn)
2276 && DECL_DECLARES_FUNCTION_P (fn)
2277 && DECL_DEFAULTED_IN_CLASS_P (fn))
2278 {
2279 tree fn_spec = TYPE_RAISES_EXCEPTIONS (TREE_TYPE (fn));
2280 if (UNEVALUATED_NOEXCEPT_SPEC_P (fn_spec))
2281 continue;
2282
2283 tree eh_spec = get_defaulted_eh_spec (fn);
2284 if (!comp_except_specs (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (fn)),
2285 eh_spec, ce_normal))
2286 DECL_DELETED_FN (fn) = true;
2287 }
2288 }
2289
2290 /* Returns true iff FN can be explicitly defaulted, and gives any
2291 errors if defaulting FN is ill-formed. */
2292
2293 bool
defaultable_fn_check(tree fn)2294 defaultable_fn_check (tree fn)
2295 {
2296 special_function_kind kind = sfk_none;
2297
2298 if (template_parm_scope_p ())
2299 {
2300 error ("a template cannot be defaulted");
2301 return false;
2302 }
2303
2304 if (DECL_CONSTRUCTOR_P (fn))
2305 {
2306 if (FUNCTION_FIRST_USER_PARMTYPE (fn) == void_list_node)
2307 kind = sfk_constructor;
2308 else if (copy_fn_p (fn) > 0
2309 && (TREE_CHAIN (FUNCTION_FIRST_USER_PARMTYPE (fn))
2310 == void_list_node))
2311 kind = sfk_copy_constructor;
2312 else if (move_fn_p (fn))
2313 kind = sfk_move_constructor;
2314 }
2315 else if (DECL_DESTRUCTOR_P (fn))
2316 kind = sfk_destructor;
2317 else if (DECL_ASSIGNMENT_OPERATOR_P (fn)
2318 && DECL_OVERLOADED_OPERATOR_IS (fn, NOP_EXPR))
2319 {
2320 if (copy_fn_p (fn))
2321 kind = sfk_copy_assignment;
2322 else if (move_fn_p (fn))
2323 kind = sfk_move_assignment;
2324 }
2325
2326 if (kind == sfk_none)
2327 {
2328 error ("%qD cannot be defaulted", fn);
2329 return false;
2330 }
2331 else
2332 {
2333 for (tree t = FUNCTION_FIRST_USER_PARMTYPE (fn);
2334 t && t != void_list_node; t = TREE_CHAIN (t))
2335 if (TREE_PURPOSE (t))
2336 {
2337 error ("defaulted function %q+D with default argument", fn);
2338 break;
2339 }
2340
2341 /* Avoid do_warn_unused_parameter warnings. */
2342 for (tree p = FUNCTION_FIRST_USER_PARM (fn); p; p = DECL_CHAIN (p))
2343 if (DECL_NAME (p))
2344 TREE_NO_WARNING (p) = 1;
2345
2346 if (TYPE_BEING_DEFINED (DECL_CONTEXT (fn)))
2347 /* Defer checking. */;
2348 else if (!processing_template_decl)
2349 defaulted_late_check (fn);
2350
2351 return true;
2352 }
2353 }
2354
2355 /* Add an implicit declaration to TYPE for the kind of function
2356 indicated by SFK. Return the FUNCTION_DECL for the new implicit
2357 declaration. */
2358
2359 tree
lazily_declare_fn(special_function_kind sfk,tree type)2360 lazily_declare_fn (special_function_kind sfk, tree type)
2361 {
2362 tree fn;
2363 /* Whether or not the argument has a const reference type. */
2364 bool const_p = false;
2365
2366 type = TYPE_MAIN_VARIANT (type);
2367
2368 switch (sfk)
2369 {
2370 case sfk_constructor:
2371 CLASSTYPE_LAZY_DEFAULT_CTOR (type) = 0;
2372 break;
2373 case sfk_copy_constructor:
2374 const_p = TYPE_HAS_CONST_COPY_CTOR (type);
2375 CLASSTYPE_LAZY_COPY_CTOR (type) = 0;
2376 break;
2377 case sfk_move_constructor:
2378 CLASSTYPE_LAZY_MOVE_CTOR (type) = 0;
2379 break;
2380 case sfk_copy_assignment:
2381 const_p = TYPE_HAS_CONST_COPY_ASSIGN (type);
2382 CLASSTYPE_LAZY_COPY_ASSIGN (type) = 0;
2383 break;
2384 case sfk_move_assignment:
2385 CLASSTYPE_LAZY_MOVE_ASSIGN (type) = 0;
2386 break;
2387 case sfk_destructor:
2388 CLASSTYPE_LAZY_DESTRUCTOR (type) = 0;
2389 break;
2390 default:
2391 gcc_unreachable ();
2392 }
2393
2394 /* Declare the function. */
2395 fn = implicitly_declare_fn (sfk, type, const_p, NULL, NULL);
2396
2397 /* [class.copy]/8 If the class definition declares a move constructor or
2398 move assignment operator, the implicitly declared copy constructor is
2399 defined as deleted.... */
2400 if ((sfk == sfk_copy_assignment || sfk == sfk_copy_constructor)
2401 && classtype_has_move_assign_or_move_ctor_p (type, true))
2402 DECL_DELETED_FN (fn) = true;
2403
2404 /* Destructors and assignment operators may be virtual. */
2405 if (sfk == sfk_destructor
2406 || sfk == sfk_move_assignment
2407 || sfk == sfk_copy_assignment)
2408 check_for_override (fn, type);
2409
2410 /* Add it to the class */
2411 bool added = add_method (type, fn, false);
2412 gcc_assert (added || errorcount);
2413
2414 /* Add it to TYPE_FIELDS. */
2415 if (sfk == sfk_destructor
2416 && DECL_VIRTUAL_P (fn))
2417 /* The ABI requires that a virtual destructor go at the end of the
2418 vtable. */
2419 TYPE_FIELDS (type) = chainon (TYPE_FIELDS (type), fn);
2420 else
2421 {
2422 DECL_CHAIN (fn) = TYPE_FIELDS (type);
2423 TYPE_FIELDS (type) = fn;
2424 }
2425 /* Propagate TYPE_FIELDS. */
2426 fixup_type_variants (type);
2427
2428 maybe_add_class_template_decl_list (type, fn, /*friend_p=*/0);
2429 if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (fn)
2430 || DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (fn))
2431 /* Create appropriate clones. */
2432 clone_function_decl (fn, /*update_methods=*/true);
2433
2434 return fn;
2435 }
2436
2437 /* Given a FUNCTION_DECL FN and a chain LIST, skip as many elements of LIST
2438 as there are artificial parms in FN. */
2439
2440 tree
skip_artificial_parms_for(const_tree fn,tree list)2441 skip_artificial_parms_for (const_tree fn, tree list)
2442 {
2443 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fn))
2444 list = TREE_CHAIN (list);
2445 else
2446 return list;
2447
2448 if (DECL_HAS_IN_CHARGE_PARM_P (fn))
2449 list = TREE_CHAIN (list);
2450 if (DECL_HAS_VTT_PARM_P (fn))
2451 list = TREE_CHAIN (list);
2452 return list;
2453 }
2454
2455 /* Given a FUNCTION_DECL FN and a chain LIST, return the number of
2456 artificial parms in FN. */
2457
2458 int
num_artificial_parms_for(const_tree fn)2459 num_artificial_parms_for (const_tree fn)
2460 {
2461 int count = 0;
2462
2463 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fn))
2464 count++;
2465 else
2466 return 0;
2467
2468 if (DECL_HAS_IN_CHARGE_PARM_P (fn))
2469 count++;
2470 if (DECL_HAS_VTT_PARM_P (fn))
2471 count++;
2472 return count;
2473 }
2474
2475
2476 #include "gt-cp-method.h"
2477