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, 2011
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 "common/common-target.h"
38 #include "tree-pass.h"
39 #include "diagnostic.h"
43 /* Various flags to control the mangling process. */
49 /* The thing we are presently mangling is part of a template type,
50 rather than a fully instantiated type. Therefore, we may see
51 complex expressions where we would normally expect to see a
52 simple integer constant. */
53 mf_maybe_uninstantiated = 1,
54 /* When mangling a numeric value, use the form `_XX_' (instead of
55 just `XX') if the value has more than one digit. */
56 mf_use_underscores_around_value = 2
59 typedef enum mangling_flags mangling_flags;
61 static void do_build_copy_assign (tree);
62 static void do_build_copy_constructor (tree);
63 static tree make_alias_for_thunk (tree);
65 /* Called once to initialize method.c. */
73 /* Return a this or result adjusting thunk to FUNCTION. THIS_ADJUSTING
74 indicates whether it is a this or result adjusting thunk.
75 FIXED_OFFSET and VIRTUAL_OFFSET indicate how to do the adjustment
76 (see thunk_adjust). VIRTUAL_OFFSET can be NULL, but FIXED_OFFSET
77 never is. VIRTUAL_OFFSET is the /index/ into the vtable for this
78 adjusting thunks, we scale it to a byte offset. For covariant
79 thunks VIRTUAL_OFFSET is the virtual binfo. You must post process
80 the returned thunk with finish_thunk. */
83 make_thunk (tree function, bool this_adjusting,
84 tree fixed_offset, tree virtual_offset)
89 gcc_assert (TREE_CODE (function) == FUNCTION_DECL);
90 /* We can have this thunks to covariant thunks, but not vice versa. */
91 gcc_assert (!DECL_THIS_THUNK_P (function));
92 gcc_assert (!DECL_RESULT_THUNK_P (function) || this_adjusting);
94 /* Scale the VIRTUAL_OFFSET to be in terms of bytes. */
95 if (this_adjusting && virtual_offset)
97 = size_binop (MULT_EXPR,
100 TYPE_SIZE_UNIT (vtable_entry_type)));
102 d = tree_low_cst (fixed_offset, 0);
104 /* See if we already have the thunk in question. For this_adjusting
105 thunks VIRTUAL_OFFSET will be an INTEGER_CST, for covariant thunks it
107 for (thunk = DECL_THUNKS (function); thunk; thunk = DECL_CHAIN (thunk))
108 if (DECL_THIS_THUNK_P (thunk) == this_adjusting
109 && THUNK_FIXED_OFFSET (thunk) == d
110 && !virtual_offset == !THUNK_VIRTUAL_OFFSET (thunk)
113 ? tree_int_cst_equal (THUNK_VIRTUAL_OFFSET (thunk),
115 : THUNK_VIRTUAL_OFFSET (thunk) == virtual_offset)))
118 /* All thunks must be created before FUNCTION is actually emitted;
119 the ABI requires that all thunks be emitted together with the
120 function to which they transfer control. */
121 gcc_assert (!TREE_ASM_WRITTEN (function));
122 /* Likewise, we can only be adding thunks to a function declared in
123 the class currently being laid out. */
124 gcc_assert (TYPE_SIZE (DECL_CONTEXT (function))
125 && TYPE_BEING_DEFINED (DECL_CONTEXT (function)));
127 thunk = build_decl (DECL_SOURCE_LOCATION (function),
128 FUNCTION_DECL, NULL_TREE, TREE_TYPE (function));
129 DECL_LANG_SPECIFIC (thunk) = DECL_LANG_SPECIFIC (function);
130 cxx_dup_lang_specific_decl (thunk);
131 DECL_THUNKS (thunk) = NULL_TREE;
133 DECL_CONTEXT (thunk) = DECL_CONTEXT (function);
134 TREE_READONLY (thunk) = TREE_READONLY (function);
135 TREE_THIS_VOLATILE (thunk) = TREE_THIS_VOLATILE (function);
136 TREE_PUBLIC (thunk) = TREE_PUBLIC (function);
137 SET_DECL_THUNK_P (thunk, this_adjusting);
138 THUNK_TARGET (thunk) = function;
139 THUNK_FIXED_OFFSET (thunk) = d;
140 THUNK_VIRTUAL_OFFSET (thunk) = virtual_offset;
141 THUNK_ALIAS (thunk) = NULL_TREE;
143 /* The thunk itself is not a constructor or destructor, even if
144 the thing it is thunking to is. */
145 DECL_INTERFACE_KNOWN (thunk) = 1;
146 DECL_NOT_REALLY_EXTERN (thunk) = 1;
147 DECL_SAVED_FUNCTION_DATA (thunk) = NULL;
148 DECL_DESTRUCTOR_P (thunk) = 0;
149 DECL_CONSTRUCTOR_P (thunk) = 0;
150 DECL_EXTERNAL (thunk) = 1;
151 DECL_ARTIFICIAL (thunk) = 1;
152 /* The THUNK is not a pending inline, even if the FUNCTION is. */
153 DECL_PENDING_INLINE_P (thunk) = 0;
154 DECL_DECLARED_INLINE_P (thunk) = 0;
155 /* Nor is it a template instantiation. */
156 DECL_USE_TEMPLATE (thunk) = 0;
157 DECL_TEMPLATE_INFO (thunk) = NULL;
159 /* Add it to the list of thunks associated with FUNCTION. */
160 DECL_CHAIN (thunk) = DECL_THUNKS (function);
161 DECL_THUNKS (function) = thunk;
166 /* Finish THUNK, a thunk decl. */
169 finish_thunk (tree thunk)
172 tree fixed_offset = ssize_int (THUNK_FIXED_OFFSET (thunk));
173 tree virtual_offset = THUNK_VIRTUAL_OFFSET (thunk);
175 gcc_assert (!DECL_NAME (thunk) && DECL_THUNK_P (thunk));
176 if (virtual_offset && DECL_RESULT_THUNK_P (thunk))
177 virtual_offset = BINFO_VPTR_FIELD (virtual_offset);
178 function = THUNK_TARGET (thunk);
179 name = mangle_thunk (function, DECL_THIS_THUNK_P (thunk),
180 fixed_offset, virtual_offset);
182 /* We can end up with declarations of (logically) different
183 covariant thunks, that do identical adjustments. The two thunks
184 will be adjusting between within different hierarchies, which
185 happen to have the same layout. We must nullify one of them to
186 refer to the other. */
187 if (DECL_RESULT_THUNK_P (thunk))
191 for (cov_probe = DECL_THUNKS (function);
192 cov_probe; cov_probe = DECL_CHAIN (cov_probe))
193 if (DECL_NAME (cov_probe) == name)
195 gcc_assert (!DECL_THUNKS (thunk));
196 THUNK_ALIAS (thunk) = (THUNK_ALIAS (cov_probe)
197 ? THUNK_ALIAS (cov_probe) : cov_probe);
202 DECL_NAME (thunk) = name;
203 SET_DECL_ASSEMBLER_NAME (thunk, name);
206 static GTY (()) int thunk_labelno;
208 /* Create a static alias to target. */
211 make_alias_for (tree target, tree newid)
213 tree alias = build_decl (DECL_SOURCE_LOCATION (target),
214 TREE_CODE (target), newid, TREE_TYPE (target));
215 DECL_LANG_SPECIFIC (alias) = DECL_LANG_SPECIFIC (target);
216 cxx_dup_lang_specific_decl (alias);
217 DECL_CONTEXT (alias) = NULL;
218 TREE_READONLY (alias) = TREE_READONLY (target);
219 TREE_THIS_VOLATILE (alias) = TREE_THIS_VOLATILE (target);
220 TREE_PUBLIC (alias) = 0;
221 DECL_INTERFACE_KNOWN (alias) = 1;
222 if (DECL_LANG_SPECIFIC (alias))
224 DECL_NOT_REALLY_EXTERN (alias) = 1;
225 DECL_USE_TEMPLATE (alias) = 0;
226 DECL_TEMPLATE_INFO (alias) = NULL;
228 DECL_EXTERNAL (alias) = 0;
229 DECL_ARTIFICIAL (alias) = 1;
230 DECL_TEMPLATE_INSTANTIATED (alias) = 0;
231 if (TREE_CODE (alias) == FUNCTION_DECL)
233 DECL_SAVED_FUNCTION_DATA (alias) = NULL;
234 DECL_DESTRUCTOR_P (alias) = 0;
235 DECL_CONSTRUCTOR_P (alias) = 0;
236 DECL_PENDING_INLINE_P (alias) = 0;
237 DECL_DECLARED_INLINE_P (alias) = 0;
238 DECL_INITIAL (alias) = error_mark_node;
239 DECL_ARGUMENTS (alias) = copy_list (DECL_ARGUMENTS (target));
242 TREE_STATIC (alias) = 1;
243 TREE_ADDRESSABLE (alias) = 1;
244 TREE_USED (alias) = 1;
245 SET_DECL_ASSEMBLER_NAME (alias, DECL_NAME (alias));
246 TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (alias)) = 1;
251 make_alias_for_thunk (tree function)
256 targetm.asm_out.generate_internal_label (buf, "LTHUNK", thunk_labelno);
259 alias = make_alias_for (function, get_identifier (buf));
261 if (!flag_syntax_only)
263 struct cgraph_node *funcn, *aliasn;
264 funcn = cgraph_get_node (function);
265 gcc_checking_assert (funcn);
266 aliasn = cgraph_same_body_alias (funcn, alias, function);
267 DECL_ASSEMBLER_NAME (function);
268 gcc_assert (aliasn != NULL);
274 /* Emit the definition of a C++ multiple inheritance or covariant
275 return vtable thunk. If EMIT_P is nonzero, the thunk is emitted
279 use_thunk (tree thunk_fndecl, bool emit_p)
281 tree a, t, function, alias;
283 HOST_WIDE_INT fixed_offset, virtual_value;
284 bool this_adjusting = DECL_THIS_THUNK_P (thunk_fndecl);
285 struct cgraph_node *funcn;
287 /* We should have called finish_thunk to give it a name. */
288 gcc_assert (DECL_NAME (thunk_fndecl));
290 /* We should never be using an alias, always refer to the
292 gcc_assert (!THUNK_ALIAS (thunk_fndecl));
294 if (TREE_ASM_WRITTEN (thunk_fndecl))
297 function = THUNK_TARGET (thunk_fndecl);
298 if (DECL_RESULT (thunk_fndecl))
299 /* We already turned this thunk into an ordinary function.
300 There's no need to process this thunk again. */
303 if (DECL_THUNK_P (function))
304 /* The target is itself a thunk, process it now. */
305 use_thunk (function, emit_p);
307 /* Thunks are always addressable; they only appear in vtables. */
308 TREE_ADDRESSABLE (thunk_fndecl) = 1;
310 /* Figure out what function is being thunked to. It's referenced in
311 this translation unit. */
312 TREE_ADDRESSABLE (function) = 1;
313 mark_used (function);
317 if (TARGET_USE_LOCAL_THUNK_ALIAS_P (function))
318 alias = make_alias_for_thunk (function);
322 fixed_offset = THUNK_FIXED_OFFSET (thunk_fndecl);
323 virtual_offset = THUNK_VIRTUAL_OFFSET (thunk_fndecl);
328 virtual_offset = BINFO_VPTR_FIELD (virtual_offset);
329 virtual_value = tree_low_cst (virtual_offset, /*pos=*/0);
330 gcc_assert (virtual_value);
335 /* And, if we need to emit the thunk, it's used. */
336 mark_used (thunk_fndecl);
337 /* This thunk is actually defined. */
338 DECL_EXTERNAL (thunk_fndecl) = 0;
339 /* The linkage of the function may have changed. FIXME in linkage
341 TREE_PUBLIC (thunk_fndecl) = TREE_PUBLIC (function);
342 DECL_VISIBILITY (thunk_fndecl) = DECL_VISIBILITY (function);
343 DECL_VISIBILITY_SPECIFIED (thunk_fndecl)
344 = DECL_VISIBILITY_SPECIFIED (function);
345 if (DECL_ONE_ONLY (function) || DECL_WEAK (function))
346 make_decl_one_only (thunk_fndecl, cxx_comdat_group (thunk_fndecl));
348 if (flag_syntax_only)
350 TREE_ASM_WRITTEN (thunk_fndecl) = 1;
354 push_to_top_level ();
356 if (TARGET_USE_LOCAL_THUNK_ALIAS_P (function)
357 && targetm_common.have_named_sections)
359 resolve_unique_section (function, 0, flag_function_sections);
361 if (DECL_SECTION_NAME (function) != NULL && DECL_ONE_ONLY (function))
363 resolve_unique_section (thunk_fndecl, 0, flag_function_sections);
365 /* Output the thunk into the same section as function. */
366 DECL_SECTION_NAME (thunk_fndecl) = DECL_SECTION_NAME (function);
370 /* Set up cloned argument trees for the thunk. */
372 for (a = DECL_ARGUMENTS (function); a; a = DECL_CHAIN (a))
374 tree x = copy_node (a);
376 DECL_CONTEXT (x) = thunk_fndecl;
377 SET_DECL_RTL (x, NULL);
378 DECL_HAS_VALUE_EXPR_P (x) = 0;
379 TREE_ADDRESSABLE (x) = 0;
383 DECL_ARGUMENTS (thunk_fndecl) = a;
384 TREE_ASM_WRITTEN (thunk_fndecl) = 1;
385 funcn = cgraph_get_node (function);
386 gcc_checking_assert (funcn);
387 cgraph_add_thunk (funcn, thunk_fndecl, function,
388 this_adjusting, fixed_offset, virtual_value,
389 virtual_offset, alias);
392 || !targetm.asm_out.can_output_mi_thunk (thunk_fndecl, fixed_offset,
393 virtual_value, alias))
395 /* If this is a covariant thunk, or we don't have the necessary
396 code for efficient thunks, generate a thunk function that
397 just makes a call to the real function. Unfortunately, this
398 doesn't work for varargs. */
400 if (varargs_function_p (function))
401 error ("generic thunk code fails for method %q#D which uses %<...%>",
405 pop_from_top_level ();
408 /* Code for synthesizing methods which have default semantics defined. */
410 /* True iff CTYPE has a trivial SFK. */
413 type_has_trivial_fn (tree ctype, special_function_kind sfk)
417 case sfk_constructor:
418 return !TYPE_HAS_COMPLEX_DFLT (ctype);
419 case sfk_copy_constructor:
420 return !TYPE_HAS_COMPLEX_COPY_CTOR (ctype);
421 case sfk_move_constructor:
422 return !TYPE_HAS_COMPLEX_MOVE_CTOR (ctype);
423 case sfk_copy_assignment:
424 return !TYPE_HAS_COMPLEX_COPY_ASSIGN (ctype);
425 case sfk_move_assignment:
426 return !TYPE_HAS_COMPLEX_MOVE_ASSIGN (ctype);
428 return !TYPE_HAS_NONTRIVIAL_DESTRUCTOR (ctype);
434 /* Note that CTYPE has a non-trivial SFK even though we previously thought
438 type_set_nontrivial_flag (tree ctype, special_function_kind sfk)
442 case sfk_constructor:
443 TYPE_HAS_COMPLEX_DFLT (ctype) = true;
445 case sfk_copy_constructor:
446 TYPE_HAS_COMPLEX_COPY_CTOR (ctype) = true;
448 case sfk_move_constructor:
449 TYPE_HAS_COMPLEX_MOVE_CTOR (ctype) = true;
451 case sfk_copy_assignment:
452 TYPE_HAS_COMPLEX_COPY_ASSIGN (ctype) = true;
454 case sfk_move_assignment:
455 TYPE_HAS_COMPLEX_MOVE_ASSIGN (ctype) = true;
458 TYPE_HAS_NONTRIVIAL_DESTRUCTOR (ctype) = true;
465 /* True iff FN is a trivial defaulted member function ([cd]tor, op=). */
468 trivial_fn_p (tree fn)
470 if (!DECL_DEFAULTED_FN (fn))
473 /* If fn is a clone, get the primary variant. */
474 fn = DECL_ORIGIN (fn);
475 return type_has_trivial_fn (DECL_CONTEXT (fn), special_function_p (fn));
478 /* Generate code for default X(X&) or X(X&&) constructor. */
481 do_build_copy_constructor (tree fndecl)
483 tree parm = FUNCTION_FIRST_USER_PARM (fndecl);
484 bool move_p = DECL_MOVE_CONSTRUCTOR_P (fndecl);
485 bool trivial = trivial_fn_p (fndecl);
487 parm = convert_from_reference (parm);
490 && is_empty_class (current_class_type))
491 /* Don't copy the padding byte; it might not have been allocated
492 if *this is a base subobject. */;
495 tree t = build2 (INIT_EXPR, void_type_node, current_class_ref, parm);
496 finish_expr_stmt (t);
500 tree fields = TYPE_FIELDS (current_class_type);
501 tree member_init_list = NULL_TREE;
502 int cvquals = cp_type_quals (TREE_TYPE (parm));
504 tree binfo, base_binfo;
506 VEC(tree,gc) *vbases;
508 /* Initialize all the base-classes with the parameter converted
509 to their type so that we get their copy constructor and not
510 another constructor that takes current_class_type. We must
511 deal with the binfo's directly as a direct base might be
512 inaccessible due to ambiguity. */
513 for (vbases = CLASSTYPE_VBASECLASSES (current_class_type), i = 0;
514 VEC_iterate (tree, vbases, i, binfo); i++)
516 init = build_base_path (PLUS_EXPR, parm, binfo, 1);
521 build_tree_list (NULL_TREE, init),
525 for (binfo = TYPE_BINFO (current_class_type), i = 0;
526 BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
528 if (BINFO_VIRTUAL_P (base_binfo))
531 init = build_base_path (PLUS_EXPR, parm, base_binfo, 1);
535 = tree_cons (base_binfo,
536 build_tree_list (NULL_TREE, init),
540 for (; fields; fields = DECL_CHAIN (fields))
545 if (TREE_CODE (field) != FIELD_DECL)
548 expr_type = TREE_TYPE (field);
549 if (DECL_NAME (field))
551 if (VFIELD_NAME_P (DECL_NAME (field)))
554 else if (ANON_AGGR_TYPE_P (expr_type) && TYPE_FIELDS (expr_type))
555 /* Just use the field; anonymous types can't have
556 nontrivial copy ctors or assignment ops or this
557 function would be deleted. */;
561 /* Compute the type of "init->field". If the copy-constructor
562 parameter is, for example, "const S&", and the type of
563 the field is "T", then the type will usually be "const
564 T". (There are no cv-qualified variants of reference
566 if (TREE_CODE (expr_type) != REFERENCE_TYPE)
570 if (DECL_MUTABLE_P (field))
571 quals &= ~TYPE_QUAL_CONST;
572 quals |= cp_type_quals (expr_type);
573 expr_type = cp_build_qualified_type (expr_type, quals);
576 init = build3 (COMPONENT_REF, expr_type, parm, field, NULL_TREE);
577 if (move_p && TREE_CODE (expr_type) != REFERENCE_TYPE)
579 init = build_tree_list (NULL_TREE, init);
581 member_init_list = tree_cons (field, init, member_init_list);
583 finish_mem_initializers (member_init_list);
588 do_build_copy_assign (tree fndecl)
590 tree parm = DECL_CHAIN (DECL_ARGUMENTS (fndecl));
592 bool move_p = move_fn_p (fndecl);
593 bool trivial = trivial_fn_p (fndecl);
594 int flags = LOOKUP_NORMAL | LOOKUP_NONVIRTUAL | LOOKUP_DEFAULTED;
596 compound_stmt = begin_compound_stmt (0);
597 parm = convert_from_reference (parm);
600 && is_empty_class (current_class_type))
601 /* Don't copy the padding byte; it might not have been allocated
602 if *this is a base subobject. */;
605 tree t = build2 (MODIFY_EXPR, void_type_node, current_class_ref, parm);
606 finish_expr_stmt (t);
611 int cvquals = cp_type_quals (TREE_TYPE (parm));
613 tree binfo, base_binfo;
615 /* Assign to each of the direct base classes. */
616 for (binfo = TYPE_BINFO (current_class_type), i = 0;
617 BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
620 VEC(tree,gc) *parmvec;
622 /* We must convert PARM directly to the base class
623 explicitly since the base class may be ambiguous. */
624 converted_parm = build_base_path (PLUS_EXPR, parm, base_binfo, 1);
626 converted_parm = move (converted_parm);
627 /* Call the base class assignment operator. */
628 parmvec = make_tree_vector_single (converted_parm);
630 (build_special_member_call (current_class_ref,
631 ansi_assopname (NOP_EXPR),
635 tf_warning_or_error));
636 release_tree_vector (parmvec);
639 /* Assign to each of the non-static data members. */
640 for (fields = TYPE_FIELDS (current_class_type);
642 fields = DECL_CHAIN (fields))
644 tree comp = current_class_ref;
650 if (TREE_CODE (field) != FIELD_DECL || DECL_ARTIFICIAL (field))
653 expr_type = TREE_TYPE (field);
655 if (CP_TYPE_CONST_P (expr_type))
657 error ("non-static const member %q#D, can%'t use default "
658 "assignment operator", field);
661 else if (TREE_CODE (expr_type) == REFERENCE_TYPE)
663 error ("non-static reference member %q#D, can%'t use "
664 "default assignment operator", field);
668 if (DECL_NAME (field))
670 if (VFIELD_NAME_P (DECL_NAME (field)))
673 else if (ANON_AGGR_TYPE_P (expr_type)
674 && TYPE_FIELDS (expr_type) != NULL_TREE)
675 /* Just use the field; anonymous types can't have
676 nontrivial copy ctors or assignment ops or this
677 function would be deleted. */;
681 comp = build3 (COMPONENT_REF, expr_type, comp, field, NULL_TREE);
683 /* Compute the type of init->field */
685 if (DECL_MUTABLE_P (field))
686 quals &= ~TYPE_QUAL_CONST;
687 expr_type = cp_build_qualified_type (expr_type, quals);
689 init = build3 (COMPONENT_REF, expr_type, init, field, NULL_TREE);
690 if (move_p && TREE_CODE (expr_type) != REFERENCE_TYPE)
693 if (DECL_NAME (field))
694 init = cp_build_modify_expr (comp, NOP_EXPR, init,
695 tf_warning_or_error);
697 init = build2 (MODIFY_EXPR, TREE_TYPE (comp), comp, init);
698 finish_expr_stmt (init);
701 finish_return_stmt (current_class_ref);
702 finish_compound_stmt (compound_stmt);
705 /* Synthesize FNDECL, a non-static member function. */
708 synthesize_method (tree fndecl)
710 bool nested = (current_function_decl != NULL_TREE);
711 tree context = decl_function_context (fndecl);
712 bool need_body = true;
714 location_t save_input_location = input_location;
715 int error_count = errorcount;
716 int warning_count = warningcount;
718 /* Reset the source location, we might have been previously
719 deferred, and thus have saved where we were first needed. */
720 DECL_SOURCE_LOCATION (fndecl)
721 = DECL_SOURCE_LOCATION (TYPE_NAME (DECL_CONTEXT (fndecl)));
723 /* If we've been asked to synthesize a clone, just synthesize the
724 cloned function instead. Doing so will automatically fill in the
725 body for the clone. */
726 if (DECL_CLONED_FUNCTION_P (fndecl))
727 fndecl = DECL_CLONED_FUNCTION (fndecl);
729 /* We may be in the middle of deferred access check. Disable
731 push_deferring_access_checks (dk_no_deferred);
734 push_to_top_level ();
736 push_function_context ();
738 input_location = DECL_SOURCE_LOCATION (fndecl);
740 start_preparsed_function (fndecl, NULL_TREE, SF_DEFAULT | SF_PRE_PARSED);
741 stmt = begin_function_body ();
743 if (DECL_OVERLOADED_OPERATOR_P (fndecl) == NOP_EXPR)
745 do_build_copy_assign (fndecl);
748 else if (DECL_CONSTRUCTOR_P (fndecl))
750 tree arg_chain = FUNCTION_FIRST_USER_PARMTYPE (fndecl);
751 if (arg_chain != void_list_node)
752 do_build_copy_constructor (fndecl);
754 finish_mem_initializers (NULL_TREE);
757 /* If we haven't yet generated the body of the function, just
758 generate an empty compound statement. */
762 compound_stmt = begin_compound_stmt (BCS_FN_BODY);
763 finish_compound_stmt (compound_stmt);
766 finish_function_body (stmt);
767 expand_or_defer_fn (finish_function (0));
769 input_location = save_input_location;
772 pop_from_top_level ();
774 pop_function_context ();
776 pop_deferring_access_checks ();
778 if (error_count != errorcount || warning_count != warningcount)
779 inform (input_location, "synthesized method %qD first required here ",
783 /* Build a reference to type TYPE with cv-quals QUALS, which is an
784 rvalue if RVALUE is true. */
787 build_stub_type (tree type, int quals, bool rvalue)
789 tree argtype = cp_build_qualified_type (type, quals);
790 return cp_build_reference_type (argtype, rvalue);
793 /* Build a dummy glvalue from dereferencing a dummy reference of type
797 build_stub_object (tree reftype)
799 tree stub = build1 (NOP_EXPR, reftype, integer_one_node);
800 return convert_from_reference (stub);
803 /* Determine which function will be called when looking up NAME in TYPE,
804 called with a single ARGTYPE argument, or no argument if ARGTYPE is
805 null. FLAGS and COMPLAIN are as for build_new_method_call.
807 Returns a FUNCTION_DECL if all is well.
808 Returns NULL_TREE if overload resolution failed.
809 Returns error_mark_node if the chosen function cannot be called. */
812 locate_fn_flags (tree type, tree name, tree argtype, int flags,
813 tsubst_flags_t complain)
815 tree ob, fn, fns, binfo, rval;
819 binfo = TYPE_BINFO (type);
823 type = BINFO_TYPE (binfo);
826 ob = build_stub_object (cp_build_reference_type (type, false));
827 args = make_tree_vector ();
830 tree arg = build_stub_object (argtype);
831 VEC_quick_push (tree, args, arg);
834 fns = lookup_fnfields (binfo, name, 0);
835 rval = build_new_method_call (ob, fns, &args, binfo, flags, &fn, complain);
837 release_tree_vector (args);
838 if (fn && rval == error_mark_node)
844 /* Locate the dtor of TYPE. */
847 get_dtor (tree type, tsubst_flags_t complain)
849 tree fn = locate_fn_flags (type, complete_dtor_identifier, NULL_TREE,
850 LOOKUP_NORMAL, complain);
851 if (fn == error_mark_node)
856 /* Locate the default ctor of TYPE. */
859 locate_ctor (tree type)
863 push_deferring_access_checks (dk_no_check);
864 fn = locate_fn_flags (type, complete_ctor_identifier, NULL_TREE,
865 LOOKUP_SPECULATIVE, tf_none);
866 pop_deferring_access_checks ();
867 if (fn == error_mark_node)
872 /* Likewise, but give any appropriate errors. */
875 get_default_ctor (tree type)
877 tree fn = locate_fn_flags (type, complete_ctor_identifier, NULL_TREE,
878 LOOKUP_NORMAL, tf_warning_or_error);
879 if (fn == error_mark_node)
884 /* Locate the copy ctor of TYPE. */
887 get_copy_ctor (tree type, tsubst_flags_t complain)
889 int quals = (TYPE_HAS_CONST_COPY_CTOR (type)
890 ? TYPE_QUAL_CONST : TYPE_UNQUALIFIED);
891 tree argtype = build_stub_type (type, quals, false);
892 tree fn = locate_fn_flags (type, complete_ctor_identifier, argtype,
893 LOOKUP_NORMAL, complain);
894 if (fn == error_mark_node)
899 /* Locate the copy assignment operator of TYPE. */
902 get_copy_assign (tree type)
904 int quals = (TYPE_HAS_CONST_COPY_ASSIGN (type)
905 ? TYPE_QUAL_CONST : TYPE_UNQUALIFIED);
906 tree argtype = build_stub_type (type, quals, false);
907 tree fn = locate_fn_flags (type, ansi_assopname (NOP_EXPR), argtype,
908 LOOKUP_NORMAL, tf_warning_or_error);
909 if (fn == error_mark_node)
914 /* Subroutine of synthesized_method_walk. Update SPEC_P, TRIVIAL_P and
915 DELETED_P or give an error message MSG with argument ARG. */
918 process_subob_fn (tree fn, bool move_p, tree *spec_p, bool *trivial_p,
919 bool *deleted_p, bool *constexpr_p,
920 const char *msg, tree arg)
922 if (!fn || fn == error_mark_node)
927 tree raises = TYPE_RAISES_EXCEPTIONS (TREE_TYPE (fn));
928 *spec_p = merge_exception_specifiers (*spec_p, raises, fn);
931 if (!trivial_fn_p (fn))
935 if (TREE_CODE (arg) == FIELD_DECL
936 && TREE_CODE (DECL_CONTEXT (arg)) == UNION_TYPE)
941 error ("union member %q+D with non-trivial %qD", arg, fn);
945 if (move_p && !move_fn_p (fn) && !trivial_fn_p (fn))
954 /* If this is a specialization of a constexpr template, we need to
955 force the instantiation now so that we know whether or not it's
957 if (DECL_DECLARED_CONSTEXPR_P (fn) && DECL_TEMPLATE_INSTANTIATION (fn)
958 && !DECL_TEMPLATE_INSTANTIATED (fn))
959 instantiate_decl (fn, /*defer_ok*/false, /*expl_class*/false);
960 if (!DECL_DECLARED_CONSTEXPR_P (fn))
961 *constexpr_p = false;
971 /* Subroutine of synthesized_method_walk to allow recursion into anonymous
975 walk_field_subobs (tree fields, tree fnname, special_function_kind sfk,
976 int quals, bool copy_arg_p, bool move_p,
977 bool assign_p, tree *spec_p, bool *trivial_p,
978 bool *deleted_p, bool *constexpr_p, const char *msg,
979 int flags, tsubst_flags_t complain)
982 for (field = fields; field; field = DECL_CHAIN (field))
984 tree mem_type, argtype, rval;
986 if (TREE_CODE (field) != FIELD_DECL
987 || DECL_ARTIFICIAL (field))
990 mem_type = strip_array_types (TREE_TYPE (field));
994 if (CP_TYPE_CONST_P (mem_type) && !CLASS_TYPE_P (mem_type))
997 error ("non-static const member %q#D, can%'t use default "
998 "assignment operator", field);
1000 else if (TREE_CODE (mem_type) == REFERENCE_TYPE)
1003 error ("non-static reference member %q#D, can%'t use "
1004 "default assignment operator", field);
1009 if (bad && deleted_p)
1012 else if (sfk == sfk_constructor)
1015 if (CP_TYPE_CONST_P (mem_type)
1016 && (!CLASS_TYPE_P (mem_type)
1017 || !type_has_user_provided_default_constructor (mem_type)))
1020 error ("uninitialized non-static const member %q#D",
1023 else if (TREE_CODE (mem_type) == REFERENCE_TYPE)
1026 error ("uninitialized non-static reference member %q#D",
1032 if (bad && deleted_p)
1035 /* For an implicitly-defined default constructor to be constexpr,
1036 every member must have a user-provided default constructor. */
1037 /* FIXME will need adjustment for non-static data member
1039 if (constexpr_p && !CLASS_TYPE_P (mem_type))
1040 *constexpr_p = false;
1043 if (!CLASS_TYPE_P (mem_type))
1046 if (ANON_AGGR_TYPE_P (mem_type))
1048 walk_field_subobs (TYPE_FIELDS (mem_type), fnname, sfk, quals,
1049 copy_arg_p, move_p, assign_p, spec_p, trivial_p,
1050 deleted_p, constexpr_p, msg, flags, complain);
1056 int mem_quals = cp_type_quals (mem_type) | quals;
1057 if (DECL_MUTABLE_P (field))
1058 mem_quals &= ~TYPE_QUAL_CONST;
1059 argtype = build_stub_type (mem_type, mem_quals, move_p);
1062 argtype = NULL_TREE;
1064 rval = locate_fn_flags (mem_type, fnname, argtype, flags, complain);
1066 process_subob_fn (rval, move_p, spec_p, trivial_p, deleted_p,
1067 constexpr_p, msg, field);
1071 /* The caller wants to generate an implicit declaration of SFK for CTYPE
1072 which is const if relevant and CONST_P is set. If spec_p, trivial_p and
1073 deleted_p are non-null, set their referent appropriately. If diag is
1074 true, we're being called from maybe_explain_implicit_delete to give
1078 synthesized_method_walk (tree ctype, special_function_kind sfk, bool const_p,
1079 tree *spec_p, bool *trivial_p, bool *deleted_p,
1080 bool *constexpr_p, bool diag)
1082 tree binfo, base_binfo, scope, fnname, rval, argtype;
1083 bool move_p, copy_arg_p, assign_p, expected_trivial, check_vdtor;
1084 VEC(tree,gc) *vbases;
1085 int i, quals, flags;
1086 tsubst_flags_t complain;
1091 *spec_p = (cxx_dialect >= cxx0x ? noexcept_true_spec : empty_except_spec);
1095 /* "The closure type associated with a lambda-expression has a deleted
1096 default constructor and a deleted copy assignment operator."
1097 This is diagnosed in maybe_explain_implicit_delete. */
1098 if (LAMBDA_TYPE_P (ctype)
1099 && (sfk == sfk_constructor
1100 || sfk == sfk_copy_assignment))
1111 check_vdtor = false;
1114 case sfk_move_assignment:
1115 case sfk_copy_assignment:
1117 fnname = ansi_assopname (NOP_EXPR);
1120 case sfk_destructor:
1122 /* The synthesized method will call base dtors, but check complete
1123 here to avoid having to deal with VTT. */
1124 fnname = complete_dtor_identifier;
1127 case sfk_constructor:
1128 case sfk_move_constructor:
1129 case sfk_copy_constructor:
1131 fnname = complete_ctor_identifier;
1138 /* If that user-written default constructor would satisfy the
1139 requirements of a constexpr constructor (7.1.5), the
1140 implicitly-defined default constructor is constexpr. */
1142 *constexpr_p = ctor_p;
1147 case sfk_constructor:
1148 case sfk_destructor:
1152 case sfk_move_constructor:
1153 case sfk_move_assignment:
1155 case sfk_copy_constructor:
1156 case sfk_copy_assignment:
1164 expected_trivial = type_has_trivial_fn (ctype, sfk);
1166 *trivial_p = expected_trivial;
1168 /* The TYPE_HAS_COMPLEX_* flags tell us about constraints from base
1169 class versions and other properties of the type. But a subobject
1170 class can be trivially copyable and yet have overload resolution
1171 choose a template constructor for initialization, depending on
1172 rvalueness and cv-quals. So we can't exit early for copy/move
1173 methods in C++0x. The same considerations apply in C++98/03, but
1174 there the definition of triviality does not consider overload
1175 resolution, so a constructor can be trivial even if it would otherwise
1176 call a non-trivial constructor. */
1177 if (expected_trivial
1178 && (!copy_arg_p || cxx_dialect < cxx0x))
1180 if (constexpr_p && sfk == sfk_constructor)
1181 *constexpr_p = synthesized_default_constructor_is_constexpr (ctype);
1185 ++cp_unevaluated_operand;
1186 ++c_inhibit_evaluation_warnings;
1188 scope = push_scope (ctype);
1192 flags = LOOKUP_NORMAL|LOOKUP_SPECULATIVE|LOOKUP_DEFAULTED;
1193 complain = tf_warning_or_error;
1197 flags = LOOKUP_PROTECT|LOOKUP_SPECULATIVE|LOOKUP_DEFAULTED;
1202 quals = TYPE_QUAL_CONST;
1204 quals = TYPE_UNQUALIFIED;
1205 argtype = NULL_TREE;
1210 msg = ("base %qT does not have a move assignment operator or trivial "
1211 "copy assignment operator");
1213 msg = ("base %qT does not have a move constructor or trivial "
1214 "copy constructor");
1216 for (binfo = TYPE_BINFO (ctype), i = 0;
1217 BINFO_BASE_ITERATE (binfo, i, base_binfo); ++i)
1219 tree basetype = BINFO_TYPE (base_binfo);
1221 argtype = build_stub_type (basetype, quals, move_p);
1222 rval = locate_fn_flags (base_binfo, fnname, argtype, flags, complain);
1224 process_subob_fn (rval, move_p, spec_p, trivial_p, deleted_p,
1225 constexpr_p, msg, basetype);
1226 if (ctor_p && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (basetype))
1228 /* In a constructor we also need to check the subobject
1229 destructors for cleanup of partially constructed objects. */
1230 rval = locate_fn_flags (base_binfo, complete_dtor_identifier,
1231 NULL_TREE, flags, complain);
1232 /* Note that we don't pass down trivial_p; the subobject
1233 destructors don't affect triviality of the constructor. */
1234 process_subob_fn (rval, false, spec_p, NULL,
1235 deleted_p, NULL, NULL,
1239 if (check_vdtor && type_has_virtual_destructor (basetype))
1241 rval = locate_fn_flags (ctype, ansi_opname (DELETE_EXPR),
1242 ptr_type_node, flags, complain);
1243 /* Unlike for base ctor/op=/dtor, for operator delete it's fine
1244 to have a null rval (no class-specific op delete). */
1245 if (rval && rval == error_mark_node && deleted_p)
1247 check_vdtor = false;
1251 vbases = CLASSTYPE_VBASECLASSES (ctype);
1252 if (vbases && assign_p && move_p)
1254 /* Should the spec be changed to allow vbases that only occur once? */
1256 error ("%qT has virtual bases, default move assignment operator "
1257 "cannot be generated", ctype);
1264 msg = ("virtual base %qT does not have a move constructor "
1265 "or trivial copy constructor");
1266 if (vbases && constexpr_p)
1267 *constexpr_p = false;
1268 FOR_EACH_VEC_ELT (tree, vbases, i, base_binfo)
1270 tree basetype = BINFO_TYPE (base_binfo);
1272 argtype = build_stub_type (basetype, quals, move_p);
1273 rval = locate_fn_flags (base_binfo, fnname, argtype, flags, complain);
1275 process_subob_fn (rval, move_p, spec_p, trivial_p, deleted_p,
1276 constexpr_p, msg, basetype);
1277 if (ctor_p && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (basetype))
1279 rval = locate_fn_flags (base_binfo, complete_dtor_identifier,
1280 NULL_TREE, flags, complain);
1281 process_subob_fn (rval, false, spec_p, NULL,
1282 deleted_p, NULL, NULL,
1288 /* Leave msg null. */;
1290 msg = ("non-static data member %qD does not have a move "
1291 "assignment operator or trivial copy assignment operator");
1293 msg = ("non-static data member %qD does not have a move "
1294 "constructor or trivial copy constructor");
1295 walk_field_subobs (TYPE_FIELDS (ctype), fnname, sfk, quals,
1296 copy_arg_p, move_p, assign_p, spec_p, trivial_p,
1297 deleted_p, constexpr_p, msg, flags, complain);
1299 walk_field_subobs (TYPE_FIELDS (ctype), complete_dtor_identifier,
1300 sfk_destructor, TYPE_UNQUALIFIED, false,
1301 false, false, spec_p, NULL,
1303 NULL, flags, complain);
1307 --cp_unevaluated_operand;
1308 --c_inhibit_evaluation_warnings;
1311 /* DECL is a deleted function. If it's implicitly deleted, explain why and
1312 return true; else return false. */
1315 maybe_explain_implicit_delete (tree decl)
1317 /* If decl is a clone, get the primary variant. */
1318 decl = DECL_ORIGIN (decl);
1319 gcc_assert (DECL_DELETED_FN (decl));
1320 if (DECL_DEFAULTED_FN (decl))
1322 /* Not marked GTY; it doesn't need to be GC'd or written to PCH. */
1323 static htab_t explained_htab;
1326 special_function_kind sfk;
1331 if (!explained_htab)
1332 explained_htab = htab_create (37, htab_hash_pointer,
1333 htab_eq_pointer, NULL);
1334 slot = htab_find_slot (explained_htab, decl, INSERT);
1339 sfk = special_function_p (decl);
1340 ctype = DECL_CONTEXT (decl);
1341 loc = input_location;
1342 input_location = DECL_SOURCE_LOCATION (decl);
1345 if (LAMBDA_TYPE_P (ctype))
1348 if (sfk == sfk_constructor)
1349 error ("a lambda closure type has a deleted default constructor");
1350 else if (sfk == sfk_copy_assignment)
1351 error ("a lambda closure type has a deleted copy assignment operator");
1357 tree parm_type = TREE_VALUE (FUNCTION_FIRST_USER_PARMTYPE (decl));
1358 bool const_p = CP_TYPE_CONST_P (non_reference (parm_type));
1359 tree scope = push_scope (ctype);
1360 error ("%qD is implicitly deleted because the default "
1361 "definition would be ill-formed:", decl);
1363 synthesized_method_walk (ctype, sfk, const_p,
1364 NULL, NULL, NULL, NULL, true);
1367 input_location = loc;
1373 /* Implicitly declare the special function indicated by KIND, as a
1374 member of TYPE. For copy constructors and assignment operators,
1375 CONST_P indicates whether these functions should take a const
1376 reference argument or a non-const reference. Returns the
1377 FUNCTION_DECL for the implicitly declared function. */
1380 implicitly_declare_fn (special_function_kind kind, tree type, bool const_p)
1383 tree parameter_types = void_list_node;
1386 tree raises = empty_except_spec;
1387 tree rhs_parm_type = NULL_TREE;
1390 HOST_WIDE_INT saved_processing_template_decl;
1395 /* Because we create declarations for implicitly declared functions
1396 lazily, we may be creating the declaration for a member of TYPE
1397 while in some completely different context. However, TYPE will
1398 never be a dependent class (because we never want to do lookups
1399 for implicitly defined functions in a dependent class).
1400 Furthermore, we must set PROCESSING_TEMPLATE_DECL to zero here
1401 because we only create clones for constructors and destructors
1402 when not in a template. */
1403 gcc_assert (!dependent_type_p (type));
1404 saved_processing_template_decl = processing_template_decl;
1405 processing_template_decl = 0;
1407 type = TYPE_MAIN_VARIANT (type);
1409 if (targetm.cxx.cdtor_returns_this () && !TYPE_FOR_JAVA (type))
1411 if (kind == sfk_destructor)
1412 /* See comment in check_special_function_return_type. */
1413 return_type = build_pointer_type (void_type_node);
1415 return_type = build_pointer_type (type);
1418 return_type = void_type_node;
1422 case sfk_destructor:
1424 name = constructor_name (type);
1427 case sfk_constructor:
1428 /* Default constructor. */
1429 name = constructor_name (type);
1432 case sfk_copy_constructor:
1433 case sfk_copy_assignment:
1434 case sfk_move_constructor:
1435 case sfk_move_assignment:
1438 if (kind == sfk_copy_assignment
1439 || kind == sfk_move_assignment)
1441 return_type = build_reference_type (type);
1442 name = ansi_assopname (NOP_EXPR);
1445 name = constructor_name (type);
1448 rhs_parm_type = cp_build_qualified_type (type, TYPE_QUAL_CONST);
1450 rhs_parm_type = type;
1451 move_p = (kind == sfk_move_assignment
1452 || kind == sfk_move_constructor);
1453 rhs_parm_type = cp_build_reference_type (rhs_parm_type, move_p);
1455 parameter_types = tree_cons (NULL_TREE, rhs_parm_type, parameter_types);
1462 synthesized_method_walk (type, kind, const_p, &raises, &trivial_p,
1463 &deleted_p, &constexpr_p, false);
1464 /* Don't bother marking a deleted constructor as constexpr. */
1466 constexpr_p = false;
1467 /* A trivial copy/move constructor is also a constexpr constructor. */
1468 else if (trivial_p && cxx_dialect >= cxx0x
1469 && (kind == sfk_copy_constructor
1470 || kind == sfk_move_constructor))
1471 gcc_assert (constexpr_p);
1473 if (!trivial_p && type_has_trivial_fn (type, kind))
1474 type_set_nontrivial_flag (type, kind);
1476 /* Create the function. */
1477 fn_type = build_method_type_directly (type, return_type, parameter_types);
1479 fn_type = build_exception_variant (fn_type, raises);
1480 fn = build_lang_decl (FUNCTION_DECL, name, fn_type);
1481 DECL_SOURCE_LOCATION (fn) = DECL_SOURCE_LOCATION (TYPE_NAME (type));
1482 if (kind == sfk_constructor || kind == sfk_copy_constructor
1483 || kind == sfk_move_constructor)
1484 DECL_CONSTRUCTOR_P (fn) = 1;
1485 else if (kind == sfk_destructor)
1486 DECL_DESTRUCTOR_P (fn) = 1;
1489 DECL_ASSIGNMENT_OPERATOR_P (fn) = 1;
1490 SET_OVERLOADED_OPERATOR_CODE (fn, NOP_EXPR);
1493 /* If pointers to member functions use the least significant bit to
1494 indicate whether a function is virtual, ensure a pointer
1495 to this function will have that bit clear. */
1496 if (TARGET_PTRMEMFUNC_VBIT_LOCATION == ptrmemfunc_vbit_in_pfn
1497 && DECL_ALIGN (fn) < 2 * BITS_PER_UNIT)
1498 DECL_ALIGN (fn) = 2 * BITS_PER_UNIT;
1500 /* Create the explicit arguments. */
1503 /* Note that this parameter is *not* marked DECL_ARTIFICIAL; we
1504 want its type to be included in the mangled function
1506 DECL_ARGUMENTS (fn) = cp_build_parm_decl (NULL_TREE, rhs_parm_type);
1507 TREE_READONLY (DECL_ARGUMENTS (fn)) = 1;
1509 /* Add the "this" parameter. */
1510 this_parm = build_this_parm (fn_type, TYPE_UNQUALIFIED);
1511 DECL_CHAIN (this_parm) = DECL_ARGUMENTS (fn);
1512 DECL_ARGUMENTS (fn) = this_parm;
1514 grokclassfn (type, fn, kind == sfk_destructor ? DTOR_FLAG : NO_SPECIAL);
1515 set_linkage_according_to_type (type, fn);
1516 rest_of_decl_compilation (fn, toplevel_bindings_p (), at_eof);
1517 DECL_IN_AGGR_P (fn) = 1;
1518 DECL_ARTIFICIAL (fn) = 1;
1519 DECL_DEFAULTED_FN (fn) = 1;
1520 if (cxx_dialect >= cxx0x)
1522 DECL_DELETED_FN (fn) = deleted_p;
1523 DECL_DECLARED_CONSTEXPR_P (fn) = constexpr_p;
1525 DECL_NOT_REALLY_EXTERN (fn) = 1;
1526 DECL_DECLARED_INLINE_P (fn) = 1;
1527 gcc_assert (!TREE_USED (fn));
1529 /* Restore PROCESSING_TEMPLATE_DECL. */
1530 processing_template_decl = saved_processing_template_decl;
1535 /* Gives any errors about defaulted functions which need to be deferred
1536 until the containing class is complete. */
1539 defaulted_late_check (tree fn)
1541 /* Complain about invalid signature for defaulted fn. */
1542 tree ctx = DECL_CONTEXT (fn);
1543 special_function_kind kind = special_function_p (fn);
1544 bool fn_const_p = (copy_fn_p (fn) == 2);
1545 tree implicit_fn = implicitly_declare_fn (kind, ctx, fn_const_p);
1547 if (!same_type_p (TREE_TYPE (TREE_TYPE (fn)),
1548 TREE_TYPE (TREE_TYPE (implicit_fn)))
1549 || !compparms (TYPE_ARG_TYPES (TREE_TYPE (fn)),
1550 TYPE_ARG_TYPES (TREE_TYPE (implicit_fn))))
1552 error ("defaulted declaration %q+D", fn);
1553 error_at (DECL_SOURCE_LOCATION (fn),
1554 "does not match expected signature %qD", implicit_fn);
1557 /* 8.4.2/2: If it is explicitly defaulted on its first declaration, it is
1558 implicitly considered to have the same exception-specification as if
1559 it had been implicitly declared. */
1560 if (DECL_DEFAULTED_IN_CLASS_P (fn))
1562 tree eh_spec = TYPE_RAISES_EXCEPTIONS (TREE_TYPE (implicit_fn));
1563 if (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (fn)))
1565 maybe_instantiate_noexcept (fn);
1566 if (!comp_except_specs (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (fn)),
1567 eh_spec, ce_normal))
1568 error ("function %q+D defaulted on its first declaration "
1569 "with an exception-specification that differs from "
1570 "the implicit declaration %q#D", fn, implicit_fn);
1572 TREE_TYPE (fn) = build_exception_variant (TREE_TYPE (fn), eh_spec);
1573 if (DECL_DECLARED_CONSTEXPR_P (implicit_fn))
1575 /* Hmm...should we do this for out-of-class too? Should it be OK to
1576 add constexpr later like inline, rather than requiring
1577 declarations to match? */
1578 DECL_DECLARED_CONSTEXPR_P (fn) = true;
1579 if (kind == sfk_constructor)
1580 TYPE_HAS_CONSTEXPR_CTOR (ctx) = true;
1584 if (!DECL_DECLARED_CONSTEXPR_P (implicit_fn)
1585 && DECL_DECLARED_CONSTEXPR_P (fn))
1587 if (!CLASSTYPE_TEMPLATE_INSTANTIATION (ctx))
1588 error ("%qD cannot be declared as constexpr", fn);
1589 DECL_DECLARED_CONSTEXPR_P (fn) = false;
1592 if (DECL_DELETED_FN (implicit_fn))
1593 DECL_DELETED_FN (fn) = 1;
1596 /* Returns true iff FN can be explicitly defaulted, and gives any
1597 errors if defaulting FN is ill-formed. */
1600 defaultable_fn_check (tree fn)
1602 special_function_kind kind = sfk_none;
1604 if (template_parm_scope_p ())
1606 error ("a template cannot be defaulted");
1610 if (DECL_CONSTRUCTOR_P (fn))
1612 if (FUNCTION_FIRST_USER_PARMTYPE (fn) == void_list_node)
1613 kind = sfk_constructor;
1614 else if (copy_fn_p (fn) > 0
1615 && (TREE_CHAIN (FUNCTION_FIRST_USER_PARMTYPE (fn))
1617 kind = sfk_copy_constructor;
1618 else if (move_fn_p (fn))
1619 kind = sfk_move_constructor;
1621 else if (DECL_DESTRUCTOR_P (fn))
1622 kind = sfk_destructor;
1623 else if (DECL_ASSIGNMENT_OPERATOR_P (fn)
1624 && DECL_OVERLOADED_OPERATOR_P (fn) == NOP_EXPR)
1627 kind = sfk_copy_assignment;
1628 else if (move_fn_p (fn))
1629 kind = sfk_move_assignment;
1632 if (kind == sfk_none)
1634 error ("%qD cannot be defaulted", fn);
1639 tree t = FUNCTION_FIRST_USER_PARMTYPE (fn);
1640 for (; t && t != void_list_node; t = TREE_CHAIN (t))
1641 if (TREE_PURPOSE (t))
1643 error ("defaulted function %q+D with default argument", fn);
1646 if (TYPE_BEING_DEFINED (DECL_CONTEXT (fn)))
1647 /* Defer checking. */;
1648 else if (!processing_template_decl)
1649 defaulted_late_check (fn);
1655 /* Add an implicit declaration to TYPE for the kind of function
1656 indicated by SFK. Return the FUNCTION_DECL for the new implicit
1660 lazily_declare_fn (special_function_kind sfk, tree type)
1663 /* Whether or not the argument has a const reference type. */
1664 bool const_p = false;
1668 case sfk_constructor:
1669 CLASSTYPE_LAZY_DEFAULT_CTOR (type) = 0;
1671 case sfk_copy_constructor:
1672 const_p = TYPE_HAS_CONST_COPY_CTOR (type);
1673 CLASSTYPE_LAZY_COPY_CTOR (type) = 0;
1675 case sfk_move_constructor:
1676 CLASSTYPE_LAZY_MOVE_CTOR (type) = 0;
1678 case sfk_copy_assignment:
1679 const_p = TYPE_HAS_CONST_COPY_ASSIGN (type);
1680 CLASSTYPE_LAZY_COPY_ASSIGN (type) = 0;
1682 case sfk_move_assignment:
1683 CLASSTYPE_LAZY_MOVE_ASSIGN (type) = 0;
1685 case sfk_destructor:
1686 CLASSTYPE_LAZY_DESTRUCTOR (type) = 0;
1692 /* Declare the function. */
1693 fn = implicitly_declare_fn (sfk, type, const_p);
1695 /* For move variants, rather than declare them as deleted we just
1696 don't declare them at all. */
1697 if (DECL_DELETED_FN (fn)
1698 && (sfk == sfk_move_constructor
1699 || sfk == sfk_move_assignment))
1702 /* A destructor may be virtual. */
1703 if (sfk == sfk_destructor
1704 || sfk == sfk_move_assignment
1705 || sfk == sfk_copy_assignment)
1706 check_for_override (fn, type);
1707 /* Add it to CLASSTYPE_METHOD_VEC. */
1708 add_method (type, fn, NULL_TREE);
1709 /* Add it to TYPE_METHODS. */
1710 if (sfk == sfk_destructor
1711 && DECL_VIRTUAL_P (fn)
1712 && abi_version_at_least (2))
1713 /* The ABI requires that a virtual destructor go at the end of the
1715 TYPE_METHODS (type) = chainon (TYPE_METHODS (type), fn);
1718 /* G++ 3.2 put the implicit destructor at the *beginning* of the
1719 TYPE_METHODS list, which cause the destructor to be emitted
1720 in an incorrect location in the vtable. */
1721 if (warn_abi && sfk == sfk_destructor && DECL_VIRTUAL_P (fn))
1722 warning (OPT_Wabi, "vtable layout for class %qT may not be ABI-compliant"
1723 "and may change in a future version of GCC due to "
1724 "implicit virtual destructor",
1726 DECL_CHAIN (fn) = TYPE_METHODS (type);
1727 TYPE_METHODS (type) = fn;
1729 maybe_add_class_template_decl_list (type, fn, /*friend_p=*/0);
1730 if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (fn)
1731 || DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (fn))
1732 /* Create appropriate clones. */
1733 clone_function_decl (fn, /*update_method_vec=*/true);
1738 /* Given a FUNCTION_DECL FN and a chain LIST, skip as many elements of LIST
1739 as there are artificial parms in FN. */
1742 skip_artificial_parms_for (const_tree fn, tree list)
1744 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fn))
1745 list = TREE_CHAIN (list);
1749 if (DECL_HAS_IN_CHARGE_PARM_P (fn))
1750 list = TREE_CHAIN (list);
1751 if (DECL_HAS_VTT_PARM_P (fn))
1752 list = TREE_CHAIN (list);
1756 /* Given a FUNCTION_DECL FN and a chain LIST, return the number of
1757 artificial parms in FN. */
1760 num_artificial_parms_for (const_tree fn)
1764 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fn))
1769 if (DECL_HAS_IN_CHARGE_PARM_P (fn))
1771 if (DECL_HAS_VTT_PARM_P (fn))
1777 #include "gt-cp-method.h"