1 /* Handle the hair of processing (but not expanding) inline functions.
2 Also manage function and variable name overloading.
3 Copyright (C) 1987, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
4 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2007, 2008, 2009, 2010, 2011
5 Free Software Foundation, Inc.
6 Contributed by Michael Tiemann (tiemann@cygnus.com)
8 This file is part of GCC.
10 GCC is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 3, or (at your option)
15 GCC is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
20 You should have received a copy of the GNU General Public License
21 along with GCC; see the file COPYING3. If not see
22 <http://www.gnu.org/licenses/>. */
25 /* Handle method declarations. */
28 #include "coretypes.h"
37 #include "common/common-target.h"
38 #include "tree-pass.h"
39 #include "diagnostic.h"
43 /* Various flags to control the mangling process. */
49 /* The thing we are presently mangling is part of a template type,
50 rather than a fully instantiated type. Therefore, we may see
51 complex expressions where we would normally expect to see a
52 simple integer constant. */
53 mf_maybe_uninstantiated = 1,
54 /* When mangling a numeric value, use the form `_XX_' (instead of
55 just `XX') if the value has more than one digit. */
56 mf_use_underscores_around_value = 2
59 typedef enum mangling_flags mangling_flags;
61 static void do_build_copy_assign (tree);
62 static void do_build_copy_constructor (tree);
63 static tree make_alias_for_thunk (tree);
65 /* Called once to initialize method.c. */
73 /* Return a this or result adjusting thunk to FUNCTION. THIS_ADJUSTING
74 indicates whether it is a this or result adjusting thunk.
75 FIXED_OFFSET and VIRTUAL_OFFSET indicate how to do the adjustment
76 (see thunk_adjust). VIRTUAL_OFFSET can be NULL, but FIXED_OFFSET
77 never is. VIRTUAL_OFFSET is the /index/ into the vtable for this
78 adjusting thunks, we scale it to a byte offset. For covariant
79 thunks VIRTUAL_OFFSET is the virtual binfo. You must post process
80 the returned thunk with finish_thunk. */
83 make_thunk (tree function, bool this_adjusting,
84 tree fixed_offset, tree virtual_offset)
89 gcc_assert (TREE_CODE (function) == FUNCTION_DECL);
90 /* We can have this thunks to covariant thunks, but not vice versa. */
91 gcc_assert (!DECL_THIS_THUNK_P (function));
92 gcc_assert (!DECL_RESULT_THUNK_P (function) || this_adjusting);
94 /* Scale the VIRTUAL_OFFSET to be in terms of bytes. */
95 if (this_adjusting && virtual_offset)
97 = size_binop (MULT_EXPR,
100 TYPE_SIZE_UNIT (vtable_entry_type)));
102 d = tree_low_cst (fixed_offset, 0);
104 /* See if we already have the thunk in question. For this_adjusting
105 thunks VIRTUAL_OFFSET will be an INTEGER_CST, for covariant thunks it
107 for (thunk = DECL_THUNKS (function); thunk; thunk = DECL_CHAIN (thunk))
108 if (DECL_THIS_THUNK_P (thunk) == this_adjusting
109 && THUNK_FIXED_OFFSET (thunk) == d
110 && !virtual_offset == !THUNK_VIRTUAL_OFFSET (thunk)
113 ? tree_int_cst_equal (THUNK_VIRTUAL_OFFSET (thunk),
115 : THUNK_VIRTUAL_OFFSET (thunk) == virtual_offset)))
118 /* All thunks must be created before FUNCTION is actually emitted;
119 the ABI requires that all thunks be emitted together with the
120 function to which they transfer control. */
121 gcc_assert (!TREE_ASM_WRITTEN (function));
122 /* Likewise, we can only be adding thunks to a function declared in
123 the class currently being laid out. */
124 gcc_assert (TYPE_SIZE (DECL_CONTEXT (function))
125 && TYPE_BEING_DEFINED (DECL_CONTEXT (function)));
127 thunk = build_decl (DECL_SOURCE_LOCATION (function),
128 FUNCTION_DECL, NULL_TREE, TREE_TYPE (function));
129 DECL_LANG_SPECIFIC (thunk) = DECL_LANG_SPECIFIC (function);
130 cxx_dup_lang_specific_decl (thunk);
131 DECL_THUNKS (thunk) = NULL_TREE;
133 DECL_CONTEXT (thunk) = DECL_CONTEXT (function);
134 TREE_READONLY (thunk) = TREE_READONLY (function);
135 TREE_THIS_VOLATILE (thunk) = TREE_THIS_VOLATILE (function);
136 TREE_PUBLIC (thunk) = TREE_PUBLIC (function);
137 SET_DECL_THUNK_P (thunk, this_adjusting);
138 THUNK_TARGET (thunk) = function;
139 THUNK_FIXED_OFFSET (thunk) = d;
140 THUNK_VIRTUAL_OFFSET (thunk) = virtual_offset;
141 THUNK_ALIAS (thunk) = NULL_TREE;
143 DECL_INTERFACE_KNOWN (thunk) = 1;
144 DECL_NOT_REALLY_EXTERN (thunk) = 1;
145 DECL_COMDAT (thunk) = DECL_COMDAT (function);
146 DECL_SAVED_FUNCTION_DATA (thunk) = NULL;
147 /* The thunk itself is not a constructor or destructor, even if
148 the thing it is thunking to is. */
149 DECL_DESTRUCTOR_P (thunk) = 0;
150 DECL_CONSTRUCTOR_P (thunk) = 0;
151 DECL_EXTERNAL (thunk) = 1;
152 DECL_ARTIFICIAL (thunk) = 1;
153 /* The THUNK is not a pending inline, even if the FUNCTION is. */
154 DECL_PENDING_INLINE_P (thunk) = 0;
155 DECL_DECLARED_INLINE_P (thunk) = 0;
156 /* Nor is it a template instantiation. */
157 DECL_USE_TEMPLATE (thunk) = 0;
158 DECL_TEMPLATE_INFO (thunk) = NULL;
160 /* Add it to the list of thunks associated with FUNCTION. */
161 DECL_CHAIN (thunk) = DECL_THUNKS (function);
162 DECL_THUNKS (function) = thunk;
167 /* Finish THUNK, a thunk decl. */
170 finish_thunk (tree thunk)
173 tree fixed_offset = ssize_int (THUNK_FIXED_OFFSET (thunk));
174 tree virtual_offset = THUNK_VIRTUAL_OFFSET (thunk);
176 gcc_assert (!DECL_NAME (thunk) && DECL_THUNK_P (thunk));
177 if (virtual_offset && DECL_RESULT_THUNK_P (thunk))
178 virtual_offset = BINFO_VPTR_FIELD (virtual_offset);
179 function = THUNK_TARGET (thunk);
180 name = mangle_thunk (function, DECL_THIS_THUNK_P (thunk),
181 fixed_offset, virtual_offset);
183 /* We can end up with declarations of (logically) different
184 covariant thunks, that do identical adjustments. The two thunks
185 will be adjusting between within different hierarchies, which
186 happen to have the same layout. We must nullify one of them to
187 refer to the other. */
188 if (DECL_RESULT_THUNK_P (thunk))
192 for (cov_probe = DECL_THUNKS (function);
193 cov_probe; cov_probe = DECL_CHAIN (cov_probe))
194 if (DECL_NAME (cov_probe) == name)
196 gcc_assert (!DECL_THUNKS (thunk));
197 THUNK_ALIAS (thunk) = (THUNK_ALIAS (cov_probe)
198 ? THUNK_ALIAS (cov_probe) : cov_probe);
203 DECL_NAME (thunk) = name;
204 SET_DECL_ASSEMBLER_NAME (thunk, name);
207 static GTY (()) int thunk_labelno;
209 /* Create a static alias to target. */
212 make_alias_for (tree target, tree newid)
214 tree alias = build_decl (DECL_SOURCE_LOCATION (target),
215 TREE_CODE (target), newid, TREE_TYPE (target));
216 DECL_LANG_SPECIFIC (alias) = DECL_LANG_SPECIFIC (target);
217 cxx_dup_lang_specific_decl (alias);
218 DECL_CONTEXT (alias) = NULL;
219 TREE_READONLY (alias) = TREE_READONLY (target);
220 TREE_THIS_VOLATILE (alias) = TREE_THIS_VOLATILE (target);
221 TREE_PUBLIC (alias) = 0;
222 DECL_INTERFACE_KNOWN (alias) = 1;
223 if (DECL_LANG_SPECIFIC (alias))
225 DECL_NOT_REALLY_EXTERN (alias) = 1;
226 DECL_USE_TEMPLATE (alias) = 0;
227 DECL_TEMPLATE_INFO (alias) = NULL;
229 DECL_EXTERNAL (alias) = 0;
230 DECL_ARTIFICIAL (alias) = 1;
231 DECL_TEMPLATE_INSTANTIATED (alias) = 0;
232 if (TREE_CODE (alias) == FUNCTION_DECL)
234 DECL_SAVED_FUNCTION_DATA (alias) = NULL;
235 DECL_DESTRUCTOR_P (alias) = 0;
236 DECL_CONSTRUCTOR_P (alias) = 0;
237 DECL_PENDING_INLINE_P (alias) = 0;
238 DECL_DECLARED_INLINE_P (alias) = 0;
239 DECL_INITIAL (alias) = error_mark_node;
240 DECL_ARGUMENTS (alias) = copy_list (DECL_ARGUMENTS (target));
243 TREE_STATIC (alias) = 1;
244 TREE_ADDRESSABLE (alias) = 1;
245 TREE_USED (alias) = 1;
246 SET_DECL_ASSEMBLER_NAME (alias, DECL_NAME (alias));
247 TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (alias)) = 1;
252 make_alias_for_thunk (tree function)
257 targetm.asm_out.generate_internal_label (buf, "LTHUNK", thunk_labelno);
260 alias = make_alias_for (function, get_identifier (buf));
262 if (!flag_syntax_only)
264 struct cgraph_node *funcn, *aliasn;
265 funcn = cgraph_get_node (function);
266 gcc_checking_assert (funcn);
267 aliasn = cgraph_same_body_alias (funcn, alias, function);
268 DECL_ASSEMBLER_NAME (function);
269 gcc_assert (aliasn != NULL);
275 /* Emit the definition of a C++ multiple inheritance or covariant
276 return vtable thunk. If EMIT_P is nonzero, the thunk is emitted
280 use_thunk (tree thunk_fndecl, bool emit_p)
282 tree a, t, function, alias;
284 HOST_WIDE_INT fixed_offset, virtual_value;
285 bool this_adjusting = DECL_THIS_THUNK_P (thunk_fndecl);
286 struct cgraph_node *funcn, *thunk_node;
288 /* We should have called finish_thunk to give it a name. */
289 gcc_assert (DECL_NAME (thunk_fndecl));
291 /* We should never be using an alias, always refer to the
293 gcc_assert (!THUNK_ALIAS (thunk_fndecl));
295 if (TREE_ASM_WRITTEN (thunk_fndecl))
298 function = THUNK_TARGET (thunk_fndecl);
299 if (DECL_RESULT (thunk_fndecl))
300 /* We already turned this thunk into an ordinary function.
301 There's no need to process this thunk again. */
304 if (DECL_THUNK_P (function))
305 /* The target is itself a thunk, process it now. */
306 use_thunk (function, emit_p);
308 /* Thunks are always addressable; they only appear in vtables. */
309 TREE_ADDRESSABLE (thunk_fndecl) = 1;
311 /* Figure out what function is being thunked to. It's referenced in
312 this translation unit. */
313 TREE_ADDRESSABLE (function) = 1;
314 mark_used (function);
318 if (TARGET_USE_LOCAL_THUNK_ALIAS_P (function))
319 alias = make_alias_for_thunk (function);
323 fixed_offset = THUNK_FIXED_OFFSET (thunk_fndecl);
324 virtual_offset = THUNK_VIRTUAL_OFFSET (thunk_fndecl);
329 virtual_offset = BINFO_VPTR_FIELD (virtual_offset);
330 virtual_value = tree_low_cst (virtual_offset, /*pos=*/0);
331 gcc_assert (virtual_value);
336 /* And, if we need to emit the thunk, it's used. */
337 mark_used (thunk_fndecl);
338 /* This thunk is actually defined. */
339 DECL_EXTERNAL (thunk_fndecl) = 0;
340 /* The linkage of the function may have changed. FIXME in linkage
342 TREE_PUBLIC (thunk_fndecl) = TREE_PUBLIC (function);
343 DECL_VISIBILITY (thunk_fndecl) = DECL_VISIBILITY (function);
344 DECL_VISIBILITY_SPECIFIED (thunk_fndecl)
345 = DECL_VISIBILITY_SPECIFIED (function);
346 DECL_COMDAT (thunk_fndecl) = DECL_COMDAT (function);
347 DECL_WEAK (thunk_fndecl) = DECL_WEAK (function);
349 if (flag_syntax_only)
351 TREE_ASM_WRITTEN (thunk_fndecl) = 1;
355 push_to_top_level ();
357 if (TARGET_USE_LOCAL_THUNK_ALIAS_P (function)
358 && targetm_common.have_named_sections)
360 resolve_unique_section (function, 0, flag_function_sections);
362 if (DECL_SECTION_NAME (function) != NULL && DECL_ONE_ONLY (function))
364 resolve_unique_section (thunk_fndecl, 0, flag_function_sections);
366 /* Output the thunk into the same section as function. */
367 DECL_SECTION_NAME (thunk_fndecl) = DECL_SECTION_NAME (function);
371 /* Set up cloned argument trees for the thunk. */
373 for (a = DECL_ARGUMENTS (function); a; a = DECL_CHAIN (a))
375 tree x = copy_node (a);
377 DECL_CONTEXT (x) = thunk_fndecl;
378 SET_DECL_RTL (x, NULL);
379 DECL_HAS_VALUE_EXPR_P (x) = 0;
380 TREE_ADDRESSABLE (x) = 0;
384 DECL_ARGUMENTS (thunk_fndecl) = a;
385 TREE_ASM_WRITTEN (thunk_fndecl) = 1;
386 funcn = cgraph_get_node (function);
387 gcc_checking_assert (funcn);
388 thunk_node = cgraph_add_thunk (funcn, thunk_fndecl, function,
389 this_adjusting, fixed_offset, virtual_value,
390 virtual_offset, alias);
391 if (DECL_ONE_ONLY (function))
392 cgraph_add_to_same_comdat_group (thunk_node, funcn);
395 || !targetm.asm_out.can_output_mi_thunk (thunk_fndecl, fixed_offset,
396 virtual_value, alias))
398 /* If this is a covariant thunk, or we don't have the necessary
399 code for efficient thunks, generate a thunk function that
400 just makes a call to the real function. Unfortunately, this
401 doesn't work for varargs. */
403 if (varargs_function_p (function))
404 error ("generic thunk code fails for method %q#D which uses %<...%>",
408 pop_from_top_level ();
411 /* Code for synthesizing methods which have default semantics defined. */
413 /* True iff CTYPE has a trivial SFK. */
416 type_has_trivial_fn (tree ctype, special_function_kind sfk)
420 case sfk_constructor:
421 return !TYPE_HAS_COMPLEX_DFLT (ctype);
422 case sfk_copy_constructor:
423 return !TYPE_HAS_COMPLEX_COPY_CTOR (ctype);
424 case sfk_move_constructor:
425 return !TYPE_HAS_COMPLEX_MOVE_CTOR (ctype);
426 case sfk_copy_assignment:
427 return !TYPE_HAS_COMPLEX_COPY_ASSIGN (ctype);
428 case sfk_move_assignment:
429 return !TYPE_HAS_COMPLEX_MOVE_ASSIGN (ctype);
431 return !TYPE_HAS_NONTRIVIAL_DESTRUCTOR (ctype);
437 /* Note that CTYPE has a non-trivial SFK even though we previously thought
441 type_set_nontrivial_flag (tree ctype, special_function_kind sfk)
445 case sfk_constructor:
446 TYPE_HAS_COMPLEX_DFLT (ctype) = true;
448 case sfk_copy_constructor:
449 TYPE_HAS_COMPLEX_COPY_CTOR (ctype) = true;
451 case sfk_move_constructor:
452 TYPE_HAS_COMPLEX_MOVE_CTOR (ctype) = true;
454 case sfk_copy_assignment:
455 TYPE_HAS_COMPLEX_COPY_ASSIGN (ctype) = true;
457 case sfk_move_assignment:
458 TYPE_HAS_COMPLEX_MOVE_ASSIGN (ctype) = true;
461 TYPE_HAS_NONTRIVIAL_DESTRUCTOR (ctype) = true;
468 /* True iff FN is a trivial defaulted member function ([cd]tor, op=). */
471 trivial_fn_p (tree fn)
473 if (!DECL_DEFAULTED_FN (fn))
476 /* If fn is a clone, get the primary variant. */
477 fn = DECL_ORIGIN (fn);
478 return type_has_trivial_fn (DECL_CONTEXT (fn), special_function_p (fn));
481 /* Generate code for default X(X&) or X(X&&) constructor. */
484 do_build_copy_constructor (tree fndecl)
486 tree parm = FUNCTION_FIRST_USER_PARM (fndecl);
487 bool move_p = DECL_MOVE_CONSTRUCTOR_P (fndecl);
488 bool trivial = trivial_fn_p (fndecl);
490 parm = convert_from_reference (parm);
493 && is_empty_class (current_class_type))
494 /* Don't copy the padding byte; it might not have been allocated
495 if *this is a base subobject. */;
498 tree t = build2 (INIT_EXPR, void_type_node, current_class_ref, parm);
499 finish_expr_stmt (t);
503 tree fields = TYPE_FIELDS (current_class_type);
504 tree member_init_list = NULL_TREE;
505 int cvquals = cp_type_quals (TREE_TYPE (parm));
507 tree binfo, base_binfo;
509 VEC(tree,gc) *vbases;
511 /* Initialize all the base-classes with the parameter converted
512 to their type so that we get their copy constructor and not
513 another constructor that takes current_class_type. We must
514 deal with the binfo's directly as a direct base might be
515 inaccessible due to ambiguity. */
516 for (vbases = CLASSTYPE_VBASECLASSES (current_class_type), i = 0;
517 VEC_iterate (tree, vbases, i, binfo); i++)
519 init = build_base_path (PLUS_EXPR, parm, binfo, 1,
520 tf_warning_or_error);
525 build_tree_list (NULL_TREE, init),
529 for (binfo = TYPE_BINFO (current_class_type), i = 0;
530 BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
532 if (BINFO_VIRTUAL_P (base_binfo))
535 init = build_base_path (PLUS_EXPR, parm, base_binfo, 1,
536 tf_warning_or_error);
540 = tree_cons (base_binfo,
541 build_tree_list (NULL_TREE, init),
545 for (; fields; fields = DECL_CHAIN (fields))
550 if (TREE_CODE (field) != FIELD_DECL)
553 expr_type = TREE_TYPE (field);
554 if (DECL_NAME (field))
556 if (VFIELD_NAME_P (DECL_NAME (field)))
559 else if (ANON_AGGR_TYPE_P (expr_type) && TYPE_FIELDS (expr_type))
560 /* Just use the field; anonymous types can't have
561 nontrivial copy ctors or assignment ops or this
562 function would be deleted. */;
566 /* Compute the type of "init->field". If the copy-constructor
567 parameter is, for example, "const S&", and the type of
568 the field is "T", then the type will usually be "const
569 T". (There are no cv-qualified variants of reference
571 if (TREE_CODE (expr_type) != REFERENCE_TYPE)
575 if (DECL_MUTABLE_P (field))
576 quals &= ~TYPE_QUAL_CONST;
577 quals |= cp_type_quals (expr_type);
578 expr_type = cp_build_qualified_type (expr_type, quals);
581 init = build3 (COMPONENT_REF, expr_type, parm, field, NULL_TREE);
582 if (move_p && TREE_CODE (expr_type) != REFERENCE_TYPE)
584 init = build_tree_list (NULL_TREE, init);
586 member_init_list = tree_cons (field, init, member_init_list);
588 finish_mem_initializers (member_init_list);
593 do_build_copy_assign (tree fndecl)
595 tree parm = DECL_CHAIN (DECL_ARGUMENTS (fndecl));
597 bool move_p = move_fn_p (fndecl);
598 bool trivial = trivial_fn_p (fndecl);
599 int flags = LOOKUP_NORMAL | LOOKUP_NONVIRTUAL | LOOKUP_DEFAULTED;
601 compound_stmt = begin_compound_stmt (0);
602 parm = convert_from_reference (parm);
605 && is_empty_class (current_class_type))
606 /* Don't copy the padding byte; it might not have been allocated
607 if *this is a base subobject. */;
610 tree t = build2 (MODIFY_EXPR, void_type_node, current_class_ref, parm);
611 finish_expr_stmt (t);
616 int cvquals = cp_type_quals (TREE_TYPE (parm));
618 tree binfo, base_binfo;
620 /* Assign to each of the direct base classes. */
621 for (binfo = TYPE_BINFO (current_class_type), i = 0;
622 BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
625 VEC(tree,gc) *parmvec;
627 /* We must convert PARM directly to the base class
628 explicitly since the base class may be ambiguous. */
629 converted_parm = build_base_path (PLUS_EXPR, parm, base_binfo, 1,
630 tf_warning_or_error);
632 converted_parm = move (converted_parm);
633 /* Call the base class assignment operator. */
634 parmvec = make_tree_vector_single (converted_parm);
636 (build_special_member_call (current_class_ref,
637 ansi_assopname (NOP_EXPR),
641 tf_warning_or_error));
642 release_tree_vector (parmvec);
645 /* Assign to each of the non-static data members. */
646 for (fields = TYPE_FIELDS (current_class_type);
648 fields = DECL_CHAIN (fields))
650 tree comp = current_class_ref;
656 if (TREE_CODE (field) != FIELD_DECL || DECL_ARTIFICIAL (field))
659 expr_type = TREE_TYPE (field);
661 if (CP_TYPE_CONST_P (expr_type))
663 error ("non-static const member %q#D, can%'t use default "
664 "assignment operator", field);
667 else if (TREE_CODE (expr_type) == REFERENCE_TYPE)
669 error ("non-static reference member %q#D, can%'t use "
670 "default assignment operator", field);
674 if (DECL_NAME (field))
676 if (VFIELD_NAME_P (DECL_NAME (field)))
679 else if (ANON_AGGR_TYPE_P (expr_type)
680 && TYPE_FIELDS (expr_type) != NULL_TREE)
681 /* Just use the field; anonymous types can't have
682 nontrivial copy ctors or assignment ops or this
683 function would be deleted. */;
687 comp = build3 (COMPONENT_REF, expr_type, comp, field, NULL_TREE);
689 /* Compute the type of init->field */
691 if (DECL_MUTABLE_P (field))
692 quals &= ~TYPE_QUAL_CONST;
693 expr_type = cp_build_qualified_type (expr_type, quals);
695 init = build3 (COMPONENT_REF, expr_type, init, field, NULL_TREE);
696 if (move_p && TREE_CODE (expr_type) != REFERENCE_TYPE)
699 if (DECL_NAME (field))
700 init = cp_build_modify_expr (comp, NOP_EXPR, init,
701 tf_warning_or_error);
703 init = build2 (MODIFY_EXPR, TREE_TYPE (comp), comp, init);
704 finish_expr_stmt (init);
707 finish_return_stmt (current_class_ref);
708 finish_compound_stmt (compound_stmt);
711 /* Synthesize FNDECL, a non-static member function. */
714 synthesize_method (tree fndecl)
716 bool nested = (current_function_decl != NULL_TREE);
717 tree context = decl_function_context (fndecl);
718 bool need_body = true;
720 location_t save_input_location = input_location;
721 int error_count = errorcount;
722 int warning_count = warningcount;
724 /* Reset the source location, we might have been previously
725 deferred, and thus have saved where we were first needed. */
726 DECL_SOURCE_LOCATION (fndecl)
727 = DECL_SOURCE_LOCATION (TYPE_NAME (DECL_CONTEXT (fndecl)));
729 /* If we've been asked to synthesize a clone, just synthesize the
730 cloned function instead. Doing so will automatically fill in the
731 body for the clone. */
732 if (DECL_CLONED_FUNCTION_P (fndecl))
733 fndecl = DECL_CLONED_FUNCTION (fndecl);
735 /* We may be in the middle of deferred access check. Disable
737 push_deferring_access_checks (dk_no_deferred);
740 push_to_top_level ();
742 push_function_context ();
744 input_location = DECL_SOURCE_LOCATION (fndecl);
746 start_preparsed_function (fndecl, NULL_TREE, SF_DEFAULT | SF_PRE_PARSED);
747 stmt = begin_function_body ();
749 if (DECL_OVERLOADED_OPERATOR_P (fndecl) == NOP_EXPR)
751 do_build_copy_assign (fndecl);
754 else if (DECL_CONSTRUCTOR_P (fndecl))
756 tree arg_chain = FUNCTION_FIRST_USER_PARMTYPE (fndecl);
757 if (arg_chain != void_list_node)
758 do_build_copy_constructor (fndecl);
760 finish_mem_initializers (NULL_TREE);
763 /* If we haven't yet generated the body of the function, just
764 generate an empty compound statement. */
768 compound_stmt = begin_compound_stmt (BCS_FN_BODY);
769 finish_compound_stmt (compound_stmt);
772 finish_function_body (stmt);
773 expand_or_defer_fn (finish_function (0));
775 input_location = save_input_location;
778 pop_from_top_level ();
780 pop_function_context ();
782 pop_deferring_access_checks ();
784 if (error_count != errorcount || warning_count != warningcount)
785 inform (input_location, "synthesized method %qD first required here ",
789 /* Build a reference to type TYPE with cv-quals QUALS, which is an
790 rvalue if RVALUE is true. */
793 build_stub_type (tree type, int quals, bool rvalue)
795 tree argtype = cp_build_qualified_type (type, quals);
796 return cp_build_reference_type (argtype, rvalue);
799 /* Build a dummy glvalue from dereferencing a dummy reference of type
803 build_stub_object (tree reftype)
805 tree stub = build1 (NOP_EXPR, reftype, integer_one_node);
806 return convert_from_reference (stub);
809 /* Determine which function will be called when looking up NAME in TYPE,
810 called with a single ARGTYPE argument, or no argument if ARGTYPE is
811 null. FLAGS and COMPLAIN are as for build_new_method_call.
813 Returns a FUNCTION_DECL if all is well.
814 Returns NULL_TREE if overload resolution failed.
815 Returns error_mark_node if the chosen function cannot be called. */
818 locate_fn_flags (tree type, tree name, tree argtype, int flags,
819 tsubst_flags_t complain)
821 tree ob, fn, fns, binfo, rval;
825 binfo = TYPE_BINFO (type);
829 type = BINFO_TYPE (binfo);
832 ob = build_stub_object (cp_build_reference_type (type, false));
833 args = make_tree_vector ();
836 tree arg = build_stub_object (argtype);
837 VEC_quick_push (tree, args, arg);
840 fns = lookup_fnfields (binfo, name, 0);
841 rval = build_new_method_call (ob, fns, &args, binfo, flags, &fn, complain);
843 release_tree_vector (args);
844 if (fn && rval == error_mark_node)
850 /* Locate the dtor of TYPE. */
853 get_dtor (tree type, tsubst_flags_t complain)
855 tree fn = locate_fn_flags (type, complete_dtor_identifier, NULL_TREE,
856 LOOKUP_NORMAL, complain);
857 if (fn == error_mark_node)
862 /* Locate the default ctor of TYPE. */
865 locate_ctor (tree type)
869 push_deferring_access_checks (dk_no_check);
870 fn = locate_fn_flags (type, complete_ctor_identifier, NULL_TREE,
871 LOOKUP_SPECULATIVE, tf_none);
872 pop_deferring_access_checks ();
873 if (fn == error_mark_node)
878 /* Likewise, but give any appropriate errors. */
881 get_default_ctor (tree type)
883 tree fn = locate_fn_flags (type, complete_ctor_identifier, NULL_TREE,
884 LOOKUP_NORMAL, tf_warning_or_error);
885 if (fn == error_mark_node)
890 /* Locate the copy ctor of TYPE. */
893 get_copy_ctor (tree type, tsubst_flags_t complain)
895 int quals = (TYPE_HAS_CONST_COPY_CTOR (type)
896 ? TYPE_QUAL_CONST : TYPE_UNQUALIFIED);
897 tree argtype = build_stub_type (type, quals, false);
898 tree fn = locate_fn_flags (type, complete_ctor_identifier, argtype,
899 LOOKUP_NORMAL, complain);
900 if (fn == error_mark_node)
905 /* Locate the copy assignment operator of TYPE. */
908 get_copy_assign (tree type)
910 int quals = (TYPE_HAS_CONST_COPY_ASSIGN (type)
911 ? TYPE_QUAL_CONST : TYPE_UNQUALIFIED);
912 tree argtype = build_stub_type (type, quals, false);
913 tree fn = locate_fn_flags (type, ansi_assopname (NOP_EXPR), argtype,
914 LOOKUP_NORMAL, tf_warning_or_error);
915 if (fn == error_mark_node)
920 /* Subroutine of synthesized_method_walk. Update SPEC_P, TRIVIAL_P and
921 DELETED_P or give an error message MSG with argument ARG. */
924 process_subob_fn (tree fn, bool move_p, tree *spec_p, bool *trivial_p,
925 bool *deleted_p, bool *constexpr_p,
926 const char *msg, tree arg)
928 if (!fn || fn == error_mark_node)
933 tree raises = TYPE_RAISES_EXCEPTIONS (TREE_TYPE (fn));
934 *spec_p = merge_exception_specifiers (*spec_p, raises, fn);
937 if (!trivial_fn_p (fn))
941 if (TREE_CODE (arg) == FIELD_DECL
942 && TREE_CODE (DECL_CONTEXT (arg)) == UNION_TYPE)
947 error ("union member %q+D with non-trivial %qD", arg, fn);
951 if (move_p && !move_fn_p (fn) && !trivial_fn_p (fn))
958 if (constexpr_p && !DECL_DECLARED_CONSTEXPR_P (fn))
960 *constexpr_p = false;
963 inform (0, "defaulted constructor calls non-constexpr "
965 explain_invalid_constexpr_fn (fn);
976 /* Subroutine of synthesized_method_walk to allow recursion into anonymous
980 walk_field_subobs (tree fields, tree fnname, special_function_kind sfk,
981 int quals, bool copy_arg_p, bool move_p,
982 bool assign_p, tree *spec_p, bool *trivial_p,
983 bool *deleted_p, bool *constexpr_p, const char *msg,
984 int flags, tsubst_flags_t complain)
987 for (field = fields; field; field = DECL_CHAIN (field))
989 tree mem_type, argtype, rval;
991 if (TREE_CODE (field) != FIELD_DECL
992 || DECL_ARTIFICIAL (field))
995 mem_type = strip_array_types (TREE_TYPE (field));
999 if (CP_TYPE_CONST_P (mem_type) && !CLASS_TYPE_P (mem_type))
1002 error ("non-static const member %q#D, can%'t use default "
1003 "assignment operator", field);
1005 else if (TREE_CODE (mem_type) == REFERENCE_TYPE)
1008 error ("non-static reference member %q#D, can%'t use "
1009 "default assignment operator", field);
1014 if (bad && deleted_p)
1017 else if (sfk == sfk_constructor)
1021 if (DECL_INITIAL (field))
1023 if (msg && DECL_INITIAL (field) == error_mark_node)
1024 inform (0, "initializer for %q+#D is invalid", field);
1028 /* Core 1351: If the field has an NSDMI that could throw, the
1029 default constructor is noexcept(false). FIXME this is
1030 broken by deferred parsing and 1360 saying we can't lazily
1031 declare a non-trivial default constructor. Also this
1032 needs to do deferred instantiation. Disable until the
1033 conflict between 1351 and 1360 is resolved. */
1034 if (spec_p && !expr_noexcept_p (DECL_INITIAL (field), complain))
1035 *spec_p = noexcept_false_spec;
1038 /* Don't do the normal processing. */
1043 if (CP_TYPE_CONST_P (mem_type)
1044 && default_init_uninitialized_part (mem_type))
1047 error ("uninitialized non-static const member %q#D",
1051 else if (TREE_CODE (mem_type) == REFERENCE_TYPE)
1054 error ("uninitialized non-static reference member %q#D",
1059 if (bad && deleted_p)
1062 /* For an implicitly-defined default constructor to be constexpr,
1063 every member must have a user-provided default constructor or
1064 an explicit initializer. */
1065 if (constexpr_p && !CLASS_TYPE_P (mem_type))
1067 *constexpr_p = false;
1069 inform (0, "defaulted default constructor does not "
1070 "initialize %q+#D", field);
1074 if (!CLASS_TYPE_P (mem_type))
1077 if (ANON_AGGR_TYPE_P (mem_type))
1079 walk_field_subobs (TYPE_FIELDS (mem_type), fnname, sfk, quals,
1080 copy_arg_p, move_p, assign_p, spec_p, trivial_p,
1081 deleted_p, constexpr_p, msg, flags, complain);
1087 int mem_quals = cp_type_quals (mem_type) | quals;
1088 if (DECL_MUTABLE_P (field))
1089 mem_quals &= ~TYPE_QUAL_CONST;
1090 argtype = build_stub_type (mem_type, mem_quals, move_p);
1093 argtype = NULL_TREE;
1095 rval = locate_fn_flags (mem_type, fnname, argtype, flags, complain);
1097 process_subob_fn (rval, move_p, spec_p, trivial_p, deleted_p,
1098 constexpr_p, msg, field);
1102 /* The caller wants to generate an implicit declaration of SFK for CTYPE
1103 which is const if relevant and CONST_P is set. If spec_p, trivial_p and
1104 deleted_p are non-null, set their referent appropriately. If diag is
1105 true, we're either being called from maybe_explain_implicit_delete to
1106 give errors, or if constexpr_p is non-null, from
1107 explain_invalid_constexpr_fn. */
1110 synthesized_method_walk (tree ctype, special_function_kind sfk, bool const_p,
1111 tree *spec_p, bool *trivial_p, bool *deleted_p,
1112 bool *constexpr_p, bool diag)
1114 tree binfo, base_binfo, scope, fnname, rval, argtype;
1115 bool move_p, copy_arg_p, assign_p, expected_trivial, check_vdtor;
1116 VEC(tree,gc) *vbases;
1117 int i, quals, flags;
1118 tsubst_flags_t complain;
1123 *spec_p = (cxx_dialect >= cxx0x ? noexcept_true_spec : empty_except_spec);
1127 /* "The closure type associated with a lambda-expression has a deleted
1128 default constructor and a deleted copy assignment operator."
1129 This is diagnosed in maybe_explain_implicit_delete. */
1130 if (LAMBDA_TYPE_P (ctype)
1131 && (sfk == sfk_constructor
1132 || sfk == sfk_copy_assignment))
1143 check_vdtor = false;
1146 case sfk_move_assignment:
1147 case sfk_copy_assignment:
1149 fnname = ansi_assopname (NOP_EXPR);
1152 case sfk_destructor:
1154 /* The synthesized method will call base dtors, but check complete
1155 here to avoid having to deal with VTT. */
1156 fnname = complete_dtor_identifier;
1159 case sfk_constructor:
1160 case sfk_move_constructor:
1161 case sfk_copy_constructor:
1163 fnname = complete_ctor_identifier;
1170 /* If that user-written default constructor would satisfy the
1171 requirements of a constexpr constructor (7.1.5), the
1172 implicitly-defined default constructor is constexpr. */
1174 *constexpr_p = ctor_p;
1179 case sfk_constructor:
1180 case sfk_destructor:
1184 case sfk_move_constructor:
1185 case sfk_move_assignment:
1187 case sfk_copy_constructor:
1188 case sfk_copy_assignment:
1196 expected_trivial = type_has_trivial_fn (ctype, sfk);
1198 *trivial_p = expected_trivial;
1200 /* The TYPE_HAS_COMPLEX_* flags tell us about constraints from base
1201 class versions and other properties of the type. But a subobject
1202 class can be trivially copyable and yet have overload resolution
1203 choose a template constructor for initialization, depending on
1204 rvalueness and cv-quals. So we can't exit early for copy/move
1205 methods in C++0x. The same considerations apply in C++98/03, but
1206 there the definition of triviality does not consider overload
1207 resolution, so a constructor can be trivial even if it would otherwise
1208 call a non-trivial constructor. */
1209 if (expected_trivial
1211 && (!copy_arg_p || cxx_dialect < cxx0x))
1213 if (constexpr_p && sfk == sfk_constructor)
1214 *constexpr_p = trivial_default_constructor_is_constexpr (ctype);
1218 ++cp_unevaluated_operand;
1219 ++c_inhibit_evaluation_warnings;
1221 scope = push_scope (ctype);
1225 flags = LOOKUP_NORMAL|LOOKUP_SPECULATIVE|LOOKUP_DEFAULTED;
1226 complain = tf_warning_or_error;
1230 flags = LOOKUP_PROTECT|LOOKUP_SPECULATIVE|LOOKUP_DEFAULTED;
1235 quals = TYPE_QUAL_CONST;
1237 quals = TYPE_UNQUALIFIED;
1238 argtype = NULL_TREE;
1243 msg = ("base %qT does not have a move assignment operator or trivial "
1244 "copy assignment operator");
1246 msg = ("base %qT does not have a move constructor or trivial "
1247 "copy constructor");
1249 for (binfo = TYPE_BINFO (ctype), i = 0;
1250 BINFO_BASE_ITERATE (binfo, i, base_binfo); ++i)
1252 tree basetype = BINFO_TYPE (base_binfo);
1254 argtype = build_stub_type (basetype, quals, move_p);
1255 rval = locate_fn_flags (base_binfo, fnname, argtype, flags, complain);
1257 process_subob_fn (rval, move_p, spec_p, trivial_p, deleted_p,
1258 constexpr_p, msg, basetype);
1259 if (ctor_p && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (basetype))
1261 /* In a constructor we also need to check the subobject
1262 destructors for cleanup of partially constructed objects. */
1263 rval = locate_fn_flags (base_binfo, complete_dtor_identifier,
1264 NULL_TREE, flags, complain);
1265 /* Note that we don't pass down trivial_p; the subobject
1266 destructors don't affect triviality of the constructor. */
1267 process_subob_fn (rval, false, spec_p, NULL,
1268 deleted_p, NULL, NULL,
1272 if (check_vdtor && type_has_virtual_destructor (basetype))
1274 rval = locate_fn_flags (ctype, ansi_opname (DELETE_EXPR),
1275 ptr_type_node, flags, complain);
1276 /* Unlike for base ctor/op=/dtor, for operator delete it's fine
1277 to have a null rval (no class-specific op delete). */
1278 if (rval && rval == error_mark_node && deleted_p)
1280 check_vdtor = false;
1284 vbases = CLASSTYPE_VBASECLASSES (ctype);
1285 if (vbases && assign_p && move_p)
1287 /* Should the spec be changed to allow vbases that only occur once? */
1289 error ("%qT has virtual bases, default move assignment operator "
1290 "cannot be generated", ctype);
1297 msg = ("virtual base %qT does not have a move constructor "
1298 "or trivial copy constructor");
1299 if (vbases && constexpr_p)
1300 *constexpr_p = false;
1301 FOR_EACH_VEC_ELT (tree, vbases, i, base_binfo)
1303 tree basetype = BINFO_TYPE (base_binfo);
1305 argtype = build_stub_type (basetype, quals, move_p);
1306 rval = locate_fn_flags (base_binfo, fnname, argtype, flags, complain);
1308 process_subob_fn (rval, move_p, spec_p, trivial_p, deleted_p,
1309 constexpr_p, msg, basetype);
1310 if (ctor_p && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (basetype))
1312 rval = locate_fn_flags (base_binfo, complete_dtor_identifier,
1313 NULL_TREE, flags, complain);
1314 process_subob_fn (rval, false, spec_p, NULL,
1315 deleted_p, NULL, NULL,
1321 /* Leave msg null. */;
1323 msg = ("non-static data member %qD does not have a move "
1324 "assignment operator or trivial copy assignment operator");
1326 msg = ("non-static data member %qD does not have a move "
1327 "constructor or trivial copy constructor");
1328 walk_field_subobs (TYPE_FIELDS (ctype), fnname, sfk, quals,
1329 copy_arg_p, move_p, assign_p, spec_p, trivial_p,
1330 deleted_p, constexpr_p, msg, flags, complain);
1332 walk_field_subobs (TYPE_FIELDS (ctype), complete_dtor_identifier,
1333 sfk_destructor, TYPE_UNQUALIFIED, false,
1334 false, false, spec_p, NULL,
1336 NULL, flags, complain);
1340 --cp_unevaluated_operand;
1341 --c_inhibit_evaluation_warnings;
1344 /* DECL is a deleted function. If it's implicitly deleted, explain why and
1345 return true; else return false. */
1348 maybe_explain_implicit_delete (tree decl)
1350 /* If decl is a clone, get the primary variant. */
1351 decl = DECL_ORIGIN (decl);
1352 gcc_assert (DECL_DELETED_FN (decl));
1353 if (DECL_DEFAULTED_FN (decl))
1355 /* Not marked GTY; it doesn't need to be GC'd or written to PCH. */
1356 static struct pointer_set_t *explained;
1358 special_function_kind sfk;
1364 explained = pointer_set_create ();
1365 if (pointer_set_insert (explained, decl))
1368 sfk = special_function_p (decl);
1369 ctype = DECL_CONTEXT (decl);
1370 loc = input_location;
1371 input_location = DECL_SOURCE_LOCATION (decl);
1374 if (LAMBDA_TYPE_P (ctype))
1377 if (sfk == sfk_constructor)
1378 inform (DECL_SOURCE_LOCATION (decl),
1379 "a lambda closure type has a deleted default constructor");
1380 else if (sfk == sfk_copy_assignment)
1381 inform (DECL_SOURCE_LOCATION (decl),
1382 "a lambda closure type has a deleted copy assignment operator");
1386 else if (DECL_ARTIFICIAL (decl)
1387 && (sfk == sfk_copy_assignment
1388 || sfk == sfk_copy_constructor)
1389 && (type_has_user_declared_move_constructor (ctype)
1390 || type_has_user_declared_move_assign (ctype)))
1392 inform (0, "%q+#D is implicitly declared as deleted because %qT "
1393 "declares a move constructor or move assignment operator",
1399 tree parm_type = TREE_VALUE (FUNCTION_FIRST_USER_PARMTYPE (decl));
1400 bool const_p = CP_TYPE_CONST_P (non_reference (parm_type));
1401 tree scope = push_scope (ctype);
1402 inform (0, "%q+#D is implicitly deleted because the default "
1403 "definition would be ill-formed:", decl);
1405 synthesized_method_walk (ctype, sfk, const_p,
1406 NULL, NULL, NULL, NULL, true);
1409 input_location = loc;
1415 /* DECL is a defaulted function which was declared constexpr. Explain why
1416 it can't be constexpr. */
1419 explain_implicit_non_constexpr (tree decl)
1421 tree parm_type = TREE_VALUE (FUNCTION_FIRST_USER_PARMTYPE (decl));
1422 bool const_p = CP_TYPE_CONST_P (non_reference (parm_type));
1424 synthesized_method_walk (DECL_CLASS_CONTEXT (decl),
1425 special_function_p (decl), const_p,
1426 NULL, NULL, NULL, &dummy, true);
1429 /* Implicitly declare the special function indicated by KIND, as a
1430 member of TYPE. For copy constructors and assignment operators,
1431 CONST_P indicates whether these functions should take a const
1432 reference argument or a non-const reference. Returns the
1433 FUNCTION_DECL for the implicitly declared function. */
1436 implicitly_declare_fn (special_function_kind kind, tree type, bool const_p)
1439 tree parameter_types = void_list_node;
1442 tree raises = empty_except_spec;
1443 tree rhs_parm_type = NULL_TREE;
1446 HOST_WIDE_INT saved_processing_template_decl;
1451 /* Because we create declarations for implicitly declared functions
1452 lazily, we may be creating the declaration for a member of TYPE
1453 while in some completely different context. However, TYPE will
1454 never be a dependent class (because we never want to do lookups
1455 for implicitly defined functions in a dependent class).
1456 Furthermore, we must set PROCESSING_TEMPLATE_DECL to zero here
1457 because we only create clones for constructors and destructors
1458 when not in a template. */
1459 gcc_assert (!dependent_type_p (type));
1460 saved_processing_template_decl = processing_template_decl;
1461 processing_template_decl = 0;
1463 type = TYPE_MAIN_VARIANT (type);
1465 if (targetm.cxx.cdtor_returns_this () && !TYPE_FOR_JAVA (type))
1467 if (kind == sfk_destructor)
1468 /* See comment in check_special_function_return_type. */
1469 return_type = build_pointer_type (void_type_node);
1471 return_type = build_pointer_type (type);
1474 return_type = void_type_node;
1478 case sfk_destructor:
1480 name = constructor_name (type);
1483 case sfk_constructor:
1484 /* Default constructor. */
1485 name = constructor_name (type);
1488 case sfk_copy_constructor:
1489 case sfk_copy_assignment:
1490 case sfk_move_constructor:
1491 case sfk_move_assignment:
1494 if (kind == sfk_copy_assignment
1495 || kind == sfk_move_assignment)
1497 return_type = build_reference_type (type);
1498 name = ansi_assopname (NOP_EXPR);
1501 name = constructor_name (type);
1504 rhs_parm_type = cp_build_qualified_type (type, TYPE_QUAL_CONST);
1506 rhs_parm_type = type;
1507 move_p = (kind == sfk_move_assignment
1508 || kind == sfk_move_constructor);
1509 rhs_parm_type = cp_build_reference_type (rhs_parm_type, move_p);
1511 parameter_types = tree_cons (NULL_TREE, rhs_parm_type, parameter_types);
1518 synthesized_method_walk (type, kind, const_p, &raises, &trivial_p,
1519 &deleted_p, &constexpr_p, false);
1520 /* Don't bother marking a deleted constructor as constexpr. */
1522 constexpr_p = false;
1523 /* A trivial copy/move constructor is also a constexpr constructor. */
1524 else if (trivial_p && cxx_dialect >= cxx0x
1525 && (kind == sfk_copy_constructor
1526 || kind == sfk_move_constructor))
1527 gcc_assert (constexpr_p);
1529 if (!trivial_p && type_has_trivial_fn (type, kind))
1530 type_set_nontrivial_flag (type, kind);
1532 /* Create the function. */
1533 fn_type = build_method_type_directly (type, return_type, parameter_types);
1535 fn_type = build_exception_variant (fn_type, raises);
1536 fn = build_lang_decl (FUNCTION_DECL, name, fn_type);
1537 DECL_SOURCE_LOCATION (fn) = DECL_SOURCE_LOCATION (TYPE_NAME (type));
1538 if (kind == sfk_constructor || kind == sfk_copy_constructor
1539 || kind == sfk_move_constructor)
1540 DECL_CONSTRUCTOR_P (fn) = 1;
1541 else if (kind == sfk_destructor)
1542 DECL_DESTRUCTOR_P (fn) = 1;
1545 DECL_ASSIGNMENT_OPERATOR_P (fn) = 1;
1546 SET_OVERLOADED_OPERATOR_CODE (fn, NOP_EXPR);
1549 /* If pointers to member functions use the least significant bit to
1550 indicate whether a function is virtual, ensure a pointer
1551 to this function will have that bit clear. */
1552 if (TARGET_PTRMEMFUNC_VBIT_LOCATION == ptrmemfunc_vbit_in_pfn
1553 && DECL_ALIGN (fn) < 2 * BITS_PER_UNIT)
1554 DECL_ALIGN (fn) = 2 * BITS_PER_UNIT;
1556 /* Create the explicit arguments. */
1559 /* Note that this parameter is *not* marked DECL_ARTIFICIAL; we
1560 want its type to be included in the mangled function
1562 tree decl = cp_build_parm_decl (NULL_TREE, rhs_parm_type);
1563 TREE_READONLY (decl) = 1;
1564 retrofit_lang_decl (decl);
1565 DECL_PARM_INDEX (decl) = DECL_PARM_LEVEL (decl) = 1;
1566 DECL_ARGUMENTS (fn) = decl;
1568 /* Add the "this" parameter. */
1569 this_parm = build_this_parm (fn_type, TYPE_UNQUALIFIED);
1570 DECL_CHAIN (this_parm) = DECL_ARGUMENTS (fn);
1571 DECL_ARGUMENTS (fn) = this_parm;
1573 grokclassfn (type, fn, kind == sfk_destructor ? DTOR_FLAG : NO_SPECIAL);
1574 set_linkage_according_to_type (type, fn);
1575 rest_of_decl_compilation (fn, toplevel_bindings_p (), at_eof);
1576 DECL_IN_AGGR_P (fn) = 1;
1577 DECL_ARTIFICIAL (fn) = 1;
1578 DECL_DEFAULTED_FN (fn) = 1;
1579 if (cxx_dialect >= cxx0x)
1581 DECL_DELETED_FN (fn) = deleted_p;
1582 DECL_DECLARED_CONSTEXPR_P (fn) = constexpr_p;
1584 DECL_NOT_REALLY_EXTERN (fn) = 1;
1585 DECL_DECLARED_INLINE_P (fn) = 1;
1586 gcc_assert (!TREE_USED (fn));
1588 /* Restore PROCESSING_TEMPLATE_DECL. */
1589 processing_template_decl = saved_processing_template_decl;
1594 /* Gives any errors about defaulted functions which need to be deferred
1595 until the containing class is complete. */
1598 defaulted_late_check (tree fn)
1600 /* Complain about invalid signature for defaulted fn. */
1601 tree ctx = DECL_CONTEXT (fn);
1602 special_function_kind kind = special_function_p (fn);
1603 bool fn_const_p = (copy_fn_p (fn) == 2);
1604 tree implicit_fn = implicitly_declare_fn (kind, ctx, fn_const_p);
1606 if (!same_type_p (TREE_TYPE (TREE_TYPE (fn)),
1607 TREE_TYPE (TREE_TYPE (implicit_fn)))
1608 || !compparms (TYPE_ARG_TYPES (TREE_TYPE (fn)),
1609 TYPE_ARG_TYPES (TREE_TYPE (implicit_fn))))
1611 error ("defaulted declaration %q+D", fn);
1612 error_at (DECL_SOURCE_LOCATION (fn),
1613 "does not match expected signature %qD", implicit_fn);
1616 /* 8.4.2/2: If it is explicitly defaulted on its first declaration, it is
1617 implicitly considered to have the same exception-specification as if
1618 it had been implicitly declared. */
1619 if (DECL_DEFAULTED_IN_CLASS_P (fn))
1621 tree eh_spec = TYPE_RAISES_EXCEPTIONS (TREE_TYPE (implicit_fn));
1622 if (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (fn)))
1624 maybe_instantiate_noexcept (fn);
1625 if (!comp_except_specs (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (fn)),
1626 eh_spec, ce_normal))
1627 error ("function %q+D defaulted on its first declaration "
1628 "with an exception-specification that differs from "
1629 "the implicit declaration %q#D", fn, implicit_fn);
1631 TREE_TYPE (fn) = build_exception_variant (TREE_TYPE (fn), eh_spec);
1632 if (DECL_DECLARED_CONSTEXPR_P (implicit_fn))
1634 /* Hmm...should we do this for out-of-class too? Should it be OK to
1635 add constexpr later like inline, rather than requiring
1636 declarations to match? */
1637 DECL_DECLARED_CONSTEXPR_P (fn) = true;
1638 if (kind == sfk_constructor)
1639 TYPE_HAS_CONSTEXPR_CTOR (ctx) = true;
1643 if (!DECL_DECLARED_CONSTEXPR_P (implicit_fn)
1644 && DECL_DECLARED_CONSTEXPR_P (fn))
1646 if (!CLASSTYPE_TEMPLATE_INSTANTIATION (ctx))
1648 error ("explicitly defaulted function %q+D cannot be declared "
1649 "as constexpr because the implicit declaration is not "
1651 explain_implicit_non_constexpr (fn);
1653 DECL_DECLARED_CONSTEXPR_P (fn) = false;
1656 if (DECL_DELETED_FN (implicit_fn))
1657 DECL_DELETED_FN (fn) = 1;
1660 /* Returns true iff FN can be explicitly defaulted, and gives any
1661 errors if defaulting FN is ill-formed. */
1664 defaultable_fn_check (tree fn)
1666 special_function_kind kind = sfk_none;
1668 if (template_parm_scope_p ())
1670 error ("a template cannot be defaulted");
1674 if (DECL_CONSTRUCTOR_P (fn))
1676 if (FUNCTION_FIRST_USER_PARMTYPE (fn) == void_list_node)
1677 kind = sfk_constructor;
1678 else if (copy_fn_p (fn) > 0
1679 && (TREE_CHAIN (FUNCTION_FIRST_USER_PARMTYPE (fn))
1681 kind = sfk_copy_constructor;
1682 else if (move_fn_p (fn))
1683 kind = sfk_move_constructor;
1685 else if (DECL_DESTRUCTOR_P (fn))
1686 kind = sfk_destructor;
1687 else if (DECL_ASSIGNMENT_OPERATOR_P (fn)
1688 && DECL_OVERLOADED_OPERATOR_P (fn) == NOP_EXPR)
1691 kind = sfk_copy_assignment;
1692 else if (move_fn_p (fn))
1693 kind = sfk_move_assignment;
1696 if (kind == sfk_none)
1698 error ("%qD cannot be defaulted", fn);
1703 tree t = FUNCTION_FIRST_USER_PARMTYPE (fn);
1704 for (; t && t != void_list_node; t = TREE_CHAIN (t))
1705 if (TREE_PURPOSE (t))
1707 error ("defaulted function %q+D with default argument", fn);
1710 if (TYPE_BEING_DEFINED (DECL_CONTEXT (fn)))
1711 /* Defer checking. */;
1712 else if (!processing_template_decl)
1713 defaulted_late_check (fn);
1719 /* Add an implicit declaration to TYPE for the kind of function
1720 indicated by SFK. Return the FUNCTION_DECL for the new implicit
1724 lazily_declare_fn (special_function_kind sfk, tree type)
1727 /* Whether or not the argument has a const reference type. */
1728 bool const_p = false;
1732 case sfk_constructor:
1733 CLASSTYPE_LAZY_DEFAULT_CTOR (type) = 0;
1735 case sfk_copy_constructor:
1736 const_p = TYPE_HAS_CONST_COPY_CTOR (type);
1737 CLASSTYPE_LAZY_COPY_CTOR (type) = 0;
1739 case sfk_move_constructor:
1740 CLASSTYPE_LAZY_MOVE_CTOR (type) = 0;
1742 case sfk_copy_assignment:
1743 const_p = TYPE_HAS_CONST_COPY_ASSIGN (type);
1744 CLASSTYPE_LAZY_COPY_ASSIGN (type) = 0;
1746 case sfk_move_assignment:
1747 CLASSTYPE_LAZY_MOVE_ASSIGN (type) = 0;
1749 case sfk_destructor:
1750 CLASSTYPE_LAZY_DESTRUCTOR (type) = 0;
1756 /* Declare the function. */
1757 fn = implicitly_declare_fn (sfk, type, const_p);
1759 /* [class.copy]/8 If the class definition declares a move constructor or
1760 move assignment operator, the implicitly declared copy constructor is
1761 defined as deleted.... */
1762 if ((sfk == sfk_copy_assignment
1763 || sfk == sfk_copy_constructor)
1764 && (type_has_user_declared_move_constructor (type)
1765 || type_has_user_declared_move_assign (type)))
1766 DECL_DELETED_FN (fn) = true;
1768 /* For move variants, rather than declare them as deleted we just
1769 don't declare them at all. */
1770 if (DECL_DELETED_FN (fn)
1771 && (sfk == sfk_move_constructor
1772 || sfk == sfk_move_assignment))
1775 /* A destructor may be virtual. */
1776 if (sfk == sfk_destructor
1777 || sfk == sfk_move_assignment
1778 || sfk == sfk_copy_assignment)
1779 check_for_override (fn, type);
1780 /* Add it to CLASSTYPE_METHOD_VEC. */
1781 add_method (type, fn, NULL_TREE);
1782 /* Add it to TYPE_METHODS. */
1783 if (sfk == sfk_destructor
1784 && DECL_VIRTUAL_P (fn)
1785 && abi_version_at_least (2))
1786 /* The ABI requires that a virtual destructor go at the end of the
1788 TYPE_METHODS (type) = chainon (TYPE_METHODS (type), fn);
1791 /* G++ 3.2 put the implicit destructor at the *beginning* of the
1792 TYPE_METHODS list, which cause the destructor to be emitted
1793 in an incorrect location in the vtable. */
1794 if (warn_abi && sfk == sfk_destructor && DECL_VIRTUAL_P (fn))
1795 warning (OPT_Wabi, "vtable layout for class %qT may not be ABI-compliant"
1796 "and may change in a future version of GCC due to "
1797 "implicit virtual destructor",
1799 DECL_CHAIN (fn) = TYPE_METHODS (type);
1800 TYPE_METHODS (type) = fn;
1802 maybe_add_class_template_decl_list (type, fn, /*friend_p=*/0);
1803 if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (fn)
1804 || DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (fn))
1805 /* Create appropriate clones. */
1806 clone_function_decl (fn, /*update_method_vec=*/true);
1811 /* Given a FUNCTION_DECL FN and a chain LIST, skip as many elements of LIST
1812 as there are artificial parms in FN. */
1815 skip_artificial_parms_for (const_tree fn, tree list)
1817 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fn))
1818 list = TREE_CHAIN (list);
1822 if (DECL_HAS_IN_CHARGE_PARM_P (fn))
1823 list = TREE_CHAIN (list);
1824 if (DECL_HAS_VTT_PARM_P (fn))
1825 list = TREE_CHAIN (list);
1829 /* Given a FUNCTION_DECL FN and a chain LIST, return the number of
1830 artificial parms in FN. */
1833 num_artificial_parms_for (const_tree fn)
1837 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fn))
1842 if (DECL_HAS_IN_CHARGE_PARM_P (fn))
1844 if (DECL_HAS_VTT_PARM_P (fn))
1850 #include "gt-cp-method.h"