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 "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 *funcn, *aliasn;
263 funcn = cgraph_get_node (function);
264 gcc_checking_assert (funcn);
265 aliasn = cgraph_same_body_alias (funcn, alias, function);
266 DECL_ASSEMBLER_NAME (function);
267 gcc_assert (aliasn != NULL);
273 /* Emit the definition of a C++ multiple inheritance or covariant
274 return vtable thunk. If EMIT_P is nonzero, the thunk is emitted
278 use_thunk (tree thunk_fndecl, bool emit_p)
280 tree a, t, function, alias;
282 HOST_WIDE_INT fixed_offset, virtual_value;
283 bool this_adjusting = DECL_THIS_THUNK_P (thunk_fndecl);
284 struct cgraph_node *funcn;
286 /* We should have called finish_thunk to give it a name. */
287 gcc_assert (DECL_NAME (thunk_fndecl));
289 /* We should never be using an alias, always refer to the
291 gcc_assert (!THUNK_ALIAS (thunk_fndecl));
293 if (TREE_ASM_WRITTEN (thunk_fndecl))
296 function = THUNK_TARGET (thunk_fndecl);
297 if (DECL_RESULT (thunk_fndecl))
298 /* We already turned this thunk into an ordinary function.
299 There's no need to process this thunk again. */
302 if (DECL_THUNK_P (function))
303 /* The target is itself a thunk, process it now. */
304 use_thunk (function, emit_p);
306 /* Thunks are always addressable; they only appear in vtables. */
307 TREE_ADDRESSABLE (thunk_fndecl) = 1;
309 /* Figure out what function is being thunked to. It's referenced in
310 this translation unit. */
311 TREE_ADDRESSABLE (function) = 1;
312 mark_used (function);
316 if (TARGET_USE_LOCAL_THUNK_ALIAS_P (function))
317 alias = make_alias_for_thunk (function);
321 fixed_offset = THUNK_FIXED_OFFSET (thunk_fndecl);
322 virtual_offset = THUNK_VIRTUAL_OFFSET (thunk_fndecl);
327 virtual_offset = BINFO_VPTR_FIELD (virtual_offset);
328 virtual_value = tree_low_cst (virtual_offset, /*pos=*/0);
329 gcc_assert (virtual_value);
334 /* And, if we need to emit the thunk, it's used. */
335 mark_used (thunk_fndecl);
336 /* This thunk is actually defined. */
337 DECL_EXTERNAL (thunk_fndecl) = 0;
338 /* The linkage of the function may have changed. FIXME in linkage
340 TREE_PUBLIC (thunk_fndecl) = TREE_PUBLIC (function);
341 DECL_VISIBILITY (thunk_fndecl) = DECL_VISIBILITY (function);
342 DECL_VISIBILITY_SPECIFIED (thunk_fndecl)
343 = DECL_VISIBILITY_SPECIFIED (function);
344 if (DECL_ONE_ONLY (function) || DECL_WEAK (function))
345 make_decl_one_only (thunk_fndecl, cxx_comdat_group (thunk_fndecl));
347 if (flag_syntax_only)
349 TREE_ASM_WRITTEN (thunk_fndecl) = 1;
353 push_to_top_level ();
355 if (TARGET_USE_LOCAL_THUNK_ALIAS_P (function)
356 && targetm.have_named_sections)
358 resolve_unique_section (function, 0, flag_function_sections);
360 if (DECL_SECTION_NAME (function) != NULL && DECL_ONE_ONLY (function))
362 resolve_unique_section (thunk_fndecl, 0, flag_function_sections);
364 /* Output the thunk into the same section as function. */
365 DECL_SECTION_NAME (thunk_fndecl) = DECL_SECTION_NAME (function);
369 /* Set up cloned argument trees for the thunk. */
371 for (a = DECL_ARGUMENTS (function); a; a = DECL_CHAIN (a))
373 tree x = copy_node (a);
375 DECL_CONTEXT (x) = thunk_fndecl;
376 SET_DECL_RTL (x, NULL);
377 DECL_HAS_VALUE_EXPR_P (x) = 0;
378 TREE_ADDRESSABLE (x) = 0;
382 DECL_ARGUMENTS (thunk_fndecl) = a;
383 TREE_ASM_WRITTEN (thunk_fndecl) = 1;
384 funcn = cgraph_get_node (function);
385 gcc_checking_assert (funcn);
386 cgraph_add_thunk (funcn, thunk_fndecl, function,
387 this_adjusting, fixed_offset, virtual_value,
388 virtual_offset, alias);
391 || !targetm.asm_out.can_output_mi_thunk (thunk_fndecl, fixed_offset,
392 virtual_value, alias))
394 /* If this is a covariant thunk, or we don't have the necessary
395 code for efficient thunks, generate a thunk function that
396 just makes a call to the real function. Unfortunately, this
397 doesn't work for varargs. */
399 if (varargs_function_p (function))
400 error ("generic thunk code fails for method %q#D which uses %<...%>",
404 pop_from_top_level ();
407 /* Code for synthesizing methods which have default semantics defined. */
409 /* True iff CTYPE has a trivial SFK. */
412 type_has_trivial_fn (tree ctype, special_function_kind sfk)
416 case sfk_constructor:
417 return !TYPE_HAS_COMPLEX_DFLT (ctype);
418 case sfk_copy_constructor:
419 return !TYPE_HAS_COMPLEX_COPY_CTOR (ctype);
420 case sfk_move_constructor:
421 return !TYPE_HAS_COMPLEX_MOVE_CTOR (ctype);
422 case sfk_copy_assignment:
423 return !TYPE_HAS_COMPLEX_COPY_ASSIGN (ctype);
424 case sfk_move_assignment:
425 return !TYPE_HAS_COMPLEX_MOVE_ASSIGN (ctype);
427 return !TYPE_HAS_NONTRIVIAL_DESTRUCTOR (ctype);
433 /* Note that CTYPE has a non-trivial SFK even though we previously thought
437 type_set_nontrivial_flag (tree ctype, special_function_kind sfk)
441 case sfk_constructor:
442 TYPE_HAS_COMPLEX_DFLT (ctype) = true;
444 case sfk_copy_constructor:
445 TYPE_HAS_COMPLEX_COPY_CTOR (ctype) = true;
447 case sfk_move_constructor:
448 TYPE_HAS_COMPLEX_MOVE_CTOR (ctype) = true;
450 case sfk_copy_assignment:
451 TYPE_HAS_COMPLEX_COPY_ASSIGN (ctype) = true;
453 case sfk_move_assignment:
454 TYPE_HAS_COMPLEX_MOVE_ASSIGN (ctype) = true;
457 TYPE_HAS_NONTRIVIAL_DESTRUCTOR (ctype) = true;
464 /* True iff FN is a trivial defaulted member function ([cd]tor, op=). */
467 trivial_fn_p (tree fn)
469 if (!DECL_DEFAULTED_FN (fn))
472 /* If fn is a clone, get the primary variant. */
473 fn = DECL_ORIGIN (fn);
474 return type_has_trivial_fn (DECL_CONTEXT (fn), special_function_p (fn));
477 /* Generate code for default X(X&) or X(X&&) constructor. */
480 do_build_copy_constructor (tree fndecl)
482 tree parm = FUNCTION_FIRST_USER_PARM (fndecl);
483 bool move_p = DECL_MOVE_CONSTRUCTOR_P (fndecl);
484 bool trivial = trivial_fn_p (fndecl);
486 parm = convert_from_reference (parm);
489 && is_empty_class (current_class_type))
490 /* Don't copy the padding byte; it might not have been allocated
491 if *this is a base subobject. */;
494 tree t = build2 (INIT_EXPR, void_type_node, current_class_ref, parm);
495 finish_expr_stmt (t);
499 tree fields = TYPE_FIELDS (current_class_type);
500 tree member_init_list = NULL_TREE;
501 int cvquals = cp_type_quals (TREE_TYPE (parm));
503 tree binfo, base_binfo;
505 VEC(tree,gc) *vbases;
507 /* Initialize all the base-classes with the parameter converted
508 to their type so that we get their copy constructor and not
509 another constructor that takes current_class_type. We must
510 deal with the binfo's directly as a direct base might be
511 inaccessible due to ambiguity. */
512 for (vbases = CLASSTYPE_VBASECLASSES (current_class_type), i = 0;
513 VEC_iterate (tree, vbases, i, binfo); i++)
515 init = build_base_path (PLUS_EXPR, parm, binfo, 1);
520 build_tree_list (NULL_TREE, init),
524 for (binfo = TYPE_BINFO (current_class_type), i = 0;
525 BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
527 if (BINFO_VIRTUAL_P (base_binfo))
530 init = build_base_path (PLUS_EXPR, parm, base_binfo, 1);
534 = tree_cons (base_binfo,
535 build_tree_list (NULL_TREE, init),
539 for (; fields; fields = DECL_CHAIN (fields))
544 if (TREE_CODE (field) != FIELD_DECL)
547 expr_type = TREE_TYPE (field);
548 if (DECL_NAME (field))
550 if (VFIELD_NAME_P (DECL_NAME (field)))
553 else if (ANON_AGGR_TYPE_P (expr_type) && TYPE_FIELDS (expr_type))
554 /* Just use the field; anonymous types can't have
555 nontrivial copy ctors or assignment ops or this
556 function would be deleted. */;
560 /* Compute the type of "init->field". If the copy-constructor
561 parameter is, for example, "const S&", and the type of
562 the field is "T", then the type will usually be "const
563 T". (There are no cv-qualified variants of reference
565 if (TREE_CODE (expr_type) != REFERENCE_TYPE)
569 if (DECL_MUTABLE_P (field))
570 quals &= ~TYPE_QUAL_CONST;
571 quals |= cp_type_quals (expr_type);
572 expr_type = cp_build_qualified_type (expr_type, quals);
575 init = build3 (COMPONENT_REF, expr_type, parm, field, NULL_TREE);
576 if (move_p && TREE_CODE (expr_type) != REFERENCE_TYPE)
578 init = build_tree_list (NULL_TREE, init);
580 member_init_list = tree_cons (field, init, member_init_list);
582 finish_mem_initializers (member_init_list);
587 do_build_copy_assign (tree fndecl)
589 tree parm = DECL_CHAIN (DECL_ARGUMENTS (fndecl));
591 bool move_p = move_fn_p (fndecl);
592 bool trivial = trivial_fn_p (fndecl);
593 int flags = LOOKUP_NORMAL | LOOKUP_NONVIRTUAL | LOOKUP_DEFAULTED;
595 compound_stmt = begin_compound_stmt (0);
596 parm = convert_from_reference (parm);
599 && is_empty_class (current_class_type))
600 /* Don't copy the padding byte; it might not have been allocated
601 if *this is a base subobject. */;
604 tree t = build2 (MODIFY_EXPR, void_type_node, current_class_ref, parm);
605 finish_expr_stmt (t);
610 int cvquals = cp_type_quals (TREE_TYPE (parm));
612 tree binfo, base_binfo;
614 /* Assign to each of the direct base classes. */
615 for (binfo = TYPE_BINFO (current_class_type), i = 0;
616 BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
619 VEC(tree,gc) *parmvec;
621 /* We must convert PARM directly to the base class
622 explicitly since the base class may be ambiguous. */
623 converted_parm = build_base_path (PLUS_EXPR, parm, base_binfo, 1);
625 converted_parm = move (converted_parm);
626 /* Call the base class assignment operator. */
627 parmvec = make_tree_vector_single (converted_parm);
629 (build_special_member_call (current_class_ref,
630 ansi_assopname (NOP_EXPR),
634 tf_warning_or_error));
635 release_tree_vector (parmvec);
638 /* Assign to each of the non-static data members. */
639 for (fields = TYPE_FIELDS (current_class_type);
641 fields = DECL_CHAIN (fields))
643 tree comp = current_class_ref;
649 if (TREE_CODE (field) != FIELD_DECL || DECL_ARTIFICIAL (field))
652 expr_type = TREE_TYPE (field);
654 if (CP_TYPE_CONST_P (expr_type))
656 error ("non-static const member %q#D, can%'t use default "
657 "assignment operator", field);
660 else if (TREE_CODE (expr_type) == REFERENCE_TYPE)
662 error ("non-static reference member %q#D, can%'t use "
663 "default assignment operator", field);
667 if (DECL_NAME (field))
669 if (VFIELD_NAME_P (DECL_NAME (field)))
672 else if (ANON_AGGR_TYPE_P (expr_type)
673 && TYPE_FIELDS (expr_type) != NULL_TREE)
674 /* Just use the field; anonymous types can't have
675 nontrivial copy ctors or assignment ops or this
676 function would be deleted. */;
680 comp = build3 (COMPONENT_REF, expr_type, comp, field, NULL_TREE);
682 /* Compute the type of init->field */
684 if (DECL_MUTABLE_P (field))
685 quals &= ~TYPE_QUAL_CONST;
686 expr_type = cp_build_qualified_type (expr_type, quals);
688 init = build3 (COMPONENT_REF, expr_type, init, field, NULL_TREE);
689 if (move_p && TREE_CODE (expr_type) != REFERENCE_TYPE)
692 if (DECL_NAME (field))
693 init = cp_build_modify_expr (comp, NOP_EXPR, init,
694 tf_warning_or_error);
696 init = build2 (MODIFY_EXPR, TREE_TYPE (comp), comp, init);
697 finish_expr_stmt (init);
700 finish_return_stmt (current_class_ref);
701 finish_compound_stmt (compound_stmt);
704 /* Synthesize FNDECL, a non-static member function. */
707 synthesize_method (tree fndecl)
709 bool nested = (current_function_decl != NULL_TREE);
710 tree context = decl_function_context (fndecl);
711 bool need_body = true;
713 location_t save_input_location = input_location;
714 int error_count = errorcount;
715 int warning_count = warningcount;
717 /* Reset the source location, we might have been previously
718 deferred, and thus have saved where we were first needed. */
719 DECL_SOURCE_LOCATION (fndecl)
720 = DECL_SOURCE_LOCATION (TYPE_NAME (DECL_CONTEXT (fndecl)));
722 /* If we've been asked to synthesize a clone, just synthesize the
723 cloned function instead. Doing so will automatically fill in the
724 body for the clone. */
725 if (DECL_CLONED_FUNCTION_P (fndecl))
726 fndecl = DECL_CLONED_FUNCTION (fndecl);
728 /* We may be in the middle of deferred access check. Disable
730 push_deferring_access_checks (dk_no_deferred);
733 push_to_top_level ();
735 push_function_context ();
737 input_location = DECL_SOURCE_LOCATION (fndecl);
739 start_preparsed_function (fndecl, NULL_TREE, SF_DEFAULT | SF_PRE_PARSED);
740 stmt = begin_function_body ();
742 if (DECL_OVERLOADED_OPERATOR_P (fndecl) == NOP_EXPR)
744 do_build_copy_assign (fndecl);
747 else if (DECL_CONSTRUCTOR_P (fndecl))
749 tree arg_chain = FUNCTION_FIRST_USER_PARMTYPE (fndecl);
750 if (arg_chain != void_list_node)
751 do_build_copy_constructor (fndecl);
753 finish_mem_initializers (NULL_TREE);
756 /* If we haven't yet generated the body of the function, just
757 generate an empty compound statement. */
761 compound_stmt = begin_compound_stmt (BCS_FN_BODY);
762 finish_compound_stmt (compound_stmt);
765 finish_function_body (stmt);
766 expand_or_defer_fn (finish_function (0));
768 input_location = save_input_location;
771 pop_from_top_level ();
773 pop_function_context ();
775 pop_deferring_access_checks ();
777 if (error_count != errorcount || warning_count != warningcount)
778 inform (input_location, "synthesized method %qD first required here ",
782 /* Build a reference to type TYPE with cv-quals QUALS, which is an
783 rvalue if RVALUE is true. */
786 build_stub_type (tree type, int quals, bool rvalue)
788 tree argtype = cp_build_qualified_type (type, quals);
789 return cp_build_reference_type (argtype, rvalue);
792 /* Build a dummy glvalue from dereferencing a dummy reference of type
796 build_stub_object (tree reftype)
798 tree stub = build1 (NOP_EXPR, reftype, integer_one_node);
799 return convert_from_reference (stub);
802 /* Determine which function will be called when looking up NAME in TYPE,
803 called with a single ARGTYPE argument, or no argument if ARGTYPE is
804 null. FLAGS and COMPLAIN are as for build_new_method_call.
806 Returns a FUNCTION_DECL if all is well.
807 Returns NULL_TREE if overload resolution failed.
808 Returns error_mark_node if the chosen function cannot be called. */
811 locate_fn_flags (tree type, tree name, tree argtype, int flags,
812 tsubst_flags_t complain)
814 tree ob, fn, fns, binfo, rval;
818 binfo = TYPE_BINFO (type);
822 type = BINFO_TYPE (binfo);
825 ob = build_stub_object (cp_build_reference_type (type, false));
826 args = make_tree_vector ();
829 tree arg = build_stub_object (argtype);
830 VEC_quick_push (tree, args, arg);
833 fns = lookup_fnfields (binfo, name, 0);
834 rval = build_new_method_call (ob, fns, &args, binfo, flags, &fn, complain);
836 release_tree_vector (args);
837 if (fn && rval == error_mark_node)
843 /* Locate the dtor of TYPE. */
846 get_dtor (tree type, tsubst_flags_t complain)
848 tree fn = locate_fn_flags (type, complete_dtor_identifier, NULL_TREE,
849 LOOKUP_NORMAL, complain);
850 if (fn == error_mark_node)
855 /* Locate the default ctor of TYPE. */
858 locate_ctor (tree type)
862 push_deferring_access_checks (dk_no_check);
863 fn = locate_fn_flags (type, complete_ctor_identifier, NULL_TREE,
864 LOOKUP_SPECULATIVE, tf_none);
865 pop_deferring_access_checks ();
866 if (fn == error_mark_node)
871 /* Likewise, but give any appropriate errors. */
874 get_default_ctor (tree type)
876 tree fn = locate_fn_flags (type, complete_ctor_identifier, NULL_TREE,
877 LOOKUP_NORMAL, tf_warning_or_error);
878 if (fn == error_mark_node)
883 /* Locate the copy ctor of TYPE. */
886 get_copy_ctor (tree type, tsubst_flags_t complain)
888 int quals = (TYPE_HAS_CONST_COPY_CTOR (type)
889 ? TYPE_QUAL_CONST : TYPE_UNQUALIFIED);
890 tree argtype = build_stub_type (type, quals, false);
891 tree fn = locate_fn_flags (type, complete_ctor_identifier, argtype,
892 LOOKUP_NORMAL, complain);
893 if (fn == error_mark_node)
898 /* Locate the copy assignment operator of TYPE. */
901 get_copy_assign (tree type)
903 int quals = (TYPE_HAS_CONST_COPY_ASSIGN (type)
904 ? TYPE_QUAL_CONST : TYPE_UNQUALIFIED);
905 tree argtype = build_stub_type (type, quals, false);
906 tree fn = locate_fn_flags (type, ansi_assopname (NOP_EXPR), argtype,
907 LOOKUP_NORMAL, tf_warning_or_error);
908 if (fn == error_mark_node)
913 /* Subroutine of synthesized_method_walk. Update SPEC_P, TRIVIAL_P and
914 DELETED_P or give an error message MSG with argument ARG. */
917 process_subob_fn (tree fn, bool move_p, tree *spec_p, bool *trivial_p,
918 bool *deleted_p, bool *constexpr_p,
919 const char *msg, tree arg)
921 if (!fn || fn == error_mark_node)
926 tree raises = TYPE_RAISES_EXCEPTIONS (TREE_TYPE (fn));
927 *spec_p = merge_exception_specifiers (*spec_p, raises);
930 if (!trivial_fn_p (fn))
934 if (TREE_CODE (arg) == FIELD_DECL
935 && TREE_CODE (DECL_CONTEXT (arg)) == UNION_TYPE)
940 error ("union member %q+D with non-trivial %qD", arg, fn);
944 if (move_p && !move_fn_p (fn) && !trivial_fn_p (fn))
953 /* If this is a specialization of a constexpr template, we need to
954 force the instantiation now so that we know whether or not it's
956 if (DECL_DECLARED_CONSTEXPR_P (fn) && DECL_TEMPLATE_INSTANTIATION (fn)
957 && !DECL_TEMPLATE_INSTANTIATED (fn))
958 instantiate_decl (fn, /*defer_ok*/false, /*expl_class*/false);
959 if (!DECL_DECLARED_CONSTEXPR_P (fn))
960 *constexpr_p = false;
970 /* Subroutine of synthesized_method_walk to allow recursion into anonymous
974 walk_field_subobs (tree fields, tree fnname, special_function_kind sfk,
975 int quals, bool copy_arg_p, bool move_p,
976 bool assign_p, tree *spec_p, bool *trivial_p,
977 bool *deleted_p, bool *constexpr_p, const char *msg,
978 int flags, tsubst_flags_t complain)
981 for (field = fields; field; field = DECL_CHAIN (field))
983 tree mem_type, argtype, rval;
985 if (TREE_CODE (field) != FIELD_DECL
986 || DECL_ARTIFICIAL (field))
989 mem_type = strip_array_types (TREE_TYPE (field));
993 if (CP_TYPE_CONST_P (mem_type) && !CLASS_TYPE_P (mem_type))
996 error ("non-static const member %q#D, can%'t use default "
997 "assignment operator", field);
999 else if (TREE_CODE (mem_type) == REFERENCE_TYPE)
1002 error ("non-static reference member %q#D, can%'t use "
1003 "default assignment operator", field);
1008 if (bad && deleted_p)
1011 else if (sfk == sfk_constructor)
1014 if (CP_TYPE_CONST_P (mem_type)
1015 && (!CLASS_TYPE_P (mem_type)
1016 || !type_has_user_provided_default_constructor (mem_type)))
1019 error ("uninitialized non-static const member %q#D",
1022 else if (TREE_CODE (mem_type) == REFERENCE_TYPE)
1025 error ("uninitialized non-static reference member %q#D",
1031 if (bad && deleted_p)
1034 /* For an implicitly-defined default constructor to be constexpr,
1035 every member must have a user-provided default constructor. */
1036 /* FIXME will need adjustment for non-static data member
1038 if (constexpr_p && !CLASS_TYPE_P (mem_type))
1039 *constexpr_p = false;
1042 if (!CLASS_TYPE_P (mem_type))
1045 if (ANON_AGGR_TYPE_P (mem_type))
1047 walk_field_subobs (TYPE_FIELDS (mem_type), fnname, sfk, quals,
1048 copy_arg_p, move_p, assign_p, spec_p, trivial_p,
1049 deleted_p, constexpr_p, msg, flags, complain);
1055 int mem_quals = cp_type_quals (mem_type) | quals;
1056 if (DECL_MUTABLE_P (field))
1057 mem_quals &= ~TYPE_QUAL_CONST;
1058 argtype = build_stub_type (mem_type, mem_quals, move_p);
1061 argtype = NULL_TREE;
1063 rval = locate_fn_flags (mem_type, fnname, argtype, flags, complain);
1065 process_subob_fn (rval, move_p, spec_p, trivial_p, deleted_p,
1066 constexpr_p, msg, field);
1070 /* The caller wants to generate an implicit declaration of SFK for CTYPE
1071 which is const if relevant and CONST_P is set. If spec_p, trivial_p and
1072 deleted_p are non-null, set their referent appropriately. If diag is
1073 true, we're being called from maybe_explain_implicit_delete to give
1077 synthesized_method_walk (tree ctype, special_function_kind sfk, bool const_p,
1078 tree *spec_p, bool *trivial_p, bool *deleted_p,
1079 bool *constexpr_p, bool diag)
1081 tree binfo, base_binfo, scope, fnname, rval, argtype;
1082 bool move_p, copy_arg_p, assign_p, expected_trivial, check_vdtor;
1083 VEC(tree,gc) *vbases;
1084 int i, quals, flags;
1085 tsubst_flags_t complain;
1090 *spec_p = (cxx_dialect >= cxx0x ? noexcept_true_spec : empty_except_spec);
1094 /* "The closure type associated with a lambda-expression has a deleted
1095 default constructor and a deleted copy assignment operator."
1096 This is diagnosed in maybe_explain_implicit_delete. */
1097 if (LAMBDA_TYPE_P (ctype)
1098 && (sfk == sfk_constructor
1099 || sfk == sfk_copy_assignment))
1110 check_vdtor = false;
1113 case sfk_move_assignment:
1114 case sfk_copy_assignment:
1116 fnname = ansi_assopname (NOP_EXPR);
1119 case sfk_destructor:
1121 /* The synthesized method will call base dtors, but check complete
1122 here to avoid having to deal with VTT. */
1123 fnname = complete_dtor_identifier;
1126 case sfk_constructor:
1127 case sfk_move_constructor:
1128 case sfk_copy_constructor:
1130 fnname = complete_ctor_identifier;
1137 /* If that user-written default constructor would satisfy the
1138 requirements of a constexpr constructor (7.1.5), the
1139 implicitly-defined default constructor is constexpr. */
1141 *constexpr_p = ctor_p;
1146 case sfk_constructor:
1147 case sfk_destructor:
1151 case sfk_move_constructor:
1152 case sfk_move_assignment:
1154 case sfk_copy_constructor:
1155 case sfk_copy_assignment:
1163 expected_trivial = type_has_trivial_fn (ctype, sfk);
1165 *trivial_p = expected_trivial;
1167 /* The TYPE_HAS_COMPLEX_* flags tell us about constraints from base
1168 class versions and other properties of the type. But a subobject
1169 class can be trivially copyable and yet have overload resolution
1170 choose a template constructor for initialization, depending on
1171 rvalueness and cv-quals. So we can't exit early for copy/move
1172 methods in C++0x. The same considerations apply in C++98/03, but
1173 there the definition of triviality does not consider overload
1174 resolution, so a constructor can be trivial even if it would otherwise
1175 call a non-trivial constructor. */
1176 if (expected_trivial
1177 && (!copy_arg_p || cxx_dialect < cxx0x))
1179 if (constexpr_p && sfk == sfk_constructor)
1180 *constexpr_p = synthesized_default_constructor_is_constexpr (ctype);
1184 ++cp_unevaluated_operand;
1185 ++c_inhibit_evaluation_warnings;
1187 scope = push_scope (ctype);
1191 flags = LOOKUP_NORMAL|LOOKUP_SPECULATIVE|LOOKUP_DEFAULTED;
1192 complain = tf_warning_or_error;
1196 flags = LOOKUP_PROTECT|LOOKUP_SPECULATIVE|LOOKUP_DEFAULTED;
1201 quals = TYPE_QUAL_CONST;
1203 quals = TYPE_UNQUALIFIED;
1204 argtype = NULL_TREE;
1209 msg = ("base %qT does not have a move assignment operator or trivial "
1210 "copy assignment operator");
1212 msg = ("base %qT does not have a move constructor or trivial "
1213 "copy constructor");
1215 for (binfo = TYPE_BINFO (ctype), i = 0;
1216 BINFO_BASE_ITERATE (binfo, i, base_binfo); ++i)
1218 tree basetype = BINFO_TYPE (base_binfo);
1220 argtype = build_stub_type (basetype, quals, move_p);
1221 rval = locate_fn_flags (base_binfo, fnname, argtype, flags, complain);
1223 process_subob_fn (rval, move_p, spec_p, trivial_p, deleted_p,
1224 constexpr_p, msg, basetype);
1225 if (ctor_p && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (basetype))
1227 /* In a constructor we also need to check the subobject
1228 destructors for cleanup of partially constructed objects. */
1229 rval = locate_fn_flags (base_binfo, complete_dtor_identifier,
1230 NULL_TREE, flags, complain);
1231 /* Note that we don't pass down trivial_p; the subobject
1232 destructors don't affect triviality of the constructor. */
1233 process_subob_fn (rval, false, spec_p, NULL,
1234 deleted_p, NULL, NULL,
1238 if (check_vdtor && type_has_virtual_destructor (basetype))
1240 rval = locate_fn_flags (ctype, ansi_opname (DELETE_EXPR),
1241 ptr_type_node, flags, complain);
1242 /* Unlike for base ctor/op=/dtor, for operator delete it's fine
1243 to have a null rval (no class-specific op delete). */
1244 if (rval && rval == error_mark_node && deleted_p)
1246 check_vdtor = false;
1250 vbases = CLASSTYPE_VBASECLASSES (ctype);
1251 if (vbases && assign_p && move_p)
1253 /* Should the spec be changed to allow vbases that only occur once? */
1255 error ("%qT has virtual bases, default move assignment operator "
1256 "cannot be generated", ctype);
1263 msg = ("virtual base %qT does not have a move constructor "
1264 "or trivial copy constructor");
1265 if (vbases && constexpr_p)
1266 *constexpr_p = false;
1267 FOR_EACH_VEC_ELT (tree, vbases, i, base_binfo)
1269 tree basetype = BINFO_TYPE (base_binfo);
1271 argtype = build_stub_type (basetype, quals, move_p);
1272 rval = locate_fn_flags (base_binfo, fnname, argtype, flags, complain);
1274 process_subob_fn (rval, move_p, spec_p, trivial_p, deleted_p,
1275 constexpr_p, msg, basetype);
1276 if (ctor_p && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (basetype))
1278 rval = locate_fn_flags (base_binfo, complete_dtor_identifier,
1279 NULL_TREE, flags, complain);
1280 process_subob_fn (rval, false, spec_p, NULL,
1281 deleted_p, NULL, NULL,
1287 /* Leave msg null. */;
1289 msg = ("non-static data member %qD does not have a move "
1290 "assignment operator or trivial copy assignment operator");
1292 msg = ("non-static data member %qD does not have a move "
1293 "constructor or trivial copy constructor");
1294 walk_field_subobs (TYPE_FIELDS (ctype), fnname, sfk, quals,
1295 copy_arg_p, move_p, assign_p, spec_p, trivial_p,
1296 deleted_p, constexpr_p, msg, flags, complain);
1298 walk_field_subobs (TYPE_FIELDS (ctype), complete_dtor_identifier,
1299 sfk_destructor, TYPE_UNQUALIFIED, false,
1300 false, false, spec_p, NULL,
1302 NULL, flags, complain);
1306 --cp_unevaluated_operand;
1307 --c_inhibit_evaluation_warnings;
1310 /* DECL is a deleted function. If it's implicitly deleted, explain why and
1311 return true; else return false. */
1314 maybe_explain_implicit_delete (tree decl)
1316 /* If decl is a clone, get the primary variant. */
1317 decl = DECL_ORIGIN (decl);
1318 gcc_assert (DECL_DELETED_FN (decl));
1319 if (DECL_DEFAULTED_FN (decl))
1321 /* Not marked GTY; it doesn't need to be GC'd or written to PCH. */
1322 static htab_t explained_htab;
1325 special_function_kind sfk;
1330 if (!explained_htab)
1331 explained_htab = htab_create (37, htab_hash_pointer,
1332 htab_eq_pointer, NULL);
1333 slot = htab_find_slot (explained_htab, decl, INSERT);
1338 sfk = special_function_p (decl);
1339 ctype = DECL_CONTEXT (decl);
1340 loc = input_location;
1341 input_location = DECL_SOURCE_LOCATION (decl);
1344 if (LAMBDA_TYPE_P (ctype))
1347 if (sfk == sfk_constructor)
1348 error ("a lambda closure type has a deleted default constructor");
1349 else if (sfk == sfk_copy_assignment)
1350 error ("a lambda closure type has a deleted copy assignment operator");
1356 tree parm_type = TREE_VALUE (FUNCTION_FIRST_USER_PARMTYPE (decl));
1357 bool const_p = CP_TYPE_CONST_P (non_reference (parm_type));
1358 tree scope = push_scope (ctype);
1359 error ("%qD is implicitly deleted because the default "
1360 "definition would be ill-formed:", decl);
1362 synthesized_method_walk (ctype, sfk, const_p,
1363 NULL, NULL, NULL, NULL, true);
1366 input_location = loc;
1372 /* Implicitly declare the special function indicated by KIND, as a
1373 member of TYPE. For copy constructors and assignment operators,
1374 CONST_P indicates whether these functions should take a const
1375 reference argument or a non-const reference. Returns the
1376 FUNCTION_DECL for the implicitly declared function. */
1379 implicitly_declare_fn (special_function_kind kind, tree type, bool const_p)
1382 tree parameter_types = void_list_node;
1385 tree raises = empty_except_spec;
1386 tree rhs_parm_type = NULL_TREE;
1389 HOST_WIDE_INT saved_processing_template_decl;
1394 /* Because we create declarations for implicitly declared functions
1395 lazily, we may be creating the declaration for a member of TYPE
1396 while in some completely different context. However, TYPE will
1397 never be a dependent class (because we never want to do lookups
1398 for implicitly defined functions in a dependent class).
1399 Furthermore, we must set PROCESSING_TEMPLATE_DECL to zero here
1400 because we only create clones for constructors and destructors
1401 when not in a template. */
1402 gcc_assert (!dependent_type_p (type));
1403 saved_processing_template_decl = processing_template_decl;
1404 processing_template_decl = 0;
1406 type = TYPE_MAIN_VARIANT (type);
1408 if (targetm.cxx.cdtor_returns_this () && !TYPE_FOR_JAVA (type))
1410 if (kind == sfk_destructor)
1411 /* See comment in check_special_function_return_type. */
1412 return_type = build_pointer_type (void_type_node);
1414 return_type = build_pointer_type (type);
1417 return_type = void_type_node;
1421 case sfk_destructor:
1423 name = constructor_name (type);
1426 case sfk_constructor:
1427 /* Default constructor. */
1428 name = constructor_name (type);
1431 case sfk_copy_constructor:
1432 case sfk_copy_assignment:
1433 case sfk_move_constructor:
1434 case sfk_move_assignment:
1437 if (kind == sfk_copy_assignment
1438 || kind == sfk_move_assignment)
1440 return_type = build_reference_type (type);
1441 name = ansi_assopname (NOP_EXPR);
1444 name = constructor_name (type);
1447 rhs_parm_type = cp_build_qualified_type (type, TYPE_QUAL_CONST);
1449 rhs_parm_type = type;
1450 move_p = (kind == sfk_move_assignment
1451 || kind == sfk_move_constructor);
1452 rhs_parm_type = cp_build_reference_type (rhs_parm_type, move_p);
1454 parameter_types = tree_cons (NULL_TREE, rhs_parm_type, parameter_types);
1461 synthesized_method_walk (type, kind, const_p, &raises, &trivial_p,
1462 &deleted_p, &constexpr_p, false);
1463 /* Don't bother marking a deleted constructor as constexpr. */
1465 constexpr_p = false;
1466 /* A trivial copy/move constructor is also a constexpr constructor. */
1467 else if (trivial_p && cxx_dialect >= cxx0x
1468 && (kind == sfk_copy_constructor
1469 || kind == sfk_move_constructor))
1470 gcc_assert (constexpr_p);
1472 if (!trivial_p && type_has_trivial_fn (type, kind))
1473 type_set_nontrivial_flag (type, kind);
1475 /* Create the function. */
1476 fn_type = build_method_type_directly (type, return_type, parameter_types);
1478 fn_type = build_exception_variant (fn_type, raises);
1479 fn = build_lang_decl (FUNCTION_DECL, name, fn_type);
1480 DECL_SOURCE_LOCATION (fn) = DECL_SOURCE_LOCATION (TYPE_NAME (type));
1481 if (kind == sfk_constructor || kind == sfk_copy_constructor
1482 || kind == sfk_move_constructor)
1483 DECL_CONSTRUCTOR_P (fn) = 1;
1484 else if (kind == sfk_destructor)
1485 DECL_DESTRUCTOR_P (fn) = 1;
1488 DECL_ASSIGNMENT_OPERATOR_P (fn) = 1;
1489 SET_OVERLOADED_OPERATOR_CODE (fn, NOP_EXPR);
1492 /* If pointers to member functions use the least significant bit to
1493 indicate whether a function is virtual, ensure a pointer
1494 to this function will have that bit clear. */
1495 if (TARGET_PTRMEMFUNC_VBIT_LOCATION == ptrmemfunc_vbit_in_pfn
1496 && DECL_ALIGN (fn) < 2 * BITS_PER_UNIT)
1497 DECL_ALIGN (fn) = 2 * BITS_PER_UNIT;
1499 /* Create the explicit arguments. */
1502 /* Note that this parameter is *not* marked DECL_ARTIFICIAL; we
1503 want its type to be included in the mangled function
1505 DECL_ARGUMENTS (fn) = cp_build_parm_decl (NULL_TREE, rhs_parm_type);
1506 TREE_READONLY (DECL_ARGUMENTS (fn)) = 1;
1508 /* Add the "this" parameter. */
1509 this_parm = build_this_parm (fn_type, TYPE_UNQUALIFIED);
1510 DECL_CHAIN (this_parm) = DECL_ARGUMENTS (fn);
1511 DECL_ARGUMENTS (fn) = this_parm;
1513 grokclassfn (type, fn, kind == sfk_destructor ? DTOR_FLAG : NO_SPECIAL);
1514 set_linkage_according_to_type (type, fn);
1515 rest_of_decl_compilation (fn, toplevel_bindings_p (), at_eof);
1516 DECL_IN_AGGR_P (fn) = 1;
1517 DECL_ARTIFICIAL (fn) = 1;
1518 DECL_DEFAULTED_FN (fn) = 1;
1519 if (cxx_dialect >= cxx0x)
1521 DECL_DELETED_FN (fn) = deleted_p;
1522 DECL_DECLARED_CONSTEXPR_P (fn) = constexpr_p;
1524 DECL_NOT_REALLY_EXTERN (fn) = 1;
1525 DECL_DECLARED_INLINE_P (fn) = 1;
1526 gcc_assert (!TREE_USED (fn));
1528 /* Restore PROCESSING_TEMPLATE_DECL. */
1529 processing_template_decl = saved_processing_template_decl;
1534 /* Gives any errors about defaulted functions which need to be deferred
1535 until the containing class is complete. */
1538 defaulted_late_check (tree fn)
1540 /* Complain about invalid signature for defaulted fn. */
1541 tree ctx = DECL_CONTEXT (fn);
1542 special_function_kind kind = special_function_p (fn);
1543 bool fn_const_p = (copy_fn_p (fn) == 2);
1544 tree implicit_fn = implicitly_declare_fn (kind, ctx, fn_const_p);
1546 if (!same_type_p (TREE_TYPE (TREE_TYPE (fn)),
1547 TREE_TYPE (TREE_TYPE (implicit_fn)))
1548 || !compparms (TYPE_ARG_TYPES (TREE_TYPE (fn)),
1549 TYPE_ARG_TYPES (TREE_TYPE (implicit_fn))))
1551 error ("defaulted declaration %q+D", fn);
1552 error_at (DECL_SOURCE_LOCATION (fn),
1553 "does not match expected signature %qD", implicit_fn);
1556 /* 8.4.2/2: If it is explicitly defaulted on its first declaration, it is
1557 implicitly considered to have the same exception-specification as if
1558 it had been implicitly declared. */
1559 if (DECL_DEFAULTED_IN_CLASS_P (fn))
1561 tree eh_spec = TYPE_RAISES_EXCEPTIONS (TREE_TYPE (implicit_fn));
1562 if (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (fn))
1563 && !comp_except_specs (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (fn)),
1564 eh_spec, ce_normal))
1565 error ("function %q+D defaulted on its first declaration "
1566 "with an exception-specification that differs from "
1567 "the implicit declaration %q#D", fn, implicit_fn);
1568 TREE_TYPE (fn) = build_exception_variant (TREE_TYPE (fn), eh_spec);
1569 if (DECL_DECLARED_CONSTEXPR_P (implicit_fn))
1570 /* Hmm...should we do this for out-of-class too? Should it be OK to
1571 add constexpr later like inline, rather than requiring
1572 declarations to match? */
1573 DECL_DECLARED_CONSTEXPR_P (fn) = true;
1576 if (!DECL_DECLARED_CONSTEXPR_P (implicit_fn)
1577 && DECL_DECLARED_CONSTEXPR_P (fn))
1579 if (!CLASSTYPE_TEMPLATE_INSTANTIATION (ctx))
1580 error ("%qD cannot be declared as constexpr", fn);
1581 DECL_DECLARED_CONSTEXPR_P (fn) = false;
1584 if (DECL_DELETED_FN (implicit_fn))
1585 DECL_DELETED_FN (fn) = 1;
1588 /* Returns true iff FN can be explicitly defaulted, and gives any
1589 errors if defaulting FN is ill-formed. */
1592 defaultable_fn_check (tree fn)
1594 special_function_kind kind = sfk_none;
1596 if (template_parm_scope_p ())
1598 error ("a template cannot be defaulted");
1602 if (DECL_CONSTRUCTOR_P (fn))
1604 if (FUNCTION_FIRST_USER_PARMTYPE (fn) == void_list_node)
1605 kind = sfk_constructor;
1606 else if (copy_fn_p (fn) > 0
1607 && (TREE_CHAIN (FUNCTION_FIRST_USER_PARMTYPE (fn))
1609 kind = sfk_copy_constructor;
1610 else if (move_fn_p (fn))
1611 kind = sfk_move_constructor;
1613 else if (DECL_DESTRUCTOR_P (fn))
1614 kind = sfk_destructor;
1615 else if (DECL_ASSIGNMENT_OPERATOR_P (fn)
1616 && DECL_OVERLOADED_OPERATOR_P (fn) == NOP_EXPR)
1619 kind = sfk_copy_assignment;
1620 else if (move_fn_p (fn))
1621 kind = sfk_move_assignment;
1624 if (kind == sfk_none)
1626 error ("%qD cannot be defaulted", fn);
1631 tree t = FUNCTION_FIRST_USER_PARMTYPE (fn);
1632 for (; t && t != void_list_node; t = TREE_CHAIN (t))
1633 if (TREE_PURPOSE (t))
1635 error ("defaulted function %q+D with default argument", fn);
1638 if (TYPE_BEING_DEFINED (DECL_CONTEXT (fn)))
1639 /* Defer checking. */;
1640 else if (!processing_template_decl)
1641 defaulted_late_check (fn);
1647 /* Add an implicit declaration to TYPE for the kind of function
1648 indicated by SFK. Return the FUNCTION_DECL for the new implicit
1652 lazily_declare_fn (special_function_kind sfk, tree type)
1655 /* Whether or not the argument has a const reference type. */
1656 bool const_p = false;
1660 case sfk_constructor:
1661 CLASSTYPE_LAZY_DEFAULT_CTOR (type) = 0;
1663 case sfk_copy_constructor:
1664 const_p = TYPE_HAS_CONST_COPY_CTOR (type);
1665 CLASSTYPE_LAZY_COPY_CTOR (type) = 0;
1667 case sfk_move_constructor:
1668 CLASSTYPE_LAZY_MOVE_CTOR (type) = 0;
1670 case sfk_copy_assignment:
1671 const_p = TYPE_HAS_CONST_COPY_ASSIGN (type);
1672 CLASSTYPE_LAZY_COPY_ASSIGN (type) = 0;
1674 case sfk_move_assignment:
1675 CLASSTYPE_LAZY_MOVE_ASSIGN (type) = 0;
1677 case sfk_destructor:
1678 CLASSTYPE_LAZY_DESTRUCTOR (type) = 0;
1684 /* Declare the function. */
1685 fn = implicitly_declare_fn (sfk, type, const_p);
1687 /* For move variants, rather than declare them as deleted we just
1688 don't declare them at all. */
1689 if (DECL_DELETED_FN (fn)
1690 && (sfk == sfk_move_constructor
1691 || sfk == sfk_move_assignment))
1694 /* A destructor may be virtual. */
1695 if (sfk == sfk_destructor
1696 || sfk == sfk_move_assignment
1697 || sfk == sfk_copy_assignment)
1698 check_for_override (fn, type);
1699 /* Add it to CLASSTYPE_METHOD_VEC. */
1700 add_method (type, fn, NULL_TREE);
1701 /* Add it to TYPE_METHODS. */
1702 if (sfk == sfk_destructor
1703 && DECL_VIRTUAL_P (fn)
1704 && abi_version_at_least (2))
1705 /* The ABI requires that a virtual destructor go at the end of the
1707 TYPE_METHODS (type) = chainon (TYPE_METHODS (type), fn);
1710 /* G++ 3.2 put the implicit destructor at the *beginning* of the
1711 TYPE_METHODS list, which cause the destructor to be emitted
1712 in an incorrect location in the vtable. */
1713 if (warn_abi && sfk == sfk_destructor && DECL_VIRTUAL_P (fn))
1714 warning (OPT_Wabi, "vtable layout for class %qT may not be ABI-compliant"
1715 "and may change in a future version of GCC due to "
1716 "implicit virtual destructor",
1718 DECL_CHAIN (fn) = TYPE_METHODS (type);
1719 TYPE_METHODS (type) = fn;
1721 maybe_add_class_template_decl_list (type, fn, /*friend_p=*/0);
1722 if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (fn)
1723 || DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (fn))
1724 /* Create appropriate clones. */
1725 clone_function_decl (fn, /*update_method_vec=*/true);
1730 /* Given a FUNCTION_DECL FN and a chain LIST, skip as many elements of LIST
1731 as there are artificial parms in FN. */
1734 skip_artificial_parms_for (const_tree fn, tree list)
1736 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fn))
1737 list = TREE_CHAIN (list);
1741 if (DECL_HAS_IN_CHARGE_PARM_P (fn))
1742 list = TREE_CHAIN (list);
1743 if (DECL_HAS_VTT_PARM_P (fn))
1744 list = TREE_CHAIN (list);
1748 /* Given a FUNCTION_DECL FN and a chain LIST, return the number of
1749 artificial parms in FN. */
1752 num_artificial_parms_for (const_tree fn)
1756 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fn))
1761 if (DECL_HAS_IN_CHARGE_PARM_P (fn))
1763 if (DECL_HAS_VTT_PARM_P (fn))
1769 #include "gt-cp-method.h"