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;
263 aliasn = cgraph_same_body_alias (cgraph_get_create_node (function),
265 DECL_ASSEMBLER_NAME (function);
266 gcc_assert (aliasn != NULL);
272 /* Emit the definition of a C++ multiple inheritance or covariant
273 return vtable thunk. If EMIT_P is nonzero, the thunk is emitted
277 use_thunk (tree thunk_fndecl, bool emit_p)
279 tree a, t, function, alias;
281 HOST_WIDE_INT fixed_offset, virtual_value;
282 bool this_adjusting = DECL_THIS_THUNK_P (thunk_fndecl);
284 /* We should have called finish_thunk to give it a name. */
285 gcc_assert (DECL_NAME (thunk_fndecl));
287 /* We should never be using an alias, always refer to the
289 gcc_assert (!THUNK_ALIAS (thunk_fndecl));
291 if (TREE_ASM_WRITTEN (thunk_fndecl))
294 function = THUNK_TARGET (thunk_fndecl);
295 if (DECL_RESULT (thunk_fndecl))
296 /* We already turned this thunk into an ordinary function.
297 There's no need to process this thunk again. */
300 if (DECL_THUNK_P (function))
301 /* The target is itself a thunk, process it now. */
302 use_thunk (function, emit_p);
304 /* Thunks are always addressable; they only appear in vtables. */
305 TREE_ADDRESSABLE (thunk_fndecl) = 1;
307 /* Figure out what function is being thunked to. It's referenced in
308 this translation unit. */
309 TREE_ADDRESSABLE (function) = 1;
310 mark_used (function);
314 if (TARGET_USE_LOCAL_THUNK_ALIAS_P (function))
315 alias = make_alias_for_thunk (function);
319 fixed_offset = THUNK_FIXED_OFFSET (thunk_fndecl);
320 virtual_offset = THUNK_VIRTUAL_OFFSET (thunk_fndecl);
325 virtual_offset = BINFO_VPTR_FIELD (virtual_offset);
326 virtual_value = tree_low_cst (virtual_offset, /*pos=*/0);
327 gcc_assert (virtual_value);
332 /* And, if we need to emit the thunk, it's used. */
333 mark_used (thunk_fndecl);
334 /* This thunk is actually defined. */
335 DECL_EXTERNAL (thunk_fndecl) = 0;
336 /* The linkage of the function may have changed. FIXME in linkage
338 TREE_PUBLIC (thunk_fndecl) = TREE_PUBLIC (function);
339 DECL_VISIBILITY (thunk_fndecl) = DECL_VISIBILITY (function);
340 DECL_VISIBILITY_SPECIFIED (thunk_fndecl)
341 = DECL_VISIBILITY_SPECIFIED (function);
342 if (DECL_ONE_ONLY (function) || DECL_WEAK (function))
343 make_decl_one_only (thunk_fndecl, cxx_comdat_group (thunk_fndecl));
345 if (flag_syntax_only)
347 TREE_ASM_WRITTEN (thunk_fndecl) = 1;
351 push_to_top_level ();
353 if (TARGET_USE_LOCAL_THUNK_ALIAS_P (function)
354 && targetm.have_named_sections)
356 resolve_unique_section (function, 0, flag_function_sections);
358 if (DECL_SECTION_NAME (function) != NULL && DECL_ONE_ONLY (function))
360 resolve_unique_section (thunk_fndecl, 0, flag_function_sections);
362 /* Output the thunk into the same section as function. */
363 DECL_SECTION_NAME (thunk_fndecl) = DECL_SECTION_NAME (function);
367 /* Set up cloned argument trees for the thunk. */
369 for (a = DECL_ARGUMENTS (function); a; a = DECL_CHAIN (a))
371 tree x = copy_node (a);
373 DECL_CONTEXT (x) = thunk_fndecl;
374 SET_DECL_RTL (x, NULL);
375 DECL_HAS_VALUE_EXPR_P (x) = 0;
376 TREE_ADDRESSABLE (x) = 0;
380 DECL_ARGUMENTS (thunk_fndecl) = a;
381 TREE_ASM_WRITTEN (thunk_fndecl) = 1;
382 cgraph_add_thunk (cgraph_get_create_node (function), thunk_fndecl, function,
383 this_adjusting, fixed_offset, virtual_value,
384 virtual_offset, alias);
387 || !targetm.asm_out.can_output_mi_thunk (thunk_fndecl, fixed_offset,
388 virtual_value, alias))
390 /* If this is a covariant thunk, or we don't have the necessary
391 code for efficient thunks, generate a thunk function that
392 just makes a call to the real function. Unfortunately, this
393 doesn't work for varargs. */
395 if (varargs_function_p (function))
396 error ("generic thunk code fails for method %q#D which uses %<...%>",
400 pop_from_top_level ();
403 /* Code for synthesizing methods which have default semantics defined. */
405 /* True iff CTYPE has a trivial SFK. */
408 type_has_trivial_fn (tree ctype, special_function_kind sfk)
412 case sfk_constructor:
413 return !TYPE_HAS_COMPLEX_DFLT (ctype);
414 case sfk_copy_constructor:
415 return !TYPE_HAS_COMPLEX_COPY_CTOR (ctype);
416 case sfk_move_constructor:
417 return !TYPE_HAS_COMPLEX_MOVE_CTOR (ctype);
418 case sfk_copy_assignment:
419 return !TYPE_HAS_COMPLEX_COPY_ASSIGN (ctype);
420 case sfk_move_assignment:
421 return !TYPE_HAS_COMPLEX_MOVE_ASSIGN (ctype);
423 return !TYPE_HAS_NONTRIVIAL_DESTRUCTOR (ctype);
429 /* Note that CTYPE has a non-trivial SFK even though we previously thought
433 type_set_nontrivial_flag (tree ctype, special_function_kind sfk)
437 case sfk_constructor:
438 TYPE_HAS_COMPLEX_DFLT (ctype) = true;
440 case sfk_copy_constructor:
441 TYPE_HAS_COMPLEX_COPY_CTOR (ctype) = true;
443 case sfk_move_constructor:
444 TYPE_HAS_COMPLEX_MOVE_CTOR (ctype) = true;
446 case sfk_copy_assignment:
447 TYPE_HAS_COMPLEX_COPY_ASSIGN (ctype) = true;
449 case sfk_move_assignment:
450 TYPE_HAS_COMPLEX_MOVE_ASSIGN (ctype) = true;
453 TYPE_HAS_NONTRIVIAL_DESTRUCTOR (ctype) = true;
460 /* True iff FN is a trivial defaulted member function ([cd]tor, op=). */
463 trivial_fn_p (tree fn)
465 if (!DECL_DEFAULTED_FN (fn))
468 /* If fn is a clone, get the primary variant. */
469 fn = DECL_ORIGIN (fn);
470 return type_has_trivial_fn (DECL_CONTEXT (fn), special_function_p (fn));
473 /* Generate code for default X(X&) or X(X&&) constructor. */
476 do_build_copy_constructor (tree fndecl)
478 tree parm = FUNCTION_FIRST_USER_PARM (fndecl);
479 bool move_p = DECL_MOVE_CONSTRUCTOR_P (fndecl);
480 bool trivial = trivial_fn_p (fndecl);
482 parm = convert_from_reference (parm);
485 && is_empty_class (current_class_type))
486 /* Don't copy the padding byte; it might not have been allocated
487 if *this is a base subobject. */;
490 tree t = build2 (INIT_EXPR, void_type_node, current_class_ref, parm);
491 finish_expr_stmt (t);
495 tree fields = TYPE_FIELDS (current_class_type);
496 tree member_init_list = NULL_TREE;
497 int cvquals = cp_type_quals (TREE_TYPE (parm));
499 tree binfo, base_binfo;
501 VEC(tree,gc) *vbases;
503 /* Initialize all the base-classes with the parameter converted
504 to their type so that we get their copy constructor and not
505 another constructor that takes current_class_type. We must
506 deal with the binfo's directly as a direct base might be
507 inaccessible due to ambiguity. */
508 for (vbases = CLASSTYPE_VBASECLASSES (current_class_type), i = 0;
509 VEC_iterate (tree, vbases, i, binfo); i++)
511 init = build_base_path (PLUS_EXPR, parm, binfo, 1);
516 build_tree_list (NULL_TREE, init),
520 for (binfo = TYPE_BINFO (current_class_type), i = 0;
521 BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
523 if (BINFO_VIRTUAL_P (base_binfo))
526 init = build_base_path (PLUS_EXPR, parm, base_binfo, 1);
530 = tree_cons (base_binfo,
531 build_tree_list (NULL_TREE, init),
535 for (; fields; fields = DECL_CHAIN (fields))
540 if (TREE_CODE (field) != FIELD_DECL)
543 expr_type = TREE_TYPE (field);
544 if (DECL_NAME (field))
546 if (VFIELD_NAME_P (DECL_NAME (field)))
549 else if (ANON_AGGR_TYPE_P (expr_type) && TYPE_FIELDS (expr_type))
550 /* Just use the field; anonymous types can't have
551 nontrivial copy ctors or assignment ops or this
552 function would be deleted. */;
556 /* Compute the type of "init->field". If the copy-constructor
557 parameter is, for example, "const S&", and the type of
558 the field is "T", then the type will usually be "const
559 T". (There are no cv-qualified variants of reference
561 if (TREE_CODE (expr_type) != REFERENCE_TYPE)
565 if (DECL_MUTABLE_P (field))
566 quals &= ~TYPE_QUAL_CONST;
567 quals |= cp_type_quals (expr_type);
568 expr_type = cp_build_qualified_type (expr_type, quals);
571 init = build3 (COMPONENT_REF, expr_type, parm, field, NULL_TREE);
572 if (move_p && TREE_CODE (expr_type) != REFERENCE_TYPE)
574 init = build_tree_list (NULL_TREE, init);
576 member_init_list = tree_cons (field, init, member_init_list);
578 finish_mem_initializers (member_init_list);
583 do_build_copy_assign (tree fndecl)
585 tree parm = DECL_CHAIN (DECL_ARGUMENTS (fndecl));
587 bool move_p = move_fn_p (fndecl);
588 bool trivial = trivial_fn_p (fndecl);
589 int flags = LOOKUP_NORMAL | LOOKUP_NONVIRTUAL | LOOKUP_DEFAULTED;
591 compound_stmt = begin_compound_stmt (0);
592 parm = convert_from_reference (parm);
595 && is_empty_class (current_class_type))
596 /* Don't copy the padding byte; it might not have been allocated
597 if *this is a base subobject. */;
600 tree t = build2 (MODIFY_EXPR, void_type_node, current_class_ref, parm);
601 finish_expr_stmt (t);
606 int cvquals = cp_type_quals (TREE_TYPE (parm));
608 tree binfo, base_binfo;
610 /* Assign to each of the direct base classes. */
611 for (binfo = TYPE_BINFO (current_class_type), i = 0;
612 BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
615 VEC(tree,gc) *parmvec;
617 /* We must convert PARM directly to the base class
618 explicitly since the base class may be ambiguous. */
619 converted_parm = build_base_path (PLUS_EXPR, parm, base_binfo, 1);
621 converted_parm = move (converted_parm);
622 /* Call the base class assignment operator. */
623 parmvec = make_tree_vector_single (converted_parm);
625 (build_special_member_call (current_class_ref,
626 ansi_assopname (NOP_EXPR),
630 tf_warning_or_error));
631 release_tree_vector (parmvec);
634 /* Assign to each of the non-static data members. */
635 for (fields = TYPE_FIELDS (current_class_type);
637 fields = DECL_CHAIN (fields))
639 tree comp = current_class_ref;
645 if (TREE_CODE (field) != FIELD_DECL || DECL_ARTIFICIAL (field))
648 expr_type = TREE_TYPE (field);
650 if (CP_TYPE_CONST_P (expr_type))
652 error ("non-static const member %q#D, can%'t use default "
653 "assignment operator", field);
656 else if (TREE_CODE (expr_type) == REFERENCE_TYPE)
658 error ("non-static reference member %q#D, can%'t use "
659 "default assignment operator", field);
663 if (DECL_NAME (field))
665 if (VFIELD_NAME_P (DECL_NAME (field)))
668 else if (ANON_AGGR_TYPE_P (expr_type)
669 && TYPE_FIELDS (expr_type) != NULL_TREE)
670 /* Just use the field; anonymous types can't have
671 nontrivial copy ctors or assignment ops or this
672 function would be deleted. */;
676 comp = build3 (COMPONENT_REF, expr_type, comp, field, NULL_TREE);
678 /* Compute the type of init->field */
680 if (DECL_MUTABLE_P (field))
681 quals &= ~TYPE_QUAL_CONST;
682 expr_type = cp_build_qualified_type (expr_type, quals);
684 init = build3 (COMPONENT_REF, expr_type, init, field, NULL_TREE);
685 if (move_p && TREE_CODE (expr_type) != REFERENCE_TYPE)
688 if (DECL_NAME (field))
689 init = cp_build_modify_expr (comp, NOP_EXPR, init,
690 tf_warning_or_error);
692 init = build2 (MODIFY_EXPR, TREE_TYPE (comp), comp, init);
693 finish_expr_stmt (init);
696 finish_return_stmt (current_class_ref);
697 finish_compound_stmt (compound_stmt);
700 /* Synthesize FNDECL, a non-static member function. */
703 synthesize_method (tree fndecl)
705 bool nested = (current_function_decl != NULL_TREE);
706 tree context = decl_function_context (fndecl);
707 bool need_body = true;
709 location_t save_input_location = input_location;
710 int error_count = errorcount;
711 int warning_count = warningcount;
713 /* Reset the source location, we might have been previously
714 deferred, and thus have saved where we were first needed. */
715 DECL_SOURCE_LOCATION (fndecl)
716 = DECL_SOURCE_LOCATION (TYPE_NAME (DECL_CONTEXT (fndecl)));
718 /* If we've been asked to synthesize a clone, just synthesize the
719 cloned function instead. Doing so will automatically fill in the
720 body for the clone. */
721 if (DECL_CLONED_FUNCTION_P (fndecl))
722 fndecl = DECL_CLONED_FUNCTION (fndecl);
724 /* We may be in the middle of deferred access check. Disable
726 push_deferring_access_checks (dk_no_deferred);
729 push_to_top_level ();
731 push_function_context ();
733 input_location = DECL_SOURCE_LOCATION (fndecl);
735 start_preparsed_function (fndecl, NULL_TREE, SF_DEFAULT | SF_PRE_PARSED);
736 stmt = begin_function_body ();
738 if (DECL_OVERLOADED_OPERATOR_P (fndecl) == NOP_EXPR)
740 do_build_copy_assign (fndecl);
743 else if (DECL_CONSTRUCTOR_P (fndecl))
745 tree arg_chain = FUNCTION_FIRST_USER_PARMTYPE (fndecl);
746 if (arg_chain != void_list_node)
747 do_build_copy_constructor (fndecl);
749 finish_mem_initializers (NULL_TREE);
752 /* If we haven't yet generated the body of the function, just
753 generate an empty compound statement. */
757 compound_stmt = begin_compound_stmt (BCS_FN_BODY);
758 finish_compound_stmt (compound_stmt);
761 finish_function_body (stmt);
762 expand_or_defer_fn (finish_function (0));
764 input_location = save_input_location;
767 pop_from_top_level ();
769 pop_function_context ();
771 pop_deferring_access_checks ();
773 if (error_count != errorcount || warning_count != warningcount)
774 inform (input_location, "synthesized method %qD first required here ",
778 /* Build a reference to type TYPE with cv-quals QUALS, which is an
779 rvalue if RVALUE is true. */
782 build_stub_type (tree type, int quals, bool rvalue)
784 tree argtype = cp_build_qualified_type (type, quals);
785 return cp_build_reference_type (argtype, rvalue);
788 /* Build a dummy glvalue from dereferencing a dummy reference of type
792 build_stub_object (tree reftype)
794 tree stub = build1 (NOP_EXPR, reftype, integer_one_node);
795 return convert_from_reference (stub);
798 /* Determine which function will be called when looking up NAME in TYPE,
799 called with a single ARGTYPE argument, or no argument if ARGTYPE is
800 null. FLAGS and COMPLAIN are as for build_new_method_call.
802 Returns a FUNCTION_DECL if all is well.
803 Returns NULL_TREE if overload resolution failed.
804 Returns error_mark_node if the chosen function cannot be called. */
807 locate_fn_flags (tree type, tree name, tree argtype, int flags,
808 tsubst_flags_t complain)
810 tree ob, fn, fns, binfo, rval;
814 binfo = TYPE_BINFO (type);
818 type = BINFO_TYPE (binfo);
821 ob = build_stub_object (cp_build_reference_type (type, false));
822 args = make_tree_vector ();
825 tree arg = build_stub_object (argtype);
826 VEC_quick_push (tree, args, arg);
829 fns = lookup_fnfields (binfo, name, 0);
830 rval = build_new_method_call (ob, fns, &args, binfo, flags, &fn, complain);
832 release_tree_vector (args);
833 if (fn && rval == error_mark_node)
839 /* Locate the dtor of TYPE. */
844 tree fn = locate_fn_flags (type, complete_dtor_identifier, NULL_TREE,
845 LOOKUP_NORMAL, tf_warning_or_error);
846 if (fn == error_mark_node)
851 /* Locate the default ctor of TYPE. */
854 locate_ctor (tree type)
858 push_deferring_access_checks (dk_no_check);
859 fn = locate_fn_flags (type, complete_ctor_identifier, NULL_TREE,
860 LOOKUP_SPECULATIVE, tf_none);
861 pop_deferring_access_checks ();
862 if (fn == error_mark_node)
867 /* Likewise, but give any appropriate errors. */
870 get_default_ctor (tree type)
872 tree fn = locate_fn_flags (type, complete_ctor_identifier, NULL_TREE,
873 LOOKUP_NORMAL, tf_warning_or_error);
874 if (fn == error_mark_node)
879 /* Locate the copy ctor of TYPE. */
882 get_copy_ctor (tree type)
884 int quals = (TYPE_HAS_CONST_COPY_CTOR (type)
885 ? TYPE_QUAL_CONST : TYPE_UNQUALIFIED);
886 tree argtype = build_stub_type (type, quals, false);
887 tree fn = locate_fn_flags (type, complete_ctor_identifier, argtype,
888 LOOKUP_NORMAL, tf_warning_or_error);
889 if (fn == error_mark_node)
894 /* Locate the copy assignment operator of TYPE. */
897 get_copy_assign (tree type)
899 int quals = (TYPE_HAS_CONST_COPY_ASSIGN (type)
900 ? TYPE_QUAL_CONST : TYPE_UNQUALIFIED);
901 tree argtype = build_stub_type (type, quals, false);
902 tree fn = locate_fn_flags (type, ansi_assopname (NOP_EXPR), argtype,
903 LOOKUP_NORMAL, tf_warning_or_error);
904 if (fn == error_mark_node)
909 /* Subroutine of synthesized_method_walk. Update SPEC_P, TRIVIAL_P and
910 DELETED_P or give an error message MSG with argument ARG. */
913 process_subob_fn (tree fn, bool move_p, tree *spec_p, bool *trivial_p,
914 bool *deleted_p, bool *constexpr_p,
915 const char *msg, tree arg)
917 if (!fn || fn == error_mark_node)
922 tree raises = TYPE_RAISES_EXCEPTIONS (TREE_TYPE (fn));
923 *spec_p = merge_exception_specifiers (*spec_p, raises);
926 if (!trivial_fn_p (fn))
930 if (TREE_CODE (arg) == FIELD_DECL
931 && TREE_CODE (DECL_CONTEXT (arg)) == UNION_TYPE)
936 error ("union member %q+D with non-trivial %qD", arg, fn);
940 if (move_p && !move_fn_p (fn) && !trivial_fn_p (fn))
949 /* If this is a specialization of a constexpr template, we need to
950 force the instantiation now so that we know whether or not it's
952 if (DECL_DECLARED_CONSTEXPR_P (fn) && DECL_TEMPLATE_INSTANTIATION (fn)
953 && !DECL_TEMPLATE_INSTANTIATED (fn))
954 instantiate_decl (fn, /*defer_ok*/false, /*expl_class*/false);
955 if (!DECL_DECLARED_CONSTEXPR_P (fn))
956 *constexpr_p = false;
966 /* Subroutine of synthesized_method_walk to allow recursion into anonymous
970 walk_field_subobs (tree fields, tree fnname, special_function_kind sfk,
971 int quals, bool copy_arg_p, bool move_p,
972 bool assign_p, tree *spec_p, bool *trivial_p,
973 bool *deleted_p, bool *constexpr_p, const char *msg,
974 int flags, tsubst_flags_t complain)
977 for (field = fields; field; field = DECL_CHAIN (field))
979 tree mem_type, argtype, rval;
981 if (TREE_CODE (field) != FIELD_DECL
982 || DECL_ARTIFICIAL (field))
985 mem_type = strip_array_types (TREE_TYPE (field));
989 if (CP_TYPE_CONST_P (mem_type) && !CLASS_TYPE_P (mem_type))
992 error ("non-static const member %q#D, can%'t use default "
993 "assignment operator", field);
995 else if (TREE_CODE (mem_type) == REFERENCE_TYPE)
998 error ("non-static reference member %q#D, can%'t use "
999 "default assignment operator", field);
1004 if (bad && deleted_p)
1007 else if (sfk == sfk_constructor)
1010 if (CP_TYPE_CONST_P (mem_type)
1011 && (!CLASS_TYPE_P (mem_type)
1012 || !type_has_user_provided_default_constructor (mem_type)))
1015 error ("uninitialized non-static const member %q#D",
1018 else if (TREE_CODE (mem_type) == REFERENCE_TYPE)
1021 error ("uninitialized non-static reference member %q#D",
1027 if (bad && deleted_p)
1030 /* For an implicitly-defined default constructor to be constexpr,
1031 every member must have a user-provided default constructor. */
1032 /* FIXME will need adjustment for non-static data member
1034 if (constexpr_p && !CLASS_TYPE_P (mem_type))
1035 *constexpr_p = false;
1038 if (!CLASS_TYPE_P (mem_type))
1041 if (ANON_AGGR_TYPE_P (mem_type))
1043 walk_field_subobs (TYPE_FIELDS (mem_type), fnname, sfk, quals,
1044 copy_arg_p, move_p, assign_p, spec_p, trivial_p,
1045 deleted_p, constexpr_p, msg, flags, complain);
1051 int mem_quals = cp_type_quals (mem_type) | quals;
1052 if (DECL_MUTABLE_P (field))
1053 mem_quals &= ~TYPE_QUAL_CONST;
1054 argtype = build_stub_type (mem_type, mem_quals, move_p);
1057 argtype = NULL_TREE;
1059 rval = locate_fn_flags (mem_type, fnname, argtype, flags, complain);
1061 process_subob_fn (rval, move_p, spec_p, trivial_p, deleted_p,
1062 constexpr_p, msg, field);
1066 /* The caller wants to generate an implicit declaration of SFK for CTYPE
1067 which is const if relevant and CONST_P is set. If spec_p, trivial_p and
1068 deleted_p are non-null, set their referent appropriately. If diag is
1069 true, we're being called from maybe_explain_implicit_delete to give
1073 synthesized_method_walk (tree ctype, special_function_kind sfk, bool const_p,
1074 tree *spec_p, bool *trivial_p, bool *deleted_p,
1075 bool *constexpr_p, bool diag)
1077 tree binfo, base_binfo, scope, fnname, rval, argtype;
1078 bool move_p, copy_arg_p, assign_p, expected_trivial, check_vdtor;
1079 VEC(tree,gc) *vbases;
1080 int i, quals, flags;
1081 tsubst_flags_t complain;
1086 *spec_p = (cxx_dialect >= cxx0x ? noexcept_true_spec : empty_except_spec);
1090 /* "The closure type associated with a lambda-expression has a deleted
1091 default constructor and a deleted copy assignment operator."
1092 This is diagnosed in maybe_explain_implicit_delete. */
1093 if (LAMBDA_TYPE_P (ctype)
1094 && (sfk == sfk_constructor
1095 || sfk == sfk_copy_assignment))
1106 check_vdtor = false;
1109 case sfk_move_assignment:
1110 case sfk_copy_assignment:
1112 fnname = ansi_assopname (NOP_EXPR);
1115 case sfk_destructor:
1117 /* The synthesized method will call base dtors, but check complete
1118 here to avoid having to deal with VTT. */
1119 fnname = complete_dtor_identifier;
1122 case sfk_constructor:
1123 case sfk_move_constructor:
1124 case sfk_copy_constructor:
1126 fnname = complete_ctor_identifier;
1133 /* If that user-written default constructor would satisfy the
1134 requirements of a constexpr constructor (7.1.5), the
1135 implicitly-defined default constructor is constexpr. */
1137 *constexpr_p = ctor_p;
1142 case sfk_constructor:
1143 case sfk_destructor:
1147 case sfk_move_constructor:
1148 case sfk_move_assignment:
1150 case sfk_copy_constructor:
1151 case sfk_copy_assignment:
1159 expected_trivial = type_has_trivial_fn (ctype, sfk);
1161 *trivial_p = expected_trivial;
1163 /* The TYPE_HAS_COMPLEX_* flags tell us about constraints from base
1164 class versions and other properties of the type. But a subobject
1165 class can be trivially copyable and yet have overload resolution
1166 choose a template constructor for initialization, depending on
1167 rvalueness and cv-quals. So we can't exit early for copy/move
1168 methods in C++0x. The same considerations apply in C++98/03, but
1169 there the definition of triviality does not consider overload
1170 resolution, so a constructor can be trivial even if it would otherwise
1171 call a non-trivial constructor. */
1172 if (expected_trivial
1173 && (!copy_arg_p || cxx_dialect < cxx0x))
1175 if (constexpr_p && sfk == sfk_constructor)
1176 *constexpr_p = synthesized_default_constructor_is_constexpr (ctype);
1180 ++cp_unevaluated_operand;
1181 ++c_inhibit_evaluation_warnings;
1183 scope = push_scope (ctype);
1187 flags = LOOKUP_NORMAL|LOOKUP_SPECULATIVE|LOOKUP_DEFAULTED;
1188 complain = tf_warning_or_error;
1192 flags = LOOKUP_PROTECT|LOOKUP_SPECULATIVE|LOOKUP_DEFAULTED;
1197 quals = TYPE_QUAL_CONST;
1199 quals = TYPE_UNQUALIFIED;
1200 argtype = NULL_TREE;
1205 msg = ("base %qT does not have a move assignment operator or trivial "
1206 "copy assignment operator");
1208 msg = ("base %qT does not have a move constructor or trivial "
1209 "copy constructor");
1211 for (binfo = TYPE_BINFO (ctype), i = 0;
1212 BINFO_BASE_ITERATE (binfo, i, base_binfo); ++i)
1214 tree basetype = BINFO_TYPE (base_binfo);
1216 argtype = build_stub_type (basetype, quals, move_p);
1217 rval = locate_fn_flags (base_binfo, fnname, argtype, flags, complain);
1219 process_subob_fn (rval, move_p, spec_p, trivial_p, deleted_p,
1220 constexpr_p, msg, basetype);
1221 if (ctor_p && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (basetype))
1223 /* In a constructor we also need to check the subobject
1224 destructors for cleanup of partially constructed objects. */
1225 rval = locate_fn_flags (base_binfo, complete_dtor_identifier,
1226 NULL_TREE, flags, complain);
1227 /* Note that we don't pass down trivial_p; the subobject
1228 destructors don't affect triviality of the constructor. */
1229 process_subob_fn (rval, false, spec_p, NULL,
1230 deleted_p, NULL, NULL,
1234 if (check_vdtor && type_has_virtual_destructor (basetype))
1236 rval = locate_fn_flags (ctype, ansi_opname (DELETE_EXPR),
1237 ptr_type_node, flags, complain);
1238 /* Unlike for base ctor/op=/dtor, for operator delete it's fine
1239 to have a null rval (no class-specific op delete). */
1240 if (rval && rval == error_mark_node && deleted_p)
1242 check_vdtor = false;
1246 vbases = CLASSTYPE_VBASECLASSES (ctype);
1247 if (vbases && assign_p && move_p)
1249 /* Should the spec be changed to allow vbases that only occur once? */
1251 error ("%qT has virtual bases, default move assignment operator "
1252 "cannot be generated", ctype);
1259 msg = ("virtual base %qT does not have a move constructor "
1260 "or trivial copy constructor");
1261 if (vbases && constexpr_p)
1262 *constexpr_p = false;
1263 FOR_EACH_VEC_ELT (tree, vbases, i, base_binfo)
1265 tree basetype = BINFO_TYPE (base_binfo);
1267 argtype = build_stub_type (basetype, quals, move_p);
1268 rval = locate_fn_flags (base_binfo, fnname, argtype, flags, complain);
1270 process_subob_fn (rval, move_p, spec_p, trivial_p, deleted_p,
1271 constexpr_p, msg, basetype);
1272 if (ctor_p && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (basetype))
1274 rval = locate_fn_flags (base_binfo, complete_dtor_identifier,
1275 NULL_TREE, flags, complain);
1276 process_subob_fn (rval, false, spec_p, NULL,
1277 deleted_p, NULL, NULL,
1283 /* Leave msg null. */;
1285 msg = ("non-static data member %qD does not have a move "
1286 "assignment operator or trivial copy assignment operator");
1288 msg = ("non-static data member %qD does not have a move "
1289 "constructor or trivial copy constructor");
1290 walk_field_subobs (TYPE_FIELDS (ctype), fnname, sfk, quals,
1291 copy_arg_p, move_p, assign_p, spec_p, trivial_p,
1292 deleted_p, constexpr_p, msg, flags, complain);
1294 walk_field_subobs (TYPE_FIELDS (ctype), complete_dtor_identifier,
1295 sfk_destructor, TYPE_UNQUALIFIED, false,
1296 false, false, spec_p, NULL,
1298 NULL, flags, complain);
1302 --cp_unevaluated_operand;
1303 --c_inhibit_evaluation_warnings;
1306 /* DECL is a deleted function. If it's implicitly deleted, explain why and
1307 return true; else return false. */
1310 maybe_explain_implicit_delete (tree decl)
1312 /* If decl is a clone, get the primary variant. */
1313 decl = DECL_ORIGIN (decl);
1314 gcc_assert (DECL_DELETED_FN (decl));
1315 if (DECL_DEFAULTED_FN (decl))
1317 /* Not marked GTY; it doesn't need to be GC'd or written to PCH. */
1318 static htab_t explained_htab;
1321 special_function_kind sfk;
1326 if (!explained_htab)
1327 explained_htab = htab_create (37, htab_hash_pointer,
1328 htab_eq_pointer, NULL);
1329 slot = htab_find_slot (explained_htab, decl, INSERT);
1334 sfk = special_function_p (decl);
1335 ctype = DECL_CONTEXT (decl);
1336 loc = input_location;
1337 input_location = DECL_SOURCE_LOCATION (decl);
1340 if (LAMBDA_TYPE_P (ctype))
1343 if (sfk == sfk_constructor)
1344 error ("a lambda closure type has a deleted default constructor");
1345 else if (sfk == sfk_copy_assignment)
1346 error ("a lambda closure type has a deleted copy assignment operator");
1352 tree parm_type = TREE_VALUE (FUNCTION_FIRST_USER_PARMTYPE (decl));
1353 bool const_p = CP_TYPE_CONST_P (non_reference (parm_type));
1354 tree scope = push_scope (ctype);
1355 error ("%qD is implicitly deleted because the default "
1356 "definition would be ill-formed:", decl);
1358 synthesized_method_walk (ctype, sfk, const_p,
1359 NULL, NULL, NULL, NULL, true);
1362 input_location = loc;
1368 /* Implicitly declare the special function indicated by KIND, as a
1369 member of TYPE. For copy constructors and assignment operators,
1370 CONST_P indicates whether these functions should take a const
1371 reference argument or a non-const reference. Returns the
1372 FUNCTION_DECL for the implicitly declared function. */
1375 implicitly_declare_fn (special_function_kind kind, tree type, bool const_p)
1378 tree parameter_types = void_list_node;
1381 tree raises = empty_except_spec;
1382 tree rhs_parm_type = NULL_TREE;
1385 HOST_WIDE_INT saved_processing_template_decl;
1390 /* Because we create declarations for implicitly declared functions
1391 lazily, we may be creating the declaration for a member of TYPE
1392 while in some completely different context. However, TYPE will
1393 never be a dependent class (because we never want to do lookups
1394 for implicitly defined functions in a dependent class).
1395 Furthermore, we must set PROCESSING_TEMPLATE_DECL to zero here
1396 because we only create clones for constructors and destructors
1397 when not in a template. */
1398 gcc_assert (!dependent_type_p (type));
1399 saved_processing_template_decl = processing_template_decl;
1400 processing_template_decl = 0;
1402 type = TYPE_MAIN_VARIANT (type);
1404 if (targetm.cxx.cdtor_returns_this () && !TYPE_FOR_JAVA (type))
1406 if (kind == sfk_destructor)
1407 /* See comment in check_special_function_return_type. */
1408 return_type = build_pointer_type (void_type_node);
1410 return_type = build_pointer_type (type);
1413 return_type = void_type_node;
1417 case sfk_destructor:
1419 name = constructor_name (type);
1422 case sfk_constructor:
1423 /* Default constructor. */
1424 name = constructor_name (type);
1427 case sfk_copy_constructor:
1428 case sfk_copy_assignment:
1429 case sfk_move_constructor:
1430 case sfk_move_assignment:
1433 if (kind == sfk_copy_assignment
1434 || kind == sfk_move_assignment)
1436 return_type = build_reference_type (type);
1437 name = ansi_assopname (NOP_EXPR);
1440 name = constructor_name (type);
1443 rhs_parm_type = cp_build_qualified_type (type, TYPE_QUAL_CONST);
1445 rhs_parm_type = type;
1446 move_p = (kind == sfk_move_assignment
1447 || kind == sfk_move_constructor);
1448 rhs_parm_type = cp_build_reference_type (rhs_parm_type, move_p);
1450 parameter_types = tree_cons (NULL_TREE, rhs_parm_type, parameter_types);
1457 synthesized_method_walk (type, kind, const_p, &raises, &trivial_p,
1458 &deleted_p, &constexpr_p, false);
1459 /* Don't bother marking a deleted constructor as constexpr. */
1461 constexpr_p = false;
1462 /* A trivial copy/move constructor is also a constexpr constructor. */
1463 else if (trivial_p && cxx_dialect >= cxx0x
1464 && (kind == sfk_copy_constructor
1465 || kind == sfk_move_constructor))
1466 gcc_assert (constexpr_p);
1468 if (!trivial_p && type_has_trivial_fn (type, kind))
1469 type_set_nontrivial_flag (type, kind);
1471 /* Create the function. */
1472 fn_type = build_method_type_directly (type, return_type, parameter_types);
1474 fn_type = build_exception_variant (fn_type, raises);
1475 fn = build_lang_decl (FUNCTION_DECL, name, fn_type);
1476 DECL_SOURCE_LOCATION (fn) = DECL_SOURCE_LOCATION (TYPE_NAME (type));
1477 if (kind == sfk_constructor || kind == sfk_copy_constructor
1478 || kind == sfk_move_constructor)
1479 DECL_CONSTRUCTOR_P (fn) = 1;
1480 else if (kind == sfk_destructor)
1481 DECL_DESTRUCTOR_P (fn) = 1;
1484 DECL_ASSIGNMENT_OPERATOR_P (fn) = 1;
1485 SET_OVERLOADED_OPERATOR_CODE (fn, NOP_EXPR);
1488 /* If pointers to member functions use the least significant bit to
1489 indicate whether a function is virtual, ensure a pointer
1490 to this function will have that bit clear. */
1491 if (TARGET_PTRMEMFUNC_VBIT_LOCATION == ptrmemfunc_vbit_in_pfn
1492 && DECL_ALIGN (fn) < 2 * BITS_PER_UNIT)
1493 DECL_ALIGN (fn) = 2 * BITS_PER_UNIT;
1495 /* Create the explicit arguments. */
1498 /* Note that this parameter is *not* marked DECL_ARTIFICIAL; we
1499 want its type to be included in the mangled function
1501 DECL_ARGUMENTS (fn) = cp_build_parm_decl (NULL_TREE, rhs_parm_type);
1502 TREE_READONLY (DECL_ARGUMENTS (fn)) = 1;
1504 /* Add the "this" parameter. */
1505 this_parm = build_this_parm (fn_type, TYPE_UNQUALIFIED);
1506 DECL_CHAIN (this_parm) = DECL_ARGUMENTS (fn);
1507 DECL_ARGUMENTS (fn) = this_parm;
1509 grokclassfn (type, fn, kind == sfk_destructor ? DTOR_FLAG : NO_SPECIAL);
1510 set_linkage_according_to_type (type, fn);
1511 rest_of_decl_compilation (fn, toplevel_bindings_p (), at_eof);
1512 DECL_IN_AGGR_P (fn) = 1;
1513 DECL_ARTIFICIAL (fn) = 1;
1514 DECL_DEFAULTED_FN (fn) = 1;
1515 if (cxx_dialect >= cxx0x)
1517 DECL_DELETED_FN (fn) = deleted_p;
1518 DECL_DECLARED_CONSTEXPR_P (fn) = constexpr_p;
1520 DECL_NOT_REALLY_EXTERN (fn) = 1;
1521 DECL_DECLARED_INLINE_P (fn) = 1;
1522 gcc_assert (!TREE_USED (fn));
1524 /* Restore PROCESSING_TEMPLATE_DECL. */
1525 processing_template_decl = saved_processing_template_decl;
1530 /* Gives any errors about defaulted functions which need to be deferred
1531 until the containing class is complete. */
1534 defaulted_late_check (tree fn)
1536 /* Complain about invalid signature for defaulted fn. */
1537 tree ctx = DECL_CONTEXT (fn);
1538 special_function_kind kind = special_function_p (fn);
1539 bool fn_const_p = (copy_fn_p (fn) == 2);
1540 tree implicit_fn = implicitly_declare_fn (kind, ctx, fn_const_p);
1542 if (!same_type_p (TREE_TYPE (TREE_TYPE (fn)),
1543 TREE_TYPE (TREE_TYPE (implicit_fn)))
1544 || !compparms (TYPE_ARG_TYPES (TREE_TYPE (fn)),
1545 TYPE_ARG_TYPES (TREE_TYPE (implicit_fn))))
1547 error ("defaulted declaration %q+D", fn);
1548 error_at (DECL_SOURCE_LOCATION (fn),
1549 "does not match expected signature %qD", implicit_fn);
1552 /* 8.4.2/2: If it is explicitly defaulted on its first declaration, it is
1553 implicitly considered to have the same exception-specification as if
1554 it had been implicitly declared. */
1555 if (DECL_DEFAULTED_IN_CLASS_P (fn))
1557 tree eh_spec = TYPE_RAISES_EXCEPTIONS (TREE_TYPE (implicit_fn));
1558 if (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (fn))
1559 && !comp_except_specs (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (fn)),
1560 eh_spec, ce_normal))
1561 error ("function %q+D defaulted on its first declaration "
1562 "with an exception-specification that differs from "
1563 "the implicit declaration %q#D", fn, implicit_fn);
1564 TREE_TYPE (fn) = build_exception_variant (TREE_TYPE (fn), eh_spec);
1565 if (DECL_DECLARED_CONSTEXPR_P (implicit_fn))
1566 /* Hmm...should we do this for out-of-class too? Should it be OK to
1567 add constexpr later like inline, rather than requiring
1568 declarations to match? */
1569 DECL_DECLARED_CONSTEXPR_P (fn) = true;
1572 if (!DECL_DECLARED_CONSTEXPR_P (implicit_fn)
1573 && DECL_DECLARED_CONSTEXPR_P (fn))
1575 if (!CLASSTYPE_TEMPLATE_INSTANTIATION (ctx))
1576 error ("%qD cannot be declared as constexpr", fn);
1577 DECL_DECLARED_CONSTEXPR_P (fn) = false;
1580 if (DECL_DELETED_FN (implicit_fn))
1581 DECL_DELETED_FN (fn) = 1;
1584 /* Returns true iff FN can be explicitly defaulted, and gives any
1585 errors if defaulting FN is ill-formed. */
1588 defaultable_fn_check (tree fn)
1590 special_function_kind kind = sfk_none;
1592 if (template_parm_scope_p ())
1594 error ("a template cannot be defaulted");
1598 if (DECL_CONSTRUCTOR_P (fn))
1600 if (FUNCTION_FIRST_USER_PARMTYPE (fn) == void_list_node)
1601 kind = sfk_constructor;
1602 else if (copy_fn_p (fn) > 0
1603 && (TREE_CHAIN (FUNCTION_FIRST_USER_PARMTYPE (fn))
1605 kind = sfk_copy_constructor;
1606 else if (move_fn_p (fn))
1607 kind = sfk_move_constructor;
1609 else if (DECL_DESTRUCTOR_P (fn))
1610 kind = sfk_destructor;
1611 else if (DECL_ASSIGNMENT_OPERATOR_P (fn)
1612 && DECL_OVERLOADED_OPERATOR_P (fn) == NOP_EXPR)
1615 kind = sfk_copy_assignment;
1616 else if (move_fn_p (fn))
1617 kind = sfk_move_assignment;
1620 if (kind == sfk_none)
1622 error ("%qD cannot be defaulted", fn);
1627 tree t = FUNCTION_FIRST_USER_PARMTYPE (fn);
1628 for (; t && t != void_list_node; t = TREE_CHAIN (t))
1629 if (TREE_PURPOSE (t))
1631 error ("defaulted function %q+D with default argument", fn);
1634 if (TYPE_BEING_DEFINED (DECL_CONTEXT (fn)))
1635 /* Defer checking. */;
1636 else if (!processing_template_decl)
1637 defaulted_late_check (fn);
1643 /* Add an implicit declaration to TYPE for the kind of function
1644 indicated by SFK. Return the FUNCTION_DECL for the new implicit
1648 lazily_declare_fn (special_function_kind sfk, tree type)
1651 /* Whether or not the argument has a const reference type. */
1652 bool const_p = false;
1656 case sfk_constructor:
1657 CLASSTYPE_LAZY_DEFAULT_CTOR (type) = 0;
1659 case sfk_copy_constructor:
1660 const_p = TYPE_HAS_CONST_COPY_CTOR (type);
1661 CLASSTYPE_LAZY_COPY_CTOR (type) = 0;
1663 case sfk_move_constructor:
1664 CLASSTYPE_LAZY_MOVE_CTOR (type) = 0;
1666 case sfk_copy_assignment:
1667 const_p = TYPE_HAS_CONST_COPY_ASSIGN (type);
1668 CLASSTYPE_LAZY_COPY_ASSIGN (type) = 0;
1670 case sfk_move_assignment:
1671 CLASSTYPE_LAZY_MOVE_ASSIGN (type) = 0;
1673 case sfk_destructor:
1674 CLASSTYPE_LAZY_DESTRUCTOR (type) = 0;
1680 /* Declare the function. */
1681 fn = implicitly_declare_fn (sfk, type, const_p);
1683 /* For move variants, rather than declare them as deleted we just
1684 don't declare them at all. */
1685 if (DECL_DELETED_FN (fn)
1686 && (sfk == sfk_move_constructor
1687 || sfk == sfk_move_assignment))
1690 /* A destructor may be virtual. */
1691 if (sfk == sfk_destructor
1692 || sfk == sfk_move_assignment
1693 || sfk == sfk_copy_assignment)
1694 check_for_override (fn, type);
1695 /* Add it to CLASSTYPE_METHOD_VEC. */
1696 add_method (type, fn, NULL_TREE);
1697 /* Add it to TYPE_METHODS. */
1698 if (sfk == sfk_destructor
1699 && DECL_VIRTUAL_P (fn)
1700 && abi_version_at_least (2))
1701 /* The ABI requires that a virtual destructor go at the end of the
1703 TYPE_METHODS (type) = chainon (TYPE_METHODS (type), fn);
1706 /* G++ 3.2 put the implicit destructor at the *beginning* of the
1707 TYPE_METHODS list, which cause the destructor to be emitted
1708 in an incorrect location in the vtable. */
1709 if (warn_abi && sfk == sfk_destructor && DECL_VIRTUAL_P (fn))
1710 warning (OPT_Wabi, "vtable layout for class %qT may not be ABI-compliant"
1711 "and may change in a future version of GCC due to "
1712 "implicit virtual destructor",
1714 DECL_CHAIN (fn) = TYPE_METHODS (type);
1715 TYPE_METHODS (type) = fn;
1717 maybe_add_class_template_decl_list (type, fn, /*friend_p=*/0);
1718 if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (fn)
1719 || DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (fn))
1720 /* Create appropriate clones. */
1721 clone_function_decl (fn, /*update_method_vec=*/true);
1726 /* Given a FUNCTION_DECL FN and a chain LIST, skip as many elements of LIST
1727 as there are artificial parms in FN. */
1730 skip_artificial_parms_for (const_tree fn, tree list)
1732 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fn))
1733 list = TREE_CHAIN (list);
1737 if (DECL_HAS_IN_CHARGE_PARM_P (fn))
1738 list = TREE_CHAIN (list);
1739 if (DECL_HAS_VTT_PARM_P (fn))
1740 list = TREE_CHAIN (list);
1744 /* Given a FUNCTION_DECL FN and a chain LIST, return the number of
1745 artificial parms in FN. */
1748 num_artificial_parms_for (const_tree fn)
1752 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fn))
1757 if (DECL_HAS_IN_CHARGE_PARM_P (fn))
1759 if (DECL_HAS_VTT_PARM_P (fn))
1765 #include "gt-cp-method.h"