1 /* Handle the hair of processing (but not expanding) inline functions.
2 Also manage function and variable name overloading.
3 Copyright (C) 1987, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
4 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2007, 2008, 2009, 2010
5 Free Software Foundation, Inc.
6 Contributed by Michael Tiemann (tiemann@cygnus.com)
8 This file is part of GCC.
10 GCC is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 3, or (at your option)
15 GCC is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
20 You should have received a copy of the GNU General Public License
21 along with GCC; see the file COPYING3. If not see
22 <http://www.gnu.org/licenses/>. */
25 /* Handle method declarations. */
28 #include "coretypes.h"
37 #include "tree-pass.h"
38 #include "diagnostic.h"
42 /* Various flags to control the mangling process. */
48 /* The thing we are presently mangling is part of a template type,
49 rather than a fully instantiated type. Therefore, we may see
50 complex expressions where we would normally expect to see a
51 simple integer constant. */
52 mf_maybe_uninstantiated = 1,
53 /* When mangling a numeric value, use the form `_XX_' (instead of
54 just `XX') if the value has more than one digit. */
55 mf_use_underscores_around_value = 2
58 typedef enum mangling_flags mangling_flags;
60 static void do_build_copy_assign (tree);
61 static void do_build_copy_constructor (tree);
62 static tree make_alias_for_thunk (tree);
64 /* Called once to initialize method.c. */
72 /* Return a this or result adjusting thunk to FUNCTION. THIS_ADJUSTING
73 indicates whether it is a this or result adjusting thunk.
74 FIXED_OFFSET and VIRTUAL_OFFSET indicate how to do the adjustment
75 (see thunk_adjust). VIRTUAL_OFFSET can be NULL, but FIXED_OFFSET
76 never is. VIRTUAL_OFFSET is the /index/ into the vtable for this
77 adjusting thunks, we scale it to a byte offset. For covariant
78 thunks VIRTUAL_OFFSET is the virtual binfo. You must post process
79 the returned thunk with finish_thunk. */
82 make_thunk (tree function, bool this_adjusting,
83 tree fixed_offset, tree virtual_offset)
88 gcc_assert (TREE_CODE (function) == FUNCTION_DECL);
89 /* We can have this thunks to covariant thunks, but not vice versa. */
90 gcc_assert (!DECL_THIS_THUNK_P (function));
91 gcc_assert (!DECL_RESULT_THUNK_P (function) || this_adjusting);
93 /* Scale the VIRTUAL_OFFSET to be in terms of bytes. */
94 if (this_adjusting && virtual_offset)
96 = size_binop (MULT_EXPR,
99 TYPE_SIZE_UNIT (vtable_entry_type)));
101 d = tree_low_cst (fixed_offset, 0);
103 /* See if we already have the thunk in question. For this_adjusting
104 thunks VIRTUAL_OFFSET will be an INTEGER_CST, for covariant thunks it
106 for (thunk = DECL_THUNKS (function); thunk; thunk = DECL_CHAIN (thunk))
107 if (DECL_THIS_THUNK_P (thunk) == this_adjusting
108 && THUNK_FIXED_OFFSET (thunk) == d
109 && !virtual_offset == !THUNK_VIRTUAL_OFFSET (thunk)
112 ? tree_int_cst_equal (THUNK_VIRTUAL_OFFSET (thunk),
114 : THUNK_VIRTUAL_OFFSET (thunk) == virtual_offset)))
117 /* All thunks must be created before FUNCTION is actually emitted;
118 the ABI requires that all thunks be emitted together with the
119 function to which they transfer control. */
120 gcc_assert (!TREE_ASM_WRITTEN (function));
121 /* Likewise, we can only be adding thunks to a function declared in
122 the class currently being laid out. */
123 gcc_assert (TYPE_SIZE (DECL_CONTEXT (function))
124 && TYPE_BEING_DEFINED (DECL_CONTEXT (function)));
126 thunk = build_decl (DECL_SOURCE_LOCATION (function),
127 FUNCTION_DECL, NULL_TREE, TREE_TYPE (function));
128 DECL_LANG_SPECIFIC (thunk) = DECL_LANG_SPECIFIC (function);
129 cxx_dup_lang_specific_decl (thunk);
130 DECL_THUNKS (thunk) = NULL_TREE;
132 DECL_CONTEXT (thunk) = DECL_CONTEXT (function);
133 TREE_READONLY (thunk) = TREE_READONLY (function);
134 TREE_THIS_VOLATILE (thunk) = TREE_THIS_VOLATILE (function);
135 TREE_PUBLIC (thunk) = TREE_PUBLIC (function);
136 SET_DECL_THUNK_P (thunk, this_adjusting);
137 THUNK_TARGET (thunk) = function;
138 THUNK_FIXED_OFFSET (thunk) = d;
139 THUNK_VIRTUAL_OFFSET (thunk) = virtual_offset;
140 THUNK_ALIAS (thunk) = NULL_TREE;
142 /* The thunk itself is not a constructor or destructor, even if
143 the thing it is thunking to is. */
144 DECL_INTERFACE_KNOWN (thunk) = 1;
145 DECL_NOT_REALLY_EXTERN (thunk) = 1;
146 DECL_SAVED_FUNCTION_DATA (thunk) = NULL;
147 DECL_DESTRUCTOR_P (thunk) = 0;
148 DECL_CONSTRUCTOR_P (thunk) = 0;
149 DECL_EXTERNAL (thunk) = 1;
150 DECL_ARTIFICIAL (thunk) = 1;
151 /* The THUNK is not a pending inline, even if the FUNCTION is. */
152 DECL_PENDING_INLINE_P (thunk) = 0;
153 DECL_DECLARED_INLINE_P (thunk) = 0;
154 /* Nor is it a template instantiation. */
155 DECL_USE_TEMPLATE (thunk) = 0;
156 DECL_TEMPLATE_INFO (thunk) = NULL;
158 /* Add it to the list of thunks associated with FUNCTION. */
159 DECL_CHAIN (thunk) = DECL_THUNKS (function);
160 DECL_THUNKS (function) = thunk;
165 /* Finish THUNK, a thunk decl. */
168 finish_thunk (tree thunk)
171 tree fixed_offset = ssize_int (THUNK_FIXED_OFFSET (thunk));
172 tree virtual_offset = THUNK_VIRTUAL_OFFSET (thunk);
174 gcc_assert (!DECL_NAME (thunk) && DECL_THUNK_P (thunk));
175 if (virtual_offset && DECL_RESULT_THUNK_P (thunk))
176 virtual_offset = BINFO_VPTR_FIELD (virtual_offset);
177 function = THUNK_TARGET (thunk);
178 name = mangle_thunk (function, DECL_THIS_THUNK_P (thunk),
179 fixed_offset, virtual_offset);
181 /* We can end up with declarations of (logically) different
182 covariant thunks, that do identical adjustments. The two thunks
183 will be adjusting between within different hierarchies, which
184 happen to have the same layout. We must nullify one of them to
185 refer to the other. */
186 if (DECL_RESULT_THUNK_P (thunk))
190 for (cov_probe = DECL_THUNKS (function);
191 cov_probe; cov_probe = DECL_CHAIN (cov_probe))
192 if (DECL_NAME (cov_probe) == name)
194 gcc_assert (!DECL_THUNKS (thunk));
195 THUNK_ALIAS (thunk) = (THUNK_ALIAS (cov_probe)
196 ? THUNK_ALIAS (cov_probe) : cov_probe);
201 DECL_NAME (thunk) = name;
202 SET_DECL_ASSEMBLER_NAME (thunk, name);
205 static GTY (()) int thunk_labelno;
207 /* Create a static alias to target. */
210 make_alias_for (tree target, tree newid)
212 tree alias = build_decl (DECL_SOURCE_LOCATION (target),
213 TREE_CODE (target), newid, TREE_TYPE (target));
214 DECL_LANG_SPECIFIC (alias) = DECL_LANG_SPECIFIC (target);
215 cxx_dup_lang_specific_decl (alias);
216 DECL_CONTEXT (alias) = NULL;
217 TREE_READONLY (alias) = TREE_READONLY (target);
218 TREE_THIS_VOLATILE (alias) = TREE_THIS_VOLATILE (target);
219 TREE_PUBLIC (alias) = 0;
220 DECL_INTERFACE_KNOWN (alias) = 1;
221 if (DECL_LANG_SPECIFIC (alias))
223 DECL_NOT_REALLY_EXTERN (alias) = 1;
224 DECL_USE_TEMPLATE (alias) = 0;
225 DECL_TEMPLATE_INFO (alias) = NULL;
227 DECL_EXTERNAL (alias) = 0;
228 DECL_ARTIFICIAL (alias) = 1;
229 DECL_TEMPLATE_INSTANTIATED (alias) = 0;
230 if (TREE_CODE (alias) == FUNCTION_DECL)
232 DECL_SAVED_FUNCTION_DATA (alias) = NULL;
233 DECL_DESTRUCTOR_P (alias) = 0;
234 DECL_CONSTRUCTOR_P (alias) = 0;
235 DECL_PENDING_INLINE_P (alias) = 0;
236 DECL_DECLARED_INLINE_P (alias) = 0;
237 DECL_INITIAL (alias) = error_mark_node;
238 DECL_ARGUMENTS (alias) = copy_list (DECL_ARGUMENTS (target));
241 TREE_STATIC (alias) = 1;
242 TREE_ADDRESSABLE (alias) = 1;
243 TREE_USED (alias) = 1;
244 SET_DECL_ASSEMBLER_NAME (alias, DECL_NAME (alias));
245 TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (alias)) = 1;
250 make_alias_for_thunk (tree function)
255 targetm.asm_out.generate_internal_label (buf, "LTHUNK", thunk_labelno);
258 alias = make_alias_for (function, get_identifier (buf));
260 if (!flag_syntax_only)
262 struct cgraph_node *aliasn = cgraph_same_body_alias (cgraph_node (function),
264 DECL_ASSEMBLER_NAME (function);
265 gcc_assert (aliasn != NULL);
271 /* Emit the definition of a C++ multiple inheritance or covariant
272 return vtable thunk. If EMIT_P is nonzero, the thunk is emitted
276 use_thunk (tree thunk_fndecl, bool emit_p)
278 tree a, t, function, alias;
280 HOST_WIDE_INT fixed_offset, virtual_value;
281 bool this_adjusting = DECL_THIS_THUNK_P (thunk_fndecl);
283 /* We should have called finish_thunk to give it a name. */
284 gcc_assert (DECL_NAME (thunk_fndecl));
286 /* We should never be using an alias, always refer to the
288 gcc_assert (!THUNK_ALIAS (thunk_fndecl));
290 if (TREE_ASM_WRITTEN (thunk_fndecl))
293 function = THUNK_TARGET (thunk_fndecl);
294 if (DECL_RESULT (thunk_fndecl))
295 /* We already turned this thunk into an ordinary function.
296 There's no need to process this thunk again. */
299 if (DECL_THUNK_P (function))
300 /* The target is itself a thunk, process it now. */
301 use_thunk (function, emit_p);
303 /* Thunks are always addressable; they only appear in vtables. */
304 TREE_ADDRESSABLE (thunk_fndecl) = 1;
306 /* Figure out what function is being thunked to. It's referenced in
307 this translation unit. */
308 TREE_ADDRESSABLE (function) = 1;
309 mark_used (function);
313 if (TARGET_USE_LOCAL_THUNK_ALIAS_P (function))
314 alias = make_alias_for_thunk (function);
318 fixed_offset = THUNK_FIXED_OFFSET (thunk_fndecl);
319 virtual_offset = THUNK_VIRTUAL_OFFSET (thunk_fndecl);
324 virtual_offset = BINFO_VPTR_FIELD (virtual_offset);
325 virtual_value = tree_low_cst (virtual_offset, /*pos=*/0);
326 gcc_assert (virtual_value);
331 /* And, if we need to emit the thunk, it's used. */
332 mark_used (thunk_fndecl);
333 /* This thunk is actually defined. */
334 DECL_EXTERNAL (thunk_fndecl) = 0;
335 /* The linkage of the function may have changed. FIXME in linkage
337 TREE_PUBLIC (thunk_fndecl) = TREE_PUBLIC (function);
338 DECL_VISIBILITY (thunk_fndecl) = DECL_VISIBILITY (function);
339 DECL_VISIBILITY_SPECIFIED (thunk_fndecl)
340 = DECL_VISIBILITY_SPECIFIED (function);
341 if (DECL_ONE_ONLY (function) || DECL_WEAK (function))
342 make_decl_one_only (thunk_fndecl, cxx_comdat_group (thunk_fndecl));
344 if (flag_syntax_only)
346 TREE_ASM_WRITTEN (thunk_fndecl) = 1;
350 push_to_top_level ();
352 if (TARGET_USE_LOCAL_THUNK_ALIAS_P (function)
353 && targetm.have_named_sections)
355 resolve_unique_section (function, 0, flag_function_sections);
357 if (DECL_SECTION_NAME (function) != NULL && DECL_ONE_ONLY (function))
359 resolve_unique_section (thunk_fndecl, 0, flag_function_sections);
361 /* Output the thunk into the same section as function. */
362 DECL_SECTION_NAME (thunk_fndecl) = DECL_SECTION_NAME (function);
366 /* Set up cloned argument trees for the thunk. */
368 for (a = DECL_ARGUMENTS (function); a; a = DECL_CHAIN (a))
370 tree x = copy_node (a);
372 DECL_CONTEXT (x) = thunk_fndecl;
373 SET_DECL_RTL (x, NULL);
374 DECL_HAS_VALUE_EXPR_P (x) = 0;
375 TREE_ADDRESSABLE (x) = 0;
379 DECL_ARGUMENTS (thunk_fndecl) = a;
380 TREE_ASM_WRITTEN (thunk_fndecl) = 1;
381 cgraph_add_thunk (cgraph_node (function), thunk_fndecl, function,
382 this_adjusting, fixed_offset, virtual_value,
383 virtual_offset, alias);
386 || !targetm.asm_out.can_output_mi_thunk (thunk_fndecl, fixed_offset,
387 virtual_value, alias))
389 /* If this is a covariant thunk, or we don't have the necessary
390 code for efficient thunks, generate a thunk function that
391 just makes a call to the real function. Unfortunately, this
392 doesn't work for varargs. */
394 if (varargs_function_p (function))
395 error ("generic thunk code fails for method %q#D which uses %<...%>",
399 pop_from_top_level ();
402 /* Code for synthesizing methods which have default semantics defined. */
404 /* True iff CTYPE has a trivial SFK. */
407 type_has_trivial_fn (tree ctype, special_function_kind sfk)
411 case sfk_constructor:
412 return !TYPE_HAS_COMPLEX_DFLT (ctype);
413 case sfk_copy_constructor:
414 return !TYPE_HAS_COMPLEX_COPY_CTOR (ctype);
415 case sfk_move_constructor:
416 return !TYPE_HAS_COMPLEX_MOVE_CTOR (ctype);
417 case sfk_copy_assignment:
418 return !TYPE_HAS_COMPLEX_COPY_ASSIGN (ctype);
419 case sfk_move_assignment:
420 return !TYPE_HAS_COMPLEX_MOVE_ASSIGN (ctype);
422 return !TYPE_HAS_NONTRIVIAL_DESTRUCTOR (ctype);
428 /* Note that CTYPE has a non-trivial SFK even though we previously thought
432 type_set_nontrivial_flag (tree ctype, special_function_kind sfk)
436 case sfk_constructor:
437 TYPE_HAS_COMPLEX_DFLT (ctype) = true;
439 case sfk_copy_constructor:
440 TYPE_HAS_COMPLEX_COPY_CTOR (ctype) = true;
442 case sfk_move_constructor:
443 TYPE_HAS_COMPLEX_MOVE_CTOR (ctype) = true;
445 case sfk_copy_assignment:
446 TYPE_HAS_COMPLEX_COPY_ASSIGN (ctype) = true;
448 case sfk_move_assignment:
449 TYPE_HAS_COMPLEX_MOVE_ASSIGN (ctype) = true;
452 TYPE_HAS_NONTRIVIAL_DESTRUCTOR (ctype) = true;
459 /* True iff FN is a trivial defaulted member function ([cd]tor, op=). */
462 trivial_fn_p (tree fn)
464 if (!DECL_DEFAULTED_FN (fn))
467 /* If fn is a clone, get the primary variant. */
468 fn = DECL_ORIGIN (fn);
469 return type_has_trivial_fn (DECL_CONTEXT (fn), special_function_p (fn));
472 /* Generate code for default X(X&) or X(X&&) constructor. */
475 do_build_copy_constructor (tree fndecl)
477 tree parm = FUNCTION_FIRST_USER_PARM (fndecl);
478 bool move_p = DECL_MOVE_CONSTRUCTOR_P (fndecl);
479 bool trivial = trivial_fn_p (fndecl);
481 parm = convert_from_reference (parm);
484 && is_empty_class (current_class_type))
485 /* Don't copy the padding byte; it might not have been allocated
486 if *this is a base subobject. */;
489 tree t = build2 (INIT_EXPR, void_type_node, current_class_ref, parm);
490 finish_expr_stmt (t);
494 tree fields = TYPE_FIELDS (current_class_type);
495 tree member_init_list = NULL_TREE;
496 int cvquals = cp_type_quals (TREE_TYPE (parm));
498 tree binfo, base_binfo;
500 VEC(tree,gc) *vbases;
502 /* Initialize all the base-classes with the parameter converted
503 to their type so that we get their copy constructor and not
504 another constructor that takes current_class_type. We must
505 deal with the binfo's directly as a direct base might be
506 inaccessible due to ambiguity. */
507 for (vbases = CLASSTYPE_VBASECLASSES (current_class_type), i = 0;
508 VEC_iterate (tree, vbases, i, binfo); i++)
510 init = build_base_path (PLUS_EXPR, parm, binfo, 1);
515 build_tree_list (NULL_TREE, init),
519 for (binfo = TYPE_BINFO (current_class_type), i = 0;
520 BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
522 if (BINFO_VIRTUAL_P (base_binfo))
525 init = build_base_path (PLUS_EXPR, parm, base_binfo, 1);
529 = tree_cons (base_binfo,
530 build_tree_list (NULL_TREE, init),
534 for (; fields; fields = DECL_CHAIN (fields))
539 if (TREE_CODE (field) != FIELD_DECL)
542 expr_type = TREE_TYPE (field);
543 if (DECL_NAME (field))
545 if (VFIELD_NAME_P (DECL_NAME (field)))
548 else if (ANON_AGGR_TYPE_P (expr_type) && TYPE_FIELDS (expr_type))
549 /* Just use the field; anonymous types can't have
550 nontrivial copy ctors or assignment ops or this
551 function would be deleted. */;
555 /* Compute the type of "init->field". If the copy-constructor
556 parameter is, for example, "const S&", and the type of
557 the field is "T", then the type will usually be "const
558 T". (There are no cv-qualified variants of reference
560 if (TREE_CODE (expr_type) != REFERENCE_TYPE)
564 if (DECL_MUTABLE_P (field))
565 quals &= ~TYPE_QUAL_CONST;
566 quals |= cp_type_quals (expr_type);
567 expr_type = cp_build_qualified_type (expr_type, quals);
570 init = build3 (COMPONENT_REF, expr_type, parm, field, NULL_TREE);
571 if (move_p && TREE_CODE (expr_type) != REFERENCE_TYPE)
573 init = build_tree_list (NULL_TREE, init);
575 member_init_list = tree_cons (field, init, member_init_list);
577 finish_mem_initializers (member_init_list);
582 do_build_copy_assign (tree fndecl)
584 tree parm = DECL_CHAIN (DECL_ARGUMENTS (fndecl));
586 bool move_p = move_fn_p (fndecl);
587 bool trivial = trivial_fn_p (fndecl);
588 int flags = LOOKUP_NORMAL | LOOKUP_NONVIRTUAL | LOOKUP_DEFAULTED;
590 compound_stmt = begin_compound_stmt (0);
591 parm = convert_from_reference (parm);
594 && is_empty_class (current_class_type))
595 /* Don't copy the padding byte; it might not have been allocated
596 if *this is a base subobject. */;
599 tree t = build2 (MODIFY_EXPR, void_type_node, current_class_ref, parm);
600 finish_expr_stmt (t);
605 int cvquals = cp_type_quals (TREE_TYPE (parm));
607 tree binfo, base_binfo;
609 /* Assign to each of the direct base classes. */
610 for (binfo = TYPE_BINFO (current_class_type), i = 0;
611 BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
614 VEC(tree,gc) *parmvec;
616 /* We must convert PARM directly to the base class
617 explicitly since the base class may be ambiguous. */
618 converted_parm = build_base_path (PLUS_EXPR, parm, base_binfo, 1);
620 converted_parm = move (converted_parm);
621 /* Call the base class assignment operator. */
622 parmvec = make_tree_vector_single (converted_parm);
624 (build_special_member_call (current_class_ref,
625 ansi_assopname (NOP_EXPR),
629 tf_warning_or_error));
630 release_tree_vector (parmvec);
633 /* Assign to each of the non-static data members. */
634 for (fields = TYPE_FIELDS (current_class_type);
636 fields = DECL_CHAIN (fields))
638 tree comp = current_class_ref;
644 if (TREE_CODE (field) != FIELD_DECL || DECL_ARTIFICIAL (field))
647 expr_type = TREE_TYPE (field);
649 if (CP_TYPE_CONST_P (expr_type))
651 error ("non-static const member %q#D, can%'t use default "
652 "assignment operator", field);
655 else if (TREE_CODE (expr_type) == REFERENCE_TYPE)
657 error ("non-static reference member %q#D, can%'t use "
658 "default assignment operator", field);
662 if (DECL_NAME (field))
664 if (VFIELD_NAME_P (DECL_NAME (field)))
667 else if (ANON_AGGR_TYPE_P (expr_type)
668 && TYPE_FIELDS (expr_type) != NULL_TREE)
669 /* Just use the field; anonymous types can't have
670 nontrivial copy ctors or assignment ops or this
671 function would be deleted. */;
675 comp = build3 (COMPONENT_REF, expr_type, comp, field, NULL_TREE);
677 /* Compute the type of init->field */
679 if (DECL_MUTABLE_P (field))
680 quals &= ~TYPE_QUAL_CONST;
681 expr_type = cp_build_qualified_type (expr_type, quals);
683 init = build3 (COMPONENT_REF, expr_type, init, field, NULL_TREE);
684 if (move_p && TREE_CODE (expr_type) != REFERENCE_TYPE)
687 if (DECL_NAME (field))
688 init = cp_build_modify_expr (comp, NOP_EXPR, init,
689 tf_warning_or_error);
691 init = build2 (MODIFY_EXPR, TREE_TYPE (comp), comp, init);
692 finish_expr_stmt (init);
695 finish_return_stmt (current_class_ref);
696 finish_compound_stmt (compound_stmt);
699 /* Synthesize FNDECL, a non-static member function. */
702 synthesize_method (tree fndecl)
704 bool nested = (current_function_decl != NULL_TREE);
705 tree context = decl_function_context (fndecl);
706 bool need_body = true;
708 location_t save_input_location = input_location;
709 int error_count = errorcount;
710 int warning_count = warningcount;
712 /* Reset the source location, we might have been previously
713 deferred, and thus have saved where we were first needed. */
714 DECL_SOURCE_LOCATION (fndecl)
715 = DECL_SOURCE_LOCATION (TYPE_NAME (DECL_CONTEXT (fndecl)));
717 /* If we've been asked to synthesize a clone, just synthesize the
718 cloned function instead. Doing so will automatically fill in the
719 body for the clone. */
720 if (DECL_CLONED_FUNCTION_P (fndecl))
721 fndecl = DECL_CLONED_FUNCTION (fndecl);
723 /* We may be in the middle of deferred access check. Disable
725 push_deferring_access_checks (dk_no_deferred);
728 push_to_top_level ();
730 push_function_context ();
732 input_location = DECL_SOURCE_LOCATION (fndecl);
734 start_preparsed_function (fndecl, NULL_TREE, SF_DEFAULT | SF_PRE_PARSED);
735 stmt = begin_function_body ();
737 if (DECL_OVERLOADED_OPERATOR_P (fndecl) == NOP_EXPR)
739 do_build_copy_assign (fndecl);
742 else if (DECL_CONSTRUCTOR_P (fndecl))
744 tree arg_chain = FUNCTION_FIRST_USER_PARMTYPE (fndecl);
745 if (arg_chain != void_list_node)
746 do_build_copy_constructor (fndecl);
748 finish_mem_initializers (NULL_TREE);
751 /* If we haven't yet generated the body of the function, just
752 generate an empty compound statement. */
756 compound_stmt = begin_compound_stmt (BCS_FN_BODY);
757 finish_compound_stmt (compound_stmt);
760 finish_function_body (stmt);
761 expand_or_defer_fn (finish_function (0));
763 input_location = save_input_location;
766 pop_from_top_level ();
768 pop_function_context ();
770 pop_deferring_access_checks ();
772 if (error_count != errorcount || warning_count != warningcount)
773 inform (input_location, "synthesized method %qD first required here ",
777 /* Build a reference to type TYPE with cv-quals QUALS, which is an
778 rvalue if RVALUE is true. */
781 build_stub_type (tree type, int quals, bool rvalue)
783 tree argtype = cp_build_qualified_type (type, quals);
784 return cp_build_reference_type (argtype, rvalue);
787 /* Build a dummy glvalue from dereferencing a dummy reference of type
791 build_stub_object (tree reftype)
793 tree stub = build1 (NOP_EXPR, reftype, integer_one_node);
794 return convert_from_reference (stub);
797 /* Determine which function will be called when looking up NAME in TYPE,
798 called with a single ARGTYPE argument, or no argument if ARGTYPE is
799 null. FLAGS and COMPLAIN are as for build_new_method_call.
801 Returns a FUNCTION_DECL if all is well.
802 Returns NULL_TREE if overload resolution failed.
803 Returns error_mark_node if the chosen function cannot be called. */
806 locate_fn_flags (tree type, tree name, tree argtype, int flags,
807 tsubst_flags_t complain)
809 tree ob, fn, fns, binfo, rval;
813 binfo = TYPE_BINFO (type);
817 type = BINFO_TYPE (binfo);
820 ob = build_stub_object (cp_build_reference_type (type, false));
821 args = make_tree_vector ();
824 tree arg = build_stub_object (argtype);
825 VEC_quick_push (tree, args, arg);
828 fns = lookup_fnfields (binfo, name, 0);
829 rval = build_new_method_call (ob, fns, &args, binfo, flags, &fn, complain);
831 release_tree_vector (args);
832 if (fn && rval == error_mark_node)
838 /* Locate the dtor of TYPE. */
843 tree fn = locate_fn_flags (type, complete_dtor_identifier, NULL_TREE,
844 LOOKUP_NORMAL, tf_warning_or_error);
845 if (fn == error_mark_node)
850 /* Locate the default ctor of TYPE. */
853 locate_ctor (tree type)
857 push_deferring_access_checks (dk_no_check);
858 fn = locate_fn_flags (type, complete_ctor_identifier, NULL_TREE,
859 LOOKUP_SPECULATIVE, tf_none);
860 pop_deferring_access_checks ();
861 if (fn == error_mark_node)
866 /* Likewise, but give any appropriate errors. */
869 get_default_ctor (tree type)
871 tree fn = locate_fn_flags (type, complete_ctor_identifier, NULL_TREE,
872 LOOKUP_NORMAL, tf_warning_or_error);
873 if (fn == error_mark_node)
878 /* Locate the copy ctor of TYPE. */
881 get_copy_ctor (tree type)
883 int quals = (TYPE_HAS_CONST_COPY_CTOR (type)
884 ? TYPE_QUAL_CONST : TYPE_UNQUALIFIED);
885 tree argtype = build_stub_type (type, quals, false);
886 tree fn = locate_fn_flags (type, complete_ctor_identifier, argtype,
887 LOOKUP_NORMAL, tf_warning_or_error);
888 if (fn == error_mark_node)
893 /* Locate the copy assignment operator of TYPE. */
896 get_copy_assign (tree type)
898 int quals = (TYPE_HAS_CONST_COPY_ASSIGN (type)
899 ? TYPE_QUAL_CONST : TYPE_UNQUALIFIED);
900 tree argtype = build_stub_type (type, quals, false);
901 tree fn = locate_fn_flags (type, ansi_assopname (NOP_EXPR), argtype,
902 LOOKUP_NORMAL, tf_warning_or_error);
903 if (fn == error_mark_node)
908 /* Subroutine of synthesized_method_walk. Update SPEC_P, TRIVIAL_P and
909 DELETED_P or give an error message MSG with argument ARG. */
912 process_subob_fn (tree fn, bool move_p, tree *spec_p, bool *trivial_p,
913 bool *deleted_p, bool *constexpr_p,
914 const char *msg, tree arg)
916 if (!fn || fn == error_mark_node)
921 tree raises = TYPE_RAISES_EXCEPTIONS (TREE_TYPE (fn));
922 *spec_p = merge_exception_specifiers (*spec_p, raises);
925 if (!trivial_fn_p (fn))
929 if (TREE_CODE (arg) == FIELD_DECL
930 && TREE_CODE (DECL_CONTEXT (arg)) == UNION_TYPE)
935 error ("union member %q+D with non-trivial %qD", arg, fn);
939 if (move_p && !move_fn_p (fn) && !trivial_fn_p (fn))
948 /* If this is a specialization of a constexpr template, we need to
949 force the instantiation now so that we know whether or not it's
951 if (DECL_DECLARED_CONSTEXPR_P (fn) && DECL_TEMPLATE_INSTANTIATION (fn)
952 && !DECL_TEMPLATE_INSTANTIATED (fn))
953 instantiate_decl (fn, /*defer_ok*/false, /*expl_class*/false);
954 if (!DECL_DECLARED_CONSTEXPR_P (fn))
955 *constexpr_p = false;
965 /* Subroutine of synthesized_method_walk to allow recursion into anonymous
969 walk_field_subobs (tree fields, tree fnname, special_function_kind sfk,
970 int quals, bool copy_arg_p, bool move_p,
971 bool assign_p, tree *spec_p, bool *trivial_p,
972 bool *deleted_p, bool *constexpr_p, const char *msg,
973 int flags, tsubst_flags_t complain)
976 for (field = fields; field; field = DECL_CHAIN (field))
978 tree mem_type, argtype, rval;
980 if (TREE_CODE (field) != FIELD_DECL
981 || DECL_ARTIFICIAL (field))
984 mem_type = strip_array_types (TREE_TYPE (field));
988 if (CP_TYPE_CONST_P (mem_type) && !CLASS_TYPE_P (mem_type))
991 error ("non-static const member %q#D, can%'t use default "
992 "assignment operator", field);
994 else if (TREE_CODE (mem_type) == REFERENCE_TYPE)
997 error ("non-static reference member %q#D, can%'t use "
998 "default assignment operator", field);
1003 if (bad && deleted_p)
1006 else if (sfk == sfk_constructor)
1009 if (CP_TYPE_CONST_P (mem_type)
1010 && (!CLASS_TYPE_P (mem_type)
1011 || !type_has_user_provided_default_constructor (mem_type)))
1014 error ("uninitialized non-static const member %q#D",
1017 else if (TREE_CODE (mem_type) == REFERENCE_TYPE)
1020 error ("uninitialized non-static reference member %q#D",
1026 if (bad && deleted_p)
1029 /* For an implicitly-defined default constructor to be constexpr,
1030 every member must have a user-provided default constructor. */
1031 /* FIXME will need adjustment for non-static data member
1033 if (constexpr_p && !CLASS_TYPE_P (mem_type))
1034 *constexpr_p = false;
1037 if (!CLASS_TYPE_P (mem_type))
1040 if (ANON_AGGR_TYPE_P (mem_type))
1042 walk_field_subobs (TYPE_FIELDS (mem_type), fnname, sfk, quals,
1043 copy_arg_p, move_p, assign_p, spec_p, trivial_p,
1044 deleted_p, constexpr_p, msg, flags, complain);
1050 int mem_quals = cp_type_quals (mem_type) | quals;
1051 if (DECL_MUTABLE_P (field))
1052 mem_quals &= ~TYPE_QUAL_CONST;
1053 argtype = build_stub_type (mem_type, mem_quals, move_p);
1056 argtype = NULL_TREE;
1058 rval = locate_fn_flags (mem_type, fnname, argtype, flags, complain);
1060 process_subob_fn (rval, move_p, spec_p, trivial_p, deleted_p,
1061 constexpr_p, msg, field);
1065 /* The caller wants to generate an implicit declaration of SFK for CTYPE
1066 which is const if relevant and CONST_P is set. If spec_p, trivial_p and
1067 deleted_p are non-null, set their referent appropriately. If diag is
1068 true, we're being called from maybe_explain_implicit_delete to give
1072 synthesized_method_walk (tree ctype, special_function_kind sfk, bool const_p,
1073 tree *spec_p, bool *trivial_p, bool *deleted_p,
1074 bool *constexpr_p, bool diag)
1076 tree binfo, base_binfo, scope, fnname, rval, argtype;
1077 bool move_p, copy_arg_p, assign_p, expected_trivial, check_vdtor;
1078 VEC(tree,gc) *vbases;
1079 int i, quals, flags;
1080 tsubst_flags_t complain;
1085 *spec_p = (cxx_dialect >= cxx0x ? noexcept_true_spec : empty_except_spec);
1089 /* "The closure type associated with a lambda-expression has a deleted
1090 default constructor and a deleted copy assignment operator."
1091 This is diagnosed in maybe_explain_implicit_delete. */
1092 if (LAMBDA_TYPE_P (ctype)
1093 && (sfk == sfk_constructor
1094 || sfk == sfk_copy_assignment))
1105 check_vdtor = false;
1108 case sfk_move_assignment:
1109 case sfk_copy_assignment:
1111 fnname = ansi_assopname (NOP_EXPR);
1114 case sfk_destructor:
1116 /* The synthesized method will call base dtors, but check complete
1117 here to avoid having to deal with VTT. */
1118 fnname = complete_dtor_identifier;
1121 case sfk_constructor:
1122 case sfk_move_constructor:
1123 case sfk_copy_constructor:
1125 fnname = complete_ctor_identifier;
1132 /* If that user-written default constructor would satisfy the
1133 requirements of a constexpr constructor (7.1.5), the
1134 implicitly-defined default constructor is constexpr. */
1136 *constexpr_p = ctor_p;
1141 case sfk_constructor:
1142 case sfk_destructor:
1146 case sfk_move_constructor:
1147 case sfk_move_assignment:
1149 case sfk_copy_constructor:
1150 case sfk_copy_assignment:
1158 expected_trivial = type_has_trivial_fn (ctype, sfk);
1160 *trivial_p = expected_trivial;
1162 /* The TYPE_HAS_COMPLEX_* flags tell us about constraints from base
1163 class versions and other properties of the type. But a subobject
1164 class can be trivially copyable and yet have overload resolution
1165 choose a template constructor for initialization, depending on
1166 rvalueness and cv-quals. So we can't exit early for copy/move
1167 methods in C++0x. The same considerations apply in C++98/03, but
1168 there the definition of triviality does not consider overload
1169 resolution, so a constructor can be trivial even if it would otherwise
1170 call a non-trivial constructor. */
1171 if (expected_trivial
1172 && (!copy_arg_p || cxx_dialect < cxx0x))
1174 if (constexpr_p && sfk == sfk_constructor)
1175 *constexpr_p = synthesized_default_constructor_is_constexpr (ctype);
1179 ++cp_unevaluated_operand;
1180 ++c_inhibit_evaluation_warnings;
1182 scope = push_scope (ctype);
1186 flags = LOOKUP_NORMAL|LOOKUP_SPECULATIVE|LOOKUP_DEFAULTED;
1187 complain = tf_warning_or_error;
1191 flags = LOOKUP_PROTECT|LOOKUP_SPECULATIVE|LOOKUP_DEFAULTED;
1196 quals = TYPE_QUAL_CONST;
1198 quals = TYPE_UNQUALIFIED;
1199 argtype = NULL_TREE;
1204 msg = ("base %qT does not have a move assignment operator or trivial "
1205 "copy assignment operator");
1207 msg = ("base %qT does not have a move constructor or trivial "
1208 "copy constructor");
1210 for (binfo = TYPE_BINFO (ctype), i = 0;
1211 BINFO_BASE_ITERATE (binfo, i, base_binfo); ++i)
1213 tree basetype = BINFO_TYPE (base_binfo);
1215 argtype = build_stub_type (basetype, quals, move_p);
1216 rval = locate_fn_flags (base_binfo, fnname, argtype, flags, complain);
1218 process_subob_fn (rval, move_p, spec_p, trivial_p, deleted_p,
1219 constexpr_p, msg, basetype);
1220 if (ctor_p && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (basetype))
1222 /* In a constructor we also need to check the subobject
1223 destructors for cleanup of partially constructed objects. */
1224 rval = locate_fn_flags (base_binfo, complete_dtor_identifier,
1225 NULL_TREE, flags, complain);
1226 /* Note that we don't pass down trivial_p; the subobject
1227 destructors don't affect triviality of the constructor. */
1228 process_subob_fn (rval, false, spec_p, NULL,
1229 deleted_p, NULL, NULL,
1233 if (check_vdtor && type_has_virtual_destructor (basetype))
1235 rval = locate_fn_flags (ctype, ansi_opname (DELETE_EXPR),
1236 ptr_type_node, flags, complain);
1237 /* Unlike for base ctor/op=/dtor, for operator delete it's fine
1238 to have a null rval (no class-specific op delete). */
1239 if (rval && rval == error_mark_node && deleted_p)
1241 check_vdtor = false;
1245 vbases = CLASSTYPE_VBASECLASSES (ctype);
1246 if (vbases && assign_p && move_p)
1248 /* Should the spec be changed to allow vbases that only occur once? */
1250 error ("%qT has virtual bases, default move assignment operator "
1251 "cannot be generated", ctype);
1258 msg = ("virtual base %qT does not have a move constructor "
1259 "or trivial copy constructor");
1260 if (vbases && constexpr_p)
1261 *constexpr_p = false;
1262 FOR_EACH_VEC_ELT (tree, vbases, i, base_binfo)
1264 tree basetype = BINFO_TYPE (base_binfo);
1266 argtype = build_stub_type (basetype, quals, move_p);
1267 rval = locate_fn_flags (base_binfo, fnname, argtype, flags, complain);
1269 process_subob_fn (rval, move_p, spec_p, trivial_p, deleted_p,
1270 constexpr_p, msg, basetype);
1271 if (ctor_p && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (basetype))
1273 rval = locate_fn_flags (base_binfo, complete_dtor_identifier,
1274 NULL_TREE, flags, complain);
1275 process_subob_fn (rval, false, spec_p, NULL,
1276 deleted_p, NULL, NULL,
1282 /* Leave msg null. */;
1284 msg = ("non-static data member %qD does not have a move "
1285 "assignment operator or trivial copy assignment operator");
1287 msg = ("non-static data member %qD does not have a move "
1288 "constructor or trivial copy constructor");
1289 walk_field_subobs (TYPE_FIELDS (ctype), fnname, sfk, quals,
1290 copy_arg_p, move_p, assign_p, spec_p, trivial_p,
1291 deleted_p, constexpr_p, msg, flags, complain);
1293 walk_field_subobs (TYPE_FIELDS (ctype), complete_dtor_identifier,
1294 sfk_destructor, TYPE_UNQUALIFIED, false,
1295 false, false, spec_p, NULL,
1297 NULL, flags, complain);
1301 --cp_unevaluated_operand;
1302 --c_inhibit_evaluation_warnings;
1305 /* DECL is a deleted function. If it's implicitly deleted, explain why and
1306 return true; else return false. */
1309 maybe_explain_implicit_delete (tree decl)
1311 /* If decl is a clone, get the primary variant. */
1312 decl = DECL_ORIGIN (decl);
1313 gcc_assert (DECL_DELETED_FN (decl));
1314 if (DECL_DEFAULTED_FN (decl))
1316 /* Not marked GTY; it doesn't need to be GC'd or written to PCH. */
1317 static htab_t explained_htab;
1320 special_function_kind sfk;
1325 if (!explained_htab)
1326 explained_htab = htab_create (37, htab_hash_pointer,
1327 htab_eq_pointer, NULL);
1328 slot = htab_find_slot (explained_htab, decl, INSERT);
1333 sfk = special_function_p (decl);
1334 ctype = DECL_CONTEXT (decl);
1335 loc = input_location;
1336 input_location = DECL_SOURCE_LOCATION (decl);
1339 if (LAMBDA_TYPE_P (ctype))
1342 if (sfk == sfk_constructor)
1343 error ("a lambda closure type has a deleted default constructor");
1344 else if (sfk == sfk_copy_assignment)
1345 error ("a lambda closure type has a deleted copy assignment operator");
1351 tree parm_type = TREE_VALUE (FUNCTION_FIRST_USER_PARMTYPE (decl));
1352 bool const_p = CP_TYPE_CONST_P (non_reference (parm_type));
1353 tree scope = push_scope (ctype);
1354 error ("%qD is implicitly deleted because the default "
1355 "definition would be ill-formed:", decl);
1357 synthesized_method_walk (ctype, sfk, const_p,
1358 NULL, NULL, NULL, NULL, true);
1361 input_location = loc;
1367 /* Implicitly declare the special function indicated by KIND, as a
1368 member of TYPE. For copy constructors and assignment operators,
1369 CONST_P indicates whether these functions should take a const
1370 reference argument or a non-const reference. Returns the
1371 FUNCTION_DECL for the implicitly declared function. */
1374 implicitly_declare_fn (special_function_kind kind, tree type, bool const_p)
1377 tree parameter_types = void_list_node;
1380 tree raises = empty_except_spec;
1381 tree rhs_parm_type = NULL_TREE;
1384 HOST_WIDE_INT saved_processing_template_decl;
1389 /* Because we create declarations for implicitly declared functions
1390 lazily, we may be creating the declaration for a member of TYPE
1391 while in some completely different context. However, TYPE will
1392 never be a dependent class (because we never want to do lookups
1393 for implicitly defined functions in a dependent class).
1394 Furthermore, we must set PROCESSING_TEMPLATE_DECL to zero here
1395 because we only create clones for constructors and destructors
1396 when not in a template. */
1397 gcc_assert (!dependent_type_p (type));
1398 saved_processing_template_decl = processing_template_decl;
1399 processing_template_decl = 0;
1401 type = TYPE_MAIN_VARIANT (type);
1403 if (targetm.cxx.cdtor_returns_this () && !TYPE_FOR_JAVA (type))
1405 if (kind == sfk_destructor)
1406 /* See comment in check_special_function_return_type. */
1407 return_type = build_pointer_type (void_type_node);
1409 return_type = build_pointer_type (type);
1412 return_type = void_type_node;
1416 case sfk_destructor:
1418 name = constructor_name (type);
1421 case sfk_constructor:
1422 /* Default constructor. */
1423 name = constructor_name (type);
1426 case sfk_copy_constructor:
1427 case sfk_copy_assignment:
1428 case sfk_move_constructor:
1429 case sfk_move_assignment:
1432 if (kind == sfk_copy_assignment
1433 || kind == sfk_move_assignment)
1435 return_type = build_reference_type (type);
1436 name = ansi_assopname (NOP_EXPR);
1439 name = constructor_name (type);
1442 rhs_parm_type = cp_build_qualified_type (type, TYPE_QUAL_CONST);
1444 rhs_parm_type = type;
1445 move_p = (kind == sfk_move_assignment
1446 || kind == sfk_move_constructor);
1447 rhs_parm_type = cp_build_reference_type (rhs_parm_type, move_p);
1449 parameter_types = tree_cons (NULL_TREE, rhs_parm_type, parameter_types);
1456 synthesized_method_walk (type, kind, const_p, &raises, &trivial_p,
1457 &deleted_p, &constexpr_p, false);
1458 /* Don't bother marking a deleted constructor as constexpr. */
1460 constexpr_p = false;
1461 /* A trivial copy/move constructor is also a constexpr constructor. */
1462 else if (trivial_p && cxx_dialect >= cxx0x
1463 && (kind == sfk_copy_constructor
1464 || kind == sfk_move_constructor))
1465 gcc_assert (constexpr_p);
1467 if (!trivial_p && type_has_trivial_fn (type, kind))
1468 type_set_nontrivial_flag (type, kind);
1470 /* Create the function. */
1471 fn_type = build_method_type_directly (type, return_type, parameter_types);
1473 fn_type = build_exception_variant (fn_type, raises);
1474 fn = build_lang_decl (FUNCTION_DECL, name, fn_type);
1475 DECL_SOURCE_LOCATION (fn) = DECL_SOURCE_LOCATION (TYPE_NAME (type));
1476 if (kind == sfk_constructor || kind == sfk_copy_constructor
1477 || kind == sfk_move_constructor)
1478 DECL_CONSTRUCTOR_P (fn) = 1;
1479 else if (kind == sfk_destructor)
1480 DECL_DESTRUCTOR_P (fn) = 1;
1483 DECL_ASSIGNMENT_OPERATOR_P (fn) = 1;
1484 SET_OVERLOADED_OPERATOR_CODE (fn, NOP_EXPR);
1487 /* If pointers to member functions use the least significant bit to
1488 indicate whether a function is virtual, ensure a pointer
1489 to this function will have that bit clear. */
1490 if (TARGET_PTRMEMFUNC_VBIT_LOCATION == ptrmemfunc_vbit_in_pfn
1491 && DECL_ALIGN (fn) < 2 * BITS_PER_UNIT)
1492 DECL_ALIGN (fn) = 2 * BITS_PER_UNIT;
1494 /* Create the explicit arguments. */
1497 /* Note that this parameter is *not* marked DECL_ARTIFICIAL; we
1498 want its type to be included in the mangled function
1500 DECL_ARGUMENTS (fn) = cp_build_parm_decl (NULL_TREE, rhs_parm_type);
1501 TREE_READONLY (DECL_ARGUMENTS (fn)) = 1;
1503 /* Add the "this" parameter. */
1504 this_parm = build_this_parm (fn_type, TYPE_UNQUALIFIED);
1505 DECL_CHAIN (this_parm) = DECL_ARGUMENTS (fn);
1506 DECL_ARGUMENTS (fn) = this_parm;
1508 grokclassfn (type, fn, kind == sfk_destructor ? DTOR_FLAG : NO_SPECIAL);
1509 set_linkage_according_to_type (type, fn);
1510 rest_of_decl_compilation (fn, toplevel_bindings_p (), at_eof);
1511 DECL_IN_AGGR_P (fn) = 1;
1512 DECL_ARTIFICIAL (fn) = 1;
1513 DECL_DEFAULTED_FN (fn) = 1;
1514 if (cxx_dialect >= cxx0x)
1516 DECL_DELETED_FN (fn) = deleted_p;
1517 DECL_DECLARED_CONSTEXPR_P (fn) = constexpr_p;
1519 DECL_NOT_REALLY_EXTERN (fn) = 1;
1520 DECL_DECLARED_INLINE_P (fn) = 1;
1521 gcc_assert (!TREE_USED (fn));
1523 /* Restore PROCESSING_TEMPLATE_DECL. */
1524 processing_template_decl = saved_processing_template_decl;
1529 /* Gives any errors about defaulted functions which need to be deferred
1530 until the containing class is complete. */
1533 defaulted_late_check (tree fn)
1535 /* Complain about invalid signature for defaulted fn. */
1536 tree ctx = DECL_CONTEXT (fn);
1537 special_function_kind kind = special_function_p (fn);
1538 bool fn_const_p = (copy_fn_p (fn) == 2);
1539 tree implicit_fn = implicitly_declare_fn (kind, ctx, fn_const_p);
1541 if (!same_type_p (TREE_TYPE (TREE_TYPE (fn)),
1542 TREE_TYPE (TREE_TYPE (implicit_fn)))
1543 || !compparms (TYPE_ARG_TYPES (TREE_TYPE (fn)),
1544 TYPE_ARG_TYPES (TREE_TYPE (implicit_fn))))
1546 error ("defaulted declaration %q+D", fn);
1547 error_at (DECL_SOURCE_LOCATION (fn),
1548 "does not match expected signature %qD", implicit_fn);
1551 /* 8.4.2/2: If it is explicitly defaulted on its first declaration, it is
1552 implicitly considered to have the same exception-specification as if
1553 it had been implicitly declared. */
1554 if (DECL_DEFAULTED_IN_CLASS_P (fn))
1556 tree eh_spec = TYPE_RAISES_EXCEPTIONS (TREE_TYPE (implicit_fn));
1557 if (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (fn))
1558 && !comp_except_specs (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (fn)),
1559 eh_spec, ce_normal))
1560 error ("function %q+D defaulted on its first declaration "
1561 "with an exception-specification that differs from "
1562 "the implicit declaration %q#D", fn, implicit_fn);
1563 TREE_TYPE (fn) = build_exception_variant (TREE_TYPE (fn), eh_spec);
1564 if (DECL_DECLARED_CONSTEXPR_P (implicit_fn))
1565 /* Hmm...should we do this for out-of-class too? Should it be OK to
1566 add constexpr later like inline, rather than requiring
1567 declarations to match? */
1568 DECL_DECLARED_CONSTEXPR_P (fn) = true;
1571 if (!DECL_DECLARED_CONSTEXPR_P (implicit_fn)
1572 && DECL_DECLARED_CONSTEXPR_P (fn))
1574 if (!CLASSTYPE_TEMPLATE_INSTANTIATION (ctx))
1575 error ("%qD cannot be declared as constexpr", fn);
1576 DECL_DECLARED_CONSTEXPR_P (fn) = false;
1579 if (DECL_DELETED_FN (implicit_fn))
1580 DECL_DELETED_FN (fn) = 1;
1583 /* Returns true iff FN can be explicitly defaulted, and gives any
1584 errors if defaulting FN is ill-formed. */
1587 defaultable_fn_check (tree fn)
1589 special_function_kind kind = sfk_none;
1591 if (DECL_CONSTRUCTOR_P (fn))
1593 if (FUNCTION_FIRST_USER_PARMTYPE (fn) == void_list_node)
1594 kind = sfk_constructor;
1595 else if (copy_fn_p (fn) > 0
1596 && (TREE_CHAIN (FUNCTION_FIRST_USER_PARMTYPE (fn))
1598 kind = sfk_copy_constructor;
1599 else if (move_fn_p (fn))
1600 kind = sfk_move_constructor;
1602 else if (DECL_DESTRUCTOR_P (fn))
1603 kind = sfk_destructor;
1604 else if (DECL_ASSIGNMENT_OPERATOR_P (fn)
1605 && DECL_OVERLOADED_OPERATOR_P (fn) == NOP_EXPR)
1608 kind = sfk_copy_assignment;
1609 else if (move_fn_p (fn))
1610 kind = sfk_move_assignment;
1613 if (kind == sfk_none)
1615 error ("%qD cannot be defaulted", fn);
1620 tree t = FUNCTION_FIRST_USER_PARMTYPE (fn);
1621 for (; t && t != void_list_node; t = TREE_CHAIN (t))
1622 if (TREE_PURPOSE (t))
1624 error ("defaulted function %q+D with default argument", fn);
1627 if (TYPE_BEING_DEFINED (DECL_CONTEXT (fn)))
1628 /* Defer checking. */;
1629 else if (!processing_template_decl)
1630 defaulted_late_check (fn);
1636 /* Add an implicit declaration to TYPE for the kind of function
1637 indicated by SFK. Return the FUNCTION_DECL for the new implicit
1641 lazily_declare_fn (special_function_kind sfk, tree type)
1644 /* Whether or not the argument has a const reference type. */
1645 bool const_p = false;
1649 case sfk_constructor:
1650 CLASSTYPE_LAZY_DEFAULT_CTOR (type) = 0;
1652 case sfk_copy_constructor:
1653 const_p = TYPE_HAS_CONST_COPY_CTOR (type);
1654 CLASSTYPE_LAZY_COPY_CTOR (type) = 0;
1656 case sfk_move_constructor:
1657 CLASSTYPE_LAZY_MOVE_CTOR (type) = 0;
1659 case sfk_copy_assignment:
1660 const_p = TYPE_HAS_CONST_COPY_ASSIGN (type);
1661 CLASSTYPE_LAZY_COPY_ASSIGN (type) = 0;
1663 case sfk_move_assignment:
1664 CLASSTYPE_LAZY_MOVE_ASSIGN (type) = 0;
1666 case sfk_destructor:
1667 CLASSTYPE_LAZY_DESTRUCTOR (type) = 0;
1673 /* Declare the function. */
1674 fn = implicitly_declare_fn (sfk, type, const_p);
1676 /* For move variants, rather than declare them as deleted we just
1677 don't declare them at all. */
1678 if (DECL_DELETED_FN (fn)
1679 && (sfk == sfk_move_constructor
1680 || sfk == sfk_move_assignment))
1683 /* A destructor may be virtual. */
1684 if (sfk == sfk_destructor
1685 || sfk == sfk_move_assignment
1686 || sfk == sfk_copy_assignment)
1687 check_for_override (fn, type);
1688 /* Add it to CLASSTYPE_METHOD_VEC. */
1689 add_method (type, fn, NULL_TREE);
1690 /* Add it to TYPE_METHODS. */
1691 if (sfk == sfk_destructor
1692 && DECL_VIRTUAL_P (fn)
1693 && abi_version_at_least (2))
1694 /* The ABI requires that a virtual destructor go at the end of the
1696 TYPE_METHODS (type) = chainon (TYPE_METHODS (type), fn);
1699 /* G++ 3.2 put the implicit destructor at the *beginning* of the
1700 TYPE_METHODS list, which cause the destructor to be emitted
1701 in an incorrect location in the vtable. */
1702 if (warn_abi && sfk == sfk_destructor && DECL_VIRTUAL_P (fn))
1703 warning (OPT_Wabi, "vtable layout for class %qT may not be ABI-compliant"
1704 "and may change in a future version of GCC due to "
1705 "implicit virtual destructor",
1707 DECL_CHAIN (fn) = TYPE_METHODS (type);
1708 TYPE_METHODS (type) = fn;
1710 maybe_add_class_template_decl_list (type, fn, /*friend_p=*/0);
1711 if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (fn)
1712 || DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (fn))
1713 /* Create appropriate clones. */
1714 clone_function_decl (fn, /*update_method_vec=*/true);
1719 /* Given a FUNCTION_DECL FN and a chain LIST, skip as many elements of LIST
1720 as there are artificial parms in FN. */
1723 skip_artificial_parms_for (const_tree fn, tree list)
1725 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fn))
1726 list = TREE_CHAIN (list);
1730 if (DECL_HAS_IN_CHARGE_PARM_P (fn))
1731 list = TREE_CHAIN (list);
1732 if (DECL_HAS_VTT_PARM_P (fn))
1733 list = TREE_CHAIN (list);
1737 /* Given a FUNCTION_DECL FN and a chain LIST, return the number of
1738 artificial parms in FN. */
1741 num_artificial_parms_for (const_tree fn)
1745 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fn))
1750 if (DECL_HAS_IN_CHARGE_PARM_P (fn))
1752 if (DECL_HAS_VTT_PARM_P (fn))
1758 #include "gt-cp-method.h"